運算符、數字、字符串、列表、字典、集合、小數據池

一  運算符

1. 算數運算符

以下假設變量： a=10，b=20：

2. 比較運算符

以下假設變量a為10，變量b為20：

3. 賦值運算符

4. 邏輯運算符

以下假設變量 a 為 10, b為 20

 

and 改寫為：如果x為False，x and y返回 x值 ，否則返回y值

記憶規律：在 x and/or y 中，整體的返回值一般不是True和False，而是x或者y值， 第一步都是看x。

print(1 and 0)
print(0 and 1)
print('' and 2)
print(2 or 0)
print(0 or 2)
結果為：
0；0； ； 2；2

運算順序為： 順序: () ==> not ==> and ==> or

print(not 2 >1 and 3<4 or 4>5 and 2>1 and 9<8 or 7<6)
False

5. 成員運算符

6. 身份運算符

身份運算符用於比較兩個對象的存儲單元

7. 運算符優先級

 以下表格列出了從最高到最低優先級的所有運算符：

參考

運算符詳解：

https://www.runoob.com/python3/python3-basic-operators.html

二  數據類型之間轉換

int(x [,base ])         將x轉換為一個整數  
long(x [,base ])        將x轉換為一個長整數  
float(x )               將x轉換到一個浮點數  
complex(real [,imag ])  創建一個復數  
str(x )                 將對象 x 轉換為字符串  
repr(x )                將對象 x 轉換為表達式字符串  
eval(str )              用來計算在字符串中的有效Python表達式,並返回一個對象  
tuple(s )               將序列 s 轉換為一個元組  
list(s )                將序列 s 轉換為一個列表  
chr(x )                 將一個整數轉換為一個字符  
unichr(x )              將一個整數轉換為Unicode字符  
ord(x )                 將一個字符轉換為它的整數值  
hex(x )                 將一個整數轉換為一個十六進制字符串  
oct(x )                 將一個整數轉換為一個八進制字符串 

三  數字（Number）

在Python3中，支持的數字類型有：

• int--整型
• float--浮點型
• fractions--分數
• complex--復數

1. 數值內部方法

####內部方法為該數據類型內部的方法，內置函數為系統的內置方法####

 var.bit_length()    求二進制長度

a= 3
print(a.bit_length())   #必須通過變量調用

2

2. 數值內置函數

1，abs(x) 求x的絕對值

2，divmod(x,y) 相當於%，divmod(10,3)結果是（3,1）也就是商3余1

3，pow(x,y[,z]) 函數表示x的y次方，如果由參數z則表示x的y次方，然后用x進行模運算之后的余數，即冪余函數，這是為了防止x,的y次冪太大導致計算機無法工作，而經常需要的

只是后幾位而已

4，round(x[,d])  表示對x進行四舍五入，精度默認為0，d代表去小數點后第d位，四舍五入

5，max( )  返回給定參數的最大值，參數可以為序列

6，min( )  返回給定參數的最小值，參數可以為序列

7，int(x)  取整函數，把參數，不論是小數，還是字符串都可以，轉換成整數

8，float(x) 可以把參數轉換成浮點數，如果是整數的話，則設置小數點后一位為0，如果是字符串則直接轉換為浮點數

參考

math及cmath模塊更多數值運算函數：

https://www.runoob.com/python/python-numbers.html

四  布爾（Bool）

布爾只有兩個值：True和False

只有一個方法 bool()

與False對應的值都有：None、 [ ]、( )、" "、{ }、0

五  字符串（String）

sequence（序列）是內置數據類型（Built-in type），可迭代對象，包含list、str、tuple、range、bytes。而dict則是一種map（映射）

population：Population must be a sequence or set. For dicts, use list(d)

python中字符串是不可變對象，所以所有修改和生成字符串的操作的實現方法都是另一個內存片段中新生成一個字符串對象。例如，'abc'.upper()將會在划分另一個內存片段，並將返回的ABC保存在此內存中。

1. 大小寫轉換

1、  S.upper()   把所有字符中的小寫字母轉換成大寫字母

2、  S.lower()  把所有字符中的大寫字母轉換成小寫字母

3、  S.capitalize()  首字母大寫

4、  S.title()   所有單詞首字母大寫

