python字典中的並集啥的

① 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集合的作用有哪些

集合可以像元組一樣，設置不可改變的類型;也可以默認像字典，列表一樣，可以迭代改變;同時集合里的元素可以是列表，元組，字典。

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集合的作用都有哪些？原來這些功能才是最實用的，集合可以像元組一樣，設置不可改變的類型;也可以默認像字典，列表一樣，可以迭代改變;同時集合里的元素可以是列表，元組，字典，你能處理好嗎?如果您還擔心自己入門不順利，可以點擊本站的其他文章進行學習。

③ 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的集合有哪些操作

集合是一個無序的，不重復的數據組合，它有著兩個主要作用：去重以及關系測試。去重指的是當把一個列表變成了集合，其中重復的內容就自動的被去掉了

關系測試指的是，測試兩組數據之間的交集、差集、並集等關系。

去重測試代碼如下：

#創建一個列表--裡面存在一些重復值

test_list = [1,2,3,4,2,2,3,4,3,2,3,4]

#利用集合將列表中重復的內容去掉

test_list = set(test_list)

#列印測試並且查看test_list被賦予新值後的數據類型print(test_list,type(test_list)) # {1, 2, 3, 4}

Tip：需要注意的是，集合和字典一樣都是無序的。

獲取交集需要使用集合中的方法intersection方法，獲取兩個集合中的交集代碼如下：

#創建兩個集合，並且獲取集合的交集

test_list_01 = set(['YanYan','LiBai','LuLu','YangMi'])

test_list_02 = set(['YanYan','LiuDeHua','ZhangXueYou','LiBai'])

#在上面的兩個集合中，存在相同的值，那麼現在我們取出兩個集合中的交集

test_intersection = test_list_01.intersection(test_list_02)print(test_intersection) # {'YanYan', 'LiBai'}

獲取並集的方式需要採用集合中union方法，獲取兩個集合的並集代碼如下：

#創建兩個集合，並且獲取集合的交集

test_list_01 =set(['YanYan','LiBai','LuLu','YangMi'])

test_list_02 =set(['YanYan','LiuDeHua','ZhangXueYou','LiBai'])

#採用集合中的union方法獲取並集

test_list_union = test_list_01.union(test_list_02)

print(test_list_union) # {'LiBai', 'LuLu', 'ZhangXueYou', 'LiuDeHua', 'YangMi', 'YanYan'}

獲取差集的方式要採用集合中的difference方法，獲取兩個集合的差集的代碼如下所示：

#創建兩個集合，並且獲取集合的交集

test_list_01 = set(['YanYan','LiBai','LuLu','YangMi'])

test_list_02 = set(['YanYan','LiuDeHua','ZhangXueYou','LiBai'])

#使用集合中的difference方法來獲取差集

test_difference = test_list_01.difference(test_list_02)

test_difference2 = test_list_02.difference(test_list_01)

print(test_difference) # {'LuLu', 'YangMi'}print(test_difference2) # {'ZhangXueYou', 'LiuDeHua'}

判斷一個集合是否是另外一個集合的子集可以使用issubset()方法，同樣，還可以使用issuperset()方法判斷一個集合是否是另外一個集合的父級

代碼如下：

#創建兩個集合

list_set = set([1,2,3,4])

list_son = set([2,3])

#判斷list_son是否是list_set的子集print(list_son.issubset(list_set)) # True#判斷list_set是否是list_son的父級print(list_set.issuperset(list_son)) # True

對稱差集(又有人稱之為叫做反向差集)，指的是取出兩個集合中互相都沒有的值取出放在一個集合中。

代碼如下：

#創建兩個集合

list_set_num1 = set([1,3,5,7,9])

list_set_num2 = set([2,3,4,6,9,10])

#獲取兩個集合的對稱差集print(list_set_num1.symmetric_difference(list_set_num2)) # {1, 2, 4, 5, 6, 7, 10}

如果上述的難以理解的話，可以對對稱差集理解為去掉兩個集合中都存在的內容，將剩餘的內容取到一個新的集合中。

除了上述的這些方法實現的關系功能之外，還有一個方法isdisjoint()，功能是判斷兩個集合中是否有相同的值，如果兩個集合中沒有相同的值(即沒有交集)，那麼返回True

代碼如下：

#創建集合

test_set_num1 = set([1,2,3,4])

test_set_num2 = set([5,6,7,8])

test_set_num3 = set([1,3,7,8])

