天天看點
傳回

字元串，清單，元祖，字典，集合的内置方法

數字類型

整型int

用途: 記錄年齡\等級\各種号碼

定義方式:    

age=18  
age=int(18)

x=int('123')      #隻能将純數字的字元串轉換成整型
print(type(x))
print(int(3.7))  #這個小數部分沒有了

View Code

常用操作+内置的方法（ 指派\比較\算術）

該類型總結：   存一個值  ;  不可變（1、可變：值變，id不變。可變==不可hash 2、不可變：值變，id就變。不可變==可hash）

判斷是否哈希           

print(hash(10))
print(hash([1,2,3]))

浮點型float

用途: 記錄身高\體重\薪資

定義方式

salary=1.3 
#salary=float(1.3)

x=float('3.1')
print(x,type(x))

常用操作+内置的方法

指派\比較\算術

該類型總結：   存一個值   ； 不可變（1、可變：值變，id不變。可變==不可hash 2、不可變：值變，id就變。不可變==可hash）

x=3.1
print(id(x))
x=3.2
print(id(x))

了解:

#複數
x=1-2j
print(x,type(x))
print(x.real)
print(x.imag)

#長整型
#不常見，知道有這個東西就行，至于到哪一位屬于長整形，沒必要了解

其他進制=>十進制
十進制: 0-9
11 = 1*10^1 + 1*10^0

二進制: 0 1
11 = 1*2^1 + 1*2^0

八進制: 0-7
11 = 1*8^1+1*8^0

十六進制:0-9 A-F
11 = 1*16^1+1*16^0

十進制=>其他進制
print(bin(13)) # 十進制=>二進制
print(oct(13)) # 十進制=>八進制
print(hex(13)) # 十進制=>十六進制

View Code

字元串類型

基本使用

用途:記錄描述性質的特征,比如名字\位址\性别

定義方式:在單引号\雙引号\三引号内包含的一串字元

msg='aaa"bbb"' 
#msg=str(...)

可以将任意類型轉換成字元串

str(1)
str(1.3)
x=str([1,2,3])
print(x,type(x))

View Code

常用操作+内置的方法 

#strip 方法用于移除字元串頭尾指定的字元（預設為空格）。
#str.strip([chars]);
# chars移除字元串頭尾指定的字元。 這是一個包含的關系
name = "*joker**"
print(name.strip("*"))
print(name.lstrip("*")) #去除左邊
print(name.rstrip("*")) #去除右邊

#長度len
msg='你好啊a'
print(len(msg))

#成員運算in和not in
msg='yangyuanhu 老師是一個非常虎的老師'
print('yangyuanhu' in msg)
print('虎' not in msg)
print(not '虎' in msg)

#format的三種玩法         一種格式化輸出的手段
print('my name is %s my age is %s' %('egon',18))
print('my name is %s my age is %s' %(18,'egon'))
print('my name is {name} my age is {age} '.format(age=18,name='egon'))
了解
 print('my name is {} my age is {} '.format(18,'egon'))
 print('my name is {0} my age is {1} '.format(18,'egon'))
 print('my name is {1} my age is {0} '.format(18,'egon'))

#replace
name = "joker is good joker boy!"
print(name.replace('joker','li')) #所有joker替換li
print(name.replace('joker','li',1)) #從左到右隻替換1次

#split           字元串切分，切分的結果是清單
name = 'root:x:0:0::/root/:bin/bash'
print(name.split(':')) #預設分隔符為空格
name = 'c:/a/b/c/d.txt' #想拿到頂級目錄
print(name.split('/',1)) #按多少次切片,從左邊
name = 'a|b|c'
print(name.rsplit('|',1)) #按多少次切片,從右邊

#join           有切分就有拼接，不過join隻能拼接字元串（其他類型會報錯），會形成一個新的字元串
tag = ' '
print(tag.join(['joker','li','good','boy'])) #可疊代對象必須都是字元串
#也就是說這個方法是将清單轉換為字元串，如果tag有變量的話，就會循環加