5、  S.swapcase()   所有字符串做大小寫轉換(大寫-->小寫，小寫-->大寫)

2. is判斷

6、 S.isdecimal()   如果字符串是否只包含十進制字符返回True，否則返回False。

7、 S.isalpha()    判斷是否都是字母

8、 S.isdigit()    判斷是否都是整數

1 >>> '8.35'.isdigit()
2 False

9、 S.isnumeric()   判斷是否都是數字

isdigit   isdecimal    isnumeric的區別

https://zhidao.baidu.com/question/496610701775817084.html

10、S.isalnum()   檢測字符串是否由字母和數字組成。

1 >>> 'a8Yn9'.isalnum()
2 True

11、 S.islower()  判斷是否都是小寫

12、S.isupper()  判斷是否都是大寫

13、S.istitle()  是否符合符合標題

14、S.isspace()   是否是空白(空格、制表符、換行符等)字符

15、S.isprintable  是否是可打印字符(例如制表符、換行符就不是可打印字符，但空格是)

16、S.isdentifer() 是否滿足標識符定義規則

標識符定義規則為：只能是字母或下划線開頭、不能包含除數字、字母和下划線以外的任意字符

3. 填充

17、S.center(width[, fillchar])

1 >>> name = 'matt'
2 >>> name.center(50,'-')
3 '-----------------------matt-----------------------'

18、S.ljust(width[, fillchar])   使用fillchar填充在字符串S的右邊，使得整體長度為width

19、S.rjust(width[, fillchar])   填充在左邊。如果不指定fillchar，則默認使用空格填充

20、S.zfill(width)     用0填充在字符串S的左邊使其長度為width

4. 檢索

21、S.count(sub[, start[, end]])   返回字符串S中子串sub出現的次數，可以指定從哪里開始計算(start)以及計算到哪里結束(end)

22、S.endswith(suffix[, start[, end]])    endswith()檢查字符串S是否以suffix結尾，返回布爾值的True和False。suffix可以是一個元組(tuple)，只要tuple中任意一個元素滿足endswith的條件，就返回True。

23、S.startswith   判斷字符串S是否是以prefix開頭

24、S.find(sub[, start[, end]])  搜索字符串S中是否包含子串sub，如果包含，則返回sub的索引位置，否則返回"-1"。

25、S.rfind(sub[, start[, end]])    返回搜索到的最右邊子串的位置

26、S.index(sub[, start[, end]])    和find()一樣，唯一不同點在於當找不到子串時，拋出ValueError錯誤

27、S.rindex(sub[, start[, end]])  返回搜索到的最右邊子串的位置

5. 替換

28、S.replace(old, new[, count])   將字符串中的子串old替換為new字符串，如果給定count，則表示只替換前count個old子串。如果S中搜索不到子串old，則無法替換，直接返回字符串S(不創建新字符串對象)。

1 >>> 'abcandabc'.replace('abc','matt')
2 'mattandmatt'

29、S.expandtabs(N)  將字符串S中的\t替換為一定數量的空格。默認N=8。

30、S.translate(table) 和  str.maketrans(x[, y[, z]])       str.maketrans()生成一個字符一 一映射的table，然后使用translate(table)對字符串S中的每個字符進行映射。

1 >>> str_in = 'abcxyz'
2 >>> str_out = '123456'
3 >>> transtab = str.maketrans(str_in,str_out)
4 >>> 'i am matt'.translate(transtab)
5 'i 1m m1tt'

maketrans 和translate是聯合起來用的，加密的作用

6. 分割

31、S.partition(sep)  搜索字符串S中的子串sep，並從sep處對S進行分割，最后返回一個包含3元素的元組：sep左邊的部分，sep自身素，sep右邊。如果搜索不到sep，則返回的3元素元組中，有兩個元素為空。

32、S.rpartition(sep)  rpartition(sep)從右邊第一個sep進行分割。

33、S.split(sep=None, maxsplit=-1)    都是用來分割字符串，並生成一個列表。

1 >>> 'a,b,c,d'.split(',',2)
2 ['a', 'b', 'c,d']

34、S.rsplit(sep=None, maxsplit=-1)   從右邊向左邊搜索

35、S.splitlines([keepends=True])  可以指定各種換行符，常見的是\n、\r、\r\n

7. 拼接

