Python數據類型進階—

??

? ? ? ? ? ? ? ? ? ? ? ? ? ? ? ? ? ? ???——?小?峰?編?程

1.整型

1.1 定義

1.2 獨有功能

1.3 公共功能

1.4 轉換

1.5 其他

1.5.1 長整型

1.5.2 地板除(除法）

2. 布爾類型

2.1 定義

2.2 獨有功能

2.3 公共功能

2.4 轉換

2.5 其他

?做條件自動轉換

3.字符串類型

3.1 定義

3.2 獨有功能（18/48）

3.3 公共功能

3.4 轉換

3.5 其他

4.列表（list）

1.1 定義

1.2 獨有功能

1.3 公共功能

?5.元組

5.1 定義

5.2 獨有功能

5.3 公共功能

5.4 轉換

5.5 其他

嵌套

6.集合（set）

6.1 定義

6.2 獨有功能

6.3 公共功能

6.4 轉換

6.5 其他

6.5.1 集合的存儲原理

6.5.2 元素必須可哈希

6.5.3 查找速度特別快

6.5.4 對比和嵌套

補充：None類型

7.字典（dict)

7.1 定義

7.2 獨有功能

7.3 公共功能

7.4 轉換

7.5 其他

1.5.1 存儲原理

1.5.2 速度快

1.5.3 嵌套

8.浮點型（float）

序言： 在前面Python的第一講中，我們其實已經對數據類型已經有了初步的認識。接下來在本講中我們會針對Python中的數據類型做以詳細的講解。每種數據類型的講解，會按照以下4個維度來進行：定義、獨有功能、公共功能、類型轉換、其他等幾個方面來進行講解。常見的數據類型：

int，整數類型（整形）
bool，布爾類型
str，字符串類型
list，列表類型
tuple，元組類型
dict，字典類型
set，集合類型
float，浮點類型（浮點型）

1.整型

?整型其實就是十進制整數的統稱，比如：1、68、999都屬于整型。他一般用于表示年齡、序號等。

1.1 定義

number = 10
age = 99

1.2 獨有功能

# 調用v1（int）,v2(int)的獨有功能，獲取v1,v2的二進制有多少個位組成。
v1=10
v2=5
print(bin(v1),bin(v2))#0b1010 0b101
print(v1.bit_length(),v2.bit_length())#4 3

1.3 公共功能

加減乘除

v1 = 4
v2 = 8
v3 = v1 + v2

1.4 轉換

在項目開發和面試題中經常會出現一些 “字符串” 和布爾值轉換為整型的情況。

# 布爾值轉整型
print(int(True),int(False)) #1 0 True轉換為整數 1  False轉換為整數 0
# 字符串轉整型
print(int("250",base=10))#把字符串看成十進制數字
print(int("0b101",base=2))#把字符串看成二進制數字
print(int("0o11",base=8))#把字符串看成八進制數字
print(int("0x10",base=16))#把字符串看成十六進制數字
#print(int("scbsbc"))#不能轉換
# 浮點型（小數）
v1 = int(8.7) # 8

Tip: 所以，如果以后別人給你一個按二進制、八進制、十進制、十六進制規則存儲的字符串時，可以輕松的通過int轉換為十進制的整數。

1.5 其他

1.5.1 長整型

Python3：整型（無限制）
Python2：整型、長整形

>>>>在python2中跟整數相關的數據類型有兩種：int(整型)、long（長整型），他們都是整數只不過能表示的值范圍不同。

int，可表示的范圍：-9223372036854775808～9223372036854775807
long，整數值超出int范圍之后自動會轉換為long類型（無限制）。

>>>>在python3中去除了long只剩下：int（整型），并且 int 長度不在限制。

