Python测开28期-学习笔记-python-数据结构

85853870_0560 · 2023 年10 月 24 日 11:01

元组

元组的特点：

有序性：组中的元素保持其原始顺序，不会发生改变。
不可变性：元组的元素是不可修改、删除或添加的。

常用方法：

len()
count()
index()

列表

列表的特点

有序性
可变性
可存储不同类型的元素

列表的构造方法

 ` l1 = list("abc")`

列表操作

1.列表中元素的引用

l = [1,2,3,4,5]
print(l[0])

2.列表中元素的修改

l = [1,2,3,4,5]
l[0] = 111

3.列表的切片操作

l = [1,2,3,4,5]
print(l[0:3])

4.统计查找操作

l = [1,2,3,4,5,1,2,3,3]
count(value) 在列表中统计参数 value 出现的次数
print(l.count(3))

index(value, start, stop) 在列表中查找参数 value 第一次出现的下标位置，如果给定范围则只在范围内查找，如果查找目标不存在则抛出错误。

l = [1,2,3,4,5,1,2,3,3]
print(l.index(3))
print(l.index(3,5,10))

5.增加元素

append(value) 向列表最后追加元素

extend(iterable) 将一个可迭代对象的元素依次添加到列表最后

l.insert(0, "A")
print(l)

6.删除元素

del 可以使用 del 关键字结合索引来删除指定位置的元素。如果指定的下标不存在则抛出一个错误。

l = [1,2,3,4,5,1,2,3]
del l[0]
print(l)
del l[10]

remove(value) 在列表中删除第一个指定的数据，如果删除的数据不存在则抛出错误

l = [1,2,3,4,5,1,2,3]
l.remove(3)
print(l)
l.remove(33)

pop(index) 从列表中取出并删除指定下标位置的元素，默认取出并删除最后一个元素，如果指定下标不存在，则会抛出一个错误。

l = [1,2,3,4,5,1,2,3]
print(l.pop())
print(l)

clear() 清空列表

7.列表排序
sort(key, reverse) 对列表进行排序

sort方法默认对基本数据类型进行升序排序
reverse参数将列表元素排序后将列表逆序，实现降序排序
key 参数用来指定排序规则，比如使用学生的年龄进行排序（此处不讲解该参数的使用，在lambda处讲解）

l = ["a","abc","ab","A"]
l.sort()
print(l)
l = ["a","abc","ab","A"]
l.sort(reverse=True) 
print(l)

元组和列表的区别

相同点：1.都是有序的，可迭代的数据结构。2.都可以存放不同数据类型的元素
不同点：1.元组是不可变的，不可以进行增删改操作，列表是可变的，可以进行增删改操作。2.实现机制不同，相同元素和个数的情况下，元组占用的内存空间更小

from sys import getsizeof
t = (1, 2, 3, 4, 5, 6, 7, 8, 9, 0)
l = [1, 2, 3, 4, 5, 6, 7, 8, 9, 0]
print(getsizeof(t))
print(getsizeof(l))

字典

字典的创建

d1 = {}
d2 = {"name": "Alice", "age": 25, "gender": "female"}

构造字典：

d1 = dict(one=1, two=2, three=3)
d2 = dict([('two', 2), ('one', 1), ('three', 3)])
d3 = dict((('two', 2), ('one', 1), ('three', 3)))

字典操作

stu = {"name":"Tom", "age": 23, "gender":"male"}
1.字典数据访问
print(stu["age"])

2.字典元素添加与修改
格式： 字典对象[key] = value

# 添加新元素
stu["address"] = "BeiJing"
print(stu)
# 修改数据
stu["name"] = "Jack"
stu["address"] = "ShangHai"
print(stu)

3.字典元素的删除

# 删除元素
del stu['age']
print(stu)
del stu['address']
print(stu)

