Python学习二

最新推荐文章于 2025-12-01 14:28:11 发布

原创最新推荐文章于 2025-12-01 14:28:11 发布 · 852 阅读

8 ·

本内容遵循CC 4.0 BY-SA版权协议

GEO检测

这周主要学习了python中主要的数据容器，包括列表，元组，字符串，序列，集合，字典。同时还学习了函数的多种参数使用形式，函数作为参数传递，lambda匿名函数等。
一、列表（List）

1. 定义与创建

列表是有序、可变的序列，用方括号`[]`括起来，元素之间用逗号分隔。可以容纳不同类型的数据。

my_list = [1, "hello", True, 3.14]

2. 索引与切片

索引从 0 开始，可通过`[index]`获取单个元素，负数索引表示从末尾开始计数。切片使用`[start:stop:step]`格式，获取子列表。

print(my_list[0])  # 输出 1
print(my_list[-1])  # 输出 3.14
print(my_list[1:3])  # 输出 ["hello", True]

3. 常用方法

`append(item)`：在列表末尾添加元素。

my_list.append("new_item")

`extend(iterable)`：将可迭代对象的元素添加到列表末尾。

another_list = [5, 6]
my_list.extend(another_list)

`insert(index, item)`：在指定索引处插入元素。

my_list.insert(2, "inserted")

`remove(item)`：移除列表中第一个匹配的元素。

my_list.remove("hello")

`pop([index])`：移除并返回指定索引处元素，默认移除末尾元素。

popped_item = my_list.pop(0)

4. 特征与用途

- 特征：可变、有序，可存储多种数据类型，内存占用灵活随元素增减变化。

- 用途：适合需要频繁修改、增删元素的数据集合场景，如记录动态变化的任务列表、学生成绩列表等。

二、元组（Tuple）

1. 定义与创建

元组是有序、不可变的序列，用圆括号`()`括起来，元素间逗号分隔。单个元素元组需在末尾加逗号避免歧义。

my_tuple = (1, "world", False)
single_tuple = (2,)

2. 索引与切片

索引和切片规则同列表，只是不能修改元组内元素。

print(my_tuple[0])  # 输出 1
print(my_tuple[1:])  # 输出 ("world", False)

3. 常用方法

- 因不可变，没有增删改方法，常用`count(item)`统计元素出现次数、`index(item)`查找元素首次出现索引。

print(my_tuple.count(1))  # 输出 1
print(my_tuple.index("world"))  # 输出 1

4. 特征与用途

特征：不可变保证数据安全稳定，有序便于按位置访问，占用内存固定。

用途：用于存储不应被修改的相关数据组合，像坐标点`(x, y)`、数据库记录字段组合等。

三、字符串（String）

1. 定义与创建

- 字符串是字符的有序序列，用单引号`''`、双引号`""`或三引号`''' '''`（可跨行）括起来。

my_str = "Hello, Python"
multi_line_str = '''This is a
multi-line string.'''

2. 索引与切片

- 按字符索引，规则同列表，切片获取子字符串。

print(my_str[0])  # 输出 'H'
print(my_str[7:])  # 输出 'Python'

3. 常用方法

- `upper()`：转换为大写。

print(my_str.upper())  # 输出 'HELLO, PYTHON'

- `lower()`：转换为小写。

print(my_str.lower())  # 输出 'hello, python'

- `strip([chars])`：去除首尾指定字符（默认空白字符）。

messy_str = "   spaces around  "
print(messy_str.strip())  # 输出'spaces around'

- `split(sep)`：按分隔符拆分字符串为列表。

words = my_str.split(", ")
print(words)  # 输出 ["Hello", "Python"]

- `join(iterable)`：用字符串连接可迭代对象元素。

new_str = "-".join(words)
print(new_str)  # 输出 'Hello-Python'

4. 特征与用途

- 特征：不可变，有序，文本数据存储与处理方便。

- 用途：广泛用于文本展示、文件读写、数据解析等场景，如网页内容处理、日志分析。

四、序列（Sequence）

1. 定义与特征

- 列表、元组、字符串都属于序列类型，具有共性：有序，能用索引访问元素，支持切片操作。

2. 通用操作示例

- `len(sequence)`：获取序列长度。

print(len(my_list))  # 列表长度
print(len(my_tuple))  # 元组长度
print(len(my_str))  # 字符串长度

- `in`与`not in`：判断元素是否在序列中。

print(1 in my_list)  # True
print("hello" not in my_tuple)  # True

五、集合（Set）

1. 定义与创建

- 集合是无序、不包含重复元素的数据容器，用花括号`{}`或`set()`函数创建。

my_set = {1, 2, 3, 3}  # 自动去重，实际为 {1, 2, 3}
set_from_list = set([4, 5, 4])  # 从列表转换，为 {4, 5}

2. 常用方法

- `add(item)`：添加元素。

my_set.add(4)

