[Python] 学习笔记-对象

[Python] 对象

---

一、使用类创建对象

生活中：设计表格、打印表格、填写表格
在程序中：设计类、创建对象、对象属性赋值

# 1.设计类
class student:
    name = None
    gender = None
    age = None

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

# 3.对象属性进行赋值
stu1.name = "xiaoming"
stu1.gender = "male"
stu1.age = 20

二、类的定义和使用

类中包含属性和行为，即成员变量和方法

若想在成员方法内部访问成员属性，前面需要带上self.

class student:
    name = None

    def say_hi(self):
        print(f"Hello! My name is {self.name}!")

stu = student()
stu.name = "xiaoming"
stu.say_hi()

成员方法中访问外部属性，不需要在前面加self.

class student:
    name = None

    def say_hi2(self, msg):
        print(f"Hello! My name is {self.name}! {msg}")

stu = student()
stu.name = "xiaoming"
stu.say_hi2("666")

三、类和对象

现实世界的事物：由属性和行为组成

对象名 = 类名称( )

这种创建对象的方法称为面向对象编程
核心：设计类、基于类创建对象、由对象做具体的工作

class clock:
    id = None
    price = None

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

clock1 = clock()
clock1.id = "001"
clock1.price = 19.99
print(f"产品ID：{clock1.id} 价格：{clock1.price}")
clock1.ring()

类型注解(提示性、非强制性)

1.变量注解

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

# 基础容器类型注解
mylist: list = [1, 2, 3]
mytuple: tuple = (1, 2, 3)
myset: set = {1, 2, 3}
mydict: sict = {"python": 666}
mystr: str = "python"
# 容器类型详细注解
mylist: list[int] = [1, 2, 3]
mytuple: tuple[str, int, bool] = (1, 2, 3)
myset: set[int] = {1, 2, 3}
mydict: sict[str, int] = {"python": 666}

2.函数注解

# 函数类型注解-形参注解
def add(x: int, y: int) -> int:
	return x + y
add(10, 20)

# 函数类型注解-返回值注解
def add(x: int, y: int)
	return x + y

3.类对象注解

class student
	pass
stu: student = student()

4.联合类型注解-Union[ ]

from typing import Union
# 变量类型为int或str
mylist: list[Union[int, str]] = [1, 2, "Python"]
# 函数传入的变量类型为int或str
def func(data: Union[int, str]) -> Union[int, str]
	pass

面向对象的三大特性

1.封装

将现实世界中的事物描述为程序中的类

现实世界中的事物有属性和行为，但是这些属性和行为不是都对用户开放的，不公开的为私有成员变量和私有成员方法，变量和方法名以两个下划线开头即可

私有成员不可以直接使用，但是可以被类中其他成员使用

class Phone:

    __current_voltage = 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()

2.继承

单继承 class 类名(父类名)：

class Phone:
    IMEI = None
    producer = "HW"

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

class Phone2023(Phone):
    face_id = "10001"

    def call_by_5g(self):
        print("2023新功能：5g通话")

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

多继承 class 类名(父类1，父类2，父类3…)：

【注意】多个父类中，若有同名的成员或成员方法，默认以继承顺序（从左到右）为优先级

# 若想看某个类继承的优先级,以下两种方法可实现
# 当某个继承的类实例化后调用了某个方法，会根据mro(Method Resolution Order)中的优先级依次查询方法是否存在，调用的查询到的存在的第一个
print(classname.__mro__)
print(classname.mro())

class Phone:
    IMEI = None
    producer = "HW"

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

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

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

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


class Phone2023(Phone, NFCReader):
    pass

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

复写 重写父类中的属性、方法

class Phone:
    IMEI = None
    producer = "HW"

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

class Phone2023(Phone, NFCReader):
    producer = "HM"

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

一旦复写父类成员，类对象调用成员的时候，就会调用复写后的新成员
若需要使用被复写的父类的成员，需要特殊的调用方式

class Phone:
    IMEI = None
    producer = "HW"

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

class Phone2023(Phone):
    producer = "HM"


    def call_by_4g(self):
    	# 方法1
        print(f"父类的厂商是：{Phone.producer}")  # 若用self.producer则是复写后的成员
        Phone.call_by_4g(self)

		# 方法2
        print(f"父类的厂商是：{super().producer}")
        super().call_by_4g()  # 若多个父类中存在同名函数，则不能用super
phone = Phone2023()  

print(phone.producer)  # HM
phone.call_by_4g()     # 父类的厂商是：HW    4g通话

3.多态

即多种状态，在完成某个行为时，使用不同的对象会得到不同的状态
要求函数(方法)形参声明接收父类对象，实际传入父类的子类对象进行工作
即以父类做定义声明，以子类做实际工作，用以获得同一行为，不同状态

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()

抽象类(接口)：具有抽象方法的类，父类确定有哪些方法，具体的方法实现由子类自行决定
顶层设计给出要有的内容，具体实现：子类继承父类并重写

# 抽象父类，上层设计
class AC:
    def cool_wind(self):
        pass

    def hot_wind(self):
        pass

# 创建子类，复写方法
class AC_1(AC):
    def cool_wind(self):
        print("空调1制冷")

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

class AC_2(AC):
    def cool_wind(self):
        print("空调2制冷")

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


def make_cool(ac):
    ac.cool_wind()

# 创建子类的类对象
midea_ac = AC_1()
gree_ac = AC_2()

make_cool(midea_ac)
make_cool(gree_ac)

四、构造方法__init__( )

在创建类对象（构造类）时，会自动执行构造方法，且会传入参数自动传递给__init__()方法使用

class student:

    def __init__(self, name, age):
    	# 同时具有赋值和定义的功能，不需要在前面定义属性
        self.name = name
        self.age = age
        print("student类创建了一个类对象")

stu = student("xiaoming", 30)
print(stu.name, stu.age)