python 内置数据结构

cliffordl

已于 2024-01-23 16:45:19 修改

阅读量546

点赞数 7

分类专栏： python 文章标签： python 数据结构 chrome

于 2023-12-14 09:20:39 首次发布

本文链接：https://blog.csdn.net/cliffordl/article/details/134986830

版权

python 专栏收录该内容

19 篇文章 0 订阅

订阅专栏

python内置的数据结构有：
列表(list)
元组(tuple)
字典(dict)
集合(set)
在python语言中，以上4种数据结构和基础数据类型（整数、浮点数等）统称为“内置类型”（Built-in Types）。

1. 列表(list)

参考：http://wed.xjx100.cn/news/317220.html?action=onClick

1.1. 创建

1.1.1. 使用[] 创建

# 定义空列表
test = []
# 使用 list() 构造函数创建列表：
test  = list(('apple', 'banana', 'cherry'))
# 定义非空列表
name = ['Tom','Jack','John']
pet = ['cat','dog','bird']

# 打印列表
print(name)	# ['Tom', 'Jack', 'John']
print(pet)	# ['cat', 'dog', 'bird']

1.1.2. 使用 range() 创建数字 list

range() 为 python 的自有类，range() 带有内置的迭代方法iter() 和 next() ，它是一个可迭代对象，我们可以通过 for 访问 range() 创建的迭代器。
range 类初始化参数说明：
range(stop): 从0开始到stop结束（不包含 stop）返回一个产生整数序列的迭代对象
range(start, stop[, step]): 从 start 开始到 stop 结束（不包含 stop）返回一个整数序列的迭代对象, step 为他的步长

# 循环输出1-10之间的数字
for num in range(11):
    print(num,end=" ")
# 输出1-10之间的偶数
for num in range(2,11,2):
    print(num,end=" ")
# 输出1-10之间的奇数
for num in range(1,11,2):
    print(num,end=" ")
# 输出1-10之间的奇数的平方
for num in range(1,11,2):
    print(num**2,end=" ")
# 创建一个数字列表
numbers = list(range(1,11))
print(numbers)

1.2. 查询

1.2.1. 使用下标查询

使用下标索引来访问列表中的值，同样你也可以使用方括号的形式截取字符，如下所示：

# 通过索引读取列表中的元素，索引从0开始，-1代表最后一个元素
print(name[0])     # Tom 查看列表中第一个
print(pet[2])      # bird 查看列表中第二个
print(name[-1])    # John 查看列表中最后一个
print(pet[-2])     # dog 查看列表中倒数第二个
print(name[0:2])   # ['Tom', 'Jack'] 查看索引2之前的元素

1.2.2. 列表切片

切片是 python 序列的重要操作之一，适用于列表、元组、字符串、range 对象等类型。切片使用2个冒号分隔的3个数字来完成：
第一个数字表示切片的开始位置，默认为0，
第二个数字表是切片的截止（但不包含）位置（默认为列表长度），
第三个数字表示切片的步长(默认为1)，当步长省略时，顺便可以省略最后一个冒号。
可以使用切片来截取列表中的任何部分，得到一个新列表，也可以通过切片来修改和删除列表中部分元素，甚至可以通过切片操作为列表对象增加元素。与使用下标访问列表元素不同，切片操作不会因为下标越界而抛出异常，而是简单地在列表尾部截断或者返回一个空列表，代码具有更强的健壮性。

# 创建一个列表
pets = ['cat','dog','duck','pig']
# 1、读取列表中2和3的元素
pets[1:3]
# 2、读取列表中1到4的元素
pets[0:4]
# 3、读取列表中的第一个元素
pets[0]
# 4、读取列表中的最后一个元素
pets[-1]
# 5、读取列表中，从第二个元素开始的所有元素
pets[1:]
# 6、读取列表中，从第一个元素开始的所有元素
pets[0:]
# 7、读取列表中，从倒数第三个元素开始的所有元素
pets[-3:]
# 8、循环输出列表中，从倒数第三个元素开始的所有元素
for pet in pets[-3:]:
    print(pet,end=" ")
