python入門教程05-01 （python語法入門之基本數據類型及內置方法）

本篇文章介紹了python語法入門之基本數據類型及內置方法，瞭解有限掌握層級及數據類型處理的方法有哪些，下面咱們一塊兒來仔細看看吧~~~

一 引子

​ 數據類型是用來記錄事物狀態的，而事物的狀態是不斷變化的(如:一我的年齡的增加（操做int類型） ，單我的名的修改（操做str類型），學生列表中增長學生（操做list類型）等)，這意味着咱們在開發程序時須要頻繁對數據進行操做，爲了提高咱們的開發效率， python針對這些經常使用的操做，爲每一種數據類型內置了一系列方法。本章的主題就是帶你們詳細瞭解下它們，以及每種數據類型的詳細定義、類型轉換。

二 數字類型int與float

2.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 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 = 'jason' # 本質: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":"jason","age":18})) #dict->str>>> type(str((1,2,3))) # tuple->str>>> type(str({1,2,3,4})) # set->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、二、四、六、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' #bytesnum2 = u'4' #unicode,python3中無需加u就是unicodenum3 = '四' #中文數字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','jason','tom',4,5]>>> my_friends[0]

tony# 1.2 反向取(負號表示從右往左)>>> my_friends[-1] 5# 1.3 對於list來講，既能夠按照索引取值，又能夠按照索引修改指定位置的值，但若是索引不存在則報錯>>> my_friends = ['tony','jack','jason',4,5]>>> my_friends[1] = 'martthow'>>> my_friends

['tony', 'martthow', 'jason', 4, 5]# 2.切片(顧頭不顧尾，步長)# 2.1 顧頭不顧尾：取出索引爲0到3的元素>>> my_friends[0:4]

['tony', 'jason', '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_friendsTrue>>> 'xxx' not in my_friendsTrue# 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()>>> res44>>> res=l.pop(1)>>> res22# 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 > l1True# 字符之間的大小取決於它們在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''jason'45

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":"jason","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) # 一、按索引取值(正向取+反向取)：只能取，不能改不然報錯！ >>> tuple1[0]1>>> tuple1[-2]22>>> tuple1[0] = 'hehe' # 報錯：TypeError:# 二、切片(顧頭不顧尾，步長)>>> tuple1[0:6:2]

(1, 15000.0, 22)# 三、長度>>> len(tuple1) 6# 四、成員運算 in 和 not in>>> 'hhaha' in tuple1 True>>> 'hhaha' not in tuple1 False # 五、循環>>> for line in tuple1:... print(line)1hhaha15000.0112233

六 字典

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 優先掌握的操做

一、按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']}# 二、長度len>>> len(dic) 3# 三、成員運算in和not in>>> 'name' in dic # 判斷某個值是不是字典的keyTrue# 四、刪除>>> dic.pop('name') # 經過指定字典的key來刪除字典的鍵值對>>> dic

{'age': 18, 'hobbies': ['play game', 'basketball']}# 五、鍵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.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':'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 # ps:字典取值建議使用get方法

2.pop()

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

{'k1': 'jason', 'kk2': 'JY'}>>> v'Tony'

3.popitem()

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

{'k3': 'JY', 'k2': 'Tony'}>>> item

('k1', 'jason')

4.update()

用新字典更新舊字典，有則修改，無則添加>>> dic= {'k1':'jason','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)>>> res333>>> dic # 字典中新增了鍵值對{'k1': 111, 'k3': 333, 'k2': 222}# key存在則不作任何修改，並返回已存在key對應的value值>>> dic={'k1':111,'k2':222}>>> res=dic.setdefault('k1',666)>>> res111>>> 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':'jason',})>>> s3 = set('egon')>>> s,s1,s2,s3

{1, 2, 3, 4} {1, 2, 3, 4} {'name'} {'e', 'o', 'g', 'n'}

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 == friends2False# 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 sTrue# 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也是不變，即字典也是可變數據類型

九 數據類型總結