1.5.2 地板除(除法）

Py3：
```
v1 = 9/2 
print(v1) # 4.5
```
py2:
```
v1 = 9/2 
print(v1) # 4
```

2. 布爾類型

布爾值，其實就是 “真”、“假” 。

2.1 定義

a = False
b = True

2.2 獨有功能

2.3 公共功能

print(True+False,True-True)#1 0

2.4 轉換

在以后的項目開發中，會經常使用其他類型轉換為布爾值的情景，此處只要記住一個規律即可。整數0、空字符串、空列表、空元組、空字典轉換為布爾值時均為False，其他均為True。

# 練習題：查看一些變量為True還是False
print(bool(0))
print(bool(-10))
print(bool(10))
print(bool("武齊"))
print(bool(""))
print(bool(" "))
print(bool([]) )# [] 表示空列表
print(bool([11,22,33])) # [11，22，33] 表示非空列表
print(bool({})) # {} 表示空字典
print(bool({"name":"武齊","age":18}))# {"name":"武齊","age":18} 表示非空字典

2.5 其他

?做條件自動轉換

????????如果在?if?、while?條件后面寫一個值當做條件時，他會默認轉換為布爾類型，然后再做條件判斷。

if 0:print("太六了")
else:print(999)if "武齊":print("你好")if "alex":print("你是王？")
else:print("你是李？")

while 1<9:pass

if 值:passwhile 值:pass

3.字符串類型

字符串，我們平時會用他來表示文本信息。例如：姓名、地址、自我介紹等。

3.1 定義

v1 = "包治百病"
v2 = '包治百病'
v3 = "包'治百病"
v4 = '包"治百病'
v5 = """
吵架都是我的錯，
因為大家打不過。
"""
# 三個引號，可以支持多行/換行表示一個字符串，其他的都只能在一行中表示一個字符串。

3.2 獨有功能（18/48）

"xxxxx".功能(...)v1 = "xxxxx"
v1.功能(...)

判斷字符串是否以 XX 開頭？得到一個布爾值

v1 = "每天事情都好多，煩死了"
# True
result = v1.startswith("每天")
print(result) # 值為True

v1 = input("請輸入住址：")
if v1.startswith("北京"):print("北京人口")
else:print("非北京人口")

判斷字符串是否以 XX 結尾？得到一個布爾值

v1 = "每天事情真多，煩死了"
result = v1.endswith("煩死了")
print(result) # 值為True

# 案例
address = input("請輸入地址：")
if address.endswith('村'):print("農業戶口")
else:print("非農戶口")

判斷字符串是否為十進制數？得到一個布爾值

v1 = "1238871"
result = v1.isdecimal()
print(result) # True

# 案例,兩個數相加。
v1 = input("請輸入值：") # ”666“
v2 = input("請輸入值：") # ”999“
if v1.isdecimal() and v2.isdecimal():data = int(v1) + int(v2)print(data)
else:print("請正確輸入數字")

v1 = "123"
print(v1.isdecimal()) # True
v2 = "①"
print(v2.isdecimal()) # False 判斷是否由十進制數字字符組成
v3 = "123"
print(v3.isdigit()) # True 判斷是否由數字字符組成
v4 = "①"
print(v4.isdigit()) # True

去除字符串兩邊的空格、換行符、制表符，得到一個新字符串

msg = " H e ll o，哥 "
print(msg.strip(),msg.rstrip(),msg.lstrip())
# 分別將msg兩邊，右邊，左邊的空白去掉

補充：去除空格、換行符、制表符。

# 案例
code = input("請輸入4位驗證碼：") #  FB87 
data = code.strip()
if data == "FB87":print('驗證碼正確')
else:print("驗證碼錯誤")

補充：去除字符串兩邊指定的內容。

字符串變大寫，得到一個新字符串

# 案例
code = input("請輸入4位驗證碼：") #  FB88   fb88 
value = code.upper() #  FB88  
data = value.strip() # FB88
if data == "FB87":print('驗證碼正確')
else:print("驗證碼錯誤")
# 注意事項
"""
code的值"fb88 "
value的值"FB88 "
data的值"FB88"
"""

字符串變小寫，得到一個新字符串

# 案例
code = input("請輸入4位驗證碼：")
value = code.strip().lower()
if value == "fb87":print('驗證碼正確')
else:print("驗證碼錯誤")

字符串內容替換，得到一個新的字符串

# 案例
video_file_name = "西游記.mp4"
new_file_name = video_file_name.replace("mp4","avi") # "西游記.avi"
final_file_name = new_file_name.replace("西游記","水滸傳") # "水滸傳.avi"
print(final_file_name)

字符串切割，得到一個列表

# 案例：判斷用戶名密碼是否正確
info = xiaofeng,root"   # 備注：字符串中存儲了用戶名和密碼
user_list = info.split(',')    # 得到一個包含了2個元素的列表 [ "武沛齊" , "root" ]
# user_list[0]  user_list[1]
user = input("請輸入用戶名：")
pwd = input("請輸入密碼：")
if user == user_list[0] and pwd == user_list[1]:print("登錄成功")
else:print("用戶名或密碼錯誤")

擴展

data = "武沛齊,root,wupeiqi@qq.com"
v1 = data.rsplit(',')
print(v1) # ['武沛齊', 'root', 'wupeiqi@qq.com']
v2 = data.rsplit(',',1) #從最右邊開始分割，最多分割一次
print(v2) # ['武沛齊,root', 'wupeiqi@qq.com']

應用場景：

#經常用于對IP地址的分割
file_path = "xxx/xxxx/xx.xx/xxx.mp4"
data_list = file_path.rsplit(".",1) # ["xxx/xxxx/xx.xx/xxx","mp4"]
data_list[0]
data_list[1]

字符串拼接，得到一個新的字符串

data_list = ["xiaofeng","是","小白"]
v1 = "_".join(data_list) 
print(v1)

格式化字符串，得到新的字符串

print("_".join(data))
name="{name}已經{age}歲了。".format(name="xiaofeng",age=20)

字符串轉換為字節類型

data = "餃子"  # unicode，字符串類型
v1 = data.encode("utf-8")  # utf-8，字節類型
v2 = data.encode("gbk")  # gbk，字節類型
print(v1)  # b'\xe5\xab\x82 \xe5\xad\x90'
print(v2)  # b'\xc9\xa9 \xd7\xd3'
s1 = v1.decode("utf-8") 
s2 = v2.decode("gbk") 
print(s1)
print(s2)

將字符串內容居中、居左、居右展示

v1="xiaofeng"
print(v1.center(18,"*"))
print(v1.rjust(18,"*"))
print(v1.ljust(18,"*"))

幫助你填充0

# 應用場景：處理二進制數據
data = "101" # "00000101"
v1 = data.zfill(8)
print(v1) # "00000101"

3.3 公共功能

相加：字符串 + 字符串
```
print("xiao"+"feng")
```
相乘：字符串 * 整數
```
print( "xiaofeng" * 3)
```

長度

value = len("xiaofeng") 
print(value) # 8

獲取字符串中的字符，索引
```
a="來這里吃點東西"0 1 2 3 4 5 6-7   ...    -1
print(a[0])
print(a[-1])
```
注意：字符串中是能通過索引取值，無法修改值。【字符串在內部存儲時不允許對內部元素修改，想修改只能重新創建。】

獲取字符串中的子序列，切片

message = "來吃點py東西呀"
#          0 1 2345 6 7
print(message[0:2]) # "來吃"
print(message[3:7]) # "py東西"
print(message[3:] ) # "py東西呀"
print(message[:5] ) # "來吃點py"
print(message[4:-1]) # "y東西"
print(message[4:-2]) # "y東"
print(message[4:len(message)] ) # "y東西呀"
print(message[::-1])#相當于字符串逆置/倒序

步長，跳著去字符串的內容

data="生活不是電影，生活比電影苦"
print(data[0:len(data):2])
#從第一個位置到最后一個位置，步長為2的切片
print(data[0::2])
#逆序切片
print(data[::-1])
print(data[::-2])

循環

while循環

data="好好學習編程技術"
i=0
while i<len(data):print(data[i],end='')i+=1

for循環

data='好好學習編程技術'
for i in data:print(i,end='')

range，幫助我們創建一系列的數字

range(10) # [0,1,2,3,4,5,6,7,8,9]
range(1,10) # [1,2,3,4,5,6,7,8,9]
range(1,10,2) # [1,3,5,7,9]
range(10,1,-1) # [10,9,8,7,6,5,4,3,2]

For + range

for i in range(11):print(i,end=' ')

message = "好好學習"
for i in range( len(message) ): print(message[i])

一般應用場景：

while，一般在做無限制（未知）循環此處時使用。

while True:...

# 用戶輸入一個值，如果不是整數則一直輸入，直到是整數了才結束。
num = 0
while True:data = input("請輸入內容:")if data.isdecimal():num = int(data)breakelse:print("輸入錯誤，請重新輸入！")

for循環，一般應用在已知的循環數量的場景。

message = "好好學習編程技術"
for char in message:print(char)

for i in range(30):print(message[i])

break和continue關鍵字

message="好好學習編程技術"
for char in message:if char=='習':continueprint(char,end='')

message="好好學習編程技術"
for char in message:if char=='習':breakprint(char,end='')

3.4 轉換

num = 999
data = str(num)
print(data) # "999"

num =["小峰",11,["xiaowang"]]
z=str(num)
print(z,type(z))

一般情況下，只有整型轉字符串才有意義。

3.5 其他

字符串不可被修改

name="xiao峰"
print(name[1])
name[1]='x'   #不支持修改，會報錯
print(name)

4.列表（list）

列表（list），是一個有序且可變的容器，在里面可以存放多個不同類型的元素。

1.1 定義

number_list = [98,88,666,12,-1]
data_list = [1,True,"xiaofeng","寶強","賈乃亮"]

data = list()
#data = [] 以上這兩種方式都不表示空列表
print(data)

補充：

不可變類型：字符串、布爾、整型（已最小，內部數據無法進行修改）
可變類型：列表（內部數據元素可以修改）

1.2 獨有功能

Python中為所有的列表類型的數據提供了一批獨有的功能。在開始學習列表的獨有功能之前，先來做一個字符串和列表的對比：

字符串，不可變，即：創建好之后內部就無法修改。【獨有功能都是新創建一份數據】

列表，可變，即：創建好之后內部元素可以修改。【獨有功能基本上都是直接操作列表內部，不會創建新的一份數據】

列表中的常見獨有功能如下：

追加，在原列表中尾部追加值。

user_list = ["語文","數學"]
user_list.append("英語")
print(user_list) # ["語文","數學","英語"]

welcome="歡迎來到游戲".center(30,"*")
print(welcome)
user_count=0
while True:user_count=input("請輸入玩游戲的人數：")if user_count.isdecimal():user_count=int(user_count)breakelse:print("輸入的需要是數字，請重新輸入！")
message=f"有{user_count}參加游戲"
print(message)
user_name=[]
for i in range(1,user_count+1):tips=f"請輸入玩家姓名{i}/{user_count}:"name=input(tips)user_name.append(name)
print(user_name)

批量追加，將一個列表中的元素逐一添加另外一個列表。
```
data = ['xiaoli',20,'男']
data.extend(['xiaowang',23,'女'])
print(data)
```

插入，在原列表的指定索引位置插入值

user_list = ["小王","雪","小張"]
user_list.insert(0,"馬蓉")
user_list.insert(2,"李小璐")
print(user_list)

在原列表中根據值刪除（從左到右找到第一個刪除）【慎用，里面沒有會報錯】

user_list = ["小王","雪","小張","雪"]
while True:if "雪" in user_list:user_list.remove("雪")else:break
print(user_list)

# 案例：自動抽獎程序
import randomdata_list = ["iphone12", "購物卡", "洗手液", "泰國5日游"]while data_list:name = input("自動抽獎程序，請輸入自己的姓名：")# 隨機從data_list抽取一個值出來value = random.choice(data_list) print( "恭喜{}，抽中{}.".format(name, value) )data_list.remove(value)

在原列表中根據索引踢出某個元素（根據索引位置刪除）

user_list = ["王寶強","陳羽凡","Alx","賈乃亮","Alx"]
#               0       1      2      3       4
user_list.pop(1)  #會自動返回，刪除索引上對應的值
print(user_list) #  ["王寶強","Alx","賈乃亮","Alx"]user_list.pop()
print(user_list) # ["王寶強","Ale","賈乃亮"]

# 案例：排隊買火車票
user_queue=[]
ticket=5
while True:name=input("請輸入你的名字進行排隊購買(Q退出)：")if name=="Q":breakelse:user_queue.append(name)
for i in range(ticket):if ticket <=ticket and len(user_queue) > 0:print(f"恭喜{user_queue.pop()}，買票成功")
if len(user_queue) >0:print(f"票數不足！非常抱歉，票已售完，以下幾位用戶請選擇其他出行方式，名單：{user_queue}.")

清空原列表

user_list = ["小王","雪","小張","雪"]
user_list.clear()
print(user_list)

根據值獲取索引（從左到右找到第一個刪除）【慎用，找不到報錯】

user_list =["小王","雪","xiaofeng","雪"]
#              0    1     2         3    
if "xiaofeng" in user_list:index = user_list.index("xiaofeng")print(index) # 2
else:print("不存在")

列表元素排序

user_list = ["小王","雪","小張","雪"]
user_list.sort() #按照對應的碼值比較
print(user_list)
num=[4,7,2,1]
num.sort()#由小到大
print(num)
num.sort(reverse=True)#由大到小
print(num)

注意：排序時內部元素無法進行比較時，程序會報錯（盡量數據類型統一）。

反轉原列表

user_list = ["小王","雪","小張","雪"]
user_list.reverse()
print(user_list)

1.3 公共功能

相加，兩個列表相加獲取生成一個新的列表。

data = ["趙四","劉能"] + ["宋曉峰","范德彪"]
print(data) # ["趙四","劉能","宋曉峰","范德彪"]

相乘，列表*整型將列表中的元素再創建N份并生成一個新的列表。
```
data = ["趙四","劉能"] * 2
print(data) # ["趙四","劉能","趙四","劉能"]
```
運算符in包含由于列表內部是由多個元素組成，可以通過in來判斷元素是否在列表中。
```
user_list = ["小王","雪","xiaofeng","雪"]
result = "xiaofeng" in user_list
print(result)
```

?5.元組

5.1 定義

列表（list），是一個有序且可變的容器，在里面可以存放多個不同類型的元素（可重復）。
元組（tuple），是一個有序且不可變的容器，在里面可以存放多個不同類型的元素。

d1 = (1)  # 1
d2 = (1,) # (1,)
d3 = (1,2)
v3 = (True,123,"xiaofeng",[11,22,33,44])
# 建議：議在元組的最后多加一個逗v3 = ("李杰","xiaofeng",)

注意：建議在元組的最后多加一個逗號，用于標識他是一個元組。

# 面試題
1. 比較值 v1 = (1) 和 v2 = 1 和 v3 = (1,) 有什么區別？
2. 比較值 v1 = ( (1),(2),(3) ) 和 v2 = ( (1,) , (2,) , (3,),) 有什么區別？

5.2 獨有功能

無

5.3 公共功能

相加，兩個列表相加獲取生成一個新的列表。
```
print((1,4)+(2,5))
```
相乘，列表*整型將列表中的元素再創建N份并生成一個新的列表。
```
print((1,3)*2)
```
獲取長度
```
data=('xiao',3,6)
print(len(data))
```
索引
```
data=('xiao',3,6)
print(data[1])
```

切片

data=('xiao',3,6)
print(data[:1:])
print(data[1::2])
print(data[2::-1])

步長

data=('xiao',3,6)
print(data[::2])
print(data[1::2])
print(data[2::-1])

for循環

data=('xiao',3,6)
for i in data:print(i)

# len + range + for + 索引
user_list = ?('xiao',3,6)
for index in range(len(user_list)):item = user_list[index]print(item)

5.4 轉換

其他類型轉換為元組，使用tuple(其他類型)，截止目前只有字符串和列表可以轉換為元組。

data = tuple(其他)

name = "xiaofeng"
data = tuple(name)
print(data)

name = ["武齊",18,"python"]
data = tuple(name)
print(data) # 輸出 ("武齊",18,"python")

5.5 其他

嵌套

????????由于元組和列表都可以充當容器，他們內部可以放很多元素，并且也支持元素內的各種嵌套。元組的元素不能被替換，但元組的元素如果是可變類型，可變類型內部是可以修改的。

data = ('xiao','wang',['zhang','li','qin'])
print(data[0])
print(data[2])
print(data[2][0])
print(data[2][1][1])
data[2][1]='liu'
print(data)

案例：動態的創建用戶并添加到用戶列表中。

# 創建用戶 5個
# user_list = [] # 用戶信息
while True:user = input("請輸入用戶名：")if user == "Q":brekpwd = input("請輸入密碼：")item = (user,pwd,)user_list.append(item)# 實現：用戶登錄案例
print("登錄程序")
username = input("請輸入用戶名：")
password = input("請輸入密碼：")is_success = Falsefor item in user_list:if username == item[0] and password == item[1]:is_success = Truebreakif is_success:print("登錄成功")
else:print("登錄失敗")

6.集合（set）

集合是一個無序、可變、不允許數據重復的容器。

6.1 定義

v1 = { 11, 22, 33, "xiaofeng" }

無序，無法通過索引取值。

可變，可以添加和刪除元素。

data={1,5,2,"xiaofeng"}
print(data)
data.add(1.2)
print(data)

不允許數據重復。
```
data={1,5,2,"xiaofeng",5}
print(data)
```

一般什么時候用集合呢？

>>就是?想要維護一大堆不重復的數據時?，就可以用它。比如：做爬蟲去網上找圖片的鏈接，為了避免鏈接重復，可以選擇用集合去存儲鏈接地址。

注意：定義空集合時，只能使用?v=set()，不能使用?v={}（這樣是定義一個空字典）。

v1 = []#空列表
v11 = list()v2 = () #空元組
v22 = tuple()v3 = set() #空集合v4 = {} # 空字典
v44 = dict()

6.2 獨有功能

添加元素

data=set()
data.add("xiaofeng")
data.add(2)
print(data)

刪除元素

data=set()
data.add("xiaofeng")
data.add(2)
print(data)
data.discard("xiaofeng")
print(data)

交集

v1={2,6,'xiao','feng'}
v2={3,6,'feng','zhang'}
print(v1.intersection(v2))
print(v1&v2)

并集

v1={2,6,'xiao','feng'}
v2={3,6,'feng','zhang'}
print(v1.union(v2))
print(v1|v2)

差集

v1={2,6,'xiao','feng'}
v2={3,6,'feng','zhang'}
print(v1.difference(v2))
print(v1-v2)
print(v2.difference(v1))
print(v2-v1)

6.3 公共功能

減，計算差集

v1={2,6,'xiao','feng'}
v2={3,6,'feng','zhang'}
print(v1-v2)
print(v2-v1)

&，計算交集

v1={2,6,'xiao','feng'}
v2={3,6,'feng','zhang'}
print(v1&v2)

|，計算并集

v1={2,6,'xiao','feng'}
v2={3,6,'feng','zhang'}
print(v1|v2)

長度
```
v={2,6,'xiao','feng'}
print(len(v))
```

for循環

v={2,6,'xiao','feng'}
for i in v:print(i,end=' ')

6.4 轉換

其他類型如果想要轉換為集合類型，可以通過set進行轉換，并且如果數據有重復自動剔除。

提示：int/list/tuple/dict 都可以轉換為集合。（str也是可以的，但是比較特殊）

a='xajnxj'
print(set(a))

v1 = [11,22,33,11,3,99,22]
v2 = set(v1)
print(v2) # {11,22,33,3,99}

v1 = (11,22,3,11)
v2 = set(v1)
print(v2) # {11,22,3}

提示：這其實也是去重的一個手段。

data = {11,22,33,3,99}
v1 = list(data) # [11,22,33,3,99]
v2 = tuple(data) # (11,22,33,3,99)

6.5 其他

6.5.1 集合的存儲原理

????????通過哈希表的存儲方式，Python的集合數據類型實現了高效的查找、插入和刪除操作。哈希表存儲的特性使得集合的平均時間復雜度為O(1)，因此在需要進行快速查找不重復元素的場景中，集合是很常用的數據結構。

6.5.2 元素必須可哈希

因存儲原理，集合的元素必須是可哈希的值，即：內部通過通過哈希函數把值轉換成一個數字。

目前可哈希的數據類型：int、bool、str、tuple，而list、set是不可哈希的。

總結：集合的元素只能是 int、bool、str、tuple 。
轉換成功
v1 = [11,22,33,11,3,99,22]
v2 = set(v1)
print(v2) # {11,22,33,3,99}
轉換失敗
v1 = [11,22,["xiao","feng"],33]
v2 = set(v1) # 報錯 
print(v2) 

6.5.3 查找速度特別快

因存儲原理特殊，集合的查找效率非常高（數據量大了才明顯）。

低

user_list = ["武齊","xiaofeng","李璐"]
if "xiaofeng" in user_list:print("在")
else:print("不在")user_tuple = ("武齊","xiaofeng","李璐")
if "xiao" in user_tuple:print("在")
else:print("不在")

效率高

user_set = {"武齊","xiaofeng","李璐"}
if "xiaofeng" in user_set:print("在")
else:print("不在")

6.5.4 對比和嵌套

類型	是否可變	是否有序	元素要求	是否可哈希	轉換	定義空
list	是	是	無	否	list(其他)	`v=[]或v=list()`
tuple	否	是	無	是	tuple(其他)	`v=()或v=tuple()`
set	是	否	可哈希	否	set(其他)	`v=set()`

注意：由于True和False本質上存儲的是 1 和 0 ，而集合又不允許重復，所以在整數 0、1和False、True出現在集合中會有如下現象：

v1 = {True, 1}
print(v1)  # {True}v2 = {1, True}
print(v2)  # {1}v3 = {0, False}
print(v3)  # {0}v4 = {False, 0}
print(v4)  # {False}

補充：None類型

Python的數據類型中有一個特殊的值None，意味著這個值啥都不是或表示空。 相當于其他語言中?null作用一樣。在一定程度上可以幫助我們去節省內存。例如：
v1 = None
v1 = [11,22,33,44]
注意：暫不要考慮Python內部的緩存和駐留機制。

目前所有轉換為布爾值為False的值有：
0 
"" #空字符串
[] or list()
() or tuple()
set()
None

7.字典（dict)