#startswith,endswith
name = "joker_li"
print(name.endswith("li")) #判斷是否以什麼結尾
print(name.startswith("joker")) #判斷是否以什麼開頭

#find,rfind,index,rindex,count
name = 'jokerk say hi'
print(name.find('s'))#find()是從字元串左邊開始查詢子字元串比對到的第一個索引,找不到不會報錯會傳回-1
print(name.count('k')) #統計包含有多少個
print(name.rfind('s')) # rfind()是從字元串右邊開始查詢字元串比對到的第一個索引
print(name.index('s'))   #index方法是在字元串裡從左邊查找子串第一次出現的位置，類似字元串的find方法，
                                  # 不過比find方法更好的是，如果查找不到子串，會抛出異常，而不是傳回-1

#center,ljust,rjust,zfill
name = 'joker'
print(name.center(10,'_')) #不夠10個字元，用_補齊
print(name.ljust(10,'*')) #左對齊
print(name.rjust(10,'*')) #右對齊，注意這個引号内隻能是一個字元
print(name.zfill(10)) #右對齊，用0補齊（）控制0的數量

#expandtabs
name = 'joker\thello'
print(name)
print(name.expandtabs(4)) #expand擴張的意思，就是将tab建轉為多少個空格

#lower,upper
name = 'joker'
print(name.lower()) #大寫變小寫，如果本來就是小寫，那就沒變化
print(name.upper()) #小寫變大寫，如果本來就是大寫，那就沒變化

#capitalize,swapcase,title
name = 'joker li'
print(name.capitalize()) #首字母大寫
print(name.swapcase()) #大小寫對調
print(name.title()) #每個單詞的首字母大寫

#expandtabs
print('hello\tworld'.expandtabs(5))    #hello與world直間列印了5個空格

#is數字系列
num1 = b'4' #bytes 類型
print(type(num1))
num2 = u'4' #unicode類型，在3裡預設就是這個類型
print(type(num2))
num3 = '四' #中文數字
num4 = 'Ⅳ' #羅馬數字

#isdigt,bytes,unicode
print(num1.isdigit()) #是不是一個整數數字,如果是浮點數就會False
print(num2.isdigit())
print(num3.isdigit()) #False
print(num4.isdigit()) #羅馬數字 False ，不是一個整數

#isdecimal,uncicode
#bytes類型無isdecimal方法
print(num2.isdecimal()) #檢查字元串是否隻包含十進制字元。這種方法隻存在于unicode對象
#注意:定義一個十進制字元串，隻需要在字元串前添加 'u' 字首即可
print(num3.isdecimal())
print(num4.isdecimal())

#isnumberic:unicode,中文數字，羅馬數字
#bytes類型無isnumberic方法
print(num2.isnumeric()) #判斷是不是數字，包括中文大寫數字，羅馬數字等
print(num3.isnumeric())
print(num4.isnumeric())

#三者不能判斷浮點數
num5='4.3' #全是false
print(num5.isdigit())
print(num5.isdecimal())
print(num5.isnumeric())
# 最常用的是isdigit,可以判斷bytes和unicode類型,這也是最常見的數字應用場景
# 如果要判斷中文數字或羅馬數字,則需要用到isnumeric


#is
print('===>')
name='joker123'
print(name.isalnum()) #字元串由字母和數字組成
print(name.isalpha()) #字元串隻由字母組成

print(name.isidentifier()) #判斷是不是一個合法的表示符
print(name.islower()) #判斷是不是小寫
print(name.isupper()) #是不是大寫
print(name.isspace()) #判斷是不是空格
print(name.istitle()) #每個單詞字母首字母大小

View Code

該類型總結：存一個值 ；有序 ； 不可變（1、可變：值變，id不變。可變==不可hash 2、不可變：值變，id就變。不可變==可hash）

清單類型

基本使用

用途:記錄多個值,比如人的多個愛好

定義方式: 在[]内用逗号分隔開多個任意類型的值

li=[1,2,3] # li=list([1,2,3])
x=list('hello')
x=list({'a':1,'b':2,'c':3})
print(x)

View Code

常用操作+内置的方法

按索引存取值(正向存取+反向存取)：即可存也可以取

