Python面向对象笔记

最新推荐文章于 2023-10-16 16:00:00 发布
最新推荐文章于 2023-10-16 16:00:00 发布
阅读量104 收藏 2
点赞数
文章标签： python 笔记 pycharm
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_55266011/article/details/132101464
版权

一、初始对象

使用对象组织数据

  1. 在程序中设计表格，我们称之为：设计类(class)

    class Student
	name = None   # 记录学生姓名

  2. 在程序中打印生产表格，我们称之为：创建对象

    # 基于类创建对象
stu_1 = Student()
stu_2 = Student()

  3. 在程序中填写表格，我们称之为：对象属性赋值

    stu_1.name = "张三"	# 为学生1对象赋予名称属性值
stu_2.name = "李四"	# 为学生1对象赋予名称属性值

二、成员方法

1.类的定义和使用

class 类名称:		# class是关键字，表示要定义类了
    类的属性		# 类的属性，即定义在类中的变量（成员变量）
    类的行为		# 类的行为，即定义在类中的函数（成员方法）
创建类对象的语法：对象 = 类名称()

2.成员变量和成员方法

class Student:
    name = None
    age = None

    def say_hi(self):
        print(f"Hi大家好，我是{self.name}")


stu = Student()
stu.say_hi() # 输出：Hi大家好，我是None

定义在类内部的函数叫方法

3.成员方法的定义语法

  • 在类中定义成员方法和定义函数基本一致，有细微之分：

    def 方法名(self, 形参1， ..., 形参n):
	方法体

    self关键字是成员方法定义的时候，必须填的

    • 他用来表示类对象自身的意思
    • 当我们使用类对象调用方法的时候，self会自动被python传入
    • 在方法内部，想要访问类的成员变量，必须使用self

4.注意事项

  • self关键字，尽管在参数列表中，但是传参的时候可以忽略它
class Student:
    name = None

    def say_hi(self):
        print(f"Hi大家好，我是{self.name}")

    def say_hi2(self, msg):
        print(f"很高兴认识大家，{msg}")


stu = Student()
stu.say_hi()
stu.say_hi2("很高兴认识大家")

三、类和对象

1.类和对象

  • 基于类创建对象的语法：对象名 = 类名称()

    class Clock:
    id = None
    price = None

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


clock1 = Clock()
clock1.id = "003"
clock1.price = 19.9
print(f"闹钟ID:{clock1.id},价格：{clock1.price}")
clock1.ring()

clock2 = Clock()
clock2.id = "004"
clock2.price = 29.9
print(f"闹钟ID:{clock2.id},价格：{clock2.price}")
clock2.ring()

四、构造方法

1. 属性（成员变量）的赋值

  • class Student:
    name = None
    age = None
	tel = None

student1 = Student()
student1.name = "张三"
student1.age = 20
student1.tel = "15547896547"

student2 = Student()
student2.name = "admin"
student2.age = 29
student2.tel = "15337896547"

2. 构造方法

python类可以使用：_ _ init _ _()方法，称之为构造方法

可以实现：

  • 在创建类对象（构造类）的时候，会自动执行
  • 在创建类对象（构造类）的时候，将传入参数自动传递给_ _init _ _()方法使用
class Student:
    # name = None
    # age = None
    # tel = None

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


student1 = Student("张三", 18, "15547852536")

3.构造方法注意事项

  • init前后都有两个下划线_ _init _ _

  • 构造方法也是成员方法，参数列表中也有：self

  • 在构造方法内定义成员变量，需要使用self关键字

    变量是定义在构造方法内部，如果要成为成员变量，需要用self来表示

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

五、其他内置方法

魔术方法：内置的类方法，各有各自特殊的功能，这些内置方法称为魔术方法

1._ _ str _ _字符串方法

class Student:
    def __init__(self, name, age):
        self.name = name
        self.age = age

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


stu = Student("admin", 30)
print(stu)          # 输出：Student类对象，name:admin, age:30
print(str(stu))     # 输出：Student类对象，name:admin, age:30

2._ _ lt _ _小于符号比较方法

class Student:
    def __init__(self, name, age):
        self.name = name
        self.age = age

    def __lt__(self, other):
        return self.age < other.age


