python基礎資料型別補充及內建方法

1.引入

之前我們已經對python基礎資料型別有了一個簡單的認識，比如有字串，布林值，列表，元組，字典等。但是

那些都是基礎的瞭解，對於基礎資料型別我們還要進一步的學習他們，以及他們常用的內建方法。

2. 數字型別

2.1 定義

age = 18 

# 實際上這是python的字面量語法,內部呼叫的是age=int(10)
# 先是在堆區中申請一塊記憶體空間,把10存進去,然後把記憶體地址繫結給棧區的變數名.

2.2 型別轉換

2.2.1 字串轉數字

int可以將由純整數構成的字串直接轉換成整型，若包含其他任意非整數符號，則會報錯。

s = '1234'
ret = int(s)
print(ret,type(ret))  # 1234  <class 'int'>

int('13.14') # 錯誤演示：字串內包含了非整數符號.
Traceback (most recent call last):
  File "<stdin>", line 1, in <module>
ValueError: invalid literal for int() with base 10: '13.14'
 

2.2.2 進位制轉換

十進位制轉其他進位制

10進位制 ---> 2進位制

res1 = bin(11)

print(res1)  # 0b1011

10進位制 ---> 8進位制

res2 = oct(11)
print(res2)  # 0o13

10進位制 ---> 16進位制

res3 = hex(11)
print(res3)  # 0xb

其他進位制轉10進位制

2進位制 ---> 10進位制

res4 = int('11', base=2)
print(res4)   # 3

8進位制 ---> 10進位制

res5 = int('13', base=8)
print(res5)   # 11
 

16進位制 ---> 10進位制

res6 = int('b', base=16)
print(res6)  # 11

關於float型別你瞭解一個型別轉換，目前就可以了。

res7 = float("3.14115926")
print(res7,type(res7))    # 3.14115926 <class 'float'> 

2.3 內建方法

int和float沒有需要掌握的內建方法，他們的使用就是數學運算+比較運算。

3. 字串型別

3.1 定義

msg = 'hello'   # msg = str('hello')
print(msg) # hello
 

3.2 型別轉換

3.2.1 str可以把任意其他型別都轉成字串

是不是很快牛逼，是真是假，我們一探究竟。

# 數字 --> str
num = 1234
res1 = str(num)
print(res1)     # '1234' <class 'str'>

# 列表 --> str
lst = ['tom',1234,['999',250],'shabi']
res2 = str(lst)
print(res2,type(res2))   # ['tom',1234,['999',250],'shabi']  <class 'str'>

# 字典 --> str
dic = {'name':'ymn'}
res3 = str(dic)
print(res3,type(res3))  # {'name':'ymn'}  <class 'str'>

3.3 內建方法

3.3.1 按照索引取值(正向取,反向取) 只能取

msg = "ymn love xcy"

# 正向取
print(msg[0])
print(msg[5])

# 反向取
print(msg[-1])

#只能取
msg[0] = "H"  # 報錯

3.3.2 切片

索引的拓展應用,從一個大字串中拷貝出一個字串 (顧頭不顧尾,步長)

msg = "ymn love xcy"
# 顧頭不顧尾
res9 = msg[0:3] # ymn

3.3.3 步長

msg = "ymn love xcy"
res = msg[0:7:2] # 0 2 4 6
print(res) # ynlv

3.3.4 反向步長

msg = "ymn love xcy"
res = msg[0:7:-1]
print(res)   # 空,原因是切片和步長的方向不一致

res = msg[7:0:-1]
print(res)   # evol nm

3.3.5 通過切片拷貝字串

msg = "ymn love xcy"
msg1 = msg[0:13]
print(msg1)    # "ymn love xcy"
msg2 = msg[:]  # 不寫索引,預設開頭:結束
print(msg2)    # "ymn love xcy"

3.3.6 把字串倒過來

msg = "ymn love xcy"
msg1 = msg[::-1]
print(msg1)     # 'ycx evol nmy'

