026.Python面向对象_类&属性

已于 2023-12-16 23:05:11 修改
阅读量124 收藏
点赞数
分类专栏： Python零基础入门 文章标签： python 面向对象 python教程 python3 Python GUI PyQt5
于 2023-09-26 14:57:10 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_50296259/article/details/133272245
版权

无奋斗不青春

我 的 个 人 主 页：👉👉 失心疯的个人主页 👈👈
入 门 教 程 推 荐 ：👉👉 Python零基础入门教程合集 👈👈
虚 拟 环 境 搭 建 ：👉👉 Python项目虚拟环境(超详细讲解) 👈👈
PyQt5 系 列 教 程：👉👉 Python GUI(PyQt5)文章合集 👈👈
Oracle数据库教程：👉👉 Oracle数据库文章合集 👈👈
优 质 资 源 下 载 ：👉👉 资源下载合集 👈👈

分隔线

Python面向对象_类&属性

类的基本理论

什么是类

  • 某一个具体对象特征的抽象
  • 例如：

    • 一个具体的对象在这里插入图片描述

    • 根据这个具体对象抽象出来的类（抽象类），其属性和行为是没有具体的值在这里插入图片描述

类的作用

  • 作用
    • 根据抽象的类，生产具体的对象（属性和行为有具体的值），这些具体对象的属性值和行为值都有各自的特点

类的组成

  • 组成
    • 名称
    • 属性
    • 方法
    • 注意：以上属性和方法，都是抽象的概念，没有具体值。在产生对象之后，对象才用友具体的属性值和方法实现

列举生活中的类

  • 示例
    # 类：钱
# 对象：1元的，5元的，10元的....

# 类：熊类
# 对象：熊大、熊二....

# 类：汽车类
# 对象：比亚迪、奥迪、大众....

对象和类的关系

  • 对象和类的关系
    • 对象 — 抽象 —> 类：通过对象的具体属性、行为抽象出来一个类
    • 类 — 实例化 —> 对象：通过类实例化出来多个具体对象，这些对象具有相同的属性和行为(方法)

面向对象在Python中的实践

  • 经典类
  • 新式类

定义经典类

  • 语法
    class ClassName:
    # 类执行体
    pass

根据类创建对象

  • 语法
    # 根据类创建对象，并赋值给变量

cl = ClassName()

创建对象时底层运作图

  • 示例代码
    class Money:
    pass


one = Money()

print(Money)                    # <class '__main__.Money'>
print(Money.__name__)           # 获取类名：Money

# Money = 666                     # Money 能被赋值，说明Money也是一个变量
# print(Money)                    # 666

print(one)                      # <__main__.Money object at 0x0000018FAAB6E640>
print(one.__class__)            # <class '__main__.Money'>

two = Money                     # 将 Money 类赋值给变量 two
print(two)                      # <class '__main__.Money'>
print(two.__name__)             # 获取类名：Money
  • 图解在这里插入图片描述

属性相关

属性和变量的区别及判断

  • 概念层面
    • 变量：是可以改变的量值（num = 5, num = 6)
    • 属性：是属于某个对象的特性（one.__class__）
  • 访问权限
    • 变量：根据不同的位置，存在不同额访问权限（全局变量、局部变量、…）
    • 属性：只能通过对象来进行访问，必须先找到对象
      对象也是通过变量名来引用，所以对象也有对应的访问权限<全局、局部>
  • 判断依据
    • 是否存在宿主（变量没有宿主，属性有宿主）
  • 根据宿主的不同，属性分为两种：类属性 和 对象属性

对象属性

增加属性

  • 方式1：通过对象动态添加

    对象.属性 = 值

  • 方式2：通过类的初始化方法（构造方法）：__init__

    class ClassName:
    def __init__():
        属性1 = 值1
        属性2 = 值2

  • 区别

    • 通过对象动态添加的属性，仅仅只是当前对象都有这些属性
    • 通过类的初始化方法添加的属性，通过类创建的所有对象都有这些属性

  • 示例1

    # 1. 定义一个类
class Person:
    pass


# 2. 根据类，实例化一个对象
zs = Person()
zl = Person()

# 3. 给zs对象增加一些属性
zs.name = '张三'
zs.age = 36

# 4. 验证属性是否添加成功
print(zs.name)              # 张三
print(zs.age)               # 36
# 查看对象的所有属性
print(zs.__dict__)          # {'name': '张三', 'age': 36}

# print(zl.name)              # AttributeError: 'Person' object has no attribute 'name'
# print(zl.age)               # AttributeError: 'Person' object has no attribute 'age'
print(zl.__dict__)          # {}

  • 图解在这里插入图片描述

  • 示例2

    # 1. 定义一个类
