python3集合

Ⅰ python集合和函數

變數名={元素，元素，，，}

nums={11,24,45,96,28}

nums.add(42)

print(nums)

nums={11,24,45,96,28}

nums2=["anfly","tom"]

nums.update(nums2)

print(nums)

1）nums={11,24,45,96,28}  [沒有該數字報錯]

       nums.remove(24)

       print(nums)

2）nums={11,24,45,96,28}  [隨機刪]

     nums.pop()

     print(nums)

3）nums={11,24,45,96,28} [沒有該數字不會報錯]

     nums.discard(24)

     print(nums)

交集:(存在相同元素)

set1={"anfly","tom","haha"}

set2={"anfly","susala"}

set3=set1&set2

print(set3)

並集:(得到全部集合中全部的元素)

set1={1,2,3,4}

set2={3,4,5,6}

new_set=set1|set2

print(new_set)

運算符 (+ * in)

內置函數 (len max min del)

列：set1 = {"1","2","3"}

        print(min(set1))

def函數名():

       執行語句

函數名()

列：

defhello():

print("hello word")

hello()

2.函數參數：

def  add2num():

    a=11

    b=22

    c=a+b

print(c)

add2num()

3.位置參數:

def  fun(a,b):

     print("a:",a)

     print("b:",b)

fun(2,3)

4.關鍵字參數：
def  fun(a,b):

      print("a:",a)

     print("b:",b)

fun(a=2,b=3)   [第一個『a』可以直接寫數字，也可以展示；第二個以及之後『b』不能直接寫數字，要寫『b=3』這種格式]

5.預設參數

def printinfo(name,age=20):

      print("name:",name)

      print("age:",age)

printinfo(name="anfly")  [展示都能展示出來]

6.不定長參數

1).*args[展示是元組]

defprintinfo(*args):

     print("args:",args)

printinfo(100,200,300,400)

2）**args[展示是k.v格式]

def printinfo(**kwargs):

     print("kwargs:",kwargs)

printinfo(a=100,b=200,c=300,d=400)

7.參數位置順序

def sun(a,*args,b=22,**kwargs):

         print("a：",a)        ==10

         print("args：",args)    ==（200，300）

         print("b：",b)    ==2

         print("kwargs：",kwargs)  =={『m』:3,'n':4}

sun(100,200,300,b=2,m=3,n=4)

8.函數返回值

def fan(a,b):

      return a+b

print(fan(1,2))  #3

9.匿名函數（lambda函數也叫匿名函數，即函數沒有具體的名稱）

案例一：

sum=lambda a,b:a+b

print(sum(1,2))  #3

案例二：

sum=lambda a,b:100

print(sum(1,2))  #100

1.局部變數

def jv():

       a=3 

       print(a)

def jv1():   

       a=99   

       print(a)

jv()       #3

jv1()    #99

2.全局變數

def jv():

       print(a) 

 def jv1():   

        a=99   

        print(a)

jv()     #全局變數

jv1()    #99

3.局部變數升成全局變數

def jv():

        a=3 

        global b   

         b="我也是全局變數" 

          print(a)

def jv1():   

           a=99   

            print(a)   

             print(b)

jv()          #3

jv1()        #99 #「我也是全局變數」

Ⅱ Python的集合介紹

和列表類似，集合也是一個數據集合，其也不要求元素的類型一致。但是集合有下面兩個特點：

•集合內元素唯一。如不可以用1、2、1、1組成集合，因為其包含重復的1。

•集合是無序的，添加元素時不能指定位置，刪除元素時也不能通過指定位置，只能通過指定值。當然也不能通過位置來定位某個元素。

1、創建集合

我們可以從列表創建集合，將列表中的元素都加入到集合中，如果有重復的元素就僅保留一個。

a = set([1, 1, 3])

print(a)#輸出結果：set([1, 3])     

也可以從元組、字典和其他集合構建集合。比如：

a = set((0, 1, 2, 3, 3, 2))   

使用的是字典的鍵來構建集合，字典的值沒有被使用到，比如：

a = set({1:10, 2:20, 3:30})

從字元串構建集合，其每個字元都成為集合的一個元素，比如：

a = set("abcdefabc") 

輸出結果：a={'c', 'e', 'f', 'b', 'd', 'a'}

另外一個集合構建集合，比如：

a = set([1, 2, 3]) 