36、S.join(iterable)   將可迭代對象(iterable)中的字符串使用S連接起來。注意，iterable中必須全部是字符串類型，否則報錯

1 >>> '|'.join(['a','b','c'])
2 'a|b|c'

8. 修剪

37、S.strip([chars])   移除左右兩邊的字符char。如果不指定chars或者指定為None，則默認移除空白(空格、制表符、換行符)

>>> '  a a   '.strip()
'a a'
>>> '--a-a--'.strip('-')
'a-a'

38、S.lstrip([chars])  

39、S.rstrip([chars])  

9.字符串拼接：

 加號（+）又稱為 "萬惡的加號",因為使用加號連接2個字符串會調用靜態函數string_concat(register PyStringObject *a ,register PyObject * b),在這個函數中會開辟一塊大小是a+b的內存的和的存儲單元，然后將a,b字符串拷貝進去。如果是n個字符串相連 那么會開辟n-1次內存，是非常耗費資源的。

9.1 占位符：S%s(string),S %d(digital),S %f(float)

name = 'matt'
age = 23
salary = 10000
print('''           #多行打印
---------format info------
name:%s
age:%d
salary:%d
'''%(name, age, salary))

注意：

print("我叫%s, 今年22歲了, 學習python2%%了" % '王尼瑪')

我叫王尼瑪, 今年22歲了, 學習python2%了

9.2 格式化輸出 ：S（{}）.format（var）

>>> 'my name is {}, and i am {}'.format('zt',22)  #位置參數
'my name is zt, and i am 22'
>>> 'my name is {1}, and i am {0}'.format('zt',22)  #位置參數
'my name is 22, and i am zt'
>>> 'my name is{name}, and i am {age}'.format(name = 'zt',age =22)  #關鍵詞參數
'my name iszt, and i am 22'

9.3 format_map    #以字典的形式賦值

>>> 'my name is {name}, and i am {age}'.format_map({'name': 'zt','age':22})
'my name is zt, and i am 22'

10. 字符串切片

str = '0123456789′
print str[0:3] #截取第一位到第三位的字符
print str[:] #截取字符串的全部字符
print str[6:] #截取第七個字符到結尾
print str[:-3] #截取從頭開始到倒數第三個字符之前
print str[2] #截取第三個字符
print str[-1] #截取倒數第一個字符
print str[::-1] #創造一個與原字符串順序相反的字符串
print str[-3:-1] #截取倒數第三位與倒數第一位之前的字符
print str[-3:] #截取倒數第三位到結尾
print str[:-5:-3] #逆序截取，截取倒數第五位數與倒數第三位數之間

這里需要強調的是，字符串對象是不可改變的，上面的函數改變了字符串后，都會返回一個新的字符串，原字串並沒有變。

11. 遍歷字符串

for 循環、     while 循環(借助len(str))  

var = 'matt'
for i in var :
    print(i)

m
a
t
t

 

參考：

isdigit   isdecimal    isnumeric的區別：

https://zhidao.baidu.com/question/496610701775817084.html

字符串操作實例：

https://www.jb51.net/article/141376.htm 

六  列表（List）

1. 增

1、L.append(obj)   末尾添加

>>> name = ['matt', 'jordan', 'logan', 'summer']
>>> name.append('tony')
>>> name
['matt', 'jordan', 'logan', 'summer', 'tony']

2、L.insert(index, obj)   定位插入

>>> name.insert(1 ,'jump')
>>> name
['matt', 'jump', 'jordan', 'logan', 'summer', 'linda', 'amy']

3、L.extend(seq)  在列表末尾一次性追加另一個序列中的多個值 與set.update()類似，

>>> name = ['matt', 'jordan', 'logan']
>>> names = ['summer', 'linda', 'amy']
>>> name.extend(names)
>>> name
['matt', 'jordan', 'logan', 'summer', 'linda', 'amy']

2. 刪

4、del  List[index]  刪除單一元素  通過索引刪除          del List   刪除整個列表     del list[1:4]切片刪除

>>> name = ['matt', 'jordan', 'logan', 'summer', 'linda', 'amy']
>>> del name[2]
>>> name
['matt', 'jordan', 'summer', 'linda', 'amy']

5、L.remove(obj)   對象

