Python基礎知識-06-集合內存布爾False

 

python其餘知識目錄

 

一、判斷一個字符串中是否有敏感字符？

#str：
m_str="我叫魔降風雲變"
if "魔" in m_str:      #判斷指定字符是否在某個字符串中
    print("含敏感字符")
---------結果：
含敏感字符

#list/tuple：
方法一：for循環
char_list=["mcw","xiaoma","xiaxiao"]
content=input("請輸入內容：")          
success=False                        #何時用success這種標誌，前面還有個message的相似的
for i in char_list:                     #判斷字符串是否在指定列表中 if i==content:
        success=True
　　　　 break
if success:
    print("包含敏感字符")
------------結果：
請輸入內容：mcw
存在敏感字符

方法二：in
char_list=["mcw","xiaoma","xiaxiao"]
content=input("請輸入內容：")
if content in char_list:
    print("存在敏感字符")
-----------結果：
請輸入內容：mcw
存在敏感字符

#dic

v = {'k1':'v1','k2':'v2','k3':'v3'}
# 默認按照鍵判斷，即：判斷x是不是字典的鍵。    
if 'x' in v:
    print(True)
# 請判斷：k1 是否在其中？     
if 'k1' in v:           #判斷是不是字典的鍵
    print(True)
# 請判斷：v2 是否在其中？
# 方式一：循環判斷
flag = '不存在'
for i in v.values():       #判斷是不是字典的值
    if i == 'v2':
        flag = '存在'
print(flag)
# 方式二：
if 'v2' in list(v.values()): # 強制轉換成列表 ['v1','v2','v3']
    print(True)
# 請判斷：k2:v2 是否在其中？
value = v.get('k2')            #判斷鍵值對是否在字典。先肯定鍵是否存在，再肯定值是否相等
if value == 'v2':
    print('存在')
else:
    print('不存在')

 二、集合

集合（set）是一個無序的不重複元素序列。

可使用大括號 { } 或者 set() 函數建立集合，注意：建立一個空集合必須用 set() 而不是 { }，由於 { } 是用來建立一個空字典。

2.1建立集合

建立格式：

parame = {value01,value02,...}
或者
set(value)

set={"mcw","xiaoma","xiaoma",1,True}
print(set)
------------------結果：
{'mcw', 'xiaoma', 1}      #集合有去重功能，每次執行一次，元素排序發生改變，說明集合是無序的.集合裏面元素 0 FALSE ； 1 Ture 算是重複值,也會去重

>>> set={"mcw","xiaoma","xiaoma",1,True}
>>> "mcw" in set #快速判斷元素是否在集合內
True
>>> "xiao" in set
False

mcw=set()               #定義空集合，空集合布爾值爲False
print(mcw,bool(mcw))             
-----------結果：             
set() False                     

2.2集合獨有功能 -添加

集合.add(集合元素)

>>> set={"mcw",1,True,(1,2)}
>>> set.add("xiaoma")
>>> print(set)
{'mcw', 1, 'xiaoma', (1, 2)}

集合.update(集合，列表等等)

>>> set={"mcw",1,True,(1,2)}
>>> set.update({"mcw","xiaoma"})     #update重複的無論，沒有的添加進集合 >>> print(set)
{'mcw', 1, (1, 2), 'xiaoma'}

>>> set={"mcw",1,(1,2)}
>>> set.update([3,4])
>>> print(set)
{(1, 2), 1, 3, 4, 'mcw'}

2.3刪除（集合無序不重複，因此不能用索引刪除）

集合.discard(集合元素)

>>> set={"mcw",1,(1,2)}
>>> set={"mcw",1,True,(1,2),"xiaoma","ming"}
>>> set.discard((1,2))             #彷佛刪除的是單個
>>> print(set)
{'mcw', 1, 'xiaoma', 'ming'}

2.4修改，由於沒法定位，沒法修改，能從新定義

2.5集合交併差以及集合運算

集合2的位置均可以是列表、元組，交集並集等都是生成新的集合，結果都是賦給新的集合

 

