Python基础（最详细，适合复习）

一、Python基础语法应用

1.学生宿舍信息输入。

模拟学生宿舍信息输入，需要输入学生个人信息、性别、年龄、宿舍号、学院、专业、电话信息，并输出显示。

import os

class Student:
    def __init__(self, id, name, gender, age, department, dormitory):
        self.id = id
        self.name = name
        self.gender = gender
        self.age = age
        self.department = department
        self.dormitory = dormitory

def addStudent():
    students_file = "students.txt"
    print("输入学生ID: ")
    id = int(input())
    print("输入学生姓名: ")
    name = input()
    print("输入性别: ")
    gender = input()
    print("输入年龄: ")
    age = int(input())
    print("输入院系: ")
    department = input()
    print("输入宿舍号: ")
    dormitory = input()

    with open(students_file, "a") as file:
        file.write(f"{id} {name} {gender} {age} {department} {dormitory}\n")

    print("学生信息已添加。")

def deleteStudent():
    students_file = "students.txt"
    temp_file = "temp.txt"
    print("输入要删除的学生ID: ")
    id = int(input())

    found = False
    with open(students_file, "r") as file, open(temp_file, "w") as temp:
        for line in file:
            s_id, *_ = line.split()
            if int(s_id) != id:
                temp.write(line)
            else:
                found = True

    os.remove(students_file)
    os.rename(temp_file, students_file)

    if found:
        print("学生信息已删除。")
    else:
        print("未找到该学生信息。")

def modifyStudent():
    students_file = "students.txt"
    temp_file = "temp.txt"
    print("输入要修改的学生ID: ")
    id = int(input())

    found = False
    with open(students_file, "r") as file, open(temp_file, "w") as temp:
        for line in file:
            s_id, s_name, s_gender, s_age, s_department, s_dormitory = line.split()
            if int(s_id) == id:
                print("输入新的学生姓名: ")
                s_name = input()
                print("输入新的性别: ")
                s_gender = input()
                print("输入新的年龄: ")
                s_age = int(input())
                print("输入新的院系: ")
                s_department = input()
                print("输入新的宿舍号: ")
                s_dormitory = input()
                found = True
            temp.write(f"{s_id} {s_name} {s_gender} {s_age} {s_department} {s_dormitory}\n")

    os.remove(students_file)
    os.rename(temp_file, students_file)

    if found:
        print("学生信息已修改。")
    else:
        print("未找到该学生信息。")

def queryStudent():
    students_file = "students.txt"
    print("输入要查询的学生ID: ")
    id = int(input())

    found = False
    with open(students_file, "r") as file:
        for line in file:
            s_id, s_name, s_gender, s_age, s_department, s_dormitory = line.split()
            if int(s_id) == id:
                print(f"学生ID: {s_id}\n姓名: {s_name}\n性别: {s_gender}\n年龄: {s_age}\n院系: {s_department}\n宿舍号: {s_dormitory}\n")
                found = True
                break

    if not found:
        print("未找到该学生信息。")

def displayMenu():
    print("\n====== 学生宿舍信息管理系统 ======")
    print("1. 添加学生信息")
    print("2. 删除学生信息")
    print("3. 修改学生信息")
    print("4. 查询学生信息")
    print("0. 退出")
    print("===================================")

def main():
    while True:
        displayMenu()
        print("请输入您的选择：")
        choice = int(input())
        if choice == 1:
            addStudent()
        elif choice == 2:
            deleteStudent()
        elif choice == 3:
            modifyStudent()
        elif choice == 4:
            queryStudent()
        elif choice == 0:
            print("感谢使用，再见！")
            break
        else:
            print("无效的选择，请重新输入。")

if __name__ == "__main__":
    main()

运行结果：

2.超市抹零。

逛超市购物结账的时候，商家都会给顾客回馈一张清单小票，票面上的金额往往会精确到角或分。大部分商家通常会采用四舍五入的原则进行结算，不过有些商家为了让利顾客，会将小数点后面的数字金额全部抹零。下面使用数字类型转换实现收银抹零行为。

# 超市收银抹零

# 尝试对金额四舍五入输出


# 根据提示语键盘输入数字
money = float(input('请输入收银金额(元)：'))

