1、列表的簡介

?????

# 創(chuàng)建列表，通過[]來創(chuàng)建列表

my_list = [] # 創(chuàng)建了一個空列表

# print(my_list , type(my_list))

# 列表存儲的數(shù)據(jù)，我們稱為元素

# 一個列表中可以存儲多個元素，也可以在創(chuàng)建列表時，來指定列表中的元素

my_list = [10] # 創(chuàng)建一個只包含一個元素的列表

# 當(dāng)向列表中添加多個元素時，多個元素之間使用,隔開

my_list = [10,20,30,40,50] # 創(chuàng)建了一個保護(hù)有5個元素的列表

# 列表中可以保存任意的對象

my_list = [10,'hello',True,None,[1,2,3],print]

# 列表中的對象都會按照插入的順序存儲到列表中，

#? ?第一個插入的對象保存到第一個位置，第二個保存到第二個位置

# 我們可以通過索引（index）來獲取列表中的元素

#? ?索引是元素在列表中的位置，列表中的每一個元素都有一個索引

#? ?索引是從0開始的整數(shù)，列表第一個位置索引為0，第二個位置索引為1，第三個位置索引為2，以此類推

my_list = [10,20,30,40,50]

# 通過索引獲取列表中的元素

# 語法：my_list[索引] my_list[0]

# print(my_list[4])

# 如果使用的索引超過了最大的范圍，會拋出異常

# print(my_list[5]) IndexError: list index out of range

# 獲取列表的長度，列表中元素的個數(shù)

# len()函數(shù)，通過該函數(shù)可以獲取列表的長度

# 獲取到的長度的值，是列表的最大索引 + 1

print(len(my_list)) # 5

2、切片

???

# 切片

# 切片指從現(xiàn)有列表中，獲取一個子列表

# 創(chuàng)建一個列表，一般創(chuàng)建列表時，變量的名字會使用復(fù)數(shù)

stus = ['孫悟空','豬八戒','沙和尚','唐僧','蜘蛛精','白骨精']

# 列表的索引可以是負(fù)數(shù)

# 如果索引是負(fù)數(shù)，則從后向前獲取元素，-1表示倒數(shù)第一個，-2表示倒數(shù)第二個 以此類推

# print(stus[-2])

# 通過切片來獲取指定的元素

# 語法：列表[起始:結(jié)束]?

#? ?通過切片獲取元素時，會包括起始位置的元素，不會包括結(jié)束位置的元素

#? ?做切片操作時，總會返回一個新的列表，不會影響原來的列表

#? ?起始和結(jié)束位置的索引都可以省略不寫

#? ?如果省略結(jié)束位置，則會一直截取到最后

#? ?如果省略起始位置，則會從第一個元素開始截取

#? ?如果起始位置和結(jié)束位置全部省略，則相當(dāng)于創(chuàng)建了一個列表的副本

# print(stus[1:])

# print(stus[:3])

# print(stus[:])

# print(stus)

# 語法：列表[起始:結(jié)束:步長]?

# 步長表示，每次獲取元素的間隔，默認(rèn)值是1

# print(stus[0:5:3])

# 步長不能是0，但是可以是負(fù)數(shù)

# print(stus[::0]) ValueError: slice step cannot be zero

# 如果是負(fù)數(shù)，則會從列表的后部向前邊取元素

print(stus[::-1])

3、通用操作

# + 和 *

# +可以將兩個列表拼接為一個列表

my_list = [1,2,3] + [4,5,6]

# * 可以將列表重復(fù)指定的次數(shù)

my_list = [1,2,3] * 5

# print(my_list)

# 創(chuàng)建一個列表

stus = ['孫悟空','豬八戒','沙和尚','唐僧','蜘蛛精','白骨精','沙和尚','沙和尚']

# in 和 not in

# in用來檢查指定元素是否存在于列表中

#? ?如果存在，返回True，否則返回False

# not in用來檢查指定元素是否不在列表中