交集
交集=集合1.intersection({集合2})
>>> set={1,2}
>>> jiao=set.intersection({2,3,4})
>>> print(jiao)
{2}
並集
並集=集合1.union({集合2})
>>> set={1,2}
>>> bing=set.union({2,3,4})
>>> print(bing)
set([1, 2, 3, 4])
差集
差集=集合1.difference(集合2)  #自我註解：集合1與2比較，1在2中1有什麼不一樣的元素。因此1有，2沒有 $1與2的差集，1-2，就是在1中減去與2相同的元素後1中剩下的元素
set1={1,2}
set2={2,3,4}
cha=set1.difference(set2)
print(cha)
--------------結果：
{1}
對稱差集  #兩者元素和再去掉兩者共有的。
對稱差集=集合1.symmetric_difference(集合2) 
set1={1,2}
set2={2,3,4}
duichencha=set1.symmetric_difference(set2)
print(duichencha)
--------------結果：
{1, 3, 4}

集合運算

      圖片修改部份內容（更精確的描述）：a與b的交集取反，不一樣時在a和b的兩個集合的元素

 

>>> a=set('abcd')
>>> b=set('cdfe')
>>> a
{'d', 'b', 'c', 'a'}
>>> a-b      #集合a中包含而集合b中不包含的元素 $a與b中的差集，在a但不在b的元素 %%%a-b差集，就是在a中減去和b相同的元素剩下來的a的元素
{'a', 'b'}
>>> a|b      #集合a或b中包含的全部元素 $a與b的並集，在a或在b的元素
{'e', 'f', 'c', 'b', 'd', 'a'}
>>> a & b    # 集合a和b中都包含了的元素 $a與b的交集，在a且在b的元素
{'d', 'c'}
>>> a^b        # 不一樣時包含於a和b的元素 $a與b的交集取反，不一樣時在a和b的兩個集合的元素
{'e', 'f', 'b', 'a'}

2.6#公共功能：只有len，for循環的公共功能

len
for循環
索引 無
步長 無
切片 無
刪除 無
修改 無

set={1,2}
print(len(set))
-------結果：
2

set={"mcw","xiaoma","ming"}
for i in set:
    print(i)
----------結果：
ming
xiaoma
mcw

2.7集合的嵌套

集合裏面能夠存放整型，布爾 字符串 None 等等

>>> print({1,"xiaoma",False,(1,2),None})
{False, 1, (1, 2), 'xiaoma', None}

View Code

不能放列表 報錯 unhashable type   列表/集合/字典不能放入集合，也不能做爲 字典的key(unhashable)

>>> set={{1,2},"xiaoma"}
Traceback (most recent call last):
  File "<pyshell#34>", line 1, in <module>
    set={{1,2},"xiaoma"}
TypeError: unhashable type: 'set'
>>> set={[1,2],"xiaoma"}
Traceback (most recent call last):
  File "<pyshell#35>", line 1, in <module>
    set={[1,2],"xiaoma"}
TypeError: unhashable type: 'list'
>>> set={{"name":"mcw"},"xiaoma"}
Traceback (most recent call last):
  File "<pyshell#36>", line 1, in <module>
    set={{"name":"mcw"},"xiaoma"}
TypeError: unhashable type: 'dict'

View Code

2.8hash

判斷什麼是否在列表裏，for循環/in方法 遍歷列表很慢
集合， 給元素計算hash值，並存放到hash表，hash值指向內存地址，效率比遍歷列表快。
字典裏面也會hash,hash鍵，並放在內存一個地址。根據key,直接定位找到value，速度快。在字典和集
閤中查詢是否存在某個元素，效率等價。
hash是怎麼回事？
由於在內部會將值進行哈希算法並獲得一個值（這個值映射到實際存儲的內存地址），之後根據值做爲索引，實現快速查找

2.9集合特殊狀況（0 False ;1 Ture會去重）

集合裏面元素 0 FALSE 1 Ture 是重複值，因爲集合元素具備惟一性，因此會作去重的 
字典裏的鍵也具備惟一性，因此也會自動作去重操做