>>> name = ['matt', 'jordan', 'logan', 'summer', 'linda', 'amy']
>>> name.remove('matt')
>>> name
['jordan', 'logan', 'summer', 'linda', 'amy']

6、L.pop([index=-1])    可以指定索引，默認最后一個

>>> name = ['matt', 'jordan', 'logan', 'summer', 'linda', 'amy']
>>> name.pop()
'amy'
>>> name.pop()
'linda'
>>> name
['matt', 'jordan', 'logan', 'summer']

注意，list和dict在循環中禁止添加和刪除，錯誤實例如下

name = ['matt', 'jordan', 'logan', 'summer', 'linda', 'amy']
for i in name:
    name.remove(i)   #remove是在原列表的基礎上進行的
print(name)

['jordan', 'summer', 'amy']

解決方法為新建一個空列表，在空列表中添加。

3. 改 

7、L[index] = obj     只能通過索引修改

>>> name = ['matt', 'jordan', 'logan', 'summer', 'linda', 'amy']
>>> name[2] = 'mike'
>>> name
['matt', 'jordan', 'mike', 'summer', 'linda', 'amy']

4. 查

8、 L.index(obj)  從列表中找出某個值第一個匹配項的索引位置，返回index

>>> name = ['matt', 'jordan', 'logan', 'summer', 'linda', 'amy']
>>> name.index('logan')
2 

9、L[index]     通過索引查找對象，返回obj

5.排序

10、L.sort(cmp=None, key=None, reverse=False)   在原來列表的基礎上修改，不會生成新的列表

11、L.reverse() 在原來列表的基礎上修改，不會生成新的列表

>>> name = ['matt', 'jordan', 'logan', 'summer', 'linda', 'amy','1','2','3']
>>> name.sort()
>>> name
['1', '2', '3', 'amy', 'jordan', 'linda', 'logan', 'matt', 'summer']

>>> name.reverse()
>>> name
['summer', 'matt', 'logan', 'linda', 'jordan', 'amy', '3', '2', '1']

6. 統計

12、L.count(obj)

7. 切片

name = ['matt', 'jordan', 'logan', 'summer', 'linda', 'amy']
print(name[0:3])    #取前三個
print(name[:3])     #取前三個
print(name[2:-1])   #取第三個到最后第二個
print(name[2:])     #取第三個到最后
print(name[-2:-1])  #取倒數第二個
print(name[::3])    #每3個元素取一個

結果為：

['matt', 'jordan', 'logan']
['matt', 'jordan', 'logan']
['logan', 'summer', 'linda']
['logan', 'summer', 'linda', 'amy']
['linda']
['matt', 'summer']

8. 賦值，淺copy，深copy

賦值（只是生產連接），L.copy()  淺copy（表層copy，下一層生成連接）和深copy（完全重建內存）

深淺copy不存在於數字，字符串中

import copy
name = ['matt', 'jordan', 'logan', 'summer',['linda', 'amy'] ]
name1 = name
name2 = name.copy()
name3 = copy.copy(name)
name4 = copy.deepcopy(name)
name[0] = 'MATT'
name[4][0] = 'LINDA'
print(name1)；print(name2)；print(name3)；print(name4)

 結果為：

['MATT', 'jordan', 'logan', 'summer', ['LINDA', 'amy']]
['matt', 'jordan', 'logan', 'summer', ['LINDA', 'amy']]
['matt', 'jordan', 'logan', 'summer', ['LINDA', 'amy']]
['matt', 'jordan', 'logan', 'summer', ['linda', 'amy']]

本方法不適用於數字和字符串

a = '2';b = a;a = 'aqs'
print(b)
結果為：
2

9. 列表內置函數

1、len(list)：列表元素個數 

2、max(list)：返回列表元素最大值 

3、min(list)：返回列表元素最小值 

4、list(seq)：將元組轉換為列表 

10. 列表操作符

>>> [1,2]+[3,4]
[1, 2, 3, 4]

>>> ['a']*3
['a', 'a', 'a']

七  元組

元組可以稱為只讀列表

1. 元組內部方法

只有兩個方法：L.count(obj)    ，L.index(obj)  返回index

name = ('matt', 'jordan', 'logan', 'summer', 'linda', 'amy','amy')
print(name.count('amy'))
print(name.index('amy'))

2. 元組切片