#? ?如果不在，返回True，否則返回False

# print('牛魔王' not in stus)

# print('牛魔王' in stus)

# len()獲取列表中的元素的個數(shù)

# min() 獲取列表中的最小值

# max() 獲取列表中的最大值

arr = [10,1,2,5,100,77]

# print(min(arr) , max(arr))

# 兩個方法（method），方法和函數(shù)基本上是一樣，只不過方法必須通過 對象.方法() 的形式調(diào)用

# xxx.print() 方法實(shí)際上就是和對象關(guān)系緊密的函數(shù)

# s.index() 獲取指定元素在列表中的第一次出現(xiàn)時索引

# print(stus.index('沙和尚'))

# index()的第二個參數(shù)，表示查找的起始位置 ， 第三個參數(shù)，表示查找的結(jié)束位置

# print(stus.index('沙和尚',3,7))

# 如果要獲取列表中沒有的元素，會拋出異常

# print(stus.index('牛魔王')) ValueError: '牛魔王' is not in list

# s.count() 統(tǒng)計(jì)指定元素在列表中出現(xiàn)的次數(shù)

print(stus.count('牛魔王'))

4、修改元素

# 創(chuàng)建一個列表

stus = ['孫悟空','豬八戒','沙和尚','唐僧','蜘蛛精','白骨精']

# print("修改前：",stus)

# 修改列表中的元素

# 直接通過索引來修改元素

stus[0] = 'sunwukong'

stus[2] = '哈哈'

# 通過del來刪除元素

del stus[2] # 刪除索引為2的元素

# print('修改后：',stus)

stus = ['孫悟空','豬八戒','沙和尚','唐僧','蜘蛛精','白骨精']

# print("修改前：",stus)

# 通過切片來修改列表

# 在給切片進(jìn)行賦值時，只能使用序列

# stus[0:2] = ['牛魔王','紅孩兒'] 使用新的元素替換舊元素

# stus[0:2] = ['牛魔王','紅孩兒','二郎神']

# stus[0:0] = ['牛魔王'] # 向索引為0的位置插入元素

# 當(dāng)設(shè)置了步長時，序列中元素的個數(shù)必須和切片中元素的個數(shù)一致

# stus[::2] = ['牛魔王','紅孩兒','二郎神']

# 通過切片來刪除元素

# del stus[0:2]

# del stus[::2]

# stus[1:3] = []

# print('修改后：',stus)

# 以上操作，只適用于可變序列

s = 'hello'

# s[1] = 'a' 不可變序列，無法通過索引來修改

# 可以通過 list() 函數(shù)將其他的序列轉(zhuǎn)換為list

s = list(s)

print(s)

5、列表的方法

# 列表的方法

stus = ['孫悟空','豬八戒','沙和尚','唐僧']

# print('原列表：',stus)

# append()?

# 向列表的最后添加一個元素

# stus.append('唐僧')

# insert()

# 向列表的指定位置插入一個元素

# 參數(shù)：

#? ?1.要插入的位置

#? ?2.要插入的元素

# stus.insert(2,'唐僧')

# extend()

# 使用新的序列來擴(kuò)展當(dāng)前序列

# 需要一個序列作為參數(shù)，它會將該序列中的元素添加到當(dāng)前列表中

# stus.extend(['唐僧','白骨精'])

# stus += ['唐僧','白骨精']

# clear()

# 清空序列

# stus.clear()

# pop()

# 根據(jù)索引刪除并返回被刪除的元素

# result = stus.pop(2) # 刪除索引為2的元素

# result = stus.pop() # 刪除最后一個

# print('result =',result)

# remove()

# 刪除指定值得元素，如果相同值得元素有多個，只會刪除第一個

# stus.remove('豬八戒')

# reverse()

# 用來反轉(zhuǎn)列表

# stus.reverse()

# sort()

# 用來對列表中的元素進(jìn)行排序，默認(rèn)是升序排列

