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

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

列表类型内置方法：

按索引取值及赋值及切片取值

my_hobby_list = ['dancing', 'reading', 'coding', 'cooking']
print(my_hobby_list[2])
print(my_hobby_list[2:])
print(my_hobby_list[-1:1:-1])
my_hobby_list[3] = 'eating'
print(my_hobby_list)

长度

my_hobby_list = ['dancing', 'reading', 'coding', 'cooking']
print(len(my_hobby_list))

成员运算

my_hobby_list = ['dancing', 'reading', 'coding', 'cooking']
print('gaming' in my_hobby_list)
print('cooking' not in my_hobby_list)

追加值

my_hobby_list = ['dancing', 'reading', 'coding', 'cooking']
if True:
    my_hobby_list.append('drinking')
print(my_hobby_list)

删除

my_hobby_list = ['dancing', 'reading', 'coding', 'cooking']
del my_hobby_list[3]
print(my_hobby_list)
del my_hobby_list

循环

my_hobby_list = ['dancing', 'reading', 'coding', 'cooking']
for i in my_hobby_list:
    print(i)

其他常用方法

my_hobby_list = ['dancing', 'reading', 'coding', 'cooking']
# insert  根据索引，插入
my_hobby_list.insert(0, 'where is me')
print(my_hobby_list)
# pop  删除，若无指定索引，默认删除最后一个
my_hobby_list.pop()
my_hobby_list.pop(0)
print(my_hobby_list)
# remove  根据内容而不是索引删除
my_hobby_list.remove('dancing')
print(my_hobby_list)
# count  计数，返回某成员出现次数
my_hobby_list.append('apple')
my_hobby_list.append('apple')
print(my_hobby_list)
print(my_hobby_list.count('apple'))
# index  索引，返回某成员第一次出现的索引
print(my_hobby_list.index('apple'))
print(my_hobby_list.index('coding'))
# clear  清除列表数据
my_hobby_list.clear()
print(my_hobby_list)
# copy  复制列表
my_new_hobby_list = ['apple', 'banana', 'cherry', 'dog', 'english']
copy_list = my_new_hobby_list.copy()
print(copy_list)
print(id(copy_list))
print(id(my_new_hobby_list))
my_new_hobby_list[4] = 'Deutsch'
print(copy_list)
print(my_new_hobby_list)
print(id(my_hobby_list))
my_hobby_list = my_new_hobby_list.copy()
print(id(my_hobby_list))
# extend  把一个列表内容扩展到另一个列表的后面
my_new_hobby_list.extend(copy_list)
print(my_new_hobby_list)
# reverse  反转列表的内容
print(my_hobby_list)
my_hobby_list.reverse()
print(my_hobby_list)
# sort  排序，但数据内容必须是同一种类型
print(my_new_hobby_list)
my_new_hobby_list.sort(reverse=False)
print(my_new_hobby_list)
my_new_hobby_list.sort(reverse=True)
print(my_new_hobby_list)

元组的内置方法

hobby_tuple = ('apple', 'boy', 'girl', 'working')
# 索引取值
print(hobby_tuple[0])
print(hobby_tuple[-1])
# 切片（顾头不顾尾，步长）
print(hobby_tuple[1:])
print(hobby_tuple[::-1])
# 长度len
print(len(hobby_tuple))
# 成员运算in和not in
print('apple' in hobby_tuple)
print('banana' not in hobby_tuple)
# 循环
for i in hobby_tuple:
    print(i)
# count
print(hobby_tuple.count('girl'))
# index
print(hobby_tuple.index('girl'))

字典类型的方法

优先需要掌握的方法

catching_dict = {'a': 'apple',
                 'b': 'butterfly',
                 'c': 'character',
                 'd': 'document',
                 'e': 'email',
                 'f': 'first'}

# 按key存取值：可存可取
print(catching_dict['c'])
catching_dict['c'] = 'car'
print(catching_dict['c'])
# 长度len
print(len(catching_dict))
# 成员运算in和not in
print('a' in catching_dict)
print('car' in catching_dict.values())
print('d' in catching_dict.values())
# 删除del & pop  补充 get popitem
del catching_dict['a']
print(catching_dict)
catching_dict.pop('f')
print(catching_dict)
print(catching_dict.get('b'))
print(catching_dict.get('a'))
print(catching_dict)
catching_dict.popitem()
print(catching_dict)
# 键keys()、值values()、键值对items()
catching_dict['a'] = 'apple'
catching_dict['e'] = 'english'
print(catching_dict)
print(catching_dict.keys())
print(catching_dict.values())
print(catching_dict.items())
# 循环
for k, v in catching_dict.items():
    print(k, v)

需要掌握的其他方法

# get  通过KEY获取VALUE，如果KEY不存在，返回 None
print(catching_dict.get('a'))
print(catching_dict.get('b'))
print(catching_dict.get('c'))
print(catching_dict.get('z'))
# update  把一个字典的内容添加到另一个字典中
append_dict = {'z': 'zoo'}
catching_dict.update(append_dict)
print(catching_dict)
# fromkeys  用列表里的数据作为KEY，生成一字典
new_dict = dict.fromkeys(['apple', 'banana', 'cherry'], 'delicious')
print(new_dict)
# setdefault  加入一组键值对，若不存在，则添加，存在则不添加
new_dict.setdefault('apple', 'good')
new_dict.setdefault('zoo', 'tiger')
print(new_dict)

集合类型的内置方法

# 长度len
empty_set = set()
fruits_a_set = {'apple', 'banana', 'cherry', 'orange', 'lemon'}
fruits_b_set = {'cherry', 'orange', 'pear', 'watermelon'}
print(len(empty_set))
print(len(fruits_a_set))
print(len(fruits_b_set))
# 成员运算in和not in
print('cherry' in fruits_b_set)
print('apple' in fruits_b_set)
print('banana' not in fruits_a_set)
# |并集、union
print(fruits_a_set.union(fruits_b_set))
print(fruits_a_set | fruits_b_set)
# &交集、intersection
print(fruits_a_set.intersection(fruits_b_set))
print(fruits_a_set & fruits_b_set)
# -差集、difference
print(fruits_a_set - fruits_b_set)
print(fruits_b_set.difference(fruits_a_set))
# ^对称差集、symmetric_difference
print(fruits_a_set.symmetric_difference(fruits_b_set))
print(fruits_b_set ^ fruits_a_set)
# ==
print(fruits_a_set == fruits_b_set)
# 父集：>、>= 、issuperset
fruits_c_set = fruits_a_set - fruits_b_set
print(fruits_a_set >= fruits_c_set)
# 子集：<、<= 、issubset
print(fruits_c_set <= fruits_a_set)

# add
empty_set.add('peach')
print(empty_set)
# remove
empty_set.remove('peach')
print(empty_set)
# difference_update
print(fruits_a_set)
print(fruits_b_set)
fruits_a_set.difference_update(fruits_b_set)
print(fruits_a_set)
# discard
fruits_a_set.discard('zoo')
fruits_a_set.discard('apple')
print(fruits_a_set)
# isdisjoint
print(fruits_a_set)
print(fruits_b_set)
print(fruits_c_set)
print(fruits_a_set.isdisjoint(fruits_b_set))
print(fruits_a_set.isdisjoint(fruits_c_set))

数据类型总结

	单值/多值	可变/不可变*	有序/无序
数字	单值	不可变	无意义
字符串	单值	不可变	有序
列表	多值	可变	有序
元组	多值	不可变	有序
字典	多值	可变	无序
集合	多值	可变	无序