class Person:
    # 2. 通过__init__方法添加属性
    def __init__(self):
        self.age = 38
        self.height = 140


# 3. 根据类，实例化一个对象
ls = Person()
ww = Person()

# 4. 验证属性是否添加成功
print(ls.age)               # 38
print(ls.height)            # 140
print(ls.__dict__)          # {'age': 38, 'height': 140}

print(ww.age)               # 38
print(ww.height)            # 140
print(ww.__dict__)          # {'age': 38, 'height': 140}

  • 图解在这里插入图片描述

查询属性
  • 查询单个属性
    对象.属性
  • 查询所有属性
    对象.__dict__
  • 示例
    # 定义一个类
class Person:
    pass


# 根据类，实例化一个对象
zs = Person()
zl = Person()

# 给zs对象增加一些属性
zs.name = '张三'
zs.age = 36

# 1. 查询单个属性
print(zs.name)              # 张三
print(zs.age)               # 36

# 2. 查看对象的所有属性
print(zs.__dict__)          # {'name': '张三', 'age': 36}
  • 访问一个属性经历的步骤
    1. 通过变量zs存储的唯一标识，找到对应的对象
2. 再根据对象的属性name/age存储的唯一标识，找到对应的值
修改属性
  • 修改属性的时候，内部会进行判断，如果属性存在，则修改；如果属性不存在，则新增
  • 对象属性直接修改
    对象.属性 = 新值
    注意：当属性的值是可变类型时
    对象.属性 = 新的可变类型 ---> 属性会重新指向另一个内存
    对象.属性.append(新值) ---> 属性不会重新指向另一个内存，而是在原内存内追加一个新值
  • 示例
    # 1. 定义一个类
class Person:
    pass


# 2. 根据类，实例化一个对象
zs = Person()

# 3. 给zs对象增加一些属性
zs.name = '张三'
print(zs.name, id(zs.name))              # 张三 2036918235664

zs.name = '曾帅'
print(zs.name, id(zs.name))              # 曾帅 2036918235856

# 属性值是可变类型
zs.pets = ['小花', '小黄']
print(zs.pets, id(zs.pets))              # ['小花', '小黄'] 2006228365440

# 通过获取对象追加新值的方式，属性不会指向新的内存
zs.pets.append('小黑')
print(zs.pets, id(zs.pets))              # ['小花', '小黄', '小黑'] 2006228365440

# 通过属性赋值一个新的可变类型值，属性会重新指向一个新的内存
zs.pets = ['来福', '旺仔']
print(zs.pets, id(zs.pets))              # ['来福', '旺仔'] 1870377827584
删除属性
  • 通过del语句删除
    # 1. 定义一个类
class Person:
    pass


# 2. 根据类，实例化一个对象
zs = Person()

# 3. 给zs对象增加一些属性
zs.name = '张三'
print(zs.name, id(zs.name))              # 张三 2036918235664

# 通过del语句删除对象属性
del zs.name                              # 删除对象的属性

# 属性被删除之后，再次访问会报错
print(zs.name, id(zs.name))              # AttributeError: 'Person' object has no attribute 'name'
  • 执行步骤
    • 1、del zs.name 删除zs对象的name属性
    • 2、zs对象的name属性被删除，属性指向值的链接也被断开
    • 3、如果这个值没有被其他变量引用，那么Python会自动回收这个值的内存
  • 注意事项
    • 不同对象直接不能互相访问对方的属性
  • 示例
    # 1. 定义一个类
class Person:
    pass


# 2. 根据类，实例化一个对象
zs = Person()
ls = Person()

# 3. 给zs对象增加一些属性
zs.name = '张三'

ls.age = 30

# print(zs.name, id(zs.name))              # 张三 2036918235664

# 不同对象之间不能互相访问对方的属性
# print(zs.age, id(zs.age))                # AttributeError: 'Person' object has no attribute 'age'


print(ls.age, id(ls.age))                  # 30 2224037194960

# 不同对象之间不能互相访问对方的属性
print(ls.name, id(ls.name))                # AttributeError: 'Person' object has no attribute 'name'

类属性

  • 在Python中，万物皆对象，所以从本质上来说，类也是对象
增加属性
  • 方式1：通过对象属性赋值方式
    类名.属性 = 值
  • 方式2：在类内部添加变量赋值方式（常用方式）
    class ClassName:
    变量1 = 值1
    变量2 = 值2
  • 示例1
    class Person:
    pass


p = Person()

Person.age = 100
Person.height = 160

