一、基礎數據類型補充內容

1、字元串

s1 = 'taobao jD shopping'
print(s1.capitalize())   #首字母大寫，其餘小寫

print(s1.swapcase())    #大小寫翻轉

print(s1.title())  #每個單詞的首字毒大寫

ret2 = s1.center(30,"*")  # 內同居中，總長度，空白處填充
print(ret2)

s1 = 'taobao jD shopping'
ret3 = s1.find('D')  #find:通過元素找索引，找到第一個就返回，找不到返回-1
print(ret3)

ret4 = s1.index('d')
print(ret4)   ## 返回的找到的元素的索引，找不到報錯。

2、元組

​ python中元組有一個特性，元組中如果只含有一個元素且沒有逗號，則該元組不是元組，與改元素數據類型一致，如果有逗號，那麼它是元組。

tu = (1)
print(tu,type(tu))  # 1 <class 'int'>
tu1 = ('alex')
print(tu1,type(tu1))  # 'alex' <class 'str'>
tu2 = ([1, 2, 3])
print(tu2,type(tu2))  # [1, 2, 3] <class 'list'>

tu = (1,)
print(tu,type(tu))  # (1,) <class 'tuple'>
tu1 = ('alex',)
print(tu1,type(tu1))  # ('alex',) <class 'tuple'>
tu2 = ([1, 2, 3],)
print(tu2,type(tu2))  # ([1, 2, 3],) <class 'tuple'>

元組也有一些其他的方法：

index：通過元素找索引（可切片），找到第一個元素就返回，找不到該元素即報錯。

tu = ('太白', [1, 2, 3, ], 'WuSir', '女神')
print(tu.index('太白'))   #0
print(tu.index('aaa'))	  #ValueError: tuple.index(x): x not in tuple

count: 獲取某元素在列表中出現的次數

tu = ('太白', [1, 2, 3, ], '太白','WuSir', '太白','女神')
print(tu.count('太白'))

3、列表

列表的其他操作方法：

count（數）（方法統計某個元素在列表中出現的次數）

a = ["q","w","q","r","t","y"]
print(a.count("q"))

index（方法用於從列表中找出某個值第一個匹配項的索引位置）

a = ["q","w","r","t","y"]
print(a.index("r"))

sort （方法用於在原位置對列表進行排序）。

reverse （方法將列表中的元素反向存放）。

a = [2,1,3,4,5]
a.sort()# 他沒有返回值，所以只能列印a
print(a)
a.reverse()#他也沒有返回值，所以只能列印a
print(a)

列表也可以相加與整數相乘

l1 = [1, 2, 3]
l2 = [4, 5, 6]
print(l1 + l2)  # [1, 2, 3, 4, 5, 6]
print(l1 * 3)  # [1, 2, 3, 1, 2, 3, 1, 2, 3]

迴圈列表，改變列表大小的問題

​ 有列表l1, l1 = [11, 22, 33, 44, 55]，請把索引為奇數對應的元素刪除（不能一個一個刪除，此l1只是舉個例子，裡面的元素不定）。

l1 = [11,22,33,44,55,66,77,88,99]
del l1[1::2]
print(l1)

l1 = [11,22,33,44,55,66,77,88,99]
for i in range(len(l1)-1,-1,-1):
    if i %2 == 1:
        l1.pop(i)
print(l1)

l1 = [11,22,33,44,55,66,77,88,99]
new_l1 = []
for i in range(len(l1)):
    if i %2 == 0 :
        new_l1.append(l1[i])
print(new_l1)

4、dict字典

#popitem 3.5版本之前，popitem為隨機刪除，3.6之後為刪除最後一個，有返回值
dic = {'name': '太白', 'age': 18}
ret = dic.popitem()
print(ret,dic) # ('age', 18) {'name': '太白'}

# update
dic = {'name': '太白', 'age': 18}
dic.update(sex='男', height=175)
print(dic) # {'name': '太白', 'age': 18, 'sex': '男', 'height': 175}