# 9.读取列表中，从第三个开始的所有数据，并组合一下数据
games = ['王者','吃ji','抢滩登陆']
# friend_games = ['王者','吃ji']
friend_games = games[:2]
print('我喜欢的游戏有:'+str(games))				# 我喜欢的游戏有:['王者', '吃ji', '抢滩登陆']
print('我朋友喜欢的游戏有:'+str(friend_games))	# 我朋友喜欢的游戏有:['王者', '吃ji']

1.3. 增加

向 python 列表里面添加元素主要有三种方法：

1.3.1. append()

append() 对于列表的操作主要实现的是在列表最后添加一个元素，并且只能一次添加一个元素，并且只能在列表最后；
name.append(元素A)

# 在列表末尾添加新元素
name.append('Bob')

1.3.2. extend()

extend() 对于列表的操作主要实现的是对于特定列表的扩展和增长，可以一次添加多个元素，不过也只能添加在列表的最后；
name.extend([元素A，元素B，……])

name.extend(['Xgp','Wsd'])

1.3.3. insert()

insert() 对于列表的操作主要是在列表的特定位置添加想要的元素，比较常用，这里的特定位置是指元素在列表中的索引号，需要注意的是这里的索引号都是从0开始的，不是从1开始的。
pet.insert(A, 元素B)：表示在列表pet的第A处加入元素B

# 在列表指定位置添加新元素
pet.insert(0,'penguin')   #在列表最前面添加数据
pet.insert(-2,'pig')      #在列表倒数第二个添加数据

1.4. 修改

使用链表索引，直接赋值即可。

1.5. 删除

与之前 python 列表的添加元素相对，删减列表里面的一些元素也有三种方法：

1.5.1. del m[n]

它的作用是删除列表中索引号为n 的元素，这里需要注意的是del是一种操作语句。
del pet[n]

# 根据索引从列表中删除元素
del pet[0]      # 删除开头的元素
del pet 		# 删除列表

1.5.2. pop()

它的作用有两个
pop() 返回列表最后一个元素，并且删除

temp=pet.pop() 	# 这里temp等于列表最后一个元素。

pop(n) 弹出指定位置的元素，并且删除

print(pet)
temp=pet.pop(2)		# ['cat', 'dog', 'penguin', 'bird'] 弹出指定位置的元素
print(pet, temp)	# ['cat', 'dog', 'bird'] penguin

1.5.3. remove()

remove() 的作用是移除列表的特定元素，不返回；
pet.remove(元素A)

# 根据元素的值进行删除：remove()
print(pet)            		# ['cat', 'dog', 'penguin', 'bird'] 查看源列表
temp=pet.remove('cat')     	#删除cat
print(pet,temp)            	# ['dog', 'penguin', 'bird'] None 打印列表

1.5.4. clear()方法

clear() 方法用于清空列表，类似于 del a[:]。
语法： list.clear()

word = ['A', 'B', 'C']
word.clear()
print(word)		# []

1.6. 排序

1.6.1. 永久排序（正索引，从头到尾）

sort() 排序方法：此函数方法对列表内容进行正向排序，排序后的新列表会覆盖原列表（id不变），也就是sort排序方法是直接修改原列表list排序方法。

# 定义列表：汽车的品牌
print('原始排序：')
brand = ['audi','bmw','toyota','luhu']
print(brand)	# ['audi', 'bmw', 'toyota', 'luhu']

# 永久排序: sort()
print('正序排序：')
brand.sort()
print(brand)	# ['audi', 'bmw', 'luhu', 'toyota']

1.6.2. 临时排序（正索引，从头到尾）

sorted() 方法：即可以保留原列表，又能得到已经排序好的列表.

#临时排序
print('临时排序：')
print(sorted(brand))	# ['audi', 'bmw', 'luhu', 'toyota']

1.6.3. 倒序（从头到尾从尾到头）

