python基本语法知识（五）—

python基本语法知识（五）——面向对象

news2024/12/30 2:15:56

类和对象

例子1

class Student:
    name = None
    gender = None
    nationality = None
    native_place = None # 籍贯
    age = None

    # 类内的成员方法,第一个参数必须为 self,
    # self相当于是当前对象
    def say_hi(self):
        print(f"大家好,我是{self.name}")
    def say_hi2(self, msg):
        print(f"大家好,我是{self.name}, {msg}")

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

# 3. 对象属性
stu1.name = "王伟"
stu1.gender = "男"
stu1.nationality = "中国"
stu1.native_place = "福建省"
stu1.age = 30

# 4.输出对象信息
print(stu1.name)
print(stu1.gender)
print(stu1.nationality)
print(stu1.native_place)
print(stu1.age)
stu1.say_hi()
stu1.say_hi2("多多关照")

输出结果：

王伟

男

中国

福建省

大家好,我是王伟

大家好,我是王伟, 多多关照

例子2：构造方法init()

与C++的构造函数类似：

class Student:
    # 这里声明其实不写也可以,构造方法里会自动声明+定义
    name = None
    age = None
    tel = None

    # !!
    def __init__(self, name, age, tel):
        self.name = name
        self.age = age
        self.tel = tel
        print("Student类创建了一个类对象")

stu1 = Student("陈奕迅", 39, 1292392992)
print(stu1.name)
print(stu1.age)
print(stu1.tel)

魔术方法

魔术方法类似于C++中的运算符重载

例子1：str 和 lt

这个方法的作用就是控制类转换为字符串时的行为

class Student:

    # !!
    def __init__(self, name, age, tel):
        self.name = name
        self.age = age
        self.tel = tel
        print("Student类创建了一个类对象")

    def __str__(self):
        return f"Student对象的成员name:{self.name}, age:{self.age}, tel:{self.tel}"
    # 相当于重载 < 运算符,使得对象可以用 < 和 >
    def __lt__(self,other):
        return self.age < other.age
    # 使得对象间 >= 和 <= 可用
    def __le__(self, other):
        return self.age <= other.age

    # ==运算符重载
    def __eq__(self, other):
        return self.age == other.age

stu1 = Student("陈奕迅", 39, 1292392992)
stu2 = Student("周杰伦", 39, 1239200233)
print(stu1 < stu2) # False
print(stu1 > stu2) # False
print(stu1 <= stu2) # True
print(stu1 >= stu2) # True
print(stu1 == stu2) # 如果类内没有实现 __eq__,则比较的时内存地址,False
print(stu1)

输出结果：

Student类创建了一个类对象

False

True

Student对象的成员name:陈奕迅, age:39, tel:1292392992

封装

例子1：私有成员变量和方法

以两个下划线__ 开头的变量或方法，就是私有的成员

class Phone:
    # 成员名前有 __ 就是私有成员
    __current_voltage = 0.5 # 手机当前电压

    def __keep_single_core(self):
        print("CPU以单核模式运行")

    def call_by_5g(self):
        # 只有类内
        if self.__current_voltage >= 1:
            print("5g通话已开启")
        else:
            self.__keep_single_core()
            print("电量不足，无法使用5g通话，并设置为单核模式")

phone = Phone()

phone.call_by_5g();
# 类外无法使用私有成员，如下：
# print(phone.__current_voltage)
# phone.__keep_single_core()

输出结果：

CPU以单核模式运行

电量不足，无法使用5g通话，并设置为单核模式

继承

简单的说就是复用其他类的内容

语法： class 类名(父类名):

例子1

class Phone:
    IMEI = None
    producer ="Apple"

    def call_by_4g(self):
        print("4g通话")

# Phone2023 继承 Phone，或称作 Phone2023 派生自 Phone
class Phone2023(Phone):
    face_id = "10001"

    def call_by_5g(self):
        print("5g通话")

phone = Phone2023()
print(phone.producer)
phone.call_by_4g()
phone.call_by_5g()

输出结果：

Apple

4g通话

5g通话

例子2：多继承

class Phone:
    IMEI = None
    producer ="Apple"

    def call_by_4g(self):
        print("4g通话")

class NFCReader:
    nfc_type = "第五代"
    producer = "Samsung"

    def read_card(self):
        print("NFC读卡")

    def write_card(self):
        print("NFC写卡")