# 如果需要降序排列，則需要傳遞一個reverse=True作為參數(shù)

my_list = list('asnbdnbasdabd')

my_list = [10,1,20,3,4,5,0,-2]

print('修改前',my_list)

my_list.sort(reverse=True)

print('修改后',my_list)

# print('修改后：',stus)

6、遍歷列表

# 遍歷列表，指的就是將列表中的所有元素取出來

# 創(chuàng)建列表

stus = ['孫悟空','豬八戒','沙和尚','唐僧','白骨精','蜘蛛精']

# 遍歷列表

# print(stus[0])

# print(stus[1])

# print(stus[2])

# print(stus[3])

# 通過while循環(huán)來遍歷列表

# i = 0

# while i < len(stus):

#? ? ?print(stus[i])

#? ? ?i += 1

# 通過for循環(huán)來遍歷列表

# 語法：

#? ?for 變量 in 序列 :

#? ? ? ?代碼塊

# for循環(huán)的代碼塊會執(zhí)行多次，序列中有幾個元素就會執(zhí)行幾次

#? ?沒執(zhí)行一次就會將序列中的一個元素賦值給變量，

#? ?所以我們可以通過變量，來獲取列表中的元素

for s in stus :

? ? print(s)

7、EMS練習(xí)

# 顯示系統(tǒng)的歡迎信息

print('-'*20 , '歡迎使用員工管理系統(tǒng)', '-'*20)

# 創(chuàng)建一個列表，用來保存員工的信息，員工的信息以字符串的形式統(tǒng)一保存到列表

emps = ['孫悟空\t18\t男\(zhòng)t花果山','豬八戒\t28\t男\(zhòng)t高老莊']

# 創(chuàng)建一個死循環(huán)

while True:

? ? # 顯示用戶的選項(xiàng)

? ? print('請選擇要做的操作：')

? ? print('\t1.查詢員工')

? ? print('\t2.添加員工')

? ? print('\t3.刪除員工')

? ? print('\t4.退出系統(tǒng)')

? ? user_choose = input('請選擇[1-4]:')

? ? print('-'*62)

? ? # 根據(jù)用戶的選擇做相關(guān)的操作

? ? if user_choose == '1' :

? ? ? ? # 查詢員工

? ? ? ? # 打印表頭

? ? ? ? print('\t序號\t姓名\t年齡\t性別\t住址')

? ? ? ? # 創(chuàng)建一個變量，來表示員工的序號

? ? ? ? n = 1

? ? ? ? # 顯示員工信息

? ? ? ? for emp in emps :

? ? ? ? ? ? print(f'\t{n}\t{emp}')

? ? ? ? ? ? n += 1

? ? elif user_choose == '2':

? ? ? ? # 添加員工

? ? ? ? # 獲取要添加員工的信息，姓名、年齡、性別、住址

? ? ? ? emp_name = input('請輸入員工的姓名：')

? ? ? ? emp_age = input('請輸入員工的年齡：')

? ? ? ? emp_gender = input('請輸入員工的性別：')

? ? ? ? emp_address = input('請輸入員工的住址：')

? ? ? ? # 創(chuàng)建員工信息

? ? ? ? # 將四個信息拼接為一個字符串，然后插入到列表中

? ? ? ? emp = f'{emp_name}\t{emp_age}\t{emp_gender}\t{emp_address}'

? ? ? ? # 顯示一個提示信息

? ? ? ? print('以下員工將被添加到系統(tǒng)中')

? ? ? ? print('-'*62)

? ? ? ? print('姓名\t年齡\t性別\t住址')

? ? ? ? print(emp)

? ? ? ? print('-'*62)

? ? ? ? user_confirm = input('是否確認(rèn)該操作[Y/N]:')

? ? ? ? # 判斷

? ? ? ? if user_confirm == 'y' or user_confirm == 'yes' :

? ? ? ? ? ? # 確認(rèn)

? ? ? ? ? ? emps.append(emp)

