列表、元组、字典、集合类型的内置方法

​ 又是美好一周的开始，上周还处在学习python的适应期，虽说还没有完全适应，但这周开始得加强学习力度了，我要更加投入。今天学的内置方法比较多，需要多用多练习才能记住。

一、列表类型内置方法

1、作用：

表示多个姓名、多个爱好、多门课程等

2、定义方式：

[]内用逗号分隔开多个任意数据类型的元素

3、内置方法：

优先掌握

1、按索引取值（正向取值和反向取值），既可存也可取

name_list=['yujin','xuchu','dianwei','xiahoudun']
name_list[1]='zyl'   # 存：把xuchu换成了zyl
print(name_list)     # ['yujin', 'zyl', 'dianwei', 'xiahoudun']
print(f"{name_list[1]}")  # 取：zyl 

2、切片

name_list=['yujin','xuchu','dianwei','xiahoudun']
print(name_list[0:4:2])  # ['yujin', 'dianwei'],2为取值长度，即在首个索引序号加2 
print(name_list[::-1]) # -1为从右到左反向取值，取值长度为1

3、len（长度）

name_list=['yujin','xuchu','dianwei','xiahoudun']
print(len(name_list))  # 结果为4

4、in/not in(成员运算)

用于判断，输出结果为True或False

name_list=['yujin','xuchu','dianwei','xiahoudun']
print('houyi'in name_list)      # False
print('houyi'not in name_list)  # True

5、for循环

name_list=['yujin','xuchu','dianwei','xiahoudun']
for name in name_list:
    print(name)  # 挨个取值，逐行法印列表中的每个元素

6、append（追加）

在列表中最后一个元素后面添加

name_list=['yujin','xuchu','dianwei','xiahoudun']
name_list.append('xiahouyuan') # 把'xiahouyuan'追加在'xiahoudun'后面
print(name_list)  # ['yujin', 'xuchu', 'dianwei', 'xiahoudun', 'xiahouyuan']

7、del （删除）

name_list=['yujin','xuchu','dianwei','xiahoudun']
del name_list[1]  # 删除索引序号为1的值，即删除'xuchu'
print(name_list)  # ['yujin', 'dianwei', 'xiahoudun']

需要掌握

1、count() （对列表内的某个元素计数）

name_list=['yujin','xuchu','dianwei','xiahoudun','xuchu']
print(name_list.count('xuchu'))  # xuchu的计数为2

2、pop() （默认删除列表内最后一个元素）

name_list=['yujin','xuchu','dianwei','xiahoudun']
print(name_list.pop()) # 打印删除的元素，默认删除最后一个元素xiahoudun
print(name_list)       # ['yujin', 'xuchu', 'dianwei']
print(name_list.pop(1)) # 也可以删除指定索引序号对应的元素，删除xuchu
print(name_list)       # ['yujin', 'dianwei']

3、remove() （移除）

name_list=['yujin','xuchu','dianwei','xiahoudun']
name_list.remove('dianwei') # 移除dianwei，直接print(name_list.remove('dianwei'))的话，打印结果为None
print(name_list)            # ['yujin', 'xuchu', 'xiahoudun']

4、insert() （插入，在指定的索引序号对应的值前面插入一个元素）

name_list=['yujin','xuchu','dianwei','xiahoudun']
name_list.insert(2,'xingtian')  # 在dianwei前插入xingtian
print(f"name_list:{name_list}")   # name_list:['yujin', 'xuchu', 'xingtian', 'dianwei', 'xiahoudun']

5、index() （索引） 打印结果必为查找的列表中值得索引序号

name_list=['yujin','xuchu','dianwei','xiahoudun']
print(name_list.index('xuchu'))  # 打印xuchu的索引序号：1
print(name_list.index('dianwei',1,3))  # 在索引序号1~3之间查找有没有'dianwei'这个值，打印结果为该值的索引序号，不能索引列表内没有的值

6、clear()（清除）基本不会用到

name_list=['yujin','xuchu','dianwei','xiahoudun']
name_list.clear()  # 清除列表中所有值
print(f"name_list:{name_list}")   # name_list:[]

