1 初识对象

# 1. 设计一个类：    类的属性->成员变量、 类的行为->成员方法
class Student:
    name = None  # 记录学生姓名
    gender = None   # 记录学生性别
    age = None   # 记录学生年龄
    score = None  # 记录学生成绩
    def say(self):   # 成员方法
        return (f"hello, my name is {self.name}")   # self表示类对象的本身,必须使用self才能访问该类的属性


# 2. 创建一个对象
stu1 = Student()

#  3. 给对象赋值
stu1.name = '张三'
stu1.gender = '男'
stu1.age = 18
stu1.score = 90

# 4. 打印对象的属性值
print('姓名：', stu1.name)
print('性别：', stu1.gender)
print('年龄：', stu1.age)
print('成绩：', stu1.score)
print('say:', stu1.say())

---

2 类和对象的关系

面向对象编程：基于类设计对象，使用对象编程（只要类设计好后，对象就可以无数次地被创建）

类和对象地关系：类是程序中的“设计图纸；对象是基于图纸生产的具体实体

class Clock:
    no = None
    price = None

    def ring(self):
        import winsound
        winsound.Beep(2000, 1000)

# 1.创建第一个对象
clock1= Clock()
clock1.no = 1
clock1.price = 200

# 2.创建第二个对象
clock2 = Clock()
clock2.no = 2
clock2.price = 300

# ...

print(clock1.no)
print(clock1.price)
print(clock2.no)
print(clock2.price)

clock1.ring()
clock2.ring()

3 类中的构造方法

使用：__init__()  方法，称之为构造方法

可以实现：

        在创建类对象的时候，会自动执行；

        在创建类对象的时候，可以将传入的参数自动传递给 __init__() 方法使用

class Student:
    name = None
    age = None
    def __init__(self, name, age):
        self.name = name    # self.name 既有赋值，也有定义的功能，上面的变量可以不写
        self.age = age
        print('正在执行构造方法')

# 创建学生对象
stu1 = Student('小明', 15)   # 这句话一执行，构造方法就执行了！！！
print(stu1.name)
print(stu1.age)

---

4 类中的魔术方法

class Student:
    name = None
    age = None
    def __init__(self, name, age):
        self.name = name
        self.age = age

    # 1. __str__  字符串方法
    # 可以通过 __str__ 方法控制类转换为字符串的行为
    def __str__(self):   #  如果不写这个，打印stu1会输出内存地址
        return f"学生姓名：{self.name}, 年龄：{self.age}"

    # 2.  __lt__  小于和大于符号比较方法
    def __lt__(self, other):
        return self.age < other.age

    # 3. __le__  小于等于,大于等于符号比较方法
    def __le__(self, other):
        return self.age <= other.age

    # 3. __le__  比较运算符实现方法 ==  相等
    def __eq__(self, other):
        return self.age == other.age


stu1 = Student("张三", 20)
print(stu1.name)

print(stu1)  # __str__
stu2 = Student("李四", 22)

print(stu1 < stu2)   # __lt__   不支持等于
print(stu1 > stu2)
print("----------------")

stu3 = Student("王五", 22)
print(stu2 <= stu3)
print(stu2 >= stu3)  # __le__
print("----------------")

stu4 =  Student("赵六", 20)
print(stu4 == stu1)
print(stu4 == stu2)

---

5 面向对象的三大特性

5.1 封装性

封装：是将现实世界中的事物在类中描述为属性和方法

私有成员变量和私有成员方法：私有成员变量和私有成员方法不能被类对象使用，但类中的其它成员可以使用访问该私有成员

class Student:
    name = None
    age = None

    __score = 50

    def __sayHello(self):
        print("hello")

    def call_by_score(self):
        if self.__score >= 60:   # 可以使用私有成员变量
            print("及格万岁")
        else:
            self.__sayHello()
            print("不及格")

stu = Student()
# print(stu.__score)   # 无法使用
# stu.__sayHello()    # 无法使用

stu.call_by_score()

---

5.2 继承性

5.2.1 单继承

语法： 

             class  类名(父类名)：

                        类的内容体