reverse=[True|False] 列表反转排序：是把原列表中的元素顺序从左至右的重新存放，而不会对列表中的参数进行排序整理。如果需要对列表中的参数进行整理，就需要用到列表的另一种排序方式 sort() 正序排序。

# 倒序排序
print('倒序排序:')
brand.sort(reverse=True)
print(brand)		# ['toyota', 'luhu', 'bmw', 'audi']

1.7. 其他操作

总结：

print()	# 打印输出
len()	# 确定列表项目
type()	# 返回变量类型
list()	# 转换为列表
max()	# 返回列表元素最大值
min()	# 返回列表元素最小值
del		# 删除列表
append(obj)	# 在列表末尾添加新的对象
insert(index, obj)	# 在指定位置添加元素
extend(seq)	# 将列表元素（或任何可迭代的元素）添加到当前列表的末尾
count(obj)	# 统计某个元素在列表中出现的次数
index(obj)	# 返回具有指定值的第一个元素的索引
sort( key=None, reverse=False)	# 对原列表进行排序
copy()		# 复制列表
reverse()	# 颠倒列表的顺序
pop([-1])	# 移除列表中的一个元素（默认最后一个元素），并且返回该元素的值
remove(obj)	# 移除列表中某个值的第一个匹配项
clear()		# 清空列表

1.7.1. 列表拼接复制

#与字符串一样，列表之间可以使用 + 号和 * 号实现元组的连接和复制，这就意味着它们可以生成一个新的列表。
# 1、+ 连接（合并）
x = [1, 2, 3]
y = [4, 5, 6]
print(x + y)	# [1, 2, 3, 4, 5, 6]
# 2、*复制
x = ['Hello']
print(x * 5)	# ['Hello', 'Hello', 'Hello', 'Hello', 'Hello']

1.7.2. 嵌套列表

# 使用嵌套列表即在列表里面创建其他列表。
x = [1, 2, 3]
y = ['a', 'b', 'c']
z = [x, y]
print(z)		# [[1, 2, 3], ['a', 'b', 'c']]

1.7.3. 列表比较

# 列表比较需要引入 operator 模块的 eq 方法。
# 导入 operator 模块
import operatora = [1, 2]
b = [2, 3]
c = [2, 3]
print("operator.eq(a, b):", operator.eq(a, b))	# operator.eq(a, b): False
print("operator.eq(b, c):", operator.eq(b, c))	# operator.eq(b, c): True

1.7.4. 内置函数

#  打印输出 print()
my_list = ['pink', True, 1.78, 65]
print(my_list)			# ['pink', True, 1.78, 65]

#  确定列表项目 len()
fruit_list = ['apple', 'banana', 'cherry']
print(len(fruit_list))	# 3

# 返回变量类型 type()
info_list = ['name', 'gender', 'age', 'height', 'weight']
# 当对info_list使用 type() 确定变量类型时，会返回<class 'list'>，表明这是一个列表。
print(type(info_list))	# <class 'list'>

# 转换为list list()
# 将字符串转换为列表
str1 = 'Hello Python'
print(list(str1))		# ['H', 'e', 'l', 'l', 'o', ' ', 'P', 'y', 't', 'h', 'o', 'n']
# 将元组转换为列表
tuple1 = ('Hello', 'Python')
print(list(tuple1))	# ['Hello', 'Python']
# 将字典转换为列表
dict1 = {'Hello': 'Python', 'name': 'pink'}
print(list(dict1))		# ['Hello', 'name']
# 将集合转换为列表
set1 = {'Hello', 'Python', 'name', 'pink'}
print(list(set1))		# ['Python', 'name', 'pink', 'Hello']
# 将区间转换为列表
range1 = range(1, 6)
print(list(range1))		# [1, 2, 3, 4, 5]

# 元素最大/小值 max()、min()
list1 = [4, 6, 2, 0, -5]
print(max(list1))		# 6
print(min(list1))		# -5
list2 = ['a', 'z', 'A', 'Z']
print(max(list2))		# z
print(min(list2))		# A

