Python基礎入門_2基礎語法和變量類型

時間 2019-12-08

標籤 python 基礎入門語法變量類型欄目 Python 简体版

原文原文鏈接

原文連接：mp.weixin.qq.com/s/Cw1TyTLKP…html

Python 基礎入門系列第二篇，上一篇簡單介紹了爲何用 Python，以及安裝和配置環境。python

這一篇將先介紹基礎的語法，包括標識符，即變量名字，而後 Python 特點的縮進規則，註釋、保留字等等，接着就是 Python 內置的六種基本數據類型的簡單介紹。git

注意：主要是基於 Python 3 的語法來介紹，而且代碼例子也是在 Python3 環境下運行的。github

本文的目錄以下：算法

1 基礎語法

標識符

標識符由字母、數字和下劃線(_)組成，其中不能以數字開頭，而且區分大小寫。編程

如下劃線開頭的標識符是有特殊意義的：bash

單下劃線開頭的如 _foo，表示不能直接訪問的類屬性，須要經過類提供的接口進行訪問，不能經過 from xxx import * 導入；
雙下劃線開頭的如 __foo ，表示類的私有成員；
雙下劃線開頭和結尾的如 __foo__ 表明 Python 中的特殊方法，好比 __init()__ 表明類的構建函數

保留字

保留字是不能用做常數或變數，或者其餘任何標識符名稱。 keyword 模塊能夠輸出當前版本的全部關鍵字：微信

import keyword
print(keyword.kwlist)
複製代碼

全部的保留字以下所示：數據結構


and	exec	not
assert	finally	or
break	for	pass
class	from	print
continue	global	raise
def	if	return
del	import	try
elif	in	while
else	is	with
except	lambda	yield

行和縮進

和其餘編程語言的最大區別就是，Python 的代碼塊不採用大括號 {} 來控制類、函數以及其餘邏輯判斷，反卻是採用縮進來寫模塊。app

縮進的空白數量是可變的，可是全部代碼塊語句必須包含相同的縮進空白數量，這個必須嚴格執行，以下所示：

# 正確示例
i = 2
if i == 3:
    print('true!')
else:
  print('False')

# 錯誤示例
if i == 3:
    print('i:')
    print(i)
else:
    print('wrong answer!')
    # 沒有嚴格縮進，執行時會報錯
  print('please check again')
複製代碼

這裏將會報錯 IndentationError: unindent does not match any outer indentation level，這個錯誤表示採用的縮進方式不一致，有的是 tab 鍵縮進，有的是空格縮進，改成一致便可。

而若是錯誤是 IndentationError: unexpected indent，表示格式不正確，多是 tab 和空格沒對齊的問題。

所以，按照約定俗成的管理，應該始終堅持使用4個空格的縮進，而且注意不能混合使用 tab 鍵和四格空格，這會報錯！

註釋

註釋分爲兩種，單行和多行的。

# 單行註釋
print('Hello, world!')

''' 這是多行註釋，使用單引號。 這是多行註釋，使用單引號。 這是多行註釋，使用單引號。 '''

""" 這是多行註釋，使用雙引號。 這是多行註釋，使用雙引號。 這是多行註釋，使用雙引號。 """
複製代碼

輸入輸出

一般是一條語句一行，若是語句很長，咱們可使用**反斜槓(\)**來實現多行語句。在 [], {}, 或 ()中的多行語句，則不須要反斜槓。

sentence1 = "I love " + \
"python"

sentence2 = ["I", "love",
          "python"]
複製代碼

另外，咱們也能夠同一行顯示多條語句，語句之間用分號(;)分割，示例以下：

print('Hello');print('world')
複製代碼

對於用戶輸入，Python2 採用的是 raw_input()，而 3 版本則是 input() 函數：

# 等待用戶輸入
# python 2 
user_input = raw_input('請輸入一個數字:\n')
# python 3
user_input = input('請輸入一個數字:\n')
print('user_input=', user_input)
複製代碼

其中 \n 實現換行。用戶按下回車鍵(enter)退出，其餘鍵顯示。