print(Person.age)               # 100
print(Person.height)            # 160
print(Person.__dict__)          # {'__module__': '__main__',..., 'age': 100, 'height': 160}
print()

print(p.age)                    # 100
print(p.height)                 # 160
print(p.__dict__)               # {}
  • 示例2
    class Person:
    age = 100
    height = 160


p = Person()

print(Person.age)               # 100
print(Person.height)            # 160
print(Person.__dict__)          # {'__module__': '__main__', 'age': 100, 'height': 160, ......}
print()

print(p.age)                    # 100
print(p.height)                 # 160
print(p.__dict__)               # {}
查询属性
  • 方式1：通过类名查询单个属性
    类名.属性
  • 方式2：查询所有属性
    类名.__dict__
  • 方式3：通过实例化的对象查询属性
    对象.属性

# 注意：对象的属性查找机制
# 优先到对象自身去查找属性，找到则结束
# 没有找到，则根据__class__找到对象对应的类，然后到这个类里面查找属性
修改属性
  • 修改属性的时候，内部会进行判断，如果属性存在，则修改；如果属性不存在，则新增
  • 方式1：通过类名进行修改
    类名.属性 = 新值
  • 注意：属性的修改不能通过 对象.属性 = 新值 的方式进行修改
  • 原因：对象属性的修改规则，内部会判断，对象本身没有这个属性，则会给这个对象新增一个属性
  • 示例
    class Person:
    age = 100
    height = 160


p = Person()

print(Person.age)               # 100
print(Person.height)            # 160
print(Person.__dict__)          # {'__module__': '__main__', 'age': 100, 'height': 160, ...}

print(p.age)                    # 100
print(p.height)                 # 160
print(p.__dict__)               # {}

Person.age = 200                # 通过 类名.属性 = 新值 直接修改属性值
p.height = 260                  # 不能通过 对象.属性 = 新值 修改类属性，因为对象没有这个属性，会直接给对象新增属性

print(Person.age)               # 200
print(Person.height)            # 160
print(Person.__dict__)          # {'__module__': '__main__', 'age': 200, 'height': 160, ...}

print(p.age)                    # 200
print(p.height)                 # 260
print(p.__dict__)               # {'height': 260}
删除属性
  • 通过 del 语句删除属性
    del 类名.属性
  • 注意：
    • 1、不能通过 del 对象.属性 的方式删除类属性
    • 2、del 语句只能删除直系属性，不能通过类删除对象的属性
属性的内存存储

  • 对象属性

  • 对象属性是存放在对象的 __dict__ 属性中，也可以通过 __dict__ 属性来进行新增和修改（一般不这么操作）

  • 但是，有些内置对象没有 __dict__ 属性

    class Person:
    pass


zs = Person()

zs.name = '张三'
zs.age = 36

print(zs.__dict__)          # {'name': '张三', 'age': 36}

  • 图解在这里插入图片描述

  • 那么，我们就可以通过__dict__这个属性来对对象的属性来进行新增和修改（一般不会这么操作）

    class Person:
    pass


zs = Person()

zs.__dict__ = {"name": "张三", "age": 30}

print(zs.name)              # 张三
print(zs.age)               # 30

  • 类属性

  • 类对象的属性也是存放在 __dict__ 属性中，但是类对象的 __dict__属性默认无法修改，需要通过 set、attr 方法修改

    class Person:
    name = '张三'
    age = 36


zs = Person()

print(Person.__dict__)          # {'__module__': '__main__', 'name': '张三', 'age': 36, ......}

  • 图解在这里插入图片描述

  • 但是，类对象的 __dict__属性默认不允许被修改

    class Person:
    name = '张三'
    age = 36


zs = Person()

# 类对象的 __dict__属性默认不允许修改，会报错
# Person.__dict__['name'] = '李四'      # TypeError: 'mappingproxy' object does not support item assignment
# Person.__dict__['sex'] = '男'         # TypeError: 'mappingproxy' object does not support item assignment
类属性被各个对象共享
  • 类属性能被通过当前类创建的所有对象共同访问
  • 修改类属性的值之后，所有对象的当前属性的值都会发生改变
类属性与对象属性之间的区别联系
  • 新增方式
    # 类属性
    # 方式1
        类名.属性 = 值
    # 方式2
        class ClassName:
            属性1 = 值1
            属性2 = 值2
            
# 对象属性
    # 方式1
        对象.属性 = 值
    # 方式2
        class ClassName:
            def __init__(self):
                self.属性1 = 值1
                self.属性2 = 值2
    # 方式3
        对象.__dict__[属性] = 值
        
        对象.__dict__ = {'属性1': 值1, '属性2': 值2}
  • 查询方式
    # 类属性
    # 方式1：查询单个属性
        类名.属性
        对象.属性
    # 方式2：查询所有属性
        类名.__dict__