7、copy() （复制）

name_list=['yujin','xuchu','dianwei','xiahoudun']
print(name_list.copy())  # 复制列表，['yujin', 'xuchu', 'dianwei', 'xiahoudun']

8、extend() （扩展列表）

name_list=['yujin','xuchu','dianwei','xiahoudun']
name_list2=['xiahouyuan','xuhuang','zhanghe']
name_list.extend(name_list2)  # 在第一个列表最后一个元素后面加上第二个列表，来扩展第一个列表
print(name_list) # ['yujin', 'xuchu', 'dianwei', 'xiahoudun', 'xiahouyuan', 'xuhuang', 'zhanghe']

9、reverse() （反转）

name_list=['yujin','xuchu','dianwei','xiahoudun']
name_list.reverse() # 把列表中元素的顺序从后往前反转
print(name_list)    # ['xiahoudun', 'dianwei', 'xuchu', 'yujin']

10、sort() （排序）使用sort排序的列表中的元素必须是同类型的

name_list=['yujin','xuchu','dianwei','xiahoudun']
name_list.sort()  # 列表中的元素按首字母的顺序从前往后排序，首字母相同的按第二个字母排序
print(name_list)  # ['dianwei', 'xiahoudun', 'xuchu', 'yujin']

s=[1,5,3,4,2]
s.sort()
print(s)  # [1, 2, 3, 4, 5]

4、存一个值还是多个值：多个值

5、有序or无序：有序

6、可变or不可变：可变

 lis = [1, 1, 2, 3, 4, 5]
 lis2 = []
 for i in lis.copy():
     if lis.count(i) == 1:
         lis2.append(i)

二、元组类型内置方法

元祖和列表一模一样,但是元祖无法修改,元祖在定义那一刻他的元素个数以及元素的值全部固定了

1、元组和列表的区别

列表可变的原因是：索引所对应的值的内存地址是可以改变的

元组不可变得原因是：索引所对应的值的内存地址是不可以改变的，或者反过来说，只要索引对应值的内存地址没有改变，那么元组是始终没有改变的

2、定义方式：把列表的[]改成()

3、内置方法：只有index()和count()

tup = (1,2,3,4)
print(tup.index(1))  # 打印0，1的索引序号为0
print(tup.count(1))  # 打印1, 1的计数为1

4、存一个值还是多个值：多个值

5、有序or无序（有序：也就是有索引，无序：无索引）：有序

6、可变or不可变：不可变

三、字典类型内置方法

1、作用：

对于值添加描述信息时使用，存多个值，但每一个值都有一个key与之对应，key对值有描述功能。多用于存的值表示的是不同的状态时，例如存的值有姓名、年龄、身高、体重、爱好

2、定义方式：

{}内用逗号分隔开多个元素，每一个元素都是key：value的形式，value可以是任意数据类型，而key通常应该是字符串类型，但是key必须为不可变类型

info_dict={'name':'zyl','age':25,'height':178,'hobby_list':['music','basketball','game']}

3、内置方法：

优先掌握

1、按key存取值，既可存也可改变

info_dict={'name':'zyl','age':25,'height':178,'hobby_list':['music','basketball','game']}
print(info_dict['hobby_list'])  # ['music', 'basketball', 'game']
info_dict['height']=183
print(info_dict)  # {'name': 'zyl', 'age': 25, 'height': 183, 'hobby_list': ['music', 'basketball', 'game']}   身高height的值就由178改为了183

2、len （长度）

info_dict={'name':'zyl','age':25,'height':178,'hobby_list':['music','basketball','game']}
print(len(info_dict))      # 该字典长度为4

3、in/not in(成员运算) 跟列表一样用于判断，输出结果为True或False

info_dict={'name':'zyl','age':25,'height':178,'hobby_list':['music','basketball','game']}
print('age'in info_dict)    # True

4、删除

