目录

1 初识对象

2. 成员方法

 3. 类和对象

4. 构造方法

5. 其它内置方法

6. 封装

7. 继承

 8. 复写

9. 类型的注解

10. 多态

---

1 初识对象

1. 生活中或是程序中，我们都可以使用设计表格、生产表格、填写表格的形式组织数据
2. 进行对比，在程序中：
设计表格，称之为：设计类（class）
打印表格，称之为：创建对象
填写表格，称之为：对象属性赋值

2. 成员方法

1.类的定义与使用

我们简单了解到可以使用类去封装属性，并基于类创建出一个个的对象来使用。
现在我们来看看类的使用语法：

class Student:
    name = None #成员变量
    def speak(self):
        print("hello world!")#成员方法

• class是关键字，表示要定义类了
• 类的属性，即定义在类中的变量（成员变量）
• 类的行为，即定义在类中的函数（成员方法）

创建类对象的语法：

2.成员变量和成员方法

总结：

 

"""
演示面向对象类中的成员方法定义和使用
"""

# 定义一个带有成员方法的类
class Student:
    name = None     # 学生的姓名

    def say_hi(self):
        print(f"大家好呀，我是{self.name}，欢迎大家多多关照")


    def say_hi2(self, msg):
        print(f"大家好，我是：{self.name}，{msg}")


stu = Student()
stu.name = "周杰轮"
stu.say_hi2("哎哟不错哟")

stu2 = Student()
stu2.name = "林俊节"
stu2.say_hi2("小伙子我看好你")

 3. 类和对象

基于类创建对象的语法:
为什么非要创建对象才能使用呢？
类只是一种程序内的“设计图纸”，需要基于图纸生产实体（对象），才能正常工作
这种套路，称之为：面向对象编程

 

"""
演示类和对象的关系，即面向对象的编程套路（思想）
"""

# 设计一个闹钟类
class Clock:
    id = None       # 序列化
    price = None    # 价格


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

# 构建2个闹钟对象并让其工作
clock1 = Clock()
clock1.id = "003032"
clock1.price = 19.99
print(f"闹钟ID：{clock1.id}，价格：{clock1.price}")
# clock1.ring()

clock2 = Clock()
clock2.id = "003033"
clock2.price = 21.99
print(f"闹钟ID：{clock2.id}，价格：{clock2.price}")
clock2.ring()

4. 构造方法

 

"""
演示类的构造方法
"""
# 演示使用构造方法对成员变量进行赋值
# 构造方法的名称：__init__

class Student:

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

stu = Student("周杰轮", 31, "18500006666")
print(stu.name)
print(stu.age)
print(stu.tel)

练习：学生信息的录入：

开学了有一批学生信息需要录入系统，请设计一个类，记录学生的：
姓名、年龄、地址，这3类信息
请实现：

• 通过for循环，配合input输入语句，并使用构造方法，完成学生信息的键盘录入
• 输入完成后，使用print语句，完成信息的输出

"""
学生信息录入
"""

# 定义学生类
class Student:
    name = None #学生姓名
    age = None #学生年龄
    address = None #学生的地址

    def __init__(self,name,age,address):
        self.name = name
        self.age = age
        self.address = address

# 输入学生信息
num_students = int(input("请输入学生的数量："))

for i in range(num_students):
    print(f"请输入第{i+1}位学生的信息")
    name = input("姓名：")
    age = input("年龄：")
    address = input("地址：")
    student = Student(name,age,address)
    print(f"第{i+1}位学生，name={name},age={age},address={address}")

5. 其它内置方法

 1. _str_ 字符串方法

当类对象需要被转换为字符串之时，会输出如上结果（内存地址）

内存地址没有多大作用，我们可以通过__str__方法，控制类转换为字符串的行为。

2. _lt_ 小于符号的比较方法

 3. __le__ 小于等于比较符号方法

 4. _eq_

 

"""
演示Python内置的各类魔术方法
"""


class Student:
    def __init__(self, name, age):
        self.name = name        # 学生姓名
        self.age = age          # 学生年龄

    # __str__魔术方法
    def __str__(self):
        return f"Student类对象，name:{self.name}, age:{self.age}"

    # __lt__魔术方法
    def __lt__(self, other):
        return self.age < other.age

    # __le__魔术方法
    def __le__(self, other):
        return self.age <= other.age

    # __eq__魔术方法
    def __eq__(self, other):
        return self.age == other.age


stu1 = Student("周杰轮", 31)
stu2 = Student("林俊节", 36)
print(stu1 == stu2)

6. 封装

面向对象的三大特性

 

私有成员

既然现实事物有不公开的属性和行为，那么作为现实事物在程序中映射的类，也应该支持。

类中提供了私有成员的形式来支持。

• 私有成员变量
• 私有成员方法

定义私有成员的方式非常简单，只需要：

• 私有成员变量：变量名以__开头（2个下划线）
• 私有成员方法：方法名以__开头（2个下划线）

即可完成私有成员的设置

 

 

 

"""
演示面向对象封装思想中私有成员的使用
"""

# 定义一个类，内含私有成员变量和私有成员方法
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()

 练习题：设计带有私有成员的手机

