9、基本資料型別及內建方法
阿新 • • 發佈：2020-11-05
一 引子
資料型別是用來記錄事物狀態的，而事物的狀態是不斷變化的(如:一個人年齡的增長（操作int型別） ，單個人名的修改（操作str型別），學生列表中增加學生（操作list型別）等)，這意味著我們在開發程式時需要頻繁對資料進行操作，為了提升我們的開發效率， python針對這些常用的操作，為每一種資料型別內建了一系列方法。本章的主題就是帶大家詳細瞭解下它們，以及每種資料型別的詳細定義、型別轉換。
二 數字型別int與float
2.1 定義
# 1、定義： # 1.1 整型int的定義 age=10 # 本質age = int(10) # 1.2 浮點型float的定義 salary=3000.3 # 本質salary=float(3000.3) # 注意：名字+括號的意思就是呼叫某個功能，比如 # print(...)呼叫列印功能 # int(...)呼叫建立整型資料的功能 # float(...)呼叫建立浮點型資料的功能
2.2 型別轉換
# 1、資料型別轉換 # 1.1 int可以將由純整數構成的字串直接轉換成整型，若包含其他任意非整數符號，則會報錯 >>> s = '123' >>> res = int(s) >>> res,type(res) (123, <class 'int'>) >>> int('12.3') # 錯誤演示：字串內包含了非整數符號. Traceback (most recent call last): File "<stdin>", line 1, in <module> ValueError: invalid literal for int() with base 10: '12.3' # 1.2 float同樣可以用來做資料型別的轉換 >>> s = '12.3' >>> res=float(s) >>> res,type(res) (12.3, <class 'float'>)
2.3 使用
數字型別主要就是用來做數學運算與比較運算，因此數字型別除了與運算子結合使用之外，並無需要掌握的內建方法
三 字串
3.1 定義：
# 定義：在單引號\雙引號\三引號內包含一串字元
name1 = 'amgulen' # 本質:name = str('任意形式內容')
name2 = "lili" # 本質:name = str("任意形式內容")
name3 = """ricky""" # 本質:name = str("""任意形式內容""")
3.2 型別轉換
# 資料型別轉換：str()可以將任意資料型別轉換成字串型別，例如 >>> type(str([1,2,3])) # list->str <class 'str'> >>> type(str({"name":"amgulen","age":18})) # dict->str <class 'str'> >>> type(str((1,2,3))) # tuple->str <class 'str'> >>> type(str({1,2,3,4})) # set->str <class 'str'>
3.3 使用
3.3.1 優先掌握的操作
>>> str1 = 'hello python!'
# 1.按索引取值(正向取，反向取)：
# 1.1 正向取(從左往右)
>>> str1[6]
p
# 1.2 反向取(負號表示從右往左)
>>> str1[-4]
h
# 1.3 對於str來說，只能按照索引取值，不能改
>>> str1[0]='H' # 報錯TypeError
# 2.切片(顧頭不顧尾，步長)
# 2.1 顧頭不顧尾：取出索引為0到8的所有字元
>>> str1[0:9]
hello pyt
# 2.2 步長：0:9:2,第三個引數2代表步長，會從0開始，每次累加一個2即可，所以會取出索引0、2、4、6、8的字元
>>> str1[0:9:2]
hlopt
# 2.3 反向切片
>>> str1[::-1] # -1表示從右往左依次取值
!nohtyp olleh
# 3.長度len
# 3.1 獲取字串的長度，即字元的個數，但凡存在於引號內的都算作字元)
>>> len(str1) # 空格也算字元
13
# 4.成員運算 in 和 not in
# 4.1 int:判斷hello 是否在 str1裡面
>>> 'hello' in str1
True
# 4.2 not in:判斷tony 是否不在 str1裡面
>>> 'tony' not in str1
True
# 5.strip移除字串首尾指定的字元(預設移除空格)
# 5.1 括號內不指定字元，預設移除首尾空格
>>> str1 = ' life is short! '
>>> str1.strip()
life is short!
# 5.2 括號內指定字元，移除首尾指定的字元
>>> str2 = '**tony**'
>>> str2.strip('*')
tony
# 6.切分split
# 6.1 括號內不指定字元，預設以空格作為切分符號
>>> str3='hello world'
>>> str3.split()
['hello', 'world']
# 6.2 括號內指定分隔字元，則按照括號內指定的字元切割字串
>>> str4 = '127.0.0.1'
>>> str4.split('.')
['127', '0', '0', '1'] # 注意:split切割得到的結果是列表資料型別
# 7.迴圈
>>> str5 = '今天你好嗎？'
>>> for line in str5: # 依次取出字串中每一個字元
... print(line)
...
今
天
你
好
嗎
？
3.3.2 需要掌握的操作
1.strip, lstrip, rstrip
>>> str1 = '**tony***'
>>> str1.strip('*') # 移除左右兩邊的指定字元
'tony'
>>> str1.lstrip('*') # 只移除左邊的指定字元
tony***
>>> str1.rstrip('*') # 只移除右邊的指定字元
**tony
2.lower(),upper()
>>> str2 = 'My nAme is tonY！'
>>> str2.lower() # 將英文字串全部變小寫
my name is tony！
>>> str2.upper() # 將英文字串全部變大寫
MY NAME IS TONY！
3.startswith,endswith
>>> str3 = 'tony jam'
# startswith()判斷字串是否以括號內指定的字元開頭，結果為布林值True或False
>>> str3.startswith('t')
True
>>> str3.startswith('j')
False
# endswith()判斷字串是否以括號內指定的字元結尾，結果為布林值True或False
>>> str3.endswith('jam')
True
>>> str3.endswith('tony')
False
4.格式化輸出之format
之前我們使用%s來做字串的格式化輸出操作，在傳值時，必須嚴格按照位置與%s一一對應，而字串的內建方法format則提供了一種不依賴位置的傳值方式
案例：
# format括號內在傳引數時完全可以打亂順序，但仍然能指名道姓地為指定的引數傳值，name=‘tony’就是傳給{name}
>>> str4 = 'my name is {name}, my age is {age}!'.format(age=18,name='tony')
>>> str4
'my name is tony, my age is 18!'
>>> str4 = 'my name is {name}{name}{name}, my age is {name}!'.format(name='tony', age=18)
>>> str4
'my name is tonytonytony, my age is tony!'
format的其他使用方式（瞭解）
# 類似於%s的用法，傳入的值會按照位置與{}一一對應
>>> str4 = 'my name is {}, my age is {}!'.format('tony', 18)
>>> str4
my name is tony, my age is 18!
# 把format傳入的多個值當作一個列表，然後用{索引}取值
>>> str4 = 'my name is {0}, my age is {1}!'.format('tony', 18)
>>> str4
my name is tony, my age is 18!
>>> str4 = 'my name is {1}, my age is {0}!'.format('tony', 18)
>>> str4
my name is 18, my age is tony!
>>> str4 = 'my name is {1}, my age is {1}!'.format('tony', 18)
>>> str4
my name is 18, my age is 18!
**5.split,rsplit **
# split會按照從左到右的順序對字串進行切分，可以指定切割次數
>>> str5='C:/a/b/c/d.txt'
>>> str5.split('/',1)
['C:', 'a/b/c/d.txt']
# rsplit剛好與split相反，從右往左切割，可以指定切割次數
>>> str5='a|b|c'
>>> str5.rsplit('|',1)
['a|b', 'c']
**6.join **
# 從可迭代物件中取出多個字串，然後按照指定的分隔符進行拼接，拼接的結果為字串
>>> '%'.join('hello') # 從字串'hello'中取出多個字串，然後按照%作為分隔符號進行拼接
'h%e%l%l%o'
>>> '|'.join(['tony','18','read']) # 從列表中取出多個字串，然後按照*作為分隔符號進行拼接
'tony|18|read'
7.replace
# 用新的字元替換字串中舊的字元
>>> str7 = 'my name is tony, my age is 18!' # 將tony的年齡由18歲改成73歲
>>> str7 = str7.replace('18', '73') # 語法:replace('舊內容', '新內容')
>>> str7
my name is tony, my age is 73!
# 可以指定修改的個數
>>> str7 = 'my name is tony, my age is 18!'
>>> str7 = str7.replace('my', 'MY',1) # 只把一個my改為MY
>>> str7
'MY name is tony, my age is 18!'
**8.isdigit **
# 判斷字串是否是純數字組成，返回結果為True或False
>>> str8 = '5201314'
>>> str8.isdigit()
True
>>> str8 = '123g123'
>>> str8.isdigit()
False
3.3.3 瞭解操作
# 1.find,rfind,index,rindex,count
# 1.1 find：從指定範圍內查詢子字串的起始索引，找得到則返回數字1，找不到則返回-1
>>> msg='tony say hello'
>>> msg.find('o',1,3) # 在索引為1和2(顧頭不顧尾)的字元中查詢字元o的索引
1
# 1.2 index:同find,但在找不到時會報錯
>>> msg.index('e',2,4) # 報錯ValueError
# 1.3 rfind與rindex：略
# 1.4 count:統計字串在大字串中出現的次數
>>> msg = "hello everyone"
>>> msg.count('e') # 統計字串e出現的次數
4
>>> msg.count('e',1,6) # 字串e在索引1~5範圍內出現的次數
1
# 2.center,ljust,rjust,zfill
>>> name='tony'
>>> name.center(30,'-') # 總寬度為30，字串居中顯示，不夠用-填充
-------------tony-------------
>>> name.ljust(30,'*') # 總寬度為30，字串左對齊顯示，不夠用*填充
tony**************************
>>> name.rjust(30,'*') # 總寬度為30，字串右對齊顯示，不夠用*填充
**************************tony
>>> name.zfill(50) # 總寬度為50，字串右對齊顯示，不夠用0填充
0000000000000000000000000000000000000000000000tony
# 3.expandtabs
>>> name = 'tony\thello' # \t表示製表符(tab鍵)
>>> name
tony hello
>>> name.expandtabs(1) # 修改\t製表符代表的空格數
tony hello
# 4.captalize,swapcase,title
# 4.1 captalize：首字母大寫
>>> message = 'hello everyone nice to meet you!'
>>> message.capitalize()
Hello everyone nice to meet you!
# 4.2 swapcase：大小寫翻轉
>>> message1 = 'Hi girl, I want make friends with you!'
>>> message1.swapcase()
hI GIRL, i WANT MAKE FRIENDS WITH YOU!
#4.3 title：每個單詞的首字母大寫
>>> msg = 'dear my friend i miss you very much'
>>> msg.title()
Dear My Friend I Miss You Very Much
# 5.is數字系列
#在python3中
num1 = b'4' #bytes
num2 = u'4' #unicode,python3中無需加u就是unicode
num3 = '四' #中文數字
num4 = 'Ⅳ' #羅馬數字
#isdigt:bytes,unicode
>>> num1.isdigit()
True
>>> num2.isdigit()
True
>>> num3.isdigit()
False
>>> num4.isdigit()
False
#isdecimal:uncicode(bytes型別無isdecimal方法)
>>> num2.isdecimal()
True
>>> num3.isdecimal()
False
>>> num4.isdecimal()
False
#isnumberic:unicode,中文數字,羅馬數字(bytes型別無isnumberic方法)
>>> num2.isnumeric()
True
>>> num3.isnumeric()
True
>>> num4.isnumeric()
True
# 三者不能判斷浮點數
>>> num5 = '4.3'
>>> num5.isdigit()
False
>>> num5.isdecimal()
False
>>> num5.isnumeric()
False
'''
總結:
最常用的是isdigit,可以判斷bytes和unicode型別,這也是最常見的數字應用場景
如果要判斷中文數字或羅馬數字,則需要用到isnumeric。
'''
# 6.is其他
>>> name = 'tony123'
>>> name.isalnum() #字串中既可以包含數字也可以包含字母
True
>>> name.isalpha() #字串中只包含字母
False
>>> name.isidentifier()
True
>>> name.islower() # 字串是否是純小寫
True
>>> name.isupper() # 字串是否是純大寫
False
>>> name.isspace() # 字串是否全是空格
False
>>> name.istitle() # 字串中的單詞首字母是否都是大寫
False
四 列表
4.1 定義
# 定義：在[]內,用逗號分隔開多個任意資料型別的值
l1 = [1,'a',[1,2]] # 本質:l1 = list([1,'a',[1,2]])
4.2 型別轉換
# 但凡能被for迴圈遍歷的資料型別都可以傳給list()轉換成列表型別，list()會跟for迴圈一樣遍歷出資料型別中包含的每一個元素然後放到列表中
>>> list('wdad') # 結果：['w', 'd', 'a', 'd']
>>> list([1,2,3]) # 結果：[1, 2, 3]
>>> list({"name":"jason","age":18}) #結果：['name', 'age']
>>> list((1,2,3)) # 結果：[1, 2, 3]
>>> list({1,2,3,4}) # 結果：[1, 2, 3, 4]
4.3 使用
4.3.1 優先掌握的操作
# 1.按索引存取值(正向存取+反向存取)：即可存也可以取
# 1.1 正向取(從左往右)
>>> my_friends=['tony','amgulen','tom',4,5]
>>> my_friends[0]
tony
# 1.2 反向取(負號表示從右往左)
>>> my_friends[-1]
5
# 1.3 對於list來說，既可以按照索引取值，又可以按照索引修改指定位置的值，但如果索引不存在則報錯
>>> my_friends = ['tony','jack','amgulen',4,5]
>>> my_friends[1] = 'martthow'
>>> my_friends
['tony', 'martthow', 'amgulen', 4, 5]
# 2.切片(顧頭不顧尾，步長)
# 2.1 顧頭不顧尾：取出索引為0到3的元素
>>> my_friends[0:4]
['tony', 'amgulen', 'tom', 4]
# 2.2 步長：0:4:2,第三個引數2代表步長，會從0開始，每次累加一個2即可，所以會取出索引0、2的元素
>>> my_friends[0:4:2]
['tony', 'tom']
# 3.長度
>>> len(my_friends)
5
# 4.成員運算in和not in
>>> 'tony' in my_friends
True
>>> 'xxx' not in my_friends
True
# 5.新增
# 5.1 append()列表尾部追加元素
>>> l1 = ['a','b','c']
>>> l1.append('d')
>>> l1
['a', 'b', 'c', 'd']
# 5.2 extend()一次性在列表尾部新增多個元素
>>> l1.extend(['a','b','c'])
>>> l1
['a', 'b', 'c', 'd', 'a', 'b', 'c']
# 5.3 insert()在指定位置插入元素
>>> l1.insert(0,"first") # 0表示按索引位置插值
>>> l1
['first', 'a', 'b', 'c', 'd', 'a', 'b', 'c']
# 6.刪除
# 6.1 del
>>> l = [11,22,33,44]
>>> del l[2] # 刪除索引為2的元素
>>> l
[11,22,44]
# 6.2 pop()預設刪除列表最後一個元素，並將刪除的值返回，括號內可以通過加索引值來指定刪除元素
>>> l = [11,22,33,22,44]
>>> res=l.pop()
>>> res
44
>>> res=l.pop(1)
>>> res
22
# 6.3 remove()括號內指名道姓表示要刪除哪個元素，沒有返回值
>>> l = [11,22,33,22,44]
>>> res=l.remove(22) # 從左往右查詢第一個括號內需要刪除的元素
>>> print(res)
None
# 7.reverse()顛倒列表內元素順序
>>> l = [11,22,33,44]
>>> l.reverse()
>>> l
[44,33,22,11]
# 8.sort()給列表內所有元素排序
# 8.1 排序時列表元素之間必須是相同資料型別，不可混搭，否則報錯
>>> l = [11,22,3,42,7,55]
>>> l.sort()
>>> l
[3, 7, 11, 22, 42, 55] # 預設從小到大排序
>>> l = [11,22,3,42,7,55]
>>> l.sort(reverse=True) # reverse用來指定是否跌倒排序，預設為False
>>> l
[55, 42, 22, 11, 7, 3]
# 8.2 瞭解知識：
# 我們常用的數字型別直接比較大小，但其實，字串、列表等都可以比較大小，原理相同：都是依次比較對應位置的元素的大小，如果分出大小，則無需比較下一個元素，比如
>>> l1=[1,2,3]
>>> l2=[2,]
>>> l2 > l1
True
# 字元之間的大小取決於它們在ASCII表中的先後順序，越往後越大
>>> s1='abc'
>>> s2='az'
>>> s2 > s1 # s1與s2的第一個字元沒有分出勝負，但第二個字元'z'>'b',所以s2>s1成立
True
# 所以我們也可以對下面這個列表排序
>>> l = ['A','z','adjk','hello','hea']
>>> l.sort()
>>> l
['A', 'adjk', 'hea', 'hello','z']
# 9.迴圈
# 迴圈遍歷my_friends列表裡面的值
for line in my_friends:
print(line)
'tony'
'jack'
'amgulen'
4
5
4.3.2 瞭解操作
>>> l=[1,2,3,4,5,6]
>>> l[0:3:1]
[1, 2, 3] # 正向步長
>>> l[2::-1]
[3, 2, 1] # 反向步長
# 通過索引取值實現列表翻轉
>>> l[::-1]
[6, 5, 4, 3, 2, 1]
五 元組
5.1 作用
元組與列表類似，也是可以存多個任意型別的元素，不同之處在於元組的元素不能修改，即元組相當於不可變的列表，用於記錄多個固定不允許修改的值，單純用於取
5.2 定義方式
# 在()內用逗號分隔開多個任意型別的值
>>> countries = ("中國"，"美國"，"英國") # 本質:countries = tuple("中國"，"美國"，"英國")
# 強調：如果元組內只有一個值，則必須加一個逗號，否則()就只是包含的意思而非定義元組
>>> countries = ("中國"，) # 本質:countries = tuple("中國")
5.3 型別轉換
# 但凡能被for迴圈的遍歷的資料型別都可以傳給tuple()轉換成元組型別
>>> tuple('wdad') # 結果：('w', 'd', 'a', 'd')
>>> tuple([1,2,3]) # 結果：(1, 2, 3)
>>> tuple({"name":"amgulen","age":18}) # 結果：('name', 'age')
>>> tuple((1,2,3)) # 結果：(1, 2, 3)
>>> tuple({1,2,3,4}) # 結果：(1, 2, 3, 4)
# tuple()會跟for迴圈一樣遍歷出資料型別中包含的每一個元素然後放到元組中
5.4 使用
>>> tuple1 = (1, 'hhaha', 15000.00, 11, 22, 33)
# 1、按索引取值(正向取+反向取)：只能取，不能改否則報錯！
>>> tuple1[0]
1
>>> tuple1[-2]
22
>>> tuple1[0] = 'hehe' # 報錯：TypeError:
# 2、切片(顧頭不顧尾，步長)
>>> tuple1[0:6:2]
(1, 15000.0, 22)
# 3、長度
>>> len(tuple1)
6
# 4、成員運算 in 和 not in
>>> 'hhaha' in tuple1
True
>>> 'hhaha' not in tuple1
False
# 5、迴圈
>>> for line in tuple1:
... print(line)
1
hhaha
15000.0
11
22
33
六 字典
6.1 定義方式
# 定義：在{}內用逗號分隔開多元素，每一個元素都是key:value的形式，其中value可以是任意型別，而key則必須是不可變型別，詳見第八小節，通常key應該是str型別，因為str型別會對value有描述性的功能
info={'name':'tony','age':18,'sex':'male'} #本質info=dict({....})
# 也可以這麼定義字典
info=dict(name='tony',age=18,sex='male') # info={'age': 18, 'sex': 'male', 'name': 'tony'}
6.2 型別轉換
# 轉換1:
>>> info=dict([['name','tony'],('age',18)])
>>> info
{'age': 18, 'name': 'tony'}
# 轉換2：fromkeys會從元組中取出每個值當做key，然後與None組成key:value放到字典中
>>> {}.fromkeys(('name','age','sex'),None)
{'age': None, 'sex': None, 'name': None}
6.3 使用
6.3.1 優先掌握的操作
# 1、按key存取值：可存可取
# 1.1 取
>>> dic = {
... 'name': 'xxx',
... 'age': 18,
... 'hobbies': ['play game', 'basketball']
... }
>>> dic['name']
'xxx'
>>> dic['hobbies'][1]
'basketball'
# 1.2 對於賦值操作，如果key原先不存在於字典，則會新增key:value
>>> dic['gender'] = 'male'
>>> dic
{'name': 'tony', 'age': 18, 'hobbies': ['play game', 'basketball'],'gender':'male'}
# 1.3 對於賦值操作，如果key原先存在於字典，則會修改對應value的值
>>> dic['name'] = 'tony'
>>> dic
{'name': 'tony', 'age': 18, 'hobbies': ['play game', 'basketball']}
# 2、長度len
>>> len(dic)
3
# 3、成員運算in和not in
>>> 'name' in dic # 判斷某個值是否是字典的key
True
# 4、刪除
>>> dic.pop('name') # 通過指定字典的key來刪除字典的鍵值對
>>> dic
{'age': 18, 'hobbies': ['play game', 'basketball']}
# 5、鍵keys()，值values()，鍵值對items()
>>> dic = {'age': 18, 'hobbies': ['play game', 'basketball'], 'name': 'xxx'}
# 獲取字典所有的key
>>> dic.keys()
dict_keys(['name', 'age', 'hobbies'])
# 獲取字典所有的value
>>> dic.values()
dict_values(['xxx', 18, ['play game', 'basketball']])
# 獲取字典所有的鍵值對
>>> dic.items()
dict_items([('name', 'xxx'), ('age', 18), ('hobbies', ['play game', 'basketball'])])
# 6、迴圈
# 6.1 預設遍歷的是字典的key
>>> for key in dic:
... print(key)
...
age
hobbies
name
# 6.2 只遍歷key
>>> for key in dic.keys():
... print(key)
...
age
hobbies
name
# 6.3 只遍歷value
>>> for key in dic.values():
... print(key)
...
18
['play game', 'basketball']
xxx
# 6.4 遍歷key與value
>>> for key in dic.items():
... print(key)
...
('age', 18)
('hobbies', ['play game', 'basketball'])
('name', 'xxx')
6.3.2 需要掌握的操作
1.get()
>>> dic= {'k1':'amgulen','k2':'Tony','k3':'JY'}
>>> dic.get('k1')
'amgulen' # key存在，則獲取key對應的value值
>>> res=dic.get('xxx') # key不存在，不會報錯而是預設返回None
>>> print(res)
None
>>> res=dic.get('xxx',666) # key不存在時，可以設定預設返回的值
>>> print(res)
666
# ps:字典取值建議使用get方法
2.pop()
>>> dic= {'k1':'amgulen','k2':'Tony','k3':'JY'}
>>> v = dic.pop('k2') # 刪除指定的key對應的鍵值對,並返回值
>>> dic
{'k1': 'amgulen', 'kk2': 'JY'}
>>> v
'Tony'
3.popitem()
>>> dic= {'k1':'amgulen','k2':'Tony','k3':'JY'}
>>> item = dic.popitem() # 隨機刪除一組鍵值對,並將刪除的鍵值放到元組內返回
>>> dic
{'k3': 'JY', 'k2': 'Tony'}
>>> item
('k1', 'amgulen')
4.update()
# 用新字典更新舊字典，有則修改，無則新增
>>> dic= {'k1':'amgulen','k2':'Tony','k3':'JY'}
>>> dic.update({'k1':'JN','k4':'xxx'})
>>> dic
{'k1': 'JN', 'k3': 'JY', 'k2': 'Tony', 'k4': 'xxx'}
5.fromkeys()
>>> dic = dict.fromkeys(['k1','k2','k3'],[])
>>> dic
{'k1': [], 'k2': [], 'k3': []}
6.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}
七 集合
7.1 作用
集合、list、tuple、dict一樣都可以存放多個值，但是集合主要用於：去重、關係運算
7.2 定義
"""
定義：在{}內用逗號分隔開多個元素，集合具備以下三個特點：
1：每個元素必須是不可變型別
2：集合內沒有重複的元素
3：集合內元素無序
"""
s = {1,2,3,4} # 本質 s = set({1,2,3,4})
# 注意1：列表型別是索引對應值，字典是key對應值，均可以取得單個指定的值，而集合型別既沒有索引也沒有key與值對應，所以無法取得單個的值，而且對於集合來說，主要用於去重與關係元素，根本沒有取出單個指定值這種需求。
# 注意2:{}既可以用於定義dict，也可以用於定義集合，但是字典內的元素必須是key:value的格式，現在我們想定義一個空字典和空集合，該如何準確去定義兩者?
d = {} # 預設是空字典
s = set() # 這才是定義空集合
7.3 型別轉換
# 但凡能被for迴圈的遍歷的資料型別（強調：遍歷出的每一個值都必須為不可變型別）都可以傳給set()轉換成集合型別
>>> s = set([1,2,3,4])
>>> s1 = set((1,2,3,4))
>>> s2 = set({'name':'amgulen',})
>>> s3 = set('pig')
>>> s,s1,s2,s3
{1, 2, 3, 4} {1, 2, 3, 4} {'name'} {'p', 'i', 'g'}
7.4 使用
7.4.1 關係運算
我們定義兩個集合friends與friends2來分別存放兩個人的好友名字，然後以這兩個集合為例講解集合的關係運算
>>> friends1 = {"zero","kevin","jason","egon"} # 使用者1的好友們
>>> friends2 = {"Jy","ricky","jason","egon"} # 使用者2的好友們
兩個集合的關係如下圖所示
# 1.合集(|)：求兩個使用者所有的好友（重複好友只留一個）
>>> friends1 | friends2
{'kevin', 'ricky', 'zero', 'jason', 'Jy', 'egon'}
# 2.交集(&)：求兩個使用者的共同好友
>>> friends1 & friends2
{'jason', 'egon'}
# 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 不存在包含關係，則返回True
>>> {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
7.4.2 去重
集合去重複有侷限性
# 1. 只能針對不可變型別
# 2. 集合本身是無序的，去重之後無法保留原來的順序
示例如下
>>> l=['a','b',1,'a','a']
>>> s=set(l)
>>> s # 將列表轉成了集合
{'b', 'a', 1}
>>> l_new=list(s) # 再將集合轉回列表
>>> l_new
['b', 'a', 1] # 去除了重複，但是打亂了順序
# 針對不可變型別，並且保證順序則需要我們自己寫程式碼實現，例如
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'}
]
7.4.3 其他操作
# 1.長度
>>> s={'a','b','c'}
>>> len(s)
3
# 2.成員運算
>>> 'c' in s
True
# 3.迴圈
>>> for item in s:
... print(item)
...
c
a
b
7.5 練習
"""
一.關係運算
有如下兩個集合，pythons是報名python課程的學員名字集合，linuxs是報名linux課程的學員名字集合
pythons={'jason','egon','kevin','ricky','gangdan','biubiu'}
linuxs={'kermit','tony','gangdan'}
1. 求出即報名python又報名linux課程的學員名字集合
2. 求出所有報名的學生名字集合
3. 求出只報名python課程的學員名字
4. 求出沒有同時這兩門課程的學員名字集合
"""
# 求出即報名python又報名linux課程的學員名字集合
>>> pythons & linuxs
# 求出所有報名的學生名字集合
>>> pythons | linuxs
# 求出只報名python課程的學員名字
>>> pythons - linuxs
# 求出沒有同時這兩門課程的學員名字集合
>>> pythons ^ linuxs
八 可變型別與不可變型別
可變資料型別：值發生改變時，記憶體地址不變，即id不變，證明在改變原值
不可變型別：值發生改變時，記憶體地址也發生改變，即id也變，證明是沒有在改變原值，是產生了新的值
數字型別:
>>> x = 10
>>> id(x)
1830448896
>>> x = 20
>>> id(x)
1830448928
# 記憶體地址改變了，說明整型是不可變資料型別，浮點型也一樣
字串
>>> x = "Jy"
>>> id(x)
938809263920
>>> x = "Ricky"
>>> id(x)
938809264088
# 記憶體地址改變了，說明字串是不可變資料型別
列表
>>> list1 = ['tom','jack','egon']
>>> id(list1)
486316639176
>>> list1[2] = 'kevin'
>>> id(list1)
486316639176
>>> list1.append('lili')
>>> id(list1)
486316639176
# 對列表的值進行操作時，值改變但記憶體地址不變，所以列表是可變資料型別
元組
>>> t1 = ("tom","jack",[1,2])
>>> t1[0]='TOM' # 報錯：TypeError
>>> t1.append('lili') # 報錯：TypeError
# 元組內的元素無法修改，指的是元組內索引指向的記憶體地址不能被修改
>>> t1 = ("tom","jack",[1,2])
>>> id(t1[0]),id(t1[1]),id(t1[2])
(4327403152, 4327403072, 4327422472)
>>> t1[2][0]=111 # 如果元組中存在可變型別，是可以修改，但是修改後的記憶體地址不變
>>> t1
('tom', 'jack', [111, 2])
>>> id(t1[0]),id(t1[1]),id(t1[2]) # 檢視id仍然不變
(4327403152, 4327403072, 4327422472)
字典
>>> dic = {'name':'egon','sex':'male','age':18}
>>>
>>> id(dic)
4327423112
>>> dic['age']=19
>>> dic
{'age': 19, 'sex': 'male', 'name': 'egon'}
>>> id(dic)
4327423112
# 對字典進行操作時，值改變的情況下，字典的id也是不變，即字典也是可變資料型別