對於 print 輸出，默認輸出是換行的，若是須要實現不換行，能夠指定參數 end，以下所示：

a = 3
b = 2
c = 4
d = 5
# 默認換行
print(a)
print(b)
# 不換行，並設置逗號分隔
print(c, end=',')
print(d)
複製代碼

2 基本變量類型

計算機程序要處理不一樣的數據，須要定義不一樣的數據類型。Python 定義了六種標準的數據類型，分佈以下所示：

Numbers(數字)
Strings(字符串)
List(列表)
Tuple(元組)
Set(集合)
Dictionary(字典)

變量賦值

Python 並不須要聲明變量的類型，所說的"類型"是變量所指的內存中對象的類型。但每一個變量使用前都必須賦值，而後纔會建立變量。給變量賦值的方法是採用等號(=)，等號左邊是變量名，右邊是存儲在變量中的值。

一個示例以下：

counter = 100  # 賦值整型變量
miles = 1000.0  # 浮點型
name = "John"  # 字符串

print(counter)
print(miles)
print(name)
複製代碼

Python 還容許同時爲多個變量賦值，有如下兩種實現方式：

# 建立一個整型對象，值爲1，三個變量被分配到相同的內存空間上
n = m = k = 2
# 建立多個對象，而後指定多個變量
cc, mm, nn = 1, 3.2, 'abc'

print('n=m=k=', n, m, k)
print('cc=', cc)
print('mm=', mm)
print('nn=', nn)
複製代碼

其中同時給多個變量賦值的方式也是 Python 獨特的一種變量賦值方法。

數字

數字類型用於存儲數值，它是不可改變的數據類型。Python 3 支持如下幾種數字類型：

int (整數)
float (浮點型)
complex(複數)
bool (布爾)

數字類型的使用很簡單，也很直觀，以下所示：

# int
q = 1
# float
w = 2.3
# bool
e = True
# complex
r = 1 + 3j
print(q, w, e, r) # 1 2.3 True (1+3j)

# 內置的 type() 函數能夠用來查詢變量所指的對象類型
print(type(q))  # <class 'int'>
print(type(w))  # <class 'float'>
print(type(e))  # <class 'bool'>
print(type(r))  # <class 'complex'>

# 也能夠採用 isinstance()
# isinstance 和 type 的區別在於：type()不會認爲子類是一種父類類型，isinstance()會認爲子類是一種父類類型
print(isinstance(q, int)) # True
print(isinstance(q, float)) # False
複製代碼

對於數字的運算，包括基本的加減乘除，其中除法包含兩個運算符，/ 返回一個浮點數，而 // 則是獲得整數，去掉小數點後的數值。並且在混合計算的時候， Python 會把整數轉換爲浮點數。