3.3.7 長度len

msg = "ymn love xcy"
print(len(msg))   # 12

3.3.8 成員運算in和not in

# 判斷一個子字串是否存在於一個大字串中
msg = "ymn love xcy"

print("ymn" in msg)  # True
print("sb" not in msg)  # True

3.3.8 移除字串左右兩側的符號strip

# 預設去掉空格
name = "    ymn    "
new_name = name.strip()

print(name) # 不會改變原值  "    ymn    "
print(new_name) # 是產生了新值 'ymn'

# 指定去除符號
msg = "***有貓膩***"
new_msg = msg.strip("*")
print(new_msg) # 有貓膩

瞭解: strip只去除兩邊的，不會去除中間的

因為strip內部是先從字串的左邊開始一一比較是不是要去除的符號,如果是就去除,然後繼續比較

如果不是就會從字串的右側開始一一比較是不是要去除的符號,直到不是要去除的符號,然後停止比較

返回去除後的新值。

# strip可以設定多個去除符號
msg = "*()-=ymn+++*&^"
new_msg = msg.strip("*()-+=&^")
print(new_msg)   # ymn

補充: lstrip rstrip

msg = "***ymn***"

print(msg.strip("*"))   # ymn
print(msg.lstrip("*"))  # ymn***,只去除左邊
print(msg.rstrip("*"))  # ***ymn,只去除右邊

3.3.9 分割split

把字串按照某種分割符進行切分,得到一個列表

info = "ymn 20 男"
# 預設按照空格分割
lst = info.split()
print(lst)  # ['ymn','20','男']

# 指定分隔符
info = "ymn:20:男"
lst = info.split(":")
print(lst)  # ['ymn','20','男']

# 指定分割的次數,預設是全部分割
info = "ymn:20:男"
lst = info.split(":", 1)
print(lst)   # ['ymn','20:男']

補充 : split rsplit

# 預設切分是從左到右,rsplit是從右向左,只有當指定分割次數的他們兩個的區分才能看出啦
msg = 'ymn:男:21'
print(msg.split(':',1))   # ['ymn', '男:21']
print(msg.rsplit(":",1))  # ['ymn:男', '21']

3.3.10 大小寫轉換 lower upper

msg = 'aaaBBccDD'
print(msg.lower())  # aaabbccdd,大寫轉小寫
print(msg.upper())  # AAABBCCDD,小寫轉大寫

3.3.11 startswith endswith

msg = 'ymn love xcy'
print(msg.startswith('ymn'))  # 判斷是否以什麼開頭
print(msg.endswith('xcy'))    # 判斷是否以什麼結尾

3.3.12 formate的三種方式

3.3.13 join拼接

# "拼接符".join(列表/字串),這也是將列表轉化為字串的方式

lst = ['ymn','21','男']
print(':'.join(lst))  # ymn:21:男

msg = 'ymn'
print('nb'.join(msg)) # ynbmnbnnb

3.3.14 replace 替換

msg = "**ymn**"
new_msg = msg.replace('*','=') # replace(待替換的字元,替換成的字元,替換次數(預設所有))
print(new_msg)  # '==ymn=='

3.3.15 isdigit

# 判斷字串是否全部由數字組成
print('123'.isdigit())  # True
print('12.3'.isdigit()) # False

3.3.16 find index

都是通過字元查詢索引,但是find找不到返回-1,index則報錯

msg = "ymn love xcy"
print(msg.find("n")) # 返回要查詢的字串在大字串中的起始索引
print(msg.find("xcy"))

print(msg.index("n")) # 返回要查詢的字串在大字串中的起始索引
print(msg.index("xcy"))

print(msg.find('alex'))  # 返回-1,代表找不到
print(msg.index('alex')) # 找不到,報錯

3.3.17 count 計數

# 統計小字串在大字串中出現的次數
msg = 'ymn love xcy'
print(msg.count('y'))  # 2
print(msg.count('ymn')) # 1

