python3 的八大數據類型

python3數據類型主要分為八大類：

• Numbers（數字）（整型int、浮點型float）
• String（字符串）
• List（列表）
• Tuple（元組）
• Dictionary（字典）
• Set（集合）
• bool（布爾）

可變類型與不可變類型

可變數據類型：值發生改變時，內存地址不變，即id不變，證明在改變原值。如：列表，字典
不可變類型：值發生改變時，內存地址也發生改變，即id也變，證明是沒有在改變原值，是產生了新的值。如：整型、字符串

1、數字類型：

python3的數字類型包括：

• int，initeger（長整型）
• float（浮點型）
• complex（復數）
• bool（布爾型）

Python3 中，bool 是 int 的子類，True 和 False 可以和數字相加， True==1、False==0 會返回 True，但可以通過 is 來判斷類型。

>>> issubclass(bool, int) 
True
>>> True==1
True
>>> False==0
True
>>> True+1
2
>>> False+1
1
>>> 1 is True
False
>>> 0 is False
False

可用type和isinstance(x,y)進行判斷

>>> a=12

>>> type(a)
<class 'int'>

>>> isinstance(a,int)
True

關於輸出兩位小數的補充

方式1: 使用字符串的 format 方法

price = 10.56789
formatted_price = "{:.2f}".format(price)
print(formatted_price)  # 輸出：10.57

方式2: 使用 f-string 格式化字符串（Python 3.6+）

price = 10.56789
formatted_price = f"{price:.2f}"
print(formatted_price)  # 輸出：10.57

方式3: 使用 % 運算符

price = 10.56789
formatted_price = "%.2f" % price
print(formatted_price)  # 輸出：10.57

2、字符串 string

字符串用單引號 ' 或雙引號 " 括起來，同時使用反斜杠 \ 轉義特殊字符。

加號 + 是字符串的連接符， 星號 * 表示復制當前字符串，與之結合的數字為復制的次數，同時支持索引截取

str = 'Runoob'
print (str)          # 輸出字符串
print (str[0:-1])    # 輸出第一個到倒數第二個的所有字符
print (str[0])       # 輸出字符串第一個字符
print (str[2:])      # 輸出從第三個開始的后的所有字符
print (str * 2)      # 輸出字符串兩次，也可以寫成 print (2 * str)
print (str + "TEST") # 連接字符串

部分內置方法：

.strip()方法可以用於去除字符串兩端的空白字符(包括空格、制表符、換行符等)。它會返回去除空白字符的新字符串。

.join()方法，將可迭代的對象，迭代后使用指定的字符進行拼接

hobby = ['hejiu', 'chouyan', 'majiang']
a = ', '.join(hobby)
print(a, type(a)) # hejiu, chouyan, majiang <class 'str'>

str的內置方法中.is開頭的都是判斷，返回布爾值。如：

• str.isalnum() 所有字符都是數字或者字母
• str.isalpha() 所有字符都是字母
• str.isdigit() 所有字符都是數字
• str.isspace() 所有字符都是空白字符、t、n、r

3、列表 list

 Python 中使用最頻繁的數據類型。

列表可以完成大多數集合類的數據結構實現。列表中元素的類型可以不相同，它支持數字，字符串甚至可以包含列表（所謂嵌套）。

列表是寫在方括號 [ ] 之間、用逗號分隔開的元素列表。

和字符串一樣，列表同樣可以被索引和截取，列表被截取后返回一個包含所需元素的新列表。

列表截取的語法格式如下：

注意：帶-的下標，list[:-3]表示從左邊-3索引位置開始到結束，list也支持：+ 列表連接運算符， *  重復操作。

list = [ 'abcd', 786 , 2.23, 'runoob', 70.2 ]
tinylist = [123, 'runoob']

print (list[:-3])       # 從第二個開始輸出到第三個元素
print (list[2:])        # 輸出從第三個元素開始的所有元素
print (tinylist * 2)    # 輸出兩次列表
print (list + tinylist) # 連接列表

注意：

• List寫在方括號之間，元素用逗號隔開。
• 和字符串一樣，list可以被索引和切片。
• List可以使用+操作符進行拼接。
• List中的元素是可以改變的（支持很多方法來增刪改查）。

list的內置方法

extend 

