python數據類型之字符串、字典、元組

一、數字類型

1、number類型

Python Number 數據類型用于存儲數值。

數據類型是不允許改變的,這就意味著如果改變 Number 數據類型的值，將重新分配內存空間。

以下實例在變量賦值時 Number 對象將被創建：

var1 = 1
var2 = 10

也可以使用del語句刪除一些 Number 對象引用。

del語句的語法是：

del var1[,var2[,var3[....,varN]]]]

可以通過使用del語句刪除單個或多個對象，例如：

del var
del var_a, var_b

Python 支持四種不同的數值類型：

整型(Int)?- 通常被稱為是整型或整數，是正或負整數，不帶小數點。
在Python 3里，只有一種整數類型 int，表示為長整型，沒有 python2 中的 Long。

Python可以處理任意大小的整數，當然包括負整數，在程序中的表示方法和數學上的寫法一模一樣，例如：1，100，-8080，0，等等。

計算機由于使用二進制，所以，有時候用十六進制表示整數比較方便，十六進制用0x前綴和0-9，a-f表示，例如：0xff00，0xa5b4c3d2，等等。

對于很大的數，例如10000000000，很難數清楚0的個數。Python允許在數字中間以_分隔，因此，寫成10_000_000_000和10000000000是完全一樣的。十六進制數也可以寫成0xa1b2_c3d4。
長整型(long integers)?- 無限大小的整數，整數最后是一個大寫或小寫的L。
浮點型(floating point real values)?- 浮點型由整數部分與小數部分組成，浮點型也可以使用科學計數法表示（2.5e2 = 2.5 x 102?= 250），
浮點數也就是小數，之所以稱為浮點數，是因為按照科學記數法表示時，一個浮點數的小數點位置是可變的，比如，1.23x109和12.3x108是完全相等的。浮點數可以用數學寫法，如1.23，3.14，-9.01，等等。但是對于很大或很小的浮點數，就必須用科學計數法表示，把10用e替代，1.23x109就是1.23e9，或者12.3e8，0.000012可以寫成1.2e-5，等等。

整數和浮點數在計算機內部存儲的方式是不同的，整數運算永遠是精確的（除法難道也是精確的？是的！），而浮點數運算則可能會有四舍五入的誤差。
復數(complex numbers)?- 復數由實數部分和虛數部分構成，可以用a + bj,或者complex(a,b)表示，復數的實部a和虛部b都是浮點型。

int	long	float	complex
10	51924361L	0.0	3.14j
100	-0x19323L	15.20	45.j
-786	0122L	-21.9	9.322e-36j
080	0xDEFABCECBDAECBFBAEl	32.3+e18	.876j
-0490	535633629843L	-90.	-.6545+0J
-0x260	-052318172735L	-32.54e100	3e+26J
0x69	-4721885298529L	70.2-E12	4.53e-7j

長整型也可以使用小寫"L"，但是還是建議您使用大寫"L"，避免與數字"1"混淆。Python使用"L"來顯示長整型。
Python還支持復數，復數由實數部分和虛數部分構成，可以用a + bj,或者complex(a,b)表示，復數的實部a和虛部b都是浮點型

2、浮點型（float）

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

v1 = 3.14
v2 = 9.89

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

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

想要保留小數點后N位

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

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

v1 = 0.1
v2 = 0.2
print(v1 + v2) # 0.30000000000000004

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

import decimalv1 = decimal.Decimal("0.1")
v2 = decimal.Decimal("0.2")
v3 = v1 + v2
print(v3) # 0.3

3、數字類型轉換

對數據內置的類型進行轉換，數據類型的轉換，只需要將數據類型作為函數名即可。

int(x)?將x轉換為一個整數。
float(x)?將x轉換到一個浮點數。
complex(x)?將x轉換到一個復數，實數部分為 x，虛數部分為 0。
complex(x, y)?將 x 和 y 轉換到一個復數，實數部分為 x，虛數部分為 y。x 和 y 是數字表達式。