字典是?無序、鍵不重復?且元素只能是?鍵值對?的可變的?個?容器。

data = { "k1":1,  "k2":2 }

容器

元素必須鍵值對
鍵不重復，重復則會被覆蓋
data = { "k1":1, "k1":2 }
print(data) # {"k1":2}
無序（在Python3.6+字典就是有序了，之前的字典都是無序。）
data = { "k1":1,  "k2":2 }
print(data)

7.1 定義

v1 = {} #這兩種都代表空字典
v2 = dict()

info={"姓名":"xiaofeng","年齡":20,"性別":"男","愛好":["編程","乒乓球"]
}
print(info)

字典中對鍵值得要求：

鍵：必須可哈希。目前為止學到的可哈希的類型：int/bool/str/tuple；不可哈希的類型：list/set/dict。（集合）
值：任意類型。

data_dict = {"小峰":29,True:5,123:5,(11,22,33):["王","zhang"]
}

一般在什么情況下會用到字典呢？

當我們想要表示一組固定信息時，用字典可以更加的直觀，例如：

# 用戶列表
user_list = [ ("admin","123"), ("xiaofeng","666") ]
...

# 用戶列表
user_list = [ {"name":"xiaowang","pwd":"123"}, {"name":"admin","pwd":"123"} ]

7.2 獨有功能