將一個可迭代對象一次性擴充到一個列表中

list.extend(iterable)

4、元組 tuple

元組（tuple）與列表類似，可以理解為： 不可修改元素的list。元組寫在小括號 () 里，元素之間用逗號隔開。元組中的元素類型也可以不相同：

tuple = ( 'abcd', 786 , 2.23, 'runoob', 70.2  )
tinytuple = (123, 'runoob')

print (tuple[2:])         # 輸出從第三個元素開始的所有元素
print (tinytuple * 2)     # 輸出兩次元組
print (tuple + tinytuple) # 連接元組

雖然tuple的元素不可改變，但它可以包含可變的對象，比如list列表。

構造包含 0 個或 1 個元素的元組比較特殊，所以有一些額外的語法規則：

tup1 = ()    # 空元組
tup2 = (20,) # 一個元素，需要在元素后添加逗號

注意：

• 1、與字符串一樣，元組的元素不能修改。
• 2、元組也可以被索引和切片，方法一樣。
• 3、注意構造包含 0 或 1 個元素的元組的特殊語法規則。
• 4、元組也可以使用+操作符進行拼接。

5、字典 dictionary

列表是有序的對象集合，字典是無序的對象集合。兩者之間的區別在於：字典當中的元素是通過鍵來存取的，而不是通過偏移存取。

字典是一種映射類型，字典用 { } 標識，它是一個無序的 鍵(key) : 值(value) 的集合。

鍵(key)必須使用不可變類型。在同一個字典中，鍵(key)必須是唯一的。

dict = {}
dict['one'] = "1111"
dict[2]     = "2222"

tinydict = {'name': 'runoob','code':1, 'site': 'www.runoob.com'}

print (dict['one'])       # 輸出鍵為 'one' 的值
print (dict[2])           # 輸出鍵為 2 的值
print (tinydict)          # 輸出完整的字典
print (tinydict.keys())   # 輸出所有鍵
print (tinydict.values()) # 輸出所有值

注意：

• 字典是一種映射類型，它的元素是鍵值對。
• 字典的關鍵字必須為不可變類型，且不能重復。
• 創建空字典使用 { }。

字典解包補充{**dict1} 

Python中，{**dict1} 是一種字典解包的用法，它允許將一個字典 dict1 解包成一個新的字典。

dict1 = {'a': 1, 'b': 2}
dict2 = {'c': 3, 'd': 4}

merged_dict = {**dict1, **dict2}
print(merged_dict) #{'a': 1, 'b': 2, 'c': 3, 'd': 4}

字典的內置方法