# 类型转换，并打印
print('抹零后金额为(元)：' + str(int(money)))

3.个人用户登录。

当用户登录时给3次机会。如果成功，显示欢迎xxx。如果登录失败，显示录入错误你还有x次机会。如果3次机会使用完毕，则显示登录超限，请明天再登录。

for i in range(3):
    name = input('请输入用户名：')
    pwd = input('请输入密码：')
    if name == '暗面的大吉岭' and pwd == '123456darjeeling':
       print('欢迎:'+name)
       break
    elif i < 2:
       n = int(2-i)
       print('输入错误，你还有%d次机会' % n)
       continue
    else:
       print('登录超限，请明天再登录')
       break

4.模拟斐波那契数列输出。

用户输入指定的数列范围，正确输出结果。

def Fibon(n):
    if (n==1 or n==2):
        return 1
    else:
        return Fibon(n-1) + Fibon(n - 2)



if __name__ == '__main__':
    list = []
    n = int(input('请输入数列的范围:'))
    for i in range(n):
        c = Fibon(i+1)
        list.append(c)
    print(list)

5.银行金额大写汉字转换。

银行电子支票业务在金额部分需要使用大写的汉字，因此需要将用户录入的数字信息转变为汉字。目前只需完成1~5位整数转换即可。

number_dict = {"1": "一", "2": "二", "3": "三", "4": "四", "5": "五", "6": "六", "7": "七", "8": "八", "9": "九",
               "0": "零"}
unit_dict = {1: '', 2: '十', 3: '百', 4: '千', 5: '万'}
zero_list = ['零万', '零千', '零百', '零十', '零零']


def main(number):
    num_str = str(number)
    print(num_str, end=':')
    int_str = deal_int(num_str)
    if num_str.__contains__("."):
        int_str = int_str + deal_decimal(num_str)
    print(int_str)