li=['a','b','c','d']
print(li[-1])
li[-1]='D'
print(li)

li[4]='e'
del li[0]
print(li)

View Code

切片

切片的文法：

list[start:end:step]  start:起始位置     end:結束位置     step:步長     其中步長可有可無
對于冒号的使用：
[m : ] 代表清單中的第m+1項到最後一項
[ : n] 代表清單中的第一項到第n項
[::-1]  可以視為翻轉操作
[::2]    隔一個取一個元素的操作

顧頭不顧尾是指結束位置的元素不取，隻取到前面一個元素

View Code

長度

print(len(li))

成員運算 in 和 not in

users=['egon','lxx','yxx','cxxx',[1,2,3]]
print('lxx' in users)
print([1,2,3] in users)
print(1 in users)

View Code

追加

li=['a','b','c','d']
print(id(li))
li.append('e')
li.append([1,2,3])
print(li,id(li))

View Code

删除

li=['a','b','c','d']
#按照元素值去單純地删除某個元素
del li[1]
res=li.remove('c')
print(li)
print(res)
#按照元素的索引去删除某個元素并且拿到該元素作為傳回值
res=li.pop(1)
print(li)
print(res)

View Code

循環

li=['a','b','c','d']
for item in li:
  print(item)

View Code

切片指派和插入

作用：可以改變原清單的排序，可以插入和修改資料
         可以用切片改變清單的對應元素的值
  
文法:
        清單[切片] = 可疊代對象
        注: 指派運算符的右側必須是一個可疊代對象 

示例:
L = [2, 3, 4]   
L[0:1] = [1.1, 2.2] 
 
#L = [1.1,2.2,3,4]
   
L = [2, 3, 4]
L[1:] = [3.3, 4.4, 5.5]

#L=[2,3.3,4.4,5.5]    #改變了切片後面的值，沒有個數限制，統統加到原來的清單中
   
L = [2, 3, 4] 
L[:] = [0, 1]  

# L = [0, 1]
   
L = [2, 4] 
L[1:1]  = [3.1, 3.2] 

# L = [2,3.1,3.2,4]    # 實作中間插入 [3.1, 3.2]
  
L = [2,3,4]   
L[0:0] = [0, 1]   # 實作在前面插入[0,1]
   
L = [2,3,4]   
L[3：3]  = [5, 6]   # 實作在後面插入[5,6]
#L[4:4] = [5, 6]     #這種也能實作後面插入   切片裡面索引值是可以超過清單本身的
  
L = [1,4]  
L[1:1] = range(2,4)   #用range函數生成的可疊代對象指派
  
L = [2,3,4]
L[1:2] = "ABCD"     # "ABCD"也是可疊代對象
           
# 切片指派注意事項:
# 對于步長不等于1的切片指派，指派運算符右側的可疊代對象提供的元素個數一定要等于切片切出的段數
L = [1, 2, 3, 4, 5, 6]
print(L[::2])
L[::2] = "ABC"  # 對的   意思是從頭到尾按步長為2指派    "ABC"可以看作三個元素
print(L)
'''[1, 3, 5]
['A', 2, 'B', 4, 'C', 6]
'''

# # 以下切出三段，但給出5個元素填充是錯的
L[::2] = "ABCDE"
print(L)

該類型總結：存多個值 ；有序 ； 可變（1、可變：值變，id不變。可變==不可hash 2、不可變：值變，id就變。不可變==可hash）

print(hash([1,2,3]))

清單常用方法

li=['a','b','c','d','c','e']
print(li.count('c'))       #計算li中字元c的個數
li.extend([1,2,3])       #把括号裡清單裡的元素添加到li
li.append([1,2,3])      #把括号裡的清單增加到清單末尾
print(li)

print(li.index('z'))      #列印出z的索引值
print(li.index('b'))
print(li.index('d',0,3))

li.insert(1,'egon')     #在索引值1處插入字元串egon
print(li)

li=[3,1,9,11]
li.reverse()         #翻轉清單的順序
print(li)

li.sort(reverse=True)    #按照數字或字母順序排序
print(li)

