python中常見的數據類型

str 經常使用方法

1. 索引(下標)

s = 'ABCDEFGHIJKLMN'
s1 = s[0]
print('s[0] = ' + s1)   #s[0] = A

2. 切片：顧頭不顧尾

s = 'ABCDEFGHIJKLMN'
s2 = s[0:3]
print('s[0:3] = ' + s2)     #s[0:3] = ABC

3. 跳取 s[首:尾:步長]

s3 = 'ABCDEFGHIJKLMN'
print(s3[0:6:2])    #ACE

4. 首字母大寫 capitalize

s = 'alexWUsir'
s4_1 = s.capitalize()  #首字母大寫
print(s4_1)   #Alexwusir

5.所有大寫 upper

s = 'alexWUsir'
s4_2 = s.upper() #所有大寫
print(s4_2)   #ALEXWUSIR

6.所有小寫 lower

s = 'alexWUsir'
s4_3 = s.lower() #所有小寫
print(s4_3)   #alexwusir

7. 大小寫互換 swapcase

s = 'alexWUsir'
s4_4 = s.swapcase() #大小寫互換
print(s4_4)   #ALEXwuSIR

8. 每一個用特殊字符或數字隔開的單詞首字母大寫 title

s = 'xc——gx*zs_shy+hihn9bbklv yiu'
s7 = s.title()
print(s7)  #Xc——Gx*Zs_Shy+Hihn9Bbklv Yiu

9. 查找 find

#s.find經過元素找索引，找到返回索引，找不到返回-1
#s.index經過元素找索引，找到返回索引，找不到返回error
s = 'alexWUsir'
s8_11 = s.find('W')
s8_12 = s.index('W')
s8_21 = s.find('WU')
s8_22 = s.index('WU')
s8_31 = s.find('A')
s8_32 = s.index('A')
print(s8_11,type(s8_12))      #4 <class 'int'>
print(s8_21 ,type(s8_22))     #4 <class 'int'>
print(s8_31 ,type(s8_32))     #報錯：ValueError: substring not found----未找到子字符串

10. 刪除字符串先後的空格/字符 strip

s = ' alexW%Usir %2% '
s9_1 = s.strip()   #刪除字符串先後的空格
print(s9_1)   #alexW%Usir %2%
ss = '% alexW%Usir %2% %'
s9_2 = ss.strip('%')    #刪除字符串先後的%
print(s9_2)  # alexW%Usir %2%

應用實例

username = input('張三 ').strip()
if username == '張三':
    print('你好呀 主人')

11. 計算字符串中某字符/字符串的個數 count

s = 'alexaa wusirl'
s10 = s.count('a')
print('此字符串中有' + s10 + '個a')   #報錯：TypeError: must be str, not int
print('此字符串中有' + str(s10) + '個a')    #此字符串中有3個a

12. 分割 split (默認按空格分割)

s = 'alex wusir taibai'
s1 = 'ale:x wus:ir :taibai'
s11_1 = s.split()
print(s11_1)    #['alex', 'wusir', 'taibai']
s11_2 = s1.split(':')
print(s11_2)   #['ale', 'x wus', 'ir ', 'taibai']

13. 三種格式化輸出 format

s12_1 = '我叫{},今年{}歲，愛好{},再說一下我叫{}'.format('張三',23,'學習','張三')
print(s12_1)    #我叫張三,今年23歲，愛好學習,再說一下我叫張三
s12_2 = '我叫{0},今年{1}歲，愛好{2},再說一下我叫{0}'.format('張三',23,'學習')
print(s12_2)    #我叫張三,今年23歲，愛好學習,再說一下我叫張三
s12_3 = s1 = '我叫{name},今年{age}歲，愛好{hobby},再說一下我叫{name}'.format(name = '張三',age = 23,hobby = '學習')
print(s12_3)    #我叫張三,今年23歲，愛好學習,再說一下我叫張三

14. 替換 replace

s13_1 = '張三，哈嘍你好，我是張三'
s13_2 = s13_1.replace('張三','李四')
s13_3 = s13_1.replace('張三','李四',1)
print(s13_1)    #張三，哈嘍你好，我是張三----原來文本
print(s13_2)    #李四，哈嘍你好，我是李四----全都替換
print(s13_3)    #李四，哈嘍你好，我是張三----只替換第一個

15. 有限循環for(while是無限循環)

s = 'zhangsan'
for i in s:
    print(i)

---

 

list 經常使用方法

1. 追加 append (在末尾進行添加)

a = [1,2,3]
a.append(4)                          #the result ： [1, 2, 3, 4]

2. 插入 insert (將對象插入到列表中)

a = [1,2,3]
a.insert(0,'aa')            #the result : ['aa', 1, 2, 3]

3. 合併 extend (列表的末尾一次性追加另外一個序列中的多個值)

a = [1,2,3]
b = [4,5,6]
a.extend(b)                          #the result ：[1, 2, 3, 4, 5, 6]

4. 統計 count (統計某個元素在列表中出現的次數)