# 元素出现次数 count()
# count() 方法用于统计某个元素在列表中出现的次数。
# 语法：list.count(value)
# 必需。任何类型（字符串、数字、列表、元组等）。要搜索的值。
num = [1, 4, 2, 9, 7, 8, 9, 3, 1]
print(num.count(9))		# 2


# 指定值索引 index()
# index() 方法用于从列表中找出某个值第一个匹配项的索引位置。
# 语法： list.index(element)
# element	必需。任何类型（字符串、数字、列表等）。要搜索的值。
num = [4, 55, 64, 32, 16, 32]
print(num.index(32))	# 3

# 复制列表 copy()
# copy() 方法用于复制列表，类似于 a[:]。
# 语法： list.copy()
fruits = ['apple', 'banana', 'cherry', 'orange']
x = fruits.copy()
print(x)				# ['apple', 'banana', 'cherry', 'orange']

# 颠倒列表顺序 reverse()
# reverse() 方法用于反向列表中元素。
# 语法：list.reverse()
fruits = ['apple', 'banana', 'cherry']
fruits.reverse()
print(fruits)			# ['cherry', 'banana', 'apple']

1.7.5. List 转 str

import json

my_list = [{"name": "Tom", "age": 25}, {"name": "Bob", "age": 30}]
json_list = json.dumps([dict(item) for item in my_list])
print(json_list)
# 输出: '[{"name": "Tom", "age": 25}, {"name": "Bob", "age": 30}]'

如果是 List 嵌套 List。可以使用一下方式

json_list = json.dumps([dict(item.dict()) for item in my_list])

参考：https://www.python100.com/html/89632.html

2. 元组(tuple)

python 的元组与列表类似，不同之处在于元组的元素不能修改。
元组使用小括号，列表使用方括号。
元组创建很简单，只需要在括号中添加元素，并使用逗号隔开即可。

2.1. 创建

# 空
_tup = ()
print(_tup, type(_tup))		# () <class 'tuple'>
# 一个元素的写法	
_tup = (666,) # 此处加‘,’的原因是要区分括号的作用
print(_tup, type(_tup))		# (666,) <class 'tuple'>
_tup = (666)
print(_tup, type(_tup))		# 666 <class 'int'>
# 多个元素的写法
(1,2,3)
# 多个对象，以逗号隔开，默认为元组
_tup = 1,2,3,"sz"
print(_tup, type(_tup))		# (1, 2, 3, 'sz') <class 'tuple'>
# 从列表转换成元组
_lst = [1, 2, 3, 4, 5]
_tup = tuple(_lst)
print(_tup, type(_tup))		# (1, 2, 3, 4, 5) <class 'tuple'>
# 元组嵌套
(1,2,("a","b"))	# 元组中的元素可以是元组

2.2. 查询

获取单个元素：tuple[index] ，index 为索引可以为负

#定义元组
numbers = (4,5,6)
print(numbers[0])   #查看元组中第一个元素

for num in numbers:
    print(num,end=" ")

获取多个元素：切片
tuple[start：end：step]
start 查询的开始位置
end 查询的结束位置
step 查询的步长

2.3. 增加（拼接和复制）

与字符串一样，元组之间可以使用 + 号和 * 号进行运算。这就意味着他们可以组合和复制，运算后会生成一个新的元组。

# 计算元素个数
print(len((1, 2, 3)))			# 3 
# 连接
print((1, 2, 3) + (4, 5, 6))	# (1, 2, 3, 4, 5, 6)
# 复制
print(('Hi!',) * 4)				# ('Hi!', 'Hi!', 'Hi!', 'Hi!')
# 元素是否存在
print(3 in (1, 2, 3))			# True
# 迭代
for x in (1, 2, 3):
    print (x,)					# 1\n 2\n 3

2.4. 修改

元组中的元素值是不允许修改的，但我们可以对元组进行连接组合，如下实例:

print(numbers)
numbers = (0,1,2)  # 对元祖重新赋值允许
print(numbers)

2.5. 删除