.get() (# ps:字典取值建議使用get方法)

>>> dic= {'k1':'jason','k2':'Tony','k3':'JY'}
>>> dic.get('k1')
'jason'                    # key存在，則獲取key對應的value值
>>> res=dic.get('xxx')     # key不存在，不會報錯而是默認返回None
>>> print(res)
None  
>>> res=dic.get('xxx',666) # key不存在時，可以設置默認返回的值
>>> print(res)
666 

.pop()

>>> dic= {'k1':'jason','k2':'Tony','k3':'JY'}
>>> v = dic.pop('k2')  # 刪除指定的key對應的鍵值對,並返回值
>>> dic
{'k1': 'jason', 'kk2': 'JY'}
>>> v
'Tony'

.popitem()

>>> dic= {'k1':'jason','k2':'Tony','k3':'JY'}
>>> item = dic.popitem()  # 隨機刪除一組鍵值對,並將刪除的鍵值放到元組內返回
>>> dic
{'k3': 'JY', 'k2': 'Tony'}
>>> item
('k1', 'jason')

.update()

 # 用新字典更新舊字典，有則修改，無則添加

>>> dic= {'k1':'jason','k2':'Tony','k3':'JY'}
>>> dic.update({'k1':'JN','k4':'xxx'})
>>> dic
{'k1': 'JN', 'k3': 'JY', 'k2': 'Tony', 'k4': 'xxx'}

支持只更新其中一部分的 v 值

my_dict = {'key1': 'value1', 'key2': 'value2', 'key3': 'value3'}

# 更新字典中的 'key2' 鍵的值
my_dict.update({'key2': 'new_value'})

# 輸出更新后的字典
print(my_dict)
# 輸出: {'key1': 'value1', 'key2': 'new_value', 'key3': 'value3'}

# 更新字典中的 'key4' 鍵的值
my_dict.update({'key4': 'new_value'})

# 輸出更新后的字典
print(my_dict)
# 輸出: {'key1': 'value1', 'key2': 'new_value', 'key3': 'value3', 'key4': 'new_value'}

.fromkeys()

>>> dic = dict.fromkeys(['k1','k2','k3'],[])
>>> dic
{'k1': [], 'k2': [], 'k3': []}

.setdefault()

# key不存在則新增鍵值對，並將新增的value返回
>>> dic={'k1':111,'k2':222}
>>> res=dic.setdefault('k3',333)
>>> res
333
>>> dic # 字典中新增了鍵值對
{'k1': 111, 'k3': 333, 'k2': 222}

# key存在則不做任何修改，並返回已存在key對應的value值
>>> dic={'k1':111,'k2':222}
>>> res=dic.setdefault('k1',666)
>>> res
111
>>> dic # 字典不變
{'k1': 111, 'k2': 222}

關於字典的補充

字典的key值必須可hash，即字典的key值必須是不可變數據類型

redis hash 類型無序，跟放的先后順序無關的

python 的字典是 有序的 字典+列表

6、集合 set

集合（set）是一個無序的不重復元素序列。可以使用大括號 { } 或者 set() 函數創建集合。構成集合的事物或對象稱作元素或是成員

基本功能是進行成員關系測試和刪除重復元素。

注意：創建一個空集合必須用 set() 而不是 { }，因為 { } 是用來創建一個空字典。

創建格式

parame = {value01,value02,...}
或者
set(value)

集合（set）是由一個或數個形態各異的大小整體組成的，構成集合的事物或對象稱作元素或是成員。

基本功能是進行成員關系測試和刪除重復元素。

可以使用大括號 { } 或者 set() 函數創建集合，注意：創建一個空集合必須用 set() 而不是 { }，因為 { } 是用來創建一個空字典。

注：所有的數據類型創建空時候，都可以用單詞名稱+()，如 set()，list(), dict()

集合的內置方法

# 1.合集/並集(|)：求兩個用戶所有的好友（重復好友只留一個）
>>> friends1 | friends2
{'kevin', 'ricky', 'zero', 'ly', 'Jy', 'qq'}

# 2.交集(&)：求兩個用戶的共同好友
>>> friends1 & friends2
{'ly', 'qq'}

# 3.差集(-)：
>>> friends1 - friends2 # 求用戶1獨有的好友
{'kevin', 'zero'}
>>> friends2 - friends1 # 求用戶2獨有的好友
{'ricky', 'Jy'}

# 4.對稱差集(^) # 求兩個用戶獨有的好友們（即去掉共有的好友）
>>> friends1 ^ friends2
{'kevin', 'zero', 'ricky', 'Jy'}

# 5.值是否相等(==)
>>> friends1 == friends2
False

# 6.父集：一個集合是否包含另外一個集合
# 6.1 包含則返回True
>>> {1,2,3} > {1,2}
True
>>> {1,2,3} >= {1,2}
True
# 6.2 不存在包含關系，則返回False
>>> {1,2,3} > {1,3,4,5}
False
>>> {1,2,3} >= {1,3,4,5}
False

# 7.子集
>>> {1,2} < {1,2,3}
True
>>> {1,2} <= {1,2,3}
True

集合去重會打亂順序，寫一個代碼實現既去重又保留之前的順序

# 針對不可變類型，並且保證順序則需要我們自己寫代碼實現，例如
l=[
    {'name':'lili','age':18,'sex':'male'},
    {'name':'jack','age':73,'sex':'male'},
    {'name':'tom','age':20,'sex':'female'},
    {'name':'lili','age':18,'sex':'male'},
    {'name':'lili','age':18,'sex':'male'},
]

new_l=[]

for dic in l:
    if dic not in new_l:
        new_l.append(dic)

print(new_l)
# 結果：既去除了重復，又保證了順序，而且是針對不可變類型的去重
[
    {'age': 18, 'sex': 'male', 'name': 'lili'}, 
    {'age': 73, 'sex': 'male', 'name': 'jack'}, 
    {'age': 20, 'sex': 'female', 'name': 'tom'}
]