python常用语句 Python常用的数据结构

一、list 列表1、列表的特点有序的，元素可以重复，列表中的元素可以进行增上改查，可以存放不同的数据类型
2、创建列表

中括号创建并填充 --->[]
通过构造函数创建 list()
列表推导式 ---> [x for x in li if x ...]

"""创建列表"""# 1、通过构造函数创建 list()li = list()print(li, type(li))li1 = list('helloworld')print(li1, type(li1))# 2、中括号创建并填充 []li2 = [1, 2, 3, 4, 4]li3 = ['helloworld', 'apple']li4 = [1, 3.4, True, 'tea', [1, 2, 3]]print(li2, type(li2))print(li3, type(li3))print(li4, type(li4))# 3、列表推导式li5 = [i for i in range(1, 10) if i % 2 == 0]print(li5, type(li5))3、列表索引

默认正向索引，编号从 0 开始。
支持反向索引，编号从-1 开始。

"列表索引"list1 = [1, 3, 5, 6, 8, 10]# 默认正向索引，编号从 0 开始。print(list1[0])print(list1[3])# 支持反向索引，编号从-1 开始。print(list1[-6])print(list1[-3])4、列表切片 [start:stop:step]

start 值: 指示开始索引值，如果没有指定，则默认开始值为 0；
stop 值: 指示到哪个索引值结束，但不包括这个结束索引值。如果没有指定，则取列表允许的最大索引值；
step 值: 步长值指示每一步大小，如果没有指定，则默认步长值为 1 。
【python常用语句 Python常用的数据结构】三个值都是可选的，非必填

li = ['h', 'o', 'g', 'w', 'a', 'r', 't', 's']print(li[2:4])print(li[3:6])print(li[2:7])print(li[2:])print(li[3:6:2])print(li[2:8:4])print(li[2:8:])print(li[2::])print(li[:2])print(li[::3])print(li[::-1])# 逆序打印5、列表运算符

重复
- 使用 * 运算符可以重复生成列表元素。
合并

使用 + 加号运算符，可以将两个列表合二为一

li1 = [1, 2] * 5li2 = [1, 2, 3]li3 = [1, 2, 4, 5]# 重复使用 `*` 运算符可以重复生成列表元素。print(li1)# 合并使用 `+` 加号运算符，可以将两个列表合二为一。print(li2 + li3)6、列表成员检测

in：检查一个对象是否在列表中，如果在则返回 True，否则返回 False 。
not in：检查一个列表是否不包含某个元素。如果不在返回 True，否则返回 False 。

li3 = [1, 2, 4, 5]print(1 in li3)print(6 not in li3)print(8 is li3)7、列表方法

append()

append(item)：将一个对象 item 添加到列表的末尾。入参：对象 item返回：None# append()list1 = []print(list1)list1.append(1)list1.append(3.14)list1.append("apple")print(list1)

extend()

extend(iterable)：将一个可迭代对象的所有元素，添加到列表末尾。入参：可迭代对象 iterable返回：None# extend()list1 = [1, 2, 3, 4, 'apple']print(list1)list1.extend('HelloWorld')# 添加的是字符串的所有字母list1.extend([8, 89, 185])# 接收列表的所有元素list1.extend((1, 5))# 接收元组的所有元素list1.extend({"a": 1}) # 接收字典的所有key值print(list1)

insert()

insert(index, item)：将一个对象插入到指定的索引位置入参：索引值 index ，一个对象 item返回：None原索引位置及后面的元素后移一位# insert()lis1 = [1, 2, 4, 6, 9]print(lis1)lis1.insert(0, 3)print(lis1)lis1.insert(4, "apple")print(lis1)

pop()

pop(index) 或 pop()弹出并返回所指定索引的元素。入参：索引值 index，可不传返回：指定索引的元素返回：未指定索引则返回末尾元素如果索引值不正确，或者列表已经为空，则引发 IndexError 错误# pop()letters = ['h', 'o', 'g', 'w', 'a', 'r', 't', 's']print(letters, len(letters))# letters.pop(8)# 报错：IndexError: pop index out of rangeletters.pop(0)print(letters, len(letters))letters.pop()print(letters, len(letters))letters.pop()print(letters, len(letters))letters.pop(3)print(letters, len(letters))

remove()

remove(item)移除列表中第一个等于 item 的元素入参：指定元素 item返回：None目标元素必须已存在，否则会报 ValueError# remove()letters = ['h', 'o', 'g', 'w', 'a', 'r', 't', 's']print(letters, len(letters))# letters.remove('p')# 报错，不存在 ValueError: list.remove(x): x not in listletters.remove('t')print(letters, len(letters))