? ? ? ? ? ? # 顯示提示信息

? ? ? ? ? ? print('添加成功！')

? ? ? ? else :

? ? ? ? ? ? # 取消操作

? ? ? ? ? ? print('添加已取消！')

? ? ? ??

? ? elif user_choose == '3':

? ? ? ? # 刪除員工，根據(jù)員工的序號來刪除員工

? ? ? ? # 獲取要刪除的員工的序號

? ? ? ? del_num = int(input('請輸入要刪除的員工的序號：'))

? ? ? ? # 判斷序號是否有效

? ? ? ? if 0 < del_num <= len(emps) :

? ? ? ? ? ? # 輸入合法，根據(jù)序號來獲取索引

? ? ? ? ? ? del_i = del_num - 1

? ? ? ? ? ? # 顯示一個提示信息

? ? ? ? ? ? print('以下員工將被刪除')

? ? ? ? ? ? print('-'*62)

? ? ? ? ? ? print('\t序號\t姓名\t年齡\t性別\t住址')

? ? ? ? ? ? print(f'\t{del_num}\t{emps[del_i]}')

? ? ? ? ? ? print('-'*62)

? ? ? ? ? ? user_confirm = input('該操作不可恢復(fù)，是否確認(rèn)[Y/N]:')

? ? ? ? ? ? # 判斷

? ? ? ? ? ? if user_confirm == 'y' or user_confirm == 'yes' :

? ? ? ? ? ? ? ? # 刪除元素

? ? ? ? ? ? ? ? emps.pop(del_i)

? ? ? ? ? ? ? ? # 顯示提示

? ? ? ? ? ? ? ? print('員工已被刪除！')

? ? ? ? ? ? else :

? ? ? ? ? ? ? ? # 操作取消

? ? ? ? ? ? ? ? print('操作已取消！')

? ? ? ? else :

? ? ? ? ? ? # 輸入有誤

? ? ? ? ? ? print('您的輸入有誤，請重新操作！')

? ? elif user_choose == '4':

? ? ? ? # 退出

? ? ? ? print('歡迎使用！再見!')

? ? ? ? input('點(diǎn)擊回車鍵退出！')

? ? ? ? break

? ? else :

? ? ? ? print('您的輸入有誤，請重新選擇！')

? ? # 打印分割線

? ? print('-'*62)

7、range

# range()是一個函數(shù)，可以用來生成一個自然數(shù)的序列

r = range(5) # 生成一個這樣的序列[0,1,2,3,4]

r = range(0,10,2)

r = range(10,0,-1)

# 該函數(shù)需要三個參數(shù)

#? ?1.起始位置（可以省略，默認(rèn)是0）

#? ?2.結(jié)束位置

#? ?3.步長（可以省略，默認(rèn)是1）

# print(list(r))

# 通過range()可以創(chuàng)建一個執(zhí)行指定次數(shù)的for循環(huán)

# for()循環(huán)除了創(chuàng)建方式以外，其余的都和while一樣，

#? ?包括else、包括break continue都可以在for循環(huán)中使用

#? ?并且for循環(huán)使用也更加簡單

# 將之前使用while循環(huán)做的練習(xí)，再使用for循環(huán)完成一次！

for i in range(30):

? ? print(i)

# for s in 'hello':

#? ? ?print(s)

8、元組

# 元組 tuple

# 元組是一個不可變的序列

# 它的操作的方式基本上和列表是一致的

# 所以你在操作元組時，就把元組當(dāng)成是一個不可變的列表就ok了

# 一般當(dāng)我們希望數(shù)據(jù)不改變時，就使用元組，其余情況都使用列表

# 創(chuàng)建元組

# 使用()來創(chuàng)建元組

my_tuple = () # 創(chuàng)建了一個空元組

# print(my_tuple,type(my_tuple)) # <class 'tuple'>

my_tuple = (1,2,3,4,5) # 創(chuàng)建了一個5個元素的元組

