python經常使用內置方法

列表類型

類型轉換：但凡能被for循環遍歷的類型均可以看成參數傳給list（）轉換成列表
例如：
res = list("hello")
print(res)
['h', 'e', 'l', 'l', 'o']

# 內置方法
1,按照索引存取值（正向存取+反向存取）：便可以取也能夠改
l = [111,'zyl','wyy']
l[0] = 222
print(l)  # 能夠取也能夠改，索引存在則修改對應的值
l = [222,'zyl','wyy']

可是不管取值操做仍是賦值操做：索引不存在則報錯
若是想要在列表中追加值
l.append('yy')
print(l)    # .append在列表末尾追加一個值
l = [222,'zyl','wyy','yy']

若是想在某一位置在列表中插入值
l.insert(0,'zz')
print(l)     # .insert在列表中按索引位置插入值
l = ['zz',222,'zyl','wyy','yy']

若是想讓兩個列表的值放在一塊兒
l = [111,'zyl','wyy']
ll = [1,2,3]
l.extend(ll)
print(l)     # .extend在類表中添加另一個列表
[111, 'zyl', 'wyy', 1, 2, 3]   

刪除列表中的值
方法一：
del l[0]
print(l)     # del 刪除索引中的值

方法二：
l.pop()   # 根據索引刪除列表中的值，不指定索引，默認刪除最後一個 
pop方法會返回一個你刪除的元素

res = l.pop()
print(res)9
print(l)

方法三：
remove根據元素刪除  返回None
l.remove('zyl')
print(l)

計算列表中元素個數
l.len()

查看列表中元素出現的次數
l.count()

查找列表中元素所在的索引。沒有報錯
l.index()

清空列表中全部的元素
l.clear()  # ()內不用傳值

將列表中元素倒過來
l.reverse()   # ()也不用傳值，不是排序就是將列表倒過來

將列表中元素排序  ，列表中必須是同種類型才能夠排序
l.sort()  默認從小到大排序
l.sort(reverse=True)  # 從大到小排序，設置爲降序

元組類型

# 元組就是一個」一個不可變的列表「
# 1，做用：按照索引位置存放多個值，只用於讀不用於改

# 2，定義：（）內用逗號分隔開多個任意類型的元素
t =(1,1.1,'zyl',[111,222],{'name':'wyy'})
print(t,type(t))
(1, 1.1, 'zyl', [111, 222], {'name': 'wyy'}) <class 'tuple'>

若是元組內只有一個元素，必須加逗號
t(1,)
print(t)

元組不能更改，可是能夠改元組裏面列表和字典的值
例如
t =(1,1.1,'zyl',[111,222],{'name':'wyy'})
t[3][0] = 555
t[4][0] = 'aaa'

print(t,type(t))
(1, 1.1, 'zyl', [555, 222], {'name': 'wyy', 0: 'aaa'}) <class 'tuple'>
（參考深淺拷貝）

類型轉換：
print(tuple("hellp"))
print(tuple([1,2,3]))
print(tuple({"a":111,"b":222}))

('h', 'e', 'l', 'l', 'p')
(1, 2, 3)
('a', 'b')

內置方法

# 查長度
len（）

# 索引取值
t = ('zyl', 'wyy', 'yy', 'zz')
print(t[0])
zyl

# 切片（顧頭不顧尾，步長）
t = ('zyl', 'wyy', 'yy', 'zz')
print(t[1:3:2])
('wyy',)

# 成員運算
t = ('zyl', 'wyy', 'yy', 'zz')
print('zyl' in t)   # zyl在不在t元組中
True

# 循環
t = ('zyl', 'wyy', 'yy', 'zz')
for name in t:
    print(name)
    
zyl
wyy
yy
zz

# count() 查看列表中元素出現的次數
t = ('zyl', 'wyy', 'yy', 'zz')
print(t.count('zyl'))
1

# index() 查找列表中元素所在的索引。沒有報錯
t = ('zyl', 'wyy', 'yy', 'zz')
print(t.index('zyl'))
0

字典類型

字典類型：

# 做用：存信息，好比年齡，姓名，體重等

# 定義{}內用逗號分隔開多個key：value，其中value可使任意類型，可是key必須是不可變類型
d = {"age":18}
print(d['age'])

18

d ={}  默認定義出來的是空字典