print(numbers)     #查看元组
del numbers        #删除元组
print ("删除后的元组 numbers : ")
print(numbers)     #因为删除了元组，所以看不到了，就会报错

2.6. 函数操作

2.6.1. 获取操作

# 统计元组中指定元素（item）的个数
tuple.count(item)
# 获取元组中指定元素（item）的索引
tuple.index(item)
# 统计元组中元素的个数
len(tuple)
# 返回元组中元素最大的值
max(tuple)
# 返回元组中元素最小的值
min(tuple)

2.6.2. 判断操作

# 元素 in 元组
# 元素 not in 元组
t1 = (1,2,3,4,5,6,'a',"a","abc")
print(1 in t1)		#输出 True
print(5 not in t1)	#输出 False
print('a' in t1)	#输出 True

2.6.3. 比较操作

# 比较运算符 ==  >  <
t1 = (1,2,3,4,5,6,'a',"a","abc")
t2 = (5,2,6,4,8,2,)
print(t2 == t1)	#输出 False
print(t2 > t1)	#输出 True
print(t2 < t1)	#输出 False

2.6.4. 拆包

# 拆包
a,b ,c= (10,20,30)
print(a)	#输出 10
print(b)	#输出 20
print(c)	#输出 30

2.6.5. 转换为字符串

_tup = ("apple", 10, True)
print(_tup, type(_tup))			# ('apple', 10, True) <class 'tuple'>
# 使用str()
_str = str(_tup)
print(_str, type(_str))			# ('apple', 10, True) <class 'str'>
# 使用列表推导的方式生成字符串
_str2 = ', '.join([str(item) for item in _tup]) # 用“, ”分割
print(_str2, type(_str2))		# apple, 10, True <class 'str'>

需要注意的是，转换后的字符串会保留元组的原始结构，包括圆括号和逗号。这是因为 str() 函数将元组视为一个整体进行转换。
参考：https://blog.51cto.com/u_16213414/7220752

3. 字典(dict)

字典是一种可变的容器，可以存储任意类型的数据
字典中的每个数据都是用"键" (key) 进行索引，而不像序列可以用下标进行索引
字典中的数据没有先后关系，字典的存储是无序的
字典是python中唯一的映射类型，**采用键值对（key-value）**的形式存储数据。key必须是不可变类型，如：数字、字符串、元组。
字典的表示方式是以{} 括起来，以冒号(:)分割的键值对，各键值对之间用逗号分隔开
字典的键一般是唯一的，如果重复最后的一个键值对会替换前面的
字典的内置方法&函数，总结：

dic.clear() # 清空字典
dic.pop(key) # 移除键，同时返回此键所对应的值
dic…popitem() # 随机删除一组键值对，同时返回对应的值
dic.copy() # 返回字典dic的副本，只复制一层（浅拷贝)
dic.update(dic1) # 将字典dic1合并到dic中，如果键相同，则此键的值取dic1的值作为新值
dic.get(key, default) # 返回键key所对应的值，如果没有此键则返回default
dic.keys() # 返回可迭代的dict_keys集合对象
dic.values() # 返回可迭代的dict_values值对象
dic.items() # 返回可迭代的dict_items对象
cmp(dict1, dict2) # 比较两个字典元素
len(dict) # 计算字典元素个数，即键的总数
str(dict) # 输出字典可打印的字符串表示
type(variable) # 返回输入的变量类型，如果变量是字典就返回字典类型

Python dict转json

loads()：将json数据转化成dict数据
dumps()：将dict数据转化成json数据
load()：读取json文件数据，转成dict数据
dump()：将dict数据转化成json数据后写入json文

参考：https://blog.csdn.net/weixin_45014379/article/details/125641819

3.1. 创建

# 创建空字典：
d = {}    	# 空字典
d = dict() 	# 空字典
# 创建非空的字典：
dic1 = {'name': 'cgk', 'age': 20, 'sex': 'male'}
dic2 = dict((('name', 'cgk'),))

3.2. 查询

