7. 基本数据类型的内置方法(列表、元组、布尔、字典、集合)
1. 列表的内置方法
1.1 优先掌握的内置方法
1.1.1 强制类型转换
可以将可迭代类型转换为列表类型
print(list('messi')) # ['m', 'e', 's', 's', 'i'] print(list((1, 2, 3))) # [1, 2, 3] print(list({4, 5, 6})) # [4, 5, 6]
list方法在强制转换字典的时候默认转换出来的是字典的键
print(list({'name': 'messi', 'goals': 91})) # ['name', 'goals']
强调：列表转换成字符串之后无法再重新转回列表
1.1.2 索引取值
正向索引/负向索引
1.1.3 切片
与字符串切片方法一样
列表[起始索引：终止索引：步长]
a = ['messi', 'ronaldo', 'neymar', 'kylian', 'haaland'] print(a[0:3]) # ['messi', 'ronaldo', 'neymar'] print(a[0:3:2]) # ['messi', 'neymar'] # 将列表顺序翻转 print(a[::-1]) # ['haaland', 'kylian', 'neymar', 'ronaldo', 'messi']
1.1.4 计算长度
len
1.1.5 成员运算
in / not in
判断某个元素是否在当前列表中
1.1.6 向列表中添加元素
方式一：添加在列表结尾
a = [1, 2, 3] a.append(4) print(a) # [1, 2, 3, 4]
方式二：插入到指定的索引位置
a = [1, 2, 3] a.insert(0, 'messi') print(a) # ['messi', 1, 2, 3]
方式三：将两个列表整合到一起（扩展列表）
# for循环将两个列表整合到一起 a = [1, 2, 3] b = [4, 5, 6] for i in b: a.append(i) print(a) # [1, 2, 3, 4, 5, 6]
# extend方法将两个列表整合到一起 a = ['messi', 'neymar', 'ronaldo'] b = [1, 2, 3] a.extend(b) print(a) # ['messi', 'neymar', 'ronaldo', 1, 2, 3]
1.1.7 删除列表中的元素
方式一：按照指定的值删除指定的元素remove
a = ['messi', 'neymar', 'ronaldo', 'kylian', 'haaland'] print(a.remove('messi')) # None 没有返回值 print(a) # ['neymar', 'ronaldo', 'kylian', 'haaland']
方式二：弹出指定元素pop
a = [1, 2, 3, 4, 5, 6] # 默认弹出最后一个元素 print(a.pop()) # 6 有返回值 print(a) # [1, 2, 3, 4, 5] # 弹出指定索引对应的元素 print(a.pop(2)) # 3 有返回值 print(a) # [1, 2, 4, 5]
方式三：删除指定索引对应的元素del
a = [1, 2, 3, 4, 5, 6] del a[2] # 不能返回，使用print会报错 print(a) # [1, 2, 4, 5, 6]
方式四：将列表清空clear
a = [1, 2, 3] a.clear() print(a) # []
1.1.8 翻转元素，作用在原列表reverse
a = [1, 2, 3, 4, 5, 6]
# 使用通用方法翻转
print(a[::-1]) # [6, 5, 4, 3, 2, 1]
print(a) # [1, 2, 3, 4, 5, 6] 原列表没有得到改变
# 使用reverse方法翻转
print(a.reverse()) # None 没有返回值
print(a) # [6, 5, 4, 3, 2, 1] 原列表得到改变
1.1.9 对列表中的元素进行排序，作用在原列表sort
a = [2, 4, 5, 9, 1, 3, 8, 6, 7] # 默认的排序方式是正序 print(a.sort()) # None 没有返回值 print(a) # [1, 2, 3, 4, 5, 6, 7, 8, 9] # 给sort加上参数reverse b = [2, 4, 5, 9, 1, 3, 8, 6, 7] b.sort(reverse=True) print(b) # [9, 8, 7, 6, 5, 4, 3, 2, 1] 列表先正序，后翻转 c = [2, 4, 5, 9, 1, 3, 8, 6, 7] c.sort(reverse=False) print(c) # [1, 2, 3, 4, 5, 6, 7, 8, 9]
# 补充方法：sorted(列表)，把列表当参数而不是调用
d = [2, 4, 5, 9, 1, 3, 8, 6, 7]
print(sorted(d)) # [1, 2, 3, 4, 5, 6, 7, 8, 9] 有返回值
print(d) # [2, 4, 5, 9, 1, 3, 8, 6, 7]
总结：
sort 使用方法：列表.sort() 没有返回值 作用在原列表
sorted 使用方法：sorted(列表) 有返回值 不会作用在原列表
1.1.10 列表遍历循环
for循环
while循环
2. 元组的内置方法
回顾：
一个元素的元组要加，逗号
不加逗号变成了元素原本的类型
在定义字符串或者其它数据类型时加了，逗号就成了元组
2.1 强制类型转换
可以将可迭代类型转换成元组
2.2 索引取值
2.3 切片
[起始索引：结束索引：步长]
a = (1, 2, 3, 4, 5, 6)
print(a[1:3]) # (2, 3)
print(a[0:5:2]) # (1, 3, 5)
print(a[::-1]) # (6, 5, 4, 3, 2, 1)
sort方法是列表的排序方法，不是元组的
2.4 计算长度
len
2.5 成员运算
in / not in
2.6 遍历
for循环
while循环
2.7 元组拼接
a = (1, 2, 3)
b = (4, 5, 6)
# 方式一：元组.__add__(元组) 返回一个新的元组，不会作用在原来的元组
print(a.__add__((666,))) # (1, 2, 3, 666)
print(a) # (1, 2, 3)
# 方式二：使用 + 进行拼接
print(a + b) # (1, 2, 3, 4, 5, 6)
2.8 元组的重复
元组*数字 将当前元组的所有元素重复指定次数并产生新的元组
a = ('j', 'q', 'k')
print(a * 3) # ('j', 'q', 'k', 'j', 'q', 'k', 'j', 'q', 'k')
3. 布尔类型的内置方法
强制类型转换 bool()
在python中为假的情况：
1. 布尔值False
2. 数字0
3. 空的其它类型
print(bool(False), type(bool(False))) # False <class 'bool'>
print(bool(0), type(bool(0))) # False <class 'bool'>
print(bool('')) # False
print(bool([])) # False
print(bool(())) # False
print(bool({})) # False
其它情况均为真：
1. 布尔值True
2. 数字1
3. 有值的其它类型，空格也算字符串也算有值
print(bool(True)) # True
print(bool(1)) # True
print(bool(['a'])) # True
print(bool(' ')) # True
4. 字典的内置方法
字典中的键必须是不可变的，通常使用字符串、数字、布尔值作为键
字典中的值可以是任意类型，包括数字、字符串、列表、字典等
4.1 取值
# （1）字典[key]
# 这种方法取字典中没有的键会报错
a = {'name': 'kylian', 'id': 9, 'country': 'France', True: 'psg'}
print(a['id']) # 9
print(a[True]) # psg
# （2）字典.get(键)
print(a.get('name')) # kylian
print(a.get('hobby')) # 如果字典中没有当前的键，返回的就是None
print(a.get('hobby', 'goat')) # goat 没有键取不到值可以指定默认值
4.2 计算长度
len 计算字典中的键值对个数
4.3 成员运算
判断某个键是否在字典中，而不是某个值
print('name' in a) # True
print('kylian' in a) # False
4.4 增加元素
字典的特性：有则添加，无则修改
（1）方式一：字典[key] = value
a = {'name': 'kylian', 'id': 9, 'country': 'France'}
a['club1'] = 'psg'
print(a) # {'name': 'kylian', 'id': 9, 'country': 'France', 'club1': 'psg'}
（2）方式二：字典.update({key:value})
a = {'one': 1, 'two': 2, 'three': 3}
b = {'four': 4, 'five': 5, 'six': 6}
# 遍历字典b，添加到字典a中
for i in b:
a[i] = b[i]
print(a) # {'one': 1, 'two': 2, 'three': 3, 'four': 4, 'five': 5, 'six': 6}
（3）方式三：字典.update(key=value)
以上使用=的方式i是一个固定的值，以下使用键值对的形式i可随遍历而改变
（4）方式四：字典.update(字典)
m = {'a': 1, 'b': 2, 'c': 3}
n = {'d': 4, 'e': 5, 'f': 6}
m.update(n)
print(m) # {'a': 1, 'b': 2, 'c': 3, 'd': 4, 'e': 5, 'f': 6}
相比于方式二for循环遍历增加一个字典所有元素，方式四代码更简洁
（5）方式五：setdefault(key, value)
向字典中设置当前键对应的默认值
setdefault(key，value)方法用于获取指定键的值；如果键不存在，则返回默认值，并在字典中添加新键值对；如果键存在，则返回键原本对应的值
4.5 删除元素
info = {'name': 'kylian', 'id': 9, 'club': 'psg', 'goal': 91}
# 方式一：del字典[key] 按照键删除字典对应的键值对
del info['club'] # 没有返回值，不能用变量接收
print(info) # {'name': 'kylian', 'id': 9, 'goal': 91}
# 方式二：字典.pop(key) 按照键删除字典对应的键值对弹出
res = info.pop('id')
print(res) # 9 相比于方式一有返回值，且可以用变量接收
print(info) # {'name': 'kylian', 'goal': 91}
# 方式三：清空字典
info.clear()
print(info) # {}
# 方式四：弹出最后一个位置的键值对
info = {'name': 'kylian', 'id': 9, 'club': 'psg', 'goal': 91}
res = info.popitem()
print(res) # ('goal', 91)
print(info) # {'name': 'kylian', 'id': 9, 'club': 'psg'}
4.6 取出字典中所有的键、所有的值、所有的键值对
info = {'a': '1', 'b': 2, 'c': 3}
# （1）获取字典中所有的键
print(info.keys())
# dict_keys(['a', 'b', 'c']) 可以看成是列表，可以用for循环取出
print(type(info.keys())) # <class 'dict_keys'>
# （2）获取字典中所有的值
print(info.values())
# dict_values(['1', 2, 3]) 可以看成是列表
# （3）获取字典中所有的键值对
print(info.items())
# dict_items([('a', '1'), ('b', 2), ('c', 3)]) 可以看成是列表嵌套元组
for k, v in info.items():
print(k) # a b c
print(v) # 1 2 3
5. 集合的内置方法
集合的特点是无序且去重
5.1 强制类型转换
print(set('messi'))
# {'e', 'm', 's', 'i'}
print(set([1, 2, 3]))
# {1, 2, 3}
print(set(('j', 'q', 'k')))
# {'q', 'k', 'j'}
print(set({'a': 11, 'b': 22, 'c': 33}))
# {'c', 'a', 'b'}
5.2 添加元素
a = {1, 2, 3, 4, 5}
# 添加单个元素
print(a.add(6)) # None
print(a) # {1, 2, 3, 4, 5, 6}
# 一次添加多个元素
a.update((11, 22, 33)) # 只能是可迭代类型
print(a) # {1, 2, 3, 4, 5, 6, 11, 22, 33}
5.3 删除元素
# 方式二：pop
# 集合的pop默认弹出第一个元素，而列表的pop默认弹出最后一个元素
b = {'messi', 'ronaldo', 'neymar', 'kylian'}
print(b.pop()) # messi 索引为0的位置
print(b) # {'ronaldo', 'neymar', 'kylian'}
5.4 其它方法
计算长度len
遍历循环for
成员运算 in / not in