# 數據類型轉換
# 一、按key存取值：可存可取
# 1.1 取
>>> dic = {
    	'name': 'xxx',
    	'age': 18,
     	'hobbies': ['play game', 'basketball']
 	}
>>> dic['name']
'xxx'
>>> dic['hobbies'][1]
'basketball'

# 1.2 對於賦值操做，若是key原先不存在於字典，則會新增key:value
>>> dic['gender'] = 'male'  
>>> dic{'name': 'xxx', 'age': 18, 'hobbies': ['play game', 'basketball'],'gender':'male'}

# 1.3 對於賦值操做，若是key原先存在於字典，則會修改對應value的值
>>> dic['name'] = 'zyl'
>>> dic{'name': 'zyl', 'age': 18, 'hobbies': ['play game', 'basketball']}


# 二、長度len
>>> len(dic) 
3


# 三、成員運算in和not in
>>> 'name' in dic  # 判斷某個值是不是字典的key
True


# 四、刪除
>>> dic.pop('name')  # 經過指定字典的key來刪除字典的鍵值對
>>> dic{'age': 18, 'hobbies': ['play game', 'basketball']}


# 五、鍵keys()，值values()，鍵值對items()
>>> dic = {'age': 18, 'hobbies': ['play game', 'basketball'], 'name': 'xxx'}
# 獲取字典全部的key
>>> dict_keys = dic.keys()
>>> print(dict_keys)
dict_keys(['age', 'hobbies', 'name'])

# 獲取字典全部的value
>>> dic.values()
>>> dict_values = dic.values()
>>> print(dict_values)
dict_values(['xxx', 18, ['play game', 'basketball']])

# 獲取字典全部的鍵值對
>>> dic.items()
dict_items([('name', 'xxx'), ('age', 18), ('hobbies', ['play game', 'basketball'])])


# 六、循環
# 6.1 默認遍歷的是字典的key
>>> for key in dic:
...     print(key)
... 
age
hobbies
name
# 6.2 只遍歷key
>>> for key in dic.keys():
...     print(key)
... 
age
hobbies
name
# 6.3 只遍歷value
>>> for key in dic.values():
...     print(key)
... 
18
['play game', 'basketball']
xxx
# 6.4 遍歷key與value
>>> for key in dic.items():
...     print(key)
... 
('age', 18)
('hobbies', ['play game', 'basketball'])
('name', 'xxx')

1.get()
>>> dic= {'k1':'zyl','k2':'wyy','k3':'yy'}
>>> dic.get('k1')
'zyl'  # key存在，則獲取key對應的value值
>>> res=dic.get('xxx') # key不存在，不會報錯而是默認返回None
>>> print(res)
None  
>>> res=dic.get('xxx',666) # key不存在時，能夠設置默認返回的值
>>> print(res)
666 
# ps:字典取值建議使用get方法

2.pop()
>>> dic= {'k1':'zyl','k2':'wyy','k3':'yy'}
>>> v = dic.pop('k2')  # 刪除指定的key對應的鍵值對,並返回值
>>> print(dic)
>>> print(v)
>>> {'k1': 'zyl', 'k3': 'yy'}
>>> wyy



3.popitem()
>>> dic= {'k1':'zyl','k2':'wyy','k3':'yy'}
>>> item = dic.popitem()  # 隨機刪除一組鍵值對,並將刪除的鍵值放到元組內返回
>>> print(dic)
>>> print(item)
{'k1': 'zyl', 'k2': 'wyy'}
('k3', 'yy')


4.update()
# 用新字典更新舊字典，有則修改，無則添加
>>> dic= {'k1':'zyl','k2':'wyy','k3':'yy'}
>>> dic.update({'k1':'zy','k4':'xxx'})
{'k1': 'zy', 'k2': 'wyy', 'k3': 'yy', 'k4': 'xxx'}

5.fromkeys()
>>> dic = dict.fromkeys(['k1','k2','k3'],[])   # # 跟[]，則value值爲[],不跟，默認是None
>>> print(dic)
{'k1': [], 'k2': [], 'k3': []}

6.setdefault()
# key不存在則新增鍵值對，並將新增的value返回
>>> dic={'k1':111,'k2':222}
>>> res=dic.setdefault('k3',333)
>>> print(res)
333
>>> print(dic) # 字典中新增了鍵值對
{'k1': 111, 'k2': 222, 'k3': 333,}

