Pythonstudy——week2

Python 函数与数据处理
函数基础：（定义与调用）
·重复写代码不如封装成函数，只需修改逻辑

语法结构：

def 函数名(参数):
    函数要做的事情
    return 结果(可选)

·核心逻辑：def声明函数 → 括号里放（参数） → return出 “成品（结果）”

示例：定义一个打招呼的函数

def say_hello(name):
    return f"你好, {name}!"

result = say_hello("小明")
print(result)

参数与返回值
1.必传参数：
·定义时写的参数，调用时必须传值，否则报错

示例：

def say_hello(name):  # name是必传参数
    return f"你好, {name}"

say_hello("小明")  # 必须传name，否则报错

2.默认参数
·定义时给参数设默认值，调用时可以不传（用默认值），也可以传新值覆盖。

语法：def 函数名(参数1, 参数2=默认值):

示例：

def add(a, b=10):  # b默认是10
    return a + b

add(5)       # 只传a，b用默认值 → 15
add(5, 3)    # 传a和b，b用3 → 8

3.可变参数
·用*args接收任意数量的参数，参数会被打包成元组
·适合不确定要传多少个参数的场景（比如计算任意数的和）
示例：

def add_many(*args):  # 注意格式
    total = 0  # 初始化总和变量为0，累加的起点
    for num in args:  # 循环遍历args中每一个参数
        total += num
    return total  # 返回最终的总和

add_many(1, 2, 3)    # args=(1,2,3) → 6
add_many(1, 2, 3, 4) # args=(1,2,3,4) → 10

返回值的 2 种情况
函数的 “成品” 可以灵活返回，支持单个 / 多个值
1.返回单个值
·用return结果，直接返回一个数据（数字、字符串、列表等）
示例：

def get_name():
    return "小明"

name = get_name()  # name = "小明"

2.返回多个值
·用return 值1, 值2，会自动把多个值打包成元组
·可以用 “拆包” 的方式分别接收
示例：

def get_info():
    name = "小明"
    age = 20
    return name, age  # 自动打包元组("小明", 20)

# 拆包接收
name, age = get_info()
print(name)  # "小明"
print(age)   # 20

列表（List）增删改查操作
（一）增加元素
·append()方法
作用：在列表末尾添加一个元素

语法：列表名.append(要添加的元素)

示例：

fruits = ["苹果", "西瓜"]
fruits.append("橙子")
# 执行后 fruits 变为 ["苹果", "西瓜", "橙子"]

·insert 方法
作用：在列表指定索引位置插入元素，原索引及之后元素后移

语法：列表名.insert(索引, 要插入的元素)，索引从 0 开始计

示例：

fruits = ["苹果", "西瓜"]
fruits.insert(1, "梨")  
# 执行后 fruits 变为 ["苹果", "梨", "西瓜"]  在索引1插入

（二）删除元素
·pop() 方法
作用：删除列表中指定索引位置的元素，并返回被删除的元素，若不指定索引，默认删除最后一个元素

语法：被删除元素 = 列表名.pop(索引)（索引可选）

示例：

fruits = ["苹果", "香蕉", "西瓜"]
deleted = fruits.pop(1)  
# 删除索引1处的“香蕉”

remove() 方法
作用：删除列表中第一个匹配指定值的元素，若值不存在，会报错

语法：列表名.remove(要删除的值)

示例：

fruits = ["苹果", "香蕉", "香蕉", "橙子"]
fruits.remove("香蕉")  
# 删除第一个“香蕉”

（三）修改元素作用：直接通过索引定位元素，重新赋值实现修改语法：列表名[索引] = 新值
示例：

fruits = ["苹果", "香蕉", "橙子"]
fruits[1] = "西瓜"  
# 执行后，将索引1处的“香蕉”改为“西瓜”

（四）查询元素
直接索引查询

语法：元素 = 列表名[索引]，通过索引快速获取对应位置元素。索引可正可负，负数从末尾开始计数（-1 表示最后一个元素 ）

示例：

fruits = ["苹果", "香蕉", "橙子"]
print(fruits[0])   # 输出“苹果”
print(fruits[-1])  # 输出“橙子”

切片查询
作用：获取列表中一段连续的子列表，语法灵活，支持设置起始、结束索引和步长。

语法：子列表 = 列表名[起始索引:结束索引:步长]
#左闭右开（包含起始索引元素，不包含结束索引元素）
#步长指每次获取元素间隔的索引数，默认步长为 1

示例：