stu1 = Student("admin", 30)
stu2 = Student("root", 20)
print(stu1 < stu2)  # 输出：False
print(stu1 > stu2)  # 输出：True

3._ _ le _ _小于等于比较符号方法

class Student:
    def __init__(self, name, age):
        self.name = name
        self.age = age

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


stu1 = Student("admin", 30)
stu2 = Student("root", 20)

print(stu1 <= stu2)     # 输出：False
print(stu1 >= stu2)     # 输出：True

4._ _ eq _ _ ,比较运算符实现方法

class Student:
    def __init__(self, name, age):
        self.name = name
        self.age = age

    def __eq__(self, other):
        return self.age == other.age


stu1 = Student("admin", 30)
stu2 = Student("root", 30)

print(stu1 == stu2)     # 输出：True

六、封装

1. 面向对象的三大特性

基于模板（类）去创建实体（对象），使用对象完成功能开发

  1. 封装
  2. 继承
  3. 多态

2. 封装

封装就是将现实世界事物的属性和方法，封装到类中，描述为成员变量和成员方法，从而完成程序对现实事物的描述

私有成员

  • 私有成员变量

    变量名以_ _开头（两个下划线）

  • 私有成员方法

    方法名_ _开头（两个下划线）

使用私有成员

class Phone:
    __is_5g_enable = False

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

七、继承

1. 继承

# 单继承
class 类名（父类名）:
	类内容体
    
# 多继承
class 类名(父类1， 父类2， ..., 父类n):
    类内容体

  • 单继承

    class Phone:
    IMEI = None
    producer = None

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


class Phone2022(Phone):
    face_id = True

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


phone = Phone2022()
print(phone.IMEI)
phone.call_by_4g()
phone.call_by_5g()

  • 多继承

    class Phone:
    IMEI = None
    producer = None

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


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

    注意事项：

    多个父类中，如果有同名的成员，那么默认以继承顺序（从左到右）为优先级

    即：先继承的保留，后继承的被覆盖

  • pass关键字

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

2. 复写

子类继承父类的成员属性和成员方法后，如果对其“不满意”，那么可以进行复写，即：在子类中重新定义同名的属性或方法即可。

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

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


class MyPhone(Phone):
    producer = "MI"     # 复写父类的成员属性

    # 复写父类的成员方法
    def call_by_5g(self):
        print("开启5g模式")
        

phone = MyPhone()
print(phone.producer)

3. 调用父类同名成员

一旦复写父类成员，那么类对象调用成员的时候，就会调用复写后的新成员。如果需要使用被复写的父类方法，需要特殊的调用方法：

  • 方式一：调用父类成员

    使用成员变量：父类名.成员变量

    使用成员方法：父类名.成员方法(self)

  • 方式二：使用super()调用父类成员

    使用成员变量：super().成员变量

    使用成员方法：super().成员方法(self)

八、类型注解

1. 类型注解

主要功能：

  • 帮助第三方IDE工具（如pycharm）对代码进行类型推断，协助做代码提示
  • 帮助开发者自身对变量进行注释

支持：

  • 变量的类型注解
  • 函数（方法）形参列表和返回值类型注解

类型注解的语法：

  • 为变量设置类型注解（基础语法： 变量: 类型）
    # 基础数据类型注解
var_1: int = 10
var_2: float = 3.1415926
var_3: bool = True
var_4: str = "admin"


# 类对象类型注解
class Student:
    pass


stu: Student = Student()
  • 容器类型注解
    # 基础容器类型注解
my_list: list = [1, 2, 3]
my_tuple: tuple = (1, 2, 3)
my_set: set = {1, 2, 3}
my_dict: dict = {"admin": 123456}
my_str: str = "admin"
# 容器类型详细注解
my_list: List[int] = [1, 2, 3]
my_tuple: Tuple[int, str, bool] = (1, "admin", True)	# 需要将每一个元素都标记出来
my_set: Set[int] = {1, 2, 3}
my_dict: Dict[str, int] = {"admin": 123456}				# 第一个是key，第二个是value
  • 除了使用变量：类型，语法注解外，也可以在注释中进行类型注解

    语法： # type:类型

  • 注意：

    一般，无法直接看出变量类型时会添加变量的类型注解

2. 函数（方法）的类型注解

  • 形参注解

    def 函数方法名(形参名：类型， 形参名：类型，......):
    pass