b = set(a)  輸出結果：b={1, 2, 3}

當然也可以構造一個空的集合，使用的方法是set()。空集合沒有任何元素，比如：

a = set()

1.添加元——add（值）

該函數只能添加一個元素。

如果添加的元素已經在集合中存在，那麼不會發生任何變化。

2.扔掉元素——discard（值）

該函數刪除集合中指定的值對應的元素。

如果指定值在集合中不存在，則不做任何操作。

3.刪除指定值——remove（值）

該函數和discard()的不同之處在於，如果指定的值在集合中不存在，會拋出異常。

4.清空所有元素——clear()

該函數扔掉所有的元素。執行完該函數後，該集合將變成一個空的集合。

a.clear()

5.刪除第一個元素——pop()

如果集合中有元素，則返回值為刪除掉的元素的值。

如果集合為空，則拋出異常。

6.得到差集——difference（集合對象）

該函數返回一個新的集合，該集合包含所有屬於a而不屬於b的元素，如圖所示。該操作不會改變原始集合a或者b的內容。

7.差集操作符（-）

該操作符和difference()類似，返回一個新的集合，該集合包含所有屬於a而不屬於b的元素。該操作不會改變原始輸入集合a或者b的內容。

8.從集合中刪除另一個集合中存在的元素——difference_update（集合對象）

該函數和difference()的不同是操作數a會被修改，而且沒有返回值。

9.得到兩個集合的交集——intersection（集合）

該函數返回所有的同時屬於集合a和集合b的元素組成的集合，即返回的是一個集合，該集合的所有元素都同時屬於集合a和b，如圖所示。輸入集合a和b在該過程中沒有發生任何改變。

10.交集操作符（&）

該操作符和intersection()的效果是一樣的。

11.刪除集合a中所有不屬於集合b的元素——intersection_update（集合）

該函數也是求交集，與intersection()不同的是其修改原始輸入集合，並且沒有返回值。這也是為何該介面函數後面帶有update字樣，因為其更新了原來的輸入集合。

12.是否存在交集——isdisjoint()

該函數判斷是否存在這樣的元素，其同時屬於集合a和集合b。如果存在這樣的元素，返回False；否則返回True。

13.並集——union（集合a，集合b）

該函數返回一個新的集合，該集合的元素要麼屬於輸入集合a要麼屬於集合b。該操作不修改作為輸入的兩個集合a和b。如圖表示該函數返回的集合的內容。

14.並集操作符（|）

該操作符和union()的效果是一樣的。其返回一個並集，並且不修改輸入集合的內容。

15.添加屬於b而不屬於a的元素——update()

該函數在集合a中添加屬於b而不屬於a的所有元素。該操作和union()不同的是，其修改了輸入集合a，並且沒有返回值。

16.外集——symmetric_difference()

外集就是由只屬於集合a或者只屬於集合b的元素組成的集合，如圖所示。該操作返回一個新的集合，並且不修改原來的輸入集合a和b。

17.外集操作符（^）

該操作符和symmetric_difference()的效果是一樣的，也是返回一個新的集合，並且不會修改輸入的集合a或者b。

18.a和b的並集減去a和b的交集——symmetric_difference_update()

該函數和symmetric_difference()的區別是，其修改了集合a的值，並且沒有返回值。

19.是指定集合的子集嗎——issubset()

a是b的子集就是說集合a的所有元素都屬於集合b。

如果a等於b，那麼a和b互為子集。

20.是指定集合的超集嗎——issuperset()

a是b的超集合就是說集合b中的所有元素都屬於集合a。

如果a是b的超集，那麼b就是a的子集。

如果a等於b，那麼它們互為子集，同時也互為超集。

Ⅲ Python中創建集合的方法有哪些呢

集合分為兩種：可變集合（set）和不可變集合（frozenset），現在學習的是可變集合。

在Python中，有關於集合的操作主要有：集合的創建；集合的添加和刪除；集合的交、並和差集運算。

今天先來學習如何創建集合。

集合的創建有兩種方法：直接賦值法和set()函數法。

1、直接賦值法

和Python的其它序列一樣，採用直接賦值法就可以直接創建一個集合，具體語法格式如下：

setname = {「element1」,「element2」,「element3」,……,「elementn」,}