3.3.17 center,ljus,rjust,zfill 控制輸出的

print('ymn'.center(20, '*'))  # 顯示寬度為20,居中,不夠的用"*"填充
print('ymn'.ljust(20, '*'))   # 顯示寬度為20,左對齊,不夠的用"*"填充
print('ymn'.rjust(20, '*'))   # 顯示寬度為20,右對齊,不夠的用"*"填充
print('ymn'.zfill(20))        # 顯示寬度為20,用0填充

3.3.18 expandtabs

# 設定製表符代表的空格數
msg = 'ymn\tnb'
print(msg.expandtabs(2))  # 'ymn  nb'

3.3.19 captalize swapcase title

print('ymn'.capitalize())   # Ymn    字串首字母大寫
print('ymn NB'.swapcase())  # YMN nb 字串大小寫翻轉
print('ymn nb'.title())     # Ymn Nb 每個單詞首字母大寫

3.3.20 is系列

# 判斷字串是否是全小寫字母組成
print('ymn'.islower()) 

# 判斷字串是否是全小寫字母組成
print('YMN'.isupper())  

# 判斷字串的每個單詞的首字母是否大寫
print('Ymn love xcy'.istitle()) 

# 判斷字串是否由數字或字母組成
print('Ymn 666'.isalnum())  

# 判斷字串是否由字母組成
print('Ymn'.isalpha()) 

# 判斷字串是否由空格組成
print('    '.isspace())  

# 判斷字串是否符合識別符號的命名規範
print('Ymn'.isidentifier())  

3.3.21 數字系列

num1 = b'4'  # bytes
num2 = u'4'  # unicode,python3中無需加u就是unicode
num3 = '四'  # 中文數字
num4 = 'Ⅳ'  # 羅馬數字

# isdigit只能識別:num1,num2
print(num1.isdigit()) # True
print(num2.isdigit()) # True
print(num3.isdigit()) # False
print(num4.isdigit()) # False

# isnumeric可以識別:num2,num3,num4 (銀行收款)
print(num2.isnumeric()) # True
print(num3.isnumeric()) # True
print(num4.isnumeric()) # True

# isdecimal只能識別:num2
print(num2.isdecimal()) # True
print(num3.isdecimal()) # False
print(num4.isdecimal()) # False

4. 列表型別

4.1 定義

# 1.作用: 按位置存放多個值
# 2.定義: 在中括號中按照逗號分隔開,多個任意型別的值
l = [1, 2, 3, 'ymn']  # l = list([1,2,3,"ymn"])

4.2 型別轉換

但凡能夠被for迴圈遍歷的型別都可以當做引數傳給list( )轉成列表

res = list("hello")  # list底層做的就是for迴圈那個引數,然後把每個值都放到列表中
print(res)    # ['h','e','l','l','o']

res1 = list({'k1':1,'k2':2})
print(res1)   # ['k1','k2']

4.3 內建方法

4.3.1 索引取值

按照索引存取值(正向/反向存取):即可以取也可以改

l = [1, 2, 3, 'ymn']
# 正向取
print(l[1])

# 反向取
print(l[-1])

# 可以取也可以改
# 索引存在則修改對應的值
l[2] = 999
print(l[2])

# 索引不存在,無論是取還是修改都會報錯
l[5] = 555
print(l)

4.3.2 切片(顧頭不顧尾,步長)

l = [1, 2, 3, 'ymn']
print(l[0:3])   # [1,2,3]
print(l[:])     # 切片等同於拷貝行為,而且相當於淺拷貝
print(l[::-1])  # 列表倒序

4.3.3 長度 len

l = [0,1,2,3,4]
print(len(l)) # 5

4.3.4 成員運算子in和not in

l = ['ymn','love','xcy']

print('mn' in l)
print('mn' not in l)

4.3.5 append

追加 在列表的末尾追加值