以下實例將浮點數變量 a 轉換為整數：

>>> a = 1.0
>>> int(a)
1

4、數字運算

二、字符串

1、字符串格式化

https://www.cnblogs.com/wupeiqi/articles/5484747.html

三、None類型

None也是一個數據類型，只有一個值就是None，意味著表是空，相當于其他語言 null 一樣

一定程度上可以幫我們節省內存

v1 = []v1 = ['a','b']# 使用None初始化
v1 = Nonev1 = ['a','b']

None可以自動轉化成布爾值為false

v1 = None
if v1:print("test")
else:print("do...")  # 執行if None:pass

目前所有轉換為布爾值為False的值有：

0
""
[] or list()
() or tuple()
set()
None

四、字典

1、定義字典

字典是有序（3.6+以前無序）、鍵不重復?且元素只能是鍵值對的可變的?個?容器。鍵不重復，重復則會被覆蓋

如下定義一個字典

# 使用大括號 {} 來創建空字典
test_dic1 = {}
# 使用內建函數 dict() 創建字典：
test_dic2 = dict()
# 創建有值得字典
info = {"age": 12,"status": True,"name": "測試","hobby": ['籃球', '足球'],(11, 22, 33): ["alex", "eric"],True: 5,12: 10
}# 打印字典
print(info)  # {'age': 12, 'status': True, 'name': '測試', 'hobby': ['籃球', '足球'], (11, 22, 33): ['alex', 'eric'], True: 5, 12: 10}
# 查看字典大小
print(len(info))  # 7
# 字典類型
print(type(info))  # <class 'dict'>

字典中對鍵值得要求：

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

如下的字典是不合法的

# 不合法
v1 = {[1, 2, 3]: '周杰倫',"age" : 18
} 
v2 = {{1,2,3}: "哈哈哈",'name':"alex"
} v3 = {{"k1":123,"k2":456}: '呵呵呵',"age":999
}

?注意：字典里如何一個key是1或0，另一個是True或False,會替換掉，如下?


test = {1: 5, True: 6}
print(test)  # 打印結果是{1: 6}

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

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

# 用戶列表
user_list = [ ("alex","123"), ("admin","666") ]
# 用戶列表 字典表示
user_list = [ {"name":"alex","pwd":"123"}, {"name":"eric","pwd":"123"} ]

2、獲取字典值

info = {"age": 12,"status": 0,"name": "測試","data": None
}# 獲取值
name = info.get("name")
email = info.get("email")  # 如果鍵不存在返回 None
data = info.get("data")  # 注意:如果值是None 返回結果就是值Noneif name:print("鍵name存在，值是", name)  # 打印
if email:print("鍵email存在，值是", email)  # 不打印
if data:print("鍵data存在，值是", data)  # 不打印

3、所有鍵

info = {"age": 12,"status": 0,"name": "測試","data": None
}# 所有鍵
keys = info.keys()
print(keys)'''
python3輸出 dict_keys(['age', 'status', 'name', 'data'])
但是python2輸出['age', 'status', 'name', 'data']
Python3中返回的是高仿列表，這個高仿的列表可以被循環顯示
'''
# 循環
for ele in info.keys():print(ele)
# 當然也可以通過list將高仿的列表轉成列表
result = list(keys)
print(result)  # ['age', 'status', 'name', 'data']# 獲取所有鍵 也可以直接用for循環
for item in info:print(item)

4、是否存在鍵

info = {"age": 12,"status": 0,"name": "測試","data": None
}# 是否存在鍵
# 方式1（推薦）
if "name" in info:print("info存在鍵name")
# 方式2
if "name" in info.keys():print("info存在鍵name")

5、所有值

info = {"age": 12,"status": 0,"name": "測試","data": None
}# 所有值
values = info.values()
print(values)
'''
python3輸出 dict_values([12, 0, '測試', None])
python2輸出 [12, 0, '測試', None]
python3輸出高仿列表這個高仿的列表可以被循環顯示
'''
# 循環
for v in values:print(v)# 當然通過list可以將高仿列表轉成列表
value1 = list(values)
print(value1)