• dict中删除之del

  info_dict={'name':'zyl','age':25,'height':178,'hobby_list':['music','basketball','game']}
  del info_dict['age']  # 删除列表中的key值为‘age’的元素
  print(info_dict)  # 原列表变为{'name': 'zyl', 'height': 178, 'hobby_list': ['music', 'basketball', 'game']}

• dict中删除之pop()

info_dict={'name':'zyl','age':25,'height':178,'hobby_list':['music','basketball','game']}
info_dict.pop('height')   # 指定删除key值为‘height’的元素
print(info_dict)  # {'name': 'zyl', 'age': 25, 'hobby_list': ['music', 'basketball', 'game']}

• del中删除之popitem()

早期的时候字典是无序的,是随机删除的,但是由于python3底层优化了字典,让字典看的貌似有序了,所以默认删除字典中最后一个键值对

info_dict={'name':'zyl','age':25,'height':178,'hobby_list':['music','basketball','game']}
print(info_dict.popitem())  # 默认删除最后一个元素('hobby_list', ['music', 'basketball', 'game'])

5、for循环 可以逐行打印想要的结果

info_dict={'name':'zyl','age':25,'height':178,'hobby_list':['music','basketball','game']}
for k,v in info_dict.items():     # items(键值对)可以换成keys()、values()
    print(k,v)  # name zyl
                # age 25
                # height 178
                # hobby_list ['music', 'basketball', 'game']

6、键keys()、值values()、键值对items() （items用的最多,一般和解压缩一起用)

info_dict={'name':'zyl','age':25,'height':178,'hobby_list':['music','basketball','game']}
print(info_dict.keys())   # 取出的是key值得元组，dict_keys(['name', 'age', 'height', 'hobby_list'])
print(list(info_dict.keys()))  # 取出的是key值得列表，['name', 'age', 'height', 'hobby_list']
print(info_dict.values())  # 取出value值得元组，dict_values(['zyl', 25, 178, ['music', 'basketball', 'game']])
print(info_dict.items())   # 取出键值对的元组，dict_items([('name', 'zyl'), ('age', 25), ('height', 178), ('hobby_list', ['music', 'basketball', 'game'])])

for i in info_dict.values():
    print(i)   # 逐行打印value值
for i in info_dict.items():
    print(i)   # 逐行打印每个键值对的元组
    

需要掌握

1、get() 括号内为key，如果有,就返回key对应的值;如果没有,默认返回None

info_dict={'name':'zyl','age':25,'height':178}
print(info_dict.get('name'))   # 找到有name，就返回name的值zyl
print（info_dict.get('weight') # 没有weight，返回None

2、setdefault() 有指定key不会改变值；无指定key则改变值；可以用来解决重复赋值

info_dict={'name':'zyl','age':25,'height':178}
print(info_dict.setdefault('name','dianwei'))  # 字典中有name，就返回name对应的值zyl
print(info_dict.setdefault('name1','dianwei'))  # 没有name1，输出指定的值dianwei
print(info_dict)  # 会在原字典中加入name1的键值对，{'name': 'zyl', 'age': 25, 'height': 178, 'name1': 'dianwei'}

3、update() 更新，在字典最后一个元素后面加入

info_dict={'name':'zyl','age':25,'height':178}
dict={'weight':'160'}
info_dict.update(dict) # 在info_dict字典的最后面加入dict中的键值对元素
print(info_dict)    # {'name': 'zyl', 'age': 25, 'height': 178, 'weight': '160'}

4、fromkeys() 由dict.出来,快速造一个字典

dic=dict.fromkeys(['name','age','height'],'zhanshen')  # 造一个字典，括号内列表中每个元素作为key，把zhanshen作为每个key的value值
print(dic)  # {'name': 'zhanshen', 'age': 'zhanshen', 'height': 'zhanshen'}

4、存一个值还是多个值：多个值，值可以是多个类型，key必须是不可变类型，通常应该是不可变类型中的字符串类型

5、有序or无序：无序

6、可变or不可变：可变

四、集合类型内置方法

1、作用：

用于关系运算的集合体，由于集合内的元素无序且集合元素不可重复，因此集合可以去重，但是去重后的集合会打乱原来元素的顺序。

