Python基礎之四：Python3 基礎資料型別

Python基礎之四：Python3 基礎資料型別

一、資料型別簡介

我們人類作為高階生物，可以很容易區分資料型別，但是計算機不能，計算機雖然很強大，但從某種角度上看又很傻，除非你明確的告訴它，什麼是數字，什麼是字串，否則它是分不清資料之間的區別的，因此，在每個程式語言裡都會有一個叫資料型別的東西，其實就是對常用的各種資料型別進行了明確的劃分，你想讓計算機進行數值運算，你就傳數字給它，你想讓他處理文字，就傳字串型別給它。

二、Python3中的基礎資料型別簡介

Python3中的基礎資料型別共6種，分別是：
1.Number（數字）： int（整數）、float（浮點數）、bool（布林值）、complex（複數）

2.String（字串）：用單引號 ’ 或雙引號 " 括起來，同時使用反斜槓 \ 轉義特殊字元

3.List（列表）：寫在方括號 [] 之間、用逗號分隔開

4.Tuple（元組）：寫在方括號 （）之間、用逗號分隔開

5.Set（集合）：由一個或數個形態各異的大小整體組成的，構成集合的事物或物件稱作元素或是成員，寫在大括號{ }之間、用逗號分隔開
注意：建立一個空集合必須用 set() 而不是 { }，因為 { } 是用來建立一個空字典

6.Dictionary（字典）：是一種對映型別，字典用 { } 標識，它是一個無序的 鍵(key) : 值(value) 的集合

三、Python3中的基礎資料型別詳解

1.Number（數字）

Python3 支援 int、float、bool、complex（複數）

1.int（整數型別）

通常被稱為是整型或整數，是正或負整數，不帶小數點。Python3 整型是沒有限制大小的，可以當作 Long 型別使用，所以 Python3 沒有 Python2 的 Long 型別。

1.1 十進位制數轉換為二進位制數

十進位制整數轉換為二進位制整數：採用"除2取餘，逆序排列"法。

具體做法是：
用2整除十進位制整數，可以得到一個商和餘數；再用2去除商，又會得到一個商和餘數，如此進行，直到商為小於1時為止，然後把先得到的餘數作為二進位制數的低位有效位，後得到的餘數作為二進位制數的高位有效位，依次排列起來。

# 將十進位制數25轉換成二進位制數：
# 25/2=12---餘數1
# 12/2=6---餘數0
# 6/2=3---餘數0
# 3/2=1---餘數1
# 1/2=0---餘數1
# 最終結果：10011

十進位制小數轉換為二進位制小數：採用"乘2取整，順序排列"法。

具體做法是：
用2乘十進位制小數，可以得到積，將積的整數部分取出，再用2乘餘下的小數部分，又得到一個積，再將積的整數部分取出，如此進行，直到積中的小數部分為零，此時0或1為二進位制的最後一位。或者達到所要求的精度為止；
然後把取出的整數部分按順序排列起來，先取的整數作為二進位制小數的高位有效位，後取的整數作為低位有效位。

#將十進位制數0.625轉換成二進位制數：
#0.625*2=1.25======取出整數部分1
#0.25*2=0.5========取出整數部分0
#0.5*2=1==========取出整數部分1
#結果：（0.101）B

1.2 二進位制數轉換為十進位制數

要從右到左用二進位制的每個數去乘以2的相應次方,小數點後則是從左往右

例如：二進位制數1101.01轉化成十進位制

1101.01（2）=1*2^0+0*2^1+1*2^2+1*2^3 +0*2^-1+1*2^-2=1+0+4+8+0+0.25=13.25（十進位制數）

所以總結起來通用公式為：

abcd.efg(2)=d*2^0+c*2^1+b*2^2+a*2^3+e*2^-1+f*2^-2+g*2^-3（十進位制數）

1.3 int操作

計算整數在記憶體中佔用的二進位制碼的長度，使用bit_length()方法：

# 將十進位制數25轉換成二進位制數：
# 25/2=12---餘數1
# 12/2=6---餘數0
# 6/2=3---餘數0
# 3/2=1---餘數1
# 1/2=0---餘數1
# 最終結果：10011
m = 25
print(m.bit_length())
#執行結果：5

2.bool（布林型別）

布林值只有兩個：True（1）、False（0）

2.1 int str bool 三者資料型別之間的轉換

str => int　　　　int(str)

