Class类学习

  • 学习类，以及类的有关方法，都基本到了这门语言语法的末尾章节了。类相较于其他知识点也是比较难理解的。如构造方法，类的继承，多态。

1，类的构造方法

  • 1，构建类的方法的时候会自动执行
  • 2，构建类对象的传参会传递给构造方法
  • 3，构造方法可以给类的成员变量赋值

写法

1
__init__(self):

Demo

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
class Student_info:
    #此处的定义可以不写，因为在self方法中self.name 既有赋值功能也有定义的功能
    name = None
    age = None
    tel = None

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


student = Student_info('周杰伦',18,'123123213')
print(f"我叫{student.name},年龄{student.age},电话号码是{student.tel}")

2，魔术方法(str, lt, le, eq)

Demo

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
class Student:
    def __init__(self, name, age):
        self.name = name
        self.age = age

    def __str__(self):      #使用此方法后，打印stu1类对象就不再是内存地址，而是自定义的字符串
        return f'我的名字是{self.name},年龄是{self.age}'

    def __lt__(self, other):    #判断该类对象的age是否大于另一个类对象的age
        return self.age > other

    def __le__(self, other):    #判断该类对象的age是否大于或等于另一个类对象的age
        return self.age >= other

    def __eq__(self, other):    #判断该类对象的age是否等于另一个类对象的age
        return self.age == other


stu1 = Student("凌俊杰", 18)
stu2 = Student("周杰伦", 20)
print(stu2)
print(stu1 > stu1)

3，私有成员变量和成员方法

  • 类对象无法访问私有成员，但是类中其他成员可以访问私有成员

Demo

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
class Phone:
    __is_5G_enable = True       #定义私有成员变量

    def __check_5G(self):       #定义私有成员函数
        if self.__is_5G_enable == True:     #私有成员函数访问私有成员变量
            print("5G开启")
        else:
            print("5G关闭，开启4G网络")

    def call_by_5G(self):
        self.__check_5G()       #通过类中的成员方法去访问私有成员函数
        print("正在通话中")

phone = Phone()     #将类实例化
phone.call_by_5G()  #调用类的公开方法

4，继承（单继承和多继承）

Demo

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
class Phone:
    IMIE = None  # 序列号
    producer = 'Itcast'  # 生产厂商

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


class Phone2023(Phone):  # 继承Phone这个类
    face_id = '13223'

    def call_by_5g(self):
        print("开启5G新时代")


class NFC_Reader:
    producer = 'Tecent'

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

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


class Remote_Control:
    rc_type = '红外遥控'

    def control(self):
        print("红外遥控器开启")
class MyPhone(Phone2023,Remote_Control, NFC_Reader):
    pass
phone = MyPhone()
phone.read_card()
phone.write_card()
phone.control()
phone.call_by_4g()
phone.call_by_5g()
print(phone.producer)

5，复用

  • (子类对父类的某些函数或者变量不满意时可以采用复用)

Demo

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
class Phone:
    producer = 'itcast'

    def call_by_5G(self):
        print('5G通话开启')
class MyPhone(Phone):
    producer = 'itheima'

    def call_by_5G(self):
        print('开启单核模式，确保CPU执行时省电')
        #调用父类的成员函数和成员方法,两种调用方法，super()或者是Phone直接写父类
        print(f"父类的生产厂商是:{Phone.producer}")
        super().call_by_5G()
        print("5G通话关闭")
        
        
phone = MyPhone()       #将类实例化
phone.call_by_5G()

6，类型注解

Demo

1
2
3
4
5
6
7
8
9
10
11
12
13
import random
import json
class Student:
    pass
stu: Student = Student()
list1: list = [1, 2, 3]     #基础容器类型注解
list2: list = [1, 2, 3]    #详细容器类型注解
my_tuple: tuple= (1, 'itheima',True)    #详细容器类型注解
var1 = random.randint(1,10)  #type: int
var2 = json.loads('{"name": "zhangsan"}')   #type: dict[str, str]
def func():
    return 10
var3 = func()   #type: int

7，对形参类型和返回值进行注解

  • 对形参类型进行注解要写在函数形参的括号中
  • 对返回值进行注解要在括号之后冒号之前进行注解（如 -> ）

Demo

1
2
3
4
5
6
7
8
9
def func(x: int, y: int) -> int:
    return x + y
ret = func(2, 5)
print(ret)

def func1(data: list) -> list:
    return data
print(func1(1))     #这里说明函数的注解只是提示性的而非强制性的，哪怕参数传递的不对也不会给报错

8，Union联合类型注解

Demo

1
2
3
4
5
6
7
8
from typing import Union	#（使用Union之前必须先导包）

#首先先写个普通的注解
my_list: list[Union[int, str]] = [1, 2, 'itheima', 'itcast']    #此注解表明我的list是个int和str混合类型

def func(data: Union[str, int]) -> Union[int, str]: #表明函数的参数和返回值为int或者str类型
    pass
func()  #在函数上面按住CRTL+ P会看到提示传入参数的类型为data[int, str]类型

9，多态

Demo

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
class AC:  # 定义抽象类（好比是一个标准），包含抽象方法（没有具体实现的方法叫做抽象方法），要求子类必须实现
    def cool_wind(self):  # 吹冷风
        pass

    def hot_wind(self):  # 吹热风
        pass

    def swing_l_r(self):  # 左右摆风
        pass


class Midea_AC(AC):  # 美的空调类继承AC类，复写AC类的抽象方法
    def cool_wind(self):
        print("美的空调核心制冷科技")

    def hot_wind(self):
        print("美的空调电热丝加热")

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


class Gree_AC(AC):  # 格力空调类继承AC类，复写AC类的抽象方法
    def cool_wind(self):
        print("格力空调核心制冷科技")

    def hot_wind(self):
        print("格力空调电热丝加热")

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


def make_cool(ac: AC):  # 该吹风函数形参为ac，而且是一个AC类型的参数
    ac.cool_wind()  #


# 一般不会构建抽象类的对象，也就是不将抽象类（AC）实例化，而是将抽象类的子类实例化
gree_ac = Gree_AC()  # 实例化空调类对象
midea_ac = Midea_AC()  # 实例化空调类对象
make_cool(gree_ac)  # 传入子类对象