nums = [1, 2, 3, 4, 5, 6]
print(nums[1:3])   # 输出 [2, 3] → 取索引1到3（不包含3）的元素，步长1
print(nums[::2])   # 输出 [1, 3, 5] → 取索引0到末尾，步长2
print(nums[2:])    # 输出 [3, 4, 5, 6] → 取索引2到末尾，步长1
print(nums[:4])    # 输出 [1, 2, 3, 4] → 取从开头到索引4（不包含4），步长1

遍历查询
作用：依次获取列表中每个元素，常用于对元素逐个处理

语法:for循环遍历
     for 元素变量 in 列表名:

示例：

fruits = ["苹果", "香蕉", "橙子"]
for fruit in fruits:
    print(f"我喜欢吃 {fruit}")

列表常用操作总结
·增加
append(元素)：在列表末尾加元素
insert(索引, 元素)：在指定索引位置插入元素
·删除
pop(索引)：删除指定索引元素，返回被删元素
remove(值)：删除第一个匹配值的元素
·修改：列表名[索引] = 新值 → 修改指定索引位置元素
·查询
列表名[索引]：获取指定索引元素
列表名[起始:结束:步长]：获取子列表
for循环遍历：逐个获取元素处理

数据结构 - 字典
1.用{}存 “键 - 值对”，比如{"name": "小明", "age": 20}
2.核心操作：
·增 / 改：字典[键] = 值（键存在则改，不存在则增）
·删：del 字典[键] 或 字典.pop(键)
·查：字典[键] 或 字典.get(键)（推荐用get，避免报错）
·遍历：
for key in 字典（遍历键）
for value in 字典.values()（遍历值）
for k, v in 字典.items()（遍历键值对）
示例：初始化一个字典

person = {"name": "小明", "age": 20, "city": "北京"}

增 / 改

person["gender"] = "男"
person["age"] = 21

删

del person["city"]
age = person.pop("age")

查

print(person["name"])
print(person.get("gender"))
print(person.get("city"))  # 键不存在时，get返回None（不会报错）

文件操作与异常处理
1.文件读写三步骤：
·打开：open(文件名, 模式)，模式常用r（读）、w（写，覆盖）、a（追加）
·操作：读用read() / readline()，写用write()
·关闭：close()（或用with自动关闭）

2.异常处理：
·用try - except捕获错误（比如文件找不到、权限不够），让程序优雅报错
方式 1：手动关闭文件（易忘，不推荐）

try:
    f = open("test.txt", "w")  # 打开文件，模式w（写）
    f.write("Hello, Python!")  # 写入内容
    f.close()  # 关闭文件
except FileNotFoundError:
    print("文件路径有问题，找不到文件！")
except PermissionError:
    print("没有权限操作文件！")

★ 方式 2：用with自动关闭（推荐）

try:
    with open("test.txt", "r") as f:  # 模式r（读）
        content = f.read()  # 读取全部内容
        print("文件内容：", content)
except FileNotFoundError:
    print("文件不存在，读不了～")

异常处理的核心思路
所有这些场景的逻辑都是 “尝试执行核心操作 → 捕获预期错误 → 返回友好提示”，核心是：
1.明确函数可能出现的错误类型（比如FileNotFoundError、KeyError）；
2.用except精准捕获，避免 “一刀切” 的模糊处理；
3.给用户 / 调用者返回清晰的错误信息，方便排查问题。

数据结构 - 元组（Tuple）与集合（Set）
1.元组（Tuple）：
·用()或逗号分隔，比如(1, 2) 或 1, 2
·不可变：创建后不能增删改，适合存固定数据（比如坐标(x, y)）
·常用操作：tuple[index]取值，len(tuple)看长度

2.集合（Set）：
·用{}或set()创建，比如{1, 2, 3} 或 set([1, 2, 3])
·无序 + 去重：自动去掉重复元素，适合快速去重或做交集 / 并集
·常用操作：add()新增，remove删除，&（交集）、|（并集）
元组示例：

coordinate = (10, 20)
print("x坐标：", coordinate[0])  # 取值 → 10
coordinate[0] = 15  # 报错！元组不可变

集合示例：

nums = {1, 2, 2, 3}  # 自动去重 → {1, 2, 3}
nums.add(4)          # 新增 → {1, 2, 3, 4}
nums.remove(2)       # 删除 → {1, 3, 4}

集合运算（交集、并集）

set_a = {1, 2, 3}
set_b = {3, 4, 5}
print("交集：", set_a & set_b)  # {3}
print("并集：", set_a | set_b)  # {1, 2, 3, 4, 5}