2019-07-04 列表、字典、集合、元組經常使用操做及內置方法

今天接着昨天列表知識點

1、列表

　　1.count()  統計該元素在此列表中有幾個　　　

l = [1,4,5,6,4,6,7]
print(l.count(6))     #2

　　2.clear()   清空列表   []

l = [1,4,5,6,4,6,7]print(l.clear())   #None    表示沒有返回任何值
print(l)       #[]

　　3.reverse()     將列表反轉（就是順序調換輸出）　

l = [1,4,5,6,4,6,7]
l.reverse()
print(l)           #[7, 6, 4, 6, 5, 4, 1]

　　4.sort () 排序  默認狀況下是從小到大（升序）

l = [1,4,5,6,4,6,7]
l.sort()
print(l)     #[1, 4, 4, 5, 6, 6, 7]

　　sort和reverse結合就能夠變成從大到小排序　　

l = [1,4,5,6,4,6,7]
l.sort(reverse=True)
print(l)    #[7, 6, 6, 5, 4, 4, 1]

　　總結：

　　　　1.能存多個值

　　　　2.有序

　　　　3.可變類型

　　用已學的知識點作隊列（先進先出）和堆棧（先進後出）

l1 = []
# 先進
l1.append('first')
 l1.append('second')
l1.append('third')
 # 先出
print(l1.pop(0))
print(l1.pop(0))
print(l1.pop(0))

# 先進
 l1.append('first')
 l1.append('second')
 l1.append('third')
# 後出
 print(l1.pop())
 print(l1.pop())
 print(l1.pop())

2、元組

　　做用：可以存儲多個元素，之間用逗號隔開，元素能夠是任意類型，元組不能被修改

　　定義：與列表相比，只不過是[]換成()

　　age = (11,22,33)    #age = tuple((11,22,33))

　　在定義元組的時候，哪怕只有一個元素的時候，也要用逗號隔開，區分一下　　

t1 = (1,2,3)
print(type(t1))    #<class 'tuple'>
t2 = (1)
print(type(t2))    #<class 'int'>

　　t  = tuple(1)   #報錯，必須傳容器類型就是能夠for循環的

　　須要掌握的操做：

　　　　1.按索引取值

　　　　　　t = (1,2,'a','b',[1,2,3])

　　　　　　print(t[0])     # 1

　　　　雖說元組不能改，可是若是要修改裏面的可變類型，你要先定位到修改數據的位置

t = (1,2,'a','b',[1,2,3])
t[-1][0] = '我改了'
print(t)      #(1, 2, 'a', 'b', ['我改了', 2, 3])

　　　　2.切片（顧頭不顧尾，步長）

　　　　　　print([::2])   #步長爲2獲取全部元素

　　　　3.長度   len

　　　　　　print(len(t))

　　　　4.成員運算   in 和not in

　　　　　　print ('a' in t)

　　　　5.循環

　　　　　　for i in t:

　　　　　　　　print(i)

　　總結：

　　　　1.能存多個值

　　　　2.有序

　　　　3.不可變類型

3、字典  dict

　　做用：能存儲多組key:value鍵值對，key是對value的描述   key一般都是字符串，這個key只能是不可變類型，value能夠是任意類型數據

　　定義： d ={'name':'jason','age':18}   #d = dict({'name':'jason','age':18})

　　注意：字典的key是不能重複的，要惟一標識一條數據，若是你重複了，後面的就會覆蓋前面的

　　須要掌握的：

　　　　1.按key存取值：可存可取　

d = {'name':'jason','age':18}

#取
print(d['name'])   #jason
print(d['user'])    #若是字典中沒有這個key，就會報錯

#修改
d['name'] = 'oldboy'
print(d)   #{'name': 'oldboy', 'age': 18}   若是是設置原字典中已經存在的key，就是修改

#添加
d['pwd'] = '123'
print(d)     #{'name': 'oldboy', 'age': 18, 'pwd': '123'}  若是原字典中沒有這個key,就是添加

　　　　2.長度len()

　　　　　　字典是統計鍵值對的個數

　　　　3.成員運算 in 和 not in    (對於字典來講只能判斷key值)　　　

d = {'name':'jason','age':18}
print('name' in d)  #True
print('pwd' in d)    #False

　　　　4.刪除 pop（根據key來刪除，返回的值是value。當刪除字典中沒有的key時，直接報錯）

d = {'name':'jason','age':18,'pwd':123}
print(d.pop('name'))  #jason
print(d)    #{'age': 18, 'pwd': 123}

print(d.pop('user'))    #直接報錯

　　　　定義字典的三種方法：　　　　　　

　　　　　　1.掌握：   d1 = {'name':'oldboy','pwd':123}

　　　　　　2.掌握：   d2  = dict(name = 'jason' , password = 123 , age = 18)  注意這裏的key設置的時候不用寫' '

　　　　　　3.瞭解便可

d ={}
l = [
    ['name','jason'],
    ['age',18],
    ['hobby','read']
]

for k,v in l:
    d[k] = v
print(d)    #{'name': 'jason', 'age': 18, 'hobby': 'read'}

#還有一種方法
d3 = dict(l)
print(d3)     #{'name': 'jason', 'age': 18, 'hobby': 'read'}