name = ('matt', 'jordan', 'logan', 'summer', 'linda', 'amy','amy')
print(name[1:4])
print(name)

('jordan', 'logan', 'summer')
('matt', 'jordan', 'logan', 'summer', 'linda', 'amy', 'amy')

3. 嵌套元組修改

name = ('matt', ['jordan', 'logan', 'summer'], 'linda', 'amy','amy')
name[1].pop()
print(name)

('matt', ['jordan', 'logan'], 'linda', 'amy', 'amy')

嵌套元組的內部元素可以修改。元組只包含一個元素時，必須加上逗號，否則不是元組。

八  字典

字典是無序的，所以先天排除重。dictionary

字典的key值必須是不可變的（可哈希的），value則沒有規定

dic = {123: 456, True: 999, "id": 1, "name": 'sylar', "age": 18, "stu": ['帥哥', '美⼥'], (1, 2, 3): '麻花藤'}

可哈希：數字，字符串，元組

1. 增

1、dict[key] = value      key存在就是修改，不存在就是添加

info = {'name': 'matt','age':'23', 'salary':'10000' }
info['job'] = 'it'
print(info)
結果為：
{'name': 'matt', 'age': '23', 'salary': '10000', 'job': 'it'}

2、dict.setdefault(key, default=None)    與get方法類似，如果 key 在 字典中，返回對應的值。如果不在字典中，則插入 key 及設置的默認值 default，並返回 default ，default 默認值為 None。

dict = {'Name': 'matt', 'Age': 20}
dict.setdefault('Age', 30)   #返回值為20
dict.setdefault('Sex', 'F')  #返回值為 F print(dict)
結果為：
{'Name': 'matt', 'Age': 20, 'Sex': 'F'}

2. 刪

3、del dict[key]  刪除單一元素  沒有返回值       del dict刪除整個字典

4、pop(key)      刪除單一元素      默認隨機刪除   返回值為刪除的value值    

5、popitem()     隨機刪除單一元素，返回值為刪除的(key, value) ，不能刪除指定key值

6、dict.clear()   清除字典

info = {'name': 'matt','age':'23', 'salary':'10000', 'job':'it' }
a = info.pop('name');print(a);print(info)
b = info.popitem();print(b);print(info)
del info['age'];print(info)

結果為：

matt
{'age': '23', 'salary': '10000', 'job': 'it'}
('job', 'it')
{'age': '23', 'salary': '10000'}
{'salary': '10000'}

3. 改

  同添加   dict[key] = value      key存在就是修改，不存在就是添加

info = {'name': 'matt','age':'23', 'salary':'10000', 'job':'it' }
info['name'] = 'logan'
print(info)
結果為：
{'name': 'logan', 'age': '23', 'salary': '10000', 'job': 'it'}

4. 查

7、dict[key]   key值存在，返回value值，key值不存在，報錯

8、 dict. get(key , default = None)，訪問字典中對應的鍵里的值，如不存在該鍵返回default的值

9、dict.has_key(key)：如果鍵在字典dict里返回true，否則返回false       與in類似 

info = {'name': 'matt','age':'23', 'salary':'10000', 'job':'it' }
print('name' in info)
print(info.get('name'))
print(info['name'])
結果為：
True；matt；matt

5. 遍歷字典

10、dict.keys()   以列表返回一個字典所有的鍵  

11、dict.values()  以列表返回字典中的所有值

12、dict.item()  以列表返回可遍歷的(鍵, 值) 元組數組 ；會先把dict轉成list,數據里大時莫用；類似於enumerate，返回的都是元組，然后一般在解包，enumerate一般用於list

info = {'name': 'matt', 'age': '23', 'salary': '10000', 'job': 'it'}
for i in info:    #與for i in info.keys()：相同
    print(i, end=' ')
print()
for i in info.values():
    print(i, end=' ')
print()
for i, j in info.items():              類似於enumerate     
    print(i, j, end=', ')
結果為：

name age salary job
matt 23 10000 it
name matt, age 23, salary 10000, job it,

6. 字典其余函數

13、dict.update(dict2)  把字典dict2的鍵/值對更新到dict里，相當於字典拼接。無返回值，在dict的基礎上拼接

