# Python-Project

**Repository Path**: su27sk/Python-Project

## Basic Information

- **Project Name**: Python-Project
- **Description**: 复习Python语法，为FastAPI项目做好准备
- **Primary Language**: Unknown
- **License**: Not specified
- **Default Branch**: master
- **Homepage**: None
- **GVP Project**: No

## Statistics

- **Stars**: 0
- **Forks**: 0
- **Created**: 2026-04-15
- **Last Updated**: 2026-05-03

## Categories & Tags

**Categories**: Uncategorized

**Tags**: Python

## README

# Python基础语法
## 基础配置
参考在线文档:https://heuqqdmbyk.feishu.cn/wiki/SHXXwTeDUiFMLhkJ3WjcrYOpnLe

## 核心基础语法

### 数据容器
- list(列表):
可以存储不同类型的元素；元素有序，可以重复，元素可以修改。相当于Java的ArrayList

- 切片:
切片是指对操作的数据截取其中一部分的操作。列表，字符串，元组都支持切片操作
<br>
不包含结束索引位置对应的元素 (开始索引未指定默认为 0；结束索引未指定默认为列表长度 (直到列表末尾)；步长未指定默认为 1)
<br>
索引采用正向、反向索引都可以
<br>
步长是选取间隔，默认步长为 1
<br>
经常配合解包和推导式使用

- str(字符串):
不可变（无法修改）,有序性，可迭代性。相当于Java的String

- tuple(元组):
元组和列表最大的不同在于元组一旦完成以后无法修改(可以重复，有序，不可修改)。相当于不可修改的list(列表)

- set(集合):
集合是一种无序的，不可重复的，可修改的数据容器。相当于Java的HashSet

- dict(字典):
相当于Java的HashMap

- 数据容器应用场景
![数据容器应用场景.png](pic/%E6%95%B0%E6%8D%AE%E5%AE%B9%E5%99%A8%E5%BA%94%E7%94%A8%E5%9C%BA%E6%99%AF.png)

### 函数
- 函数基础
- 函数进阶

变量作用范围
```commandline
# 全局变量
num = 100

# 定义函数
def circle_area(r):
    pi = 3.14
    area = pi * r ** 2
    # 想在函数内修改全局变量 → 必须加 global 变量名.声明当前的变量是全局的那个变量
    global num
    num = 10000
    print("num = ", num)
    return area

# 调用函数
c_area = circle_area(10)
print(c_area)

print("num = ",num)
```
不定长函数
```commandline
# -------------- 函数 - 不定长参数(位置参数 *args --> 元组)  --------------
# 不定长位置参数

# 需求：根据传入的数据计算数据的最小值，最大值，平均值
def calc_data(*args):
    min_data = min(args)
    max_data = max(args)
    avg_data = round(sum(args) / len(args))
    return min_data,max_data,avg_data

print(calc_data(3,67,8,90,45,67,8))


# -------------- 函数 - 不定长参数(关键字参数 **kwargs --> 字典)  --------------
# 不定长位置参数关键字
# 需求：根据传入的数据计算数据的最小值，最大值，平均值;保留平均值几位小数，是否打印
def calc_data(*args,**kwargs):
    """
    根据传入的数据计算数据的最小值，最大值，平均值;保留平均值几位小数，是否打印
    Args:
        *args:  不定长位置参数
        **kwargs: 不定长位置参数关键字

    Returns: 计算数据的最小值，最大值，平均值

    """
    min_data = min(args)
    max_data = max(args)
    avg_data = sum(args) / len(args)

    if kwargs.get("round") is not None:
        avg_data = round(avg_data,kwargs.get("round"))

    if kwargs.get("print"):
         print(f"计算出来的最小值:{min_data},最大值:{max_data},平均值:{avg_data}")
    return min_data,max_data,avg_data


print(calc_data(2,34,5,6,78,56,27,round = 3,print = True))
print(calc_data(2,34,5,6,78,56,27,print=False))
```
函数作为参数
```commandline
# -------------- 函数 - 函数作为参数  --------------
'''
# 函数参数类型
def add(x,y):
    return x+y

def subtract(x,y):
    return x-y

def multiply(x,y):
    return x*y

def divide(x,y):
    return x/y

# 计算
def calc(x,y,oper):
    return oper(x,y)

print(calc(10,20,add))
'''
```
匿名函数
```commandline
# 匿名函数是没有名字的函数，用lambda表达式来定义

# 匿名函数
# 需求1：打印一个分割线
# def out_line():
#     print("-------------------------")

out_line = lambda : print("-------------------------")

out_line()

# 需求2：计算两个数之和
# def add(x,y):
#     return x + y

add = lambda x,y:x+y
print(add(10,20))

# 需求3：完成如下列表的排序操作，按照每一个元素的字符个数，从小到大排序
data_list = ["C++","C","Python","Jack","PHP","Java","Go","JavaScript","Rust"]
print(data_list)

# 规定按照字符个数排序
data_list.sort(key= lambda item : len(item))
print(data_list)
```
### 类型注解
- 变量类型注解:如果对变量直接赋值、变量运算等场景，Python 会自动进行类型推断,Python是动态类型语言。类型注解只是给一个友好型提升，并不是强制约束
- 函数类型注解
```commandline
def 函数名(参数名: 类型, 参数名: 类型 = 默认值) -> 返回值类型:
    pass
```