獲取值

user_list={"xiaofeng":"xiaofeng","admin":"123456"
}
user_name=input("請輸入用戶名：")
user_pwd=input("請輸入密碼：")
if user_list.get(user_name):while  user_pwd!=user_list.get(user_name):print("密碼錯誤，請重新輸入！")user_pwd = input("請輸入密碼：")else:print("密碼正確，登陸成功！")
else:print("對不起，該用戶不存在！")# 但我建議一般遵循寫代碼的準則：簡單的邏輯處理放在前面；復雜的邏輯放在后面。

所有的鍵

info = {"age":12, "status":True, "name":"xiaofeng","email":"@xiaofeng.com"}
data=info.keys()
print(type(data))
print(list(data))

注意：在Python2中字典.keys()直接獲取到的是列表，而Python3中返回的是高仿列表，這個高仿的列表可以被循環顯示。

# 循環
info = {"age":12, "status":True, "name":"xiaofeng","email":"@xiaofeng.com"}
for i in info.keys():print(i)

所有的值
```
info = {"age":12, "status":True, "name":"xiaofeng","email":"@xiaofeng.com"}
for i in info.values():print(i)
```
注意：在Python2中字典.values()直接獲取到的是列表，而Python3中返回的是高仿列表，這個高仿的列表可以被循環顯示。