info = {'name': 'matt', 'age': '23'}
info2 = {'salary': '10000', 'job': 'it'}
print(info.update(info2))
print(info)
print(info2)
結果為：

None
{'name': 'matt', 'age': '23', 'salary': '10000', 'job': 'it'}
{'salary': '10000', 'job': 'it'}

14、dict.copy()    返回一個字典的淺復制

15、dict.fromkeys()：創建一個新字典，以序列seq中元素做字典的鍵，val為字典所有鍵對應的初始值

>>> dict.fromkeys([1,2,3],'testd')
{1: 'testd', 2: 'testd', 3: 'testd'}

7. 字典內置函數

1、len(dict)：計算字典元素個數，即鍵的總數。
2、str(dict)：輸出字典可打印的字符串。
3、type(variable)：返回輸入的變量類型，如果變量是字典就返回字典類型。

九  集合

set() 中的元素是不重復的，無序的。內部的元素必須是可hash的(int, str, tuple,bool), 我們可以這樣來記. set就是dict類型的數據，但是不保存value, 只保存key。 

set是可迭代對象

利用set（）不重復的特性，給list（）去重

# 給list去重復
lst = [45, 5, "哈哈", 45, '哈哈', 50]
lst = list(set(lst)) # 把list轉換成set, 然后再轉換回list
print(lst)

[5, '哈哈', 50, 45]

1. 增

1、set.add(obj)  add添加單個元素

2、set.update(set)    update添加時首先生成set，然后再合並，類似於dict.update(dict2) 和 list.extend(seq)

s = {"劉嘉玲", '關之琳', "王祖賢"}
s.add(("鄭裕玲",'張曼玉'))
print(s)
s.add("劉嘉玲") # 重復的內容不會被添加到set集合中
print(s)
s = {"劉嘉玲", '關之琳', "王祖賢"}
s.update("麻花藤") # 迭代更新
print(s)
s.update(["張曼", "李若彤","李若彤"])
print(s)

{'王祖賢', '劉嘉玲', '關之琳', ('鄭裕玲', '張曼玉')}
{'王祖賢', '劉嘉玲', '關之琳', ('鄭裕玲', '張曼玉')}
{'藤', '麻', '花', '王祖賢', '劉嘉玲', '關之琳'}
{'藤', '李若彤', '麻', '張曼', '花', '王祖賢', '劉嘉玲', '關之琳'}

2. 刪

3、set.pop()    因為set沒有索引，只能隨機刪除一個

4、set.remove(obj)   刪除指定元素   刪除不存在的元素會報錯

5、set.discard()  刪除集合中指定的元素 刪除不存在的元素啥都不做

6、set.clear()     清空，最后的打印結果為：set（）

s = {"劉嘉玲", '關之琳', "王祖賢","張曼", "李若彤"}
item = s.pop() # 隨機彈出1個.
print(s)
print(item)
s.remove("關之琳") # 直接刪除元素
# s.remove("疼") # 不存在這個元素. 刪除會報錯
print(s)
s.clear() # 清空set集合.需要注意的是set集合如果是空的. 打印出來是set() 因為要和dict區分的.
print(s) # set()

#discard()  刪除集合中指定的元素  刪除不存在的元素啥都不做
boys = {'bd','zw','jl','zy'}
boys.discard('zy1')
print(boys)

3. 改

set集合中的數據沒有索引. 也沒有辦法去定位元素.。所以沒有辦法進行直接修改。我們可以采用先刪除后添加的方式來完成修改操作。

s = {"劉嘉玲", '關之琳', "王祖賢","張曼⽟", "李若彤"}
# 把劉嘉玲改成趙本⼭
s.remove("劉嘉玲")
s.add("趙本⼭")
print(s)

4. 遍歷集合

set是可迭代對象

s = {"劉嘉玲", '關之琳'}
for el in s:
    print(el)

5. 集合操作

7、set.copy()     淺復制

#copy()  復制集合
boys = {'bd','zw','jl','zy'}
newboys = boys.copy()
print(newboys)

 

#集合推導式
var = {'螞蚱','螳螂','蟈蟈','蛐蛐'}

#基本的集合推導式
result = {'*'+i+'*' for i in var}
print(result)

#帶有判斷條件的集合推導式
result = {i for i in var if i != '蛐蛐'}
print(result)