### 模块
![模块导入方法.png](pic/%E6%A8%A1%E5%9D%97%E5%AF%BC%E5%85%A5%E6%96%B9%E6%B3%95.png)
![导入包.png](pic/%E5%AF%BC%E5%85%A5%E5%8C%85.png)

### 异常
```
try:
    print("=======================")
    # print(my_name)
    # print( 1 / 0)
    print("aaa".hello)
    print("=======================")

except NameError as e: # 捕获NameError异常
    print(f"名字不存在，异常信息：{e}")
except ZeroDivisionError as e: # 捕获ZeroDivisionError异常
    print(f"0不能做除数，异常信息：{e}")
except Exception as e:
    print(f"程序出错了，异常信息：{e}")
finally:
    print("资源释放")
```

# Python 面向对象基础语法
## 类的基本定义模板
```commandline
'''
self关键字：
  代表本类当前对象的引用，谁调用，self就代表谁。用于区分函数不同的对象
'''
class Car:

    def run(self):
        print(f"汽车会跑")

    def show(self):
        print(f"我是show函数,颜色:{self.color},轮胎数量:{self.number}")

c1 = Car()
c1.color = '红色'
c1.number = 4
print(f"颜色:{c1.color},轮胎数量:{c1.number}")
c1.run()
c1.show()

print("- " * 30)

c2 = Car()
c2.run()
# c2.show() 报错
```

## 魔法方法
魔法方法又称双下划线方法，格式：__方法名__，是 Python 内置特殊方法。特点：不用手动调用，执行对应语法时自动触发，用来改写类的底层行为。

### __init__
__init__:对象创建的时候自动被调用执行，赋予的属性对象一创建既有了。
```commandline
class Car:

    def __init__(self,color,number):
        """

        Args:
            color: 颜色
            number: 轮胎数量
        """
        self.color = color
        self.number = number

    def show(self):
        print(f"颜色:{self.color},轮胎数量:{self.number}")


c1 = Car('红色',4)
c1.show()
```

### __str__
__str__ 是用来获取「对象的字符串形式」的方法。例如print()打印对象的时候，会自动调用类里面的__str__魔法方法
```commandline
class Car:

    def __init__(self,color,number):
        """

        Args:
            color: 颜色
            number: 轮胎数量
        """
        self.color = color
        self.number = number

    def __str__(self):
        return f"颜色:{self.color},轮胎数量:{self.number}"



c1 = Car('红色',4)
print(c1)
c2 = Car('黑色',3)
print(c2)
```
### __del__
当.py文件执行结束或者手动del释放对象资源的时候，会自动调用该函数。
```commandline
class Car:

    def __init__(self,brand):
        self.brand = brand

    def __str__(self):
        return f"品牌:{self.brand}"

    # 删除对象的时候有提示
    def __del__(self):
        print(f"{self}对象 被删除了")

c1 = Car("小米 Su7")
print(c1)
print(c1.brand)
print("- " *30)
del c1
# print(c1)
print("程序结束了")
```

### 类创建的三种格式
不写父类 → 自动默认继承 object ;写了 (object) → 就是明确写默认父类。

Python 和 Java 逻辑一致，object 是万物顶层父类，不写继承就默认继承它。区别只在于 Python 有多继承，Java 是单继承。
```commandline
class A:
    pass
    
class A(object):
    pass
    
class A(父类):
    pass
```

## 继承
### 单继承
```commandline
class Master:

    def __init__(self):
        self.kongfu = '[古法配方]'

    def make_cake(self):
        print(f"采用{self.kongfu} 摊煎饼")

class Prentice(Master):
    pass

p = Prentice()
p.make_cake()
```

### 多继承
当一个类有多个父类时，默认使用第一个父类的同名属性和方法，可以使用类名.__mro__属性或类名.mro () 方法查看调用的先后顺序。
```commandline
class Master:

    def __init__(self):
        self.kongfu = '[古法煎饼]'

    def make_cake(self):
        print(f"运用{self.kongfu} 摊煎饼")

class School:

    def __init__(self):
        self.kongfu = '[AI新技术]'

    def make_cake(self):
        print(f"运用{self.kongfu} 摊煎饼")

class Prentice(School,Master):  # 从左到右，就近原则
    pass

p = Prentice()
print(p.kongfu)
p.make_cake()
print("-" * 30)
print(Prentice.mro())
print(Prentice.__mro__)
```

