我和Python的Py交易》》》》》》數據類型

時間 2019-11-26

原文原文鏈接

Python裏的變量 ---門牌

Python在使用變量以前無須定義它的類型，可是必須聲明以及初始化該變量。html

Python中給變量賦值就是聲明，初始化變量(也就是建立一個相應數據類型的對象，而那些數據類型就是類)，變量的類型是取決於其儲存的數據。（下面代碼中的a變量，其類型類型隨着賦值的類型不一樣而改變）python

#type(a)返回a的數據類型
a=1
print(type(a),'整型')

a=1.1
print(type(a),'浮點型')

a=True
print(type(a),'布爾類型')

a=''
print(type(a),'字符串類型')

a=['牀前明月光','地上鞋兩雙']
print(type(a),'列表')

a=(123,123)
print(type(a),'元組')

a={'好詩':'舉頭望明月，低頭思故鄉','好溼':'牀前明月光，地上鞋兩雙'}
print(type(a),'字典')

a={12345,'上山打老虎'}
print(type(a),'集合')


# <class 'int'> 整型
# <class 'float'> 浮點型
# <class 'bool'> 布爾類型
# <class 'str'> 字符串類型
# <class 'list'> 列表
# <class 'tuple'> 元組
# <class 'dict'> 字典
# <class 'set'> 集合

數據類型

Python3 中經常使用的數據類型：app

不可變數據類型
Number（數字）
String（字符串）
Tuple（元組）
可變數據類型
List（列表）
Dictionary（字典）
Sets（集合）

數據類型類型可分爲：可變數據類型，不可變數據類型。ide

可變數據類型是指一個ID地址中儲存的數據是能夠改變的。函數

不可變數據類型是指一個ID地址中儲存的數據不能夠改變。測試

一，Number(數字)----不可變數據類型

1.int（整型）

int類型就是整數google

Python的2.x的版本中還存在Long長整型（表示比較長的整數（比較大OR比較小）），3.x的版本中就只有int整型spa

整型類型能表達的數值僅僅與你的機器支持的（虛擬）內存大小有關，換句話說，Python能輕鬆表達很大的整數。3d

（嘿嘿，本身去算算對不對）code

2.float（浮點數）

咱們暫時的把浮點數理解爲帶小數點的小數（我還會開單章來講說浮點數）

浮點數隨筆連接

3.bool（布爾類型）

把 True 和 False 定義成關鍵字了，但它們的值仍是 1 和 0，它們能夠和數字相加

注意：

一、Python能夠同時爲多個變量賦值，如a, b = 1, 2。
二、一個變量能夠經過賦值指向不一樣類型的對象。
三、數值的除法 / 老是返回一個浮點數，要獲取整數使用 // 操做符（ // 是以捨去小數部分來取整的）。
四、在混合計算時，Python會把整型轉換成爲浮點數。

Python還支持complex（複數），複數由實數部分和虛數部分構成，能夠用a + bj,或者complex(a,b)表示，複數的實部a和虛部b都是浮點型。

二，String（字符串）----不可變數據類型

字符串是以單引號 ' or雙引號 " or三引號 ''' 括起來的任意文本（用來括起文本的單引號，雙引號，三引號並非文本里的字符），例如：'追求喜歡的女孩’,「有機會要追求」，‘’’沒有機會，創造機會也要追求‘‘’

當有屬於文本中的單引號 ’ ，就須要用雙引號把文本括起來；當有屬於文本中的雙引號 "，就須要用三引號把文本括起來。（當引號爲文本時要用引號多的把引號少的括起來）

三引號能夠把多行字符串括起來

使用反斜槓 \ 轉義特殊字符，若是你不想讓反斜槓發生轉義，能夠在字符串前面添加一個 r，表示原始字符串：

>>>print('L\ove')
L
ove
>>> print(r'L\ove')
L\ove
>>>

字符串的操做

[ ],[ : ],[ : : ]經過索引能夠進行切片操做，和列表同樣（在列表時會詳細講）

加號 (+) 是字符串的鏈接符，星號 (*) 表示複製當前字符串，緊跟的數字爲複製的次數。