所有的鍵值

info = {"age":12, "status":True, "name":"xiaofeng","email":"@xiaofeng.com"}
for i in info.items():print(i)

info = {"age":12, "status":True, "name":"xiaofeng","email":"@xiaofeng.com"}
for i in info.items():print(i[0],i[1]) # item是一個元組 (鍵，值)

info = {"age":12, "status":True, "name":"xiaofeng","email":"@xiaofeng.com"}
for i,j in info.items():print(i,j) #i代表鍵，j代表值，將兼職從元組中直接拆分出來了。

設置值

info = {"age":12, "status":True, "name":"xiaofeng"}
print(info)
info.setdefault("h",180)
print(info)

更新字典鍵值對

info = {"age":12, "status":True, "name":"xiaofeng"}
print(info)
info.update({"name":'zhang'})
print(info)

移除指定鍵值對

info = {"age":12, "status":True, "name":"xiaofeng"}
info.pop('age')

按照順序移除（后進先出）
```
info = {"age":12, "status":True, "name":"xiaofeng"}
data=info.popitem()
print(data)
print(info)
```
- py3.6后，popitem移除最后一個位置的值。
- py3.6之前，popitem隨機刪除。

# 練習題
""" 
結合下面的兩個變量 header 和 stock_dict實現注意輸出股票信息，格式如下：SH601778，股票名稱:中國晶科、當前價:6.29、漲跌額:+1.92。SH688566，股票名稱:吉貝爾、當前價:...               。...
"""
header = ['股票名稱', '當前價', '漲跌額']stock_dict = {'SH601778': ['中國晶科', '6.29', '+1.92'], 'SH688566': ['吉貝爾', '52.66', '+6.96'], 'SH688268': ['華特氣體', '88.80', '+11.72'], 'SH600734': ['實達集團', '2.60', '+0.24']
}