sort()

sort(key=None, reverse=False)对列表进行原地排序，只使用 < 来进行各项间比较。入参：支持 2 个关键字参数：key：指定带有一个参数的函数，用于从每个列表元素中提取比较键。reverse：默认值为 False 表示升序，为 True 表示降序返回：None# sort()nums = [2, 4, 3, 1, 5]print(nums)# 不传参数，默认升序，数字从小到大排列nums.sort()print(nums)# 指定key=len，按元素的长度排序words = ['Python', 'Java', 'R', 'Go']print(words)words.sort(key=len)print(words)# 指定reverse=True，降序lis1 = [1, 2, 4, 6, 9]print(lis1)lis1.sort(reverse=True)print(lis1)

reverse()

reverse()：将列表中的元素顺序反转参数：无返回：None反转只是针对索引值，元素之间不相互比较。# reverse()nums = [8, 1, 5, 2, 77]print(nums)nums.reverse()print(nums)8、列表嵌套

创建嵌套列表
访问嵌套列表的元素

"""列表嵌套"""# 创建嵌套列表num = [[1, 2, 3], [3, 8, 98]]print(num, len(num))# 访问嵌套列表的元素print(num[0][1])print(num[1][2])num[1].append("李梓杰")print(num)9、列表推导式列表推导式是指循环创建列表，相当于 for 循环创建列表的简化版语法：[x for x in li if x ...]"""列表推导式"""# 语法：[x for x in li if x ...]# 实例1：将 1-10 中的所有偶数平方后组成新的列表# 普通的result = []for a in range(1, 11):if a % 2 == 0:result.append(a ** 2)print(result)# 列表推导式res = [b ** 2 for b in range(1, 11) if b % 2 == 0]print(res)# 实例2：将 20-30 中的所有基数组成新的列表# 普通d = []for c in range(20, 31):if c % 2 != 0:d.append(c)print(d)# 列表推导式f = [v for v in range(20, 31) if v % 2 != 0]print(f)二、tuple 元组1、元组的特点有序，元素可以重复，元组中的元素是不可以修改的，可以存放不同的数据类型
2、创建元组

使用逗号分隔
通过小括号填充元素
通过构造方法 tuple(iterable)

"""创建元组"""# 1、使用逗号分隔tup1 = 1, 2, 3print(tup1, type(tup1))# 2、过小括号填充元素tup2 = (1, 2, 3, 4, 5)tup3 = (1, 2, 4.5, True, "TTTT", (1, 2, 3), [1, 99, 555])print(tup2, type(tup3))print(tup3, type(tup3))# 3、通过构造方法 tuple(iterable)a = tuple()print(a, type(a))a1 = tuple((1, 2, 3))# 添加组，单个无法添加print(a1, type(a1))a2 = tuple([1, 2, 4])print(a2, type(a2))3、元组索引

正向索引，默认编号从 0 开始
反向索引，默认编号从-1 开始

"""元组索引"""# 正向索引，默认编号从 0 开始tup2 = (1, 2, 3, 4, 5)print(tup2[2])tup1 = (range(1, 9))print(tup1[3])# 反向索引，默认编号从-1 开始print(tup2[-3])print(tup1[-3])4、元组切片[start: stop: step]"""元组切片"""tup2 = (1, 2, 3, 4, 5, 8, 9)print(tup2[:])# 打印整个元素print(tup2[:-2]) print(tup2[2:4]) print(tup2[2:7:2])5、元组常用方法

index()

index(item)返回与目标元素相匹配的首个元素的索引。目标必须在元组中存在的，否则会报错ValueError# 1、index() # 查看元组中元素的索引值tup2 = (1, 2, 3, 4, 5, 8, 9)print(tup2.index(3))print(tup2.index(9))# print(tup2.index(20))# 目标必须在元组中存在的，否则会报错 ValueError: tuple.index(x): x not in tupletup3 = ('H', 'e', 'l', 'l', 'o')print(tup3.index('H'))# print(tup3.index('0')) # 目标必须在元组中存在的，否则会报错 ValueError: tuple.index(x): x not in tuple

count()

count(item)：返回某个元素出现的次数。入参：对象 item返回：次数tup3 = (1, 1, 1, 1, 3, 3, 8)print(tup3.count(3))print(tup3.count(1))print(tup3.count(8))6、元组的解包把一个可迭代对象里的元素，一并赋值到由对应的变量组成的元组中。

传统逐个赋值的方式
使用元组解包，一气呵成