int => str　　　　str(int)

int => bool　　　bool(int) 0是 False， 非0 就是 True

str = > bool　　 bool(str) 空字串 就是 False ， 非空就是 True

bool => str　　　str(bool) 把 bool 值轉換成相對應的 “值”

# int ---> bool
i = 100
print(bool(i))  # True  # 非零即True(1)
i1 = 0
print(bool(i1))  # False 零即False(0)

# 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'

3.float（浮點數型別）

浮點型由整數部分與小數部分組成，浮點型也可以使用科學計數法表示（2.5e2 = 2.5 x 102 = 250）

m = 55.7
print(float(m))#55.5
print(int(m))#55

4.complex（複數）

複數由實數部分和虛數部分構成，可以用a + bj,或者complex(a,b)表示， 複數的實部a和虛部b都是浮點型。

5.數字型別轉換

int(x) 將x轉換為一個整數。

float(x) 將x轉換到一個浮點數。

complex(x) 將x轉換到一個複數，實數部分為 x，虛數部分為 0。

complex(x, y) 將 x 和 y 轉換到一個複數，實數部分為 x，虛數部分為 y。x 和 y 是數字表示式。

5.數字相關函式

5.1 數學函式

import math
print(abs(-10))	#返回數字的絕對值,結果：10
print(math.ceil(3.2))	#返回數字的上入整數,結果：4
print(math.exp(1))	#返回e的x次冪(ex),結果：2.718281828459045
print(math.fabs(-10))	#返回數字的絕對值，結果：10.0
print(math.floor(4.9))	#返回數字的下舍整數，結果：4
print(math.log(100, 10))# log函式，結果：2.0
print(math.log10(100))# 返回以10為基數的x的對數，結果： 2.0
print(max(1,5,3,6,4,8))	#返回給定引數的最大值，結果：8。
print(min(1,5,3,6,4,8))	#返回給定引數的最小值，結果：1。
print(math.modf(3.88))	#返回x的整數部分與小數部分，兩部分的數值符號與x相同，整數部分以浮點型表示。，結果：(0.8799999999999999, 3.0)
print(pow(2, 4))	#x**y 運算後的值,即x的y次冪。結果：16
print(round(10.8765,2))#返回浮點數 x 的四捨五入值，如給出n值，則代表舍入到小數點後的位數。其實準確的說是保留值將保留到離上一位更近的一端。結果：10.88
print(math.sqrt(16))	#返回數字x的平方根。結果：4.0

5.2 隨機數函式

import random
print(random.choice(range(10)))#從序列的元素中隨機挑選一個元素，比如random.choice(range(10))，從0到9中隨機挑選一個整數。
print(random.randrange(1, 100, 2))#從指定範圍內，按指定基數遞增的集合中獲取一個隨機數。1-100隨機一個奇數
print(random.random())	#隨機生成下一個實數，它在[0,1)範圍內。
random.seed(10)	#改變隨機數生成器的種子seed。如果你不瞭解其原理，你不必特別去設定seed，Python會幫你選擇seed。
print(random.shuffle([]))	#將序列的所有元素隨機排序
print(random.uniform(0, 10))	#隨機生成下一個實數，它在[0,10]範圍內。

5.3三角函式

# acos(x)	返回x的反餘弦弧度值。
# asin(x)	返回x的反正弦弧度值。
# atan(x)	返回x的反正切弧度值。
# atan2(y, x)	返回給定的 X 及 Y 座標值的反正切值。
# cos(x)	返回x的弧度的餘弦值。
# hypot(x, y)	返回歐幾里德範數 sqrt(x*x + y*y)。
# sin(x)	返回的x弧度的正弦值。
# tan(x)	返回x弧度的正切值。
# degrees(x)	將弧度轉換為角度,如degrees(math.pi/2) ， 返回90.0
# radians(x)	將角度轉換為弧度

5.3數字常量

pi 數學常量 pi（圓周率，一般以π來表示）

e 數學常量 e，e即自然常數（自然常數）

2.String（字串）

凡是用引號引起來的資料可以稱為字串型別，組成字串的每個元素稱之為字元，將這些字元一個一個連線起來，然後在用引號起來就是字串。

2.1 字串的索引與切片

索引：即下標，就是字串組成的元素從第一個開始，初始索引為0以此類推

st = 'ABCDEFG'
print(st[0])#A
print(st[2])#C
print(st[6])#G

