python入门篇11-面向对象的基础使用

---

1.前言简介

1.1 专栏传送门

1.1.1 上文小总结

1.1.2 上文传送门

2. python基础使用

2.1 面向对象的基础使用

2.1.1 创建类

class关键字修饰

• 类名首字母大写
• 属性名 = None

class Student:
    username = None
    age = None
    gender = None
    phone = None
    email = None

2.1.2 使用对象(定义成员变量)

student = Student()即可 java是new对象初始化
属性赋值是 对象.属性 =

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

# 3. 对象属性进行赋值
student.username = "张三"
student.age = "20"
student.gender = "男"
student.phone = "13345678910"
student.email = "123456@qq.com"

print(student.username)
print(student.age)
print(student.gender)
print(student.phone)
print(student.email)

2.1.3 成员方法的定义与使用

关键字 def , 默认生成一个self关键字 跟this一样 指代当前对象

class Student:
    id = None
    username = None
    age = None
    gender = None
    phone = None
    email = None

    def introduce_myself(self):
        """
        自我介绍
        :return:
        """
        print(f"你好,我是{self.username},年龄{self.age},性别是{self.gender},手机号是:{self.phone},邮箱是:{self.email}")

    def introduce_hobby(self, msg):
        """
        爱好介绍
        :return:
        """
        print(f"你好,我是{self.username},我的爱好是:{msg}")

案例使用: 创建对象 赋值并使用成员方法

# 使用对象
student = Student()

# 3. 对象属性进行赋值
student.id = 1
student.username = "张三"
student.age = "20"
student.gender = "男"
student.phone = "13345678910"
student.email = "123456@qq.com"

student1 = Student()
student1.id = 2
student1.username = "李四"
student1.age = "25"
student1.gender = "女"
student1.phone = "13345678911"
student1.email = "145689@qq.com"

student.introduce_myself()
student1.introduce_hobby("唱跳rap,篮球")

2.1.4 构造方法的使用

注意看 2.1.1 与这个写法区别 可以不写成员属性, 直接在构造方法中写
java不可以的呦~~

class Student:
    # id = None
    # username = None
    # age = None
    # gender = None
    # phone = None
    # email = None

    def __init__(self, id, username, age, gender, phone, email):
        self.id = id
        self.username = username
        self.age = age
        self.gender = gender
        self.phone = phone
        self.email = email
        print("构造方法执行成功")

案例使用测试

for i in range(10):
    username = input("请输入用户名: \n")
    age = input("请输入年龄: \n")
    sex = input("请输入性别: \n")
    phone = input("请输入电话号: \n")
    email = input("请输入邮箱: \n")
    student = Student(i, username, age, sex, phone, email)
    print(f"第{i + 1}名学生录入成功", "")
    print(f"你好,我是{student.username},年龄{student.age},性别是{student.gender},手机号是:{student.phone},邮箱是:{student.email}")

2.1.5 常用魔术方法

__init__: 构造方法
__str__: 不加这个就是内存地址 加了str的魔术方法 返回的就是return信息
__lt__: (>,=,<) 任意类型比较
__le__: >=,<=
__eq__: ==
还有很多, 如图:

class Student:

    def __init__(self, id, username, age):
        self.id = id
        self.username = username
        self.age = age

    def __str__(self):
        """
        不加这个就是内存地址 加了str的魔术方法 返回的就是return信息
        :return:
        """
        return f"student对象,id是:{self.id}name:{self.username}"

    def __lt__(self, other):
        """
        任意选择一个属性进行类对象进行对比(>,=,<)  不写这个比较会报错的
        :param other:
        :return:
        """
        return self.age < other.age

    def __le__(self, other):
        """
        >=,<=
        :param other:
        :return:
        """
        return self.age <= other.age

    def __eq__(self, other):
        """
        不写比较的是地址
        :param other:
        :return:
        """
        return self.age == other.age

案例使用测试

# 区别对比
# 不加__str__()方法 <__main__.Student object at 0x0000021E508FFFD0>
# 加__str__()方法 student对象,id是:1name:张三
stu = Student(1, "张三", 20)
print(stu)
print(str(stu))

# __lt__()
stu1 = Student(2, "李四", 25)
print(stu > stu1)  # False

# le
stu2 = Student(3, "王五", 25)
print(stu1 <= stu2)  # True

# eq
print(stu1 == stu2)  # True

2.2 面向对象思想核心

java/python都是 封装继承 多态三大基本特性
有的会说四大特性: 抽象 abstract

2.2.1 面向对象_私有成员

java的private
__修饰
私有属性和方法
建立成员方法对外暴露
对象使用可使用成员方法

• 定义一个类 内含私有成员变量和私有成员方法

class Phone:
    __current_voltage = 0  # 当前手机的运行电压

    def __keep_single_core(self):
        print("进入超级省电模式")

    def call_by_5g(self):
        if self.__current_voltage >= 1:
            print("功能正常使用!")
        else:
            self.__keep_single_core()
            print("电量过低, 不可使用此功能")