#使用isdisjoint()方法來判斷print(test_set_num1.isdisjoint(test_set_num2)) # Trueprint(test_set_num1.isdisjoint(test_set_num3)) # False

通過運算符來進行關系測試

在上面的應用中，主要是通過python中的方法進行的關系測試，那麼在python中，除了使用方法以外，還可以使用關系運算符來進行關系測試。

實例代碼如下：

test_list_01 =set(['YanYan','LiBai','LuLu','YangMi'])

test_list_02 =set(['YanYan','LiuDeHua','ZhangXueYou','LiBai'])

#獲取交集&print(test_list_01 & test_list_02) # {'LiBai', 'YanYan'}

#獲取並集|print(test_list_01 | test_list_02) # {'LuLu', 'LiBai', 'LiuDeHua', 'YanYan', 'ZhangXueYou', 'YangMi'}

#獲取差集-print(test_list_01 - test_list_02) # {'LuLu', 'YangMi'}print(test_list_02 - test_list_01) # {'LiuDeHua', 'ZhangXueYou'}

#獲取對稱差集print(test_list_01 ^ test_list_02) # {'ZhangXueYou', 'YangMi', 'LuLu', 'LiuDeHua'}

集合的增刪改查

添加

語法：Set.add()

代碼如下：

#創建一個集合

test_set =set(['YanYan'])

#添加

test_set.add('LiBai') #添加一項

test_set.update(['LuLu','JingJing']) #一次性向集合中添加多項

#輸出集合

print(test_set) #{'YanYan', 'LuLu', 'LiBai', 'JingJing'}

刪除

刪除集合中的某一個元素可以使用remove方法

代碼如下：

#創建一個集合

test_set = set(['YanYan'])

#使用remove方法刪除元素

test_set.remove('YanYan')print(test_set) # set()

刪除項目除了使用remove以外，還可以使用pop()方法，但是pop()方法刪除內容不能夠指定，只是隨機刪除。

pop方法會把刪除的內容返回，示例代碼如下：

#創建一個集合

test_set = set([20,9,'a',1,2,3,4])print(test_set.pop()) # 1print(test_set.pop()) # 2print(test_set.pop()) # 3

刪除元素還可以使用discard()方法，這個方法沒有返回值，如果列印返回值的話會輸出None

#創建一個集合

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

#使用discard()方法刪除--注意，discard()方法刪除返回None，也就是沒有返回值print(test_list.discard(3)) # None#此時原集合中的3已經被刪除了print(test_list) # {1, 2, 4, 5}

查詢

xins #判斷x是否是s的成員

xnotins 判斷x是否是s的成員

len(x) #查看x的長度

s <= t #測試是否s中的每一個元素都在t中

s >= t #測試是否t中的每一個元素都在s中

⑤ 如何合並python字典里的列表中的元素

l2 = l1[:2]
l2.append(''.join(l1[2:]))
# l1是原列表，l2是處理後的列表

⑥ 電腦python並集符號怎麼打

• 首先打開pyharm編輯器。

  

⑦ python中集合的特點和注意點

1、集合概念

Python中的集合，是一個無序的、沒有重復項的集。它支持數學概念上的集合操作，如交集、並集、補集和差集。集合是可變的，可以在其中添加或刪除項。集合用花括弧「{}」括起來，並用逗號「,」來分隔其中的項。

2、創建集合

可以使用花括弧「{}」創建集合，集合會自動去除重復的項。下面的集合包含了幾種用字元串表示的水果：

• >>>#創建fruits集合時，'apple'出現了兩次

• >>>fruits={'apple','banana','watermelon','strawberry','apple'}

• >>>fruits#查看fruits集合，'apple'只有保留了一個

• {'apple','strawberry','banana','watermelon'}

與列表、元組、字典一樣，集合也可以用工廠函數set()來創建。set()函數的參數要麼為空，要麼為可迭代對象(如列表、元組和字元串)：

• >>>fruits=set(['apple','banana','watermelon','strawberry','apple'])#以列表為參數創建集合

• >>>fruits

• {'apple','strawberry','banana','watermelon'}

• >>>numbers=set((1,2,3,3,2,4))#以元組為參數創建集合

• >>>numbers

• {1,2,3,4}

• >>>letters=set('banana')#以字元串為參數創建集合

• >>>letters

• {'b','a','n'}

如果想要創建一個空集合，那麼使用空的花括弧「{}」是行不通的，因為這樣創建的是一個空字典：