str = 'I Love'
print((str+'You ')*4)

#輸出 I LoveYou I LoveYou I LoveYou I LoveYou

注意

Python 沒有單獨的字符類型，一個字符就是長度爲1的字符串。

與 C 字符串不一樣的是，Python 字符串不能被改變。向一個索引位置賦值，好比word[0] = ‘m’會致使錯誤。

三，tuple（元組）----不可變數據類型

元組被稱爲只讀列表，即數據能夠被查詢，但不能被修改，因此，列表的切片操做一樣適用於元組。

元組寫在小括號 () 裏，元素之間用逗號隔開。

同一個元組中，元素能夠是不一樣的（元素能夠爲任意類型）

雖然tuple的元素不可改變，但它的元素能夠爲可變數據類型，好比list列表。（如今不理解不要緊，在後面解釋可變與不可變數據類型中會有詳細解釋）

tup =([11,22,33], ['無邊落木蕭蕭下', 44])
a=tup[1]
b=[11,22,33]
print(id(a))
print(id(tuple[1]))
print(id(b))
#輸出結果
#31469064
#31469064
#31927176

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

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

做用：

1 對於一些數據咱們不想被修改，可使用元組；

2 另外，元組的意義還在於，元組能夠在映射（和集合的成員）中看成鍵使用——而列表則不行；元組做爲不少內建函數和方法的返回值存在。

四， List（列表）----可變數據類型

列表（list）是使用使用中括號 [ ] 來解析列表。

經過列表能夠對數據實現最方便的存儲、修改等操做

定義列表

a = ['錦','瑟','無','端','五','十','弦']  # 定義一個列表
a=list(('錦','瑟','無','端','五','十','弦'))#強制轉換

同一個列表中，元素能夠是不一樣的（元素能夠爲任意類型）

經過下標訪問列表中的元素，下標從0開始計數

增（append，insert， extend）

1.insert 方法用於將對象插入到列表中

a = ['錦', '瑟', '無', '端', '五', '十', '弦'] # 定義一個列表 a.insert(0,'就是這') print(a) # ['就是這', '錦', '瑟', '無', '端', '五', '十', '弦']

2.append方法則用於在列表末尾追加新的對象

a = ['錦', '瑟', '無', '端', '五', '十', '弦']  # 定義一個列表
a.append('最後面')
print(a)
# ['錦', '瑟', '無', '端', '五', '十', '弦', '最後面']

3.追加一個序列裏的多個元素( extend)

extend 方法能夠在列表的末尾一次性追加另外一個序列（可迭代對象，如列表，字典，元組，字符串）中的多個值。

　　 extend 方法修改了被擴展的列表，而原始的鏈接操做（+）則否則，它會返回一個全新的列表。

#列表
a = ['錦', '瑟', '無', '端', '五', '十', '弦'] b = ['一', '弦', '一', '柱', '思', '華', '年'] a.extend(b) #只是對a進行擴展，無返回值（不會產生新的列表） print(a) # ['錦', '瑟', '無', '端', '五', '十', '弦', '一', '弦', '一', '柱', '思', '華', '年'] b.extend(b) print(b) # ['一', '弦', '一', '柱', '思', '華', '年', '一', '弦', '一', '柱', '思', '華', '年']　 
#字典 a = ['一', '弦', '一', '柱', '思', '華', '年'] b = {'字典':123,'鍵':456} # 可迭代對象是字典(默認是鍵) a.extend(b) print(a) # ['一', '弦', '一', '柱', '思', '華', '年', '字典', '鍵'] 
#元組 a = ['一', '弦', '一', '柱', '思', '華', '年'] b=(1,2,3,4) a.extend(b) print(a) # ['一', '弦', '一', '柱', '思', '華', '年', 1, 2, 3, 4] 
#字符串 a = ['一', '弦', '一', '柱', '思', '華', '年'] b='abcd' a.extend(b) print(a) # ['一', '弦', '一', '柱', '思', '華', '年', 'a', 'b', 'c', 'd']

