Python---容器

北染星辰

已于 2024-08-21 15:03:07 修改

阅读量912

点赞数 30

分类专栏： python 文章标签： python 开发语言

于 2024-08-18 01:30:09 首次发布

本文链接：https://blog.csdn.net/zhoutong2323/article/details/141265989

版权

python 专栏收录该内容

10 篇文章 0 订阅

订阅专栏

一.容器概念

在Python中，容器是指可以存放多个元素的对象。常见的容器类型有列表（List）、元组（Tuple）、集合（Set）和字典（Dictionary）。

列表（List）是有序、可重复的容器，可以使用方括号 [] 来创建。列表中的元素可以是任意类型的对象，包括其他容器。列表可以通过索引访问和修改其中的元素。
元组（Tuple）也是有序的容器，但是与列表不同的是，元组一旦创建就不能修改。元组使用圆括号 () 来创建，元素之间使用逗号分隔。
集合（Set）是无序且不重复的容器，可以使用花括号 {} 或 set() 函数来创建。集合中的元素必须是可哈希的（即不可变的对象），不能包含其他集合。
字典（Dictionary）是无序的键值对容器，可以使用花括号 {} 或 dict() 函数来创建。字典中的键必须是唯一的，且不可变的对象，而值可以是任意类型的对象

二.列表

特点：

列表中的元素可以是任意数据类型
列表的长度可动态的添加或删除
频繁添加新元素会影响程序内存使用率

切片

列表切片是一种在Python中处理列表的常用技巧。它允许你从一个列表中选择特定的元素，然后创建一个新的列表。

基本的列表切片语法如下：

new_list = old_list[起点:终点:步长]

注：步长>0时，起点必须<终点，从左向右切片
    步长<0时，起点必须>终点，从右向左切片

list = [1, 2, 3, 4, 5]
 选择列表的前三个元素
new_list = list[:3]    [1, 2, 3]
 选择列表的第二个到第四个元素
new_list = list[1:4]   [2, 3, 4]
 选择列表的最后两个元素
new_list = list[-2:]   [4, 5]

增加

append()方法：追加

ls = [1,2,3]
ls.append(4)
print(ls)

insert()方法：插入

在Python中，insert函数用于在列表中的指定位置插入一个元素。其语法如下：

list.insert(index, element)

其中，index表示要插入元素的位置，element表示要插入的元素。调用insert函数后，原列表中位于index位置及其后面的元素都会向后移动一位，以给新插入的元素腾出位置。

list = [1, 2, 3, 4]
list.insert(2, 5)
print(list)

extend()方法：合并

在python中，extend函数用于将一个序列（例如列表、元组、字符串等）中的元素逐个添加到另一个序列的末尾。面是一些使用extend函数的示例：

list1 = [1, 2, 3]
list2 = [4, 5, 6]

#  使用extend将list2中的元素添加到list1的末尾
list1.extend(list2)
print(list1)    # 输出：[1, 2, 3, 4, 5, 6]

#  使用extend将字符串中的字符添加到列表的末尾
list3 = [7, 8, 9]
string = "abc"
list3.extend(string)
print(list3)   #  输出：[7, 8, 9, 'a', 'b', 'c']

删除

remove()方法：

remove()方法可以删除列表中第一个匹配指定值的元素。例如，要删除列表list中值为value的元素，可以使用list.remove(value)。

pop()方法：

pop()方法可以删除并返回列表中指定索引处的元素。例如，要删除列表list中的第一个元素，并将其存储在变量item中，可以使用item = list.pop(0)，

区别：pop()方法删除指定序号的元素，remove()方法删除指定元素，更关注内容

list = [1, 2, 3, 4]
list.remove(2)
print("删除列表中的元素2：",list)
list.pop(2)
print("第2号元素被删除",list)

排序

sort函数用于对列表进行排序操作。它默认按照元素的大小进行升序排序，也可以通过参数指定其他的排序规则。reverse函数可以用于反转列表。

numbers = [3, 1, 4, 2, 5]
numbers.sort()  # 默认按照升序排序
print(numbers)  # 输出：[1, 2, 3, 4, 5]

numbers = [3, 1, 4, 2, 5]
numbers.sort(reverse=True)  # 默认按照降序排序
print(numbers)  # 输出：[5，4，3，2，1]

fruits = ['apple', 'banana', 'orange', 'kiwi']
fruits.sort(key=len)  # 按照字符串长度进行排序
print(fruits)  # 输出：['kiwi', 'apple', 'banana', 'orange']

拷贝

浅拷贝：

copy()函数是用来创建一个对象的浅拷贝，副本中的引用对象(如列表，字典等)和主本中的引用对象共享内存空间，这意味着副本中列表数据改变，主本中列表的数据也会随之改变。