案例使用测试
phone = Phone()
phone.call_by_5g() 运行正常
ps: 特别注意:
直接使用private方法, 会报错
phone.__keep_single_core()
报错信息: # AttributeError: ‘Phone’ object has no attribute ‘__keep_single_core’. Did you mean: ‘_Phone__keep_single_core’ ?

2.2.2 复写

父类成员属性的重新赋值 叫属性复写
父类成员方法的重新定义 叫方法复写

class BasePhone:
    IMEI = None  # 序列号
    producer = 'ANDROD'  # 品牌

    def call_by_4g(self):
        print("手机4g基础功能开启!")


class UpPhone(BasePhone):
    IMEI = "aaabbbccc123456"  # 序列号
    face_id = "123456"
    producer = 'UPONE'  # 品牌

    def call_by_4g(self):
        print("手机4g暂停维护!")
    
    def call_by_5g(self):
        print("手机开启5g功能, 对应功耗增加")

2.2.3 继承

配合2.1.2使用
java是单继承(extend)多实现(implement)
python既可以单继承 也可以 多继承

• 关键字pass 没有特殊意义 占位(防止语法错误)
• 直接看代码吧

class BasePhone:
    IMEI = None  # 序列号
    producer = 'ANDROD'  # 品牌

    def call_by_4g(self):
        print("手机4g基础功能开启!")


class UpPhone(BasePhone):
    face_id = "123456"
    producer = 'UPONE'  # 品牌

    def call_by_4g(self):
        print(f"{self.producer}手机4g暂停维护!")

    def call_by_5g(self):
        print(f"手机基础系统:{super().producer}")
        super().call_by_4g()
        print("手机开启5g功能, 对应功耗增加")


class NFCReader:
    nfc_type = "门禁"

    def open_by_nfc(self):
        print(f"nfc功能启动, 类型:{self.nfc_type}")


class RemoteControl:
    rc_type = "红外遥控"

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


class MyPhone(UpPhone, NFCReader, RemoteControl):
    IMEI = "123456"

    def call_by_4g(self):
        UpPhone.call_by_5g(self)
        print(f"UpPhone的4g最新公告来袭~~~")
        print(f"{UpPhone.producer}手机通信重新升级, 4g+模式, 快人一步")

    pass  # 补全功能 不报语法错误

案例使用测试

• 测试继承和复写

phone = MyPhone()
print(phone.producer)
print(phone.IMEI)
phone.call_by_4g()
phone.call_by_5g()
phone.open_by_nfc()
phone.start_rc_control()

• 复写并要查找父类功能
  phone = MyPhone()
  phone.call_by_4g()

2.2.4 多态

多态解释:

• 同一个行为可以有多个不同表现形式的能力

抽象类: 含有抽象方法的类
抽象方法: 方法体是空实现的(pass) 称之为抽象方法
抽象类建成后 里面装满要求
子类继承后根据要求自己完善功能
传入不同对象执行不同结果

[理解: 跟一个使用规范差不多, 必须实现的功能说明, 具体怎么实现不管, 类似甲方]

# 同一行为 不同对象使用 获得不同装填  学校都有这些行为
class AbstractSchool01:

    def class_begin(self):
        print("-> 上课 <-")

    pass

    def class_over(self):
        print("-> 下课 <-")
        pass

    def after_school(self):
        print("-> 放学 <-")


# A学校复写功能
class ASchool(AbstractSchool01):
    def class_begin(self):
        print("-> A学校-上课 <-")

    pass

    def class_over(self):
        print("-> A学校-下课 <-")
        pass

    def after_school(self):
        print("-> A学校-放学 <-")


# B学校复写功能
class BSchool(AbstractSchool01):
    def class_begin(self):
        print("-> B学校-上课 <-")

    pass

    def class_over(self):
        print("-> B学校-下课 <-")
        pass

    def after_school(self):
        print("-> B学校-放学 <-")


def choose_school(school: AbstractSchool01):
    school.class_begin()
    school.class_over()
    school.after_school()

choose_school(ASchool())
choose_school(BSchool())

2.3 python变量的类型注解

2.3.1

2.3.2

3. 基础语法总结案例

3.1 用面向对象思想 设计一个闹钟

包含价格, 主键id和功能

3.1.1 创建闹钟的实体类对象

一般与数据库字段对应

class Clock:
    id = None
    price = None

    def ring(self):
        import winsound
        winsound.Beep(366, 500)
        winsound.Beep(500, 150)
        winsound.Beep(800, 100)
        winsound.Beep(400, 160)
        winsound.Beep(600, 100)

        winsound.Beep(600, 100)
        winsound.Beep(400, 160)
        winsound.Beep(700, 150)
        winsound.Beep(200, 100)
        winsound.Beep(366, 500)

3.1.2 创建 赋值并使用闹钟功能

clock = Clock()
clock.id = 1
clock.price = 20
print(f"闹钟id:{clock.id}, 价格是:{clock.price}, 响~~~")
clock.ring()

clock1 = Clock()
clock1.id = 1
clock1.price = 20
print(f"闹钟id:{clock.id}, 价格是:{clock.price}, 响~~~")
clock1.ring()

3.2

3.2.1

3.2.2

4. 文章的总结与预告

4.1 本文总结

4.2 下文预告

---

作者pingzhuyan 感谢观看