python3基礎篇（二）——數據類型

python3基礎篇（二）——數據類型

1 閱讀這篇文章我能學到什麼？
  這篇文章將爲你介紹python3的幾種數據類型以及對這些數據類型的簡單操作。

——如果您覺得這是一篇不錯的博文，希望你能給一個小小的贊，感謝您的支持。

1 python3變量的一般特徵

  與大多數腳本類似，python3中的變量不需要單獨定義，首次賦值即定義。由於賦值即完成定義的特徵，在變量使用前都必須賦值（即使用前必須定義）。
  對於python3來說變量是不分類型的，我們討論的皆爲數據的類型，也即存儲在變量內存當中的對象數據的類型。（所以標題叫數據類型而不是變量類型）
與其他語言類似，我們使用=作爲賦值操作符，將右側表達式的值賦值給左側變量，這個過程即完成了變量在內存空間的創建，也完成了表達式的計算和存儲。

a = 1 + 1               #創建變量a，計算右側表達式值並賦值給變量a
b = a                   #變量之間賦值

  對變量賦值操作。

a = 100                 #a中存儲整形數據
a = 0.0001              #a中存儲浮點數據
a = 'string'            #a中存儲字符串數據
print(a)                #打印變量a的值

  對變量a進行多種數據類型存儲。

a = b = c = 0                 #從右到左依次對三個變量賦值相同的值
d, e, f = 1, 0.2, "string"    #對三個變量分別賦值，且類型不同

del a
del b
del c
del d, e, f

  賦值操作是靈活的，定義的變量可以使用del關鍵詞刪除變量回收內存。變量被del之後不能再使用，除非重新定義。

2 有哪些數據類型

• Number（數字）：具體又有整形（int）、浮點（float）、複數（complex）、布爾（bool）四種類型。
• String（字符串）：被符號'或"括起來的數據爲字符串，與c/c++不同，python沒有單個字符的字符類型，即使單個字符也被認爲是字符串。
• Tuple（元組）：寫在()內的多個元素構成一個整體，這些元素的類型可以不同，但是元素不能被修改。元組是有序的。
• List(列表)：寫在[]內的多個元素構成一個整體，與元組類似元素類型同樣可不同，但列表的元素可以被修改。列表同樣是有序的。
• Set（集合）：寫在{}內，類似數學概念的集合，由一個或多個各異的大小整體構成，這些整體稱爲集合的元素或成員。集合是無序的。
• Dictionary（字典）：寫在{}內，相比於列表，列表是有序的對象集合，字典是無序的對象集合。列表通過偏移來查找元素，字典通過鍵值來查找元素。字典的每個元素都由一個鍵値（key）和一個值（value）構成，一個字典中的key必須是唯一的。

#Number
print(type(1))
print(type(0.1))
print(type(1 + 2j))
print(type(True))

#String
print(type("String"))
print(type('String'))

#Tuple
print(type((1, 2)))

#List
print(type([1, 2]))

#Set
print(type({1, 2}))

