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。
三个值都是可选的,非必填
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] * 5
li2 = [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 range
letters.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 list
letters.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, 3
print(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 tuple
tup3 = ('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"}
# in
print(1 in set1)
print(6 in set1)
# not
print("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 |
返回:None |
a = 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 不存在于集合中则会引发 KeyError |
set1 = {1, 2, 3, 5}
print(set1)
# 1、删除已存在的元素
set1.remove(1)
print(set1)
# 2、删除不存在的元素 报错:KeyError: 6
set1.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() :清空集合,移除所有元素 |
---|
入参:无 |
返回:None |
st = {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'] = 89
print(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、访问存在的key
print(dc.get('name'))
# 2、访问不存在的key
print(dc.get('hobby')) # None
- update()
使用来自 dict 的键/值对更新字典,覆盖原有的键和值。 |
---|
入参:字典对象,必传 |
返回:None |
dc = {"name": "Harry Potter", "age": 18}
print(dc)
dc.update({'mark': {'english': 30, 'math': 88}})
print(dc)
- pop()
删除指定 key 的键值对,并返回对应 value 值。 |
---|
入参: key:必传 |
返回: 如果 key 存在于字典中,则将其移除并返回 value 值 如果 key 不存在于字典中,则会引发 KeyError |
dc = {"name": "Harry Potter", "age": 18, 'mark': {'english': 30, 'math': 88}}
print(dc)
# 1、弹出
dc.pop('name')
print(dc)
# 2、删除不存在的key # 报错KeyError
dc.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 ** 2
print(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)
最新文章
- css水平居中那点事
- python学习笔记(2)
- HDOJ 1576 A/B
- TI Zigbee Light Link 参考设计
- Redis的Python客户端redis-py的初步使用
- oracle数据学习第二天
- activiti 介绍
- Display Images in widget
- MySQL自动化安装(双主多从读写分离)
- 也谈OpenFlow, SDN, NFV
- Excel 开发概述
- vuejs数据双向绑定原理(get &; set)
- Java中面向字符的输入流
- 【一天一道LeetCode】#345. Reverse Vowels of a String
- ranch 源码分析(完)
- 对requestAnimationFrame的一点理解
- LeetCode算法题-Remove Linked List Elements(Java实现)
- PHP实用代码片段(四)
- 随机森林RandomForest
- 【spring源码分析】spring AspectJ的Execution表达式
热门文章
- Table.ReverseRows反转…Reverse…(Power Query 之 M 语言)
- 可视报表(Project)
- linux安装软件系列之yum安装
- java 网络编程基础 UDP协议的Socket:DatagramSocket;广播Socket:MulticastSocket
- IDEA安装vue.js插件后,new没有Vue component
- std::bind与std::ref, why and how
- 【LeetCode】43. Multiply Strings 解题报告(Python & C++)
- Elasticsearch核心技术(五):搜索API和搜索运行机制
- [CodeLife]记毕业后第一份工作
- CS5268 Typec转HDMI+VGA+PD3.0四合一扩展坞转换器方案芯片