練習，模拟堆棧和隊列

隊列: 先進先出
q=[]    
入隊
q.append('first')
q.append('second')
q.append('third')
print(q)   
出隊
print(q.pop(0))
print(q.pop(0))
print(q.pop(0))

堆棧: 先進後出
q=[] 
入棧
q.append('first')
q.append('second')
q.append('third')
出棧
print(q.pop(-1))
print(q.pop(-1))
print(q.pop(-1))

元組類型

元組其實跟清單差不多，也是存一組數，隻不是它一旦建立，便不能再修改，是以又叫隻讀清單，用于存放多個值,當存放的多個值隻有讀的需求沒有改的需求時用元組最合适

定義方式 : 在()内用逗号分隔開多個任意類型的值

t=(1,3.1,'aaa',(1,2,3),['a','b'])    # t=tuple(...)
print(type(t))

res=tuple('hello')
res=tuple({'x':1,'y':2})
print(res)

View Code

元組的另外一種建立方式

用逗号建立一個元組，就是這麼神奇

# res='dsb',
#('dsb',)
res='dsb','yyh'
print(res)
#('dsb', 'yyh')

在後面項目中遇到的坑 

# 處理資料庫的連接配接
class Connection:
    # 目前的連接配接數
    current_connect_count = 0
    host = "127.0.0.1",
    user = "root",
    password = "root",
    database = "ormtest",
    charset = "utf8",
    autocommit = True

    def create_conn(self):
        pass

# 在定義類的時候，在共有屬性後面加上逗号，就成了元組，不用逗号才是正常的類型
print(Connection.host,Connection.database)
print(type(Connection.current_connect_count))

常用操作+内置的方法

優先掌握的操作：

按索引取值(正向取+反向取)：隻能取

t=('a','b',1)
 t[0]=111

切片(顧頭不顧尾，步長)

t=('h','e','l','l','o')
 res=t[1:3]
 print(res)
 print(t)

View Code

長度

t=('h','e','l','l','o')
print(len(t))

成員運算in和not in

t=('h','e','l','l','o')
print('h' in t)

循環

t=('h','e','l','l','o')
for item in t:
print(item)

該類型總結  ：存多個值，有序，不可變（1、可變：值變，id不變。可變==不可hash 2、不可變：值變，id就變。不可變==可hash）

t=(1,'a',['x','y','z'])
# print(id(t[2]))

# print(id(t))
t[2][0]='X'
print(t)
print(id(t))

print(id(t[2]))

list1=['a','b','c']
print(id(list1[0]))
print(id(list1[1]))
print(id(list1[2]))

print('='*50)
list1[1]='B'
print(id(list1[0]))
print(id(list1[1]))
print(id(list1[2]))


t=('a','b','a')
print(t.index('a'))
t.index('xxx')

View Code

可變類型與不可變類型圖解分析

字元串，清單，元祖，字典，集合的内置方法

字典類型

字典的特性：

  • dict 是無序的
  • key 必須是唯一的，不能重複

常用操作+内置的方法

增加

info={'stu1102': 'LongZe Luola', 'stu1104': '蒼井空'}
info['huahuagongzi']='lengdigaga'    #隻要對應字典的鍵值對就能增加
print(info)

View Code

修改

>>> info['stu1101'] = "武藤蘭"
>>> info
{'stu1102': 'LongZe Luola', 'stu1103': 'XiaoZe Maliya', 'stu1101': '武藤蘭'}

View Code

删除

>>> info
{'stu1102': 'LongZe Luola', 'stu1103': 'XiaoZe Maliya', 'stu1101': '武藤蘭'}
>>> info.pop("stu1101") #标準删除姿勢
'武藤蘭'
>>> info
{'stu1102': 'LongZe Luola', 'stu1103': 'XiaoZe Maliya'}
>>> del info['stu1103'] #換個姿勢删除
>>> info
{'stu1102': 'LongZe Luola'}
>>> 
>>> 
>>> 
>>> info = {'stu1102': 'LongZe Luola', 'stu1103': 'XiaoZe Maliya'}
>>> info
{'stu1102': 'LongZe Luola', 'stu1103': 'XiaoZe Maliya'} #随機删除
>>> info.popitem()
('stu1102', 'LongZe Luola')
>>> info
{'stu1103': 'XiaoZe Maliya'}