切片：就是通過索引（索引：索引：步長）擷取字串的一段，形成新的字串（原則就是顧頭不顧腚）

2.2 字串的訪問

按索引：s1[index]
按照切片： s1[start_index: end_index+1]
按照切片步長： s1[start_index: end_index+1:2]
反向按照切片步長： s1[start_index: end_index後延一位:2]

st = 'ABCDEFG'
print(st[0:6:2])#ACE，A到F範圍內(不包括F)，每隔2取一個值
print(st[0:6:3])#AD，A到F範圍內(不包括F)，每隔3取一個值
print(st[:7])#ABCDEFG，A到G範圍內（包括G），每隔1取一個值
print(st[-2:1:-1])#FEDC，F到B範圍內（不包括B），每隔-1取一個值
print(st[-3:0:-2])#EC，E到A範圍內（不包括A），每隔-2取一個值

 1 str = '0123456789′
 2 print str[0:3] #擷取第一位到第三位的字元
 3 print str[:] #擷取字串的全部字元
 4 print str[6:] #擷取第七個字元到結尾
 5 print str[:-3] #擷取從頭開始到倒數第三個字元之前
 6 print str[2] #擷取第三個字元
 7 print str[-1] #擷取倒數第一個字元
 8 print str[::-1] #創造一個與原字串順序相反的字串
 9 print str[-3:-1] #擷取倒數第三位與倒數第一位之前的字元
10 print str[-3:] #擷取倒數第三位到結尾
11 print str[:-5:-3] #逆序擷取，擷取倒數第五位數與倒數第三位數之間

2.3 轉義字元

在需要在字元中使用特殊字元時，python用反斜槓()轉義字元

轉義字元	描述
(在行尾時)	續行符
\	反斜槓符號
’	單引號
"	雙引號
\a	響鈴
\b	退格(Backspace)
\000	空
\n	換行
\v	縱向製表符
\t	橫向製表符
\r	回車
\f	換頁
\oyy	八進位制數，yy 代表的字元，例如：\o12 代表換行，其中 o 是字母，不是數字 0。
\xyy	十六進位制數，yy代表的字元，例如：\x0a代表換行
\other	其它的字元以普通格式輸出

2.4 字串運算子

操作符	描述 例項
+	字串連線
*	重複輸出字串

2.5 字串格式化

Python 支援格式化字串的輸出 。儘管這樣可能會用到非常複雜的表示式，但最基本的用法是將一個值插入到一個有字串格式符 %s 的字串中。

在 Python 中，字串格式化使用與 C 中 sprintf 函式一樣的語法。

符 號	描述
%c	格式化字元及其ASCII碼
%s	格式化字串
%d	格式化整數
%u	格式化無符號整型
%o	格式化無符號八進位制數
%x	格式化無符號十六進位制數
%X	格式化無符號十六進位制數（大寫）
%f	格式化浮點數字，可指定小數點後的精度
%e	用科學計數法格式化浮點數
%E	作用同%e，用科學計數法格式化浮點數
%g	%f和%e的簡寫
%G	%f 和 %E 的簡寫
%p	用十六進位制數格式化變數的地址

f-string： python3.6 之後版本新增的，稱之為字面量格式化字串，是新的格式化字串的語法

name = '小明'
age = 18
print (f"我叫{name}，今年{age}歲!" )
#我叫小明，今年18歲!

2.6 字串常用方法

1.字串大小寫變換

st = 'aBcDe'
print(st.upper())#將字串轉換成大寫，結果：ABCDE
print(st.lower())#將字串轉換成小寫，結果：abcde
print(st.title())#返回字串的標題式樣（即首字母大寫）
print(st.swapcase())#返回字串大小寫交換

2.字串元素內容檢查

st = 'aBcDe'
print(st.startswith('a'))#字串是否以a開頭，結果：True
print(st.endswith('m'))#將字元是否以m結尾，結果：False
print(st.isalnum()) #檢查所有字串是否只有數字和字母
print(st.isalpha())# 檢查字串中是否只有字母
print(st.isdigit())# 檢查字串字元是否全為數字
print(st.islower())#檢查字串字元是否全為小寫
print(st.isupper())#檢查字串字元是否全為大寫
print(st.istitle())# 檢查字串字元是否為標題式樣

3.字串分隔、剝離與連線