2、定义方式：

{}内用逗号分隔开多个元素，每个元素必须是不可变类型

s = {1, 2, 1, 'a', 'a', 'c'}
print(s)

s = {} 空大括号是字典，不是集合，定义空集合必须得用set()

3、内置方法：

*优先掌握

1、len（长度）

2、in/not in（成员运算）

3、|（竖杠） 或者union（并集） 把两个集合合并起来，重复的元素在输出的集合中只有一个

pythoners = {'jason', 'nick', 'tank', 'sean'}
linuxers = {'nick', 'egon', 'kevin'}

print(f"pythoners|linuxers: {pythoners|linuxers}")
print(f"pythoners.union(linuxers): {pythoners.union(linuxers)}")

输出：pythoners | linuxers: {'egon', 'tank', 'kevin', 'jason', 'nick', 'sean'}
pythoners.union(linuxers): {'egon', 'tank', 'kevin', 'jason', 'nick', 'sean'}

4、& 或 intersection （交集） 找到两个集合中重复的元素

pythoners = {'jason', 'nick', 'tank', 'sean'}
linuxers = {'nick', 'egon', 'kevin'}

print(f"pythoners&linuxers: {pythoners&linuxers}")
print(f"pythoners.intersection(linuxers): {pythoners.intersection(linuxers)}")

输出：pythoners&linuxers: {'nick'}
pythoners.intersection(linuxers): {'nick'}

5、- 或 difference （差集） a-b，在集合a中去掉与集合b重复的元素

pythoners = {'jason', 'nick', 'tank', 'sean'}
linuxers = {'nick', 'egon', 'kevin'}

print(f"pythoners-linuxers: {pythoners-linuxers}")
print(f"pythoners.difference(linuxers): {pythoners.difference(linuxers)}")

输出：pythoners-linuxers: {'tank', 'jason', 'sean'}
pythoners.difference(linuxers): {'tank', 'jason', 'sean'}

6、== 用于判断两个集合中的元素是否一样，返回结果为True或False

7、^ 或symmetic_difference (对称差集) 把两个集合合并起来并去掉重复的元素

pythoners = {'jason', 'nick', 'tank', 'sean'}
linuxers = {'nick', 'egon', 'kevin'}

print(f"pythoners^linuxers: {pythoners^linuxers}")
print(
    f"pythoners.symmetric_difference(linuxers): {pythoners.symmetric_difference(linuxers)}")

输出：pythoners^linuxers: {'egon', 'tank', 'kevin', 'jason', 'sean'}
pythoners.symmetric_difference(linuxers): {'egon', 'tank', 'kevin', 'jason', 'sean'}

8、>、>=、issuperset (父集) 判断前者是否是后者的父集，返回结果为True或False

9、<、<=、issubset （子集） 判断前者是否是后者的子集，返回结果为True或False

10、add() 按顺序加入

s = {1, 2, 'a'}
s.add(3)
print(s)   # {1, 2, 3, 'a'}

需要掌握

1、remove()（移除）

s = {1, 2, 'a'}
s.remove(1)
print(s)  # {2, 'a'}

2、difference_update() 把前者在后者中相同的元素更新掉，即去掉

pythoners = {'jason', 'nick', 'tank', 'sean'}
linuxers = {'nick', 'egon', 'kevin'}
pythoners.difference_update(linuxers)
print(f"pythoners.difference_update(linuxers): {pythoners}")  
 # pythoners.difference_update(linuxers): {'tank', 'jason', 'sean'}

3、update() 把后一个集合中的元素更新到前一个集合中，并去掉重复的

4、discard() 删除元素，元素在集合中就删除，不在就不变，也不报错，remove要删除的元素找不到的话会报错

5、isdisjoint() 判断两个集合有没有共同的部分，没有返回True，有返回False

4、存一个值还是多个值：多个值，且值为不可变类型

5、有序or无序：无序

6、可变or不可变：可变

​ 学习总结的时间花费太长了，效率太低了，还得多加锻炼