View Code

查找

>>> info = {'stu1102': 'LongZe Luola', 'stu1103': 'XiaoZe Maliya'}
>>> 
>>> "stu1102" in info #标準用法
True
>>> info.get("stu1102")  #擷取
'LongZe Luola'
>>> info["stu1102"] #同上，但是看下面
'LongZe Luola'
>>> info["stu1105"]  #如果一個key不存在，就報錯，get不會，不存在隻傳回None
Traceback (most recent call last):
  File "<stdin>", line 1, in <module>
KeyError: 'stu1105'

View Code

多級字典嵌套及操作

av_catalog = {
    "歐美":{
        "www.youporn.com": ["很多免費的,世界最大的","品質一般"],
        "www.pornhub.com": ["很多免費的,也很大","品質比yourporn高點"],
        "letmedothistoyou.com": ["多是自拍,高品質圖檔很多","資源不多,更新慢"],
        "x-art.com":["品質很高,真的很高","全部收費,屌比請繞過"]
    },
    "日韓":{
        "tokyo-hot":["品質怎樣不清楚,個人已經不喜歡日韓範了","聽說是收費的"]
    },
    "大陸":{
        "1024":["全部免費,真好,好人一生平安","伺服器在國外,慢"]
    }
}

av_catalog["大陸"]["1024"][1] += ",可以用爬蟲爬下來"
print(av_catalog["大陸"]["1024"])
#ouput 
['全部免費,真好,好人一生平安', '伺服器在國外,慢,可以用爬蟲爬下來']

View Code

其他操作

#values
>>> info.values()
dict_values(['LongZe Luola', 'XiaoZe Maliya'])

#keys
>>> info.keys()
dict_keys(['stu1102', 'stu1103'])

#items
info={'stu1102': '龍澤蘿拉', 1: 2, 3: 4, 'stu1103': 'XiaoZe Maliya', 'stu1106': 'Alex'}
info_new=info.items()   #Python 字典 items() 方法以清單傳回可周遊的(鍵, 值) 元組數組
print(info_new,type(info_new))   #傳回可周遊的(鍵, 值) 元組數組

#setdefault
#setdefault:key不存在則設定預設值，并且将預設值添加到values中
#key存在則不設定預設，并且傳回已經有的值
>>> info.setdefault("stu1106","Alex")
'Alex'
>>> info
{'stu1102': 'LongZe Luola', 'stu1103': 'XiaoZe Maliya', 'stu1106': 'Alex'}
>>> info.setdefault("stu1102","龍澤蘿拉")
'LongZe Luola'
>>> info
{'stu1102': 'LongZe Luola', 'stu1103': 'XiaoZe Maliya', 'stu1106': 'Alex'}


#update 
>>> info
{'stu1102': 'LongZe Luola', 'stu1103': 'XiaoZe Maliya', 'stu1106': 'Alex'}
>>> b = {1:2,3:4, "stu1102":"龍澤蘿拉"}
>>> info.update(b)
>>> info
{'stu1102': '龍澤蘿拉', 1: 2, 3: 4, 'stu1103': 'XiaoZe Maliya', 'stu1106': 'Alex'}

#fromkeys()
用于建立一個新的字典，其中包含seq的值和設定為value的值。
文法 
dict.fromkeys(seq[, value]))
參數
seq - 這是用于字典鍵準備的值的清單。
value - 這是可選的，如果提供，則值将被設定為此值。
傳回值
此方法傳回值的清單。
#!/usr/bin/python3
seq = ('name', 'age', 'sex')
dict = dict.fromkeys(seq)
print ("New Dictionary : %s" %  str(dict))
dict = dict.fromkeys(seq, 10)
print ("New Dictionary : %s" %  str(dict))
當運作上面的程式，它産生以下結果 -
New Dictionary : {'age': None, 'name': None, 'sex': None}
New Dictionary : {'age': 10, 'name': 10, 'sex': 10}