7.3 公共功能

求并集（Python3.9新加入）

d1={"k1":1,"k3":3}
d2={"k3":3,"k4":4}
print(d1|d2)

長度
```
d1={"k1":1,"k3":3}
print(len(d1))
```

是否包含

d1={"k1":1,"k3":3}
print("k1" in d1)
print("k1" in d1.keys())
print(1 in d1.values())
print(("k3",3) in d1.items())

索引（鍵）字典不同于元組和列表，字典的索引是鍵，而列表和元組則是?0、1、2等數值?。
```
d1={"k1":1,"k3":3}
print(d1["k1"])
print(d1.get("k1"))
```
根據?鍵 修改值 和 添加值 和 刪除鍵值對 上述示例通過鍵可以找到字典中的值，通過鍵也可以對字典進行添加和更新操作
```
d={"k1":3,"k2":2}
d["k3"]=3 #添加
print(d)
d["k1"]=4 #通過鍵進行更新
print(d)
del d["k2"] #通過鍵進行刪除
print(d)
```

for循環由于字典也屬于是容器，內部可以包含多個鍵值對，可以通過循環對其中的：鍵、值、鍵值進行循環；

info = {"age":12, "status":True, "name":"xiaofeng","email":"@xiaofeng.com"}
for i in info.items():print(i)