刪（remove，del，pop）

1.remove刪除以值指定的元素

a = ['錦', '瑟', '無', '端', '五', '十', '弦'] # 定義一個列表
a.remove('瑟')  # 刪除元素'瑟'，當要刪除的元素有多個相同時，刪最前面那個（就是下標最小的那個，這個函數檢索列表是從下標0開始的）
print(a)
# ['錦', '無', '端', '五', '十']

2.del刪除如下標指定的元素or整個列表

a = ['錦', '瑟', '無', '端', '五', '十', '弦'] # 定義一個列表
del a[0]   # 刪除如下標指定的元素
print(a)
# ['無', '端', '五', '十']
del a    # 刪除整個列表

3.pop刪除列表中指定下標元素，默認刪除最後一個元素，而且返回該元素的值，若是列表爲空或者索引值超出範圍會報一個異常。

# a.pop([index=-1]) a = ['一', '弦', '一', '柱', '思', '華', '年'] # 定義一個列表 b=a.pop() # 默認下標爲-1 index=-1 刪除最後一個元素  print(b) # a.pop()會返回被刪除的元素 # 弦
print(a) # ['一', '弦', '一', '柱', '思', '華'] 
a.pop(0)
print(a) # ['弦', '一', '柱', '思', '華']

改（從新賦值）

注意：列表能夠從新賦值，元組不能夠

a = ['錦', '瑟', '無', '端', '五', '十', '弦'] # 定義一個列表 a[0]=0 print(a) # [0, '瑟', '無', '端', '五', '十', '弦'] a[1]='1' print(a) # [0, '1', '無', '端', '五', '十', '弦'] a[2:4]=2,3 print(a) # [0, '1', 2, 3, '五', '十', '弦'] a[4::2]=4,7 print(a) # [0, '1', 2, 3, 4, '十', 7]

查（切片，index）

1.切片操做（列表的切片，字符串，元組的切片操做都是同樣的）

切片---取一個元素

a = ['錦','瑟','無','端','五','十','弦'] # 定義一個列表

>>> a[0]
'錦'
>>> a[6]
'弦'
>>> a[-1]
 '弦'
>>> a[-2] #還能夠倒着取
 '十

切片---取多個元素（獲得的是一個新的列表）

a = ['錦', '瑟', '無', '端', '五', '十', '弦']  # 定義一個列表

# a[起始下標:結束下標:移動的方向和步幅]

b = a[0:6]
print(b)
# ['錦', '瑟', '無', '端', '五', '十']
# a[0:6]取頭不取尾
b = a[0:]
print(b)
# ['錦', '瑟', '無', '端', '五', '十', '弦']
# a[0:]才能夠去到尾
b = a[:]
print(b)
# ['錦', '瑟', '無', '端', '五', '十', '弦']
# b = a[:]從頭取到尾

# 當a[::]的的二個 : 沒有時，咱們就默認其步幅爲1。
# 步幅: 步幅爲1時是「走一步「取一個。例如，'錦'走一步是'瑟'
#      步幅爲2時時「走兩步」取一個。例如，'錦'走兩步是'無'
# 方向：步幅爲正數時(順着取)，是由左向右走；步幅爲負數時(倒着取)，是由右向左走

b = a[0:6:2]
print(b)
# ['錦', '無', '五']
# 步幅爲2
b = a[0:-1:2]
print(b)
# ['錦', '無', '五']
b = a[6:1:-1]
print(b)
# ['弦', '十', '五', '端', '無']
# 步幅爲-2
b = a[-1:1:-2]
print(b)
# ['弦', '五', '無']

2.靠元素找下標 (index)

　　該方法能夠避免遍歷列表來找元素下標。

Python 列表 index() 方法用於從列表中找出某個對象第一個匹配項的索引位置，若是這個對象不在列表中會報一個異常。

　　index() 方法語法：

a.index(value, start, stop)

    value-- 指定檢索的對象。
    start -- 可選參數，開始索引，默認爲0。（可單獨指定）
    stop -- 可選參數，結束索引，默認爲元祖的長度。（可單獨指定）