# 元組是不可變對象，不能嘗試為元組中的元素重新賦值

# my_tuple[3] = 10 TypeError: 'tuple' object does not support item assignment

# print(my_tuple[3])

# 當(dāng)元組不是空元組時，括號可以省略

# 如果元組不是空元組，它里邊至少要有一個,

my_tuple = 10,20,30,40

my_tuple = 40,

# print(my_tuple , type(my_tuple))

my_tuple = 10 , 20 , 30 , 40

# 元組的解包（解構(gòu)）

# 解包指就是將元組當(dāng)中每一個元素都賦值給一個變量

a,b,c,d = my_tuple

# print("a =",a)

# print("b =",b)

# print("c =",c)

# print("d =",d)

a = 100

b = 300

# print(a , b)

# 交互a 和 b的值，這時我們就可以利用元組的解包

a , b = b , a

# print(a , b)

my_tuple = 10 , 20 , 30 , 40

# 在對一個元組進(jìn)行解包時，變量的數(shù)量必須和元組中的元素的數(shù)量一致

# 也可以在變量前邊添加一個*，這樣變量將會獲取元組中所有剩余的元素

a , b , *c = my_tuple

a , *b , c = my_tuple

*a , b , c = my_tuple

a , b , *c = [1,2,3,4,5,6,7]

a , b , *c = 'hello world'

# 不能同時出現(xiàn)兩個或以上的*變量

# *a , *b , c = my_tuple SyntaxError: two starred expressions in assignment

print('a =',a)

print('b =',b)

print('c =',c)

9、可變對象

# # 可變對象

# a = [1,2,3]

# print('修改前：', a , id(a))

# # 通過索引修改列表

# a[0] = 10

# print('修改后：', a , id(a))

# # 為變量重新賦值

# a = [4,5,6]

# print('修改后：', a , id(a))

a = [1,2,3]

b = a

# b[0] = 10

b = [10,2,3]

# print("a",a,id(a))

# print("b",b,id(b))

# == !=? is is not

# == != 比較的是對象的值是否相等?

# is is not 比較的是對象的id是否相等（比較兩個對象是否是同一個對象）

a = [1,2,3]

b = [1,2,3]

print(a,b)

print(id(a),id(b))

print(a == b) # a和b的值相等，使用==會返回True

print(a is b) # a和b不是同一個對象，內(nèi)存地址不同，使用is會返回False

10、字典

# 字典

# 使用 {} 來創(chuàng)建字典

d = {} # 創(chuàng)建了一個空字典

# 創(chuàng)建一個保護(hù)有數(shù)據(jù)的字典

# 語法：

#? ?{key:value,key:value,key:value}

#? ?字典的值可以是任意對象

#? ?字典的鍵可以是任意的不可變對象（int、str、bool、tuple ...），但是一般我們都會使用str

#? ? ? ?字典的鍵是不能重復(fù)的，如果出現(xiàn)重復(fù)的后邊的會替換到前邊的

# d = {'name':'孫悟空' , 'age':18 , 'gender':'男' , 'name':'sunwukong'}

d = {

'name':'孫悟空' ,?

'age':18 ,?

'gender':'男' ,?

'name':'sunwukong'

}

# print(d , type(d))

# 需要根據(jù)鍵來獲取值

# print(d['name'],d['age'],d['gender'])

# 如果使用了字典中不存在的鍵，會報錯

# print(d['hello']) KeyError: 'hello'

11、字典的使用

# 創(chuàng)建字典

# 使用{}

# 語法：{k1:v1,k2:v2,k3:v3}

# 使用 dict()函數(shù)來創(chuàng)建字典

# 每一個參數(shù)都是一個鍵值對，參數(shù)名就是鍵，參數(shù)名就是值（這種方式創(chuàng)建的字典，key都是字符串）

d = dict(name='孫悟空',age=18,gender='男')?

# 也可以將一個包含有雙值子序列的序列轉(zhuǎn)換為字典