從格式上看，和其它的序列創建方法基本一樣，就是集合名setname直接使用賦值運算符等號「=」賦值，等號後面的元素內容使用英文半形的大括弧「{ }」括起來，各個元素之間依然使用英文半形的逗號「,」分隔。

這里雖然和字典一樣使用大括弧「{ }」，但是只要記住字典的元素是由鍵值對組成的（詳見前第62節內容），就完全可以區分所創建的是字典還是集合了。

Ⅳ 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基礎數據結構：序列、映射、集合

參考資料：http://www.cnblogs.com/jeffwongishandsome/archive/2012/08/05/2623660.html

Python中常見的數據結構可以統稱為容器（container）。序列（如列表和元組）、映射（如字典）以及集合（set）是三類主要的容器。

一、序列（列表、元組和字元串）

序列中的每個元素都有自己的編號。Python中有6種內建的序列。其中列表和元組是最常見的類型。其他包括字元串、Unicode字元串、buffer對象和xrange對象。下面重點介紹下列表、元組和字元串。

1、列表

列表是可變的，這是它區別於字元串和元組的最重要的特點，一句話概括即：列表可以修改，而字元串和元組不能。

（1）、創建

通過下面的方式即可創建一個列表：

輸出：

['hello', 'world']

[1, 2, 3]

可以看到，這中創建方式非常類似於javascript中的數組。

（2）、list函數

通過list函數（其實list是一種類型而不是函數）對字元串創建列表非常有效：

輸出：

['h', 'e', 'l', 'l', 'o']

2、元組

元組與列表一樣，也是一種序列，唯一不同的是元組不能被修改（字元串其實也有這種特點）。

（1） 、創建

輸出：

(1, 2, 3) ('jeffreyzhao', 'cnblogs') (1, 2, 3, 4) () (1,)

從上面我們可以分析得出：

a、逗號分隔一些值，元組自動創建完成；

b、元組大部分時候是通過圓括弧括起來的；

c、空元組可以用沒有包含內容的圓括弧來表示；

d、只含一個值的元組，必須加個逗號（,）；

（2）、tuple函數

tuple函數和序列的list函數幾乎一樣：以一個序列（注意是序列）作為參數並把它轉換為元組。如果參數就算元組，那麼該參數就會原樣返回：

輸出：

(1, 2, 3)

('j', 'e', 'f', 'f')

(1, 2, 3)

Traceback (most recent call last):

File "F:\Python\test.py", line 7, in

t4=tuple(123)

TypeError: 'int' object is not iterable

3、字元串

（1）創建

輸出：

Hello world

H

H

e

l

l

o

w

o

r

l

d

（2）、格式化

format（）：

print(『{0} was {1} years old when he wrote this book』. format(name,age) )

print(『{} was {} years old when he wrote this book』. format(name,age) )

print(『{name} was {age} years old when he wrote this book』. format(name=』Lily』,age=』22』) )

#對於浮點數「0.333」保留小數點後三位

print(『{0 : .3f}』.format(1.0/3) )

結果：0.333

#使用下劃線填充文本，並保持文字處於中間位置

#使用^定義『_____hello_____』字元串長度為11

print(『{0 : ^_11}』.format(『hello』) )

結果：_____hello_____

% :

格式化操作符的右操作數可以是任何東西，如果是元組或者映射類型（如字典），那麼字元串格式化將會有所不同。

輸出：

Hello,world

Hello,World

注意：如果需要轉換的元組作為轉換表達式的一部分存在，那麼必須將它用圓括弧括起來：

輸出：

Traceback (most recent call last):

File "F:\Python\test.py", line 2, in

str1='%s,%s' % 'Hello','world'

TypeError: not enough arguments for format string

如果需要輸出%這個特殊字元，毫無疑問，我們會想到轉義，但是Python中正確的處理方式如下：

輸出：100%

對數字進行格式化處理，通常需要控制輸出的寬度和精度：

輸出：

3.14

3.141593

3.14

字元串格式化還包含很多其他豐富的轉換類型，可參考官方文檔。

4、通用序列操作（方法）

從列表、元組以及字元串可以「抽象」出序列的一些公共通用方法（不是你想像中的CRUD），這些操作包括：索引（indexing）、分片（sliceing）、加（adding）、乘（multiplying）以及檢查某個元素是否屬於序列的成員。除此之外，還有計算序列長度、最大最小元素等內置函數。

