Python面向对象编程基础-优快云博客

# 设计类
class Student:
    name = None
    age = None
    sex = None

# 创建对象
stu_1 = Student()

# 对象属性赋值
stu_1.name = "张三"
stu_1.age = 18
stu_1.sex = "男"
# 张三
print(stu_1.name)
# 18
print(stu_1.age)
# 男
print(stu_1.sex)

2. 类的成员方法

1.类是由哪两部分组成？

类的属性：成员变量。
类的行为：成员方法。

注意：函数是定义在类外的，而方法是定义类内的。

2.类和成员方法的定义语法

3.self的作用

self表示类对象本身的作用。
只有通过self，成员方法才能访问类的成员变量。
self虽然出现在形参列表中，但是不占用参数位置。

class Student:
    name = None

    def say_hi(self):
        print(f"大家好，我是{self.name},请多多指教！")

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

stu1 = Student()
stu1.name = "张三"
stu1.say_hi()

stu2 = Student()
stu2.name = "李四"
stu2.say_hi2("请多多关照！")

3. 类和对象

1. 现实世界的事物由什么组成？

属性
行为

类也可以包含属性和行为，所以使用类描述现实世界事物是非常合适的。

2. 类和对象的关系是什么？

类是程序中的“设计图纸”。
对象是基于图纸生产的具体实体。

3. 什么是面向对象编程？

面向对象编程就是，使用对象进行编程。
即，设计类，基于类创建对象，并使用对象来完成具体的工作。

# 设计类
class Clock:
    # 序列号
    id = None
    # 零售价
    price = None

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

# 创建对象
clock1 = Clock()
# 给对象属性赋值
clock1.id = "1001"
clock1.price = 19.99
# 使用对象的属性和方法
print(f"闹钟ID：{clock1.id}，价格：{clock1.price}")
clock1.ring()

# 创建对象
clock2 = Clock()
# 给对象属性赋值
clock2.id = "1002"
clock2.price = 29.99
# 使用对象的属性和方法
print(f"闹钟ID：{clock2.id}，价格：{clock2.price}")
clock2.ring()

4. 构造方法

1.构造方法的名称：

__init__，注意init前后的2个下划线符号。

2.构造方法的作用：

构建类对象的时候会自动运行。

构建类对象的传参会传递给构造方法，借此特性可以给成员变量赋值。

3.注意事项：

构造方法不要忘记self关键字。

在方法内使用成员变量需要使用self。

案例

# 设计类
class Student:
    # # 成员变量
    # name = None
    # age = None
    # address = None

    # 构造方法
    def __init__(self,name,age,address):
        self.name = name
        self.age = age
        self.address = address

# 循环录入学生信息并打印学生信息
for i in range(3):
    print(f"当前录入第{i+1}学生信息，总共需要录入2位学生信息")
    name = input("请输入姓名：")
    age = input("请输入年龄：")
    address = input("请输入地址：")
    # 创建对象
    stu = Student(name,age,address)
    # 打印学生信息
    print(f"学生{i+1}信息录入完成，信息为：【姓名：{stu.name}，年龄：{stu.age}，地址：{stu.address}】")
    print("-"*47)

5. 其它内置方法

方法	功能
__init__	构造方法，可用于创建类对象的时候设置初始化行为
__str__	用于实现类对象转字符串的行为
__lt__	用于2个类对象进行小于或大于比较
__le__	用于2个类对象进行小于等于或大于等于比较
__eq__	用于2个类对象进行相等比较

class Student:
    # __init__构造方法
    def __init__(self,name,age):
        self.name = name
        self.age = age

    # __str__字符串方法
    def __str__(self):
        return f"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("张三",20)
stu2 = Student("李四",21)
stu3 = Student("王五",20)

'''
调用__str__字符串方法
'''
# name=张三,age=20
print(stu1)
# name=李四,age=21
print(str(stu2))

'''
__lt__小于符号比较方法
'''
# True
print(stu1 < stu2)
# False
print(stu1 > stu2)


'''
__le__小于等于比较方法
'''
# True
print(stu1 <= stu3)
# False
print(stu1 >= stu2)

'''
__eq__比较运算符实现方法
'''
# 若不实现__eq__方法，对象之间可以比较，但是比较的是对象的内存地址
# 若实现__eq__方法，就按照自己的想法来决定2个对象是否相等
# True
print(stu1 == stu3)