def deal_int(number: str):
    # 处理整数
    number = int(number.split('.')[0])
    if number == 0:
        return ''
    return_str = ''
    if number >= 100000000:
        current = deal_single_int((number - (number % 100000000)) // 100000000)
        return_str = return_str + current + '亿'
        number = number % 100000000
    if number >= 10000:
        current = deal_single_int((number - (number % 10000)) // 10000)
        return_str = return_str + current + '万'
        number = number % 10000
    if number >= 0:
        return_str = return_str + deal_single_int(number) + '元'
    if ('零' in return_str):
        return_str = deal_zero(return_str)
    return return_str


def deal_single_int(number: int):
    number_str = str(number)
    lenth = len(number_str)
    return_str = ''
    for i in range(0, lenth):
        upper_num = number_dict[number_str[i]]
        unit = unit_dict.get(lenth - i)
        return_str = return_str + upper_num + unit
        if return_str.endswith("零"):
            return_str = return_str[:-1]
    return return_str


def deal_zero(number: str):
    # 处理返回值中的零
    for item in zero_list:
        if item in number:
            number = number.replace(item, '零')
    number = deal_multiple_zero(number)
    if number.endswith("零"):
        number = number[:-1]
    return number


def deal_multiple_zero(number: str):
    if '零零' in number:
        number = number.replace('零零', '零')
        return deal_multiple_zero(number)
    else:
        return number


def deal_decimal(number: str):
    # 处理小数
    number = number.split('.')[1]
    return_str = number_dict[number[0]] + '角'
    if len(number) > 1:
        return_str = return_str + number_dict[number[1]] + '分'
    return return_str


if __name__ == '__main__':
    main(34009.6)
    main(5009.6)
    main(334009.6)
    main(3331009.6)
    main(33023009.7)
    main(433303009.7)
    main(5203323009.7)
    main(0.73)

6.编程求出2-1000内的所有回文素数。

能被1 和本身整除的整数叫素数；如一个素数从左向右和从右向左是相同的数，则该素数为回文素数。

for i in range(2, 1001):
    for j in range(2, i):
        if i % j == 0:
            break
    else:
        n = str(i)
        m = n[::-1]
        if m == n:
            print(i, end=' ')

7.求完全平方数。

一个整数，它加上100后是一个完全平方数，再加上168又是一个完全平方数，请问该数是多少？

import math
for n in range(-100,27956):
    x = int(math.sqrt(100+n))
    y = int(math.sqrt(100+168 + n))
    if 100+n ==x*x and 268+n == y*y :
        print(n)

8. 水仙花数是3位整数（100-199），它的各位数字立方和等于该数本身。请编写程序。

for i in range(100,1000):
    sum = 0
    temp = i
    while temp:
        sum += (temp % 10) ** 3
        temp //= 10
    if sum == i:
        print(i,"是水仙数")

9.计算BMI 。

写一个计算可以计算一个人BMI（身体质量指数）指数程序体质指数（BMI）=体重（kg）÷身高的平方（m）
成人的BMI数值：
过轻：低于18.5
正常：18.5-23.9
过重：24-27
肥胖：27-32
非常肥胖, 高于32

name = str(input("请输入你的姓名："))
height = eval(input("请输入你的身高（m）:"))
weight = eval(input("请输入你的体重（kg）:"))

BMI = weight / pow(height, 2)
print("BMI值为：{:.2f}".format(BMI))  # {:.2f} 调用方法保留小数点后两位
if BMI < 18.5:
    print("偏瘦")
else:
    if 18.5 < BMI < 25:
        print("正常")
    else:
        if 25 < BMI < 28:
            print("偏胖")
        else:
            if 28 < BMI < 32:
                print("肥胖")
            else:
                if BMI > 32:
                    print("严重肥胖！")

10.阶乘。

n = int(input("请输入一个非负整数："))

if n < 0:
    print("负数没有阶乘！")
else:
    result = 1
    for i in range(1, n + 1):
        result *= i
    print(f"{n} 的阶乘是 {result}")   

二、字符串操作

2.类的成员（属性与方法）

#1.实例属性：对象独有，通过self定义；类属性：类共享，所有对象共用一个值。
class Person:
    info = "这是人类"  # 类属性（所有对象共享）
    
    def __init__(self, name):
        self.name = name  # 实例属性（对象独有）

# 访问类属性
print(Person.info)  # 直接通过类访问 → 这是人类
p1 = Person("小吴")
p2 = Person("小邹")
print(p1.info, p2.info)  # 对象也可访问 → 这是人类 这是人类

# 修改类属性（影响所有对象）
Person.info = "这是智慧人类"
print(p1.info, p2.info)  # → 这是智慧人类 这是智慧人类

# 修改实例属性（仅影响当前对象）
p1.name = "小吴同学"
print(p1.name, p2.name)  # → 小吴同学 小邹



#2.@property装饰器（属性封装）:用于将方法伪装为属性，方便访问和赋值时添加逻辑。
class Person:
    def __init__(self, name, age):
        self.name = name
        self._age = None  # 受保护属性
    
    #  getter方法：获取属性值
    @property
    def age(self):
        print("获取年龄")
        return self._age
    
    #  setter方法：设置属性值（仅在需要修改时定义）
    @age.setter
    def age(self, value):
        if value < 0 or value > 120:
            print("年龄无效！")
            return
        print("设置年龄")
        self._age = value

# 使用@property
p = Person("小李", 16)
p.age = 18  # 调用setter → 设置年龄
print(p.age)  # 调用getter → 获取年龄 → 18
p.age = 200  # → 年龄无效！


#3.方法

#3.1实例方法：第一个参数为self，绑定当前对象；只能通过对象调用，可访问实例属性和类属性。
class Person:
    def __init__(self, name):
        self.name = name
    
    def show_name(self):  # 实例方法
        print(f"姓名：{self.name}")

p = Person("张三")
p.show_name()  # → 姓名：张三
# Person.show_name()  # 错误：类不能直接调用实例方法（需手动传self）

#3.2类方法:用@classmethod装饰，第一个参数为cls（指代当前类）；可通过类或对象调用，仅能访问类属性。
class Person:
    info = "人类"
    
    @classmethod
    def show_info(cls):  # 类方法
        print(f"类信息：{cls.info}")

Person.show_info()  # 类调用 → 类信息：人类
p = Person()
p.show_info()  # 对象调用 → 类信息：人类

#3.3静态方法:用@staticmethod装饰，无默认参数；与类和对象无关，仅托管在类的命名空间中。
class Person:
    @staticmethod
    def static_info():  # 静态方法
        print("这是一个人类相关的静态方法")

Person.static_info()  # 类调用 → 这是一个人类相关的静态方法
p = Person()
p.static_info()  # 对象调用 → 这是一个人类相关的静态方法

3.继承与方法重写

#1. 单继承基础：子类继承父类的属性和方法，可新增或重写方法。
# 父类
class Person:
    def __init__(self, name, age):
        self.name = name
        self.age = age
    
    def say_hello(self):
        print(f"{self.name}说：您好！")

# 子类（继承Person）
class Student(Person):
    # 重写构造方法（需调用父类构造方法初始化属性）
    def __init__(self, name, age, sno):
        super().__init__(name, age)  # 调用父类构造方法（推荐）
        # Person.__init__(self, name, age)  # 另一种调用方式
        self.sno = sno  # 子类新增属性
    
    # 重写父类方法
    def say_hello(self):
        print(f"学生{self.name}（学号：{self.sno}）说：您好！")
    
    # 子类新增方法
    def show_stu_info(self):
        print(f"学号：{self.sno}，姓名：{self.name}，年龄：{self.age}")

# 测试子类
stu = Student("小吴", 20, "230606")
stu.say_hello()  # 调用重写的方法 → 学生小吴（学号：230606）说：您好！
stu.show_stu_info()  # 调用新增方法 → 学号：230606，姓名：小吴，年龄：20


#2. 多重继承（Python 特有）：一个类可继承多个父类，按广度优先查找方法（Python 3 默认）。
class Father:
    def func(self):
        print("Father的方法")

class Mother:
    def func(self):
        print("Mother的方法")

class Child(Father, Mother):  # 继承Father和Mother
    pass

child = Child()
child.func()  # 按继承顺序查找 → Father的方法


#3. 方法重写与多态：子类重写父类方法后，不同对象调用同一方法呈现不同行为。
class Person:
    def info(self):
        print("这是人类")

class Student(Person):
    def info(self):
        print("这是学生")

class Teacher(Person):
    def info(self):
        print("这是老师")

# 多态：同一方法对不同对象有不同实现
def show_info(obj):
    obj.info()

p = Person()
stu = Student()
tea = Teacher()

show_info(p)  # → 这是人类
show_info(stu)  # → 这是学生
show_info(tea)  # → 这是老师

4.面向对象高级应用

# 1. 动态扩展类与实例：Python 支持动态为类或对象添加属性和方法。
from types import MethodType

class Student:
    pass

# 动态为对象添加方法
def set_name(self, name):
    self.name = name

stu1 = Student()
stu1.set_name = MethodType(set_name, stu1)  # 绑定实例方法
stu1.set_name("张三")
print(stu1.name)  # → 张三

# 动态为类添加方法
@classmethod  # 加上这个装饰器，让它成为类方法
def set_sno(cls, sno):
    cls.sno = sno

Student.set_sno = set_sno  # 绑定类方法
Student.set_sno("2023001")
print(Student.sno)  # → 2023001


# 2. __slots__限制属性限制类实例：只能添加指定属性，提升性能并防止属性滥用。
class Person:
    __slots__ = ("name", "age")  # 仅允许添加name和age属性

    def __init__(self, name, age):
        self.name = name
        self.age = age


p = Person("tom", 18)
p.name = "jerry"  # 允许修改


# p.sex = "male"  # 错误：AttributeError（不允许新增sex属性）


# 3. 单例模式：保证类只有一个实例（适用于日志、数据库连接池等场景）。
class Singleton:
    __instance = None  # 私有类属性：存储唯一实例

    def __new__(cls, *args, **kwargs):  # 控制实例创建（比__init__早执行）
        if cls.__instance is None:
            cls.__instance = super().__new__(cls)  # 创建实例
        return cls.__instance  # 返回唯一实例


# 测试：所有对象指向同一实例
s1 = Singleton()
s2 = Singleton()
print(s1 == s2)  # → True（内存地址相同）
print(id(s1), id(s2))  # 输出相同的内存地址


# 4.鸭子类型：关注对象的 “行为” 而非 “类型”，只要对象有对应方法即可使用。
class Duck:
    def walk(self):
        print("像鸭子一样走路")

    def swim(self):
        print("像鸭子一样游泳")


class Person:
    def walk(self):
        print("像鸭子一样走路")

    def swim(self):
        print("像鸭子一样游泳")


# 不关心对象类型，只关心是否有walk和swim方法
def watch_duck(animal):
    animal.walk()
    animal.swim()


duck = Duck()
person = Person()

watch_duck(duck)  # 像鸭子一样走路 → 像鸭子一样游泳
watch_duck(person)  # 像鸭子一样走路 → 像鸭子一样游泳

5.实战：校园管理系统核心类设计

class Person:
    def __init__(self, name, gender, age):
        self.name = name
        self.gender = gender
        self.age = age
    
    def show_basic_info(self):
        print(f"姓名：{self.name}，性别：{self.gender}，年龄：{self.age}")

# 学生类
class Student(Person):
    def __init__(self, name, gender, age, sno, college, major):
        super().__init__(name, gender, age)
        self.sno = sno  # 学号
        self.college = college  # 学院
        self.major = major  # 专业
    
    def show_stu_info(self):
        print("=== 学生信息 ===")
        self.show_basic_info()
        print(f"学号：{self.sno}，学院：{self.college}，专业：{self.major}")

# 教师类
class Teacher(Person):
    def __init__(self, name, gender, age, tid, teach_age, title, course):
        super().__init__(name, gender, age)
        self.tid = tid  # 工号
        self.teach_age = teach_age  # 教龄
        self.title = title  # 职称
        self.course = course  # 教授课程
    
    def show_tea_info(self):
        print("=== 教师信息 ===")
        self.show_basic_info()
        print(f"工号：{self.tid}，教龄：{self.teach_age}年，职称：{self.title}，教授课程：{self.course}")

# 课程类
class Course:
    def __init__(self, cid, name, exam_type):
        self.cid = cid  # 课程编号
        self.name = name  # 课程名称
        self.exam_type = exam_type  # 考核方式
    
    def show_course_info(self):
        print(f"课程编号：{self.cid}，课程名称：{self.name}，考核方式：{self.exam_type}")

# 测试
stu = Student("小吴", "男", 20, "230606", "软件学院", "计算机科学与技术")
stu.show_stu_info()

tea = Teacher("牛老师", "女", 40, "T2024001", 15, "教授", "Python开发与应用")
tea.show_tea_info()

course = Course("C2024001", "Python面向对象", "闭卷考试")
course.show_course_info()

五、组合数据类型、文件操作、异常处理和数据库操作

1.组合数据类型（列表、元组、集合、字典）

组合数据类型用于存储批量数据，按特性分为序列类型（列表、元组）、集合类型、映射类型（字典），核心优势是简化数据管理与操作。

1.1列表（List）- 有序可变

定义：用[]包裹，元素可重复、类型不限，支持增删改查；

核心特性：有序、可变，支持嵌套和切片；

常用场景：存储有序数据（如学生列表、成绩列表）。

# 1. 列表创建
list1 = ['张轩', '李岚', 92]  # 混合类型
list2 = list(('a', 'b', 'c'))  # 从元组转换
list3 = [i for i in range(10) if i % 2 == 0]  # 列表推导式（0-9的偶数）

# 2. 增删改查
list1.append('王晨')  # 末尾添加 → ['张轩', '李岚', 92, '王晨']
list1.insert(1, '刘峰')  # 指定位置插入 → ['张轩', '刘峰', '李岚', 92, '王晨']
list1.remove('李岚')  # 删除指定元素 → ['张轩', '刘峰', 92, '王晨']
del list1[2]  # 按索引删除 → ['张轩', '刘峰', '王晨']
list1[0] = '张飞'  # 修改元素 → ['张飞', '刘峰', '王晨']

# 3. 切片操作
print(list1[1:3])  # 截取索引1-2 → ['刘峰', '王晨']
print(list1[:-1])  # 截取到倒数第二个 → ['张飞', '刘峰']

# 4. 排序与嵌套
stu_list = [['张轩', 92], ['李岚', 87], ['王晨', 95]]
stu_list.sort(key=lambda x: x[1], reverse=True)  # 按成绩降序 → [['王晨',95], ['张轩',92], ['李岚',87]]

# 5. 深浅拷贝
import copy
list4 = [1, 2, [3, 4]]
shallow_copy = list4.copy()  # 浅拷贝（嵌套元素共享内存）
deep_copy = copy.deepcopy(list4)  # 深拷贝（完全独立）
list4[2][0] = 5
print(shallow_copy)  # [1,2,[5,4]]（嵌套元素受影响）
print(deep_copy)    # [1,2,[3,4]]（不受影响）

1.2 元组（Tuple）- 有序不可变

定义：用()包裹，元素可重复、类型不限，创建后不可修改；

核心特性：有序、不可变，占用内存少，支持切片；

常用场景：存储固定数据（如坐标、配置参数）。

# 1. 元组创建
tup1 = ('a', 'b', 123)
tup2 = 1, 2, 3  # 省略括号（非空元组需保留逗号）
tup3 = tuple([4, 5, 6])  # 从列表转换
tup4 = (7,)  # 单元素元组（必须加逗号）

# 2. 访问与切片
print(tup1[0])  # 按索引访问 → 'a'
print(tup1[1:3])  # 切片 → ('b', 123)

# 3. 不可修改特性（以下代码会报错）
# tup1[0] = 'c'  # TypeError: 'tuple' object does not support item assignment

# 4. 常用操作
print(len(tup1))  # 长度 → 3
print(tup1 + tup2)  # 连接 → ('a','b',123,1,2,3)
print(tup2 * 2)  # 重复 → (1,2,3,1,2,3)
print(1 in tup2)  # 成员判断 → True

1.3集合（Set）- 无序去重

定义：用{}或set()创建，元素唯一、无序，不可存可变类型；

核心特性：自动去重、支持集合运算（交集、并集、差集）；

常用场景：数据去重、关系判断（如共同好友、数据筛选）。

# 1. 集合创建
set1 = {'张轩', '李岚', '王晨'}
set2 = set([1, 2, 2, 3])  # 自动去重 → {1,2,3}
set3 = set()  # 空集合（不可用{}，{}是空字典）

# 2. 增删操作
set1.add('刘峰')  # 添加元素 → {'张轩','李岚','王晨','刘峰'}
set1.remove('李岚')  # 删除元素（不存在报错）
set1.discard('赵钢')  # 删除元素（不存在不报错）
set1.pop()  # 随机删除一个元素

# 3. 集合运算
a = {1, 2, 3, 4}
b = {3, 4, 5, 6}
print(a & b)  # 交集 → {3,4}
print(a | b)  # 并集 → {1,2,3,4,5,6}
print(a - b)  # 差集（a有b无）→ {1,2}
print(a ^ b)  # 对称差集（互不包含）→ {1,2,5,6}

# 4. 实战：数据去重与排序
import random
nums = set()
for _ in range(10):
    nums.add(random.randint(1, 100))  # 生成10个1-100的随机数（自动去重）
print(sorted(nums, reverse=True))  # 降序排序 → [98, 76, ...]

1.4字典（Dict）- 键值对映射

定义：用{key:value}创建，键唯一且不可变（如字符串、数字、元组），值可任意；

核心特性：无序（Python3.7 + 有序）、查询效率高，支持键值对增删改查；

常用场景：存储关联数据（如学生信息、配置参数）。

# 1. 字典创建
stu = {'id': 1001, 'name': '张轩', 'score': 92}
stu2 = dict(id=1002, name='李岚', score=87)  # 用dict()创建
stu3 = {i: i*2 for i in range(3)}  # 字典推导式 → {0:0,1:2,2:4}

# 2. 增删改查
stu['age'] = 19  # 添加键值对 → {'id':1001,...,'age':19}
stu['score'] = 95  # 修改值 → score=95
print(stu.get('address', '未知'))  # 安全获取（不存在返回默认值）→ '未知'
stu.pop('age')  # 删除键值对 → 返回19
del stu2['id']  # 删除键值对

# 3. 遍历操作
for key in stu.keys():
    print(key)  # 遍历键 → id, name, score
for value in stu.values():
    print(value)  # 遍历值 → 1001, 张轩, 95
for k, v in stu.items():
    print(f'{k}:{v}')  # 遍历键值对 → id:1001, ...

# 4. 字典拼接（Python3.9+支持|运算符）
d1 = {'a':1, 'b':2}
d2 = {'c':3, 'd':4}
d3 = d1 | d2  # → {'a':1,'b':2,'c':3,'d':4}

1.5迭代器与生成器

迭代器：实现__iter__()和__next__()的对象，支持next()遍历，耗尽抛StopIteration；

生成器：用()或yield创建，延迟生成数据，节省内存；

常用场景：大批量数据处理、循环遍历优化。

# 1. 迭代器
list_iter = iter([1, 2, 3])
print(next(list_iter))  # → 1
print(next(list_iter))  # → 2
print(next(list_iter))  # → 3
# print(next(list_iter))  # StopIteration

# 2. 生成器表达式
gen1 = (x*x for x in range(5))  # 括号替换列表推导式的中括号
for num in gen1:
    print(num)  # → 0,1,4,9,16

# 3. 生成器函数（含yield）
def fibonacci(n):
    a, b = 0, 1
    count = 0
    while count < n:
        yield a  # 暂停并返回值
        a, b = b, a + b
        count += 1

fib = fibonacci(5)
for num in fib:
    print(num)  # → 0,1,1,2,3

2.文件操作

文件操作是数据持久化的核心，支持文本文件、二进制文件及 CSV 格式文件的读写。

2.1普通文件操作

打开模式：r（只读）、w（覆盖写）、a（追加写）、r+（读写）、b（二进制模式）；

核心流程：打开文件 → 读写操作 → 关闭文件（推荐用with语句自动关闭）；

常用方法：read()（读全部）、readline()（读一行）、readlines()（读所有行）、write()（写内容）。

2.2 CSV 文件操作

CSV：逗号分隔的文本文件，用于存储表格数据（如学生成绩、统计数据）；

核心模块：csv，支持reader（按行读）、writer（按行写）、DictReader/DictWriter（按字典读写）；

常用场景：数据导入导出、表格数据处理。

#普通文件操作
# 1. 基本读写（with语句自动关闭文件）
with open('test.txt', 'w', encoding='utf-8') as f:
    f.write('河南大学\nPython开发与应用')  # 写内容（需手动加换行符）

with open('test.txt', 'r', encoding='utf-8') as f:
    print(f.read())  # 读全部内容
    # print(f.readline())  # 读一行
    # print(f.readlines())  # 读所有行（返回列表）

# 2. 二进制文件操作（如图片、视频）
with open('image.jpg', 'rb') as f:
    data = f.read()  # 读二进制数据
with open('image_copy.jpg', 'wb') as f:
    f.write(data)  # 写二进制数据

# 3. 文件定位
with open('test.txt', 'r', encoding='utf-8') as f:
    f.read(5)  # 读5个字节
    print(f.tell())  # 获取当前指针位置 → 5
    f.seek(0)  # 指针回到文件开头
    print(f.readline())  # 重新读第一行 → '河南大学'

# 4. 实战：文件内容替换
with open('test1.txt', 'r', encoding='utf-8') as f1, open('test2.txt', 'w', encoding='utf-8') as f2:
    for line in f1:
        f2.write(line.replace('Python', 'Python编程'))  # 替换内容并写入新文件




#CSV 文件操作
import csv

# 1. 写入CSV文件
data = [
    ['学号', '姓名', '平时成绩', '期末成绩'],
    ['1445204009', '王召', 100, 90],
    ['1445204013', '林锦', 95, 67]
]
with open('StudentInfo.csv', 'w', newline='', encoding='utf-8') as f:
    writer = csv.writer(f)
    writer.writerow(data[0])  # 写表头
    writer.writerows(data[1:])  # 写多行数据

# 2. 读取CSV文件（按行读）
with open('StudentInfo.csv', 'r', encoding='utf-8') as f:
    reader = csv.reader(f)
    for row in reader:
        print(row)  # → ['学号','姓名','平时成绩','期末成绩'], ...

# 3. 按字典读写CSV（更直观）
with open('StudentInfo.csv', 'r', encoding='utf-8') as f:
    reader = csv.DictReader(f)  # 以表头为键
    for row in reader:
        print(row['姓名'], row['期末成绩'])  # → 王召 90, 林锦 67

# 4. 追加数据到CSV
new_row = ['1445204017', '杜静静', 93, 94]
with open('StudentInfo.csv', 'a', newline='', encoding='utf-8') as f:
    writer = csv.writer(f)
    writer.writerow(new_row)

3.异常处理

异常：程序运行时的错误（如文件不存在、除零错误），未处理会导致程序终止；

处理语句：try-except（捕获异常）、else（无异常执行）、finally（无论是否异常都执行）；

自定义异常：继承Exception类，用raise抛出。

# 1. 基本异常处理
try:
    num = int(input('请输入数字：'))
    result = 10 / num
except ValueError:
    print('输入不是有效数字！')
except ZeroDivisionError:
    print('除数不能为0！')
except Exception as e:
    print(f'未知异常：{e}')
else:
    print(f'结果：{result}')  # 无异常时执行
finally:
    print('程序执行完毕！')  # 必执行

# 2. 自定义异常
class IDError(Exception):
    def __init__(self, msg):
        self.msg = msg
    def __str__(self):
        return self.msg

try:
    sid = input('请输入学号：')
    if len(sid) != 10:
        raise IDError('学号长度必须为10位！')  # 抛出自定义异常
except IDError as e:
    print(e)  # → 学号长度必须为10位！

# 3. 文件操作异常处理（实战）
try:
    with open('nonexistent.txt', 'r', encoding='utf-8') as f:
        content = f.read()
except FileNotFoundError as e:
    print(f'文件不存在：{e}')
except IOError as e:
    print(f'文件读写错误：{e}')

4.数据库操作（MySQL）

核心库：pymysql（Python3 连接 MySQL 的库）；

操作流程：连接数据库 → 创建游标 → 执行 SQL → 提交事务 / 回滚 → 关闭连接；

常用操作：创建表、增删改查、CSV 数据导入导出。

import pymysql
import csv

# 1. 连接数据库（需先安装pymysql：pip install pymysql）
config = {
    'host': 'localhost',
    'port': 3306,
    'user': 'root',
    'password': '123456',
    'db': 'student',
    'charset': 'utf8mb4'
}
db = pymysql.connect(**config)
cursor = db.cursor()  # 创建游标

# 2. 创建表
create_sql = """
CREATE TABLE IF NOT EXISTS stuTest (
    学号 VARCHAR(10) PRIMARY KEY,
    姓名 VARCHAR(20) NOT NULL,
    平时成绩 INT,
    期末成绩 INT
) DEFAULT CHARSET=utf8;
"""
cursor.execute(create_sql)
db.commit()  # 提交事务

# 3. 插入数据
insert_sql = """
INSERT INTO stuTest (学号, 姓名, 平时成绩, 期末成绩)
VALUES ('1445204009', '王召', 100, 90),
       ('1445204013', '林锦', 95, 67);
"""
try:
    cursor.execute(insert_sql)
    db.commit()
    print('插入成功！')
except Exception as e:
    db.rollback()  # 出错回滚
    print(f'插入失败：{e}')

# 4. 查询数据
select_sql = "SELECT * FROM stuTest;"
cursor.execute(select_sql)
results = cursor.fetchall()  # 获取所有结果
for row in results:
    print(f'学号：{row[0]}, 姓名：{row[1]}, 总分：{row[2]+row[3]}')

# 5. 更新与删除数据
update_sql = "UPDATE stuTest SET 平时成绩=99 WHERE 学号='1445204009';"
cursor.execute(update_sql)
db.commit()

delete_sql = "DELETE FROM stuTest WHERE 学号='1445204013';"
cursor.execute(delete_sql)
db.commit()

# 6. CSV数据导入数据库
with open('StudentInfo.csv', 'r', encoding='utf-8') as f:
    reader = csv.DictReader(f)
    for row in reader:
        insert_sql = f"""
        INSERT INTO stuTest (学号, 姓名, 平时成绩, 期末成绩)
        VALUES ('{row['学号']}', '{row['姓名']}', {row['平时成绩']}, {row['期末成绩']});
        """
        try:
            cursor.execute(insert_sql)
            db.commit()
        except Exception as e:
            db.rollback()
            print(f'导入失败：{e}')

# 7. 关闭连接
cursor.close()
db.close()