① python字典的並交集
沒看太懂，如果只是對key值求交集和並集，下圓散面這個程序就好了，不是的話，說清楚
def union_intersection(d1,d2,mark):
"""
@attention: 這個陸纖是只對Key值做的
"""
temp = []
if mark == "union"早腔仿:
temp = list(set(d1.keys()+d2.keys()))
else:
temp = list(set(d1.keys())&set(d2.keys()))
tempdict = {}
for item in temp:
tempdict.setdefault(item,None)
return tempdict
if __name__ == '__main__':
d1 = {1:'a', 2:'b', 3:'c'}
d2 = {2:'2', 3:'3', 4:'4'}
print union_intersection( d1, d2, 'union' )
print union_intersection( d1, d2, 'intersection' )
② Python 簡明教程 ---13，Python 集合
目錄
前幾節我們已經介紹了Python 中的 列表list ， 元組tuple 和 字典dict ，本節來介紹Python 中的最後一種數據結構—— 集合set 。
Python 中的 set 與 dict 很像，唯一的不同是， dict 中保存的是 鍵值對 ，而 set 中只保存 鍵 ，沒有 值 。
Python 集合 有如下特點：
Python 集合的聲明有兩種方式：
創建 空集合 時，只能用 set() ，而不能用 {} ：
創建 非空集合 時，可以用 set() ，也可以用 {} ：
由於集合中的元素是唯一的，如果初始化時的 可迭代 數據中有重復的元素，則會自動刪去重復的元素：
使用 len() 函數可以查看集合中元素的個數：
由於Python 集合中的元素的是無序的，所以可不能使用 下標 的方式來訪問集合中的單個元素。
我們可以使用 for 循環 來遍歷集合中的所有元素：
我們可以對兩個集合進行如下運算：
交集與並集
in 運算
使用 dir(set) 查看集合支持的所有方法：
下面一一介紹這些 非魔法方法 ，共17 個。
1. add 方法
由於集合中的元素是唯一的，向集合中添加元素時有兩種情況：
示例：
2. remove 方法
示例：
3. discard 方法
示例：
4. pop 方法
示例：
5. union 方法
示例：
6. update 方法
示例：
7. clear 方法
示例：
8. 方法
示例：
9. difference 方法
示例：
10. difference_update 方法
示例：
11. intersection 方法
示例：
12. intersection_update 方法
示例：
13. isdisjoint 方法
示例：
14. issubset 方法
示例：
15. issuperset 方法
示例：
16. symmetric_difference 方法
示例：
17. symmetric_difference_update 方法
示例：
（完。）
推薦閱讀：
Python 簡明教程 --- 8，Python 字元串函數
Python 簡明教程 --- 9，Python 編碼
Python 簡明教程 ---10，Python 列表
Python 簡明教程 ---11，Python 元組
Python 簡明教程 ---12，Python 字典
③ Python其實很簡單 第十章 字典與集合
前面介紹的列表和元組都是有序序列，而字典與集合屬於無序序列，也就是說，不能通過索引來操作元素。
10.1 字典
語法格式：
dictionary= {key1 : value1, key2 : value2, key3 : value3 ,...., key n : value n }
其中，dictionary是字典名稱，key表示元素的鍵，value表示元素的值，鍵和值必須是成對的。
如：
>>> dict1 = { 'abc': 123, 98.6: 37 }
>>> dict1
{'abc': 123, 98.6: 37}
可以看出，鍵可以是字元串、數字或者元組，但必須是唯一的；而值可以是任何數據類型，也沒有要求是唯一的。
1、創建字典的方法
方法一：同時給定鍵和值，即「關鍵字參數」形式。
dictionary=dict(key1=value1,key2=value2,.....,key n=value n)
注意：這里的key 必須符合Python標識符的命名規則。
例：
先使用「{}」創建字典：
>>> dict1={1:'一',2:'二',3:'三',4:'四',5:'五'}
>>> dict1
{1: '一', 2: '二', 3: '三', 4: '四', 5: '五'}
再通過「關鍵字參數」形式創建：
>>> dict1=dict(1='一',2='二',3='三',4='四',5='五')
SyntaxError: expression cannot contain assignment, perhaps you meant "=="?
創建不成功，原因在於key 不符合Python標識符的命名規則。前面已經介紹過，標識符不能用數字表示或者用數字打頭。
現在對鍵如下修改：
>>> dict1=dict(n1='一',n2='二',n3='三',n4='四',n5='五') #在數字前加了一個字元」n」
>>> dict1
{'n1': '一', 'n2': '二', 'n3': '三', 'n4': '四', 'n5': '五'}
方法二 ：使用已經存在的元組和列表通過映射函數創建字典。
格式：dictionary=dict(zip(tuplekey,listvalue))
例：
>>> tuplekey=('n1','n2','n3','n4','n5') #鍵的序列採用元組
>>> listvalue=['一','二','三','四','五'] #值的序列採用列表
>>> dict1=dict(zip(tuplekey,listvalue))
>>> dict1
{'n1': '一', 'n2': '二', 'n3': '三', 'n4': '四', 'n5': '五'}
注意：tuple(listname)函數可以將列表轉換為元組，list(tuplename)函數可以將元組轉換為列表。
2、通過鍵訪問字典
直接獲取鍵的相應元素的值
>>> dict1['n2']
'二'
利用get()方法
>>> dict1.get('n2')
'二'
get()方法也可以帶參數，當要訪問的鍵不存在時返回一個字元串。如：
>>> dict1.get('n0','can't find!') #當要查找的鍵不存在，返回'can't find!'
"can't find!"
3、遍歷字典
使用字典對象的items()方法可以獲取字典的「鍵.值對」列表。
>>> for item in dict1.items():
print(item)
('n1', '一')
('n2', '二')
('n3', '三')
('n4', '四')
('n5', '五')
也可以獲取具體的每個元素的鍵和值，如：
>>> for key,value in dict1.items():
print(key,'對應的是',value)
n1 對應的是 一
n2 對應的是 二
n3 對應的是 三
n4 對應的是 四
n5 對應的是 五
4、添加、修改和刪除字典元素
使用下面的語句，若指定的鍵存在，就可以修改該元素的值；若指定的鍵不存在，則添加該元素。如：
>>> dict1['n6']='六' # 鍵』n6』不存在，故添加該元素
>>> dict1
{'n1': '一', 'n2': '二', 'n3': '三', 'n4': '四', 'n5': '五', 'n6': '六'}
>>> dict1['n4']='肆' # 鍵』n4』存在，故修改該元素
>>> dict1
{'n1': '一', 'n2': '二', 'n3': '三', 'n4': '肆', 'n5': '五', 'n6': '六'}
5、利用推導式建立字典
import random
dict1={i:random.randint(1,100) for i in range(5)}
# 生成元素的鍵為0到5整數，值為1到100之間的隨機數
print(dict1)
運行結果：{0: 28, 1: 59, 2: 79, 3: 30, 4: 88}
10.2 集合
集合是數學中一個很重要的概念，集合具有確定性、互異性、無序性三個基本屬性。在Python中，集合同樣具有這三個基本屬性，其中，確定性是指對象要麼是集合的元素，要麼不是集合的元素；互異性是指集合中的元素不能重復；無序性是指集合中的元素不分先後次序，可以隨意更換位置。
1、集合的創建
直接使用「{}」創建
>>> set1={'春','夏','秋','冬'}
>>> set1
{'秋', '春', '冬', '夏'}
>>> set2={3,2,1,4,5}
>>> set2
{1, 2, 3, 4, 5}
利用已有的列表、元組創建集合
>>> list1=['東','南','西','北']
>>> set3=set(list1)
>>> set3
{'南', '東', '北', '西'}
利用已有的集合建立一個「副本」
>>> set3
{'南', '東', '北', '西'} #set3和set4的值一樣
>>> set4=set3
>>> set4
{'南', '東', '北', '西'}
>>> set4.add('中') #給set4添加元素
>>> set4
{'西', '中', '東', '南', '北'} # 這個好理解
>>> set3
{'西', '中', '東', '南', '北'} # 意想不到吧？Set3為什麼會發生變化？
再看看簡單變數的情況：
>>> a=2
>>> b=a #是不是與前面set4=set3相似
>>> b+=1
>>> b
3
>>> a
2 #但a的值並沒有發生改變
從上面集合set3、set4和簡單變數a、b的值的變化情況對比，不難發現set3和set4是指向同一地址的對象，而變數a和變數b指向了不同地址，語句b=a是將a的值傳遞個b，並不是將a的地址傳遞給b。列表、元組、字典都和集合一樣具有這樣的性質。
所以，將set4稱為set3的「副本」更為恰當。
2、添加和刪除元素
>>> set3
{'南', '東', '北', '西'}
>>> set3.add('中') # 添加元素
>>> set3
{'西', '中', '東', '南', '北'} # 集合內的元素是無序的，不要糾結次序的變化
>>> set3.remove('中') # 刪除元素
>>> set3
{'西', '東', '南', '北'}
3、集合運算
集合運算包括交(&)、並(|)、差(-)，和數學中的集合運算是一致的。
>>> set3={'南', '東', '北', '西'}
>>> set4={'西', '中', '東', '南', '北'}
>>> set3 & set4 #取set3和set4的交集
{'西', '南', '北', '東'}
>>> set3 | set4 #取set3和set4的並集
{'中', '南', '北', '西', '東'}
>>> set3 - set4 #取set3與set4的差，即set3比set4多出來的元素
set()
>>> set4 -set3 #取set4與set3的差，即set4比set3多出來的元素
{'中'}
④ python 里的差集，交集，並集是什麼意思
這是 set的用法
首先set是集合，集合是無序不重復的
t=set([1,2,3,4,5])
s=set([5,6,7,8,9])
並集:
a = t | s # t 和 s的並集，計算的是t和s加在一起有多少不重復的元素，根據上面的例子，a就是一個包含1、2、3、4、5、6、7、8、9這九個元素的集合
交集：
b = t & s # t 和 s的交集，計算的是t和s有多少共同擁有不重復的元素，根據上面的例子，a就是一個包含5這一個元素的集合
差集：
c = t - s # 求差集（項在t中，但不在s中），根據上面的例子，a就是一個包含1、2、3、4這四個元素的集合
⑤ python字典的並交集
沒看太懂，如果只是對key值求交集和並集，下面這個程序就好了，不是的話，說清楚
def union_intersection(d1,d2,mark):
"""
@attention: 這個是只對Key值做的
"""
temp = []
if mark == "union":
temp = list(set(d1.keys()+d2.keys()))
else:
temp = list(set(d1.keys())&set(d2.keys()))
tempdict = {}
for item in temp:
tempdict.setdefault(item,None)
return tempdict
if __name__ == '__main__':
d1 = {1:'a', 2:'b', 3:'c'}
d2 = {2:'2', 3:'3', 4:'4'}
print union_intersection( d1, d2, 'union' )
print union_intersection( d1, d2, 'intersection' )
⑥ python 多個字元串交集演算法
如果原數據是唯一的，就把每一個元素，添加到一個字典中
最終獲得類似{"A1":5,"A3":2,"D1":5,"D3":10}的字典，也就是記錄每一個元素出現的次數，如果是10個元組的交集，那麼次數=10。
⑦ Python精講：Python中集合的交集並集差集和對稱差集運算方法詳解
歡迎你來到站長在線的站長學堂學習Python知識，本文學習的是《Python中集合的交集、並集、差集和對稱差集運算方法詳解》。主要講的是集合運算的相關的概念，及運算方法，包括：集合的交集、集合的並集、集合的差集、集合的對稱差集、集合的交集運算方法、集合的並集運算方法、集合的差集運算方法、集合的對稱差集運算方法。
在Python中，集合最常用的操作就是進行交集、並集、差集和對稱差集的運算。
要想學習集合的交集、並集、差集和對稱差集運算方法，首先我們來了解這些名詞的含義：
設A、B兩個集合，由所有屬於集合A且屬於集合B的元素所組成的集合，叫做集合A與集合B的交集。在Python中，進行交集運算時使用「&」符號。
給定兩個集合A、B，把他們所有的元素合並在一起組成的集合，叫做集合A與集合B的並集。在Python中，進行並集運算時使用「|」符號。
設A，B是兩個集合，則所有屬於A且不屬於B的元素構成的集合，叫做集合A與集合B的差集。在Python中，進行差集運算時使用「-」符號。
對稱差集也稱為對稱差分或者補集，設A，B是兩個集合，所有不相同的集合，叫做集合A與集合B的對稱差集（對稱差分或者補集）。在Python中，進行對稱差集運算時使用「^」符號。
上面都是概念性的描述，下面站長在線來舉實際的場景來對交集、並集、差集和對稱差集運算方法進行深入淺出的解讀。
場景模擬：某高中三年級，文科班高考的科目是語文、數學、英語、政治、 歷史 和地理。理科班高考的科目是語文、數學、英語、物理、化學和生物。
設定集合A為文科班高考的科目，集合B為理科班高考的科目。
A = {'語文','數學','英語','政治',' 歷史 ','地理'}
B = {'語文','數學','英語','物理','化學','生物'}
我們使用集合的交集運算的時候可以採用兩種方式，一種是使用「&」運算符進行操作，另一種是使用 intersection() 方法來實現。
運行結果：
運行結果：
同理集合B和集合A的交集也是一樣。我這里就不重復了，自己去體驗一下。
集合的並集運算也有兩種方式，一種是使用「|」運算符進行操作，另一種是使用union()方法來實現。
運行結果如下：
運行結果為：
同理集合B和集合A的並集也是一樣。自己去體驗一下吧！
集合的差集運算也有兩種方式，一種是使用「-」運算符進行操作，另一種是使用difference()方法來實現。
運行結果為：
上面是集合A和集合B的差集，但是集合B和集合A的差集就不是一樣的了哦！
運行結果為：
從上面可以看出，集合A和集合B的差集 與 集合B和集合A的差集是不一樣的，(A - B)是A中存在的部分，(B - A)是B中存在的部分。
運行結果：
同理，使用difference()方法進行集合B和集合A的差集也是不同的
運行結果：
集合的差集運算也有兩種方式，一種是使用「^」運算符進行操作，另一種是使用symmetric_difference()方法來實現。
運行結果為：
運行結果為：
同樣的，集合B與集合A的對稱差集也是一樣，自己去體驗一下。
我們對集合的交集、並集、差集和對稱差集運算方法全部詳細的講解了一遍，通過運行結果，我們得出結論：
集合中進行交集、並集、對稱差集進行運算的時候，集合A與集合B，位置替換的時候，結果相同。
集合中進行差集運算的時候，集合A與集合B，位置替換的時候，結果不同，為前面那個集合獨立存在的部分。
到此為止，本節課的內容《Python中集合的交集、並集、差集和對稱差集運算方法詳解》就完全講完了，主要講的集合運算的相關的概念，及運算方法，包括：集合的交集、集合的並集、集合的差集、集合的對稱差集、集合的交集運算方法、集合的並集運算方法、集合的差集運算方法、集合的對稱差集運算方法。
⑧ python常見數據類型
一,python整數類型所表示的數據。
1,一般用以表示一類數值:所有正整數,0和負整數;
2,整型作為最常用的,頻繁參與計算的數據類型，在python3.5中解釋器會自動在內存中創建-5-3000之間的（包含5，不包含3000）整型對象，也就是說在該范圍內,相等都是同一個已經創建好的整型對象。范圍之外的即使相等也表示不同對象，該特性隨python版本而改變，不要過於依賴。
3,bool型繼承了int型，他是int的子類。
4,Python2中有長整型long，數值范圍更大，在python3中已取消，所有整型統一由int表示。
5,參與所有數值計算，數學運算，科學計算。這也是所有編程語言都有的數據類型，因為編程語言生而需要模擬人的思維，藉助數學方式，自動計算、更好的解決大量重復性的事務，因此數值類型、整數類型在編程語言中不可或缺。
6,支持二進制(0b\0B開頭),十進制,八進制(0o\0O),十六進制(0x\0X)
二，python整數和浮點型支持常規的數值運算
整數和浮點數都可參與的運算：+ - * / %（取余） //（整除） **（冪）
Python字元型：
python字元型表示的數據：
python3支持Unicode編碼，由字母、數字和符號組成的形式就叫字元串，更接近或者相同與人們文字元號表示，因此在信息表示和傳遞時它也是最受認可的形式。在程序編寫中也是非常常用，對應的可操作的方法也很多，很有意思。
字元串不可被修改，可以拼接等方法創建新字元串對象；
支持分片和下標操作；a[2:]
支持+拼接，*重復操作和成員關系in/not in；
表示形式：用單引號雙引號包含起來的符號；a = str(『sdfsdfsdf』) 或 r』\t\nabcd』 原始字元，Bytes：b』abcd』；
6,字元串屬於不可變數據類型，內部機制為了節省空間，相同的兩個字元串表示相同的一個對象。a = 『python』 b = 『python』 a is b :True
二, 字元串支持的運算方法
1,capitalize() :首字母大寫後邊的字母小寫 a = 『abcd』 b = a.capitalize() b:Abcd
2,casefold() lower():字母轉換為全小寫
3,center(width,fillchar) :居中，width填補的長度；fillchar添加的字元
a = a.center(10,』_』) //』____abcd____』 默認無fillchar填充空格
4,count(sub,star,end) :字母計數：sub要查詢的字元
5,encode(encoding=』utf-8』,errors=』strict』) 設置編碼
Errors :設置錯誤類型
6,endswith(suffix,star,end) : 若以suffix結尾返回True
7，expandtabs(8) :設置字元串中tab按鍵符的空格長度：』\tabcde』
8,find(sub,star,end) : 返回指定范圍內的字元串下標，未找到返回-1
9，index(sub,star,end) :返回指定范圍字元串下標未找到拋出異常
10，isalnum() :判斷字元串是否是字母或數字，或字母和數字組合
11，isalpha() :判斷是否全是字母
12，isdecimal() :判斷字元串是否是十進制數值
13，isdigit() :判斷字元串是否是數字
14，isidentifier() :判斷字元串中是否包含關鍵字
15，islower() :判斷是否全小寫
16，isnumeric() :判斷全是數字
17，isspace() :判斷是否是空格
18，isupper() 判斷是否大寫
19，istitle() :判斷是否首字母大寫
20，join(iterable) :把可迭代對象用字元串進行分割：a.join(『123』)
21,ljust(width,fillchar);rjust() :左對齊右對齊
22, upper() :將字元串改為大寫
23，split(sep=None,maxsplit=-1) :分割一個字元串，被選中字元在字元串中刪除
『ab1cd1efg』.split(『1』) :[『ab』,』cd』,』efg』]
三，字元串格式化：按照規格輸出字元串
format(*args,**kwargs) :args位置參數，kwargs關鍵字參數
『{0:.1f}』.format(123.468) :格式化參數，小數點後保留1位四捨五入
四，字元串操作符%
1，%s :格式化字元串 『abcd%sdef』%』dddd』
2，%d:格式化整數
3，%o格式化無符號八進制
4，%x格式化無符號十六進制
5，%f格式化定點數
6, %e: 科學計數法格式化定點數
7，%g 根據值大小自動選%f,%e
8, %G E X :大寫形式
五，格式化輔助命令：
m.n :m最小總寬度，n小數點後位數：』%12.4f』%23456.789
六，轉義字元：字元串前r避免轉義：r』\nhello\thi』
\n:換行符
\t:橫向製表符
\':'
\":"
\b:退格符
\r:回車
\v:縱向製表符
\f:換頁符
\o,\x:八進制和十六進制
\0:空字元串
Python列表list
一，Python的列表list類型表示的數據：
Python列表在cpython中被解釋為長度可變的數組，用其他對象組成的連續數組。
列表中元素可以是相同或不同的數據類型；
當列表元素增加或刪除時，列表對象自動進行擴展或收縮內存，保證元素之間沒有縫隙，總是連續的。
Python中的列表是一個序列，也是一個容器類型
創建列表：a = []; b = [1,』python』]; c = list(); d = list((1,3,4,5))
支持切片操作list[start,stop,step]
python列表常用方法
1,append添加單個元素：list.append(object); //a.append(『python』)
2,extend添加可迭代對象: list.extend(iterable); //a.extend(『abcde』/[1,2,3])
3,insert 插入元素：list.insert(index,object): 在index下標前插入元素//a.insert(2,』python』)
4,clear 清空所有元素：list.clear() //a.clear()
5,pop 刪除並返回一個元素：list.pop(index) //默認刪除默認一個元素
remove 刪除指定元素：list.remove(v) ,v元素不存在報錯 //a.remove(『c』)
7，count 返回這個值在列表中數量：list.count(value)
8, 淺拷貝一個新列表：list.()
9,sort:排序list.sort(reverse=False/True) :默認升序
排序函數：sorted(list)
10，reverse: 原地翻轉：list.reverse()
11，index(value,star,stop) :指定范圍內該值下標：list.index(2,0,5)
列表元素訪問：
下標訪問：list[1]
For循環遍歷
通過下標修改元素：list[2 ] = 『hello』
列表常用運算符：
1,比較運算符：從第一個元素開始對比
2，+ 拼接一個新列表：l1+ l2
3, 重復操作符：* ,多個列表拼接
成員關系操作符：in/ not in
邏輯運算符：and not or
列表常用的排序方法：
冒泡排序；選擇排序；快速排序；歸並排序
Python元組tuple
一，Python元組tuple數據類型表示的數據：
元組是受到限制的、不可改變的列表；
可以是同構也可以是異構；
元組是序列類型、是可迭代對象，是容器類型。
元組的創建: a = (1,2,3)或a=1,2,3; b = tuple(); c = tuple(iterable)
支持切片操作tuple[start,stop,step]
二，python元組常用方法
1,index(value,star,stop) :指定范圍內該值下標：tuple.index(2,0,5)
2,count(value) ：值出現次數
三，支持運算：
1,比較運算符：從第一個元素開始對比
2，+ 拼接一個新元組：l1+ l2
3, 重復操作符：* ,多個元組拼接
4成員關系操作符：in/ not in
邏輯運算符：and not or
四，元組的訪問
下標操作；
For循環遍歷訪問。
Python字典類型
一,Python字典dict表示的數據：{key:value}
可根據關鍵字：鍵快速索引到對應的值；
字典是映射類型，鍵值對一一對應關系，不是序列；
字典元素是無序的；
字典是可迭代對象，是容器類型；
字典的創建：k = {}; k1={『keyword』:object}; k2 = dict();
K3 = dict(mapping); dict=(iterable)
二，字典的訪問：
通過key：k[『key』]
修改key對應的值：K[『key』] = value
For循環遍歷出來的是key；
For循環鍵值對：for I in d.items():
For 循環enumerate: for k,v in enumerate(k1):
In/not in 成員關系查詢鍵不支持查值
三，字典常用方法
get(key,de):獲取值：k.get(key,de) //若不存在則默認輸出de
pop(k,de):刪除一個鍵值對，不存在輸出de，未設置報錯；
keys() :返回字典所有key組成的序列：list(k.keys()) [1,2,3];
values():返回字典所有value組成的序列：list(k.values())
items():返回鍵值對組成的元組為元素的序列：（類set）list(k.items())
update(e):更新字典：e可是字典或兩元素組成的單位元素序列：e=[(5,6),(7,8)];
k.update(e)
clear():清空字典；
popitem()刪除某個鍵值對，若字典為空則報錯
() :淺拷貝
10, fromkeys(iterable,value=None):從可迭代對象創建字典
{}.fromkeys([1,2,3]) -----{1:None,2:None,3:None}
11,setdefault(k,d=None) :若key不存在則生成一個鍵值對
k.setdefault(『keyword』)
Python 集合set
集合表示的數據：
多個元素的無序組合，集合是無序的，集合元素是唯一的；
字典的鍵是由集合實現的；
集合是可迭代對象
集合創建：s = {1,2}; s1 = set(); s2 = set(iterable)
集合元素的訪問：
For 循環將集合所有元素全部訪問一遍，不重復
常用方法：
add(object):s.add(『hi』) 向集合添加一個元素
pop() :彈棧，集合為空則報錯：刪除任意一個元素；
clear():清空集合，返回一個空集合對象；
remove(object):刪除一個元素，不存在和報錯：s.remove(『hi』)
update(集合)：更新另一個集合，元素不存在則不更新；
() :淺拷貝
集合的運算：
交集：s1&s2;
差集,補集：s1-s2;
並集：s1|s2;
Issubset():判斷是否是子集：s1.issubset(s2) s1是否s2的集合子集
Issuperset():判斷是否是父集：s1.issuperset()
不可變集合：
Frozenset():返回一個空的不可變集合對象
Frozenset(iterable):
S = frozenset(iterable)
Python序列類型共同特性
一,序列類型共同特性
python序列類型有:str字元串,list列表,tuple元組
都支持下標索引，切片操作；
下標都是從0開始，都可通過下標進行訪問；
擁有相同的操作符
二，支持的函數：
len(obj):返回對象長度；
list(iterable):將可迭代對象轉為列表；
tuple(iterable):將可迭代對象轉為元組；
str(ojb):將任何對象轉為字元串形式；
max(iterable): python3中元素要是同類型，python2中元素可異構：max([『a』,1])
min(iterable):和max類似；
sum(iterable,star=0),求可迭代對象和，默認star為0，元素不能為字元串
sorted(iterable,key=None,reverse=False)
s=[(『a』,3),(『b』,2),(『c』,9)]
sorted(s,key=lambda s:s[1]) //按照數字排序
reversed(sequence):翻轉序列，返回迭代器
enumerate(iterable):返回enumerate對象,其元素都是一個元組（下標，值）
zip（iter1,iter2）: zip([1,2],[3,4]) ----[(1,3),(2,4)]
序列類型的切片操作：
Slice:
L[index]; 訪問某個元素；
L[1:4]; 區間
L[star:stop:step]; 設置步長取區間元素
⑨ python集合的運算（交集、並集、差集、補集）
我們在遇到一些問題的時候，使用集合的交集、並集和差集能夠更便捷的幫助我們去解決問題，看下面一個例子。
某學校有兩個班級，班級A需要學習數學、語文、英語、物理、化學和生物，班級B需要學習數學、語文、英語、政治、地理和歷史。
我們可以直接看出A班級和B班級的交集為數學、語文和英語，並集為數學、語文、英語、物理、化學、生物、政治、地理、歷史，A和B的差集為物理、化學和生物。
那麼怎麼使用Python去完成這些運算？
我們先在這里定義兩個集合，
因為是求交集，因此A和B的位置調換依然不影響結果。
使用集合求並集的方式同樣也是兩種方式，一種是使用 『|』 運算符進行操作，一種是使用 union() 方法來實現。
求並集的時候同樣不需要注意 A 和 B 的位置關系。
使用集合求差集的方式同樣也是兩種方式，一種是使用 『-』 運算符進行操作，一種是使用 difference() 方法來實現。
在方法2中注意 A 和 B 的位置不同的時候是有區別的，如果是 A 使用 difference() 方法，那麼是輸出 A 中有而 B 中沒有的元素，如果是 B 使用 difference() 方法，那麼是輸出 B 中有而 A 中沒有的元素。
學習完了集合，四種核心集合我們已經基本掌握，接下來幾節我們來通過學習一些字元串的相關操作，學習字元串的過程中會穿插著前面簡單介紹過但沒仔細講解的方法及操作。
⑩ python集合的作用有哪些
集合可以像元組一樣，設置不可改變的類型;也可以默認像字典，列表一樣，可以迭代改變;同時集合里的元素可以是列表，元組，字典。
1、python集合的作用——創建字典
可使用大括弧 { } 或者 set() 函數創建集合，注意：創建一個空集合必須用 set() 而不是 { }，因為 { } 是用來創建一個空字典。
>>> my_set = set(('apple',))
>>> my_set
{'apple'}
2、python集合的作用——添加元素(add(),update())
# add 作為一個整體添加到集合中
my_set = set()
my_set.add("abc")
print(my_set)
#update 是把要傳入的元素拆分，做為個體傳入到集合中
my_set = set()
my_set.update("abc")
print(my_set)
3、python集合的作用——刪除元素(remove()，pop()，discard())
#remove 如果集合種有，則直接刪除;如果沒有，程序報錯 格式：集合名.remove(元素)
my_set = {11, 13, 15}
my_set.remove(13)
print(my_set) my_set.remove(131)
print(my_set)
#pop 隨機刪除集合中的元素 如果集合中沒有元素則程序報錯
my_set = {11, 13, 15}
my_set.pop()
print(my_set)
#discard 如果集合中元素存在，直接刪除; 如果元素不存在 不做任何操作 格式: 集合名.discard(元素)
my_set = {11, 13, 15}
my_set.discard(13)
print(my_set)
my_set.discard(131)
print(my_set)
4、python集合的作用——交集( & )
set1 = {9, 2, 3, 4}
set2 = {3, 4, 5, 16}
new_set = set1 & set2
print(new_set)
# result {3, 4}
5、python集合的作用——並集( | )
set1 = {1, 2, 3, 4}
set2 = {3, 5, 5, 6}[page]
new_set = set1 | set2
print(new_set)
# result {1, 2, 3, 4, 5, 6}
6、python集合的作用——差集(-)
項在前一個集合中，但不在後一個集合中。
set1 = {1, 2, 3, 4}
set2 = {3, 4, 5, 6}
new_set = set1 - set2
print(new_set)
# result {1, 2}
7、python集合的作用——對稱差集( ^ )
即項在前一個集合或後一個集合中，但不會同時出現在二者中。即交集減去並集。
set1 = {1, 2, 3, 4}
set2 = {3, 4, 5, 6}
new_set = set1 ^ set2
print(new_set)
# result {1,2,5,6}
8、python集合的作用——子集判斷
set1 = { 3, 4}
set2 = {3, 4, 5, 6}
# 判斷set1是否是set2的子集
print(set1.issubset(set2))
# result True
9、python集合的作用——父集判斷
set1 = { 3, 4}
set2 = {3, 4, 5, 6}
# 判斷set1是否是set2的父集
print(set1.issuperset(set2))
# result False
10、python集合的作用——迭代和枚舉
s={34,56,76,34,56,54,43,23,56}
for i in s:
print(i) ##迭代輸出其內容
for i,v in enumerate(s):
print('index: %s,value: %s' %(i,v))
"""
result:
index: 0,value: 34
index: 1,value: 43
index: 2,value: 76
index: 3,value: 54
index: 4,value: 23
index: 5,value: 56
"""
可觀察出，集合會自動過濾掉相同元素。
python集合的作用都有哪些？原來這些功能才是最實用的，集合可以像元組一樣，設置不可改變的類型;也可以默認像字典，列表一樣，可以迭代改變;同時集合里的元素可以是列表，元組，字典，你能處理好嗎?如果您還擔心自己入門不順利，可以點擊本站的其他文章進行學習。