View Code

循環dict 

info = {'stu1102': 'LongZe Luola', 'stu1103': 'XiaoZe Maliya'}
for key in info:     #預設周遊字典的鍵
    print(key,info[key])

View Code

字典内置函數

len(dict)              #計算字典元素個數，即鍵的總數。
str(dict)              #輸出字典可列印的字元串表示。
type(variable)     #傳回輸入的變量類型，如果變量是字典就傳回字典類型

字典内置方法

radiansdict.clear()    #删除字典内所有元素
radiansdict.copy()    #傳回一個字典的淺複制
radiansdict.fromkeys()    #建立一個新字典，以序列seq中元素做字典的鍵，val為字典所有鍵對應的初始值
radiansdict.get(key, default=None)    #傳回指定鍵的值，如果值不在字典中傳回default值
radiansdict.has_key(key)    #如果鍵在字典dict裡傳回true，否則傳回false
radiansdict.items()    #以清單傳回可周遊的(鍵, 值) 元組數組
radiansdict.keys()    #以清單傳回一個字典所有的鍵
radiansdict.setdefault(key, default=None)    #和get()類似, 但如果鍵不已經存在于字典中，将會添加鍵并将值設為default
radiansdict.update(dict2)    #把字典dict2的鍵/值對更新到dict裡
radiansdict.values()    #以清單傳回字典中的所有值

集合 

a = t | s          # t 和 s的并集  
b = t & s          # t 和 s的交集  
c = t – s          # 求差集（項在t中，但不在s中）  
d = t ^ s          # 對稱差集（項在t或s中，但不會同時出現在二者中）  

# set 無序，不重複序列

# 建立
# se = {'123',345}
# print(type(se))

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

# # 對比，之前我們把元祖轉換成清單的方法
# l = list((1,2,3))
# print(l)   # [1, 2, 3] 實際裡面運作了for循環，也就是init方法
#
# s1 = set(l)
# print(s1)  # {1, 2, 3} 集合還有一個機制就是，如果有相同的就會去除

# 功能
# s = set()
# s.add(1)
# s.add(1)
# print(s)   # {1}
# s.clear()
# print(s)  # 清空


# 差集
s1 = {11,22,33}
s2 = {22,33,44}
# s3= s1.difference(s2)  # s1中存在，s2中不存在 {11}
# s1.difference_update(s2) 更新到s1裡面，不需要建立新的集合
# print(s3)

# 對稱差集
# s3 = s1.symmetric_difference(s2) # 對稱差集 {11, 44}
# s1.symmetric_difference_update(s2)  更新到s1裡面，不需要建立新的集合
# print(s3)

# 删除
# s1.discard(11)
# print(s1) # {33, 22} 移除指定元素，不存在不報錯

# s1.remove(11)
# print(s1)   {33, 22} ，不存在報錯

# ret = s1.pop()  随機的,有傳回值
# print(ret)

# 交集
# ret = s1.intersection(s2)
# print(ret)   {33, 22}  
# s1.intersection_update(s2)

# ret = s1.isdisjoint(s2)
# print(ret)   # 沒有交集傳回true,有交集傳回true

# s1.issubset() # 是否是子序列，包含的關系
# s1.issuperset() # 是否是父序列，被包含的關系

# 并集
# ret = s1.union(s2)
# print(ret) {33, 22, 11, 44} 并集

# li = [1,2,3]
# s1.update(li) # 接收一個可疊代的相比add，它可以添加個序列，并且循環執行add
#
# print(s1) # {33, 2, 3, 1, 11, 22}

什麼是集合

在{}内用逗号分隔開多個值,集合的特點:

每個值必須是不可變類型

集合無序

集合内元素不能重複

為何要用集合

用于做關系運算

去重

集合的第一大用途: 關系運算

pythons={'egon','張鐵蛋','李銅蛋','趙銀彈','王金蛋','艾裡克斯'}
linuxs={'歐德博愛','李銅蛋','艾裡克斯','lsb','ysb','wsb'}