info ={1:2,True:3}
print(info)
---------結果：
{1: 3}

三、內存相關的東西 賦值和修改要區別開來，賦值（從新定義）是從新開闢內存，修改是原內存空間內的改變

3.1賦值（定義）和修改

定義兩個列表，字符串，都是從新開闢內存地址。兩塊內存地址

>>> li1=["mcw","xiaoma"]
>>> li2=["mcw","xiaoma"]
>>> id(li1)
46000048
>>> id(li2)
45924224

View Code

定義一個變量，給變量從新賦值，從新開闢內存空間。原值內存地址若是沒有指定它的那麼就會成爲垃圾，垃圾回收機制會回收內存地址

>>> li=["mcw","xiaoma"]
>>> id(li)
45994232
>>> li=["ming","tian"]
>>> id(li)
45924064

View Code

定義變量1，定義變量2=變量1，變量1有內存地址，變量2指向變量1的內存地址

>>> li=["mcw","xiaoma"]
>>> li1=["mcw","xiaoma"]
>>> li2=li1
>>> id(li1)
45999968
>>> id(li2)
45999968

View Code

v1=
v2=v1

v1=[原]
v2=v1
v1=[新]
print(v2) #[原]
思考，再對v2操做，結果？

-----------
v=[1,2,3]
valuse=[11,22,v]
v.append(9)
v發生變化，values發生變化,values裏的v指向v的內存地址

v=999
values仍是原來的地址，人眼看的v只是一個外部表現形式，其實內部執行時表現形式是內存地址
v只是內存地址指向嗎？
何時成爲垃圾，沒有人指向它的時候（自我思考：那麼有人指向的時候是否是有標記記錄呢）

查看內存地址的函數：
id(變量)

3.2Python的內部緩衝機制實現性能優化

Python緩衝機制，爲了提升性能的優化方案，經常使用的沒有從新開闢內存空間，而是指向內存中已存在的 
地址。Python數據的小數據池，經常使用字符串，浮點型等緩存 
一、整型-5到256 緩存，不從新開闢
二、字符串： "f_*"*3 包含特殊字符串的會從新開闢內存。
列表，元組等就不是這樣了。

--------

案例分析：

a=1
b=1 按理說應該從新開闢內存，可是Python爲了提升性能，有緩存機制，-5到256，因此內存地址同樣

a=1
b=a 內存地址同樣

>>> a=-5
>>> b=-5
>>> id(a)
1357524016
>>> id(b)
1357524016
>>> a=-6
>>> b=-6
>>> id(a)
45638912
>>> id(b)
45639568
>>> a=256
>>> b=256
>>> id(a)
1357528192
>>> id(b)
1357528192
>>> a=257
>>> b=257
>>> id(a)
45639568
>>> id(b)
45638912

View Code

-------

3.3  問題：==和is的區別是什麼

v1==v2 ==比較值是否相等 返回布爾值
v1 is v2 is比較的內存地址是否一致 返回布爾值

>>> v1=257
>>> v2=257
>>> bool(v1==v2)
True
>>> v1 is v2
False
>>> id(v1)
45639136
>>> id(v2)
45639152

View Code

若是v1,v2的值符合Python緩衝機制裏面的要求，那麼v1==v2 ,v1 is v2 返回的是同樣的

>>> v1=256
>>> v2=256
>>> bool(v1==v2)
True
>>> v1 is v2
True
>>> id(v1)
1421687936
>>> id(v2)
1421687936

View Code

-----

四、布爾返回值是False的有哪些？

>>> print(bool(0))    #數字0
False
>>> print(bool(()))    #空元組
False
>>> print(bool([]))    #空列表
False
>>> print(bool({}))    #空字典
False
>>> print(bool(None))    #None
False
>>> print(bool(""))      #空字符串
False
>>> print(bool(set()))    #空集合
False
>>> bool(False)           #False
False
#備註：3+5空

python 字節碼和彙編語言是同級別的