# 例如：
def add(x: int, y: int):
    return x + y
add(1, 2)

  • 返回值注解

    def 函数方法名(形参名：类型， 形参名：类型，......) -> 返回值类型:
    pass

# 例如：
def func(data: list) -> list:
    return data

3. Union类型注解

  • 使用Union[类型, …, 类型]，可以定义联合类型注解

    from typing import Union, Dict

my_dict: Dict[str, Union[str, int]] = {"name": "admin", "age": 20}

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

    from typing import Union, Dict, List

my_list: List[Union[int, str]] = [1, 2, "admin", "admin"]
my_dict: Dict[str, Union[str, int]] = {"name": "admin", "age": 20}


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

九、多态

1.多态

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

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

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)

2. 抽象类（接口）

含义是：

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

抽象类：含有抽象方法的类称之为抽象类（抽象类就好比定义一个标准，包含了一些抽象的方法，要求子类必须实现）

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

class AC:
    def cool_wind(self):
        """制冷"""
        pass

    def hot_wind(self):
        """制热"""
        pass

    def swing_wind(self):
        """左右摆风"""
        pass


class Mide_AC(AC):
    def cool_wind(self):
        print("美的空调核心制冷科技")

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

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


class GREE_AC(AC):
    def cool_wind(self):
        print("格力空调变频省电制冷")

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

    def swing_wind(self):
        print("格力空调静音左右摆风")


def make_cool(ac: AC):
    ac.cool_wind()


midea_ac = Mide_AC()
gree_ac = GREE_AC()

make_cool(gree_ac)	# 格力空调变频省电制冷
make_cool(midea_ac)	# 美的空调核心制冷科技

十、综合案例

  • main.py

    """
1. 设计一个类，可以完成数据的封装
2. 设计一个抽象类，定义文件读取的相关功能，并使用子类实现具体功能
3. 读取文件，生产数据对象
4. 进行数据需求的逻辑计算（计算每一天的销售额）
5. 通过pyecharts进行图形绘制
"""
from typing import List
from file_define import FileReader, TextFileReader, JsonFileReader
from data_define import Record
from pyecharts.charts import Bar
from pyecharts.options import *
from pyecharts.globals import ThemeType

text_file_reader = TextFileReader("2011年1月销售数据.txt")
json_file_reader = JsonFileReader("2011年2月销售数据JSON.txt")

jan_data: List[Record] = text_file_reader.read_data()
feb_data: List[Record] = json_file_reader.read_data()
# 将两个月份的数据合并为一个list来存储
all_data: List[Record] = jan_data + feb_data

# 开始进行计算数据
data_dict = {}
for record in all_data:
    if record.date in data_dict.keys():
        # 当前日期有记录，可累计money
        data_dict[record.date] += record.money
    else:
        data_dict[record.date] = record.money

print(data_dict)

# 可视化图标开发
bar = Bar(init_opts=InitOpts(theme=ThemeType.LIGHT))

bar.add_xaxis(list(data_dict.keys()))
bar.add_yaxis("销售额", list(data_dict.values()), label_opts=LabelOpts(is_show=False))
bar.set_global_opts(
    title_opts=TitleOpts(title="每日销售额")
)

bar.render("每日销售额.html")

  • file_define.py

    """
和文件相关的类定义
"""
import json
from typing import List
from data_define import Record


# 先定义一个抽象类来做顶层设计，确定有哪些功能实现
class FileReader:

    def read_data(self) -> List[Record]:
        # 读取文件数据，读到的每一行数据都转换为Record对象，将他们都封装到list内返回
        pass


class TextFileReader(FileReader):

    def __init__(self, path):
        self.path = path

    # 复写（实现抽象方法）父类方法
    def read_data(self) -> List[Record]:
        f = open(self.path, "r", encoding="UTF-8")

        record_list: List[Record] = []
        for line in f.readlines():
            line = line.strip()     # 消除读取到的每一行数据中的\n
            data_list = line.split(",")
            record = Record(data_list[0], data_list[1], int(data_list[2]), data_list[3])
            record_list.append(record)

        f.close()
        return record_list