　　　　5.鍵keys(),值values(),鍵值對items()

　　　　　　keys是取出全部key放在一個列表中，values是取出全部value放在一個列表中，items是把每一個鍵值對放在一個元組中，而後全部鍵值對組成一個列表。

d = {'name':'jason','age':18,'pwd':123}
print(d.keys())    #dict_keys(['name', 'age', 'pwd'])
print(d.values())    #dict_values(['jason', 18, 123])
print(d.items())    #dict_items([('name', 'jason'), ('age', 18), ('pwd', 123)])

　　　　6.get()根據key獲取value   (這種方法相對於d['name'] 直接取值的方法更好，由於這個在取不存在的key時，不會報錯)　　　　　　　

d = {'name':'jason','age':18,'pwd':123}
print(d.get('name'))    #jason
print(d.get('age'))     #18
print(d.get('user'))    #None
print(d.get('aa','不存在的'))   #不存在的  
　　　　第二個參數若是不寫的話，當key不存在的話就返回None，寫了就返回你寫好的第二個參數信息

　　　　須要掌握的：

　　　　7.快速建立一個字典    fromkeys()

d = {'name':'jason','age':18,'pwd':123}
print(d.fromkeys(d,123))   #{'name': 123, 'age': 123, 'pwd': 123}
print(d.fromkeys('sad',123))    #{'s': 123, 'a': 123, 'd': 123}

　　　　8.popitem() 刪除   尾部以元組格式彈出

d = {'name':'jason','age':18,'pwd':123}
print(d.popitem())    #('pwd', 123)
print(d)    #{'name': 'jason', 'age': 18}

　　　　9.setdefault()

d1 = {'name':'jason','pwd':123}
res1 = d1.setdefault('name','xxoo')  # 當鍵存在的狀況下 不修改值 而且將原先key對應值返回給你
print(d1,res1)    #jason
res2 = d1.setdefault('age',18)  # 當鍵不存在的狀況下 新增一個鍵值對 而且將新增的鍵值對的值返回給你
print(d1,res2)     #18

　　　　10.update()  若是updata字典裏面沒有的key，就會新加一個鍵值對。若是update原來存在的key，那麼只會修改value

d1 = {'name':'jason','pwd':123}
d2 = {"age":18}
d1.update(d2)
print(d1)      #{'name': 'jason', 'pwd': 123, 'age': 18}

d1.update(age=666)
print(d1)    #{'name': 'jason', 'pwd': 123, 'age': 666}

　　　　11.循環     字典循環結果是顯示出key

　　　　d1  ={'name':'jason','age':18}

　　　　for i in d1:

　　　　　　print(i)

　　總結：

　　　　1.存在多個值

　　　　2.無序

　　　　3.可變的

4、集合　　　　

　　　　做用：去重、關係運算

　　　　定義：能夠包含多個元素，用逗號分開    s  = {1,2,3,4,5}      #  s = set()

　　　　注意在定義空集合的時候只能用關鍵字 set() ，   空{}指的是字典

　　　　集合的元素遵循三個原則：

　　　　　　1.每一個元素都必須是不可變元素

　　　　　　2.沒有重複的元素

　　　　　　3.無序

　　　　優先掌握的操做：

　　　　　　1.長度len()

　　　　　　2.成員運算  in 和 not in

　　　　　　3.   | 合集    （兩個集合合併）    兩個班級的全部人

pythons = {'jason', 'nick', 'tank', 'egon', 'kevin', 'owen', 'alex'}
linux = {'frank', 'jerry', 'tank', 'egon', 'alex'}

print(pythons | linux) #{'frank', 'tank', 'alex', 'jason', 'kevin', 'jerry', 'egon', 'owen', 'nick'}

　　　　　　4.   & 交集   （兩個集合的共同點）　兩個班級都報名了　 　

pythons = {'jason', 'nick', 'tank', 'egon', 'kevin', 'owen', 'alex'}
linux = {'frank', 'jerry', 'tank', 'egon', 'alex'}

print(pythons & linux)    #{'egon', 'alex', 'tank'}

　　　　　　5.  - 差集     只報了一個班的學生　　　　

pythons = {'jason', 'nick', 'tank', 'egon', 'kevin', 'owen', 'alex'}
linux = {'frank', 'jerry', 'tank', 'egon', 'alex'}

#只報名pythons班級的學生
print(pythons - linux)    #{'jason', 'kevin', 'nick', 'owen'}

#只報名linux班級的學生
print(linux - pythons)    #{'frank', 'jerry'}

　　　　　　6. == 判斷是否相等　　　

s1 = {1,2,3}
s2 = {1,3,2}
print(s1==s2)    #True    由於集合是無序的

　　　　　　7.     父集： >,>=     子集：<,<=    （判斷是否包含）返回結果是True或者False

s1 = {1,2,3}
s2 = {1,3,2,4,5}
print(s1<s2)     #True

 

數據類型總結

　　int

　　float

　　str

　　list

　　dict

　　set

       tuple

　　bool

 

　　可變類型：list / dcit /set

　　不可變類型： int /float /str /tuple

　　按訪問順序區分：

　　　　直接訪問：數字

　　　　順序訪問：字符串，列表，元組

　　　　key值訪問：字典