求同時報名兩門課程的學生姓名:交集
print(pythons & linuxs)
print(pythons.intersection(linuxs))

pythons=pythons & linuxs
print(pythons) #{'李銅蛋', '艾裡克斯'}
pythons.intersection_update(linuxs) #pythons=pythons.intersection(linuxs)
print(pythons) #{'艾裡克斯', '李銅蛋'}

求報名學校課程的所有學生姓名:并集
print(pythons | linuxs)
print(pythons.union(linuxs))

求隻報名python課程的學生姓名: 差集
print(pythons - linuxs)
print(pythons.difference(linuxs))
print(linuxs - pythons) #求隻報名linux課程的學生姓名
print(linuxs.difference(pythons))

求沒有同時報名兩門課程的學生姓名: 對稱差集
print((pythons - linuxs) | (linuxs - pythons))
print(pythons ^ linuxs)
print(pythons.symmetric_difference(linuxs))

父子集:指的是一種包含與被包含的關系

s1={1,2,3}
s2={1,2}
print(s1 >= s2)
print(s1.issuperset(s2))
print(s2.issubset(s1))


情況一:
print(s1 > s2) #>号代表s1是包含s2的,稱之為s1為s2的父集
print(s2 < s1)

情況二:
s1={1,2,3}
s2={1,2,3}
print(s1 == s2) #s1如果等于s2,也可以稱為s1是s2的父集合

綜上:
s1 >= s2 就可以稱為s1是s2的父集


s3={1,2,3}
s4={3,2,1}
print(s3 == s4)

s5={1,2,3}
s6={1,2,3}
print(s5 >= s6)
print(s6 >= s5)

集合的第二大用途:去重

集合去重的局限性:

1. 會打亂原值的順序

2. 隻能針對不可變的值去重

stus=['egon','lxx','lxx','alex','alex','yxx']
new_l=list(set(stus))
print(new_l)

old_l=[1,[1,2],[1,2]]
set(old_l)

l = [
    {'name': 'egon', 'age': 18, 'sex': 'male'},
    {'name': 'alex', 'age': 73, 'sex': 'male'},
    {'name': 'egon', 'age': 20, 'sex': 'female'},
    {'name': 'egon', 'age': 18, 'sex': 'male'},
    {'name': 'egon', 'age': 18, 'sex': 'male'},
]
new_l=[]
for dic in l:
if dic not in new_l:
new_l.append(dic)
print(new_l)

View Code

需要掌握的操作

s1.update({3,4,5})
print(s1)
print(s1.pop())
print(s1)

s1.remove(2)
print(s1)

s1={1,2,3}
print(id(s1))
s1.add(4)
print(s1)
print(id(s1))

s1={1,2,3}
s1.discard(4)  移除指定元素，不存在不報錯
           
s1.remove(4) print(s1) s1={1,2,3} s2={4,5} print(s1.isdisjoint(s2))

總結  ： 存多個值   ； 無序  ；  set可變

布爾值

所有資料類型都自帶布爾值

1、None，0，空（空字元串，空清單，空字典等）三種情況下布爾值為False

2、其餘均為真  

資料類型總結

按存儲空間的占用分（從低到高）：

數字

字元串

集合：無序，即無序存索引相關資訊

元組：有序，需要存索引相關資訊，不可變

清單：有序，需要存索引相關資訊，可變，需要處理資料的增删改

字典：無序，需要存key與value映射的相關資訊，可變，需要處理資料的增删改

按存值個數區分：

标量／原子類型：數字，字元串

容器類型：清單，元組，字典

按可變不可變區分

可變          清單，字典

不可變             數字，字元串，元組

按通路順序區分

直接通路       數字

順序通路（序列類型）  字元串，清單，元組

key值通路（映射類型）  字典

轉載于:https://www.cnblogs.com/596014054-yangdongsheng/p/9664982.html

爬蟲 Python 資料庫
上一篇: Python内置序列之清單、元組、字元串、集合以及字典
下一篇: Python(二)-字元串、清單、字典 、元組、集合第1章 字元串處理第2章 list清單第3章 dict字典第4章 元組處理第5章 set集合

繼續閱讀