（1）索引

輸出

H

2

345

索引從0（從左向右）開始，所有序列可通過這種方式進行索引。神奇的是，索引可以從最後一個位置（從右向左）開始，編號是-1：

輸出：

o

3

123

（2）分片

分片操作用來訪問一定范圍內的元素。分片通過冒號相隔的兩個索引來實現：

輸出：

[0, 1, 2, 3, 4, 5, 6, 7, 8, 9]

[1, 2, 3, 4]

[6, 7, 8, 9]

[1, 2, 3, 4, 5, 6, 7, 8, 9]

[7, 8]

[7, 8, 9]

不同的步長，有不同的輸出：

輸出：

[0, 1, 2, 3, 4, 5, 6, 7, 8, 9]

[0, 1, 2, 3, 4, 5, 6, 7, 8, 9]

[0, 2, 4, 6, 8]

[0, 3, 6, 9]

[]

（3）序列相加

輸出：

Hello world

[1, 2, 3, 2, 3, 4]

Traceback (most recent call last):

File "F:\Python\test.py", line 7, in

print str1+num1

TypeError: cannot concatenate 'str' and 'list' objects

（4）乘法

輸出：

[None, None, None, None, None, None, None, None, None, None]

HelloHello

[1, 2, 1, 2]

Traceback (most recent call last):

File "F:\Python\test.py", line 5, in

print str1*num1

TypeError: can't multiply sequence by non-int of type 'list'

（5）成員資格

in運算符會用來檢查一個對象是否為某個序列（或者其他類型）的成員（即元素）：

輸出：

False

True

True

（6）長度、最大最小值

通過內建函數len、max和min可以返回序列中所包含元素的數量、最大和最小元素。

輸出：

5

o

H

5

123

1

二、映射（字典）

映射中的每個元素都有一個名字，如你所知，這個名字專業的名稱叫鍵。字典（也叫散列表）是Python中唯一內建的映射類型。

1、鍵類型

字典的鍵可以是數字、字元串或者是元組，鍵必須唯一。在Python中，數字、字元串和元組都被設計成不可變類型，而常見的列表以及集合（set）都是可變的，所以列表和集合不能作為字典的鍵。鍵可以為任何不可變類型，這正是Python中的字典最強大的地方。

輸出：

{1: 1}

Traceback (most recent call last):

File "F:\Python\test.py", line 6, in

d[list1]="Hello world."

TypeError: unhashable type: 'list'

2、自動添加

即使鍵在字典中並不存在，也可以為它分配一個值，這樣字典就會建立新的項。

3、成員資格

表達式item in d（d為字典）查找的是鍵（containskey），而不是值（containsvalue）。

三、集合

集合（Set）在Python 2.3引入，通常使用較新版Python可直接創建，如下所示：

strs=set(['jeff','wong','cnblogs'])

nums=set(range(10))

看上去，集合就是由序列（或者其他可迭代的對象）構建的。集合的幾個重要特點和方法如下：

1、副本是被忽略的

集合主要用於檢查成員資格，因此副本是被忽略的，如下示例所示,輸出的集合內容是一樣的。

輸出如下：

set([0, 1, 2, 3, 4, 5])

set([0, 1, 2, 3, 4, 5])

2、集合元素的順序是隨意的

這一點和字典非常像，可以簡單理解集合為沒有value的字典。

輸出如下：

set(['wong', 'cnblogs', 'jeff'])

3、集合常用方法

a、並集union

輸出：

set([1, 2, 3])

set([2, 3, 4])

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

union操作返回兩個集合的並集，不改變原有集合。使用按位與（OR）運算符「|」可以得到一樣的結果：

輸出和上面union操作一模一樣的結果。

其他常見操作包括&（交集）,<=,>=,-,()等等，這里不再列舉。

輸出如下：

set([1, 2, 3])

set([2, 3, 4])

set([2, 3])

True

set([1, 2, 3])

False

b、add和remove

和序列添加和移除的方法非常類似，可參考官方文檔：

輸出：

set([1])

set([1, 2])

set([1])

set([1])

False

Traceback (most recent call last):

File "F:\Python\test.py", line 9, in

set1.remove(29) #移除不存在的項

KeyError: 29

4、frozenset

集合是可變的，所以不能用做字典的鍵。集合本身只能包含不可變值，所以也就不能包含其他集合：