class JsonFileReader(FileReader):

    def __init__(self, path):
        self.path = path

    # 复写父类方法
    def read_data(self) -> List[Record]:
        f = open(self.path, "r", encoding="UTF-8")

        record_list: List[Record] = []
        for line in f.readlines():
            data_dict = json.loads(line)
            record = Record(data_dict["date"], data_dict["order_id"], int(data_dict["money"]), data_dict["province"])
            record_list.append(record)

        f.close()
        return record_list


if __name__ == '__main__':
    text_file_reader = TextFileReader("2011年1月销售数据.txt")
    json_file_reader = JsonFileReader("2011年2月销售数据JSON.txt")
    list1 = text_file_reader.read_data()
    list2 = json_file_reader.read_data()

    for l in list1:
        print(l)

    for l in list2:
        print(l)

  • data_define.py

    """
定义数据的类
"""


class Record:

    def __init__(self, date, order_id, money, province):
        self.date = date            # 订单日期
        self.order_id = order_id    # 订单ID
        self.money = money          # 订单金额
        self.province = province    # 销售省份

    def __str__(self):
        return f"{self.date}, {self.order_id}, {self.money}, {self.province}"
_Pomelo
关注
  • 0
    点赞
  • 踩
  • 2
    收藏
    觉得还不错? 一键收藏
  • 1
    评论