s = "  www.jianchi-jiushi-shengli.com  "
print('1:', s.split('.'))           #以"."進行字串分割，返回結果為列表。以split()括號裡的引數為標準進行字串分割
print('2:', s.strip(' '))           #剝離字串兩端空格。 不指定引數時預設剝離首尾空格和換行
print('3:', s.lstrip(' w'))         #剝離字串左端空格和w
print('4:', s.rstrip(' om'))        #剝離字串右端空格及字元o和m
print('5:', "-".join(s.split('.'))) #以“.”進行字串分割後，再以“-”進行字串連線

4.字串的查詢與替換

s = "www.jianchi-jiushi-shengli.com  "
print(s.count('g')) #統計某個字元出現的次數
print(s.capitalize()) #返回字串首字母大寫
print(s.find('q'))#找到q返回下標，多個時返回第一個；不存在的字元返回-1
print(s.index('c'))#找到這個字元返回下標，多個時返回第一個；不存在的字元報錯
print(s.replace('g', 'a'))#字串替換
print(s.center(40, '*'))#輸出一個兩邊用*補充的長度為40的字串

5.字串的格式化輸出

name = 'liang'
age = 18
print('my name is {name},I am {age}'.format(name = name, age = age))
#my name is liang,I am 18

3.List（列表）

列表是python的基礎資料型別之一 ,其他程式語言也有類似的資料型別.比如JS中的數 組, java中的陣列等等. 它是以[ ]括起來, 每個元素用’ , '隔開而且可以存放各種資料型別: 列表是python中的基礎資料型別之一，其他語言中也有類似於列表的資料型別，比如js中叫陣列，他是以[]括起來，每個元素以逗號隔開，而且他裡面可以存放各種資料型別比如：

li = [‘alex’,123,Ture,(1,2,3,’wusir’),[1,2,3,’小明’,],{‘name’:’alex’}]

列表相比於字串，不僅可以儲存不同的資料型別，而且可以儲存大量資料，32位python的限制是 536870912 個元素,64位python的限制是 1152921504606846975 個元素。而且列表是有序的，有索引值，可切片，方便取值。

簡單概括：1.承載任意資料型別，儲存大量的資料，對應別的語言：陣列

1.列表的建立

方式一：（常用）

l1 = [1, 2, '學習']

方式二：（不常用）

l1 = list() 空列表
l1 = list(iterable)  可迭代物件
l1 = list('123')
print(l1)  ['1', '2', '3']

方式三：列表推導式

l1 = [i for i in range(1,5)]
print(l1)  # [1, 2, 3, 4]

2.列表的增刪改查

2.1增加

# append 追加，給列表的最後面追加一個元素
l = [1, 2, 'a']
l.append(666)
print(l) # [1, 2, 'a', 666]

# insert  插入在列表的任意位置插入元素
l = [1, 2, 'a']
l.insert(1, '學習')
print(l) # [1, '學習', 2, 'a']

# extend  迭代著追加，在列表的最後面迭代著追加一組資料
l = [1, 2, 'a']
l.extend('學習a')
print(l)#[1, 2, 'a', '學', '習', 'a']

2.2查詢

names = ["aaron", "alex", "james", "meihengfan"]
print(names)            #列出列表的內容
print(names[3])         #訪問列表中第4個值
print(names[1:3])       #訪問列表中從第2個到第3個的值
print(names[-1])        #訪問列表中的最後一個值
print(names[:-2])       #訪問列表中的所有值，但是把倒數第二個及後面的所有值都去掉
print(names[-3:])       #訪問列表中倒數第一個到倒數第三個的值
print(names[0],names[3])    #注意取多個值的時候，不能直接把下標寫到一起，需要按照這種方式寫
print(names[::2])       #列印列表，但是以2為步長，就是跳著切，也可以根據需求把這個步長給改了
print(names.index("james"))         #查詢列表中james這個元素的下標
print(len(names))                   #確定列表的長度

2.3刪除

names = ["aaron", "alex", "james", "meihengfan"]
names.remove("aaron")#指定元素刪除，預設刪除第一個
del names[2] #按索引和切片刪除
del names #直接刪除列表
names.pop() #按索引刪除，預設刪除最後一個
names.clear()#清空列表，危險操作，請慎用

2.4修改

直接操作

names = ["aaron", "alex", "james", "meihengfan"]
names[2] = "liming" #把索引為2的元素修改成了‘liming’

3.列表的其他操作

3.1列表的常用方法