• >>>empty={}

• >>>empty

• {}

• >>>type(empty)

• <class'dict'>

創建空集合的唯一方式就是使用不包含任何參數的set()函數：

• >>>empty=set()

• >>>empty#空集合表示為set()

• set()

• >>>type(empty)

• <class'set'>

3、集合添加項

集合是可變的數據類型，在創建集合之後，可以使用集合的add()方法向其添加項：

• >>>numbers={1,2,3}

• >>>numbers.add(4)#向numbers集合中添加整數4

• >>>numbers

• {1,2,3,4}

• >>>numbers.add('five')#向numbers集合中添加字元串'five'

• >>>numbers

• {1,2,3,4,'five'}

• >>>numbers.add((5,6,7))#向numbers集合中添加元組(5,6,7)

• >>>numbers

• {1,2,3,4,(5,6,7),'five'}

如果向某個集合中添加已經存在的項，那麼什麼也不會發生：

• >>>fruits={'apple','strawberry','banana','watermelon'}

• >>>fruits

• {'banana','apple','watermelon','strawberry'}

• >>>fruits.add('apple')#添加已經存在的項'apple'

• >>>fruits#fruits集合並沒有改變

• {'banana','apple','watermelon','strawberry'}

也可以使用集合的update()方法向集合中添加項，參數必須是可迭代對象，如列表、字元串或另一個集合。類似於列表的append()方法和extend()方法，但區別是集合的update()方法總是會將可迭代對象「展開」：

• >>>numbers={1}

• >>>numbers

• {1}

• >>>numbers.update((5,6,7))

• >>>numbers#可以看出update()方法和add()方法的區別

• {1,5,6,7}

• >>>numbers.update({4,5},{6,7,8})#參數為兩個集合

• >>>numbers

• {1,4,5,6,7,8}

4、集合刪除項

可以使用集合的remove()方法刪除某個集合中的指定項：

• >>>numbers={1,2,3,5,7}

• >>>numbers.remove(1)

• >>>numbers

• {2,3,5,7}

• >>>numbers.remove(3)

• >>>numbers

• {2,5,7}

如果試圖刪除集合中不存在的項，那麼Python解釋器會報錯：

• >>>numbers={1,2,3,5,7}

• >>>numbers.remove(4)

• Traceback(mostrecentcalllast):

• File"<stdin>",line1,in<mole>

• KeyError:4

還可以使用集合的discard()方法來刪除項，它和remove()方法唯一的區別是，當試圖刪除不存在的項時，discard()方法並不會報錯，而是什麼也不會發生：

• >>>numbers={1,2,3,5,7}

• >>>numbers.discard(1)

• >>>numbers

• {2,3,5,7}

• >>>numbers.discard(3)

• >>>numbers

• {2,5,7}

• >>>numbers.discard(4)

• >>>numbers#什麼也沒發生

• {2,5,7}

5、檢查某個項是否在集合中

集合的in操作符用於檢查指定項是否在集合中，not in操作符用於檢查指定項是否不在集合中：

• >>>numbers={1,2,3,5,7}

• >>>1innumbers#1在numbers集合中，返回True

• True

• >>>3innumbers#3在numbers集合中，返回True

• True

• >>>4innumbers#4不在numbers集合中，返回False

• False

• >>>4notinnumbers#notin是in的反向操作

• True

6、查看集合的長度

集合的內建函數len()用於查看集合的長度，即集合中項的個數：

• >>>empty=set()

• >>>len(empty)

• 0

• >>>numbers={1,2,3,5,7}

• >>>len(numbers)

• 5

⑧ python中字典與集合的區別

在 Python3.7+以後字典都被確定為有序，而集合是無序的元素集。
集合和字典基本相同，唯一的區別是集合沒有鍵和值的配對，是一系列無序的、唯一的元素組合。

⑨ 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中如何去兩個文件的並集

有時候，為了需求，需要統計兩個 list 之間的交集，並集，差集。查詢了一些資料，現在總結在下面:
1. 獲取兩個list 的交集

#方法一:

a=[2,3,4,5]

b=[2,5,8]

tmp = [val for val in a if val in b]

print tmp

#[2, 5]

#方法二

print list(set(a).intersection(set(b)))

2. 獲取兩個list 的並集

print list(set(a).union(set(b)))

3. 獲取兩個 list 的差集

print list(set(b).difference(set(a))) # b中有而a中沒有的