python面向对象基础知识笔记.doc
10-01
面向对象编程是Python中一种重要的编程范式，与面向过程编程相比，面向对象编程更加侧重于数据和操作数据的函数的结合，通过封装、继承和多态等特性，提高代码的可重用性和可维护性。 面向过程编程是按照业务逻辑...
python面向对象笔记
liyuYangyue的博客
04-23 122
面向对象就是将编程当成是一个事物，对外界来说，事物是直接使用的，不用管它内部的情况。python面向对象的继承指的是多个类之间的从属关系，即子类默认继承父类的所有属性和方法，具体如下。在python中，一般定义函数名get_xx来获取私有属性，定义set_xx来修改私有属性值。结论：如果子类和父类拥有同名属性和方法，子类创建对象调用属性和方法的时候，调用的是子类的。当一个类有多个父类的时候，默认使用第一个父类的同名属性和方法。九、子类调用父类的同名方法和属性。八、子类重写父类同名方法和属性。
Python中面向对象（学习笔记）
最新发布
weixin_55154866的博客
10-16 120
面向对象编程（Object Oriented Programming，OOP，面向对象程序设计）和面向过程编程，是两种不同的编程方式。 相比较函数，面向对象是更大的封装，根据职责在 一个对象中封装多个方法
python 获取对象中的属性并进行赋值操作
dandanforgetlove的专栏
06-14 547
需要保存十张不同结构表的数据，但是不想写十个实体类赋值的代码。于是乎，想着数据转成dict，然后dict转成实体类。所以主要的就是dict 转换成实体类这里。当然了，还有getattr方法。
Python面向对象详解，一文通透
XuZhiqiang的博客
02-02 385
在Python中，所有数据类型都可以视为对象，当然也可以自定义对象。自定义的对象数据类型就是面向对象中的类（Class）的概念。
python属性查找与属性赋值
usiel的博客
09-10 2371
在之前文章中写了一节同名的类和实例变量，如果存在同名的类和实例变量的话，属性查找会优先选择实例变量，而描述器会改变python默认的属性查找行为。如果一个类属性是描述器的话，使用实例调用a.attr1这种形式将只会访问类属性，而不会像之前那样访问实例变量，这是怎么回事，通过一个例子看一下： class Desc1: def __get__(self, obj, objtype=None): print('__get__ age') return self.age
Python面向对象进阶教程,Python面向对象进阶知识笔记.doc
10-01
本文将深入探讨Python面向对象编程的进阶知识，包括类方法、静态方法、`__new__`和`__init__`方法以及单例模式。 1. **类方法**： 类方法是通过装饰器`@classmethod`标识的方法，它们的第一个参数通常是`cls`，...
Python的面向对象编程方式学习笔记
09-21
面向对象编程（Object-Oriented Programming，OOP）是Python编程的核心概念之一，它基于类（Class）和对象（Object）的概念。Python中的类是对象的蓝图，它定义了对象的属性（Attributes）和行为（Methods）。让我们...
Python面向对象编程中关于类和方法的学习笔记
09-21
在Python的面向对象编程中，类（Class）和方法（Method）是构建程序结构的核心元素。面向对象编程（Object-Oriented Programming, OOP）基于类的概念，它允许我们将数据和操作数据的函数封装在一起，形成一个独立的...
面向对象语法精讲笔记.zip
05-25
学习嵩天老师课程所做的笔记。课程目标：正确理解Python面向对象编程理念与方法，掌握面向对象编程设计的具体方法。包括Python面向对象基础，Python面向对象进阶。包括了Python面向对象进阶语法全体系。
Python学习笔记(新手入门)（7）面向对象
yingyuzhai的博客
12-21 672
目录 3.8.4 析构方法 3.8.5 继承 3.8.5.1 单继承 3.8.5.2 多继承 3.8.5.3 继承的传递 3.8.6 父类方法 3.8.6.1 重写和调用父类方法 3.8.7 多态 3.8.7.1 类属性和实例属性 3.8.7.2 类方法和静态方法 3.8.4 析构方法 当整个程序脚本执行完毕后自动调用__del__方法 当对象被手动销毁时也会自动调用__del__ 析构函数一般用于资源回收，利用__del__方法销毁对象回收内存等资源
面向对象自学笔记（Python版）
Luciferzcy的博客
01-15 686
Python面向对象自学笔记笔记初始第一章——基础理论（1-5） 笔记初始 基于生疏的C++面向对象基础，为了巩固以及更好的学习了解Py，突发奇想，作此拙作。 课程来源：撩课学院 推荐该课程是因为每集时长短，符合当今快节奏的社会，在娱乐至死的大潮中，可以压缩碎片化时间，为自己的未来添砖加瓦，且附一个异常精致的思维导图——XMind（B站介绍有，在此出于版权，不便附上，但深表钦佩） 第一章——基础理论（1-5） 重点：面向过程和面向对象的区别（做饭的例子非常形象） ...
Python面向对象学习笔记【超清楚，一定可以帮助你】
qq_54634562的博客
06-05 309
基本理论 万物皆对象 对象是具体物体：拥有属性和行为 面向对象是面向过程的封装 成为包工头，进行指挥：把某些功能（属性和行为）安排给某一个对象，然后指挥对象工作。 类 组成 名称，属性，方法 作用 根据抽象的类，生产具体的对象 ......
python对象的赋值和参数传递
loglikelihood的博客
11-12 1613
python对象的可变类型和不可变类型的赋值和参数传递。
python 面向对象笔记
cainiao22222的博客
09-19 232
Python 面向对象小结，最近在学习Python，在学习到面向对象时有些记不住，特写此笔记： 1.定义类     class People:         num = 0         def SayHello(self):             print("Hello"); 2.定义对象     P = People()     p.SayHello() 3.构造函数__init__(...
python笔记(面向对象)
小小龙的博客
11-15 159
一、面向对象 1.所谓模子就是类抽象的 2.对象 = 类名() 3.过程： （1） 类名():首先会创造出一个对象，创建了一个self变量 （2） 调用init方法，类名括号里的参数会被这里接收 （3）执行init方法 （4）返回self: self就是一个能够存储很多属性的一个大字典 class Person: country = 'china' #创造了一个只要是这个...
python 面向对象学习笔记
nailwl
03-11 282
概念： 1、方法与函数的区别 2、类对象、类变量 3、实例对象、实例变量 4、装饰器 5、实例方法、类方法、静态方法及被装饰器装饰的方法 6、命名空间及作用域 7、__dict__、__init__、__self__、__main__、__name__、__call__ 8、静态方法没有和任何类或实例绑定，所以静态方法是个函数。 9、装饰器不会改变被装饰函数或方法的类型。 10...
Python中的面向对象概述笔记
いいこと？暁の磕盐线に胜利を刻みなさいっ！
06-25 299
Python中的面向对象概述笔记（1） 吾王呆毛所指 吾等心之所向 ! 1 对象——Object 对象分为两个部分——静态部分和动态部分：静态部分称为“属性” 在Python中，一切都是对象，即不仅使具体的事物称为对象，字符串，函数等也都是对象。 2 类 类是封装对象的属性和行为的载体，也就是说具有 相同属性和行为（方法） 的一类实体会被称为类。在Python中，可以定义每个对象共有的属性和...
评论 1
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值