dic = {'name': '太白', 'age': 18}
dic.update([(1, 'a'),(2, 'b'),(3, 'c'),(4, 'd')])
print(dic) # {'name': '太白', 'age': 18, 1: 'a', 2: 'b', 3: 'c', 4: 'd'}

dic1 = {"name":"jin","age":18,"sex":"male"}
dic2 = {"name":"alex","weight":75}
dic1.update(dic2)
print(dic1) # {'name': 'alex', 'age': 18, 'sex': 'male', 'weight': 75}
print(dic2) # {'name': 'alex', 'weight': 75} 

fromkeys：創建一個字典：字典的所有鍵來自一個可迭代對象，字典的值使用同一個值。

dic = dict.fromkeys('abcd','太白')
print(dic) # {'a': '太白', 'b': '太白', 'c': '太白', 'd': '太白'}

dic = dict.fromkeys([1, 2, 3],'太白')
print(dic) # {1: '太白', 2: '太白', 3: '太白'}

# 這裡有一個坑，就是如果通過fromkeys得到的字典的值為可變的數據類型，那麼你的小心了。
dic = dict.fromkeys([1, 2, 3], [])
dic[1].append(666)
print(id(dic[1]),id(dic[2]),id(dic[3]))  # {1: [666], 2: [666], 3: [666]}
print(dic)  # {1: [666], 2: [666], 3: [666]}

迴圈字典，改變字典大小的問題

dic = {'k1':'太白','k2':'barry','k3': '白白', 'age': 18} 請將字典中所有鍵帶k元素的鍵值對刪除。

dic = {'k1':'太白','k2':'barry','k3': '白白', 'age': 18}
dic2= dic.keys()
dic3 = list(dic2)
for i in dic3:
    if i.find('k') != -1:
        del dic[i]
print(dic)
輸出結果:
{'age': 18}

dic = {'k1': '太白', 'k2': 'barry', 'k3': '白白', 'age': 18}
for i in list(dic.keys()):
    if 'k' in i:
        del dic[i]
print(dic)
輸出結果:
{'age': 18}

二. 數據類型間的轉換問題

int bool str 三者轉換

# int ---> bool
i = 100
print(bool(i))  # True  # 非零即True
i1 = 0
print(bool(i1))  # False 零即False

# bool ---> int
t = True
print(int(t))  # 1  True --> 1
t = False
print(int(t))  # 0  False --> 0

# int ---> str
i1 = 100
print(str(i1))  # '100'

# str ---> int  # 全部由數字組成的字元串才可以轉化成數字
s1 = '90'
print(int(s1))  # 90

# str ---> bool
s1 = '太白'
s2 = ''
print(bool(s1))  # True 非空即True
print(bool(s2))  # False
# bool ---> str
t1 = True
print(str(True))  # 'True'

str list 兩者轉換

# str ---> list
s1 = 'alex 太白 武大'
print(s1.split())  # ['alex', '太白', '武大']

# list ---> str  # 前提 list 裡面所有的元素必須是字元串類型才可以
l1 = ['alex', '太白', '武大']
print(' '.join(l1))  # 'alex 太白 武大'

list set 兩者轉換

# list ---> set
s1 = [1, 2, 3]
print(set(s1))

# set ---> list
set1 = {1, 2, 3, 3,}
print(list(set1))  # [1, 2, 3]

str bytes 兩者轉換

# str ---> bytes
s1 = '太白'
print(s1.encode('utf-8'))  # b'\xe5\xa4\xaa\xe7\x99\xbd'

# bytes ---> str
b = b'\xe5\xa4\xaa\xe7\x99\xbd'
print(b.decode('utf-8'))  # '太白'

所有數據都可以轉化成bool值

轉化成bool值為False的數據類型有：
'', 0, (), {}, [], set(), None

三.基礎數據類型的總結

按存儲空間的占用分（從低到高）

• 數字
• 字元串
• 集合：無序，即無序存索引相關信息
• 元組：有序，需要存索引相關信息，不可變
• 列表：有序，需要存索引相關信息，可變，需要處理數據的增刪改
• 字典：有序，需要存key與value映射的相關信息，可變，需要處理數據的增刪改（3.6之後有序）