a = ['一', '弦', '一', '柱', '思', '華', '年', '一', '弦', '一', '柱', '思', '華', '年'] b = a.index('一') print(b) # 0 b = a.index('一',1) print(b) # 2 b = a.index('弦',0,0) print(b) # b = a.index('弦',0,0) # ValueError: '弦' is not in list

其餘

1.統計( count)

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

a = ['錦', '瑟', '無', '端', '五', '十', '弦', '弦', '弦']  # 定義一個列表
b = a.count('弦')  # 統計'弦'在列表a中出現的次數
print(b)  # 3

2.翻轉(reverse)

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

該方法只是對列表操做，無返回值（不會產生新的列表）

a = ['一', '弦', '一', '柱', '思', '華', '年']
a.reverse()
print(a)  # ['年', '華', '思', '柱', '一', '弦', '一']

3.複製（copy()）

由於列表的元素能夠是可變和不可變數據類型，因此就涉及到了深淺複製

a=['錦', '瑟', '無', '端', '五', '十', '弦', '一', '弦', '一', '柱', '思', '華', '年']
b=a.copy()
print(b) # ['錦', '瑟', '無', '端', '五', '十', '弦', '一', '弦', '一', '柱', '思', '華', '年']

五，Dictionary（字典）----可變數據類型

字典是python中惟一的映射類型，採用鍵值對（key-value）的形式存儲數據。

python對key進行哈希函數運算，根據計算的結果決定value的存儲地址，因此字典是無序存儲的，且key必須是可哈希的。

可哈希表示key必須是不可變類型，如：數字、字符串、元組。

dic1={'name':'BarkingPig',(1,):[1,2,3],2:13}
dic2=dict((('name','BarkingPig'),((1,),[1,2,3]),(2,13)))

增（‘=’，setdefault()）

1.‘=’

dic = {1: '日照香爐生紫煙', 2: '遙看瀑布掛前川'}
dic[3] = '飛流直下三千尺'
print(dic)
#{1: '日照香爐生紫煙', 2: '遙看瀑布掛前川', 3: '飛流直下三千尺'}

2.添加查詢鍵值對（setdefault()）

Python 字典 setdefault() 方法和 get() 方法相似,返回指定鍵的值，若是鍵不在字典中，將會添加鍵並將值設置爲一個指定值，默認爲None。

而 get() 不會添加鍵。

dic.setdefault(key[,default=None])

key -- 字典中要查找的鍵。
default -- 可選參數，若是指定鍵的值不存在時，返回該值，默認爲 None

dic = {1: '日照香爐生紫煙', 2: '遙看瀑布掛前川'}
dic.setdefault(3)
dic.setdefault(4,'疑是銀河落九天')
print(dic)
#{1: '日照香爐生紫煙', 2: '遙看瀑布掛前川', 3: None, 4: '疑是銀河落九天'}

刪（del,pop(),clear()，popitem()）

1.刪除查詢到的鍵值對or整個字典（del）

刪除整個字典

dic = {1: '日照香爐生紫煙', 2: '遙看瀑布掛前川',3:'飛流直下三千尺',4:'疑是銀河落九天'}
del dic
print(dic)
# NameError: name 'dic' is not defined

刪除鍵對應鍵值對

dic = {1: '日照香爐生紫煙', 2: '遙看瀑布掛前川',3:'飛流直下三千尺',4:'疑是銀河落九天'}
del dic[1]
print(dic)
# {2: '遙看瀑布掛前川', 3: '飛流直下三千尺', 4: '疑是銀河落九天'}

2刪除指定鍵值對（pop()）

pop() 方法刪除給定鍵所對應的鍵/值對，並返回被刪除的值。給定鍵若是不在字典中，則必須設置一個default值，不然會報錯，此時返回的就是default值。

dic.pop(key[,default])

key: 要刪除的鍵/值對所對應的鍵
default: 可選參數，給定鍵不在字典中時必須設置，否者會報錯(沒有默認值)，此時返回default值。