info = {"age":12, "status":True, "name":"xiaofeng","email":"@xiaofeng.com"}
for i in info.keys():print(i)

info = {"age":12, "status":True, "name":"xiaofeng","email":"@xiaofeng.com"}
for i in info.values():print(i)

info = {"age":12, "status":True, "name":"xiaofeng","email":"@xiaofeng.com"}
for i,j in info.items():print(i,j) #i代表鍵，j代表值，將兼職從元組中直接拆分出來了。

7.4 轉換

想要轉換為字典.

v = dict([("k1", "v1"), ["k2", "v2"]])
print(v)

info = { "age":12, "status":True, "name":"xiaofeng" }
v1 = list(info)
v2 = list(info.keys())
#以上這兩種是相同的結果 ['age', 'status', 'name']
v3 = list(info.values())
#[12, True, 'xiaofeng']
v4 = list(info.items())
#[('age', 12), ('status', True), ('name', 'xiaofeng')]

7.5 其他

1.5.1 存儲原理

????????Python的字典通過哈希函數和哈希表的結構，實現了高效的鍵值對存儲和查找，平均情況下字典操作的時間復雜度為O(1)，即具有很高的性能。

1.5.2 速度快

1.5.3 嵌套

我們已學了很多數據類型，在涉及多種數據類型之間的嵌套時，需注意一下幾點：

