0基础python组合数据类型学习

1.列表

一、基础定义

列表是 Python 中最常用的组合数据类型,用于存储多个元素。
特点

  • 可变:可以修改、添加或删除元素。
  • 有序:元素按插入顺序排列,可通过索引访问。
  • 可重复:允许存储重复元素。
  • 异构:可以存储不同类型的元素(如整数、字符串、列表等)。

二、创建列表

# 空列表
empty_list = []  # 或 list()

# 包含元素的列表
numbers = [1, 2, 3, 4]
mixed = [1, "hello", True, [5, 6]]  # 异构列表
nested = [[1, 2], [3, 4]]  # 嵌套列表

# 通过构造函数创建
constructed = list("hello")  # ['h', 'e', 'l', 'l', 'o']

三、基本操作

1. 访问元素

my_list = ["apple", "banana", "cherry"]

# 通过索引访问(从0开始)
print(my_list[0])  # 输出:apple
print(my_list[-1])  # 输出:cherry(负数索引表示从后往前)

# 切片:获取子列表 [start:stop:step]
print(my_list[1:3])  # 输出:['banana', 'cherry']
print(my_list[::2])  # 输出:['apple', 'cherry'](步长为2)

2. 修改元素

my_list = [1, 2, 3]
my_list[0] = 100  # 修改第一个元素
print(my_list)  # 输出:[100, 2, 3]

3. 添加元素

my_list = [1, 2]

my_list.append(3)  # 在末尾添加单个元素
my_list.extend([4, 5])  # 在末尾添加多个元素(扩展列表)
my_list.insert(1, 100)  # 在指定位置插入元素(索引1处)

print(my_list)  # 输出:[1, 100, 2, 3, 4, 5]

4. 删除元素

my_list = [1, 2, 3, 2]

my_list.remove(2)  # 删除首个值为2的元素
popped = my_list.pop()  # 删除并返回最后一个元素
del my_list[0]  # 删除指定索引的元素

print(my_list)  # 输出:[3]

5. 查询元素

my_list = [1, 2, 3, 2]

index = my_list.index(2)  # 返回首个值为2的索引(输出:1)
count = my_list.count(2)  # 统计值为2的元素数量(输出:2)
exists = 3 in my_list  # 判断元素是否存在(输出:True)

四、常用方法

方法描述
append(x)在列表末尾添加元素 x
extend(iterable)将可迭代对象(如列表、元组)的元素添加到列表末尾。
insert(i, x)在索引 i 处插入元素 x
remove(x)删除首个值为 x 的元素,若不存在则报错。
pop([i])删除并返回索引 i 处的元素(默认删除最后一个)。
clear()清空列表所有元素。
index(x)返回首个值为 x 的索引,若不存在则报错。
count(x)统计值为 x 的元素出现的次数。
sort(key=None, reverse=False)原地排序(升序),可通过 reverse=True 降序。
reverse()原地反转列表元素的顺序。
copy()返回列表的浅拷贝(创建新列表,但元素引用相同)。

五,进阶操作

1. 列表推导式

语法[表达式 for 变量 in 可迭代对象 [条件]]
示例

# 生成平方数列表
squares = [x**2 for x in range(5)]  # [0, 1, 4, 9, 16]

# 过滤偶数
evens = [x for x in range(10) if x % 2 == 0]  # [0, 2, 4, 6, 8]

# 嵌套推导式(二维列表转一维)
matrix = [[1, 2], [3, 4]]
flattened = [num for row in matrix for num in row]  # [1, 2, 3, 4]
2. 浅拷贝 vs 深拷贝
# 浅拷贝(仅复制外层结构,内部元素引用相同)
original = [1, [2, 3]]
shallow_copy = original.copy()  # 或 original[:]
shallow_copy[1][0] = 99  # 修改内部列表
print(original)  # 输出:[1, [99, 3]](原列表也被修改)

# 深拷贝(完全独立的副本)
import copy
deep_copy = copy.deepcopy(original)
deep_copy[1][0] = 100
print(original)  # 输出:[1, [99, 3]](原列表不受影响)

3. 常用内置函数
my_list = [3, 1, 4]

length = len(my_list)  # 长度:3
total = sum(my_list)  # 求和:8
max_val = max(my_list)  # 最大值:4
min_val = min(my_list)  # 最小值:1