class Phone:
    __is_5g_enable = None #type:bool

    #构造方法，为私有成员赋值
    def __init__(self,__is_5g_enble):
        self.__is_5g_enable =__is_5g_enble

    #判断5g的状态
    def __check_5g(self):
        if self.__is_5g_enable:
            print("5g开启")
        else:
            print("5g关闭，使用4g网络")
    #调用私有方法来查看5g的状态
    def call_by_5g(self):
        self.__check_5g()
        print("正在通话中")

phone = Phone(True)
phone.call_by_5g()

phone = Phone(False)
phone.call_by_5g()

运行结果：

7. 继承

 

 

 

"""
演示面向对象：继承的基础语法
"""

# 演示单继承
class Phone:
    IMEI = None     # 序列号
    producer = "ITCAST" # 厂商


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


class Phone2022(Phone):
    face_id = "10001"       # 面部识别ID


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


phone = Phone2022()
print(phone.producer)
phone.call_by_4g()
phone.call_by_5g()
# 演示多继承
class NFCReader:
    nfc_type = "第五代"
    producer = "HM"

    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


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

print(phone.producer)



# 演示多继承下，父类成员名一致的场景

 8. 复写

 

 

"""
演示面向对象：继承中
对父类成员的复写和调用
"""


class Phone:
    IMEI = None             # 序列号
    producer = "ITCAST"     # 厂商

    def call_by_5g(self):
        print("使用5g网络进行通话")


# 定义子类，复写父类成员
class MyPhone(Phone):
    producer = "ITHEIMA"        # 复写父类的成员属性

    def call_by_5g(self):
        print("开启CPU单核模式，确保通话的时候省电")
        # 方式1
        # print(f"父类的厂商是：{Phone.producer}")
        # Phone.call_by_5g(self)
        # 方式2
        print(f"父类的厂商是：{super().producer}")
        super().call_by_5g()
        print("关闭CPU单核模式，确保性能")

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

# 在子类中，调用父类成员

9. 类型的注解

9.1 变量的类型注解

 

 

 

 

#第一种方式的类型注解
name:str = None
age:int = None
address = None

#第二种方式的类型注解
name = None #type:str
age = None #type:int
address = None #type:str

 

 

 

 

 

"""
演示变量的类型注解
"""

# 基础数据类型注解
import json
import random

# var_1: int = 10
# var_2: str = "itheima"
# var_3: bool = True
# 类对象类型注解
class Student:
    pass
stu: Student = Student()

# 基础容器类型注解
# my_list: list = [1, 2, 3]
# my_tuple: tuple = (1, 2, 3)
# my_dict: dict = {"itheima": 666}
# 容器类型详细注解
my_list: list[int] = [1, 2, 3]
my_tuple: tuple[int, str, bool] = (1, "itheima", True)
my_dict: dict[str, int] = {"itheima": 666}
# 在注释中进行类型注解
var_1 = random.randint(1, 10)   # type: int
var_2 = json.loads('{"name": "zhangsan"}')  # type: dict[str, str]
def func():
    return 10
var_3 = func()  # type: int
# 类型注解的限制
var_4: int = "itheima"
var_5: str = 123

 9.2 函数（方法）的类型注解

函数（方法）的类型注解 - 形参注解

def func(x:int,y:int)

 上述代码分别对func()函数的x、y形参注解为int类型

函数（方法）的类型注解 - 返回值注解

def func(x:int,y:int) -> int:
    return x + y

 上述代码中 -> int 表示函数返回int的数据类型

代码演示

"""
演示对函数（方法）进行类型注解
"""

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

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

print(func(1))

9.3 Union类型

使用Union[类型,......,类型]

可以用来去定义联合类型的注解

Union联合类型注解，在变量注解、函数（方法）形参和返回值注解中，均可使用。

1. 什么是Union类型？
使用Union可以定义联合类型注解
2. Union的使用方式

• 导包：from typing import Union
• 使用：Union[类型, ......, 类型]

代码详解：

"""
演示Union联合类型注解
"""
# 使用Union类型，必须先导包
from typing import Union

my_list: list[Union[int, str]] = [1, 2, "itheima", "itcast"]

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

10. 多态

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

同样的行为（函数），传入不同的对象，得到不同的状态

 抽象类
 

class Animal:

    def speak(self):
        pass

这种设计的含义是：

• 父类用来确定有哪些方法
• 具体的方法实现，由子类自行决定

这种写法，就叫做抽象类（也可以称之为接口）

抽象类：含有抽象方法的类称之为抽象类
抽象方法：方法体是空实现的（pass）称之为抽象方法

抽象类（接口）

抽象类就好比定义一个标准，
包含了一些抽象的方法，要求子类必须实现。

配合多态，完成

• 抽象的父类设计（设计标准）
• 具体的子类实现（实现标准）

"""
演示面向对象的多态特性以及抽象类（接口）的使用
"""


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对象"""
    animal.speak()


# 演示多态，使用2个子类对象来调用函数
dog = Dog()
cat = Cat()

make_noise(dog)
make_noise(cat)


# 演示抽象类
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)