# 传统逐个赋值的方式t = (1, 2, 3)a = t[0]# 索引b = t[1]c = t[2]print(a, b, c)# 使用元组解包，一气呵成a, b, c = (1, 2, 3)print(a, b, c)7、元组与列表

相同点
- 都是有序的，元素可以重复
- 都是异构的，能够包含不同类型的对象
- 都支持索引和切片
区别
- 声明方式不同，元组使用()，列表使用 []
- 列表是可变的，元组是不可变的

三、set 集合1、集合的特点无序、用大括号{}包围、添加或删除元素、可以存放不同的数据类型、去重
2、创建集合

通过使用{}填充元素
通过构造方法 set()
通过集合推导式

"""创建集合"""# 1、使用大括号{}填充元素set1 = {1, 2, 3, 4.5, "ll"}print(set1)set2 = {1, 1, 2, 3, 3}print(set2)# 去重set()# 2、使用构造方法创建集合 set()a = set('hello')print(a)b = set()# 空集print(b)# 3、使用集合推导式set3 = {x for x in range(1, 11)}print(set3)set4 = {x * 2 for x in range(1, 11) if x % 2 == 0}print(set4)# 注意：不要单独使用{ }来创建空集合set4 = {}# 这是字典类型print(set4, type(set4))3、集合成员检测

in 判断元素是否在集合中存在
not in 判断元素是否在集合中不存在

set1 = {1, 2, 3, 4.5, "ll"}# inprint(1 in set1)print(6 in set1)# notprint("ll" not in set1)print(6 not in set1)4、集合方法

add()

add(item)：将单个对象添加到集合中入参：对象 item返回：None# add() 随机添加位置set1 = {1, 2, 3, 5}print(set1, len(set1))# len()函数计算长度set1.add('happy')set1.add(96)set1.add(12)set1.add("hh")set1.add(4.6)print(set1, len(set1))

update()

update(iterable) 批量添加来自可迭代对象中的所有元素入参：可迭代对象 iterable返回：Nonea = set()print(a)a.update('hello')# 随机填入print(a)# 1、批量添加列表中的元素a.update([1, 2, 3])print(a)# 2、批量添加元组中的元素a.update((1, 2, 4))print(a)# 3、批量添加集合中的元素a.update({99, 88})print(a)

remove()

remove(item)：从集合中移除指定元素 item 。入参：指定元素值返回：None如果 item 不存在于集合中则会引发 KeyErrorset1 = {1, 2, 3, 5}print(set1)# 1、删除已存在的元素set1.remove(1)print(set1)# 2、删除不存在的元素报错：KeyError: 6set1.remove(6)print(set1)

discard()

discard(item)：从集合中移除指定对象 item 。入参：指定元素值返回：None元素 item 不存在没影响，不会抛出 KeyError 错误。set1 = {1, 2, 3, 6}print(set1)set1.discard(6)print(set1)# 没有元素，也不会报错set1.discard(888)

pop()

pop()：随机从集合中移除并返回一个元素。入参：无。返回：被移除的元组。如果集合为空则会引发 KeyError 。set1 = {1, 2, 3, 7}print(set1)# 1、随机删除某个对象set1.pop()print(set1)# 2、集合本身为空会报错 # KeyError: 'pop from an empty set'set2 = set()set2.pop()print(set2)

clear()

clear()：清空集合，移除所有元素入参：无返回：Nonest = {1, 2, 3, 4, 5}print(st)st.clear()print(st)5、集合运算交集运算并集运算差集运算intersection()union()difference()操作符：&操作符：｜操作符： -"""集合运算"""st = {1, 2, 3, 4, 5}st2 = {5, 8, 7, 1, 2}# 交集运算# 1 、intersection()# 2、操作符： &print(st.intersection(st2))print(st & st2)# 并集运算# 1、union()# 2、操作符：｜print(st.union(st2))print(st | st2)# 差集运算# 1、difference()# 2、操作符： -print(st.difference(st2))print(st - st2)6、集合的推导式语法：{x for x in ... if ...}
# 语法 {x for x in ... if ...}b = set()for y in 'hogwarts':if y in 'hello world':b.add(y)print(b)a = {x for x in 'hogwarts' if x in 'hello world'}print(a)四、dict 字典1、字典的特征无序的，用大括号{}包围，键值对的形式，键是不可以重复的
2、创建字典

使用大括号填充键值对 {}
通过构造方法 dict()
使用字典推导式