sorted_list = sorted(my_list)  # 返回新的排序列表:[1, 3, 4]
reversed_list = list(reversed(my_list))  # 返回反转后的列表:[4, 1, 3]

 

2,元组

一、基础定义

  • 不可变:创建后不能修改元素。
  • 有序:可通过索引访问。
  • 异构:支持不同类型元素。

二、创建元组

empty = ()                # 空元组
single = (1,)             # 单元素元组(必须加逗号)
mixed = (1, "a", [2, 3])  # 异构元组
implicit = 1, 2, 3        # 省略括号(推荐)

三、核心操作

  1. 访问元素

    t = ("a", "b", "c")
    print(t[0])     # 输出:a
    print(t[-1])    # 输出:c(负数索引)
    print(t[1:3])   # 输出:('b', 'c')(切片)
    
  2. 元组解包

    x, y = (1, 2)   # x=1, y=2
    a, b= (1, 2, 3)  # a=1, b=[2, 3]

    查询方法

    t = (1, 2, 2)
    print(t.index(2))  # 输出:1(首个索引)
    print(t.count(2))  # 输出:2(出现次数)
    

四、不可变性

元组本身不可变,但内部可变元素(如列表)可修改:

t = (1, [2, 3])
# t[0] = 100  # 报错!元组不可变
t[1][0] = 99  # 允许!修改列表内部
print(t)      # 输出:(1, [99, 3])

五、注意事项

  1. 单元素元组需逗号(1,) 而非 (1)
  2. 不可变元素限制:元组元素必须全部可哈希(如不可包含列表)。

 

3,字典

一、基础定义

  • 无序键值对集合(3.7+ 保持插入顺序)
  • 键必须唯一且可哈希(如字符串、数字、元组)
  • 值可为任意类型

二、创建字典

empty = {}  # 空字典
person = {
    "name": "Alice",
    "age": 30,
    "hobbies": ["reading", "swimming"]
}

# 快捷方式
from_pairs = dict([("x", 1), ("y", 2)])  # {'x': 1, 'y': 2}

三、核心操作

1,访问值

print(d["name"])  # 输出:Alice
print(d.get("age", 25))  # 安全访问,默认值 25

2,修改/添加

d["age"] = 30     # 添加新键值对
d["name"] = "Bob" # 修改已有值
d.update({"city": "Beijing"})  # 批量更新

 3,删除

del d["age"]
d.pop("city", None)  # 安全删除

四、常用方法

方法作用
keys()返回所有键
values()返回所有值
items()返回所有键值对
get(key, default)安全获取值(不存在返回默认值)
update()合并字典(覆盖重复键)
pop(key)删除并返回值

五、字典推导式

# 生成平方数
squares = {x: x**2 for x in range(3)}  # {0: 0, 1: 1, 2: 4}

# 筛选偶数
evens = {x: x**2 for x in range(5) if x % 2 == 0}  # {0: 0, 2: 4, 4: 16}

六、注意事项

  1. 键必须不可变

    valid = {(1, 2): "point"}  # 元组可哈希
    # invalid = {[1, 2]: "point"}  # 列表不可哈希(报错

 

 4,集合

一、基础特性
  • 无序、唯一、元素可哈希
  • 空集合:set()(注意:{} 是字典)
二、核心操作
  1. 创建与去重

    s = {1, 2, 2}  # 自动去重为 {1, 2}
    s = set([1, 2, 2])  # 从列表转换
    
  2. 修改

    s.add(3)        # 添加元素
    s.update([3,4]) # 批量添加
    s.remove(2)     # 删除(不存在则报错)
    s.discard(2)    # 安全删除
    s.pop()         # 随机删除并返回
    s.clear()       # 清空
    
  3. 查询

    3 in s          # 判断元素是否存在
    len(s)          # 获取元素个数
    
三、集合运算
操作语法示例(a={1,2}b={2,3}
并集`ab`{1,2,3}
交集a & b{2}
差集a - b{1}
对称差a ^ b{1,3}
四、推导式
s = {x**2 for x in [1,2,2]}  # {1,4}(自动去重)
五、注意事项
  • 元素必须可哈希(如 intstrtuple
  • 不可用列表、字典等可变类型作为元素
评论
添加红包

请填写红包祝福语或标题

红包个数最小为10个

红包金额最低5元

当前余额3.43前往充值 >
需支付:10.00
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明:

1.余额是钱包充值的虚拟货币,按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载,可以购买VIP、付费专栏及课程。

余额充值