# 雙值序列，序列中只有兩個值，[1,2] ('a',3) 'ab'

# 子序列，如果序列中的元素也是序列，那么我們就稱這個元素為子序列

# [(1,2),(3,5)]

d = dict([('name','孫悟飯'),('age',18)])

# print(d , type(d))

d = dict(name='孫悟空',age=18,gender='男')?

# len() 獲取字典中鍵值對的個數(shù)

# print(len(d))

# in 檢查字典中是否包含指定的鍵

# not in 檢查字典中是否不包含指定的鍵

# print('hello' in d)

# 獲取字典中的值，根據(jù)鍵來獲取值

# 語法：d[key]

# print(d['age'])

# n = 'name'

# print(d[n])

# 通過[]來獲取值時，如果鍵不存在，會拋出異常 KeyError

# get(key[, default]) 該方法用來根據(jù)鍵來獲取字典中的值

#? ?如果獲取的鍵在字典中不存在，會返回None

#? ?也可以指定一個默認(rèn)值，來作為第二個參數(shù)，這樣獲取不到值時將會返回默認(rèn)值

# print(d.get('name'))

# print(d.get('hello','默認(rèn)值'))

# 修改字典

# d[key] = value 如果key存在則覆蓋，不存在則添加

d['name'] = 'sunwukong' # 修改字典的key-value

d['address'] = '花果山' # 向字典中添加key-value

# print(d)

# setdefault(key[, default]) 可以用來向字典中添加key-value

#? ?如果key已經(jīng)存在于字典中，則返回key的值，不會對字典做任何操作

#? ?如果key不存在，則向字典中添加這個key，并設(shè)置value

result = d.setdefault('name','豬八戒')

result = d.setdefault('hello','豬八戒')

# print('result =',result)

# print(d)

# update([other])

# 將其他的字典中的key-value添加到當(dāng)前字典中

# 如果有重復(fù)的key，則后邊的會替換到當(dāng)前的

d = {'a':1,'b':2,'c':3}

d2 = {'d':4,'e':5,'f':6, 'a':7}

d.update(d2)

# print(d)

# 刪除，可以使用 del 來刪除字典中的 key-value

del d['a']

del d['b']

# popitem()

# 隨機(jī)刪除字典中的一個鍵值對，一般都會刪除最后一個鍵值對

#? ?刪除之后，它會將刪除的key-value作為返回值返回

#? ?返回的是一個元組，元組中有兩個元素，第一個元素是刪除的key，第二個是刪除的value

# 當(dāng)使用popitem()刪除一個空字典時，會拋出異常 KeyError: 'popitem(): dictionary is empty'

# d.popitem()

# result = d.popitem()

# pop(key[, default])

# 根據(jù)key刪除字典中的key-value

# 會將被刪除的value返回！

# 如果刪除不存在的key，會拋出異常

#? ?如果指定了默認(rèn)值，再刪除不存在的key時，不會報錯，而是直接返回默認(rèn)值

result = d.pop('d')

result = d.pop('z','這是默認(rèn)值')

# del d['z'] z不存在，報錯

# result = d.popitem()

# result = d.popitem()

# result = d.popitem()

# result = d.popitem()

# clear()用來清空字典

d.clear()

# print('result =',result)

# print(d)

# copy()

# 該方法用于對字典進(jìn)行淺復(fù)制

# 復(fù)制以后的對象，和原對象是獨(dú)立，修改一個不會影響另一個

# 注意，淺復(fù)制會簡單復(fù)制對象內(nèi)部的值，如果值也是一個可變對象，這個可變對象不會被復(fù)制

d = {'a':1,'b':2,'c':3}

d2 = d.copy()

# d['a'] = 100

d = {'a':{'name':'孫悟空','age':18},'b':2,'c':3}

d2 = d.copy()

d2['a']['name'] = '豬八戒'

print('d = ',d , id(d))

print('d2 = ',d2 , id(d2))