# 对象属性
    # 方式1：查询单个属性
        对象.属性
    # 方式2：查询所有属性
        对象.__dict__
  • 修改方式
    # 类属性
    # 方式1
        类名.属性 =  新值

# 对象属性
    # 方式1
        对象.属性 = 新值
    # 方式2
        对象.__dict__[属性] = 新值
  • 删除方式
    # 类属性
    del 类名.属性
    
# 对象属性
    del 对象.属性

限制对象属性的添加：__slots__

  • 在其他语言中，在创建类的时候，就确定了对象的属性，所有通过类创建的对象，属性都一致
  • 在Python中，对象可以随意添加和删除属性，这样就导致通过同一个对象创建出来的多个对象，每一个对象都可能有不同的属性
  • 通过类的 __slots__ 属性可以限定对象允许添加的属性
  • 语法
    class Person:
    __slots__ = ['属性1', '属性2']
  • 示例1：未限定前
    class Person:
    pass


p1 = Person()
p1.age = 30
p1.name = '张三'

p2 = Person()
p2.height = 160
p2.weight = 63

print(p1.age)           # 30
print(p1.name)          # 张三
print(p2.height)        # 160
print(p2.weight)        # 63
    • 没有限制前，可以通过对象随意添加属性，导致多个对象间属性不一致
  • 示例2：限定后
    class Person:
    __slots__ = ['name', 'age']
    pass


p1 = Person()
p1.age = 30
p1.name = '张三'

p2 = Person()
# 添加的属性不在类的__slots__属性限定范围内，会报错
# p2.height = 160         # AttributeError: 'Person' object has no attribute 'height'
# p2.weight = 63          # AttributeError: 'Person' object has no attribute 'weight'

p2.name = '李四'
p2.age = 28

print(p1.age)           # 30
print(p1.name)          # 张三

print(p2.age)           # 李四
print(p2.name)          # 28
    • 限定之后，所有对象均只能添加类的 __slots__ 属性中限定的属性
失心疯_2023
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 打赏
    打赏
  • 0
    评论
