變量

• 變量名 = 變量值? # = 綁定；變量名（標識符）映射變量值，當定義一個變量時，解釋器開辟一塊兒內存空間，存入變量的值。也可以說，變量名指向值在內存中的地址。

內存回收

• 沒有綁定關系的變量值被回收，即值的引用計數器為0時，python解釋器會自動回收該值。
• 當變量名綁定新的值時，原來的值無綁定，被回收。
• 一個值可以綁定多個變量名
• del 變量名? # 解除綁定
• id(變量名)? # 查看變量綁定值所在的內存地址的id號
• 比較短的值，像小整數，占用的內存空間小，python解釋器會將它們緩存在內存中，一旦再有變量被賦值為小整數，就可以直接引用。比較長的值，不會緩存在內存中，每次定義一個變量，都會開辟新的內存空間。

輸入輸出

• input()? # 括號內可以寫提示信息。在python3中，默認所有的輸入被轉為字符串。在python2中，用戶輸入什么類型就是什么類型，輸入字符串時要加‘? ‘，告知input輸入類型。python3中的input()《==相當于==》python2中的raw_input()。
• 在windows命令行窗口中，可以通過import getpass 來輸入用戶密碼時不顯示密碼 password = getpass.getpass('密碼')
• type(變量)? # 顯示變量類型
• print('......', abc) 與print('.....%s.....', abc)? # 使用%d(整數)、%f(浮點數)、%s(字符串)這些占位符，可以更靈活的打印變量

運算符

• 算術運算符：+、-、*、/、//(取整除)、**(冪的運算，e.g. 7**2表示7的2次冪)、%
• 賦值運算：= 、+=、-、-=、*=、/=、%=、**=、//=
  
• 比較運算符：==、！=、>、>=、<、<=
• 邏輯運算符：and、or、not
  
• 關系運算符：

文件頭與注釋

• # -*- coding: utf-8 -*-?? 指定字符編碼方式
• # 單行注釋；''' '''多行注釋

python中的數據類型：

即變量的值的類型：

• 數字類型：int、float、bool、復數（注意：python2中還有long lint，python3中int長度無限制）
  • 科學計數法：e.g. 1.3e5 ------> 1.3 * 10^5
  • bin(int): 轉二進制；標識：0b
    oct(int): 轉八進制；標識：0o
    hex(jbin): 轉16進制；標識0x
  • 特性：一經定義，值不可更改（即，改變值必須改變內存地址）；直接訪問
• 字符串類型：
  • ‘ ’‘ ’‘’ 三種引號引起來的都是字符串
  • 常用操作：
    • x.strip() # 默認去空格，也可以去括號內指定的字符
    • x.split() # 分割字符串為列表，默認以空格分割，具體可以根據字符串的特征選取分隔符
    • ' '.join(字符串列表) # 引號內可以指定連接符。
    • x.isdigit() # 判斷字符串是否是整數?？梢杂脕砼袛嘤脩糨斎胧欠穹弦?br /> age = input('請輸入年紀：') if age.isdigit():age_new = int(age) #將用戶輸入的字符串轉化為int ；如果不加判斷的轉化，一旦用戶輸入了非數字的字符串，那么int()轉化將導致錯誤。print(age_new, type(age_new)) 請輸入年紀：20 20 <class 'int'>
      
    • x.format() # 格式化字符串：
      string = 'a:{}, b:{}, c:{}' x = string.format(100, 90, 80) print(x)a:100, b:90, c:80
      person = 'name:{x}, gender:{y}, age:{z}' x = person.format(x='tom',y='male',z='20') print(x)name:tom, gender:male, age:20
    • x.place() # 替換字符串。替換并不會改變原值，除非重新賦值
      string = 'ich liebe das world' print(string.replace('das','die')) ich liebe die world
    • x.startswith() #以括號內字符開頭，判斷真假
    • x.endswith()? #以括號內字符結尾，判斷真假
    • x.find() # 查找，結果以index號顯示
    • x.index() # 顯示字符串中某個字符的index號，配合切片使用
    • x.[ : : ] # 切片? 起始：結束：步長
      s = 'das gerne ich, aber kann ich nicht' print(s[s.index('k')]) #找到字母k的索引號，然后用切片的方式打印出來 k
    • x.count() # 計算括號內字符出現的次數
    • x.capitalize() #首字母大寫
    • x.upper() # 所有字母大寫
    • x.lower() # 所有字母小寫
    • x.title() #標題，判斷首字母是否大寫，如果不是自動大寫
    • x.ljust()左對齊, 括號內指定縮進和填充符
      s = 'als' print(s.ljust(10,'*')) als*******
      
    • x.rjust() # 右對齊
    • x.center() # 居中
      s = 'als' print(s.center(10,'*')) ***als****