4.字典数据获取
stu = {'name': 'Tom', 'age': 23, 'gender': 'male', 'address': 'BeiJing'}
keys() 用来获取字典中所有的 key，保存到一个列表中
ks = stu.keys()
values() 用来获取字典中所有的value, 保存到一个列表中，并以 dict_values 类型返回
ks = stu.values()
items() 用来获取字典中所有的键值对，每一个元素键值对都以一个元组保存，将所有元素元组保存到一个列表中，并以 dict_items 类型返回

ks = stu.items()
print(ks)

get(key, default) 用来获取key对应的值，如果指定的key不存在，则返回默认值。

print(stu.get("name"))
print(stu.get("hobby"))

5.字典添加更新
stu = {‘name’: ‘Tom’, ‘age’: 23, ‘gender’: ‘male’, ‘address’: ‘BeiJing’}

setdefault(key,default) 给一个不存在的key添加一个默认值并将该键值对保存到字典中

stu.setdefault("hobby1")
print(stu)
stu.setdefault("hobby2", "无")
print(stu)

fromkeys(keys,val) 用于创建一个新字典，以序列 keys 中元素做字典的键，value 为字典所有键对应的初始值,默认为None 。

ks = ("name", "age", "gender")
s1 = dict.fromkeys(ks)
print(s1)

s2 = dict.fromkeys(ks,"无")
print(s2)

update(d/iterable) 使用参数中的数据更新当前字典。

6.字典删除类
popitem() 用来获取并删除字典中的最后一个键值对，返回一个元组，如果字典为空时，则抛出一个错误

stu = {'name': 'Tom', 'age': 23, 'gender': 'male', 'address': 'BeiJing'}
v = stu.popitem()
print(v)
print(stu)

pop(key) 用于获取并删除字典中指定key对应的键值对。如果指定的key不存在，则抛出错误
clear() 清空字典中所有的键值对元素

集合

集合的创建

不能使用 {} 创建一个空集合，因为此种方式创建的类型为字典。

# 不能使用花括号 {} 来定义一个空集合
s1 = set()
s2 = {}
print(type(s1))
print(type(s2))

# 使用花括号 {}，在内部添加元素，用逗号 , 分隔
my_set = {1, 2, 3, 4, 5}

# 使用内置函数 set() 创建集合
my_set = set([1, 2, 3, 4, 5])

# 集合元素具有唯一性
s = {1,1,1,2,3,4,5,6,6,6,6,6,6,6}
print(s)

执行结果：

<class 'set'>
<class 'dict'>
{1, 2, 3, 4, 5, 6}

集合操作

1.添加操作

add(ele) 向集合中添加一个元素,如果元素已存在则不产生任何影响
update(others) 更新集合，添加来自 others 中的所有元素,others是一个可迭代对象，如果数据在集合中存在则不更新。

s = {1, 2, 3}

s.update((4,5,6))
print(s)
s.update([5,6,7])
print(s)
s.update({6,7,8,9})
print(s)

执行结果：

{1, 2, 3, 4, 5, 6}
{1, 2, 3, 4, 5, 6, 7}
{1, 2, 3, 4, 5, 6, 7, 8, 9}

2.删除操作
s = {1, 2, 3}

pop() 从集合中移除并返回任意一个元素，如果集合为空，则抛出错误s.pop()
remove(elem) 从集合中移除元素 elem。如果 elem 不存在于集合中则抛出错误。
s.remove(1)
discard(elem) 如果元素 elem 存在于集合中则将其移除，如果elem不存在，则什么也不做
clear() 清空集合s.clear()

3.集合操作

判断两个集合是否不相交

isdisjoint(other) 如果集合中没有与 other 共有的元素则返回 True。当且仅当两个集合的交集为空集合时，两者为不相交集合。

s = {1, 2, 3}

print(s.isdisjoint({4, 5, 6}))
print(s.isdisjoint({3, 4, 5}))

判断集合是否是另一个集合的子集

issubset(other) 检测是否集合中的每个元素都在 other 之中。

s = {1, 2, 3}