# 加
print('2 + 3 =', 2 + 3)  # 2 + 3 = 5
# 減
print('3 - 2 =', 3 - 2)  # 3 - 2 = 1
# 乘
print('5 * 8 =', 5 * 8)  # 5 * 8 = 40
# 除
# 獲得浮點數，完整的結果
print('5 / 2 =', 5 / 2)  # 5 / 2 = 2.5
# 獲得一個整數
print('5 // 2 =', 5 // 2)  # 5 // 2 = 2
# 取餘
print('5 % 2 =', 5 % 2)  # 5 % 2 = 1
# 乘方
print('5 ** 2 =', 5 ** 2)  # 5 ** 2 = 25
複製代碼

字符串

字符串或串(String)是由數字、字母、下劃線組成的一串字符。通常是用單引號 '' 或者 "" 括起來。

注意，Python 沒有單獨的字符類型，一個字符就是長度爲 1 的字符串。而且，Python 字符串是不可變，向一個索引位置賦值，如 strs[0]='m' 會報錯。

能夠經過索引值或者切片來訪問字符串的某個或者某段元素，注意索引值從 0 開始，例子以下所示：

切片的格式是 [start:end]，實際取值範圍是 [start:end) ，即不包含 end 索引位置的元素。還會除了正序訪問，還能夠倒序訪問，即索引值能夠是負值。

具體示例以下所示：

s1 = "talk is cheap"
s2 = 'show me the code'
print(s1)
print(s2)

# 索引值以 0 爲開始值，-1 爲從末尾的開始位置
print('輸出 s1 第一個到倒數第二個的全部字符: ', s1[0:-1])  # 輸出第一個到倒數第二個的全部字符
print('輸出 s1 字符串第一個字符: ', s1[0])  # 輸出字符串第一個字符
print('輸出 s1 從第三個開始到第六個的字符: ', s1[2:6])  # 輸出從第三個開始到第六個的字符
print('輸出 s1 從第三個開始的後的全部字符:', s1[2:])  # 輸出從第三個開始的後的全部字符

# 加號 + 是字符串的鏈接符
# 星號 * 表示複製當前字符串，緊跟的數字爲複製的次數
str = "I love python "
print("鏈接字符串:", str + "!!!")
print("輸出字符串兩次:", str * 2)

# 反斜槓 \ 轉義特殊字符
# 若不想讓反斜槓發生轉義，能夠在字符串前面添加一個 r
print('I\nlove\npython')
print("反斜槓轉義失效:", r'I\nlove\npython')
複製代碼

注意：

一、反斜槓能夠用來轉義，使用 r 可讓反斜槓不發生轉義。
二、字符串能夠用 + 運算符鏈接在一塊兒，用 * 運算符重複。
三、Python 中的字符串有兩種索引方式，從左往右以 0 開始，從右往左以 -1 開始。
四、Python 中的字符串不能改變。

字符串包含了不少內置的函數，這裏只介紹幾種很是常見的函數：

strip(x)：當包含參數 x 表示刪除句首或者句末 x 的部分，不然，就是刪除句首和句末的空白字符，而且能夠根據須要調用 lstrip() 和 rstrip() ，分別刪除句首和句末的空白字符；
split()：一樣能夠包含參數，若是不包含參數就是將字符串變爲單詞形式，若是包含參數，就是根據參數來劃分字符串；
join()：主要是將其餘類型的集合根據必定規則變爲字符串，好比列表；
replace(x, y)：採用字符串 y 代替 x
index()：查找指定字符串的起始位置
startswith() / endswith()：分別判斷字符串是否以某個字符串爲開始，或者結束；
find()：查找某個字符串；
upper() / lower() / title()：改變字符串的大小寫的三個函數

下面是具體示例代碼：

# strip()
s3 = " I love python "
s4 = "show something!"
print('輸出直接調用 strip() 後的字符串結果: ', s3.strip())
print('lstrip() 刪除左側空白後的字符串結果: ', s3.lstrip())
print('rstrip() 刪除右側空白後的字符串結果: ', s3.rstrip())
print('輸出調用 strip(\'!\')後的字符串結果: ', s4.strip('!'))
# split()
s5 = 'hello, world'
print('採用split()的字符串結果: ', s5.split())
print('採用split(\',\')的字符串結果: ', s5.split(','))
# join()
l1 = ['an', 'apple', 'in', 'the', 'table']
print('採用join()鏈接列表 l1 的結果: ', ''.join(l1))
print('採用\'-\'.join()鏈接列表 l1 的結果: ', '-'.join(l1))
# replace()
print('replace(\'o\', \'l\')的輸出結果: ', s5.replace('o', 'l'))
# index()
print('s5.index(\'o\')的輸出結果: ', s5.index('o'))
# startswith() / endswith()
print('s5.startswith(\'h\')的輸出結果: ', s5.startswith('h'))
print('s5.endswith(\'h\')的輸出結果: ', s5.endswith('h'))
# find()
print('s5.find(\'h\')的輸出結果: ', s5.find('h'))
# upper() / lower() / title()
print('upper() 字母全大寫的輸出結果: ', s5.upper())
print('lower() 字母全小寫的輸出結果: ', s5.lower())
print('title() 單詞首字母大寫的輸出結果: ', s5.title())
複製代碼

列表

列表是 Python 中使用最頻繁的數據類型，它能夠完成大多數集合類的數據結構實現，能夠包含不一樣類型的元素，包括數字、字符串，甚至列表（也就是所謂的嵌套）。

和字符串同樣，能夠經過索引值或者切片(截取)進行訪問元素，索引也是從 0 開始，而若是是倒序，則是從 -1 開始。列表截取的示意圖以下所示：

另外，還能夠添加第三個參數做爲步長：

一樣，列表也有不少內置的方法，這裏介紹一些常見的方法：

len(list)：返回列表的長度
append(obj) / insert(index, obj) / extend(seq)：增長元素的幾個方法
pop() / remove(obj) / del list[index] / clear()：刪除元素
reverse() / reversed：反轉列表
sort() / sorted(list)：對列表排序，注意前者會修改列表內容，後者返回一個新的列表對象，不改變原始列表
index()：查找給定元素第一次出現的索引位置

初始化列表的代碼示例以下：

# 建立空列表，兩種方法
list1 = list()
list2 = []
# 初始化帶有數據
list3 = [1, 2, 3]
list4 = ['a', 2, 'nb', [1, 3, 4]]

print('list1:', list1)
print('list2:', list2)
print('list3:', list3)
print('list4:', list4)
print('len(list4): ', len(list4))
複製代碼

添加元素的代碼示例以下：

# 末尾添加元素
list1.append('abc')
print('list1:', list1)
# 末尾添加另外一個列表，併合併爲一個列表
list1.extend(list3)
print('list1.extend(list3), list1:', list1)
list1.extend((1, 3))
print('list1.extend((1,3)), list1:', list1)
# 經過 += 添加元素
list2 += [1, 2, 3]
print('list2:', list2)
list2 += list4
print('list2:', list2)
# 在指定位置添加元素,原始位置元素右移一位
list3.insert(0, 'a')
print('list3:', list3)
# 末尾位置添加，原來末尾元素依然保持在末尾
list3.insert(-1, 'b')
print('list3:', list3)
複製代碼

刪除元素的代碼示例以下：

# del 刪除指定位置元素
del list3[-1]
print('del list3[-1], list3:', list3)
# pop 刪除元素
pop_el = list3.pop()
print('list3:', list3)
print('pop element:', pop_el)
# pop 刪除指定位置元素
pop_el2 = list3.pop(0)
print('list3:', list3)
print('pop element:', pop_el2)
# remove 根據值刪除元素
list3.remove(1)
print('list3:', list3)
# clear 清空列表
list3.clear()
print('clear list3:', list3)
複製代碼

查找元素和修改、訪問元素的代碼示例以下：

# index 根據數值查詢索引
ind = list1.index(3)
print('list1.index(3)，index=', ind)
# 訪問列表第一個元素
print('list1[0]: ', list1[0])
# 訪問列表最後一個元素
print('list1[-1]: ', list1[-1])
# 訪問第一個到第三個元素
print('list1[:3]: ', list1[:3])
# 訪問第一個到第三個元素,步長爲2
print('list1[:3:2]: ', list1[:3:2])
# 複製列表
new_list = list1[:]
print('copy list1, new_list:', new_list)
複製代碼

排序的代碼示例以下：

list5 = [3, 1, 4, 2, 5]
print('list5:', list5)
# use sorted
list6 = sorted(list5)
print('list6=sorted(list5), list5={}, list6={}'.format(list5, list6))
# use list.sort()
list5.sort()
print('list5.sort(), list5: ', list5)
複製代碼

sorted() 都不會改變列表自己的順序，只是對列表臨時排序，並返回一個新的列表對象；

相反，列表自己的 sort() 會永久性改變列表自己的順序。

另外，若是列表元素不是單純的數值類型，如整數或者浮點數，而是字符串、列表、字典或者元組，那麼還能夠自定義排序規則，這也就是定義中最後兩行，例子以下：

# 列表元素也是列表
list8 = [[4, 3], [5, 2], [1, 1]]
list9 = sorted(list8)
print('list9 = sorted(list8), list9=', list9)
# sorted by the second element
list10 = sorted(list8, key=lambda x: x[1])
print('list10 = sorted(list8, key=lambda x:x[1]), list10=', list10)
list11 = sorted(list8, key=lambda x: (x[1], x[0]))
print('list11 = sorted(list8, key=lambda x:(x[1],x[0])), list11=', list11)
# 列表元素是字符串
list_str = ['abc', 'pat', 'cda', 'nba']
list_str_1 = sorted(list_str)
print('list_str_1 = sorted(list_str), list_str_1=', list_str_1)
# 根據第二個元素排列
list_str_2 = sorted(list_str, key=lambda x: x[1])
print('list_str_2 = sorted(list_str, key=lambda x: x[1]), list_str_2=', list_str_2)
# 先根據第三個元素，再根據第一個元素排列
list_str_3 = sorted(list_str, key=lambda x: (x[2], x[0]))
print('list_str_3 = sorted(list_str, key=lambda x: (x[2], x[0])), list_str_3=', list_str_3)
複製代碼

反轉列表的代碼示例以下：

# 反轉列表
list5.reverse()
print('list5.reverse(), list5: ', list5)
list7 = reversed(list5)
print('list7=reversed(list5), list5={}, list7={}'.format(list5, list7))
#for val in list7:
# print(val)
# 注意不能同時兩次
list7_val = [val for val in list7]
print('採用列表推導式, list7_val=', list7_val)
list8 = list5[::-1]
print('list5 = {}\nlist_reversed = list5[::-1], list_reversed = {}'.format(list5, list_reversed))
複製代碼

reverse() 方法會永久改變列表自己，而 reversed() 不會改變列表對象，它返回的是一個迭代對象，如例子輸出的 <list_reverseiterator object at 0x000001D0A17C5550> , 要獲取其排序後的結果，須要經過 for 循環，或者列表推導式，但須要注意，它僅僅在第一次遍歷時候返回數值。

以及，一個小小的技巧，利用切片實現反轉，即 <list> = <list>[::-1]。

元組

元組和列表比較類似，不一樣之處是元組不能修改，而後元組是寫在小括號 () 裏的。

元組也能夠包含不一樣的元素類型。簡單的代碼示例以下：

t1 = tuple()
t2 = ()
t3 = (1, 2, '2', [1, 2], 5)
# 建立一個元素的元祖
t4 = (7, )
t5 = (2)
print('建立兩個空元組：t1={}, t2={}'.format(t1, t2))
print('包含不一樣元素類型的元組：t3={}'.format(t3))
print('包含一個元素的元祖: t4=(7, )={}, t5=(2)={}'.format(t4, t5))
print('type(t4)={}, type(t5)={}'.format(type(t4), type(t5)))
print('輸出元組的第一個元素：{}'.format(t3[0]))
print('輸出元組的第二個到第四個元素：{}'.format(t3[1:4]))
print('輸出元祖的最後一個元素: {}'.format(t3[-1]))
print('輸出元祖兩次: {}'.format(t3 * 2))
print('鏈接元祖: {}'.format(t3 + t4))
複製代碼

元祖和字符串也是相似，索引從 0 開始，-1 是末尾開始的位置，能夠將字符串看做一種特殊的元組。

此外，從上述代碼示例能夠看到有個特殊的例子，建立一個元素的時候，必須在元素後面添加逗號，即以下所示:

tup1 = (2,) # 輸出爲 (2,)
tup2 = (2)  # 輸出是 2
print('type(tup1)={}'.format(type(tup1))) # 輸出是 <class 'tuple'>
print('type(tup2)={}'.format(type(tup2))) # 輸出是 <class 'int'>
複製代碼

還能夠建立一個二維元組，代碼例子以下：

# 建立一個二維元組
tups = (1, 3, 4), ('1', 'abc')
print('二維元組: {}'.format(tups)) # 二維元組: ((1, 3, 4), ('1', 'abc'))
複製代碼

而後對於函數的返回值，若是返回多個，實際上就是返回一個元組，代碼例子以下：

def print_tup():
    return 1, '2'


res = print_tup()
print('type(res)={}, res={}'.format(type(res), res)) # type(res)=<class 'tuple'>, res=(1, '2')
複製代碼

元組不可修改，但若是元素可修改，那能夠修改該元素內容，代碼例子以下所示：

tup11 = (1, [1, 3], '2')
print('tup1={}'.format(tup11)) # tup1=(1, [1, 3], '2')
tup11[1].append('123')
print('修改tup11[1]後，tup11={}'.format(tup11)) # 修改tup11[1]後，tup11=(1, [1, 3, '123'], '2')
複製代碼

由於元組不可修改，因此僅有如下兩個方法：

count(): 計算某個元素出現的次數
index(): 尋找某個元素第一次出現的索引位置

代碼例子：

# count()
print('tup11.count(1)={}'.format(tup11.count(1)))
# index()
print('tup11.index(\'2\')={}'.format(tup11.index('2')))
複製代碼

字典

字典也是 Python 中很是經常使用的數據類型，具備如下特色：

它是一種映射類型，用 {} 標識，是無序的 鍵(key): 值(value) 的集合；
鍵(key) 必須使用不可變類型；
同一個字典中，鍵必須是惟一的；

建立字典的代碼示例以下，總共有三種方法：

# {} 形式
dic1 = {'name': 'python', 'age': 20}
# 內置方法 dict()
dic2 = dict(name='p', age=3)
# 字典推導式
dic3 = {x: x**2 for x in {2, 4, 6}}
print('dic1={}'.format(dic1)) # dic1={'age': 20, 'name': 'python'}
print('dic2={}'.format(dic2)) # dic2={'age': 3, 'name': 'p'}
print('dic3={}'.format(dic3)) # dic3={2: 4, 4: 16, 6: 36}
複製代碼

常見的三個內置方法，keys(), values(), items() 分別表示鍵、值、對，例子以下：

print('keys()方法，dic1.keys()={}'.format(dic1.keys()))
print('values()方法, dic1.values()={}'.format(dic1.values()))
print('items()方法, dic1.items()={}'.format(dic1.items()))
複製代碼

其餘對字典的操做，包括增刪查改，以下所示：

# 修改和訪問
dic1['age'] = 33
dic1.setdefault('sex', 'male')
print('dic1={}'.format(dic1))
# get() 訪問某個鍵
print('dic1.get(\'age\', 11)={}'.format(dic1.get('age', 11)))
print('訪問某個不存在的鍵，dic1.get(\'score\', 100)={}'.format(dic1.get('score', 100)))
# 刪除
del dic1['sex']
print('del dic1[\'sex\'], dic1={}'.format(dic1))
dic1.pop('age')
print('dic1.pop(\'age\'), dic1={}'.format(dic1))
# 清空
dic1.clear()
print('dic1.clear(), dic1={}'.format(dic1))
# 合併兩個字典
print('合併 dic2 和 dic3 前, dic2={}, dic3={}'.format(dic2, dic3))
dic2.update(dic3)
print('合併後，dic2={}'.format(dic2))

# 遍歷字典
dic4 = {'a': 1, 'b': 2}
for key, val in dic4.items():
    print('{}: {}'.format(key, val))
# 不須要採用 keys()
for key in dic4:
    print('{}: {}'.format(key, dic4[key]))
複製代碼

最後，由於字典的鍵必須是不可改變的數據類型，那麼如何快速判斷一個數據類型是否能夠更改呢？有如下兩種方法：

id()：判斷變量更改先後的 id，若是同樣表示能夠更改，不同表示不可更改。
hash()：若是不報錯，表示能夠被哈希，就表示不可更改；不然就是能夠更改。

首先看下 id() 方法，在一個整型變量上的使用結果：

i = 2
print('i id value=', id(i)) 
i += 3
print('i id value=', id(i)) 
複製代碼

輸出結果，更改先後 id 是更改了，代表整型變量是不可更改的。

i id value= 1758265872
i id value= 1758265968
複製代碼

而後在列表變量上進行一樣的操做：

l1 = [1, 3]
print('l1 id value=', id(l1)) 
l1.append(4)
print('l1 id value=', id(l1))
複製代碼

輸出結果，id 並無改變，說明列表是能夠更改的。

l1 id value= 1610679318408
l1 id value= 1610679318408
複製代碼

而後就是採用 hash() 的代碼例子：

# hash
s = 'abc'
print('s hash value: ', hash(s)) 
l2 = ['321', 1]
print('l2 hash value: ', hash(l2)) 
複製代碼

輸出結果以下，對於字符串成功輸出哈希值，而列表則報錯 TypeError: unhashable type: 'list'，這也說明了字符串不可更改，而列表能夠更改。

s hash value:  1106005493183980421
TypeError: unhashable type: 'list'
複製代碼

集合

集合是一個無序的不重複元素序列，採用大括號 {} 或者 set() 建立，但空集合必須使用 set() ，由於 {} 建立的是空字典。

建立的代碼示例以下：

# 建立集合
s1 = {'a', 'b', 'c'}
s2 = set()
s3 = set('abc')
print('s1={}'.format(s1)) # s1={'b', 'a', 'c'}
print('s2={}'.format(s2)) # s2=set()
print('s3={}'.format(s3)) # s3={'b', 'a', 'c'}
複製代碼

注意上述輸出的時候，每次運行順序均可能不一樣，這是集合的無序性的緣由。

利用集合能夠去除重複的元素，以下所示：

s4 = set('good')
print('s4={}'.format(s4)) # s4={'g', 'o', 'd'}
複製代碼

集合也能夠進行增長和刪除元素的操做，代碼以下所示：

# 增長元素，add() 和 update()
s1.add('dd')
print('s1.add(\'dd\'), s1={}'.format(s1)) # s1.add('dd'), s1={'dd', 'b', 'a', 'c'}
s1.update('o')
print('添加一個元素，s1={}'.format(s1)) # 添加一個元素，s1={'dd', 'o', 'b', 'a', 'c'}
s1.update(['n', 1])
print('添加多個元素, s1={}'.format(s1)) # 添加多個元素, s1={1, 'o', 'n', 'a', 'dd', 'b', 'c'}
s1.update([12, 33], {'ab', 'cd'})
print('添加列表和集合, s1={}'.format(s1)) # 添加列表和集合, s1={1, 33, 'o', 'n', 'a', 12, 'ab', 'dd', 'cd', 'b', 'c'}

# 刪除元素, pop(), remove(), clear()
print('s3={}'.format(s3)) # s3={'b', 'a', 'c'}
s3.pop()
print('隨機刪除元素, s3={}'.format(s3)) # 隨機刪除元素, s3={'a', 'c'}
s3.clear()
print('清空全部元素, s3={}'.format(s3)) # 清空全部元素, s3=set()
s1.remove('a')
print('刪除指定元素,s1={}'.format(s1)) # 刪除指定元素,s1={1, 33, 'o', 'n', 12, 'ab', 'dd', 'cd', 'b', 'c'}
複製代碼

此外，還有專門的集合操做，包括求取兩個集合的並集、交集

# 判斷是否子集, issubset()
a = set('abc')
b = set('bc')
c = set('cd')
print('b是否a的子集:', b.issubset(a)) # b是否a的子集: True
print('c是否a的子集:', c.issubset(a)) # c是否a的子集: False

# 並集操做，union() 或者 |
print('a 和 c 的並集:', a.union(c)) # a 和 c 的並集: {'c', 'b', 'a', 'd'}
print('a 和 c 的並集:', a | c) # a 和 c 的並集: {'c', 'b', 'a', 'd'}

# 交集操做，intersection() 或者 &
print('a 和 c 的交集:', a.intersection(c)) # a 和 c 的交集: {'c'}
print('a 和 c 的交集:', a & c) # a 和 c 的交集: {'c'}

# 差集操做，difference() 或者 - ，即只存在一個集合的元素
print('只在a中的元素:', a.difference(c)) # 只在a中的元素:: {'b', 'a'}
print('只在a中的元素:', a - c) # 只在a中的元素:: {'b', 'a'}

# 對稱差集, symmetric_difference() 或者 ^, 求取只存在其中一個集合的全部元素
print('對稱差集:', a.symmetric_difference(c)) # 對稱差集: {'a', 'd', 'b'}
print('對稱差集:', a ^ c) # 對稱差集: {'a', 'd', 'b'}
複製代碼