# 1、使用大括号填充键值对 {}a = {'name': '张学友', "age": 50}print(a, type(a))# 2、通过构造方法 dict()a1 = dict()print(a1, type(a1))a2 = dict(name='李梓杰', age=24)print(a2, type(a2))dc3 = dict([("name", "Harry Potter"), ("age", 18)])print(type(dc3), dc3)# 3、使用字典推导式dc4 = {k: v for k, v in [("name", "Harry Potter"), ("age", 18)]}print(type(dc4), dc4)3、访问字典中元素

访问存在的key
访问不存在的key，会报KeyError错误

"""访问字典中元素"""a = {'name': '理财友', "age": 50}# 1、访问存在的[key]print(a['name'], a['age'])# 2、访问不存在的key，会报KeyError错误print(a['hobby'])4、字典操作元素（添加修改）

语法：dict[key] = value
添加元素
- 键不存在
修改元素

键已经存在

a = {'name': '理财友', "age": 50}print(a, type(a))# 语法：dict[key] = value# 1、添加元素键不存在a['hobby'] = '骑马'print(a, type(a))# 2、修改元素键已经存在a['name'] = '王彬彬'print(a)5、字典嵌套

嵌套字典
字典的值可以是字典对象

"""嵌套字典"""a = {'name': '理财友', "age": 50, 'mark': {'python': 30, 'math': 56}}print(a)# 1、获取课程math的值print(a['mark']['math'])# 2、把python分数改成100分a['mark']['python'] = 89print(a)6、字典方法keys()values()items()返回由字典键组成的一个新视图对象。返回由字典值组成的一个新视图对象。返回由字典项 ((键, 值) 对) 组成的一个新视图对象。# keys()、values()、items()dc = {"name": "Harry Potter", "age": 18}# 1、返回由字典键组成的一个新视图对象。keys()a = dc.keys()print(a)# 2、返回由字典值组成的一个新视图对象。values()a1 = dc.values()print(a1)# 3、返回由字典项 ((键, 值) 对) 组成的一个新视图对象。items()a2 = dc.items()print(a2)

get()

获取指定 key 关联的 value 值。入参:key：字典的键，必传。返回：如果Key存在于字典中，返回Key关联的Value值如果Key不存在，则返回None此方法的好处是无需担心 key 是否存在，永远都不会引发 KeyError 错误。dc = {"name": "Harry Potter", "age": 18}# 1、访问存在的keyprint(dc.get('name'))# 2、访问不存在的keyprint(dc.get('hobby'))# None

update()

使用来自 dict 的键/值对更新字典，覆盖原有的键和值。入参：字典对象，必传返回：Nonedc = {"name": "Harry Potter", "age": 18}print(dc)dc.update({'mark': {'english': 30, 'math': 88}})print(dc)

pop()

删除指定 key 的键值对，并返回对应 value 值。入参：key：必传返回：如果 key 存在于字典中，则将其移除并返回 value 值如果 key 不存在于字典中，则会引发 KeyErrordc = {"name": "Harry Potter", "age": 18, 'mark': {'english': 30, 'math': 88}}print(dc)# 1、弹出dc.pop('name')print(dc) # 2、删除不存在的key# 报错KeyErrordc.pop('dog')print(dc)7、字典推导式实例1：给定一个字典对象{'a': 1, 'b': 2, 'c': 3}，找出其中所有大于 1 的键值对，同时 value 值进行平方运算。
实例2：给定一个字典对象，请使用字典推导式，将它的key和value分别进行交换。也就是key变成值，值变成key 。输入: {'a': 2, 'b': 8, 'c': 4}输出: {2: 'a',8: 'b', 4: 'c'}
"""字典推导式""""""实例1：给定一个字典对象{'a': 1, 'b': 2, 'c': 3}，找出其中所有大于 1 的键值对，同时 value 值进行平方运算。"""# 未使用字典推导式的写法a = {'a': 1, 'b': 2, 'c': 3}b = dict()for k, v in a.items():if v > 1:b[k] = v ** 2print(b)# 使用字典推导式c = {k: v ** 2 for k, v in a.items() if v > 1}print(c)"""实例2:给定一个字典对象，请使用字典推导式，将它的key和value分别进行交换。也就是key变成值，值变成key 。输入: {'a': 2, 'b': 8, 'c': 4}输出: {2: 'a',8: 'b', 4: 'c'}"""dc = {'a': 2, 'b': 8, 'c': 4}f = {v: k for k, v in dc.items()}print(f)本文来自博客园，作者：{jiuyou-emperor}，转载请注明原文链接：{https://www.cnblogs.com/jiuyou-emperor/}