l = [11,'ymn',666]
l.append(333)
print(l)   # [11,'ymn',666,333]

4.3.6 insert 插入

當索引大於當前列表最大索引,預設插入到列表末尾

l = [11, 'ymn', 666]
l.insert(1, 'alex')
print(l)    # [11,'alex','ymn', 666]

l.insert(-1,'wusir') # 如果索引是負的,那麼追加的值的位置是向左偏移一個單位.
print(l)   # [11, 'ymn', 'wusir', 666]

4.3.7 extend 迭代新增

l = [11, 'ymn', 666]
l1 = [99,88,77]
l.extend(l1)
print(l)      # [11, 'ymn', 666,99,88,77]

# 內部實現
for el in l1:
    l.append(el)
print(l)

4.3.8 刪除

# 方式1: del 通用的刪除方法,沒有返回值
l = [11, 'ymn', 666]
del l[1]
x = del l[1] # 丟擲異常,不支援賦值語法
print(l)

# 方式二:l.pop() 根據索引刪除,會返回刪除的值
l = [11, 'ymn', 666]
res = l.pop() # 不指定索引預設刪除最後一個
print(res)  # 666
print(l)    # [11, 'ymn', 666]

# 方式三:l.remove() 根據元素刪除,返回None
l = [11, 'ymn', 666]
l.remove('ymn')
print(l)  # [11, 666]

4.3.9 for迴圈

謹記:迴圈只是為了讀,儘量不要修改,否則會出現索引問題

for x in [1,2,3,4]:
    print(x)

4.3.10 count( )

# 統計元素在列表中出現的次數
l = [11, 22, 11, 22, 'ymn']
print(l.count(11))  # 2

4.3.11 index( )

# 返回元素在列表中首位索引
l = ['ymn',18]
print(l.index('ymn')) # 0
print(l.index('mn'))  # 找不到報錯

4.3.12 clear( )

# 清空列表
l = [1,2,3,4]
l.clear()
print(l)

4.3.13 reverse( )

不是排序,就是把列表倒過來

l = [11, 22, 11, 22, 'ymn']
l.reverse()
print(l)  # ['ymn',22,11,22,11]

4.3.14 sort( )

列表內的元素必須是同種型別才可以排序

l = ['ymn','123','haha']  # 字串比大小,按照對應的位置的字元依次pk,一旦有結果就停止pk,字串的大小按照ASCII碼錶的先後順序區別字元大小

l.sort() # 預設從小到大排,升序
print(l) # ['123', 'haha', 'ymn']

l.sort(reverse=True) # 從大到小,降序
print(l) # ['ymn', 'haha', '123']

print('a' > "A") # True

# 瞭解:列表也可以比大小,原理同字串一樣,對應位置必須是同種型別,否則報錯
l = [11,22,33,44]
l1 = [12]
print(l < l1)  # True

4.3.15 補充:佇列,堆疊 兩種資料結構 就是用來存取值的

# 佇列:FIFO,先進先出
l = []
# 入隊操作
l.append('1')
l.append('2')
l.append('3')
print(l)

# 出隊操作
print(l.pop(0))
print(l.pop(0))
print(l.pop(0))


# 堆疊:LIFO,後進先出
l = []
# 入棧操作
l.append('1')
l.append('2')
l.append('3')
print(l)

# 出棧操作
print(l.pop())
print(l.pop())
print(l.pop())

5. 元組型別

元組就是"一個不可變的列表"

5.1 定義

# 1.作用: 按照索引(位置)存放多個值,只用於讀不用於改

# 2.定義: ()內用逗號分隔開多個任意型別的元素
t = (1,2,3)  # t = tupte(1,2,3)
print(t,type(t)) # (1,2,3) <class tuple>

x = (10) # 單獨一個括號代表包含的意思
print(x,type(x))  # 10 <class int>

tu = (10,)  # 如果元組中只有一個元素,必須加逗號

5.2 探祕元組的不可變