a = ['aa','bb','cc','aa','aa']
print(a.count('aa'))                 #the result ： 3

5. 刪除 pop (移除列表中的一個元素，默認是最後一個，而且返回該元素的值)

a = [1,2,3]
a.pop()                             #the result ： [1, 2]
a.pop(0)

6. 刪除對象 remove (移除列表中某個值的第一個匹配項)

a = ['aa','bb','cc','aa']
a.remove('aa')                      #the result ： ['bb', 'cc', 'aa']

7. 反轉 reverse (將列表中的元素反向存放)

a = ['a','b','c']
a.reverse()                         #the result ： ['c', 'b', 'a']

8. 排序 sort (在原位置對列表進行排序，意味着改變原來的列表，讓其中的元素按必定順序排列)

a = ['a','b','c',1,2,3]
a.sort()                           #the result ：[1, 2, 3, 'a', 'b', 'c']

9. 索引 index (從列表中找出某個值第一個匹配項的索引位置)

a = [1,2,3,1]
print(a.index(1))                   #the result ： 0

10. enumerate 用法（打印元素對應的下標）

li = [11,22,33]
for k,v in enumerate(li, 1):       
    print(k,v)                     #the result ： 1 11 2 22 3 33

---

 

tuple 經常使用方法

1. 元組中只包含一個元素時，須要在元素後面添加逗號來消除歧義

tup1=(50,)

2. 元組中的元素值使不容許修改的，但能夠對元組進行鏈接組合

tup1=(12,34.56)
tup2=('abc','xyz')
tup1[0]=100 #非法操做，元組中的元素是不容許被修改的
tup3=tup1+tup2 #python運行元組進行鏈接組合
print(tup3)# 輸出:(12,34.56,'abc','xyz')

3. 元組之間可使用+和*，即容許元組進行組合鏈接和重複複製，運算後會生成一個新的元組

tup1=(1,2,3)
tup2=(3,4,5)
​
tup3=tup1+tup2 #輸出：tup3=(1,2,3,3,4,5)
tup4=tup1*3 #輸出： tup4=(1,2,3,1,2,3,1,2,3)

4. 任意無符號的對象，以逗號隔開，默認爲元組

a=1,2,3,'hello'
print(a) #輸出：(1,2,3,'hello')

5. 對元組進行操做的內建函數

——cmp(tup1,tup2): 比較兩個元組元素

——len(tup): 返回元組中元素的個數

——max(tup): 返回元組中元素最大的值

——min(tup): 返回元組中元素最小的值

——tuple(seq): 將列表轉化爲元組

6. 元組的方法（元組沒有列表中的增、刪、改的操做，只有查的操做）

——tuple.index(obj)：從元組中找出某個值第一個匹配項的索引值

——tuple.count(obj)： 統計某個元素在元組中出現的次數

---

dict 經常使用方法

1. 清空 clear （用於清空字典中全部的 key-value 對，對一個字典執行 clear() 方法以後，該字典就會變成一個空字典）

d = {'name':"tom"}
d.clear()
print(d)                                         #the result : {}

2. 獲取 get （根據 key 來獲取 value，若是key不存在，返回None）

d = {'Tom':8777,'Jack':8888,'Fly':6666}
print(d.get('Tom'))                              #the result ：     8777
print(d.get('not_exist'))                       #the result ：     None

3. 更新 update （利用一個字典項更新另外一個字典，提供的字典中的項會被添加到舊的字典中，若有相同的鍵則會被覆蓋）

d = {'Tom':8777,'Jack':8888,'Fly':6666}
a = {'Tom':110,'Test':119}
d.update(a)
print(d)                                       #the result ：{'Fly': 6666, 'Test': 119, 'Jack': 8888, 'Tom': 110}

4. setdefault （在某種程度上相似於get方法，可以得到與給定鍵相關聯的值，除此以外，setdefault還能在字典中不含有給定鍵的狀況下設定相應的鍵值）

d = {'Tom':8777,'Jack':8888,'Fly':6666}
d.setdefault('Tom')                           #the result ： 8777
print(d.setdefault('Test'))                  #the result ： None
print(d)                                      #{'Fly': 6666, 'Jack': 8888, 'Tom': 8777, 'Test': None}

5. 刪除 pop （用於獲取指定 key 對應的 value，並刪除這個 key-value 對）

d = {'Tom':8777,'Jack':8888,'Fly':6666}
v = d.pop('Tom')
print(v)                    #8777

6. fromkeys （使用給定的鍵創建新的字典，每一個鍵都對應一個默認的值None）

print({}.fromkeys(['name','age']))              #the result　：　{'age': None, 'name': None}

7. for循環字典的三種方法

d = {'Tom':8777,'Jack':8888,'Fly':6666}
for k,v in d.items():
    print(k,v)
for k in d.values():
    print(k)
for k in d.keys():
    print(k)

8. 將兩個列表組合成字典

keys = ['a', 'b']
values = [1, 2]
print(dict(zip(keys,values)))                                      # {'a': 1, 'b': 2}