#多循環集合推導式
colors = {'red','blue','pink'}
sizes = {36,37,38,39}
result = {c + str(s) for c in colors for s in sizes}
print(result)


#difference() 計算2個集合的差集
dreamers = {'ljl','wc','xy','zb','lsy'}
girls = {'mmf','lsy','syj'}
result = dreamers.difference(girls)# result = a + b
print(result)

#difference_update()  計算2個集合的差集(差集更新操作)
dreamers = {'ljl','wc','xy','zb','lsy'}
girls = {'mmf','lsy','syj'}
dreamers.difference_update(girls)#a = a + b  a += b
print(dreamers)

#union()  並集操作
dreamers = {'ljl','wc','xy','zb','lsy'}
girls = {'mmf','lsy','syj'}
result = dreamers.union(girls)
print(result)

#update()  並集更新操作
dreamers = {'ljl','wc','xy','zb','lsy'}
girls = {'mmf','lsy','syj'}
dreamers.update(girls)
print(dreamers)

#intersection()  計算2個集合的交集
dreamers = {'ljl','wc','xy','zb','lsy'}
girls = {'mmf','lsy','syj'}
result = dreamers.intersection(girls)
print(result)

#intersection_update  交集更新操作
dreamers = {'ljl','wc','xy','zb','lsy'}
girls = {'mmf','lsy','syj'}
dreamers.intersection_update(girls)
print(dreamers)

#超集和子集
boys = {'zzy','yqw','dw','wzc','lyb','wym','chy'}
zoudu = {'wzc','lyb','wym'}
girls = {'lsy','mmf','syj'}

#issuperset()  檢測當前集合是否是另一個集合的超集
result = boys.issuperset(zoudu)
print(result)

#issubset()  檢測當前集合是否是另一個集合的子集
result = zoudu.issubset(boys)
print(result)

#isdisjoint()  檢測2個集合是否不存在交集  存在交集 False
result = boys.isdisjoint(girls)
print(result)

#symmetric_difference()  對稱差集
dreamers = {'ljl','wc','xy','zb','lsy'}
girls = {'mmf','lsy','syj'}
result = dreamers.symmetric_difference(girls)
print(result)

#symmetric_difference_update()  對稱更新差集
dreamers = {'ljl','wc','xy','zb','lsy'}
girls = {'mmf','lsy','syj'}
dreamers.symmetric_difference_update(girls)
print(dreamers)

6. 冰凍集合

set集合本是可以發生改變的，是不可hash的. 我們可以使用frozenset來保存數據。
frozenset  是不可變的. 也就是一個可哈希的數據類型 。

s = frozenset(["趙本", "劉能", "哈哈", "跪"])
dic = {s:'123'} # 可以正常使用
print(dic)

 

#冰凍集合
#冰凍集合是一種特殊的集合類型,也是集合(集合是列表的話,冰凍集合就是元組)
#創建冰凍集合
#一般不會創建空的冰凍集合
var = frozenset()
print(var,type(var))

#帶有數據的冰凍集合
var = frozenset(('qs','szx','bjh','acs'))
print(var,type(var))

#成員檢測
result = 'szx' in var
print(result)

#遍歷冰凍集合
for i in var:
    print(i)

#集合推導式(無法得到冰凍集合,可以得到集合,列表,元組,字典類型)
result = {i for i in var}
print(result,type(result))

#函數
#冰凍集合可以使用集合的函數(不修改集合本身的函數都可以使用)
var = frozenset(('qs','szx','bjh','acs'))

#copy()
result = var.copy()
print(result)

#集合操作  交集,並集,差集,對稱差集等  不修改冰凍集合本身就能使用:冰凍集合的操作結果都是冰凍集合
var1 = frozenset(('qs','szx','bjh','acs'))
var2 = {'szx','bjh','lc','wb'}

#冰凍集合操作
result = var1.union(var2)
print(result)

#普通集合操作(冰凍集合是參考集合)
result = var2.union(var1)
print(result)

十  小數據池

1. is 與 == 的區別

通過id()可以查看到一個變量表示的值在內存中的地址

• ==：判斷左右兩端的值是否相等
• is：判斷左右兩端內容的內存地址是否一致。如果返回True,那可以確定這兩個變量使用的是同一個對象

a = 100
b = 100
print(a is b)  # True
print(a == b)  # True