按存值個數區分

按可變不可變區分

按訪問順序區分

四. 編碼的進階

編碼即是密碼本，編碼記錄的就是二進位與文字之間的對應關係，現存的編碼本有：

ASCII碼：包含英文字母，數字，特殊字元與01010101對應關係。

　　a 01000001 一個字元一個位元組表示。

GBK：只包含本國文字（以及英文字母，數字，特殊字元）與0101010對應關係。

　　a 01000001 ascii碼中的字元：一個字元一個位元組表示。

　　中 01001001 01000010 中文：一個字元兩個位元組表示。

Unicode：包含全世界所有的文字與二進位0101001的對應關係。

　　a 01000001 01000010 01000011 00000001

　　b 01000001 01000010 01100011 00000001

　　中 01001001 01000010 01100011 00000001

UTF-8:包含全世界所有的文字與二進位0101001的對應關係（最少用8位一個位元組表示一個字元）。

　 a 01000001 ascii碼中的字元：一個字元一個位元組表示。

　　To 01000001 01000010 (歐洲文字：葡萄牙，西班牙等)一個字元兩個位元組表示。

　　中 01001001 01000010 01100011 亞洲文字；一個字元三個位元組表示。

1、不同的密碼本之間不能互相識別

2、數據在記憶體中全是以Unicode編碼的，但是當你的數據用於網路傳輸或者存儲到硬碟中，必須以非Unicode編碼(utf-8,gbk等等)

3、bytes數據類型

英文

• ​ str :'hello'

​ 記憶體中的編碼方式：Unicode

​ 表現形式:'hello'

• ​ bytes:

​ 記憶體中的編碼方式:非Unicode

​ 表現形式; b'hello'

b = b'hello'  #如果在字元串前加b，它就變為一個bytes類型的數據
print(b,type(b))  #b'hello' <class 'bytes'>

b = b'hello'
print(b.upper(),type(b))  #b'HELLO' <class 'bytes'>

中文

• str :'中國'

​ 記憶體中的編碼方式：Unicode

​ 表現形式:'中國'

• bytes:

​ 記憶體中的編碼方式:非Unicode

​ 表現形式; b'\xe4\xb8\xad\xe5\x9b\xbd'

轉換

• str -------> bytes

# encode稱作編碼:將 str 轉化成 bytes類型
s1 = '中國'
b1 = s1.encode('utf-8')  # 轉化成utf-8的bytes類型
print(s1)  # 中國
print(b1)  # b'\xe4\xb8\xad\xe5\x9b\xbd'

s1 = '中國'
b1 = s1.encode('gbk')  # 轉化成gbk的bytes類型
print(s1)  # 中國
print(b1)  # b'\xd6\xd0\xb9\xfa'

• bytes ----->str

# decode稱作解碼, 將 bytes 轉化成 str類型
b1 = b'\xe4\xb8\xad\xe5\x9b\xbd'
s1 = b1.decode('utf-8')
print(s1)  # 中國

# decode稱作解碼, 將 bytes 轉化成 str類型
b1 = b'\xd6\xd0\xb9\xfa'
s1 = b1.decode('gbk')
print(s1)  # 中國

註：用什麼編碼(gbk,utf-8等)轉過來的，必須要用相同的編碼轉回去。

• gbk ------>utf-8

​ gbk編碼的bytes如何轉化成utf-8編碼的bytes

​ 不同編碼之間，不能直接互相識別。

​ Unicode是萬碼之源，先用gbk轉為Unicode,轉從Unicode轉換為utf-8

b1 =  b'\xe4\xb8\xad\xe5\x9b\xbd'  # 這是utf-8編碼bytes類型的中國
b2 =  b'\xd6\xd0\xb9\xfa'   # 這是gbk編碼bytes類型的中國

b2 =  b'\xd6\xd0\xb9\xfa'  # 這是gbk編碼bytes類型的中國
s = b2.decode('gbk')
print(s)
s1 = s.encode('utf-8')
print(s1)
輸出結果:b'\xe4\xb8\xad\xe5\x9b\xbd'