一、基礎資料型別補充內容
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之后有序）
按存值個數區分
| 標量／原子型別 | 數字，字串 |
|---|---|
| 容器型別 | 串列，元組，字典 |
按可變不可變區分
| 可變 | 串列，字典 |
|---|---|
| 不可變 | 數字，字串，元組，布林值 |
按訪問順序區分
| 直接訪問 | 數字 |
|---|---|
| 順序訪問（序列型別） | 字串，串列，元組 |
| key值訪問（映射型別） | 字典 |
四. 編碼的進階
編碼即是密碼本，編碼記錄的就是二進制與文字之間的對應關系，現存的編碼本有：
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'
轉載請註明出處，本文鏈接：https://www.uj5u.com/houduan/114475.html
標籤：Python
下一篇：16.DRF-JWT