6、是否存在值

info = {"age": 12,"status": 0,"name": "測試","data": None
}# 是否存在值
if "測試" in info.values():print("info 存在值 測試")

7、所有鍵值對

info = {"age": 12,"status": 0,"name": "測試","data": None
}# 所有的鍵值
item1 = info.items()
print(item1)  # dict_items([('age', 12), ('status', 0), ('name', '測試'), ('data', None)])for item in info.items():print(item[0], item[1])  # item是一個元組 (鍵，值)for key, value in info.items():print(key, value)  # key代表鍵，value代表值，將鍵和值從元組中直接拆分出來了。

8、是否存在鍵值對

info = {"age": 12,"status": 0,"name": "測試","data": None
}
# 是否存在鍵值
if ('age', 12) in info.items():print("在")
else:print("不在")

9、設置值

info = {"age": 12,"status": 0,"name": "測試","data": None
}
# 設置值
info.setdefault("email", "test@163.com")
print(info)  # {'age': 12, 'status': 0, 'name': '測試', 'data': None, 'email': 'test@163.com'}info.setdefault("name", "test")  # 如果鍵存在 則不設置
print(info)  # {'age': 12, 'status': 0, 'name': '測試', 'data': None, 'email': 'test@163.com'}

10、更新鍵值對

info = {"age": 12,"status": 0,"name": "測試","data": None
}
# 更新值
info.update({"age": 14, "name": "test"})  # info中沒有的鍵直接添加；有的鍵則更新值
print(info)  # {'age': 14, 'status': 0, 'name': 'test', 'data': None}

11、移除指定鍵值對

info = {"age": 12,"status": 0,"name": "測試","data": None
}
# 移除指定鍵值對
info.pop("age")
print(info)  # {'status': 0, 'name': '測試', 'data': None}

12、按照順序移除（后進先出）

info = {"age": 12,"status": 0,"name": "測試","data": None
}
# 按順序移除
data = info.popitem()
print(info)  # {'age': 12, 'status': 0, 'name': '測試'}
print(data)  # ('data', None) 被移除的被自動轉成了一個元祖

py3.6后，popitem移除最后的值。
py3.6之前，popitem隨機刪除。

13、求并集

（Python3.9新加入）

v1 = {"k1": 1, "k2": 2}
v2 = {"k2": 22, "k3": 33}v3 = v1 | v2
print(v3) # {'k1': 1, 'k2': 22, 'k3': 33}

14、索引（鍵）

字典不同于元組和列表，字典的索引是鍵，而列表和元組則是?0、1、2等數值?。?

info = {"age": 12,"status": 0,"name": "測試","data": None
}print(info["age"])  # 輸出：12
print(info["xxxx"])  # 報錯，通過鍵為索引去獲取之后時，鍵不存在會報錯（以后項目開發時建議使用get方法根據鍵去獲取值）value = info.get("xxxxx")  # None
print(value)

15、根據索引鍵修改值和添加值和刪除鍵值對

上述示例通過鍵可以找到字典中的值，通過鍵也可以對字典進行添加和更新操作?

info = {"age": 12,"status": 0,"name": "測試","data": None
}# 增加鍵值對
info["gender"] = "男"
print(info)  # {'age': 12, 'status': 0, 'name': '測試', 'data': None, 'gender': '男'}# 更新鍵值對
info["age"] = 18
print(info)  # {'age': 18, 'status': 0, 'name': '測試', 'data': None, 'gender': '男'}# 刪除鍵值對
del info["age"]  # 刪除info字典中鍵為age的那個鍵值對（鍵不存在則報錯）
print(info)  # 輸出： {'status': 0, 'name': '測試', 'data': None, 'gender': '男'}

16、轉換