• 列表：逗號分隔多個元素，元素可以是任意類型
  定義一個列表：l = [1, 'a', [3, 4]]?? # l = list([1, 'a', [3, 4]])

  • 取值 l[index], 同字符串，都是有序的
  • 遍歷：
    • 方法一：for i in l:
    • 方法二：
      count = 0 while count < len(l):print(l[count])count += 1
  • l.append(元素) # 默認追加到最后面
  • l.insert(index) # 插入括號內指定位置，默認插在最前面
  • l.pop(index) # 括號內填入index, 指定要刪除的元素；不加index,默認刪除最后一個元素，相當于pop(-1)。另外，該命令有返回值：返回剛剛刪除的值。
  • 隊列與堆棧的模擬：
    • 隊列：先進先出：l.append()===>l.pop(0)? 或 l.insert()====>l.pop()
      
    • 堆棧：先進后出(后進先出）：l.append()=====>l.pop()
  • len(l) #統計隊列長度
  • l.index(元素）#查索引
  • l.count(元素) #查元素的個數
  • l.extend([列表]) # 合并列表。不同于append, 后者是把列表作為一個元素追加入原列表
  • l.remove(元素） 刪除元素，如果有多個重復元素，只刪除第一個。（pop是按索引來刪）
  • l.sort() # 默認從小到大。排序不像pop有返回值
  • l.sort(reverse = True) # 先按大小排序，再反轉
  • l.reverse()# 反轉（沒有比較大小的屬性）
  • 包含（也適用于字符串）：元素 in 列表中，返回True/False
    s = 'lena is smart' print('lena' in s) True
    

• 元組：有序，不可變。定義一個元組 t =(元素1，元素2，#元素可以是任意類型，所以可以嵌套列表，修改里面列表的元素)

  • t.count(元素) 計數
  • t.index(元素）
  • t[index] 索引
  • t[::]切片、長度、包含
• 字典：d={key1:value1, key2:value2} key value用冒號分隔
  • key必須是不可變類型（數字、字母、元組、或者說可hash類型，hash() 括號內傳入不可變對象，hash校驗出一個值）。
  • vaue可以是任意類型數據。
  • 字典的取值：d[key] 字典是無序的（no index)
  • 字典的修改：d[key] = value_new
  • 字典的循環：d.keys() 提取key d.values() 提取value
  • 迭代器遍歷字典：這種方法不通過索引，對于列表，元組，字符串，將取出元素，對于字典，取出key
    for k in d:print(k, d(k))
  • d.get(key)? vs d[key]：后者在key不存在的情況下，會報錯。前者不會，這樣程序不會崩潰。
• 集合：set
  定義集合：s = {...} ==> s = set({...}) 調用set工廠函數
  • 集合的特點：
    • 集合內的元素是唯一的：自動去重
    • 集合內的元素必須是可hash的，也就是不可變類型
    • 集合是無序的，無索引。但是可以遍歷：for i in set
      
  • 集合的作用：作關系運算
    • s1 & s2 取交集 ===> s1.intersection(s2)
      
    • s1 | s2 取并集 ===> s1.union(s2)
      
    • s1 - s2 取差集：在s1， 不在s2 ===> s1.difference(s2)
      
    • s2 - s1 取差集：在s2，不在s1 ====> s2.difference(s1)
      
    • s1 ^ s2 取對稱差集（不在交集中的）===> s1.sysmmetic_difference(s2)
  • 常用的操作：
    • s.clear() 清空
    • s1.update(s2) s2的值并入s1
    • s1.difference_update(s2) 求與s2的差集，并把差集部分覆蓋寫入s1
      s1 ={ 1, 2, 3, 4, 6} s2 = {1, 5, 6, 2} s1.difference_update(s2) print(s1) 結果是：{3, 4}
    • s1.update(s2) s2的值加入s1
    • s.add(元素） 增加元素
    • s.remove() 刪除元素，如果元素不存在報錯
    • s.discard(元素) 刪除元素，如果元素不存在不報錯，better than remove
    • s.pop() 隨機刪（因為集合是無序的）
    • s1.issubset(s2) s1是s2的子集，返回bool值
    • s1.issuperset(s2) s1是s2的父級，返回bool值
    • s1.isdisjoint(s2) 沒有交集返回True
      

• bool值：True & False
  • 產生bool值：比較運算、成員運算（if m in n: ）
  • 所有數據類型都自帶bool值
  • 數據類型返回False的情況：0、None、空（例如：空列表）；其余情況都是True
    
• 變量的三種比較：
  • • x is y # 比較id
    • x == y # 值比較
    • type(x) is type(y) 類型比較
      
• 每種數據類型都是一個類，每個類都有方法，對象調用方法用 . 點。e.g. a = 1 (a = int(1),創建一個整型數，就調用int方法，把1傳入===》工廠函數（批量生產)；同樣的 s = 'abc' 即s = str(abc), str也是工廠函數
• 幾種賦值：
  • x =1 賦值操作，沒有任何返回值
  • 鏈式賦值：
    a=b=c=d=e=f=10 print(a,b,c,d,e,f) 10 10 10 10 10 10
  • 多元賦值：交換變量的值（C語言是通過一個中間值）
    x = 12 y = 56 x,y = y,x print(x,y) 56 12
• 解壓序列類型：
  • s = 'hello' a,b,c,d,e = s 按索引一一對應 a,_,_,_,e = s 用下劃線占位，只取首尾（要丟棄的值賦給_下劃線） a,*_,b = s 中間都不要 m,n,*_ =s 只要前兩個 *_,m,n = s 只要后兩個 a,*_ = [1, 2, 3, 4] 取列表第一個值
• 其它分類方式：
  
  • 可變與不可變：一個身份id 不可變（變了內存空間就變了）；一個類型 不可變（變了內存空間就變了）；而一個值可變，比如 列表的值可變
    不可變對象：數字、字符、元組；可變對象：列表、字典。
    列表因為可變，內存中會預留空間，所以列表耗內存。
    字典在內存中存的has表，占用空間比列表還大，但優化了查詢速度。
  • 取值方式來分：直接取值：數字（通過綁定的變量名，一次取出整體）
  • 序列類型：字符串、元組、列表
  • 映射類型：字典
    

流程控制與循環結構

• if 條件語句：
  語句1: if 條件1: # 判斷條件1為真，則執行語句2語句2 elif:條件2: # 判斷條件2為真，則執行語句3語句3 else:語句4 # 如果前面條件都不滿足，則執行語句4 語句5 # 語句5與if無關
• 循環語句：
  • while循環
    while 條件: # 條件判斷為真，則執行循環體循環體語句1 # 循環不結束，該語句不執行break 退出當層循環 continue 終止當層循環中的本次循環，進入下一次循環將while的條件設為一變量值滿足某一條件為真，讓這一變量值在循環體內進行自增計數，直到不滿足條件為假，循環結束； tag標志位法：tag = True 賦值，while tag: 開始循環，直到某一步完成，進行tag = False，循環結束。
  • for循環：
    for i in range(x, y, z):語句x起始 y尾(不包括) z步長 ?
  • while 和 else 連用：while循環正常結束后，即沒有被continue或break打斷，才能輸出else內容。
    for 和 else 連用，也是同樣的效果。
    i = 0 while i < 5:print(i,end=' ')i += 1 else:print('循環正常結束')運行結果： 0 1 2 3 4 循環正常結束—————————————
    i = 0while i < 5: print(i,end=' ') i += 1 if i == 3: breakelse: print('循環正常結束')
    運行結果： 0 1 2
    

總結

以上是生活随笔為你收集整理的python数据类型和循环控制的全部內容，希望文章能夠幫你解決所遇到的問題。

如果覺得生活随笔網站內容還不錯，歡迎將生活随笔推薦給好友。