dic = {1: '日照香爐生紫煙', 2: '遙看瀑布掛前川',3:'飛流直下三千尺',4:'疑是銀河落九天'}
a=dic.pop(4,True)
print(dic,a) # {1: '日照香爐生紫煙', 2: '遙看瀑布掛前川', 3: '飛流直下三千尺'} 疑是銀河落九天
a=dic.pop(5,True)
print(dic,a) # {1: '日照香爐生紫煙', 2: '遙看瀑布掛前川', 3: '飛流直下三千尺'} True

3.置空（clear()）

clear() 方法用於刪除字典內全部元素(就是把字典置空，不刪除字典)。

dic = {1: '日照香爐生紫煙', 2: '遙看瀑布掛前川',3:'飛流直下三千尺',4:'疑是銀河落九天'}
dic.clear()
print(dic) # {}

4..刪除「最後一對鍵值對」（popitem()）

popitem() 方法隨機返回並刪除字典中的一個鍵/值對（通常刪除末尾對）。

爲何是隨機刪除呢？由於字典是無序的，沒有所謂的「最後一項」或是其它順序。在工做時若是遇到須要逐一刪除項的工做，用popitem()方法效率很高。

若是字典已經爲空，卻調用了此方法，就報出KeyError異常。

dic = {1: '日照香爐生紫煙', 2: '遙看瀑布掛前川',3:'飛流直下三千尺',4:'疑是銀河落九天'}
a=dic.popitem()
print(dic,a) # {1: '日照香爐生紫煙', 2: '遙看瀑布掛前川', 3: '飛流直下三千尺'} (4, '疑是銀河落九天')

改（‘=’，update()）

1.‘=’

dic = {1: '日照香爐生紫煙', 2: '遙看瀑布掛前川',3:'飛流直下三千尺',4:'疑是銀河落九天'}
dic[1]='黃河之水天上來'
print(dic) #{1: '黃河之水天上來', 2: '遙看瀑布掛前川', 3: '飛流直下三千尺', 4: '疑是銀河落九天'}

2.改，擴展（update()）

update() 方法用於更新字典中的鍵/值對，能夠修改存在的鍵對應的值，也能夠添加新的鍵/值對到字典中

dic= {1: '日照香爐生紫煙', 'two':'遙看瀑布掛前川' }
dic.update(two='黃河之水天上來')  # 修改鍵對應的值，鍵爲數字時不適用
print(dic) # {1: '日照香爐生紫煙', 'two': '黃河之水天上來'}
dic1={3:'飛流直下三千尺',4:'疑是銀河落九天'}
dic.update(dic1)  # 擴展字典
print(dic) # {1: '日照香爐生紫煙', 'two': '黃河之水天上來', 3: '飛流直下三千尺', 4: '疑是銀河落九天'}

查（‘=’，get()，keys()，values()，items()，in/not in，sorted()）

1.‘=’

dic = {1: '日照香爐生紫煙', 2: '遙看瀑布掛前川', 3: '飛流直下三千尺', 4: '疑是銀河落九天'}
a=dic[1]
print(a) # 日照香爐生紫煙

2.鍵找值（get()）

get() ,返回指定鍵的值，若是鍵不在字典中，返回一個指定值，默認爲None。

dic = {1: '日照香爐生紫煙', 2: '遙看瀑布掛前川', 3: '飛流直下三千尺', 4: '疑是銀河落九天'}
a=dic.get(1)
print(a) # 日照香爐生紫煙

3.全部鍵列表（keys()）

keys() 方法以列表形式（並不是直接的列表，若要返回列表值還需調用list函數）返回字典中的全部的鍵。

dic = {1: '日照香爐生紫煙', 2: '遙看瀑布掛前川', 3: '飛流直下三千尺', 4: '疑是銀河落九天'}
print(dic.keys()) # dict_keys([1, 2, 3, 4]) #並不是直接的列表
a=list(dic.keys()) 
print(a)  # [1, 2, 3, 4]

4.全部值列表（values()）

values() 方法以列表形式（並不是直接的列表，若要返回列表值還需調用list函數）返回字典中的全部值。