假设我们有一个包含列表的列表 a = [1, 2, [3, 4]]：

使用浅拷贝 b = a.copy() 后，b 和 a 的最外层列表是独立的(即1与2,与[3, 4])，但内部的子列表元素 [3, 4] 是共享的。因此，如果 b[2].append(5)，则 a 也会变为 [1, 2, [3, 4, 5]]。

lst1 = [1,2,3,[1,2,3]]
lst2 = lst1.copy()
lst2[3][1] = None
print("主本lst1内部子列表元素与副本lst2共享内存")
print("主本：",lst1)
print("副本：",lst2)

print("主本lst3外层列表和副本lst4不共享内存")
lst3 = [1,2,3,[1,2,3]]
lst4 = lst3.copy()
lst4[3] = str("主本lst3此处列表不改变")
print("主本：",lst3)
print("副本：",lst4)

print("主本lst5外层元素和副本lst6不共享内存")
lst5 = [1,2,3,[1,2,3]]
lst6 = lst5.copy()
lst6[2] = str("主本lst5此处元素不改变")
print("主本：",lst5)

深拷贝：

deepcopy()函数会完整的复制主本，新创建的对象和原始对象不会共享内存空间，主本数据不会随着副本数据变化而变化。

import copy
lst1 = [1, 2, 3,[1,2,3]]
lst2 = copy.deepcopy(lst1)
lst2[3][1] = None
print(lst1)
print(lst2)

统计

ount函数是Python中内置的一个方法，用于统计某个元素在一个序列中出现的次数。count方法的语法如下：

sequence.count(element)

sequence表示要统计的序列，可以是字符串、列表、元组等可迭代对象；element表示要统计的元素。

s = "Hello, World!"
count = s.count('o')
print(count)  # 输出：2

三.元组

特点：元组一旦创建后不能修改

tp = (1,2,3)
print("元组的0号元素是：",tp[0])
tp[0] = 5

图中尝试将元组中的0号元素的值修改为5，此时报错：元组类型不支持修改元素

四.集合

集合是无序且不重复的容器，无法通过索引访问或修改其中的元素，也无法进行切片，此外可以利用集合进行去重，取交集，取并集，取差集。

特点：

集合中的元素被存储并组织在哈希表中，而哈希表中的元素是按照哈希值的顺序存储的，所以集合中的元素是无序的。

另外，由于哈希表的特性，它不能包含重复的键（元素），如果有重复的键（元素）被添加到集合中，只会保留一个。这是因为集合内的元素被存储在哈希表的键（元素）上，而哈希表中的键必须是唯一的，不能重复

去重

st = {1,2,3,4,4,3,2,1}
print(st)

ls = [1,2,3,3,2,1]
print("列表去重后的结果是：",set(ls))

取交集

st1 = {1,2,3,4,5}
st2 = {3,4,5,6,7}
st3 = st1.intersection(st2)
print(st3)

取并集

st1 = {1,2,3,4,5}
st2 = {3,4,5,6,7}
st3 = st1.union(st2)
print(st3)

取差集

st1 = {1,2,3,4,5}
st2 = {3,4,5,6,7}
st3 = st1.difference(st2)
print("集合st1对于集合st2的差集是：",st3)
st4 = st2.difference(st1)
print("集合st2对于集合st1的差集是：",st4)

五.字典

在Python中，字典是一种可变的数据类型，用于存储键值对。它是一种无序的集合，其中的元素通过键来索引，而不是通过位置。字典中的键必须是唯一的，而值可以是任何类型的对象。

字典的特点包括：

字典使用大括号（{}）来创建，键值对之间用冒号（:）分隔。
键必须是不可变的对象，如字符串、数字或元组，而值可以是任何对象。
字典中的元素是无序的，不能通过索引来访问。
字典是可变的，可以通过键来添加、删除或修改元素。
字典可以包含其他的字典作为值，也可以包含列表、集合等其他类型的对象。

字典语法：

字典 = {键1:值,键2:值2,健3:值3}

字典值获取

字典[键] 如果键不存在会报错
字典.get(键) 如果键不存在返回空值

字典值设置/删除

字典[键] = 值   ===>设置对应键值
字典.setdefault(键,值)

字典.pop(键)=====>删除对应键的值
字典.popitem()===>删除末尾元素

获取键/值/键值对集合

print("键集合是：",person.keys())
print("值集合是：",person.values())
print("键值对集合是:",person.items())

下面是一个演示案例：

person = {'name': 'John', 'age': 25, 'city': 'New York'}
print(person)
print("字典中name键对应的值是:",person['name'])
print("键集合是：",person.keys())
print("值集合是：",person.values())