- `remove(item)`：移除元素，不存在会报错，`discard(item)`更安全，不存在不报错。

my_set.remove(2)
my_set.discard(5)

- `union(other_set)`：求并集。

set2 = {3, 4, 5}
union_set = my_set.union(set2)  # {1, 3, 4, 5}

- `intersection(other_set)`：求交集。

intersection_set = my_set.intersection(set2)  # {3, 4}

-’difference(other_set)':求差集。

返回一个包含在set1中但不在set2中的所有元素组成的新集合。

set1 = {10, 20, 30, 40}
set2 = {30, 40, 50}
result = set1.difference(set2)
print(result)

这种方法不会改变原来的集合，而是返回一个新的集合来表示差集结果。如果想要改变原集合，使其成为差集后的状态，可以使用difference_update()方法

set_a = {1, 2, 3}
set_b = {2, 3, 4}
set_a.difference_update(set_b)
print(set_a)

3. 特征与用途

- 特征：无序、自动去重，支持高效数学集合运算。

- 用途：常用于数据去重、判断元素唯一性，数学集合场景如求共同元素、合并数据（不重复合并）。

六、字典（Dictionary）

1. 定义与创建

- 字典是无序的键值对集合，用花括号`{}`创建，键与值用冒号`:`分隔，键必须唯一且不可变（常用字符串、数字），值可为任意类型。

my_dict = {"name": "Alice", "age": 25, "city": "New York"}

2. 索引与常用方法

- 通过键索引获取对应值，`my_dict["name"]`。

print(my_dict.keys())  # dict_keys(['name', 'age', 'city'])

- `keys()`：获取所有键组成的可迭代视图。

print(my_dict.values())  # dict_values(['Alice', 25, 'New York'])

- `values()`：获取所有值组成的可迭代视图。

print(my_dict.values())  # dict_values(['Alice', 25, 'New York'])

- `items()`：获取键值对元组组成的可迭代视图。

print(my_dict.items())  # dict_items([('name', 'Alice'), ('age', 25), ('city', 'New York')])

- `get(key, default)`：获取键对应值，不存在返回默认值，比直接索引更安全。

print(my_dict.get("job", "N/A"))  # N/A

- `update(other_dict)`：合并字典。

new_dict = {"job": "Engineer"}
my_dict.update(new_dict)

3. 特征与用途

- 特征：无序，通过键快速查找对应值，内存利用高效（哈希表实现）。

- 用途：适合存储关联数据，如用户信息（用户名对应密码、资料等）、配置参数（键为参数名，值为设置内容）。

七、函数的多种参数使用形式

1、位置参数

- 按顺序传入参数，函数定义与调用参数顺序对应。

def add_numbers(a, b):
    return a + b
result = add_numbers(3, 5)  # 8

2. 关键字参数

- 调用函数时指定参数名与值，顺序不限。

result = add_numbers(b=2, a=4)  # 6

3. 默认参数

- 函数定义时给参数设默认值，调用可不传该参数。

def greet(name="World"):
    return f"Hello, {name}!"
print(greet())  # Hello, World!
print(greet("Alice"))  # Hello, Alice!

4. 可变参数（*args）

- 接收不定数量的位置参数，打包成元组。

def sum_all(*args):
    return sum(args)
print(sum_all(1, 2, 3, 4))  # 10

5. 可变关键字参数（**kwargs）

- 接收不定数量的关键字参数，打包成字典。

def print_info(**kwargs):
    for key, value in kwargs.items():
        print(f"{key}: {value}")
print_info(name="Bob", age=30, city="London")

6. 函数作为参数传递

- 函数可作为参数传递给其他函数，增强代码复用与灵活性。

def apply_function(func, value):
    return func(value)
def square(x):
    return x ** 2
result = apply_function(square, 5)  # 25

7. lambda匿名函数

- 用`lambda`关键字定义匿名函数，简洁定义简单功能函数，语法`lambda 参数: 表达式`。常用于临时、简单场景，作为函数参数传递等。

double = lambda x: x * 2
print(double(3))  # 6

八、各数据容器区别

1. 列表与元组

- 列表可变，元组不可变。列表适合动态操作数据，元组用于固定数据组合，保障数据完整性、一致性。

2. 列表与集合

- 列表有序且允许重复，集合无序且自动去重。需要顺序与重复元素用列表，侧重唯一性、集合运算用集合。

3. 列表与字典

- 列表按索引存数据，字典用键值对。列表适合顺序处理数据，字典用于关联数据快速查找、存储。

4. 元组与集合

- 元组有序不可变，集合无序去重。元组侧重固定组合，集合关注元素唯一性与集合运算。

5. 元组与字典

- 元组索引访问简单数据组合，字典键值对关联复杂数据，字典键灵活查找，元组按位置访问。

6. 集合与字典

- 集合关注元素集合性质，字典聚焦键值映射关系，集合无键概念，字典依靠键定位值。

标签

#数据库