dic = {1: '日照香爐生紫煙', 2: '遙看瀑布掛前川', 3: '飛流直下三千尺', 4: '疑是銀河落九天'}
print(dic.values()) # dict_values(['日照香爐生紫煙', '遙看瀑布掛前川', '飛流直下三千尺', '疑是銀河落九天']) #並不是直接的列表
a=list(dic.values())
print(a)  # ['日照香爐生紫煙', '遙看瀑布掛前川', '飛流直下三千尺', '疑是銀河落九天']

5.全部鍵值對列表（items()）

items() 方法以列表形式（並不是直接的列表，若要返回列表值還需調用list函數）返回全部的鍵值對（一對鍵值對構成的元組）

dic = {1: '日照香爐生紫煙', 2: '遙看瀑布掛前川', 3: '飛流直下三千尺', 4: '疑是銀河落九天'}
print(dic.items())  # dict_items([(1, '日照香爐生紫煙'), (2, '遙看瀑布掛前川'), (3, '飛流直下三千尺'), (4, '疑是銀河落九天')]) # 並不是直接的列表
a=list(dic.items())
print(a)  # [(1, '日照香爐生紫煙'), (2, '遙看瀑布掛前川'), (3, '飛流直下三千尺'), (4, '疑是銀河落九天')]

6.in/not in（是否存在）

in 操做符用於判斷鍵（key）是否存在於字典（D）中，若是鍵在字典中返回True，不然返回False。

not in 則相反

dic = {1: '日照香爐生紫煙', 2: '遙看瀑布掛前川', 3: '飛流直下三千尺', 4: '疑是銀河落九天'}
print(1 in dic) # True
print(1 not in dic) # False

7.全部鍵列表（sorted()）

返回一個有序的包含字典全部key的列表

dic = {1: '日照香爐生紫煙', 2: '遙看瀑布掛前川', 3: '飛流直下三千尺', 4: '疑是銀河落九天'}
print(sorted(dic)) # [1, 2, 3, 4]

其餘騷操做（dict.fromkeys()，copy() ）

1.可迭代對象作鍵（dict.fromkeys()）

fromkeys() 方法用於建立一個新的字典，並以可迭代對象中的元素分別做爲字典中的鍵，且全部鍵對應同一個值，默認爲None。

dic.fromkeys(iterable[,value=None])

iterable-- 用於建立新的字典的鍵的可迭代對象（字符串、列表、元祖、字典）。
value -- 可選參數, 字典全部鍵對應同一個值的初始值，默認爲None

str = "12" # 字符串
dic = {1:'one',2:'two'} # 字典
a=dict.fromkeys(str,'字符串')
print(a) # {'1': '字符串', '2': '字符串'}
a=dict.fromkeys(dic,'字典')
print(a) # {1: '字典', 2: '字典'} #字典是仍是用鍵作新鍵

2.複製（copy()）

dic.copy() 對字典 dic 進行淺複製，返回一個和dic有相同鍵值對的新字典。(由於字典的值value能夠是可變和不可變數據類型，因此就涉及到了深淺複製)

dic = {1: '日照香爐生紫煙', 2: '遙看瀑布掛前川', 3: '飛流直下三千尺', 4: '疑是銀河落九天'}
d=dic.copy()
print(d) # {1: '日照香爐生紫煙', 2: '遙看瀑布掛前川', 3: '飛流直下三千尺', 4: '疑是銀河落九天'}

3.字典的嵌套（多級菜單）

menu = {
    '北京': {
        '海淀': {
            '五道口': {
                'soho': {},
                '網易': {},
                'google': {}
            },
            '中關村': {
                '愛奇藝': {},
                '汽車之家': {},
                'youku': {},
            },
            '上地': {
                '百度': {},
            },
        },
        '昌平': {
            '沙河': {
                '老男孩': {},
                '北航': {},
            },
            '天通苑': {},
            '回龍觀': {},
        },
        '朝陽': {},
        '東城': {},
    },
    '上海': {
        '閔行': {
            "人民廣場": {
                '炸雞店': {}
            }
        },
        '閘北': {
            '火車站': {
                '攜程': {}
            }
        },
        '浦東': {},
    },
    '山東': {},
}

