變量

• 變量名 = 變量值? # = 綁定；變量名（標(biāo)識符）映射變量值，當(dāng)定義一個(gè)變量時(shí)，解釋器開辟一塊兒內(nèi)存空間，存入變量的值。也可以說，變量名指向值在內(nèi)存中的地址。

內(nèi)存回收

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

輸入輸出

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

運(yùn)算符

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

文件頭與注釋

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

python中的數(shù)據(jù)類型：

即變量的值的類型：

• 數(shù)字類型：int、float、bool、復(fù)數(shù)（注意：python2中還有l(wèi)ong lint，python3中int長度無限制）
  • 科學(xué)計(jì)數(shù)法：e.g. 1.3e5 ------> 1.3 * 10^5
  • bin(int): 轉(zhuǎn)二進(jìn)制；標(biāo)識：0b
    oct(int): 轉(zhuǎn)八進(jìn)制；標(biāo)識：0o
    hex(jbin): 轉(zhuǎn)16進(jìn)制；標(biāo)識0x
  • 特性：一經(jīng)定義，值不可更改（即，改變值必須改變內(nèi)存地址）；直接訪問
• 字符串類型：
  • ‘ ’‘ ’‘’ 三種引號引起來的都是字符串
  • 常用操作：
    • x.strip() # 默認(rèn)去空格，也可以去括號內(nèi)指定的字符
    • x.split() # 分割字符串為列表，默認(rèn)以空格分割，具體可以根據(jù)字符串的特征選取分隔符
    • ' '.join(字符串列表) # 引號內(nèi)可以指定連接符。
    • x.isdigit() # 判斷字符串是否是整數(shù)。可以用來判斷用戶輸入是否符合要求
      age = input('請輸入年紀(jì)：') if age.isdigit():age_new = int(age) #將用戶輸入的字符串轉(zhuǎn)化為int ；如果不加判斷的轉(zhuǎn)化，一旦用戶輸入了非數(shù)字的字符串，那么int()轉(zhuǎn)化將導(dǎo)致錯(cuò)誤。print(age_new, type(age_new)) 請輸入年紀(jì)：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() #以括號內(nèi)字符開頭，判斷真假
    • x.endswith()? #以括號內(nèi)字符結(jié)尾，判斷真假
    • x.find() # 查找，結(jié)果以index號顯示
    • x.index() # 顯示字符串中某個(gè)字符的index號，配合切片使用
    • x.[ : : ] # 切片? 起始：結(jié)束：步長
      s = 'das gerne ich, aber kann ich nicht' print(s[s.index('k')]) #找到字母k的索引號，然后用切片的方式打印出來 k
    • x.count() # 計(jì)算括號內(nèi)字符出現(xiàn)的次數(shù)
    • x.capitalize() #首字母大寫
    • x.upper() # 所有字母大寫
    • x.lower() # 所有字母小寫
    • x.title() #標(biāo)題，判斷首字母是否大寫，如果不是自動(dòng)大寫
    • x.ljust()左對齊, 括號內(nèi)指定縮進(jìn)和填充符
      s = 'als' print(s.ljust(10,'*')) als*******
      
    • x.rjust() # 右對齊
    • x.center() # 居中
      s = 'als' print(s.center(10,'*')) ***als****

• 列表：逗號分隔多個(gè)元素，元素可以是任意類型
  定義一個(gè)列表：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(元素) # 默認(rèn)追加到最后面
  • l.insert(index) # 插入括號內(nèi)指定位置，默認(rèn)插在最前面
  • l.pop(index) # 括號內(nèi)填入index, 指定要?jiǎng)h除的元素；不加index,默認(rèn)刪除最后一個(gè)元素，相當(dāng)于pop(-1)。另外，該命令有返回值：返回剛剛刪除的值。
  • 隊(duì)列與堆棧的模擬：
    • 隊(duì)列：先進(jìn)先出：l.append()===>l.pop(0)? 或 l.insert()====>l.pop()
      
    • 堆棧：先進(jìn)后出(后進(jìn)先出）：l.append()=====>l.pop()
  • len(l) #統(tǒng)計(jì)隊(duì)列長度
  • l.index(元素）#查索引
  • l.count(元素) #查元素的個(gè)數(shù)
  • l.extend([列表]) # 合并列表。不同于append, 后者是把列表作為一個(gè)元素追加入原列表
  • l.remove(元素） 刪除元素，如果有多個(gè)重復(fù)元素，只刪除第一個(gè)。（pop是按索引來刪）
  • l.sort() # 默認(rèn)從小到大。排序不像pop有返回值
  • l.sort(reverse = True) # 先按大小排序，再反轉(zhuǎn)
  • l.reverse()# 反轉(zhuǎn)（沒有比較大小的屬性）
  • 包含（也適用于字符串）：元素 in 列表中，返回True/False
    s = 'lena is smart' print('lena' in s) True
    

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

  • t.count(元素) 計(jì)數(shù)
  • t.index(元素）
  • t[index] 索引
  • t[::]切片、長度、包含
• 字典：d={key1:value1, key2:value2} key value用冒號分隔
  • key必須是不可變類型（數(shù)字、字母、元組、或者說可hash類型，hash() 括號內(nèi)傳入不可變對象，hash校驗(yàn)出一個(gè)值）。
  • vaue可以是任意類型數(shù)據(jù)。
  • 字典的取值：d[key] 字典是無序的（no index)
  • 字典的修改：d[key] = value_new
  • 字典的循環(huán)：d.keys() 提取key d.values() 提取value
  • 迭代器遍歷字典：這種方法不通過索引，對于列表，元組，字符串，將取出元素，對于字典，取出key
    for k in d:print(k, d(k))
  • d.get(key)? vs d[key]：后者在key不存在的情況下，會報(bào)錯(cuò)。前者不會，這樣程序不會崩潰。
• 集合：set
  定義集合：s = {...} ==> s = set({...}) 調(diào)用set工廠函數(shù)
  • 集合的特點(diǎn)：
    • 集合內(nèi)的元素是唯一的：自動(dòng)去重
    • 集合內(nèi)的元素必須是可hash的，也就是不可變類型
    • 集合是無序的，無索引。但是可以遍歷：for i in set
      
  • 集合的作用：作關(guān)系運(yùn)算
    • 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) 結(jié)果是：{3, 4}
    • s1.update(s2) s2的值加入s1
    • s.add(元素） 增加元素
    • s.remove() 刪除元素，如果元素不存在報(bào)錯(cuò)
    • s.discard(元素) 刪除元素，如果元素不存在不報(bào)錯(cuò)，better than remove
    • s.pop() 隨機(jī)刪（因?yàn)榧鲜菬o序的）
    • s1.issubset(s2) s1是s2的子集，返回bool值
    • s1.issuperset(s2) s1是s2的父級，返回bool值
    • s1.isdisjoint(s2) 沒有交集返回True
      

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

流程控制與循環(huán)結(jié)構(gòu)

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

總結(jié)

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

如果覺得生活随笔網(wǎng)站內(nèi)容還不錯(cuò)，歡迎將生活随笔推薦給好友。