11、遍歷字典

# 遍歷字典

# keys() 該方法會返回字典的所有的key

#? ?該方法會返回一個序列，序列中保存有字典的所有的鍵

d = {'name':'孫悟空','age':18,'gender':'男'}

# 通過遍歷keys()來獲取所有的鍵

# for k in d.keys() :

#? ? ?print(k , d[k])

# values()

# 該方法會返回一個序列，序列中保存有字典的左右的值

# for v in d.values():

#? ? ?print(v)

# items()

# 該方法會返回字典中所有的項(xiàng)

# 它會返回一個序列，序列中包含有雙值子序列

# 雙值分別是，字典中的key和value

# print(d.items())

for k,v in d.items() :

? ? print(k , '=' , v)

12、集合

# 集合

# 使用 {} 來創(chuàng)建集合

s = {10,3,5,1,2,1,2,3,1,1,1,1} # <class 'set'>

# s = {[1,2,3],[4,6,7]} TypeError: unhashable type: 'list'

# 使用 set() 函數(shù)來創(chuàng)建集合

s = set() # 空集合

# 可以通過set()來將序列和字典轉(zhuǎn)換為集合

s = set([1,2,3,4,5,1,1,2,3,4,5])

s = set('hello')

s = set({'a':1,'b':2,'c':3}) # 使用set()將字典轉(zhuǎn)換為集合時，只會包含字典中的鍵

# 創(chuàng)建集合

s = {'a' , 'b' , 1 , 2 , 3 , 1}

# 使用in和not in來檢查集合中的元素

# print('c' in s)

# 使用len()來獲取集合中元素的數(shù)量

# print(len(s))

# add() 向集合中添加元素

s.add(10)

s.add(30)

# update() 將一個集合中的元素添加到當(dāng)前集合中

#? ?update()可以傳遞序列或字典作為參數(shù)，字典只會使用鍵

s2 = set('hello')

s.update(s2)

s.update((10,20,30,40,50))

s.update({10:'ab',20:'bc',100:'cd',1000:'ef'})

# {1, 2, 3, 100, 40, 'o', 10, 1000, 'a', 'h', 'b', 'l', 20, 50, 'e', 30}

# pop()隨機(jī)刪除并返回一個集合中的元素

# result = s.pop()

# remove()刪除集合中的指定元素

s.remove(100)

s.remove(1000)

# clear()清空集合

s.clear()

# copy()對集合進(jìn)行淺復(fù)制

# print(result)

print(s , type(s))

13、集合的運(yùn)算

# 在對集合做運(yùn)算時，不會影響原來的集合，而是返回一個運(yùn)算結(jié)果

# 創(chuàng)建兩個集合

s = {1,2,3,4,5}

s2 = {3,4,5,6,7}

# & 交集運(yùn)算

result = s & s2 # {3, 4, 5}

# | 并集運(yùn)算

result = s | s2 # {1,2,3,4,5,6,7}

# - 差集

result = s - s2 # {1, 2}

# ^ 異或集 獲取只在一個集合中出現(xiàn)的元素

result = s ^ s2 # {1, 2, 6, 7}

# <= 檢查一個集合是否是另一個集合的子集

# 如果a集合中的元素全部都在b集合中出現(xiàn)，那么a集合就是b集合的子集，b集合是a集合超集

a = {1,2,3}

b = {1,2,3,4,5}

result = a <= b # True

result = {1,2,3} <= {1,2,3} # True

result = {1,2,3,4,5} <= {1,2,3} # False

# < 檢查一個集合是否是另一個集合的真子集

# 如果超集b中含有子集a中所有元素，并且b中還有a中沒有的元素，則b就是a的真超集，a是b的真子集

result = {1,2,3} < {1,2,3} # False

result = {1,2,3} < {1,2,3,4,5} # True

# >= 檢查一個集合是否是另一個的超集

# > 檢查一個集合是否是另一個的真超集

print('result =',result)