a = ["q","w","q","r","t","y"]
print(a.count('q'))#統計列表中q出現的次數
print(a.index('q'))#找出列表中第一個q出現位置的索引
a.reverse()#反向存放列表
print(a)
print(sorted(a))#對列表進行臨時性排序
a.sort()#將原列表排序
print(a)

3.2列表的相加和相乘

相加

l1 = [1, 2, 3]
l2 = [4, 5, 6]
print(l1*3)  # [1, 2, 3, 1, 2, 3, 1, 2, 3]

相乘

l1 = [1, 2, 3]
l2 = [4, 5, 6]
print(l1*3)  # [1, 2, 3, 1, 2, 3, 1, 2, 3]

4.Tuple（元組）

俗稱不可變的列表，又被成為只讀列表，元祖也是python的基本資料型別之一，用小括號括起來，裡面可以放任何資料型別的資料，查詢可以，迴圈也可以，切片也可以，但就是不能改。

元組的操作方法基本和列表一致，就是不能增加、刪除、修改，只能查詢！

5.TupleDictionary（字典）

字典是以鍵值對形式儲存的容器型資料型別，且可儲存任意型別物件。

字典的每個鍵值 key=>value 對用冒號 : 分割，每個對之間用逗號(,)分割，整個字典包括在花括號 {} 中 ,格式如下所示：

d = {key1 : value1, key2 : value2 }

鍵必須是唯一不可變的，但值則不必，值可以是任意資料型別或者物件。

可變資料型別：列表、字典、集合

不可變資料型別：數字（包含布林值）、字串、元組

1.字典的建立

# 方式1:
dic = dict((('one', 1),('two', 2),('three', 3)))
# dic = dict([('one', 1),('two', 2),('three', 3)])
print(dic)  # {'one': 1, 'two': 2, 'three': 3}


# 方式2:
dic = dict(one=1,two=2,three=3)
print(dic)  # {'one': 1, 'two': 2, 'three': 3}


# 方式3:
dic = dict({'one': 1, 'two': 2, 'three': 3})
print(dic)  # {'one': 1, 'two': 2, 'three': 3}

# 方式4: 字典推導式
# dic = { k: v for k,v in [('one', 1),('two', 2),('three', 3)]}
# print(dic)

2.字典的增刪改查

2.1增加

# 通過鍵值對直接增加
dic = {'name': '小明', 'age': 18}
dic['weight'] = 75 # 沒有weight這個鍵，就增加鍵值對
print(dic) # {'name': '小明', 'age': 18, 'weight': 75}
dic['name'] = 'barry' # 有name這個鍵，就成了字典的改值
print(dic) # {'name': 'barry', 'age': 18, 'weight': 75}

# setdefault
dic = {'name': '小明', 'age': 18}
dic.setdefault('height', 175) # 沒有height此鍵，則新增
print(dic) # {'name': '小明', 'age': 18, 'height': 175}
dic.setdefault('name', 'barry') # 有此鍵則不變
print(dic) # {'name': '小明', 'age': 18, 'height': 175}

2.2刪除

# pop 通過key刪除字典的鍵值對，有返回值，可設定返回值。
dic = {'name': '小明', 'age': 18}
# ret = dic.pop('name')
# print(ret, dic) # 小明 {'age': 18}
ret1 = dic.pop('n', None)
print(ret1, dic) # None {'name': '小明', 'age': 18}

#popitem 3.5版本之前，popitem為隨機刪除，3.6之後為刪除最後一個，有返回值
dic = {'name': '小明', 'age': 18}
ret = dic.popitem()
print(ret, dic) # ('age', 18) {'name': '小明'}

#clear 清空字典
dic = {'name': '小明', 'age': 18}
dic.clear()
print(dic) # {}

# del
# 通過鍵刪除鍵值對
dic = {'name': '小明', 'age': 18}
del dic['name']
print(dic) # {'age': 18}
#刪除整個字典
del dic

2.3修改

# 通過鍵值對直接改
dic = {'name': '小明', 'age': 18}
dic['name'] = 'barry'
print(dic) # {'name': 'barry', 'age': 18}

# 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} 

2.4查詢

# 通過鍵查詢
# 直接dic[key](沒有此鍵會報錯)
dic = {'name': '小明', 'age': 18}
print(dic['name']) # 小明