专栏目录
python3 面向对象__类的内置属性与方法的实例代码
09-19
通过理解这些内置属性和方法，你可以更好地掌握Python类的工作原理，从而编写出更加灵活和高效的面向对象代码。在实际应用中，根据需求自定义这些方法可以帮助实现特定的行为，比如自定义比较规则、序列化逻辑或者...
面向对象编程基础_python面向对象_python教程_
09-29
以上就是Python面向对象编程的基本概念和特性。掌握这些基础知识，能帮助你更好地理解和编写Python程序，尤其在处理复杂逻辑和大型项目时，面向对象编程的优势会更加明显。在实际应用中，不断实践和探索，才能真正...
Python面向对象之类的内置attr属性示例
09-19
在Python的面向对象编程中，类的属性是其核心组成部分，它们定义了对象的状态和行为。内置的`attr`属性，即`__getattr__`, `__setattr__` 和 `__delattr__`，是Python中处理类属性访问的特殊方法，它们提供了自定义...
python面向对象之类属性和类方法案例分析
09-18
本篇文章将深入探讨Python面向对象中的类属性和类方法，并通过案例进行详细分析。 1. 类属性和实例属性 类属性是直接在类定义中创建的属性，它们与类相关联而不是特定的实例。类属性通常用于存储与类整体相关的...
随机数种子的作用
帆的博客
07-23 807
设置随机数种子（random seed）的目的是为了确保随机数生成器在每次运行时产生相同的随机数序列，从而保证实验结果的一致性。随机数种子通过初始化随机数生成器的内部状态，使得在相同的种子值下，随机数生成器每次调用时生成的序列是相同的。
Java-Lambda
lizhiwei21的博客
07-21 460
lambda表达式可以理解为对匿名内部类的一种简化 , 但是本质是有区别的面向对象思想 :强调的是用对象去完成某些功能函数式编程思想 :强调的是结果 , 而不是怎么去做。
使用9种方法隐藏和显示元素
lulei5153的博客
07-21 186
【代码】使用9种方法隐藏和显示元素。
提取autocad2024图形中图块的属性的代码-统计选中图块长度属性的总长度
VB973490770的专栏
07-24 101
阀门位号：XV-123。
【Python数据增强】图像数据集扩充
最新发布
阿齐Archie
07-25 491
该脚本用于图像数据增强，特别是目标检测任务中的图像和标签数据增强。通过应用一系列数据增强技术（如旋转、平移、裁剪、加噪声、改变亮度、cutout、翻转等），生成多样化的图像数据集，以提高目标检测模型的鲁棒性和准确性。
python获取剪切板内容
cuisidong1997的博客
07-21 250
python获取剪切板内容在Python中，可以使用第三方库clipboard获取剪切板的内容。以下是两种不同的实现方法：方法一：使用clipboard库。
Python编程防止计算机休眠，保持唤醒状态
anyes的博客
07-21 196
该库提供了一个名为 moveTo() 的函数，可以移动鼠标指针，防止计算机进入睡眠状态或锁定屏幕。为了使计算机保持唤醒状态，不自动进入睡眠模式，可以使用 mouse 库，该库提供了一个名为 move() 的函数，可以移动鼠标指针，通过不断将鼠标指针移动到屏幕上的不同位置，防止计算机进入睡眠状态或锁定屏幕。使用 mouse 的 move() 函数，每隔 5 秒，将鼠标指针移动到屏幕上的指定位置。如果临时需要保持计算机的唤醒状态，可以使用 python 编写程序，保持计算机的唤醒状态。
numpy矩阵相关操作
2301_79810514的博客
07-23 308
​ 所谓的广播机制就是当2个不同维度的数组进行加减的时候，将把维度小的数组自动填充数组变成维度大且维度数组相同的数组，然后再进行计算，在填充过程中会有已有数据进行填充。n1.sort()，这个时候n1就是已经排好序的数组，可以直接使用。np.sort(n1) 如果要使用，就需要用一个变量接住。2）两个数组的操作(每个数组中对应的元素做操作)不改变原数组的排序，会占用额外的内存空间。3）线性代数中的矩阵操作。1）单个数组元素的操作。直接改变数组元素的排序。
爬虫基本原理入门
RHeng的博客
07-25 614
爬虫（Web Crawler），又称为网络爬虫或网页蜘蛛，是一种按照一定的规则，自动地抓取万维网信息的程序或者脚本。它们可以模拟浏览器行为，遍历网页并抓取网页中的信息，如文本、图片、链接等。接下来，我们会尝试使用Python等编程语言，结合相关库和工具，动手编写自己的爬虫程序，探索更多关于爬虫技术的奥秘。
牛客周赛 Round 52 解题报告 | 珂学家
m0_66102593的博客
07-22 1031
好难的场, 从第二题开始，就感觉画风不对
python解析pdf文件
irisMoon06的博客
07-21 438
先安装PyPDF2，据说这是目前最好的解析pdf的包。
sklearn基础学习
招风的黑耳CSDN
07-23 680
sklearn，或者更正式地称为scikit-learn，是一个基于Python的开源机器学习库。它建立在NumPy、SciPy和matplotlib之上，提供了简单而有效的工具用于数据挖掘和数据分析。sklearn支持监督学习和无监督学习算法，包括分类、回归、聚类和降维等。
SSTI模板注入
google20的博客
07-21 897
SSTI模板注入
Mojo编程语言
七夜的博客
07-22 345
Mojo编程语言凭借其高性能、易用性和强大的生态系统兼容性，已经成为AI开发者的新宠儿。它不仅能够提高开发效率，还能充分利用AI硬件的潜力，推动AI技术的发展。对于需要高性能计算、并行处理和硬件加速的应用场景，Mojo是一个值得考虑的选择。
26、灵活生成月时间序列：基于Pandas的generate_dates函数详解
小兔子乖乖
07-21 24
在数据分析和时间序列处理中，生成特定时间范围的日期序列是一项基础且重要的任务。无论是进行历史数据分析、预测模型构建还是时间序列可视化，都需要一个准确且灵活的日期生成工具。本文介绍的generate_dates函数，正是为了满足这一需求而设计的。generate_dates函数利用Python的Pandas库，提供了一个简洁而强大的接口，用于生成指定年份和月份的月时间序列。用户可以通过简单的参数设置，灵活地控制日期序列的生成方式，无论是需要同一年份内的月份序列，还是跨年份的月份序列，该函数都能轻松应对。
Python面向对象编程详解
Python程序设计语言深入探讨面向对象程序设计的概念，这一主题由张晓教授于2009年在西北工业大学计算机学院讲解。面向对象编程（Object-Oriented Programming，简称OOP）是一种编程范式，它将数据和操作数据的函数...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包

打赏作者

失心疯_2023

你的鼓励将是我创作的最大动力

¥1 ¥2 ¥4 ¥6 ¥10 ¥20
扫码支付：¥1
获取中
扫码支付

您的余额不足，请更换扫码支付或充值

打赏作者

实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

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

余额充值