輸出如下：

Traceback (most recent call last):

File "F:\Python\test.py", line 3, in

set1.add(set2)

TypeError: unhashable type: 'set'

可以使用frozenset類型用於代表不可變（可散列）的集合：

輸出：

set([1, frozenset([2])])

Ⅵ 2021-04-04 python3集合運算：補集交集並集子集

A在B中的相對補集：
元素屬於B，但不屬於A。寫作B - A，讀作「A在B中的相對補集」。

以{1，2，3}為例說明子集和真子集：
子集為{1}、{2}、{3}、{1，2}、{1，3}、{2，3}、它本身、再加個空集
真子集為{1}、{2}、{3}、{1，2}、{1，3}、{2，3}、再加個空集，不包括它本身。
非空真子集為{1}、{2}、{3}、{1，2}、{1，3}、{2，3}，不包括它本身及空集。

運行結果：

in 不能用來判斷子集，可以判斷元素是否存在於集合中

運行結果：

https://www.videoc.cn/pages/208120043
https://ke..com/item/%E7%9B%B8%E5%AF%B9%E8%A1%A5%E9%9B%86?fromtitle=%E7%BB%9D%E5%AF%B9%E8%A1%A5%E9%9B%86&fromid=942400
https://blog.csdn.net/liu_yuan_kai/article/details/81127422
https://blog.csdn.net/weixin_36670529/article/details/107102920

Ⅶ python中集合的表述方式

解決集合出現下劃線「function can call be replace with set literal」的問題

集合的三種創建方式：

>>> def f():

       return set([1, 2, 3])

>>> def h():

       return set((1, 2, 3))

>>> def g():  #set Literals

       return {1, 2, 3}

>>> f()

set([1, 2, 3])

>>> h()

set([1, 2, 3])

>>> g()

set([1, 2, 3])

效率對比：

>>> import timeit

>>> min(timeit.repeat(f))

0.675529956817627

>>> min(timeit.repeat(h))

0.5531120300292969

>>> min(timeit.repeat(g))

0.35515809059143066        #最快

盡管這里生成set()的方式對性能的提升很小，set literals不用花費時間調用函數處理中間數據，並且這種寫法是非常漂亮的，所以 建議用set literals的方式

a=set(["1","2","3"])可以用a={"1","2","3"}代替，這樣演算法的時間更短，不用調用set()函數，雖然這種表達和字典形式沖突，但機器會根據輸入的形式判斷是字典還是集合。但是如果是空字典和空集合，則必須用set加以區分。如空字典 dic={}   空集合 s=set()

Ⅷ python數據類型（集合）

    1.集合（set）是一個無序不重復元素的序列(意思是有重復的會自動刪除,每次列印元素的位置不一定)

    2.基本功能是進行成員關系測試和刪除重復元素

    3.可以使用大括弧 { } 或者 set() 函數創建集合，注意：創建一個空集合必須用 set() 而不是 { }，因為 { } 是用來創建一個空字典

    4.因為set存儲的是無序集合，所以我們沒法通過索引來訪問。訪問 set中的某個元素實際上就是判斷一個元素是否在set中。

1.創建集合

s=set()#創建一個空集合

s1={1,2,3,'a','python'}

2.刪除重復的元素

集合是一個無序不重復元素的序列(意思是有重復的會自動刪除,每次列印元素的位置不一定)

3.成員關系測試(檢測某個成員是否在集合中)

案例:從終端輸入5位數,以空格隔開,把這5位數存入列表中,剔除重復的數據,列印出來

#提示,列表轉集合,集合轉列表

a=input("請輸入5位數字:")

mylist=a.split()

print(mylist)

b=set(mylist)

c=list(b)

print(c)

4.集合常用操作

    1.添加元素

    2.刪除元素

    3.刪除整個集合

    4.獲取集合的長度

    5.不支持改元素

集合操作-添加元素

格式:

集合.add(元素)

格式:

集合.update(元素)

區別:

add不能添加列表,update可以

update是將字元串中的拆分成字元進行追加

add，是當做整體追加在集合中

#案例:從終端輸入一個數字就加入集合中,然後列印,又輸入一個數字,然後列印,直到輸入-1,退出輸入

#然後列印最終的集合

ms=set()

while 1:

a=int(input("請輸入一個數字:"))