# get
dic = {'name': '小明', 'age': 18}
v = dic.get('name')
print(v) # '小明'
v = dic.get('name1')
print(v) # None
v = dic.get('name2','沒有此鍵')
print(v) # 沒有此鍵 

keys()
dic = {'name': '小明', 'age': 18}
print(dic.keys()) # dict_keys(['name', 'age']) 

values()
dic = {'name': '小明', 'age': 18}
print(dic.values()) # dict_values(['小明', 18])

items()
dic = {'name': '小明', 'age': 18}
print(dic.items()) # dict_items([('name', '小明'), ('age', 18)])

3.字典的巢狀

用一個簡單的例子說明字典的巢狀

dic = {
    'name':'汪峰',
    'age':48,
    'wife':[{'name':'國際章','age':38}],
    'children':{'girl_first':'小蘋果','girl_second':'小怡','girl_three':'頂頂'}
}

# 1. 獲取汪峰的名字。
print(dic['name'])
# 2.獲取這個字典：{'name':'國際章','age':38}。
print(dic['wife'][0])
# 3. 獲取汪峰妻子的名字。
print(dic['wife'][0]['name'])
# 4. 獲取汪峰的第三個孩子名字。
print(dic['children']['girl_three'])

3.關於拆包應用到字典

a,b = 1,2
print(a,b)#1 2

a,b = ('你好','世界')  # 元組的拆包
print(a,b)#你好 世界

a,b = ['你好','大飛哥']# 列表的拆包
print(a,b)#你好 大飛哥

a,b = {'汪峰':'北京北京','王菲':'天后'}# 字典的拆包
print(a,b)#汪峰 王菲

6.Set（集合）

集合是一個無序的不重複元素序列

1.集合的建立

#方法一：
se1 = {1, 2, 8, 2}
print(se1)
#方法二：
se2 = set({1, 2, 8, 2})
print(se2)

強調：建立一個空集合必須用 set() 而不是 { }，因為 { } 是用來建立一個空字典

se1 = set()
print(type(se1))#<class 'set'>
se2 = {}
print(type(se2))#<class 'dict'>

2.集合的增加和刪除

由於集合是無序的、不重複的，所以集合在儲存元素時會自動刪除重複的元素，並且無序性使之不能查詢單個元素

2.1集合的增加

#方法一：add
se1 = {1, 2, 8, 2}
se1.add('小明')
print(se1)#{8, 1, 2, '小明'}

#方法二：update
se1 = {1, 2, 8, 2}
# se1.update('小明')
# print(se1)#{1, 2, '明', 8, '小'}
se1.update(['xiaoming', 'xiaoai'])
print(se1)#{1, 2, 'xiaoming', 8, 'xiaoai'}

2.2集合的刪除

set1 = {1, 2, 8, 2}
set1.remove(8)  # 刪除一個元素
print(set1)

set1.pop()  # 隨機刪除一個元素
print(set1)

set1.clear()  # 清空集合
print(set1)

del set1  # 刪除集合
print(set1)

3.集合的關係測試

3.1交集（& 或者 intersection）

set1 = {1,2,3,4,5}
set2 = {4,5,6,7,8}
print(set1 & set2)  # {4, 5}
print(set1.intersection(set2))  # {4, 5}

3.2並集（| 或者 union）

set1 = {1,2,3,4,5}
set2 = {4,5,6,7,8}
print(set1 | set2)  # {1, 2, 3, 4, 5, 6, 7,8}
print(set2.union(set1))  # {1, 2, 3, 4, 5, 6, 7,8}

3.3差集（- 或者 difference）

set1 = {1,2,3,4,5}
set2 = {4,5,6,7,8}
print(set1 - set2)  # {1, 2, 3}
print(set1.difference(set2))  # {1, 2, 3}

3.4反交集（^ 或者 symmetric_difference）

set1 = {1,2,3,4,5}
set2 = {4,5,6,7,8}
print(set1 ^ set2)  # {1, 2, 3, 6, 7, 8}
print(set1.symmetric_difference(set2))  # {1, 2, 3, 6, 7, 8}

3.5子集與超集

set1 = {1,2,3}
set2 = {1,2,3,4,5,6}

print(set1 < set2)
print(set1.issubset(set2))  # 這兩個相同，都是說明set1是set2子集。

print(set2 > set1)
print(set2.issuperset(set1))  # 這兩個相同，都是說明set2是set1超集。

四、Python3中的基礎資料型別圖