python的序列

Python的数据类型

序列

序列：块可以存放多个值的连续空间

1.列表：[] <class 'list'>

列表：[] 可以存储任意类型的元素

1.1存储类型:任意

list=[1,'张三', 1.2, True,[2,3],{"name":"张三"}]
print(list)
print(type(list))

​ 输出：

[1, '张三', 1.2, True, [2, 3], {'name': '张三'}]
<class 'list'>

1.2 增

• list.append(x) # 在末尾添加单个元素 x,效率高

• list.insert(i,x) #在索引 i 处插入元素 x

• list.extend(iter) #iter为列表、元组、字符串，字典类型无法完全存储，只能将key存到列表中

• list3 = list1 + list2

1.3 删

• list.remove("苹果")#只删除第一个出现的匹配元素，若元素不存在会报错

list = ["苹果", "香蕉", "苹果", "橙子"]
list.remove("苹果")  # 删除第一个"苹果"
print(lst)  # 输出：['香蕉', '苹果', '橙子']

• 循环 remove()：删除所有匹配的元素

lst = ["苹果", "香蕉", "苹果", "橙子"]
while "苹果" in lst:  # 循环删除，直到没有"苹果"
    lst.remove("苹果")
print(lst)  # 输出：['香蕉', '橙子']

• list.pop()#无参数时，默认删除最后一个元素
  有参数时，删除指定索引的元素，并返回该元素
若索引超出范围（如 lst.pop(10)），会报错 IndexError

lst = ["苹果", "香蕉", "橙子"]
# 删除指定索引的元素（索引1）
item = lst.pop(1)
print(item)       # 输出：香蕉（返回该元素）
print(lst)        # 输出：['苹果', "橙子"]

• del语句#可删除单个元素、连续切片，甚至清空列表

lst = ["苹果", "香蕉", "橙子", "西瓜"]

# 删除索引1的元素
del lst[1]
print(lst)  # 输出：['苹果', '橙子', '西瓜']

# 删除切片 索引就相当于下标，可以看为[1,2)左闭右开的集合
del lst[1:2]
print(lst)  # 输出：['苹果', "橙子",'西瓜']

# 清空列表（删除所有元素）
del lst[:]
print(lst)  # 输出：[]

清空列表：lst.clear()/重新赋值

lst = ["苹果", "香蕉"]
lst = []  # 原列表被覆盖，内存中会被垃圾回收
print(lst)  # 输出：[]

1.4 改

• 通过索引修改单个元素，并重新赋值

索引从 0 开始，支持负数（-1 表示最后一个元素）
负数就是倒着数，只不过从-1开始数

• 通过切片
• 循环遍历

# 将列表中所有小于5的元素翻倍
lst = [1, 6, 3, 8, 4]
for i in range(len(lst)):
    if lst[i] < 5:
        lst[i] *= 2  # 修改当前元素
print(lst)  # 输出：[2, 6, 6, 8, 8]

1.5 查

• X in list

lst = ["苹果", "香蕉", "橙子"]
a="苹果" in lst
print(a)  #True

• index()

lst = ["苹果", "香蕉", "橙子","苹果", "香蕉", "橙子","苹果", "香蕉", "橙"]

index=lst.index("橙",-6,-1)#[-6,-1)
print(index)

• list.count(element)统计元素在列表中出现的次数（整数）
  可以根据count的值判断列表中是否存在某个元素
• 遍历列表查找

numbers = [5, 12, 8, 15, 3]

# 查找第一个大于10的数
for num in numbers:
    if num > 10:
        print(f"找到第一个大于10的数：{num}")  # 输出：12
        break  # 找到后立即退出循环
else:  # 循环未被break时执行（即没找到）
    print("没找到大于10的数")

2.元组：()<class 'tuple'>

元组：() 可以存储任意类型的对象
特点：

• 不可变性：元组的元素不能被修改、添加或删除。
• 有序性：元素按插入顺序排列，支持索引访问。

# 创建元组
t = (1, 2, "apple")  # 常见写法
t = 1, 2, "apple"    # 省略括号也可以
t = (1,)             # 单个元素的元组，必须加逗号
t = ()               # 空元组

2.1 增

拼接创建新元组

t1 = (1, 2)
t2 = (3, 4)
new_t = t1 + t2  # 创建新元组，原元组不变
print(new_t)     # 输出：(1, 2, 3, 4)

使用 * 复制元组

t = (1, 2)
new_t = t * 3    # 创建新元组，重复3次
print(new_t)     # 输出：(1, 2, 1, 2, 1, 2)

添加单个元素

t = (1, 2)
new_t = t + (3,)  # 必须加逗号，否则 (3) 是整数
print(new_t)      # 输出：(1, 2, 3)