# Python 面向对象进阶语法
## 子类重写父类
```commandline
class Master:

    def __init__(self):
        self.kongfu = '[古法煎饼]'

    def make_cake(self):
        print(f"运用{self.kongfu} 摊煎饼")

class School:

    def __init__(self):
        self.kongfu = '[AI新技术]'

    def make_cake(self):
        print(f"运用{self.kongfu} 摊煎饼")

class Prentice(School,Master):
    # 从左到右，就近原则
    def __init__(self):
        self.kongfu = '[独创技术技术]'

    def make_cake(self):
        print(f"运用{self.kongfu} 摊煎饼")

if __name__ == "__main__":
    p = Prentice()
    print(p.kongfu)
    p.make_cake()
```

## 子类访问父类方法
- 父类名.父类函数名(self): 精准访问，想找哪个父类，就调哪个父类。
- super().父类函数名():只能访问最近的那个父类，有就用，没有就下一个，一直没有就报错。

## 多层继承
```commandline
class Master:

    def __init__(self):
        self.kongfu = '[古法煎饼]'

    def make_cake(self):
        print(f"运用{self.kongfu} 摊煎饼")


class School:

    def __init__(self):
        self.kongfu = '[AI新技术]'

    def make_cake(self):
        print(f"运用{self.kongfu} 摊煎饼")

class Prentice(School,Master):
    # 从左到右，就近原则
    def __init__(self):
        self.kongfu = '[独创技术技术]'

    def make_cake(self):
        print(f"运用{self.kongfu} 摊煎饼")

    def make_master_cake(self):
        Master.__init__(self)
        Master.make_cake(self)

    def make_school_cake(self):
        School.__init__(self)
        School.make_cake(self)

# 创建徒孙类
class TuSun(Prentice):
    pass

if __name__ == "__main__":
   ts = TuSun()
   ts.make_cake()
   ts.make_master_cake()
   ts.make_school_cake()
   ts.make_cake()
```

## 封装
私有属性不能直接访问，在 Python 中，一般定义方法名get_xx用来获取私有属性，定义set_xx用来修改私有属性值。
```commandline
'''
私有属性: __属性名
私有函数: __函数名
'''

class Prentice():
    # 从左到右，就近原则
    def __init__(self):
        self.kongfu = '[独创技术技术]'
        # 私房钱
        self.__money = 20000

    def make_cake(self):
        print(f"运用{self.kongfu} 摊煎饼")

    # 针对私有的属性,提供公共的访问方式
    def get_money(self):
        return self.__money

    def set_money(self):
        self.__money = 100

# 创建徒孙类
class TuSun(Prentice):
    pass

if __name__ == "__main__":
   ts = TuSun()
   print(ts.kongfu)
   ts.make_cake()
   ts.set_money()
   print(ts.get_money())
```

## 多态
多态概述： 专业版：同一个函数，接收不同的参数，有不同的效果 ;大白话：同一个事物在不同时刻表现出来的不同状态，形态。

前提条件： 要有继承。 要有方法重写，不然多态无意义。 要有父类引用指向子类对象。
```commandline
'''
案例：演示多态入门。
    多态概述：
        专业版：同一个函数，接收不同的参数，有不同的效果
        大白话：同一个事物在不同时刻表现出来的不同状态，形态。
    前提条件：
        要有继承。
        要有方法重写，不然多态无意义。
        要有父类引用指向子类对象。
'''

class Animal:

    def speak(self):
        print("动物会叫")

class Dog(Animal):

    def speak(self):
        print("汪汪汪")


class Cat(Animal):

    def speak(self):
        print("喵喵喵")

class Car:

    def speak(self):
        print("嘀嘀嘀")

def make_noise(an:Animal):
    an.speak()

if __name__ == "__main__":

    d:Animal = Dog() # 父类引用执行子类对象
    c:Animal = Cat()

    make_noise(d)
    make_noise(c)

    print("- " *30)
    c2 = Car()
    make_noise(c2)
```

## 抽象类
在Python中, 抽象类 = 接口, 即: 有抽象方法的类就是 抽象类,也叫 接口. 抽象方法 = 没有方法体的方法, 即: 方法体是 pass 修饰的.

作用/目的:抽象类一般充当父类, 用于指定行业规范, 准则, 具体的实现交由 子类 来完成.
```commandline
class AC:

    def cool_wind(self):
        pass

    def hot_wind(self):
        pass

    def swing_l_r(self):
        pass

class XiaoMi(AC):

    def cool_wind(self):
        print("小米 核心 制冷技术")

    def hot_wind(self):
        print("小米 核心 制热技术")

    # def swing_l_r(self):
    #     print("小米 核心 静音左右摆风技术")

class Gree(AC):

    def cool_wind(self):
        print("格力 核心 制冷技术")

    def hot_wind(self):
        print("格力 核心 制热技术")

    def swing_l_r(self):
        print("格力 核心 低频左右摆风技术")

# 测试
if __name__ == "__main__":

    xm = XiaoMi()
    xm.cool_wind()
    xm.hot_wind()
    xm.swing_l_r()
    print("- " * 30)

    gree = Gree()
    gree.cool_wind()
    gree.hot_wind()
    gree.swing_l_r()
```

## 综合案例-学生管理系统