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

全文目录,一步到位

1.前言简介
- [1.1 专栏传送门](#1.1 专栏传送门)
- - [1.1.1 上文小总结](#1.1.1 上文小总结)
  - [1.1.2 上文传送门](#1.1.2 上文传送门)
[2. python基础使用](#2. python基础使用)
- [2.1 面向对象的基础使用](#2.1 面向对象的基础使用)
- - [2.1.1 创建类](#2.1.1 创建类)
  - [2.1.2 使用对象(定义`成员变量`)](#2.1.2 使用对象(定义成员变量))
  - [2.1.3 `成员方法`的定义与使用](#2.1.3 成员方法的定义与使用)
  - [2.1.4 `构造方法`的使用](#2.1.4 构造方法的使用)
  - [2.1.5 常用魔术方法](#2.1.5 常用魔术方法)
- [2.2 面向对象思想核心](#2.2 面向对象思想核心)
- - [2.2.1 面向对象_私有成员](#2.2.1 面向对象_私有成员)
  - [2.2.2 复写](#2.2.2 复写)
  - [2.2.3 继承](#2.2.3 继承)
  - [2.2.4 多态](#2.2.4 多态)
- [2.3 python变量的类型注解](#2.3 python变量的类型注解)
- - 2.3.1
  - 2.3.2
[3. 基础语法总结案例](#3. 基础语法总结案例)
- [3.1 用面向对象思想设计一个闹钟](#3.1 用面向对象思想设计一个闹钟)
- - [3.1.1 创建闹钟的实体类对象](#3.1.1 创建闹钟的实体类对象)
  - [3.1.2 创建赋值并使用闹钟功能](#3.1.2 创建赋值并使用闹钟功能)
- 3.2
- - 3.2.1
  - 3.2.2
[4. 文章的总结与预告](#4. 文章的总结与预告)
- [4.1 本文总结](#4.1 本文总结)
- [4.2 下文预告](#4.2 下文预告)

1.前言简介

1.1 专栏传送门

1.1.1 上文小总结

1.1.2 上文传送门

2. python基础使用

2.1 面向对象的基础使用

2.1.1 创建类

class关键字修饰

类名首字母大写

属性名 = None

python 复制代码

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

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

student = Student()即可 java是new对象初始化

属性赋值是对象.属性 =

python 复制代码

# 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一样指代当前对象

python 复制代码

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}")

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

python 复制代码

# 使用对象
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不可以的呦~~

python 复制代码

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("构造方法执行成功")

案例使用测试

python 复制代码

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__: ==

还有很多, 如图:

python 复制代码

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

案例使用测试

python 复制代码

# 区别对比
# 不加__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
__修饰

私有属性和方法

建立成员方法对外暴露

对象使用可使用成员方法

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

python 复制代码

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 复写

父类成员属性的重新赋值叫属性复写

父类成员方法的重新定义叫方法复写

python 复制代码

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 没有特殊意义占位(防止语法错误)

直接看代码吧

python 复制代码

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  # 补全功能 不报语法错误

案例使用测试

测试继承和复写
python 复制代码
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) 称之为抽象方法

抽象类建成后里面装满要求

子类继承后根据要求自己完善功能

传入不同对象执行不同结果

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

python 复制代码

# 同一行为 不同对象使用 获得不同装填  学校都有这些行为
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()

python 复制代码

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

2.3 python变量的类型注解

2.3.1

python 复制代码

2.3.2

3. 基础语法总结案例

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

包含价格, 主键id和功能

3.1.1 创建闹钟的实体类对象

一般与数据库字段对应

python 复制代码

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 创建赋值并使用闹钟功能

python 复制代码

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

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

全文目录,一步到位

1.前言简介

1.1 专栏传送门

1.1.1 上文小总结

1.1.2 上文传送门

2. python基础使用

2.1 面向对象的基础使用

2.1.1 创建类

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

2.1.3 成员方法的定义与使用

2.1.4 构造方法的使用

2.1.5 常用魔术方法

2.2 面向对象思想核心

2.2.1 面向对象_私有成员

2.2.2 复写

2.2.3 继承

2.2.4 多态

2.3 python变量的类型注解

2.3.1

2.3.2

3. 基础语法总结案例

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

3.1.1 创建闹钟的实体类对象

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

3.2

3.2.1

3.2.2

4. 文章的总结与预告

4.1 本文总结

4.2 下文预告

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

2.1.3 `成员方法`的定义与使用

2.1.4 `构造方法`的使用

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

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