v = dict([("k1", "v1"), ["k2", "v2"]])print(v)  # { "k1":"v1", "k2":"v2" }
info = {"age": 12, "status": True, "name": "test"}
v1 = list(info)  # ["age","status","name"]
v2 = list(info.keys())  # ["age","status","name"]
v3 = list(info.values())  # [12,True,"test"]
v4 = list(info.items())  # [ ("age",12), ("status",True), ("name","test") ]

17、嵌套

# 字典的鍵必須可哈希（list/set/dict不可哈希）
info = {(11, 22): 123
}# 錯誤
info = {(11, [11, 22, ], 22): "alex"
}# 字典的值可以是任意類型
info = {"k1": {12, 3, 5},"k2": {"xx": "x1"}
}# 字典的鍵和集合的元素在遇到 布爾值 和 1、0 時，需注意重復的情況。如下實際為1:3
info = {1: 0,True: 3
}
# 元組的元素不可以被替換
dic = {'name': 'test','age': 48,'wife': [{'name': 'aaa', 'age': 38}, {'name': 'bbb', 'age': 48}],'children': ['第一個娃', '第二個娃']
}
"""
1. 獲取test的妻子名字d1 = dic['wife'][0]['name']print(d1)
2. 獲取test的孩子們d2 = dic['children']print(d2)
3. 獲取test的第一個孩子d3 = dic['children'][0]print(d3)
4. test的媳婦姓名變更為 cccdic['wife'][0]['name'] = "ccc"print(dic)
5. test再娶一任妻子dic['wife'].append( {"name":"鐵錘","age":19} )print(dic)6. 給test添加一個愛好：吹牛逼dic['hobby'] = "吹牛逼"print(dic)
7. 刪除test的年齡del dic['age']或dic.pop('age')print(dic)
"""

五、元組

1、定義

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

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

Python 的元組與列表類似，不同之處在于元組的元素不能修改。

元組使用小括號?( )，列表使用方括號?[ ]。

元組創建很簡單，只需要在括號中添加元素，并使用逗號隔開即可。

tup1 = ('Google', 'Runoob', 1997, 2000)
tup2 = (1, 2, 3, 4, 5 )
tup3 = "a", "b", "c", "d" ? # ?不需要括號也可以

創建空元組

tup1 = ()

建議在元組的最后多加一個逗號，用于標識他是一個元組。特別是元組中只包含一個元素時，需要在元素后面添加逗號?,?，否則括號會被當作運算符使用：

>>> tup1 = (50)
>>> type(tup1) ? ? # 不加逗號，類型為整型
<class 'int'>>>> tup1 = (50,)
>>> type(tup1) ? ? # 加上逗號，類型為元組
<class 'tuple'>

元組與字符串類似，下標索引從 0 開始，可以進行截取，組合等。?

user_list = ("范德彪","劉華強",'尼古拉斯趙四',)
print( user_list[0] )
print( user_list[2] )
print( user_list[3] )#切片
print( user_list[0:2] )
print( user_list[1:] )
print( user_list[:-1] )#步長演示
user_list = ("范德彪","劉華強",'尼古拉斯趙四',"宋小寶","劉能")
print( user_list[1:4:2] )
print( user_list[0::2] )
print( user_list[1::2] )
print( user_list[4:1:-1] )

2、訪問元組

元組可以使用下標索引來訪問元組中的值，如下實例:

tup1 = ('Google', 'Runoob', 1997, 2000)
tup2 = (1, 2, 3, 4, 5, 6, 7 )print ("tup1[0]: ", tup1[0])
print ("tup2[1:5]: ", tup2[1:5])結果
tup1[0]:  Google
tup2[1:5]:  (2, 3, 4, 5)

3、獲取長度

user_list = ("范德彪","劉華強",'尼古拉斯趙四',)
print( len(user_list) )

4、 for循環