dic4 = {'name': 'cgk', 'age': '20', 'hobby': 'girl'}
# 通过键查找
print(dic4['name'], type(dic4['name']))     # cgk <class 'str'>
# 打印全部值
print(dic4.values(), type(dic4.values()))   # dict_values(['cgk', '20', 'girl']) <class 'dict_values'>
# 打印全部键
print(dic4.keys(), type(dic4.keys()))      	# dict_keys(['name', 'age', 'hobby']) <class 'dict_keys'>
# 打印全部键值对
print(dic4.items(), type(dic4.items()))		# dict_items([('name', 'cgk'), ('age', '20'), ('hobby', 'girl')]) <class 'dict_items'>
# 打印全部键，转成列表形式
print(list(dic4.keys()), type(list(dic4.keys())))	# ['name', 'age', 'hobby'] <class 'list'>

# 判断是否存在
print('name' in dic4)						# True
print('name' not in dic4)					# False

3.3. 增加

#增
dic1 = {'name': 'cgk'}
dic1['age'] = '20'
print(dic1)

#键存在，不改动，返回字典中相对应的键对应的值
a = dic1.setdefault('age', 30)
print(a)
print(dic1)

#键不存在，在字典中增加新的键值对，并返回相应的值
b = dic1.setdefault('hobby', 'girl')
print(b)
print(dic1)

3.4. 修改

# 修改字典对应键的值
dic4 = {'name': 'cgk', 'age': '20', 'hobby': 'girl'}
dic4['age'] = 30		#更新
dic4['school'] = '北大'	#添加
print(dic4)

# 向字典添加新内容的方法是增加新的键/值对——updat
dic4 = {'name': 'cgk', 'age': '20', 'hobby': 'girl'}
dic5 = {1: "1", 'age': "30"}
dic4.update(dic5)       #把dic5加进dic4里面，如果有重复的键，则覆盖
print(dic4)

3.5. 删除

dic5 = {'name': 'cgk', 'age': '20', 'hobby': 'girl', 'school': '北大'}
del dic5['name']		#删除键是name的条目
print(dic5)

red = dic5.pop('hobby')	#通过pop删除键是hoppy的条目，并返回删除的值
print(red)
print(dic5)

dic5.clear()			#清空字典
print(dic5)

del dic5				#直接删除字典

3.6. 其他操作

# d.copy()
# 对字典 d 进行浅复制，返回一个和d有相同键值对的新字典

# 嵌套
#嵌套
av_catalog = {
    "欧美": {
        "www.111.com": ["免费的,高清的", "质量一般"],
        "www.222.com": ["免费的,清晰", "质量还行"],
        "333.com": ["自拍,图片", "资源不多,更新慢"],
        "444.com": ["质量很高,good", "收费,白嫖绕路"]
    },
    "日韩": {
        "555.com": ["质量很差,不喜欢", "收费"]
    },
    "大陆": {
        "666.com": ["免费,好人一生平安", "服务器在国外,慢"]
    }
}

av_catalog["大陆"]["666.com"][1] += ",可以用爬虫爬下来"       #修改
print(av_catalog["大陆"]["666.com"])      #['全部免费,真好,好人一生平安', '服务器在国外,慢,可以用爬虫爬下来']

# sorted(dict)
#返回一个有序的包含字典所有key的列表
dic = {5: '555', 2: '222', 4: '444'}
print(sorted(dic))				#默认根据键排序 [2, 4, 5]
print(sorted(dic.values()))     #根据值排序 ['222', '444', '555']
print(sorted(dic.items()))      #根据键排序 [(2, '222'), (4, '444'), (5, '555')]

# 字典的遍历
dic = {'zhangsan': {'age': 11, 'sex': '男'},
     '李四': {'age': 22, 'sex': '男'},
     'wangwu': {'age': 33, 'sex': '女'}
       }
#方法一：       
for i in dic:
     print(i)       			#默认遍历打印键
     print(i, dic[i])         	#打印键值对

#方法二：
for i in dic.items():
     print(i)       			#打印键值对

for i, v in dic.items():
     print(i, v)         		#打印键值对