#Dictionary
print(type({'key1':1, 'key2':2})

  type函數可以查看數據類型。
輸入結果：

<class 'int'>
<class 'float'>
<class 'complex'>
<class 'bool'>
<class 'str'>
<class 'str'>
<class 'tuple'>
<class 'list'>
<class 'set'>
<class 'dict'>

3 Number

3.1 int

3.1.1 int的長度

  python3只有一種整數類型即長整型，表示爲int，python取消了python2中的long類型。python3一大特點是對整型沒有大小限制，這一點也是爲了方便表達和運算。

number1 = 99999999999999999999999999999999999999999999
number2 = 33333333333333333333333333333333333333333333
number3 = number1 + number2
print(number3)

輸出結果爲：133333333333333333333333333333333333333333332
  處理這樣長串的數據對python來說毫無難度，對c來說會是很頭疼的事。

3.1.2 int的表示形式

  python支持int類型的十進制、十六進制、八進制、二進制表示。

#0x或0X表示16進制
print(0x0F)                         #16進制的A~F也可用小寫a~f
print(0X0F)

#0o或0O表示8進制
print(0o07)
print(0O07)

#0b或0B表示2進制
print(0b00000101)
print(0B00000101)

3.1.3 int的運算

  與其他計算與編程語言一樣，python3好的int類型也可以和操作符結合構成表達式計算結果。這裏簡單帶過，後面講運算符時會詳細講解。

print(1 + 2)
print(2 * 3)
print(4 / 2)            #/運算的結果爲浮點
print(5 - 2)
print(10 % 2)           #取餘
print(3 ** 2)           #3的2次方
print(3 // 2)           #除法，但是舍小數取整

運行結果爲：

3
6
2.0
3
0
9
1

3.2 float

3.2.1 float的長度

  和int不一樣，python3的float類型能表示的長度是有限制的，它更像是c/c++中的雙精度double類型。python3對於浮點默認是提供17位數字的精度。

number1 = 9.9999999999999999999999999999999999999999999             #浮點有效位並不能達到這麼多，精度將會丟失
number2 = 3.3333333333333333333333333333333333333333333             #浮點有效位並不能達到這麼多，精度將會丟失
number3 = number1 + number2
print(number1)
print(number2)
print(number3)

輸出結果爲：

10.0
3.3333333333333335
13.333333333333334

  可以看到python的浮點表示的數據長度是有限的，在使用時我們要注意有效位的問題。

3.2.2 float的表示形式

• 科學表示法

number1 = 3e+2                              #指數是正數時，+號可省略
number2 = 1000E-2                           #e可以大寫爲E

print(number1)
print(number2)
print(type(3e+2))                           #科學表示法是float類型

  科學表示法是float類型，不要認爲計算結果是整數就是int類型。e表示的不是數學中的自然對數的底數，同c/c++一樣，python3中aeb表示的是$a \times 10^b$。 注意 科學計數法表示只能是常量，這裏的a和b都不能寫成變量。

3.2.3 float的運算

  float的運算同int的運算，這裏也是簡略看下示例代碼，等後面講操作符時詳細講。

print(1.00002 + 2)
print(2e2 * 3)
print(4E-2 / 2)           #/運算的結果爲浮點
print(5.0 - 2.0)
print(10.2 % 2)           #取餘
print(3.2 ** 2.1)         #3.2的2.1次方
print(3.0 // 2)           #除法，但是舍小數取整

輸出結果爲：

3.00002
600.0
0.02
3.0
0.1999999999999993
11.503101568235094
1.0

4 String

  python3的字符串類型由'或"括起來，在python3中單雙引號的作用是等價的。要對字符串中的字符或子字符串操作時，需要結合[]進行訪問。和其他腳本一樣，python3也支持對字符串的運算，支持轉義字符。python也支持格式化的字符串，f-string是3.6版本後新增的規則。python2對字符串有兩種存儲方式，一種是8位ASCII字符存儲，一種是Unicode字符存儲，而python3將所有字符都以Unicode字符存儲。python3爲了方便字符串操作，內建了很多字符串操作函數。
  字符串的'和"雖然都能表示字符串，但是不能交叉匹配，比如'AAA"和"AAA'都是錯誤的字符串。另外引號嵌套時需要注意，比如"'AAA'"和'"AAA"'最外層的引號會配成一對，最後print得到字符串分別爲'AAA'和"AAA"，而''AAA''和""AAA""將會語法報錯，因爲相鄰的引號之間會配對。如果是普通字符串你可以使用轉義字符寫爲'\'AAA\''或"\"AAA\""。字符串嵌套時內外層使用不同的引號的運用主要是在f-string中，後文會講到。

4.1 字符串的訪問

  對字符串的訪問有兩種操作，一種對對字符串索引得到字符串內的一個字符，另一種是對字符串進行截取得到子字符串。因爲python將字符串進行有序存儲，所以兩種操作都是基於字符串中字符的索引號進行的。python字符串中每個字符都具有兩個索引號，一正一負，正數表示從左往右（從首字符到末尾字符），從0遞增時分配的索引。負數表示從右往左（從末尾字符到首字符），從-1遞減時分配的索引。比如字符串"0123456"，字符0的索引是0也是-7，字符6的索引是-1也是6。
  對字符串的字符索引時，可以在字符串變量後加上[]並在其中寫上需要索引的字符的索引號。最終表達式的值就是隻含有所需索引字符的字符串，前面提到過，python是沒有隻含單個字符的字符類型的，都是字符串類型。比如"0123456"[0]的值是字符串'0'。
&ems; 對字符串的截取。截取字符串就是通過運算符[:]設定區間的過程，比如"0123456[1:5]"得到的結果就是子字符串'01234'。由於python3字符串內每個字符具有兩個索引號（一正一負，表示索引的方向不同），似乎使得[:]運算符的使用變得複雜，其實只要記住python的字符串截取區間是“左閉右開”的，比如"0123456[1:5]"截取的區間爲$[1,5)$，即包含索引是1的字符，但不包含索引是5的字符，所以得到的字符串是'01234'。

str = '0123456'                 #字符串中每個字符都有對應索引（是有序的），索引從左到右從0開始步長爲1累加
#訪問字符串內字符，即索引字符
print(str[0])                   #輸出索引是0的字符
print(str[6])                   #輸出索引是6的字符

#訪問整個字符串
print(str)
print(str[0:])                  #左邊0可以被省略，但是右邊沒有-0這種操作！
print(str[:])

#訪問子字符串，即截取出子字符串
print(str[1:])                  #從索引爲1的字符截取至字符串結束
print(str[:6])                  #從字符串起始截至索引爲6的字符
print(str[1:6])                 #從索引號爲1的字符截取至索引號爲6的字符
print(str[1:-1])                #從索引號爲1的字符截取至索引號爲-1的字符
print(str[-6:-1])               #從索引號爲-6的字符截取至索引號爲-1的字符
print(str[-6:6])                #從索引號爲-6的字符截取至索引號爲6的字符

#訪問空字符串
print(str[3:3])                 #當截取的區間長度小於等於0時，截取到的子字符串爲空
print(str[3:2])

輸出結果爲：

0123456
0123456
123456
012345
12345
12345
12345
12345

截取子字符串是不會修改原變量值的。

4.2 轉義字符

轉義字符	含義
\	反斜槓
’	單引號
"	雙引號
\a	響鈴
\b	退格
\0	空
\n	換行
\v	縱向製表符
\t	橫向製表符
\r	回車
\f	換頁
\o	八進制
\x	十六進制
\other	其他字符以普通格式輸出

print('\\')                 #輸出\
print('\'')                 #輸出'
print('\"')                 #輸出"
print('123\b')              #退格，刪除字符3
print('ab\ncd')             #換行
print('ab\tcd')             #橫向製表符
print('ab\rcd')             #回車
print('A\x0aA')             #回車

輸出結果爲：

\
'
"
12
ab
cd
ab	cd
cd
A
A

4.3 字符串運算

操作符	作用
+	字符串連接
*	重複輸出字符串
[]	索引字符串中字符
in	成員運算符，判斷某字符是否存在字符串中，結果爲bool型
not in	成員運算符，判斷某字符是否不存在字符串中，結果爲bool型
r/R	原始字符串，被該運算符修改的字符串直接按照字面意思使用，不含轉義字符或不能打印的字符。
%	格式字符串

str1 = "abc"
str2 = "123"

print(str1 + str2)                    #字符串拼接
print(str1 * 3)                       #字符串重複3次
print(str1[1])                        #索引字符
print(str1[1:2])                      #截取子字符串
print("a" in str1)                    #判斷str1中是否含有字符a
print("a" not in str2)                #判斷str2中是否不含有字符a

str3 = r"A\nA"
str4 = "A\nA"
print(str3)
print(str4)

輸出結果爲：

abc123
abcabcabc
b
b
True
True
A\nA
A
A

4.4 字符串格式化

python3的字符串格式化類似於c/c++的sprintf函數的用法。

格式	作用
%c	格式化字符及其ASCII碼
%s	格式化字符串
%d	格式化整數
%u	格式化無符號整形
%o	格式化無符號八進制
%x/%X	格式化無符號十六進制數，大寫X時十六進制數也相應大寫
%f	格式化浮點數，可指定小數點後的精度
%e/%E	以科學計數法格式化浮點數，e的大小寫決定科學計數法e的大小寫
%g/%G	小寫g是%f和%e的簡寫，大寫G是%f和%E的簡寫

print("%c, %s, %d, %u" % ("A", "abc", -10.1, 5.1))              #可以看到%d和%u將浮點數格式化爲整數
print("%u" % (-5.1))                                            #%u輸出依然是帶符號了，並沒有轉化爲無符號數

print("%o, %x, %X" % (10, 10, 10))                              #8進制和16進制，o不能大寫，x的大小寫對應16進制數的大小寫

print("%f, %e, %E" % (1.99999, 3.14159265359, 3.14159265359))
print("%g, %g, %G, %G" % (999999999999, 999, 99999999999, 999)) #自動優化決定將浮點數按%f或%e/%G顯示

輸出結果爲：

A, abc, -10, 5
-5
12, a, A
1.999990, 3.141593e+00, 3.141593E+00
1e+12, 999, 1E+11, 999

格式化字符時的輔助字符：

符號	作用
.	.號前表明字最小段寬度後表示小數位精度
*	表明字段最小寬度或者小數位精度，與.一起使用後字段寬度和精度數從參數中讀取
-	用做左對齊
+	在正數前面顯示加號+
<sp>	在正數前面顯示空格，比如% f或% f，與空格數無關
#	在八進制數前面顯示0，在十六進制前顯示0x或0X
0	再試的數字前面填充0
%	%%輸出一個%字符

print("%05.f, %05.0f, %05.f, %05.0f" % (33.0, 33.0, 333333.0, 333333.0))      #字段寬度最小寬度爲5，用0補齊。.之後的0可省略，表示保留0位小數
print("%5.f" % (33.0))                                                        #未指定用0補齊，則默認用空格補齊左端（默認右對齊）

print("%.5f, %0.5f" % (33.33, 33.33))                                         #保留小數後5位
print("%.5f" % (33.333333))

print("%0*.*f" % (6, 2, 33.0))

print("%-05.f" % (33.0))                                                      #指定左對齊，空格在右端補齊

print("%+f, %+f" % (33.0, -33.0))                                             #如果是正數則顯示正號

print("%f, %f" % (33.0, -33.0))
print("% f, % f" % (33.0, -33.0))                                             #在正數的符號位顯示一個空格
print("%    f" % (33.0))                                                      #與空格數無關，最終只會顯示一個空格

print("%o, %#o" % (33, 33))
print("%x, %#x, %#X" % (33, 33, 33))

print("%5.d, %05.d" % (33, 33))                                               #保持最小字段寬度，用0填補

print("%%d, \%d" % (33))                                                      #\$不會被轉義，%%表示輸出一個%號

輸出結果爲：

00033, 00033, 333333, 333333
   33
33.33000, 33.33000
33.33333
033.00
33   
+33.000000, -33.000000
33.000000, -33.000000
 33.000000, -33.000000
 33.000000
41, 0o41
21, 0x21, 0X21
   33, 00033
%d, \33

4.5 三引號

python三引號是可以跨越多行的字符串，其字符串中可以包含轉義字符。

#三引號字符串，所見即所得。也能使用轉義字符。
str1 = '''aaa
aaa
aaa'''
str2 = '''\
bbb
bbb
bbb
'''
str3 = '''
ccc
ccc
ccc\
'''
str4 = 'aaa\nbbb\nccc'
str5 = '''aaa
bbb
ccc\
'''
str6 = '''aaa\nbbb\nccc'''
print(str1)
print(str2)
print(str3)
print(str4)                         #str4 str5 str6輸入同樣字符串
print(str5)
print(str6)

輸出結果爲：

aaa
aaa
aaa
bbb
bbb
bbb


ccc
ccc
ccc
aaa
bbb
ccc
aaa
bbb
ccc
aaa
bbb
ccc

4.6 新字符串格式化語法——f-string

  python3.6之後新增f-string特性，用於新的格式化字符串語法。與舊的格式化語法最大不同在於，新的格式化語法不用太關心數據的類型，舊的格式化語法需要使用%d和%f等表明語法格式。舊格式化語法使用%，新的格式化語法使用f聲明字符串符合f-string格式，{}內進行計算和替換。

dic = {"int":3, "float":2.1, "string":"aaa"}
print("%d, %d, %f, %s" % (1 + 2, dic["int"], dic["float"], dic["string"]))  #舊格式化方法
print(f"{1+1}, {dic['int']}, {dic['float']}, {dic['string']}")              #新格式化方法

a = 1
print(f"{a+2}")
print(f"{a+2=}")                                                            #自動將結果添補在=號之後

str1 = "a + 2 = %d" % (a + 2)
str2 = f"{a + 2 = }"
print(str1)
print(str2)

輸出結果爲：

3, 3, 2.100000, aaa
2, 3, 2.1, aaa
3
a+2=3
a + 2 = 3
a + 2 = 3

5 Tuple

  元組與列表相似。不同在於元組中的元素創建後就無法修改。元組使用()符號表示。元組的元素可以是不同的類型。雖然元組元素不允許修改，但是可以使用del刪除整個元組。列表是有序的。

5.1 創建元組

• 創建空元組

Tuple = ()                      #因爲元組不能修改，所以創建空元組一般沒啥用
print(type(Tuple))

輸出結果爲：

<class 'tuple'>

  使用()來創建元組，若元素爲空則表示創建空元組，因爲元組不能修改，所以創建空元組一般沒啥用。

• 創建單元素元組

Tuple = (1, )                           #創建單元素元祖時，元素後需要加,號，否則會把()內當做表達式處理
number = (1)
print(type(Tuple))
print(type(number))

輸出結果爲：

<class 'tuple'>
<class 'int'>

  創建單元素元組時，元素後要加,符號，否則會被判定爲表達式。

• 創建多個元素元組

Tuple1 = (1, 2)                             #多個元素
Tuple2 = (1, 2,)                            #每個元素後都跟一個,號是被允許的
Tuple3 = ('a', 'b', Tuple1)                 #嵌套元祖，元組元素可由不同類型元素組成
print(Tuple3)

輸出結果爲：

('a', 'b', (1, 2))

• 創建一個元素同於其他元組的元組

Tuple1 = ()                 #創建空元組
Tuple2 = (1,)               #創建單元素元組
Tuple3 = (1, "2")           #創建多元素元組
Tuple4 = Tuple1             #創建元組，其元素同Tuple1元組
Tuple5 = Tuple2
Tuple6 = Tuple3

print(Tuple1, Tuple4)
print(Tuple2, Tuple5)
print(Tuple3, Tuple6)

輸出結果爲：

() ()
(1,) (1,)
(1, '2') (1, '2')

5.2 訪問元組

  對元組的訪問是指對元組元素的訪問。元組是有序的，其訪問方式同前面提到的字符串的索引訪問，正向索引時第一個元素的索引號是0，索引號從0開始遞增，反向索引時最後一個元素索引號-1，索引從-1開始遞減。每個元素有正負兩個索引號。當然，同樣也支持像字符串那樣用[:]區間截取。

Tuple = (1, '2', 3.0)
print(f"{Tuple[0]}, {Tuple[1]}, {Tuple[2]}")                #索引元組的元素，正序號
print(f"{Tuple[-3]}, {Tuple[-2]}, {Tuple[-1]}")             #索引元組的元素，負序號

print(f"{Tuple[1:]}")                                       #區間截取
print(f"{Tuple[-2:]}")

輸出結果爲：

1, 2, 3.0
1, 2, 3.0
('2', 3.0)
('2', 3.0)

5.3 元組運算

  由於元組的元素不能修改，所以其運算相對簡單。其運算有將多個元組使用+進行拼接產生新的元祖，使用*產生內容重複的新元組，使用in或not in判斷元素是否存在元組中。另外還有一些元組的內置函數這裏就不講了，查一下文檔會更詳細。

Tuple1 = (1, 2, 3)
Tuple2 = (3, 2, 1)

print(len(Tuple1))                              #元組長度
print(Tuple1+Tuple2)                            #元組相加爲元組元素的拼接
print((1, 2) + Tuple2)                          #元組拼接
print(Tuple1 * 3)                               #賦值3倍元組
print(3 in Tuple1)                              #判斷元素是否存在元組中
print(4 not in Tuple1)                          #判斷元素是否不存在元組中

輸出結果爲：

3
(1, 2, 3, 3, 2, 1)
(1, 2, 3, 2, 1)
(1, 2, 3, 1, 2, 3, 1, 2, 3)
True
True

6 List

  python的列表是運用較爲頻繁的數據類型，其與元組非常像，區別在於列表的元素可以被修改。列表使用[]表示。元素類型也可以不同。列表也是有序的。

6.1 創建列表

• 創建空列表

List = []
print(type(List))

輸出結果爲：

<class 'list'>

  使用[]來創建列表，不同於元組，空列表後續可以增添和修改值。

• 創建多個元素元組

List1 = [1]                      #只含一個元素，[]符號不會與表達式衝突，因此不需要加,號
List2 = [1, "2", 3.0]            #含有多個元素的列表創建，可以由不同類型元素構成
List3 = [1, "2", 3.0,]           #創建列表，可以在每個元素末尾後加,
List4 = [1, List2]               #嵌套列表，創建多元素列表
print(type(List1))
print(List1)
print(List2)
print(List3)
print(List4)

輸出結果爲：

<class 'list'>
[1]
[1, '2', 3.0]
[1, '2', 3.0]
[1, [1, '2', 3.0]]

  創建只含一個元素的列表時，不需要像元組那樣必須加一個,號，因爲元組的符號是()會與表達式表示衝突，而列表是[]不會與表達式衝突。

• 創建一個元素同於其他列表的列表

List1 = []                 #創建空列表
List2 = [1,]               #創建單元素列表
List3 = [1, "2"]           #創建多元素列表
List4 = List1              #創建列表，其元素同List1列表
List5 = List2
List6 = List3

print(List1, List4)
print(List2, List5)
print(List3, List6)

輸出結果爲：

[] []
[1] [1]
[1, '2'] [1, '2']

6.2 訪問列表

  列表也是有序存儲，同字符串和數組一樣，列表也是通過元素的序號進行訪問。每個元素同樣都有正負兩個序號，同樣是使用[]符號進行索引，使用[:]進行截取。

List = [1, '2', 3.0]
print(f"{List[0]}, {List[1]}, {List[2]}")                #索引列表的元素，正序號
print(f"{List[-3]}, {List[-2]}, {List[-1]}")             #索引列表的元素，負序號

print(f"{List[1:]}")                                     #區間截取
print(f"{List[-2:]}")

輸出結果爲：

1, 2, 3.0
1, 2, 3.0
['2', 3.0]
['2', 3.0]

6.3 列表運算

  列表的運算除了列表之間的運算，還有對列表內元素的運算。

• 列表中元素的修改

List = [1, "2", 3.0]

List[2] = 3.3                     #修改列表元素的值
print(List)
#List[3] = 4                      #此時列表還沒有序號是3的元素，這樣操作並不是新增元素，會語法錯誤
List.append(4)                    #使用列表內置函數爲列表中新增一個元素
print(List)
List.insert(3, 4.4)               #使用列表內置函數在序號3處插入一個元素，後續元素依次往後移動
print(List)
List.pop(3)                       #移除需序號3的元素
print(List)

輸出結果爲：

[1, '2', 3.3]
[1, '2', 3.3, 4]
[1, '2', 3.3, 4.4, 4]
[1, '2', 3.3, 4]

• 列表之間的運算

List1 = [1, 2, 3]
List2 = ['a', 'b', 'c']
print(List1 + List2)                    #將兩個列表拼接
print(List1 * 3)                        #將列表重複3次
print(3 in List1)                       #判斷List1中是否存在值爲3的元素
print(4 not in List1)                   #判斷List1中是否不存在值爲4的元素
del List1, List2                        #刪除List2

輸出結果爲：

[1, 2, 3, 'a', 'b', 'c']
[1, 2, 3, 1, 2, 3, 1, 2, 3]
True
True

  關於列表的操作還有很多內置的函數，這裏就不一一講了。

7 Set

  集合是一些不重複元素的集合，這些元素在集合內是無序的，不像元組和列表那樣每個元素都有確定且有序的索引號。python3的集合概念很像數學裏的集合概念。創建集合時使用{}，但當創建空集合時必須使用set()，因爲無元素的{}表示創建空的字典，有衝突所以只能滿足其一。

7.1 創建集合

• 創建空集合

Set = set()                 #創建空集合，輸出空集合顯示爲"set()"
print(type(Set))
print(Set)

輸出結果爲：

<class 'set'>
set()

• 創建非空集合

Set1 = {1,}                 #創建單元素集合
Set2 = {1, "2", 3.0}        #創建多元素集合，元素可以是不同類型
Set3 = set("aaabcdef")      #使用set函數帶一個字符串參數創建集合時，集合元素爲字符串中每個字符構成的集合，元素不能重複。
#Set4 = {1, 2, {1, 3}}      #集合不能嵌套定義
#Set5 = {1, 2, [1, 3]}      #列表不能作爲集合元素
Set6 = {1, 2, (1, 3)}       #元組可以作爲集合的元素
print(Set1)
print(Set2)
print(Set3)

Set1.pop()                  #集合Set1中只有一個元素，將這個元素彈出後變空元素
print(Set1)

輸出結果爲：

{1}
{1, 3.0, '2'}
{'b', 'a', 'f', 'e', 'c', 'd'}
{1, 2, (1, 3)}
set()

  以上程序你可以試着多運行幾次，你會發現集合中元素的順序不是固定的。

7.2 訪問集合

  集合元素是無序的，因此不能通過索引進行訪問。討論”元素位於集合中第幾個？“這樣的問題是沒有意義的，集合中的元素是不重複的（如果放入重複元素，那麼也只會有一個有效），我們關心的是某些元素存在還是不存在某個集合中，以及集合之間的運算。

Set1 = {1, 1, 2, 2}                         #嘗試創建有重複元素的集合
print(Set1)
Set1.add(1)                                 #繼續往裏添加重複元素
print(Set1)

print(1 in Set1)                            #判斷集合Set1中是否含有元素1
print(3 not in Set1)                        #判斷集合Set1中是否不含元素3

輸出結果爲：

{1, 2}
{1, 2}
True
True

7.3 集合的運算

Set1 = set("aaabcdef")
Set2 = set("abefgh")
print(Set1)
print(Set2)
print(Set1 - Set2)          #集合作差，從集合Set1中去掉兩集合共同有的元素。或者說集合Set1有而Set2沒有的元素
print(Set1 | Set2)          #集合Set1或Set2中含有的元素
print(Set1 & Set2)          #集合Set1和Set2都含有的元素
print(Set1 ^ Set2)          #不同時存在於集合Set1和Set2的元素，或者說兩集合的差異元素。

輸出結果爲：

{'e', 'a', 'f', 'd', 'b', 'c'}
{'h', 'e', 'g', 'a', 'f', 'b'}
{'d', 'c'}
{'h', 'e', 'g', 'a', 'f', 'd', 'b', 'c'}
{'a', 'b', 'f', 'e'}
{'h', 'g', 'd', 'c'}

  關於集合中元素的增添，刪除，求集合的大小等操作其實就是python3集合內置函數的運用，這裏就不介紹了，我們主要討論的是幾種數據類型的特性。幾種類型的內置函數都比較相似，很容易掌握和記憶。

8 Dictionary

  字典是很強大的數據類型，已經有較多腳本語言都支持字典類型。字典也集合一樣也使用{}進行表示。每個元素都由一個鍵和一個值構成，鍵在字典中必須是唯一的，因爲字典也是無序的，字典中兩個元素你說不清楚誰先誰後，元素是靠鍵來索引的。不同元素的值是允許重複和修改的。其元素的值可以是任意類型，但鍵是不允許修改的（鍵可以是常量——字符串、數字、元組），所以你想修改字典中某個元素的鍵，請將該元素刪除後重新添加。

8.1 創建字典

• 創建空字典

dic = {}
print(type(dic))

輸出結果爲：

<class 'dict'>

• 創建非空字典

dic1 = {1:1}                                                      #創建單元素字典
dic2 = {1:1, "2":"2", 3.0:3.0, (1, 4):(1, 4), 5:[1, 2], 6:{1, 6}} #鍵可以是常亮字符串、數字、元組，而值可以是任意類型
dic3 = {1:1, 1:2}                                                 #相同的鍵被賦多次值事，值只會是最新的依次。
print(dic1)
print(dic2)
print(dic3)

輸出結果爲：

{1: 1}
{1: 1, '2': '2', 3.0: 3.0, (1, 4): (1, 4), 5: [1, 2], 6: {1, 6}}
{1: 2}

8.2 訪問字典

  因爲字典是無序的，所以不能按序號訪問，但是每個元素都有唯一的鍵値，字典是按鍵値訪問的。

dic1 = {1:1, "2":"2", 3.0:3.0, (1, 4):(1, 4), 5:[1, 2], 6:{1, 6}} #鍵可以是常亮字符串、數字、元組，而值可以是任意類型
print(dic1[1], dic1["2"])                                         #按鍵値訪問字典

輸出結果爲：

1 2

8.3 字典運算

  字典主要用於查詢，對字典的操作主要是對字典中元素的操作，所以字典之間沒有啥運算。

dic1 = {1:1, "2":"2"}
dic1["2"] = 2               #修改字典中鍵對應的元素值
print(dic1)
del dic1["2"]               #刪除鍵對應的元素
print(dic1)
dic1.clear()                #清空字典所用元素
print(dic1)
dic1[5] = 5                 #字典中添加新元素，直接往新鍵裏寫值會自動創建新元素
print(dic1)
del dic1                    #刪除整個字典

輸出結果爲：

{1: 1, '2': 2}
{1: 1}
{}
{5: 5}

  字典同樣也有很多內置函數，這些庫函數需要用的時候邊查邊學比較好。