字典的鍵必須可哈希（list/set/dict不可哈希）。
info = {(11,22):123
}
# 錯誤
info = {(11,[11,22,],22):"alex"
}
字典的值可以是任意類型。
info = {"k1":{12,3,5},"k2":{"xx":"x1"}
}
字典的鍵和集合的元素在遇到布爾值和 1、0 時，需注意重復的情況。

PS:元組的元素不可以被替換。

8.浮點型（float）

浮點型，一般在開發中用于表示小數。

v1 = 3.14
v2 = 9.89

關于浮點型的其他知識點如下：

在類型轉換時需要，在浮點型轉換為整型時，會將小數部分去掉。
```
print(int(3.14))
```

想要保留小數點后N位

v1 = 3.1415926
result = round(v1,3)
print(result) # 3.142

浮點型的坑（所有語言中）

print(0.1+0.2)  #0.30000000000000004

底層原理視頻：float浮點型底層存儲原理【0.1+0.2 不等于 0.3，不服來戰】_嗶哩嗶哩_bilibili

在項目中如果遇到精確的小數計算應該怎么辦？

import decimalv1 = decimal.Decimal("0.1")
v2 = decimal.Decimal("0.2")
v3 = v1 + v2
print(v3) # 0.3
#為什么普通浮點數計算 0.1 + 0.2 不精確？?
?二進制浮點數的局限性?：
Python 的 float 類型基于 IEEE 754 標準，用二進制表示小數。
0.1 和 0.2 在二進制中是無限循環小數（類似 1/3 在十進制中的情況），導致存儲時被截斷，引發精度丟失。
?十進制算術?：
decimal.Decimal 直接以十進制格式存儲和計算數值，避免了二進制浮點的截斷誤差。
?精確表示?：
使用字符串初始化（如 Decimal("0.1")）確保值在構造時無精度損失。
（若用 Decimal(0.1) 會傳遞浮點數的近似值，仍然不精確！

?本? ?篇? ?完? ?結? ?…? …

持? ? ?續? ? ?更? ? ?新? ? ?中???…? ? …?