# in 運算符
user_list = ("范德彪","劉華強",'尼古拉斯趙四',"宋小寶","劉能")
for item in user_list:print(item)# 下標user_list = ("范德彪","劉華強",'尼古拉斯趙四',"宋小寶","劉能")
for item in user_list:if item == '劉華強':continueprint(name)#目前：只有 str、list、tuple 可以被for循環。 "xxx"  [11,22,33]  (111,22,33) 
# len + range + for + 索引
user_list = ("范德彪","劉華強",'尼古拉斯趙四',"宋小寶","劉能")
for index in range(len(user_list)):item = user_list[index]print(item)

5、修改元組

元組中的元素值是不允許修改的，但我們可以對元組進行連接組合，如下實例:

tup1 = (12, 34.56)
tup2 = ('abc', 'xyz')# 以下修改元組元素操作是非法的。
# tup1[0] = 100# 創建一個新的元組
tup3 = tup1 + tup2
print (tup3) # (12, 34.56, 'abc', 'xyz')

6、刪除元組

元組中的元素值是不允許刪除的，但我們可以使用del語句來刪除整個元組，如下實例:

#!/usr/bin/python3tup = ('Google', 'Runoob', 1997, 2000)print (tup)
del tup
print ("刪除后的元組 tup : ")
print (tup)以上實例元組被刪除后，輸出變量會有異常信息，輸出如下所示：
刪除后的元組 tup : 
Traceback (most recent call last):File "test.py", line 8, in <module>print (tup)
NameError: name 'tup' is not defined

7、元組運算符

與字符串一樣，元組之間可以使用?+、+=和?*?號進行運算。這就意味著他們可以組合和復制，運算后會生成一個新的元組。

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

data = ("趙四","劉能") + ("宋曉峰","范德彪")
print(data) # ("趙四","劉能","宋曉峰","范德彪")v1 = ("趙四","劉能")
v2 = ("宋曉峰","范德彪")
v3 = v1 + v2
print(v3) # ("趙四","劉能","宋曉峰","范德彪")

相乘，列表*整型將列表中的元素再創建N份并生成一個新的列表。

data = ("趙四","劉能") * 2
print(data) # ("趙四","劉能","趙四","劉能")v1 = ("趙四","劉能")
v2 = v1 * 2
print(v1) # ("趙四","劉能")
print(v2) # ("趙四","劉能","趙四","劉能")

8、元組索引，截取

因為元組也是一個序列，所以我們可以訪問元組中的指定位置的元素，也可以截取索引中的一段元素，如下所示：元組：>>> tup = ('Google', 'Runoob', 'Taobao', 'Wiki', 'Weibo','Weixin')
>>> tup[1]
'Runoob'
>>> tup[-2]
'Weibo'
>>> tup[1:]
('Runoob', 'Taobao', 'Wiki', 'Weibo', 'Weixin')
>>> tup[1:4]
('Runoob', 'Taobao', 'Wiki')
>>>

?9、轉換

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

name = "測試"
data = tuple(name)
print(data) # 輸出 ("測","試")name = ["測試",18,"pythonav"]
data = tuple(name)
print(data) # 輸出 ("測試",18,"pythonav")

10、嵌套

由于元組和列表都可以充當容器，他們內部可以放很多元素，并且也支持元素內的各種嵌套。?

tu = ( 'a', 'b', ('c','d') )
tu1 = tu[0]
tu2 = tu[1]
tu3 = tu[2][0]
tu4 = tu[2][1]
tu5 = tu[2][1][3]print(tu1) # a
print(tu2) # b
print(tu3) # c
print(tu4) # d

11、關于元組是不可變的

所謂元組的不可變指的是元組所指向的內存中的內容不可變。

>>> tup = ('r', 'u', 'n', 'o', 'o', 'b')
>>> tup[0] = 'g' ? ? # 不支持修改元素
Traceback (most recent call last):File "<stdin>", line 1, in <module>
TypeError: 'tuple' object does not support item assignment
>>> id(tup) ? ? # 查看內存地址
4440687904
>>> tup = (1,2,3)
>>> id(tup)
4441088800 ? ?# 內存地址不一樣了

從以上實例可以看出，重新賦值的元組 tup，綁定到新的對象了，不是修改了原來的對象。