class Phone:
    no = None
    price = None

    def call_by_4g(self):
        print("4G通话中...")


class Phone2022(Phone):
    face_id = None

    def call_by_5g(self):
        print("5G通话中...")

phone2022 = Phone2022()
phone2022.call_by_4g()
phone2022.no = 1100
print(phone2022.no)
phone2022.call_by_5g()

---

5.2.2 多继承

语法：

        class  类名(父类名1, 父类名2, ......):

                类的内容体

当继承的两个或多个父类中，有相同名字的成员，则按继承的顺序来，左边的优先  (父类名1, 父类名2, ......)

5.2.3 复写父类成员和调用父类成员

复写：

        子类继承父类的成员属性和成员方法后，如果对其“不满意”，那么可以进行复写。即在子类中重新定义同名的属性和方法即可。

class Phone:
    no = None
    price = 100
    def call(self):
        print("我可以打电话")

class Phone2022(Phone):
    price = 188

    def call(self):
        print("我可以视频通话")

phone2022 = Phone2022()
print(phone2022.price)
phone2022.call()
print("---------------------")

---

 

---

一旦复写父类成员，那么类对象调用成员的时候，就会调用复写后的新成员，如果需要使用被复写的父类的成员，需要特殊的调用格式

"""
    方式1 调用父类成员
        使用成员变量：父类名.成员变量名
        使用成员方法：父类名.成员方法名(self)
"""

"""
    方法2 使用super()调用父类成员
        使用成员变量：super().成员变量名
        使用成员方法：super().成员方法名(self)
"""

class Phone2023(Phone):
    price = 188

    def call(self):
        print("我可以视频通话")
        super().call()
        print(f"父类的价格为：{Phone.price}")

phone2023 = Phone2023()
print(phone2023.price)
phone2023.call()

5.3 多态性

多态指的是：多种状态，即完成某个行为时，使用不同的对象会得到不同的状态

函数（方法）形参声明接收父类对象；
实际传入的是父类的子类对象进行工作；
    ->  同一行为，不同状态

class Animal:
    def speak(self):     # 抽象类  pass  -> 用作顶层设计，我们不直接使用，我们使用他具体的子类
        pass

class Dog(Animal):
    def speak(self):
        print("汪汪汪")

class Cat(Animal):
    def speak(self):
        print("喵喵喵")


def animal_speak(animal: Animal):
    animal.speak()

dog = Dog()
cat = Cat()
animal_speak(dog)
animal_speak(cat)

---

6 类型注解

# 一、变量的类型注解：
"""
    语法1：
        变量名: 变量类型 = 变量值
    语法2：
        在注释中， #type: 类型

    注意：注解仅是提示的作用，变量类型和注解不对应不会导致错误
"""
import json
import random

from typing import Tuple, List

# 1. 基础数据类型的类型注解
var1: int = 10
var2: str = "hello"
var3: float = 3.14
var4: bool = True

# 2. 类对象的类型注解
class MyClass:
    pass
stu: MyClass = MyClass()

# 3. 容器数据类型的类型注解
# 列表的类型注解
my_list: list = [1, 2, 3]
my_tuple: tuple = (1, 2, 3)
my_tuple1: tuple[str, int] = ("hello", 20)
my_dict: dict = {"name": "Tom", "age": 20}

# 4.在注释中进行类型注解
var5 = random.randint(1, 10)   # type: int
var6 = json.loads('{"age": 20}')   # type: dict[str, int]



# 二、函数和方法的类型注解
"""
    语法：
        def 函数名(参数1: 参数类型, 参数2: 参数类型) -> 返回值类型:
            函数体/pass
"""
def add(x: int, y: int) -> int:
    pass



# 三、Union的类型注解  (在函数和变量中都可以使用)
"""
    语法：
        Union[类型1, 类型2, ...]
"""

# 首先导包
from typing import Union
my_list1: list[Union[int, str]] = [1, 2, "hello"]

my_dict2: dict[str, Union[str, int, bool]] = {"name": "Tom", "age": 20, "gender": True}

def func(data: Union[int, str]) -> Union[int, str]:
    pass