if a==-1:

    break

    ms.add(a)

print(ms)

print(ms)

#案例:從終端輸入一個字元串就加入集合中,然後列印,又輸入一個字元串,然後列印,直到輸入q,退出輸入

#然後列印最終的集合,字元串要分開存儲,如輸入hello,存儲的列表是{'h','e','l','0'}

ms=set()

while 1:

a=input("請輸入一個字元串:")

if a=='q':

    break

    ms.update(a)

print(ms)

print(ms)

集合操作-刪除元素及刪除整個集合

格式:

集合.remove(元素)  # 元素如果不存在會引發KeyError

集合.discard(元素)  # 元素如果不存在不發生任何事

集合.pop()  # 集合元素是字元串類型時刪除隨機元素。 集合元素是其他數據類型時，刪除左邊第一個元素

del 集合名 #刪除整個集合

#案例:有集合{1,2,3,'hello','world'},刪除全部字元串,然後最左邊第一個元素

a={1,2,3,'hello','world'}

a.discard("hello")

a.discard("world")

a.pop()

print(a)

集合操作-獲取集合的長度

格式:

len(集合名)

#案例:有集合{1,2,3,4,'hello','a'},保留1個元素,其他的刪除,假如元素個數不確定

s={1,2,3,4,'hello','a'}

for i  in range(len(s)-1):

            s.pop()

  print(s)

集合的集運算

集合的交集,並集,差集,對稱差集的運算

{1,2,3,4}交集{4,5,6,7} -->4   交集(&)

{1,2,3,4}並集{4,5,6,7} ->1,2,3,4,5,6,7  並集(|)

{1,2,3,4}差集{4,5,6,7} ->1,2,3  差集(-)

{1,2,3,4}對稱差集{4,5,6,7}->1,2,3,5,6,7 4同時出現在兩個集合中,不選它 對稱差集(^)

#案例:使用花括弧和set創建各一個集合,然後對集合進行交、並、差、對稱差運算

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

s1=set([6,7,8,9,10])

print(s&s1)

print(s|s1)

print(s-s1)

print(s^s1)

Ⅸ Python3的元組，字典，列表，集合有什麼聯系和區別

4個都是python的數據結構。
元組和列表的底層實現是一樣的，本質都是把一堆東西放在一排，區別在於元祖放完後就不能改了。
你把字典理解成我們普通用的字典就可以了，而集合就是把字典的所有value都設置成None。字典和集合的底層實現原理是一樣的，但初學者不必關注這個原理。集合與數學中的集合有相同性質，比如唯一性，對比字典中key的唯一性來理解一下。
比方：你遇到一個沒見過的字，查查看是不是標準的漢字，這就是集合的作用，集合只關注有沒有的問題；如果是標准漢字，你要看看這個字的意思，這就是字典的作用；你現在找來一個漢字，打算組成成語，然後再找幾個字，向第一個漢字左右放，就是列表的作用；一旦發現一個成語，就固定不變了，字和字的排列都不能改，這就是元祖。

Ⅹ 寫出python中6種數據類型

Python中的變數不需要聲明。每個變數在使用前都必須賦值，變數賦值以後該變數才會被創建。
Python3中有六個標準的數據類型：Number（數字）+String（字元串）+List（列表）+Tuple（元組）+Sets（集合）+Dictionary（字典）。
Number（數字）數字類型是顧名思義是用來存儲數值的，需要記住的是，有點和Java的字元串味道差不多，如果改變了數字數據類型的值，將重新分配內存空間。
可以使用del語句刪除一些數字對象的引用delvar1[,var2[,var3[....,varN]]]]。Python支持三種不同的數值類型：
1.整型(Int)-通常被稱為是整型或整數，是正或負整數，不帶小數點。
Python3整型是沒有限制大小的，可以當作Long類型使用，所以Python3沒有Python2的Long類型。
2.浮點型(float)-浮點型由整數部分與小數部分組成，浮點型也可以使用科學計數法表示（2.5e2=2.5x102=250）
3.復((complex))-復數由實數部分和虛數部分構成，可以用a+bj,或complex(a,b)表示，復數的實部a和虛部b都是浮點型。數字類型轉換1.int(x)將x轉換為一個整數。
4.complex(x,y)將x和y轉換到一個復數，實數部分為x，虛數部分為y。x和y是數字表達式。