多級菜單

六集合(set)

集合(set)是一個無序的，把不一樣的元素(set elements)組成一塊兒造成集合(不重複的數據組合)，它的主要做用以下：

去重: 把一個列表變成集合，就自動去重了(不可重複）

關係測試: 測試兩組數據以前的交集、差集、並集等關係

集合分類：可變集合、不可變集合

可變集合(set)：可添加和刪除元素，非可哈希的（可變數據類型），不能用做字典的鍵，也不能作其餘集合的元素

不可變集合(frozenset)：不可添加，不可刪除元素，可哈希的（不可變數據類型），能用做字典的鍵，也能作其餘集合的元素

list=['一', '弦', '一', '柱', '思', '華', '年']
set=set(list)
print(set)  # {'弦', '華', '思', '柱', '年', '一'}   去重，無序

建立集合

集合的工廠方法set()和frozenset()建立

set1={'一', '弦', '一', '柱', '思', '華', '年'}
print(type(set1))  # <class 'set'>

set2=set('一弦一柱思華年')
print(type(set2))  # <class 'set'>

set3=frozenset('一弦一柱思華年')
print(type(set3)) # <class 'frozenset'>   不可添加，不可刪除元素，可哈希的（不可變數據類型）

增（add，update）

.add()添加單個元素（能夠重複添加相同的值，可是沒用，集合去重的）

set1={'一', '弦', '一', '柱', '思', '華', '年'}
set1.add('詩............')
print(set1)  # {'柱', '詩............', '弦', '華', '思', '一', '年'}  #增長一個元素，能夠重複添加相同的值，可是沒用，集合去重的

.update()添加一個序列（多個元素）

set1={'一', '弦', '一', '柱', '思', '華', '年'}
set1.update('弓弦')
print(set1)  # {'柱', '詩............', '弦', '華', '思', '弓', '一', '年'} #重複添加相同的值，可是沒用，集合去重的

刪（remove，discard，pop，del）

.remove() 刪除元素，直接要刪除指定元素就能夠，但元素不存在時報錯

.discard() 刪除元素，直接要刪除指定元素就能夠，元素不存在時不報錯

.pop() 隨機刪除一個元素，由於集合是無序的

del 刪除集合自己

set1={'一', '弦', '一', '柱', '思', '華', '年'}
set1.remove('一')
print(set1)  # {'思', '年', '弦', '柱', '華'}
set1.discard('思')
print(set1)  # {'年', '弦', '柱', '華'}
del set1


set1.pop()
print(set1)  # {'弦', '柱', '華'}

查

因爲集合自己是無序的，因此不能爲集合建立索引或切片操做，只能循環遍歷或使用in、not in來訪問或判斷集合元素

set1={'一', '弦', '一', '柱', '思', '華', '年'}
if '一' in set1:
    print('在裏面')
if '不存在的' not in set1:
    print('不存在的')
for s in set1:
    print(s)
    
#打印結果
# 在裏面
# 不存在的
# 柱
# 弦
# 一
# 思
# 年
# 華

集合之間的關係

集合等價與不等價(==, !=)；子集、超集；

s1={'滅霸','卡魔拉','烏木喉'}  # 滅霸戰隊
s2={'美國隊長','託尼.斯塔克','星爵','卡魔拉'}  # 復仇者聯盟陣營
s3={'美國隊長','託尼.斯塔克'}  # 婦聯
s4={'滅霸','卡魔拉','烏木喉'}  # 滅霸戰隊
print(s1==s4)  # 集合等價(==)兩個集合之間，全部元素徹底相等。不等價(!=)兩集合之間，存在不相等的元素
print(s3<s2)

s2是s3的子集（'<'表示的是真子集），s3是s2的超集

聯合（並集）(|)

聯合(union)操做和（|）與集合其實等價的。

s1={'滅霸','卡魔拉','烏木喉'}  # 滅霸戰隊
s2={'美國隊長','託尼.斯塔克','星爵','卡魔拉'}  # 復仇者聯盟陣營
print(s1|s2)  # {'託尼.斯塔克', '滅霸', '卡魔拉', '美國隊長', '烏木喉', '星爵'}
print(s1.union(s2))  # {'託尼.斯塔克', '滅霸', '卡魔拉', '美國隊長', '烏木喉', '星爵'}

交集(&)

交集符號的等價方法是intersection()。

s1={'滅霸','卡魔拉','烏木喉'}  # 滅霸戰隊
s2={'美國隊長','託尼.斯塔克','星爵','卡魔拉'}  # 復仇者聯盟陣營
s3=s1&s2
print(s3)  # {'卡魔拉'}
s3=s1.intersection(s2)
print(s3)  # {'卡魔拉'}

查集（補集，包括：相等補集，絕對補集）(-)

等價方法是difference()

s1={'滅霸','卡魔拉','烏木喉'}  # 滅霸戰隊
s2={'美國隊長','託尼.斯塔克','星爵','卡魔拉'}  # 復仇者聯盟陣營
s3={'美國隊長','託尼.斯塔克'}  # 婦聯
s4=s2-s1
print(s4)
#{'美國隊長', '星爵', '託尼.斯塔克'}
s5=s1-s2
print(s5)
#{'烏木喉', '滅霸'}
s6=s1.difference(s2)
print(s6)
# {'烏木喉', '滅霸'} 等價於 s1-s2
s7=s2.difference(s1)
print(s7)
# {'美國隊長', '星爵', '託尼·斯塔克'} 等價於 s2-s1
s8=s2-s3
print(s8)
# {'星爵', '卡魔拉'}
s9=s3-s2
print(s9)
# set() 空集合
s10=s2.intersection(s3)
print(s10)
# {'美國隊長', '託尼.斯塔克'}  intersection()函數不適用於絕對補集
s11=s3.difference(s2)
print(s11)
# set() 空集合

對稱差集(^)

（ab交接相對於ab並集的補集）取得的元素屬於a,b但不一樣時屬於a和b.其等價方法symmetric_difference()

s1={'滅霸','卡魔拉','烏木喉'}  # 滅霸戰隊
s2={'美國隊長','託尼.斯塔克','星爵','卡魔拉'}  # 復仇者聯盟陣營
s3={'美國隊長','託尼.斯塔克'}  # 婦聯
print(s1^s1)  # set()
print(s1^s2)  # {'星爵', '滅霸', '託尼.斯塔克', '美國隊長', '烏木喉'}
print(s2^s3)  # {'星爵', '卡魔拉'}
print(s1.symmetric_difference(s2))  # {'星爵', '滅霸', '託尼.斯塔克', '美國隊長', '烏木喉'}  等價於s1^s2

來來來，經常使用的數據類型差很少就這些，以後就談談它們背後那些不可告人的.......

變量，數據，內存三者的關係（不是三角戀哈）

a='黃河之水天上來，你說奇怪不奇怪'     # id(),是獲取數據在內存上的儲存地址
print(id('黃河之水天上來，你說奇怪不奇怪'))  # 34507248
print(id(a))  # 34507248

print(id(2*3))  # 1509649584     
print(id(6))    # # 1509649584

可變數據類型與不可變數據類型的愛恨情愁...不對是前世此生

a = ['託尼·斯塔克', '馬克系列', '反浩克裝甲', '血邊戰衣']
# 而不可變數據類型則是每一次引用內存地址都是不變的
# 可變數據類型的內存地址引用一次改改變一次
print(id(a))  # 32076360
print(id(['託尼·斯塔克', '馬克系列', '反浩克裝甲', '血邊戰衣']))  # 31274056

print(id(a[0]))  # 32006192
print(id('託尼·斯塔克'))  # 32006192

print(id(a[1]))  # 6719984
print(id('馬克系列'))  # 6719984

print(id(a[2]))  # 31383040
print(id('反浩克裝甲'))  # 31383040

print(id(a[3]))  # 31994216
print(id('血邊戰衣'))  # 31994216