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'}]

# 结果：既去除了重复，又保证了顺序，并且是针对不可变类型的去重