class RemoteControl:
    rc_type = "红外遥控"

    def control(self):
        print("红外遥控开启")

class MyPhone(Phone, NFCReader, RemoteControl):
    pass # 啥也不想写就填 pass

phone = MyPhone()
phone.call_by_4g()
phone.read_card()
phone.write_card()
phone.control()

# 注意Phone, NFCReader都有 producer 成员
# 注意这里 producer 使用的是Phone::producer,即继承中左边的类的成员
print(phone.producer)

输出结果：

4g通话

NFC读卡

NFC写卡

红外遥控开启

Apple

例子3：子类复写父类成员；子类使用父类的成员

class Phone:
    IMEI = None
    producer ="Apple"

    def call_by_5g(self):
        print("5g通话")

class MyPhone(Phone):
    # 复写父类的成员
    producer = "Nokia"

    def call_by_5g(self):
        print("开启CPU单核模式，确保通话时省电")
        # 使用父类成员方式1
        # print(f"父类的厂商是{Phone.producer}")
        # Phone.call_by_5g(self) # 注意这种方法要传 self

        # 使用父类成员方式2 super()
        print(f"父类的厂商是{super().producer}")
        super().call_by_5g()
        print("关闭CPU单核模式，确保性能")

phone = MyPhone()
phone.call_by_5g()
print(phone.producer)

输出结果:

开启CPU单核模式，确保通话时省电

父类的厂商是Apple

5g通话

关闭CPU单核模式，确保性能

Nokia

类型的注解

给类型加上注解之后，比如给函数参数加注解，则调用函数时，智能提示就能提示输入参数类型。

一般是无法看出来的参数类型才建议加注解

例子1

tu:Student = Student()

# 基础容器类型注解
my_list: list = [1, 2, 3]
my_tuple: tuple = (1, 2, 3)
my_dict: dict = {"lisi": 44}

# 容器类型详细注释
my_list1: list[int] = [1, 2, 3]
my_tuple1: tuple[int, str, bool] = (1, "apple", False)
my_dict1: dict[str, int] = {"lisi": 44}

# 在注释中进行类型注解
var_4 = random.randint(1, 10)  # type: int
var_5 = json.loads('{"name": "wangwu"}') # type:dict[str, str]
def func():
    return 10

var_6 = func() # type: int

# 类型注解的限制
# 如果注解和实际类型不符合，pycharm提示按用户注解来
var_7: int = "nokia"
var_8: str = 222

在这里插入图片描述

例子2：函数参数类型进行注解

# 对形参类型进行注解
def add(x: int, y: int):
    return x + y

# 对返回值进行类型注解
def func(data: list) ->list:
    return data


# 类型注解只是起提示作用，下面语句仍能正常运行
print(type(func(1))) # <class 'int'>

注解：

添加注解后，调用函数按下 ctrl + p会有如下提示

在这里插入图片描述

例子3：union联合类型注解

from typing import Union

# 表示列表元素类型可为 int 或 str
my_list: list[Union[int, str]] = [1, 2, 3]

# 表示函数参数类型可为 int 或str
def func(data: Union[int, str]) -> Union[int, str]:
    pass

在这里插入图片描述

多态

例子1

class Animal:
    def speak(self):
        pass

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

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

# 根据不同参数来调用对应的对象,基类接受派生类
def make_noise(animal: Animal):
    animal.speak()

dog = Dog()
cat = Cat()
make_noise(dog)
make_noise(cat)

输出结果：

汪汪汪

喵喵喵

例子2

# 空调抽象基类
class AC:
    def cool_wind(self):
        pass

    def hot_wind(self):
        pass

    def swing_l_r(self):
        pass

class Midea_AC(AC):
    def cool_wind(self):
        print("美的空调制冷")

    def hot_wind(self):
        print("美的空调制热")

    def swing_l_r(self):
        print("美的空调左右摆风")

class GREE_AC(AC):
    def cool_wind(self):
        print("格力空调制冷")

    def hot_wind(self):
        print("格力空调制热")

    def swing_l_r(self):
        print("格力空调左右摆风")

def make_cool(ac: AC):
    ac.cool_wind()

midea_ac = Midea_AC()
gree_ac = GREE_AC()

make_cool(midea_ac)
make_cool(gree_ac)