a = 1000
b = 1000
print(a == b) # True
print(a is b) # False 在command命令下為False, 在.py文件中（例如pycharm中）得到的結果為True。（每一行cmd命令都是一個代碼塊）

代碼幫助理解

a = 10
print(id(a))
print(id(10))
print(a is 10)
print(a == 10)

8791375307696
8791375307696
True
True

2. 代碼塊

Python程序是由代碼塊構造的，它是作為一個單元執行的。

一個代碼塊可以：

• 一個函數(function)
• 一個類(class)的多個實例
• 每一行command命令
• eval()
• exec()

3. 代碼塊緩存機制

前提條件：在同一代碼塊中

機制內容：執行同一個代碼塊時，遇到初始化對象的命令時，他會將初始化的這個變量與值存儲在一個字典中，再遇到新的初始化對象命令時，先在字典中查詢其值是否已經存在，如果存在，那么它會重復使用這個字典中的之前的這個值。即兩變量指向同一個內存地址。如果是不同的代碼塊，則判斷這兩個變量是否滿足小數據池的數據，如果滿足，則兩變量指向同一個地址。如果不滿足，則得到兩個不同的對象，即兩變量指向的是不同的內存地址。

如果在同一代碼塊下，則采用同一代碼塊下的換緩存機制。如果是不同代碼塊，則采用小數據池的駐留機制。

注意：對於同一個代碼塊，只針對單純創建變量，才會采用緩存機制，對於創建變量並同時做相關運算，則無。

a = 1000
b = 1000
print(id(a)) # 2135225709680
print(id(b)) # 2135225709680
print(a is b)  # True  .py文件運行


a = 1000
b = 10*100
print(id(a)) # 1925536396400
print(id(b)) # 1925536643952
print(a is b) # False  .py文件運行

適用對象： int（float），str，bool

具體細則：

• int(float): 任何數字在同一代碼塊下都會復用；
• bool: True和False在字典中會以1，0方式存在，並且復用；
• str：幾乎所有的字符串都會符合緩存機制，具體規定如下：
  • 非乘法或乘數為1時，得到的字符串都滿足代碼塊的緩存機制；
  • 乘數>=2時：僅含大小寫字母，數字，下划線，總長度<=20，滿足代碼塊的緩存機制。

4. 小數據池

小數據池，不同代碼塊的緩存機制，也稱為小整數緩存機制，或者稱為駐留機制等等

前提條件：在不同一個代碼塊內。

適用對象： int（float），str，bool 

具體細則：

• int（float）：-5~256會被加到小數據池中，每次使用都是同一個對象。
• str：
• 如果字符串的長度是0或者1，包含特殊字符，都會默認進行緩存。（中文字符無效）
• 字符串長度大於1，但是字符串中只包含數字，字母，下划線時會被緩存。（特殊字符無效）
• 乘數大於1，僅包含數字，字母，下划線時會被緩存，但字符串長度不能大於20

內存緩存機制處理的數字和字符串范圍更大

優點：能夠提高字符串、整數的處理速度。省略了創建對象的過程。

缺點：在"池"中創建或者插入新的內容會花費更多的時間。

a = 5*5
b = 25
print(id(a))  # 1592487712
print(id(b))  # 1592487712
print(a is b)  # True  

a = "Incomputer science, string interning is a method of storing only onecopy of each distinct string value"
b = "Incomputer science, string interning is a method of storing only onecopy of each distinct string value"
print(id(a)) # 2926961023256
print(id(b)) # 2926961023256
print(a is b) # True  .py文件運行

def func():
    i1 = 1000
    print(id(i1))  # 2288555806672
def func2():
    i1 = 1000
    print(id(i1))  # 2288557317392

def func():
    i1 = 100
    print(id(i1))  # 8791514836720
def func2(): i1 = 100 print(id(i1)) # 8791514836720

5 . 指定駐留

 

可以通過sys模塊中的intern()函數來指定要駐留的內容。(詳情見sys模塊相關內容)

 

from sys import intern
a = intern('hello!@'*20)
b = intern('hello!@'*20)
print(a is b)
#指定駐留是你可以指定任意的字符串加入到小數據池中，讓其只在內存中創建一個對象，多個變量都是指向這一個字符串。

True