標籤:單引號 text 截取字串 rev ima tty 圖片 lock cal
python可變和不可變對象
python中所有的資料都是圍繞對象來構建,這些對象可分為兩類:可變對象和不可變對象。當變數被賦值,變數中存放的是對象引用(可以理解為C語言中的指標),指向記憶體中存放該對象的地區。
對於不可變對象而言,對象本身不可以改變(也可以理解為對象的值不可以改變),可以改變的是指向該對象的引用。
對於可變對象而言,對象本身的內容可以改變,指向該對象的引用不變~
不可變對象
不可變對象有:int,string,float,tuple...
不可變對象一旦建立,該對象本身就不能改變。若變數的值需要改變,只能重新建立對象,並改變變數的引用,如所示:
原來的對象不再被引用,會被當做記憶體回收~,可以使用 id() 函數做如下驗證:
>>> abc = 1>>> id(abc)1456500192>>> abc=2>>> id(abc)1456500224
可變對象
可變對象有:list,dict...
可變對象的內容可以改變,而變數的引用不會發生改變,如所示:
可以看到,對於可變對象,變數值的變化不需要重新建立對象,在python中可變對象往往是容器物件(即一個對象包含對其他對象的引用)
>>> abc=[‘a‘,‘b‘]>>> id(abc)2768889238408>>> abc+=[‘c‘]>>> id(abc)2768889238408>>> abc[‘a‘, ‘b‘, ‘c‘]
在python中可以通過 is 判斷 兩個變數是否引用自同一個對象,樣本如下:
>>> a = 1>>> b = 1>>> a is bTrue>>> c = 2>>> a is cFalse
由於python中存在小整數對象池,[-5,257)範圍內的整數對象,python解譯器不會重複建立~
python基礎資料型別 (Elementary Data Type)數字
python中的數字有很多種,包括:整型,長整型,布爾,浮點,複數。數字一經定義,不可更改(不可變對象)
-- 整型
python中的整型用八進位,十進位,十六進位表示:
# 環境為 python3>>> 1 # 預設為十進位1>>> oct(8) # 八進位,"0o" 為首碼,python2.7中的首碼為"0",10表示為‘010‘‘0o10‘>>> hex(10) # 十六進位,首碼為0X或0x‘0xa‘
資料類型轉換,可使用 int() 轉換為整型:
>>> a = ‘12‘>>> b = int(a) # 字串類型轉換為整型>>> b12>>> int(1.2) # 浮點數轉換為整型,小數部分會被略去1
--長整型
python2中的整型有長度的限制,32位系統上長度為32位,取值範圍為-2**31~2**31-1;64位系統上長度為64位,取值範圍為-2**63~2**63-1。
python3中的長整型沒有長度限制,可以無限大,但是這受到記憶體大小的限制(就是不可能無限大)
# 環境為 python2.7>>> a = 1 # 定義整型>>> a 1>>> b = 2L # 定義長整型>>> b2L>>> a = 9999999999999999999999999999999999>>> a9999999999999999999999999999999999L
通過在數字後面加上 大寫L 或者 小寫l 表示長整型;在定義整型時,若資料的位元超過了限制範圍,則會預設轉換為長整型
Tip:在python3中,整型和長整型歸為一類:整數類型 int
--布爾型bool
True 和 False,或者用1和0表示:1 表示True,0表示False~
在條件判斷時,若條件陳述式返回為非零數值、非Null 字元串、非空list等,均表示為True,否則表示為False。
if []: print(‘OK‘)else: print(‘NO‘)結果輸出:NOwhile 1: # 等效於while true,無限迴圈 print(‘hello world‘)
--浮點數float
python中的浮點數也就是小數,可用普通的方式表示,例如:
1.23,3.56 ...
也可以使用科學計數法表示:
1.23*10^9就是1.23e9,或者12.3e8 # 小數位元太多時,用科學計數法表示~0.000012可以寫成1.2e-5
?
整數和浮點數在電腦內部儲存的方式是不同的,整數運算是精確的,而浮點數運算則可能會有
四捨五入的誤差。
--複數complex
複數由實數部分和虛數部分組成,一般形式為x+yj,其中的x是複數的實數部分,y是複數的虛數部分,這裡的x和y都是實數。虛數部分的字母j大小寫都可以~
>> a = 1.3 + 2.5j>> a(1.3+2.5j)>> type(a)<class ‘complex‘>
數值的運算這裡不做介紹
字串
字串是一個有序的字元集合,且字串為不可變對象,一經建立,不可更改~
--建立字串
python字串的建立可以使用單引號,也可以使用雙引號
str1 = ‘Hello‘str2 = "World"
單引號或雙引號前面加 r ,可以使字串中的特殊字元失效,按原樣輸出:
>>> print(‘abc\tde‘)abc de>>> print(r‘abc\tde‘)abc\tde
當 r 與 unicode字串一起使用時,u 需要放在 r 的前面
str1 = ur‘abc\tde
--常用字串運算
var1 = ‘Hello‘; var2 = ‘Kitty‘# 字串拼接var1 + var2 # 輸出:‘HelloKitty‘# 重複輸出var1 * 3 # 輸出:‘HelloHelloHello‘# 成員運算,判斷字元是否存在於指定字串中‘t‘ in var2 # 輸出:True,存在返回True‘a‘ not in var2 # 輸出:True,不存在返回True# 原始字串輸出,字串中的轉移字元失效,在引號前使用 R 或 r 均可~print(r‘\t\n‘) # 輸出:\t\nprint(R‘\t\n‘) # 輸出:\t\n
--三引號(triple quotes)使用
python中的三引號,用於跨行輸出,例如要輸出如下語句:
line1---line2---line3---
方式一:
>>> str1 = "line1---\nline2---\nline3---">>> str1‘line1---\nline2---\nline3---‘>>> print(str1)line1---line2---line3---
方式二(3對單引號還是3對雙引號,結果一樣)Pycharm環境:
str2 = ‘‘‘line1---line2---line3---‘‘‘print(str2)輸出結果:line1---line2---line3---
3對雙引號""" """ 或者 3對單引號 ‘‘‘ ‘‘‘ 還可以表示多行注釋(其中 # 為當行注釋):
class Abc(): """ 多行注釋 多行注釋 多行注釋 """ def __init__(self): pass def say_hello(self): # 單行注釋 # 單行注釋 return ‘hello‘
--字串常用操作
----字串索引
>>> my_str = ‘hello‘>>> my_str[4]‘o‘>>> my_str[-3] # 最後第3個字元‘l‘
----截取字串
>>> my_str = ‘hello‘>>> my_str[1:4] # 截取其中的 第2個到第5個 字元‘ell‘>>> my_str[:4]‘hell‘ # 截取其中的 第1個到第4個 字元,不包括 my_str[4]>>> my_str[3:]‘lo‘ # 截取其中的 第4個到最後1個字元>>> my_str[:-3]‘he‘ # 截取第1個到最後第3個字元(不包括最後第3個)>>> my_str[-3:-1]‘ll‘ # 截取倒數第3個到倒數第1個字元(不包括倒數第一個)>>> my_str[-3:]‘llo‘ # 截取倒數第3個到最後一個字元>>> my_str[::-1]‘olleh‘ # 產生一個與原字串順序相反的字串
----切割、合并字串
按字串中的字元,切割字串
>>> my_str = ‘a,b,c,d,e‘>>> my_str.split(‘,‘)[‘a‘, ‘b‘, ‘c‘, ‘d‘, ‘e‘] # 返回列表
合并列表或元組中的元素成字串
>>> ‘:‘.join([‘a‘, ‘b‘, ‘c‘, ‘d‘, ‘e‘]) # 列表‘a:b:c:d:e‘>>> ‘#‘.join((‘a‘, ‘b‘, ‘c‘, ‘d‘, ‘e‘)) 元組‘a#b#c#d#e‘
----其他動作
>>> my_str = ‘ abc ‘>>> len(my_str) # 擷取字串長度5# 移除字串兩邊空白>>> my_str.strip()‘abc‘# 移除字串左邊空白>>> my_str.lstrip()‘abc ‘# 移除字串右邊空白>>> my_str.rstrip()‘ abc‘# 尋找字元>>> my_str.index(‘b‘) # 若字串中沒有該字元,會返回報錯資訊2# 尋找字串S.find(substr, [start, [end]]) # [start, [end]] 指定起始位置和結束位置>>> my_str.find(‘bc‘)2 # 返回尋找到的字串的第一個字元的索引,若沒有找到,返回-1# 搜尋和替換S.replace(oldstr, newstr, [count]) # count 指定替換次數>>> my_str.replace(‘b‘,‘B‘,2)‘aBc aBc abc‘>>> my_str = ‘abCD efg‘>>> my_str.lower() # 都轉為小寫‘abcd efg‘>>> my_str.upper() # 都轉為大寫‘ABCD EFG‘>>> my_str.swapcase() # 大小寫互換‘ABcd EFG‘>>> my_str.capitalize() # 首字母大寫‘Abcd efg‘
使用 str() 將其他類型的資料轉換成字串
>>> str(123456)‘123456‘>>> str([‘a‘,‘b‘,‘c‘])"[‘a‘, ‘b‘, ‘c‘]"
列表
列表兩邊使用 [] 包含,[] 中可以存放多種類型的資料,每個資料之間使用逗號(,)分隔。列表資料可變對象~
--建立列表
方式一:my_lst1 = [‘a‘, 1, 2]方式二:my_lst2 = list(‘abc‘)方式三:my_lst3 = list([‘a‘, 1, 2])
建立空列表:
my_lst = []my_lst = list()
--列表常用操作
# 索引>>> my_lst = [‘a‘,‘b‘,‘c‘,‘d‘]>>> my_lst[2]‘c‘# 搜尋列表元素>>> my_lst.index(‘c‘)2 # 返回index,若沒有對應元素,返回報錯資訊# 列表長度>>> len(my_lst)4# 列表的切片,使用方式與字串類似,不做意義注釋>>> my_lst = [‘a‘,‘b‘,‘c‘,‘d‘]>>> my_lst[1:3][‘b‘, ‘c‘]>>> my_lst[:3][‘a‘, ‘b‘, ‘c‘]>>> my_lst[2:][‘c‘, ‘d‘]>>> my_lst[:-2][‘a‘, ‘b‘]>>> my_lst[-3:-1][‘b‘, ‘c‘]>>> my_lst[-3:][‘b‘, ‘c‘, ‘d‘]>>> my_lst[::-1][‘d‘, ‘c‘, ‘b‘, ‘a‘]# 追加元素(append追加)>>> my_lst = [1,2,3]>>> my_lst.append(4) # [1, 2, 3, 4]# 追加元素(extend追加)>>> my_lst = [1,2,3]>>> my_lst.extend([4,5]) # [1, 2, 3, 4, 5]# append與 extend 的區別在於,append 直接追加對象,extend 會迭代對象中的每個元素,然後進行追加>>> my_lst = [1,2,3]>>> my_lst.append([4, 5]) # [1, 2, 3, [4, 5]]>>> my_lst = [1,2,3]>>> my_lst.extend([4, 5]) # [1, 2, 3, 4, 5]# 指定索引位置插入元素>>> my_lst = [1,2,3]>>> my_lst.insert(-1, ‘a‘) # 最後一個元素前面插入>>> my_lst[1, 2, ‘a‘, 3]>>> my_lst.insert(0, 0) # 第一個元素前面插入>>> my_lst[0, 1, 2, ‘a‘, 3]# 刪除元素>>> a = my_lst.pop() # 不加參數預設刪除最後一個元素,並將刪除元素返回>>> my_lst[0, 1, 2, ‘a‘]>>> a3# pop() 指定參數,通過所應刪除>>> my_lst.pop(1)1>>> my_lst[0, 2, ‘a‘]# 刪除列表中的指定值 li.remove(‘aa‘)>>> my_lst.remove(‘a‘) # 若列表中沒有該元素,返回報錯資訊>>> my_lst[0, 2]# 通過 索引和切片 刪除元素>>> my_lst = [‘a‘, ‘b‘, ‘c‘, ‘d‘]>>> del my_lst[0:2]>>> my_lst[‘c‘, ‘d‘]# 清空列表>>> my_lst.clear()>>> my_lst[]# 列表元素出現的次數>>> my_lst = [‘a‘, ‘b‘, ‘c‘, ‘d‘, ‘a‘]>>> my_lst.count(‘a‘)2>>> my_lst.count(‘g‘)0# 翻轉列表>>> my_lst = [‘a‘, ‘b‘, ‘c‘, ‘d‘]>>> my_lst.reverse()>>> my_lst[‘d‘, ‘c‘, ‘b‘, ‘a‘]
----列表中的 in 操作(返回布爾值)
判斷元素是否存在於列表中~
>>> my_lst = [‘a‘, ‘b‘, ‘c‘, ‘d‘]>>> print(‘a‘ in my_lst)True>>> print(‘z‘ in my_lst)False
--迴圈列表
這裡僅介紹 for 迴圈
my_lst = [‘a‘, ‘b‘, ‘c‘, ‘d‘, ‘e‘]for i in my_lst: print(i)for i in range(len(my_lst)): print(my_lst[i])
以上兩種方式的輸出結果一致~
可以使用 enumerate 函數連同 index 一起輸出,首先瞭解下 enumerate:
my_lst = [‘a‘, ‘b‘, ‘c‘, ‘d‘, ‘e‘]for i in enumerate(my_lst): print(i)輸出:(0, ‘a‘)(1, ‘b‘)(2, ‘c‘)(3, ‘d‘)(4, ‘e‘)# 所以可以這樣使用:my_lst = [‘a‘, ‘b‘, ‘c‘, ‘d‘, ‘e‘]for index, value in enumerate(my_lst): print(‘%s --> %s‘ % (index, value))輸出:0 --> a1 --> b2 --> c3 --> d4 --> e
Tip:enumerate的第二個參數,可改變起始序號,可以自己嘗試~
元組和字串可通過 list() 轉換成列表,這也是初始化列表的方法之一
lst_1 = list((1,2,3)) # [1, 2, 3]lst_2 = list(‘abc‘) # [‘a‘, ‘b‘, ‘c‘]
來自字典的轉換
>>> my_dict = {‘a‘: 1, ‘b‘: 2, ‘c‘: 3}>>> list(my_dict) # 將字典中的 keys 轉為 list[‘a‘, ‘b‘, ‘c‘]或者>>> list(my_dict.keys())[‘a‘, ‘b‘, ‘c‘]>>> list(my_dict.values()) # 將字典中的 values 轉為list[1, 2, 3]
元組
元組與列表類似,使用 () 包含其元素;元組與列表的最大區別在於,元組為不可變對象,一經建立,其內容無法更改。
--建立元組
tup_1 = (‘a‘, ‘b‘, 1, 2)tup_2 = (1, 2, 3, 4)tup_3 = ‘a‘, ‘b‘, ‘c‘, ‘d‘
建立空元組
tup_4 = ()
建立僅包含一個元素的元組:
>>> tup_4 = (2) # 這樣建立 tup_4 會被當做 int 類型,而不是 tuple;>>> type(tup_4)<class ‘int‘># 正確建立方式>>> tup_4 = (2,)>>> type(tup_4)<class ‘tuple‘>
--元組常用操作
元組的索引操作(tup[index]),搜尋元素(tup.index()),擷取長度(len(tup)),切片(tup(1:3)),元素出現的次數(tup.count())等 這些操作與 list 一致~
因為 tuple 為不可變對象,所以不支援 append,insert,extend,pop,remove,del,clear 等操作
>>> tup_1 = (1,2,3)>>> tup_1[1] = 4Traceback (most recent call last): File "<stdin>", line 1, in <module>TypeError: ‘tuple‘ object does not support item assignment
tuple 不支援 sort 和 reverse 操作,支援 sorted 操作,傳回型別為列表
>>> tup_1 = (2,3,90,6,234,1,53,2)>>> sorted(tup_1)[1, 2, 2, 3, 6, 53, 90, 234]
tuple同樣也支援 in 操作:
>>> my_tup = (‘a‘,‘b‘,‘c‘,‘d‘)>>> print(‘a‘ in my_tup)True>>> print(‘z‘ in my_tup)False
上述對 list 的迴圈操作,同樣也適用於tuple~
tuple() 可應用於 list,字串,將其轉換成 tuple 類型的資料
tup_1 = tuple("abcdefg") # (‘a‘, ‘b‘, ‘c‘, ‘d‘, ‘e‘, ‘f‘, ‘g‘)tup_2 = tuple([1,2,3,4,5]) # (1, 2, 3, 4, 5)
來自字典的轉換,與list類似
list(my_dict.keys()) 或者 list(my_dict) # 將字典中的 keys 轉成tuplelist(my_dict.values()) # 將字典中的 values 轉成tuple
字典
字典也屬於可變對象,使用一對花括弧 {} 包含元素,字典中的每個元素為一個 key->value對,key和value之間使用冒號 : 分割,每個元素之間使用逗號隔開~
Tip:dict中的key必須是不可變對象,或者說是可hash類型(例如元組可以作為key),value可以是可變對象,也可以是不可變對象~
--建立字典
d1 = {‘a‘: 1, ‘b‘: 2, ‘c‘: 3}d2 = dict({‘a‘: 1, ‘b‘: 2, ‘c‘: 3})d3 = dict(a=1, b=2, c=3) # 這種方式定義字典,key 只能是字串類型d4 = dict([(‘a‘, 1), (‘b‘, 2), (‘c‘, 3)])# 初始化字典d6 = {}.fromkeys([‘a‘, ‘b‘], None) # {‘a‘: None, ‘b‘: None}d7 = {}.fromkeys([‘a‘,‘b‘], [1, 2]) # {‘a‘: [1, 2], ‘b‘: [1, 2]}
建立空字典:
d1={}; d2=dict();
字典的迴圈(d.keys,d.values, for i in d取出的是key)
dict.get(key)
dict.setdefault()
--字典常用操作
# 擷取字典元素>>> my_dict = {‘a‘: 1, ‘b‘: 2, ‘c‘: 3}>>> my_dict[‘b‘]2# 使用 get 方法擷取,若沒有指定的 key 返回為 None>>> my_dict.get(‘b‘)2# 當只有一個參數時,setdefault的範圍get類似,尋找指定的key,若沒有返回None。當指定的key沒有時,不光會返回 None ,還會在字典中添加該 key ,且值為None>>> my_dict.setdefault(‘c‘)3>>> my_dict.setdefault(‘d‘)>>> my_dict{‘a‘: 1, ‘b‘: 2, ‘c‘: 3, ‘d‘: None}# 添加的 key,也可以指定 value>>> my_dict.setdefault(‘e‘, 5)5>>> my_dict{‘a‘: 1, ‘b‘: 2, ‘c‘: 3, ‘d‘: None, ‘e‘: 5}# 添加操作>>> my_dict = {‘a‘: 1, ‘b‘: 2, ‘c‘: 3}>>> my_dict[‘d‘] = 4>>> my_dict{‘a‘: 1, ‘b‘: 2, ‘c‘: 3, ‘d‘: 4}# 修改操作>>> my_dict[‘d‘] = 40>>> my_dict{‘a‘: 1, ‘b‘: 2, ‘c‘: 3, ‘d‘: 40}# 刪除操作>>> my_dict.pop(‘a‘)1>>> my_dict{‘b‘: 2, ‘c‘: 3, ‘d‘: 40}# 清空字典>>> my_dict.clear()>>> my_dict{}# update操作,將 一個字典中(d_1)的元素更新到 另一個字典(d_2)中,若d_1中的key,d_2中也有,則d_1中的key更新d_2中的key,若d_1中的key,d_2中沒有,則在d_2中進行添加,樣本如下:>>> d_1 = {‘a‘: 1, ‘b‘: 2, ‘c‘: 3}>>> d_2 = {‘a‘: 12, ‘x‘: 10, ‘y‘: 20, ‘z‘: 30}>>> d_1.update(d_2)>>> d_1{‘a‘: 12, ‘b‘: 2, ‘c‘: 3, ‘x‘: 10, ‘y‘: 20, ‘z‘: 30}
--對字典的迴圈操作
字典的 items() 函數以列表形式 返回可遍曆的(鍵, 值) 元組。
my_dict = {‘a‘: 1, ‘b‘: 2, ‘c‘: 3}for i in my_dict.items(): print(i)結果輸出:(‘a‘, 1)(‘b‘, 2)(‘c‘, 3)
keys(),values()
my_dict = {‘a‘: 1, ‘b‘: 2, ‘c‘: 3}for i in my_dict.keys(): # keys() 擷取字典的所有 key, 並以列表形式返回 print(i)結果輸出:abcmy_dict = {‘a‘: 1, ‘b‘: 2, ‘c‘: 3}for i in my_dict.values(): # values() 擷取字典的所有 value, 並以列表形式返回 print(i)結果輸出:123
在python2中,也有items(),keys(),values()函數,返回的是一個字典的拷貝列表(items,keys或values),對應的還有iteritems(),iterkeys(),itervalues(),返回字典所有items(key,value)的一個迭代器,前者會佔用額外記憶體,後者不會
在python3中,廢棄了iteritems(),iterkeys(),itervalues()函數,使用items(),keys(),values()替代,其返回結果與python2中的iteritems(),iterkeys(),itervalues()一致
遍曆字典也可以不使用上述的函數:
my_dict = {‘a‘: 1, ‘b‘: 2, ‘c‘: 3}for key in my_dict: # 遍曆字典中的所有key print(my_dict[key])
--dict() 轉換的使用
列錶轉字典
方式一:
>>> ls_key = [‘a‘, ‘b‘, ‘c‘]>>> ls_value = [1, 2, 3]>>> dict(zip(ls_key, ls_value)){‘a‘: 1, ‘b‘: 2, ‘c‘: 3}
方式二:
>>> ls_key_value = [[‘a‘, 1], [‘b‘, 2], [‘c‘, 3]]>>> dict(ls_key_value){‘a‘: 1, ‘b‘: 2, ‘c‘: 3}
字串轉為字典
方式一:
import jsonuser_str = ‘{"name" : "Kitty", "gender" : "female", "age": 18}‘# user_str = "{‘name‘ : ‘Kitty‘, ‘gender‘ : ‘female‘, ‘age‘: 18}" # 必須寫成上面這種形式(雙引號),不能使用單引號,這也是使用 json 方式的缺陷user_dict = json.loads(user_str) # {"name" : "Kitty", "gender" : "female", "age": 18}
方式二:
user_str = ‘{"name" : "Kitty", "gender" : "female", "age": 18}‘user_dict = eval(user_str) # {‘name‘: ‘Kitty‘, ‘gender‘: ‘female‘, ‘age‘: 18}
Tip:使用eval不存在向json這樣的問題,但是eval存在安全性問題,所以不建議使用~
方式三:
import astuser_str = ‘{"name" : "Kitty", "gender" : "female", "age": 18}‘user_dict = ast.literal_eval(user_str) # {‘name‘: ‘Kitty‘, ‘gender‘: ‘female‘, ‘age‘: 18}
Tip:ast.literal_eval 不存在 json 的問題,也沒有安全性問題,推薦使用~
集合
集合(set)是一個無序不重複元素的序列。集合中只能存放不可變對象(可hash的)~
--建立集合
使用 {} 或者 set() 建立集合
my_set = {‘python‘, ‘ruby‘, ‘java‘, ‘python‘, ‘go‘} # 推薦使用# 或者my_set = set([‘python‘, ‘ruby‘, ‘java‘, ‘python‘, ‘go‘])my_set = set({‘python‘, ‘ruby‘, ‘java‘, ‘python‘, ‘go‘})my_set = set((‘python‘, ‘ruby‘, ‘java‘, ‘python‘, ‘go‘))# 建立的集合為:{‘python‘, ‘java‘, ‘go‘, ‘ruby‘}# 集合中不可存放可變對象>>> my_set = {[1,2,3], ‘abc‘}Traceback (most recent call last): File "<stdin>", line 1, in <module>TypeError: unhashable type: ‘list‘
Tip:由於集合中的元素不可重複,重複的元素僅保留一個
建立空集合
my_set = set() # 不能使用 {},{} 會建立一個空的字典
--集合常用操作
# 添加元素,add() 操作,若元素已經存在,則不進行任何操作>>> my_set = {‘python‘, ‘ruby‘, ‘java‘, ‘python‘, ‘go‘}>>> my_set.add(‘c‘)>>> my_set{‘go‘, ‘ruby‘, ‘c‘, ‘python‘, ‘java‘}# 更新集合,update操作,已存在的元素,不進行操作,不存在的元素進行添加>>> my_set = {‘python‘, ‘ruby‘, ‘java‘, ‘python‘, ‘go‘}>>> my_set.update({‘go‘,‘php‘,‘c‘})>>> my_set{‘go‘, ‘ruby‘, ‘c‘, ‘python‘, ‘php‘, ‘java‘}# 刪除元素# remove,從集合中移除元素,若不存在,報錯~>>> my_set = {‘python‘, ‘ruby‘, ‘java‘, ‘python‘, ‘go‘}>>> my_set.remove(‘python‘)>>> my_set{‘go‘, ‘ruby‘, ‘java‘}>>> my_set.remove(‘php‘)Traceback (most recent call last): File "<stdin>", line 1, in <module>KeyError: ‘php‘# discard,從集合中移除元素,元素不存在不會報錯>>> my_set = {‘python‘, ‘ruby‘, ‘java‘, ‘python‘, ‘go‘}>>> my_set.discard(‘ruby‘)>>> my_set.discard(‘php‘)>>> my_set{‘go‘, ‘python‘, ‘java‘}# pop,隨機從集合中刪除一個元素,並返回被刪除的元素>>> my_set = {‘python‘, ‘ruby‘, ‘java‘, ‘python‘, ‘go‘}>>> my_set.pop()‘go‘>>> my_set{‘python‘, ‘ruby‘, ‘java‘}# 計算集合中元素個數>>> len(my_set)3# 清空集合>>> my_set.clear()>>> my_setset()# 判斷集合是否包含某個元素,存在返回True,否則返回False~;對應的還有not in>>> my_set = {‘python‘, ‘ruby‘, ‘java‘, ‘python‘, ‘go‘}>>> ‘java‘ in my_setTrue>>> ‘erlang‘ in my_setFalse
--集合運算
>>> my_set_1 = {‘Apple‘, ‘Facebook‘, ‘Amazon‘}>>> my_set_2 = {‘Apple‘, ‘Google‘, ‘Alibaba‘}
----並集 union
>>> my_set_1 | my_set_2{‘Apple‘, ‘Amazon‘, ‘Google‘, ‘Alibaba‘, ‘Facebook‘}# 對應方法>>> my_set_1.union(my_set_2){‘Apple‘, ‘Amazon‘, ‘Google‘, ‘Alibaba‘, ‘Facebook‘}
----交集 intersection
>>> my_set_1 & my_set_2{‘Apple‘}# 對應方法>>> my_set_1.intersection(my_set_2){‘Apple‘}
----差集 difference
>>> my_set_1 - my_set_2{‘Amazon‘, ‘Facebook‘}# 對應方法>>> my_set_1.difference(my_set_2){‘Amazon‘, ‘Facebook‘}
----對稱差集 sysmmetric difference
>>> my_set_1 ^ my_set_2{‘Alibaba‘, ‘Amazon‘, ‘Google‘, ‘Facebook‘}# 對應方法>>> my_set_1.symmetric_difference(my_set_2){‘Alibaba‘, ‘Amazon‘, ‘Google‘, ‘Facebook‘}
可使用 set() 將list,tuple,dict,字串 轉換成集合
my_set = set([‘python‘, ‘ruby‘, ‘java‘, ‘python‘, ‘go‘])my_set = set((‘python‘, ‘ruby‘, ‘java‘, ‘python‘, ‘go‘))my_set = set({‘a‘:1, ‘b‘:2, ‘c‘:3}) # 僅擷取 keys,轉換後的集合 {‘a‘, ‘c‘, ‘b‘}my_set = set(‘abcdefg‘) # {‘e‘, ‘c‘, ‘f‘, ‘d‘, ‘b‘, ‘a‘, ‘g‘}
.................^_^
python基礎資料型別 (Elementary Data Type)