t = (11,22,'aa',[11,22]) 
print(id(t(3)))  # 75438567785467
# t = (0->值1的記憶體地址,1->值22的記憶體地址,2->值"aa"的記憶體地址)
# 元組在記憶體中存的是索引和值的記憶體地址,說元素不可變,就是當元祖在記憶體中建立好了,那麼索引對應的記憶體地址就不能改變了,換句話說,當元祖中的索引對應的記憶體地址沒有發生改變,那麼元組就沒有改變
t(1) = 99 # 不能改,報錯

t(3)(1) = 99
print(t) # (11, ,22, 'aa', [11, 99]) 因為索引3對應的值是可變型別的資料,
# 我們只是對他的內部元素進行了修改,但是元祖中這個索引對應的記憶體地址並沒有,所以元組並沒有發生改變
print(id(t(3)))  # 75438567785467

5.3 型別轉換

只要是可以被for迴圈的資料型別都可以被tuple強制轉換成元組

print(tupte('hello'))      # ('h','e','l','l',o)
print(tupte(['hello']))    # ("hello",)
print(tupte({'hello':1}))  # ("hello",)

5.4 常用和內建方法

5.4.1 索引取值

# 按照索引存取值(正向/反向存取):只能取
t = (1, 2, 3, 'ymn')
# 正向取
print(t(1))   # 2

# 反向取
print(t(-1))  # "ymn"

5.4.2 切片 (顧頭不顧尾,步長)

t = (1, 2, 3, 'ymn')
print(t(0:3))     # (1,2,3)
print(t(:))       # 切片等同於拷貝行為,而且相當於淺拷貝
print(t(::-1))    # 元祖倒敘

5.4.3 長度 len

tu = (1,2,3,4)
print(len(tu))  # 4

5.4.4 成員運算子in和not in

t = ('ymn',18,'男')
print('mn' in t)     # False
print('mn' not in t) # True

5.4.5 迴圈

t = (1, 2, 3, 'ymn')
for el in t:
    print(el)

5.4.6 內建方法

t = (1,2,3)
print(t.count(1))  # 1
print(t.index(1))  # 0

6. 字典型別

6.1 定義

{ }內用逗號分隔開多個key:value,其中value可以是任意型別,但是key必須是不可變的型別,且不能重複

dic = {"k1":1}     # dic = dict(k1=1})
print(dic)

6.2 型別轉換

info = [
    ['name','ymn'],
    ['age',18],
    ['gender',"男"],
]
d = {}
for k,v in info:
    d[k] = v
print(d)    # {"name":'ymn','age':18,'gender':'男'}

res = dict(info) # 一行程式碼解決,實際上內部做的就是上面的for迴圈,前提是子元素必須是有兩個值
print(res)  # {"name":'ymn','age':18,'gender':'男'}

6.3 初始化字典

即字典的key對應的值為None

# 1.直接手寫
d = {'k1':None,'k2':None,'k3':None}

# 2.迴圈增加
keys = ['k1','k2','k3']
d = {}
for key in keys:
    d[key] = None
print(d)

# 3.利用內建的fromkeys方法
d1 = dict.fromkeys(keys,None) # 內部就是上面的for迴圈
print(d1)

6.4 內建方法

6.4.1 按照key存取值:可存可取

d = {'k1':1}
# 針對賦值操作key存在,則修改
d['k1'] = 22
print(d)  # {"k1":22}

# 針對賦值操作key不存在,則建立新值(有則修改,無則增加)
d['k2'] = 333
print(d)  # {'k1':22,'k2':333}

6.4.2 長度 len

d = {'k1':1,'k2':2,'k3':3}
print(len(d))  # 3

6.4.3.成員運算 in 和 not in: 根據key

d = {'k1':1,'k2':2,'k3':33}
print('k1' in d)
print('k1' not in d)

6.4.4 刪除