2.2 删

删除整个元组del

t = (1, 2, 3)
del t          # 删除元组对象
# print(t)     # 报错：NameError（变量t已被删除）

2.3 改

元组的元素不可修改，只能创建新元组
可以修改嵌套列表中的元素

t = (1, [2, 3])
t[1][0] = 20  # 修改列表的第一个元素
print(t)      # 输出：(1, [20, 3])

2.4 查

通过索引和切片

t = (1, 2, 3, 4, 5)
#索引
print(t[0])   # 输出：1（第一个元素）
print(t[-1])  # 输出：5（最后一个元素）
# print(t[10])  # 报错：IndexError（索引越界）

#切片  左闭右开的区间
print(t[1:3])   # 输出：(2, 3)（索引1到2的元素）
print(t[:3])    # 输出：(1, 2, 3)（前3个元素）
print(t[3:])    # 输出：(4, 5)（从索引3到末尾）

使用in判断元素是否存在

t = (1, "apple", 3.14)
print("apple" in t)  # 输出：True
print(2 in t)        # 输出：False

使用 index()
使用 count()

t = (1, 2, "apple", 2)
print(t.index("apple"))  # 输出：2（元素"apple"的索引）
print(t.count(2))        # 输出：2（元素2出现的次数）

3.字典：{key:value} <class 'dict'>

在 Python 中，字典（dict）是一种无序的键值对集合，通过键来快速访问值。
字典的 值（value） 可以存储任意类型的对象，包括字符串、元组、字典、列表、布尔值、整数等，甚至可以混合存储不同类型。字典的 键（key） ，必须是可哈希不可变对象。
什么叫做可哈希

我的理解是，很难局部改变，都是整个改变的，是不可变的

3.1 增

直接赋值

d = {"name": "Alice"}
d["age"] = 30       # 添加新键值对
d["city"] = "Beijing"
print(d)  # 输出：{'name': 'Alice', 'age': 30, 'city': 'Beijing'}

使用 update() 方法

d = {"name": "Alice", "age": 30}
print(d)
d.update({"gender": "female", "age": 31})  # 已有键会被覆盖
print(d) 

#输出：{'name': 'Alice', 'age': 30}
{'name': 'Alice', 'age': 31, 'gender': 'female'}

3.2 删

使用 del 语句

d = {"name": "Alice", "age": 30, "city": "Beijing"}
del d["age"]        # 删除指定键

使用 pop() 方法（删除并返回值）

age = d.pop("age")  # 删除并返回值
print(age)          # 输出：30
default = d.pop("cit", "N")  # 键不存在时返回默认值
print(default)      # 输出：N

使用 clear() 方法（清空字典）

3.3 改

直接赋值
使用 update() 方法同“增"里面的update

3.4 查

通过键访问

d = {"name": "Alice", "age": 30}
print(d["name"])  # 输出：Alice

使用 get() 方法

print(d.get("name"))      # 输出：Alice
print(d.get("city"))      # 输出：None（默认值）
print(d.get("city", "N/A"))  # 输出：city键不存在时自定义默认返回值为N/A

检查键是否存在

if "age" in d:
    print("年龄:", d["age"])  # 输出：年龄: 30

if "city" not in d:
    print("城市信息不存在")  # 执行此代码

通过value找到key

my_dict = {'a': 1, 'b': 2, 'c': 2}

# 查找值为2的所有键
keys = []
for key, value in my_dict.items():
    if value == 2:
        keys.append(key)

print(keys)  # 输出: ['b', 'c']

4.集合：{} <class 'set'>

集合中的元素必须是不可变类型，包括：
基本数据类型：整数（int）、浮点数（float）、字符串（str）、布尔值（bool）。
元组（tuple）：但元组内的所有元素也必须是不可变类型。
冻结集合（frozenset）：因为 frozenset 本身不可变。

set1={
    "ta",
    1,
    2.1,
    True,
    # {"name":"John", "age":20}, #TypeError: unhashable type: 'dict'
    (1,2),
    # [False,1] #TypeError: unhashable type: 'list'
    }
print(set1)#输出：{1, 'ta', (1, 2), 2.1}
print(type(set1))#输出：<class 'set'>

4.1 增

s.add()

s = {1, 2, 3}

# 添加单个元素（若元素已存在，则无操作）
s.add(4)      # s 变为：{1, 2, 3, 4}
s.add(2)      # 无操作，元素 2 已存在

s.update

# 添加多个元素（参数必须是可迭代对象）
s = {1, 2, 3}
s.update([4, 5, 6])  # s 变为：{1, 2, 3, 4, 5, 6}
s.update("abc")     # s 变为：{1, 2, 3, 4, 5, 6, 'a', 'b', 'c'}