# 判断 s 是否为 other参数的子集
print(s.issubset({1, 2, 3}))
print(s.issubset({1, 2, 3, 4}))
print(s.issubset({3, 4, 5}))
print("*" * 10)
# 也可以通过运算符 <= 直接判断
print(s <= {1, 2, 3})
print(s <= {1, 2, 3, 4})
print(s <= {3, 4, 5})
print("*" * 10)

# 判断是否为真子集
print(s < {1, 2, 3})
print(s < {1, 2, 3, 4})
print(s < {3, 4, 5})

执行结果：

True
True
False
**********
True
True
False
**********
False
True
False

判断集合是否是另一个集合的超集

issuperset(other) 检测是否 other 中的每个元素都在集合之中。

s = {1, 2, 3, 4}

# 判断 s 是否为 other参数的超集
print(s.issuperset({1, 2, 3}))
print(s.issuperset({1, 2, 3, 4}))
print(s.issuperset({3, 4, 5}))
print("*" * 10)
# 也可以通过运算符 >= 直接判断
print(s >= {1, 2, 3})
print(s >= {1, 2, 3, 4})
print(s >= {3, 4, 5})
print("*" * 10)

# 判断是否为真超集
print(s > {1, 2, 3})
print(s > {1, 2, 3, 4})
print(s > {3, 4, 5})

执行结果：

True
True
False
**********
True
True
False
**********
True
False
False

并集

union(*other) 返回一个新集合，其中包含来自原集合以及 others 指定的所有集合中的元素,other可以指定多个集合

s1 = {1, 2, 3, 4}
s2 = {3, 4, 5, 6}
s3 = {5, 6, 7, 8}
print(s1.union(s2))
print(s1.union(s2,s3))
# 也可以使用 | 进行集合并集运算
print(s1 | s2)
print(s1 | s2 | s3)

执行结果：

{1, 2, 3, 4, 5, 6}
{1, 2, 3, 4, 5, 6, 7, 8}
{1, 2, 3, 4, 5, 6}
{1, 2, 3, 4, 5, 6, 7, 8}

交集

intersection(*others) 返回一个新集合，其中包含原集合以及 others 指定的所有集合中共有的元素。

s1 = {1, 2, 3, 4}
s2 = {3, 4, 5, 6}
s3 = {5, 6, 7, 8}
print(s1.intersection(s2))
print(s1.intersection(s2, s3))
print(s1.intersection(s3))
print("*" * 10)
# 也可以使用 & 进行集合交集运算
print(s1 & s2)
print(s1 & s2 & s3)
print(s1 & s3)

执行结果：

{3, 4}
set()
set()
**********
{3, 4}
set()
set()

差集

difference(*others) 返回一个新集合，包含原集合中在 others 指定的其他集合中不存在的元素。

s1 = {1, 2, 3, 4}
s2 = {3, 4, 5, 6}
s3 = {5, 6, 7, 8}
print(s1.difference(s2))
print(s1.difference(s2, s3))
print(s1.difference(s3))
print("*" * 10)
# 也可以使用 - 进行集合差集运算
print(s1 - s2)
print(s1 - s2 - s3)
print(s1 - s3)

执行结果：

{1, 2}
{1, 2}
{1, 2, 3, 4}
**********
{1, 2}
{1, 2}
{1, 2, 3, 4}
set()
set()

对称差集

symmetric_difference(other) 返回一个新集合，其中的元素或属于原集合或属于 other 指定的其他集合，但不能同时属于两者。

s1 = {1, 2, 3, 4}
s2 = {3, 4, 5, 6}
s3 = {5, 6, 7, 8}
print(s1.symmetric_difference(s2))
print(s1.symmetric_difference(s3))
print("*" * 10)
# 也可以使用 ^ 进行集合对称差集运算
print(s1 ^ s2)
print(s1 ^ s3)

执行结果：

{1, 2, 5, 6}
{1, 2, 3, 4, 5, 6, 7, 8}
**********
{1, 2, 5, 6}
{1, 2, 3, 4, 5, 6, 7, 8}