6. 封装

1.封装的概念？

将现实世界事物在类中描述为属性和方法，即为封装。

2.什么是私有成员？为什么需要私有成员？

现实事物有部分属性和行为是不公开对使用者开放的。同样在类中描述属性和方法的时候也需要达到这个要求，这就需要定义私有成员了。

3.如何定义私有成员？

成员变量和成员方法的命名均以__作为开头即可。

4.私有成员的访问限制？

类中的其它成员可以访问私有成员。
类对象无法访问私有成员。

案例

class Phone:
    # 私有成员变量（对用户隐藏）
    __is_5g_enable = False  # 5g状态

    # 私有成员方法（对用户隐藏）
    def __check_5g(self):
        if self.__is_5g_enable:
            print("5g开启")
        else:
            print("5g关闭，使用4g网络")

    # 公开成员方法（对用户公开）
    def call_by_5g(self):
        self.__check_5g()
        print("正在通话中")

phone = Phone()
phone.call_by_5g()

7. 继承

7.1 继承的基础语法

1.什么是继承？

继承就是一个类，继承另外一个类的成员变量和成员方法。

语法：

子类构建的类对象，可以：

使用父类的成员变量和成员方法。
有自己的成员变量和成员方法。

2.单继承和多继承

单继承：一个类继承另一个类。

多继承：一个类继承多个类，按照顺序从左到右依次继承。

多继承中，如果父类有同名方法和属性，先继承的优先级高于后继承。

3.pass关键字的作用

pass是占位语句，用来保证函数（方法）或类定义的完整性，表示无内容，空的意思。

'''
单继承
'''
class Phone:
    # 序列号
    IMEI = None
    # 厂商
    producer = "HW"


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

class Phone2022(Phone):
    # 面部识别
    face_id = True

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

Phone2022 = Phone2022()
# 4g通话
Phone2022.call_by_4g()
# 2022最新5g通话
Phone2022.call_by_5g()

'''
多继承
'''
class NFCReader:
    nfc_type = "第五代"
    producer = "HM"

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

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

class MyPhone(Phone,NFCReader):
    pass

my_phone = MyPhone()
# 4g通话
my_phone.call_by_4g()
# 读取NFC卡
my_phone.read_card()
# 多个父类中，如果有同名的成员，那么默认以继承顺序（从左到右）为优先级
# HW
print(my_phone.producer)

7.2 复写和调用父类成员

1.复写表示：

对父类的成员属性或成员方法重新定义。

2.复写语法：

在子类中重新实现同名成员方法或成员属性即可。

3.在子类中，如何调用父类成员？

注意：只可以在子类内部调用父类的同名成员，子类的实体类对象调用默认是调用子类复写的。

class Phone:
    IMEI = None
    producer = "ITCAST"

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

# 子类1复写父类的成员属性和成员方法
class MyPhone1(Phone):
    producer = "ITHEIMA"

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

# 子类2复写父类的成员属性和成员方法，并在成员方法中调用父类成员
class MyPhone2(Phone):
    producer = "ITHEIMA"

    def call_by_5g(self):
        # # 方式1调用父类成员
        # print(f"父类的品牌是：{Phone.producer}")
        # Phone.call_by_5g(self)

        # 方式2调用父类成员
        print(f"父类的品牌是：{super().producer}")
        super().call_by_5g()
        print("子类的5g通话")

'''
子类的实体类对象调用的成员默认是调用子类复写的。
'''
my_phone1 = MyPhone1()
# ITHEIMA
print(my_phone1.producer)
# 子类的5g通话
my_phone1.call_by_5g()

my_phone2 = MyPhone2()
# 父类的品牌是：ITCAST
# 父类的5g通话
# 子类的5g通话
my_phone2.call_by_5g()

8. 多态

1.什么是多态？

多态指的是，同一个行为，使用不同的对象获得不同的状态。如，定义函数（方法），通过类型注解声明需要父类对象，实际传入子类对象进行工作，从而获得不同的工作状态。

2.什么是抽象类（接口）？

包含抽象方法的类，称之为抽象类。抽象方法是指：没有具体实现的方法（pass）称之为抽象方法。

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()
# 汪汪汪
make_noise(dog)
# 喵喵喵
make_noise(cat)