# key存在則不作任何修改，並返回已存在key對應的value值
>>> dic={'k1':111,'k2':222}
>>> res=dic.setdefault('k1',666)
>>> print(res)
111
>>> print(dic) # 字典不變
{'k1': 111, 'k2': 222}

集合類型

集合也能夠存放多個值，但主要用於：去重、關係運算
"""
定義：在{}內用逗號分隔開多個元素，集合具有如下三個特色：
     1：每一個元素必須是不可變類型
     2：集合內沒有重複的元素
     3：集合內元素無序
"""
s = {1,2,3,4}  # 本質 s = set({1,2,3,4})
""""""
注意1：列表類型是索引對應值，字典是key對應值，都可以取得單個指定的值，而集合類型既沒有索引也沒有key與值對應，因此沒法取得單個的值，並且對於集合來講，主要用於去重與關係元素，根本沒有取出單個指定值這種需求。

注意2:{}既能夠用於定義dict，也能夠用於定義集合，可是字典內的元素必須是key:value的格式，如今咱們想定義一個空字典和空集合，該如何準確去定義二者?
d = {} # 默認是空字典 
s = set() # 這纔是定義空集合

""""""
# 類型轉換

但凡能被for循環的遍歷的數據類型（強調：遍歷出的每個值都必須爲不可變類型）均可以傳給set()轉換成集合類型
>>> s = set([1,2,3,4])
>>> s1 = set((1,2,3,4))
>>> s2 = set({'name':'zyl',})
>>> s3 = set('zyl')
>>> s,s1,s2,s3
{1, 2, 3, 4} {1, 2, 3, 4} {'name'} {'z', 'y', 'l'}

# 關係運算
咱們定義兩個集合friends與friends2來分別存放兩我的的好友名字，而後以這兩個集合爲例講解集合的關係運算
friends1 = {"zyl","wyy","yy","zz"}
friends2 = {"fzf","zht","yy","zz"}

# 1.合集(|)：求兩個用戶全部的好友（重複好友只留一個）
print(friends1 | friends2)
{'yy', 'fzf', 'zht', 'wyy', 'zz', 'zyl'}

# 2.交集(&)：求兩個用戶的共同好友
print(friends1 & friends2)
{'yy', 'zz'}

# 3.差集(-)：
print(friends1 - friends2)   # friends1獨有的好友
{'zyl', 'wyy'}
print(friends2 - friends1)   # friends2獨有的好友
{'zht', 'fzf'}

# 4.對稱差集(^) # 去掉共有的好友
print(friends1 ^ friends2)
{'fzf', 'zyl', 'wyy', 'zht'}

# 5.值是否相等(==)
print(friends1 == friends2)
False

# 6.父集：一個集合是否包含另一個集合
# 6.1 包含則返回True
print({1,2,3} > {1,2})
True
# 6.2 不存在包含關係，則返回False
print({1,2,3} > {1,3,4,5})
False

# 7.子集
print({1,2} < {1,2,3})
True
print({1,2} <= {1,2,3})
True

集合去重

# 1. 只能針對不可變類型
# 2. 集合自己是無序的，去重以後沒法保留原來的順序

例如：
l = ['a', 'b', 1, 'a', 'a']
s=set(l)     # 將列表轉成了集合   
print(s)
{1, 'a', 'b'}    # 將重複的a去除，排列無序 

l_new=list(s) # 再將集合轉回列表
print(l_new)     
['b', 'a', 1]     # 去除了重複，可是打亂了順序

# 針對不可變類型，而且保證順序則須要咱們本身寫代碼實現，例如
l=[
    {'name':'zyl','age':18,'sex':'male'},
    {'name':'wyy','age':16,'sex':'male'},
    {'name':'yy','age':20,'sex':'female'},
    {'name':'aa','age':18,'sex':'male'},
    {'name':'aa','age':18,'sex':'male'},
]

new_l=[]

for dic in l:
    if dic not in new_l:
        new_l.append(dic)

print(new_l)
[{'name': 'zyl', 'age': 18, 'sex': 'male'}, 
{'name': 'wyy', 'age': 16, 'sex': 'male'}, 
{'name': 'yy', 'age': 20, 'sex': 'female'}, 
{'name': 'aa', 'age': 18, 'sex': 'male'}]

# 結果：既去除了重複，又保證了順序，並且是針對不可變類型的去重