如果传入的参数不是可迭代对象（例如整数、浮点数）,会抛出 TypeError：

s = {1, 2}
s.update(3)  # 报错：TypeError: 'int' object is not iterable

# 正确做法：用列表/元组包装单个元素
s.update([3])  # 或 s.update((3,)) → s 变为 {1, 2, 3}

4.2 删

s.remove()

s = {1, 2, 3, 4, 5}
# 删除指定元素（元素不存在时会报错）
s.remove(3)       # s 变为：{1, 2, 4, 5}
# s.remove(10)    # 报错：KeyError

s.discard()

s = {1, 2, 3, 4, 5}
# 删除指定元素（元素不存在时静默处理）
s.discard(4)      # s 变为：{1, 2, 5}
s.discard(10)     # 无操作，不报错

s.pop():随机删除并返回一个元素,因为集合无序，无法预知删除哪个

s = {1, 2, 3, 4, 5}
popped = s.pop()

4.3 改

集合中的元素必须是不可变类型（如数字、字符串、元组），且元素具有唯一性，因此无法直接修改。若需修改，需先删除旧元素，再添加新元素：

4.4 查

使用in关键字

s = {1, 2, 3}

# 使用 in 关键字检查元素是否存在（时间复杂度 O(1)）
print(2 in s)      # 输出：True
print(10 not in s) # 输出：True

对于集合的特性：不可重复性/唯一性，多个集合间可实现去重

集合不能使用索引，因为集合无序

集合的其他操作

a = {1, 2, 3, 4}
b = {3, 4, 5, 6}

# 交集：同时存在于两个集合的元素
print(a & b)      # 输出：{3, 4}
print(a.intersection(b))  # 等价方法

# 并集：合并两个集合的所有元素（自动去重）
print(a | b)      # 输出：{1, 2, 3, 4, 5, 6}
print(a.union(b)) # 等价方法

# 差集：存在于 a 但不存在于 b 的元素
print(a - b)      # 输出：{1, 2}
print(a.difference(b))  # 等价方法

# 对称差集：只存在于一个集合中的元素
print(a ^ b)      # 输出：{1, 2, 5, 6}
print(a.symmetric_difference(b))  # 等价方法

s = {1, 2, 3}

# 判断子集/超集
print({1, 2}.issubset(s))      # 输出：True
print(s.issuperset({1, 2}))    # 输出：True

# 判断集合是否不相交（没有共同元素）
print(s.isdisjoint({4, 5}))    # 输出：True

# 集合长度
print(len(s))                  # 输出：3

# 使用花括号创建集合（注意：空集合必须用 set()）
fruits = {"apple", "banana", "cherry"}
empty_set = set()  # 空集合

# 从列表/元组创建集合（自动去重）
numbers = set([1, 2, 2, 3])  # 结果：{1, 2, 3}
letters = set("hello")       # 结果：{'h', 'e', 'l', 'o'}

5.字符串：""或'' <class 'str'>

索引：

索引：跟java中的下标有点类似，但不完全相同
1. 有正数表示，从左到右，从0开始
2. 有负数表示，从右到左，从-1开始，依次-2，-3，-4...
3. 正负表示区间移动方向

序列名[索引值]:

lst=[1,2,3,4,5,6,7,8,9]
print(lst[2]) #输出:3,索引值依次为0,1,2....
print(lst[-2]) #输出:8, 索引值从右往左数依次为-1,-2...

切片语法

序列名[起始索引:结束索引:步长]左闭右开的区间
起始索引：开始的索引值
结束索引：结束的索引值
步长：自增的量。可以省略不写，默认为1.正负表示方向

num_list=[11,22,33,44,55,66,88,99]
        # 0   1  2  3  4  5  6  7
        # -8 -7 -6 -5 -4 -3 -2 -1         
print(num_list[:6:-1])#在索引值为6结束，所以到88这个元素的时候应该停止。-1：方向从右到左，步长为1
                      #输出：[99]
print(num_list[2::-1])#在索引值为2开始，所以从33这个元素开始，-1：方向从右到左，步长为1
                      #输出:[33,22,11]
print(num_list[4:1:1])#在索引值为4开始，所以从55这个元素开始,1：方向从左到右，步长为1
                      #输出：[]   why? 从索引值为4开始出发，一直往右走也找不到索引值为1的元素
print(num_list[100:200:1])
#输出：[]
why?
如果 start 超出列表的有效范围（即 start >= len(list)），切片直接返回空列表 []，无论 stop 和 step 如何设置。

print(num_list[100:1:1])#输出：[]
print(num_list[1:100:1])#输出：[22, 33, 44, 55, 66, 88, 99]