# 4.1通用刪除
d = {'k1':1,'k2':2,'k3':33}
del d['k1']
print(d)  # {'k2':2,'k3':33}

# 4.2 pop刪除: 根據key刪除元素,返回刪除key對應的value值
d = {'k1':1,'k2':2,'k3':33}
print(d.pop('k2'))  # 2
print(d)   # {'k1':1,'k3':33}

# 4.3 popitem刪除: 隨機刪除,返回一個元組(刪除的key,value)
d = {'k1':1,'k2':2,'k3':33}
res = d.popitem()
print(res)  # ('k3',33)
print(d)    # {'k1':1,'k2':2}

6.4.5 鍵keys( ) 值values( ) 鍵值對items( )

d = {'k1':1,'k2':2,'k3':33}

print(d.keys(),type(d.keys())) # dict_keys(['k1', 'k2', 'k3']) <class 'dict_keys'>
print(d.values())              # dict_values([1, 2, 33])
print(d.items())               # dict_items([('k1', 1), ('k2', 2), ('k3', 33)])

6.4.6 for迴圈

d = {'k1':1,'k2':2,'k3':33}
for key in d.keys():
    print(key)

for k in d:
    print(k)

for v in d.values():
    print(v)

for k,v in d.items():
    print(k,v)

6.4.7 clear( )

# 清空字典
d = {'k1':1,'k2':2,'k3':33}
d.clear()
print(d)  # {}

6.4.8 update( )

更新字典,用新字典更新老字典,一切以新字典為準

d = {'k1':1,'k2':2,'k3':33}
d.update({'k1':99,'k4':44})
print(d)  # {'k1':99,'k2':2,'k3':33,'k4':44}

6.4.9 get( )

通過get(key),獲取字典中key對應的值 ,不存在預設返回None

d = {'k1':1,'k2':2,'k3':33}
print(d.get('k1'))    # 1
print(d.get('k5'))    # None

6.4.10 setdefault( )

d = {'k1':1,'k2':2,'k3':33}
# 4.1 如果key存在,就不修改原值,返回字典中key對應的值
print(d.setdefault('k1',444))  # 1
print(d)    # {'k1':1,'k2':2,'k3':33}

# 4.2 如果key不在,增加新值,返回字典中key對應的值
print(d.setdefault('k4',4444))  # 4444
print(d)     # {'k1':1,'k2':2,'k3':33,'k4':4444}

7. 集合

7.1 作用

集合是把一堆值集中在一起來做一個整體方面的操作,如關係運算,去重

如果你去關注把集合中的某一個元素取出來的話,就喪失了建立集合的初衷,你想取出單個值,那麼你用列表或者元組就好了.

7.2 定義

在{ }內用逗號分隔開多個元素,多個元素滿足以下三個條件

1. 集合內元素必須是不可變型別
2. 集合內元素無序
3. 集合內元素沒有重複

s1 = {1,2} # s1 = set(1,2)
print(s1)

補充 :

s = {} # 預設是空字典
print(s,type(s))  # {} <class dict>
# 定義空集合
s = set()
print(s,type(s))  # {} <class 'set'>

7.3 型別轉換

s = set({1,2,3})  # 內部和list,tuple一樣都是呼叫的for迴圈
print(s)

s = set("hello")
print(s)

s = set([1,2,3,[1,2,3],2]) # 報錯,因為元素中存在了可變的資料型別
print(s)

s = set({'k1':1,'k2':2}) # 只把key新增到集合中
print(s)

7.4 關係運算

7.4.1 交集 &/intersection

friend1 = {'ymn', 'tom', 'fangfang', 'jack'}
friend2 = {'ymn', 'benben', 'niuniu', 'jack'}

res = friend1 & friend2
print(res)                             # {'ymn','jack'}
print(friend1.intersection(friend2))   # {'ymn','jack'}

7.4.2 並（合）集 |/union

friend1 = {'ymn', 'tom', 'fangfang', 'jack'}
friend2 = {'ymn', 'benben', 'niuniu', 'jack'}

res = friend1 | friend2  # {'ymn', 'benben','tom', 'fangfang', 'niuniu', 'jack'}
print(friend1.union(friend2))# {'ymn','benben','tom','fangfang','niuniu', 'jack'}

7.4.3 差集 -/difference

friend1 = {'ymn', 'tom', 'fangfang', 'jack'}
friend2 = {'ymn', 'benben', 'niuniu', 'jack'}
# 取friend1獨有的好友
res = friend1 - friend2
print(res)                        # {'tom', 'fangfang'}
print(friend1.difference(friend2))# {'tom', 'fangfang'}

# 取friend2獨有的好友
res = friend2 - friend1
print(res)     # {'benben', 'niuniu'}

7.4.4 對稱差集 ^/symmetric_difference

friend1 = {'ymn', 'tom', 'fangfang', 'jack'}
friend2 = {'ymn', 'benben', 'niuniu', 'jack'}
# 取兩個使用者獨有的好友(即去掉公共的好友)
print((friend1 - friend2) | (friend2 - friend1)) 
# {'tom','fangfang','benben','niuniu'}

print(friend1 ^ friend2)  # {'tom','fangfang','benben','niuniu'}

print(friend1.symmetric_difference(friend2)) 
# {'tom','fangfang','benben','niuniu'}

7.4.5 父子集 包含關係

s1 = {1, 2, 3, 4, }
s2 = {1, 2, 5}
# 不存在包含關係,下面比較均為False
print(s1 > s2)  # False
print(s1.issuperset(s2)) # False

print(s1 < s2)  # False
print(s1.issubset(s2))  # False

s1 = {1, 2, 3, 4, }
s2 = {1, 2, 3}
print(s1 > s2)  # True  當s1大於或等於s2時,才能說s1是s2他爹

s1 = {1, 2, 3}
s2 = {1, 2, 3}
print(s1 == s2)  # True s1和s2互為父子集
print(s1.issuperset(s2)) # True
print(s2.issuperset(s1)) # True

7.5 去重

雖然集合具有天然的去重性，但是也有一定的侷限性，它只能適用於對順序沒有要求的去重。

# 1.只能針對不可變型別去重
print(list(set([1,2,1,2,1,3])))

# 2.無法保證原來的順序
print(list(set(['a',1,2,3,1,'a','ymn'])))

# 通常我們用成員運算也能達到去重的效果
# 小練習:去重
l = [
    {'name':'ymn'},
    {'name':'tom'},
    {'name':'fangfang'},
    {'name':'tom'},
]
new_l = []
for item in l:
    if item not in new_l:
        new_l.append(item)
print(new_l)

7.6 其他內建方法

7.6.1 刪除

s1 = {1, 2, 3, 4, }
res = s1.discard(5) # 刪除元素,不存在返回None
print(res)  # None
print(s1)  # {1, 2, 3, 4, }

res = s1.remove(5) # 刪除元素,不存在報錯
print(res)
print(s1)

7.6.2 clear( )

# 清空集合
s1 = {1, 2, 3, 4, }
s1.clear()
print(s1)    # {}

7.6.3 pop ( )

# 隨機刪除集合的一個元素
s1 = {1, 2, 3, 4, }
print(s1.pop())  # 2
print(s1)        # {1, 3, 4, }

7.6.4 update ( )

# 更新集合
s1 = {1, 2, 3, 4, }
s1.update({4,5,6,8})
print(s1)           # {1, 2, 3, 4,5,6,8}

7.6.5 add ( )

# 增加新值
s1 = {1, 2, 3, 4, }
s1.add('ymn')
print(s1)     # {1,'ymn', 2, 3, 4, }

7.6.6 isdisjoint ( )

# 判斷兩個集合是否相互獨立,即不存在交集
print({1,2,3}.isdisjoint({4,5,6}))  # True

8. 總結

​