python中的类与对象

最新推荐文章于 2024-06-12 13:15:00 发布
最新推荐文章于 2024-06-12 13:15:00 发布
阅读量1.1k 收藏 13
点赞数 32
分类专栏： python 文章标签： python
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_39743356/article/details/136885810
版权

前言

在Python中，类是一种用于创建新类型对象的结构，它允许我们将数据和功能（属性和方法）封装到一个单独的逻辑单元中。类可以被看作是创建对象（实例）的蓝图或模板。类（Class）和对象（Object）是面向对象编程（OOP）的核心概念。

概念

类（Class）

类是一个用于创建对象的模板或蓝图。它定义了一组属性和方法，这些属性和方法将被它创建的对象所共享。类本质上是一种数据结构，它封装了数据以及操作这些数据的函数。

  • 属性：类中定义的变量。它们代表了该类所有对象共有的数据。
  • 方法：类中定义的函数。它们用于描述该类所有对象共有行为或功能。

通过定义一个类，你实际上是在定义一种新类型的数据结构，这种结构包含了特定类型、对象所具有的属性、可以对这些属性执行哪些操作。

对象（Object）

对象是根据类被创建出来的实例。每个对象都拥有独立于其他对象的属性值集合，但所有对象都共享同一个方法集合（即那些在其对应类中被定义过）。简单来说：

  • 每个实例或对象都拥有从相同模板或蓝图（即：class）继承而来但独立存在、可以各自不同状态信息。
  • 实例化是根据类创建对象的过程

类与对象之间关系

  1. 类型与实例关系：从概念上讲，你可以把“class”看作“type”，把由此“type”生成出来具体存在事物看作“instance”。例如，“Dog”可以是一个表示所有狗通性特点模板名字；而你家那条叫做"Rex"具体小狗则可视作根据"Dog"模板生成出来、带有自己特定状态信息如年龄、品种等信息记录项事物。
  2. 共享与唯一性原则：所有由同一个class生成出来instances会共享该class定义的代码逻辑项，不随各自instance状态变化而变化；同时每个instance也会拥有属于自己唯一且可能随时间改变状态信息记录项。
  3. 继承性原则: 类之间可以通过继承机制分享通用代码逻辑项，并允许子级别class在保持父级别已经提供功能基础上添加或修改部分以满足更加具体需求场景使用要求。

类定义

一个基本的类定义包括关键字class，后面跟着类名和冒号。在其下方缩进的代码块中，可以定义属性（变量）和方法（函数）。

要使用一个类，你需要根据该类创建对象。每个对象都会有自己独立的属性集合。

class MyClass:
    def __init__(self, value):  # 特殊方法__init__用于初始化对象，构造器
        self.my_attribute = value

    def my_method(self):
        return self.my_attribute * 2


# 实例化对象
obj = MyClass(99)
print(obj)
print(obj.my_method())
print(obj.my_attribute)

# 直接修改对象的属性
obj.my_attribute = 100

print(obj)
print(obj.my_method())
print(obj.my_attribute)

类的命名规范

  1. 驼峰命名法：Python中的类名通常使用驼峰命名法（CamelCase）。这意味着类名中每个单词的首字母都大写，而且单词之间不使用下划线分隔。例如，MyClass、DataProcessor、CarEngine。

  2. 描述性命名：类名应该简洁且富有描述性，清楚地表明类的用途或功能。例如，避免使用模糊的名称如Foo或Bar，而应选择更具描述性的名称，如Customer、EmailParser。

  3. 避免缩写：尽量避免使用缩写，因为缩写可能会使代码的可读性降低。完整的单词能更好地表达类的意图和功能。

  4. 首字母大写：按照Python的约定，类名的首字母应该大写，即使它是一个缩写。例如，URLParser而不是urlParser。

  5. 避免使用内置类型名称：避免使用像str、list或dict这样的Python内置类型名称作为类名，以免造成混淆。

  6. 命名长度：虽然没有硬性的长度限制，但一般推荐类名不要过长，以保持代码的清晰和易于维护。

特殊方法

Python提供了多个特殊方法（也称为魔术方法），它们由双下划线包围。这些特殊方法提供了与Python语言功能集成的方式。

初始化和构造

  • __init__(self, [...]): 对象初始化方法，在创建新实例后被调用。
  • __new__(cls, [...]): 实际的对象构造函数，是一个静态方法，在__init__之前被调用。
class TestClassMethod:
    # 定义变量，如果不赋值则必须指定类型
    # 但是类型注解 value_a: int 表示期望 value_a 是一个整数类型，但它并不会阻止你将其他类型赋给该属性。
    value_a: int
    value_b = "value_b"

    # 初始化方法
    def __init__(self, init_value: int):  # 类型注解本身并不会强制变量类型，在运行时仍然可以给带有类型注解的变量赋予任何类型的值。
        print(f'初始化方法调用... init_value : {init_value}')
        # 如果不指定 self. 则为局部变量，无法在这里赋值
        # value_a = init_value
        self.value_a = init_value

    # 实际的对象构造函数，是一个静态方法，在__init__之前被调用。
    # 在生产环境编写代码时通常不需要自己手动重写 __new__ 方法；除非你需要控制对象创建过程。对于大多数情况，默认行为已经足够。
    @staticmethod
    # 名为 __new__ 的实例方法并非特殊方法。特殊方法 __new__ 应当被定义为静态方法（使用装饰器 @staticmethod），或者更常见地作为类方法（使用装饰器 @classmethod）。
    def __new__(cls, *args, **kwargs):
        print(f'对象构造函数调用... cls : {cls}')
        return super(TestClassMethod, cls).__new__(cls)


method = TestClassMethod(1)

print(method.value_a)
# 虽然类中定义了类型为int，但是照常可以赋值字符串
method.value_a = 'aa'
print(method.value_a)

print(method.value_b)

print(dir(method))

表示和格式化

  • __repr__(self): 定义对象的“官方”字符串表示。
  • __str__(self): 定义对象的“非正式”或可打印字符串表示。
  • __format__(self, format_spec): 定义当使用format()函数时对象的格式。
__repr__(self)
  • 目的：创建一个代表对象的官方字符串表示形式。
  • 调用时机：当你调用内置函数repr()时；当没有定义__str__时，在使用print函数打印对象或者在解释器中直接输入变量名查看对象时；还有就是在调试过程中经常会看到这个表示。
  • 特点：应该尽可能返回一个明确且不模糊的字符串表示形式，最好能够通过这个字符串来重新创建该对象。因此，通常返回值会看起来像是一个有效的Python表达式。
class Point:
    def __init__(self, x, y):
        self.x = x
        self.y = y

    def __repr__(self):
        return f"Point({self.x}, {self.y})"
__str__(self)
  • 目的：创建一个对用户友好（非技术用户）的字符串表示形式。
  • 调用时机：当你使用内置函数str()或者使用print函数打印一个对象时。
  • 特点：返回值应该是可读性强、信息友好型描述。
class Point:
    def __init__(self, x, y):
        self.x = x
        self.y = y

    def __str__(self):
        return f"Point located at ({self.x}, {self.y})"
区别

虽然两者都提供了关于对象信息展示方式，但主要区别在于目标受众和它们各自所承担角色：

  • __repr__: 面向开发者和调试器。其目标是明确无误地表达出如何构造出相同数据内容的新实例。
  • __str__: 面向最终用户。其目标是提供友好易懂且便于阅读理解信息。

如果只实现了其中之一，则未实现者将默认使用已实现者进行替代。如果都没有实现，则会默认使用继承自object类中相应方法。

建议至少定义一个__repr__() 方法，在大多数情况下它将足够用来输出有意义并可辨识资源信息，并作为后备方案以防未定义 __str__().

运算符重载（算术、比较运算符）

  • __add__(self, other): 加法运算符+。
  • __sub__(self, other): 减法运算符-。
  • __mul__(self, other): 乘法运算符*。
  • __truediv__(self, other): 真除法运算符/.
  • __floordiv__(self, other): 地板除法运算符//.
  • __mod__(self, other): 取模（余数）操作 %.
  • __eq__(self, other): 等于操作=.
  • __ne__(self, other): 不等于操作不等于操作.
class TestClassMethod:
    value = 100

    def __add__(self, other):
        return self.value + other

    def __sub__(self, other):
        return self.value - other

    def __mul__(self, other):
        return self.value * other

    def __truediv__(self, other):
        return self.value / other

    def __floordiv__(self, other):
        return self.value // other

    def __mod__(self, other):
        return self.value % other

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

    def __ne__(self, other):
        return self.value != other

    # 大于
    def __gt__(self, other):
        return self.value > other

    # 大于等于
    def __ge__(self, other):
        return self.value >= other

    # 小于
    def __lt__(self, other):
        return self.value < other

    # 小于等于
    def __le__(self, other):
        return self.value <= other


method = TestClassMethod()

print(method + 100)
print(method - 100)
print(method * 100)
print(method / 100)
print(method // 100)
print(method % 100)
print(method == 100)
print(method != 100)
print(method > 100)
print(method >= 100)
print(method < 100)
print(method <= 100)

属性访问

属性访问相关的特殊方法可以帮助我们自定义属性的获取、设置和删除行为：

class TestClassMethod:
    def __getattr__(self, name):
        # 当尝试获取一个不存在的属性时调用
        print(f"【报错】！！尝试获取不存在的属性: {name} ")
        return '不存在的属性!'

    def __setattr__(self, name, value):
        # 当对属性赋值时调用
        print(f"调用赋值方法 {name} {value}")
        # self.name = value 不能这样赋值，会导致递归调用
        super().__setattr__(name, value)

    def __delattr__(self, name):
        # 当删除一个属性时调用
        print(f"调用删除属性的方法 {name} ")
        super().__delattr__(name)


method = TestClassMethod()

method.value = 1
print(method.value)
print(method.value2)
del method.value

类属性

在Python中，类的属性可以分为两种：类属性和实例属性。

类属性

  1. 类属性访问
    • 类属性可以通过类名直接访问。
    • 实例也可以访问类属性，但是如果实例具有与类属性同名的实例属性，则会优先访问实例属性。
  2. 修改类属性
    • 通过类名修改类属性会影响到所有访问该属性的实例，因为它们共享同一个类变量。
    • 如果通过实例修改看似“修改”了一个类变量（即instance.attribute = value），其实是在该实例中创建了一个同名的实例变量，并不会影响到其他实例或者是该变量在原来的那个class中。

类属性是属于类本身的变量，它被所有该类的实例共享。这意味着如果你修改了一个类的类属性，这个改变会影响到所有该类的实例。

class MyClass:
    class_attribute = 0


# 修改类属性将影响所有实例
MyClass.class_attribute = 1

instance1 = MyClass()
instance2 = MyClass()

print(instance1.class_attribute)  # 输出: 1
print(instance2.class_attribute)  # 输出: 1

实例（对象）属性

实例属性是属于特定对象（即某个具体实例）的变量。每个对象都有自己独立的一套实例属性，修改一个对象的实例属性不会影响其他对象。

  1. 对象属性访问
    • 对象属性只能通过实例对象访问。它们是绑定到特定实例的，因此每个实例都有自己独立的对象属性副本。
  2. 修改对象属性
    • 对象属性的修改仅限于该特定实例。修改实例的属性不会影响到类的其他实例。
    • 如果尝试通过实例修改一个不存在的属性，Python会自动在该实例上创建这个属性。
class MyClass:
    def __init__(self, value):
        self.instance_attribute = value


# 每个对象都有自己独立的 instance_attribute 属性。
instance1 = MyClass(10)
instance2 = MyClass(20)

print(instance1.instance_attribute)  # 输出: 10
print(instance2.instance_attribute)  # 输出: 20

# 修改一个对象的 instance_attribute 不会影响另一个。
instance1.instance_attribute = 30

print(instance1.instance_attribute)  # 输出: 30
print(instance2.instance_attribute)  # 输出: 20

属性引用和修改规则

  • 类变量属于整个类，所有基于此类创建出来的对象共享这个变量。
  • 如果需要对所有对象都生效地更改某个值，请操作这个值所属类上定义好了的那个变量。
  • 对象属性是绑定到类的实例上的，因此它们对于每个实例来说都是唯一的。
  • 修改一个实例的属性不会影响到其他实例。
  • 通过实例可以访问类属性，但是如果实例有一个与类属性同名的对象属性，则访问的是对象属性，这体现了Python中的“名称遮蔽”特性。（在Python中，“名称遮蔽”（Name Shadowing）是指子作用域中的名称覆盖了外部作用域中相同名称的变量。这种特性在类属性与实例属性之间的交互中尤为常见。）
class TestClassModifyAttr:
    attribute = 0

    def __init__(self, value):
        self.attribute = value

    @property
    def test_method(self):
        """
        当你尝试访问或者修改一个对象（即某个具体实例）
        上不存在但在其对应类型定义中存在作为`@property`装饰器修饰过得方法时，
        Python解释器将调用相应方法来处理此次访问或者修改行为。
        """
        print("调用 test_method")


a = TestClassModifyAttr(999)

print(a.attribute)
print(a.test_method)

# 如果你尝试访问或者修改一个不存在于任何地方（既不是该类型定义中也不是其基类型定义中）
# 且未通过`@property`装饰器修饰过得方法时，
# 则解释器将调用 `__getattr__()` 或 `__setattr__()` 特殊方法来处理此次访问或者修改行为。
print(a.test_method2)
程序猿-瑞瑞
关注
  • 32
    点赞
  • 踩
  • 13
    收藏
    觉得还不错? 一键收藏
  • 打赏
    打赏
  • 0
    评论
专栏目录
Python中的类（Class）和对象（Object）
这家伙很懒，什么都没有留下
12-01 5138
类是创建对象的模板。它定义了一个对象的属性和方法。属性是在对象中存储的数据，而方法是可以在对象上执行的操作。在Python中，使用class关键字定义类。def __init__(self): # 构造函数，在创建新对象时自动调用self.attribute = "Hello" # 属性定义def method(self): # 方法定义本文详细介绍了Python中的类（Class）和对象（Object）的概念和应用场景。类是对象的模板或蓝图，而对象是类的实例。
python类与对象
一步一个脚印
05-12 250
类与对象 创建类 通过关键字class创建一个Player类，来个栗子 class Player: pass 创建对象 通过类实例化两个对象，来个栗子 class Player: pass p1 = Player() p2 = Player() print(p1) #<__main__.Player object at 0x0000...
Python的类和对象
Fengfengyuyuyu的博客
10-15 2762
前言 类和对象是面向对象编程中重要的概念。
超详细Python教程——类和对象
最新发布
月流霜的专栏
06-12 905
除此之外，在这里，还要强调一个概念，当你把类实例化之后，里面的属性和方法，就不叫类属性和类方法了，改为叫实例属性和实例方法，也可以叫对象属性和对象方法。如果这个问题我们需要验证的话，是不是要重写实例的方法，然后观察结果，看看类方法有没有改变，这样就能得出结果了。这很好理解，因为我们的实例对象就是根据类来复制出来的，类属性改变了，实例对象的属性也会跟着改变。是这样的，可以仔细对比一下，类的实例化和直接使用类的格式有什么不同？回归正题，从运行的结果来看，类方法改变了，实例方法也是会跟着改变的。
Python类和对象
qq_61707222的博客
01-24 1714
什么是 Python 类？ python 中的类是创建特定对象的蓝图。它使您可以以特定方式构建软件。问题来了，怎么办？类允许我们以一种易于重用的方式对我们的数据和函数进行逻辑分组，并在需要时进行构建。考虑下图。 类变量是一个类的所有不同对象/实例共享的变量。 实例变量是每个实例唯一的变量。它是在方法内部定义的，并且只属于类的当前实例。 方法也称为函数，它们在类中定义并描述对象的行为。 现在，让我们继续前进，看看它在 PyCharm 中是如何工作的。要开始，首先看一下 python 类的语法。 语法
Python：类和对象
2302_79085918的博客
02-14 1704
在主程序部分，主程序创建了Apple对象之后，可以访问该Apple对象的info()和taste()方法，这表明Apple对象也具有了info()和taste()方法，这就是承接的作用——子类扩展（继承）了父类，将可以继承得到父类定义的方法，这样的子类就可以复用父类的方法了。当程序涉及Canvas类的draw_pic()方法时，该方法所需的参数是非常灵活的，程序为该方法传入的参数对象只要具有制定方法就行，至于该方法呈现怎样的行为特征，则完全取决于对象本身，这大大提高了draw_pic()方法的灵活性。
Python 类和对象
qq_33807380的博客
06-06 726
Python和Java一样，都是面向对象的编程语言，面向对象编程其实是一种封装代码的方法，把一些公共的属性或者方法封装到一个类中，然后再通过这个类可以创建多个对象，最后使用这些对象去调用这些封装起来的公共的属性或者方法。类(Class)：用来描述具有相同的属性和方法的对象的集合。类就好比现实生活中的印刷机的模板，这个模板是不能直接被使用的，模板的主要作用是用来创建对象的。对象：是通过类创建出的实例。
python中的类和对象
Lonely_Fishes的博客
08-05 387
python中的类和对象 一、面向对象大的思想 1.python基于哲学观点：万物皆对象, 一切皆对象 举例说明： 案例一：我想吃大盘鸡 面向过程----------------------面向对象 1.自己去买菜----------------1.委托一个人帮忙买菜 2.自己择菜-------------------2.委托一个人帮忙择菜 3.自己做菜-------------------3.委托一个人厨师做菜 4.自己吃----------------------4.自己吃 面向对象：类，对象，pyth
Python面向对象(类和对象)
Charge8的博客
02-03 2311
Python面向对象(类和对象)
Python基础——类和对象
薛定谔的猫的博客
06-25 3730
Python中的类和对象，私有和公有，继承和多重继承，组合，构造和析构函数，以及绑定的概念
Python类和对象基本概念
网络架构
07-20 469
Python类和对象基本概念27 类和对象 27 类和对象 面向对象编程，是日常常听到的一个词汇，啥意思？有人总结了一下面向对象编程的基本特征： **抽象：**提取现实世界中某事物的关键特性，为该事物构建模型的过程。对同一事物在不同的需求下，需要提取的特性可能不一样。得到的抽象模型中一般包含：属性（数据）和操作（行为）。这个抽象模型我们称之为类。对类进行实例化得到对象。 **封装：**封装可以使类具有独立性和隔离性；保证类的高内聚。只暴露给类外部或者子类必须的属性和操作。类封装的实现依赖类的修饰符（publ
python中什么叫类、什么叫对象_python中的类&面向对象的基本概念!
weixin_39861955的博客
11-26 190
一、概述今天我们讲述Python中的类&面向对象的基本概念。首先我们为什么要学习面向对象,我讲一个故事,应该就可以明白了。在古时候,官府衙门如果要颁布什么告示就会去找工匠将命令中的字都雕刻到石刻上去,然后在把石刻当模板印出文字来, 当工匠辛辛苦苦将文字都在石刻上雕刻好，突然官府又说告示上的文字显得不够官方，不够威严，需要改动一两处小的文字。于是工匠又只能再取一个石刻，然后把文字修改后的告示内容...
python 类与对象
HongKong_Python的博客
12-27 290
类:具有相同的属性和方法的对象的集合 对象:万物皆是对象 类和对象的关系: 类的包含属性和方法: 语法:  class类名: 属性: 方法: 定义一个类: 创建对象:属性写在类外的情况,就是通过对象,属性,对象.方法()的方式调用. 调用对象的方法: 创建多个对象: self:Python类里声明的方法必须的参数 def _init_(self):初始化属性; def _
Python中的类和对象
weixin_63436649的博客
07-30 634
python的类组成包括类属性，实例方法，静态方法，类方法，初始化方法五种。def在类之外定义称为函数，在类之内称为方法。
Python —— 类和对象
南夏一木子的博客
09-19 896
1、init方法在类定义的时候，就会给对象定义实例属性2、初始化对象过程：函数的名字是固定的不能变2、实例化对象的过程，会调用init方法4、实例属性都会在init函数里去定义，基本上不会在外面去定义5、init方法没有返回值，不能写 return，写了默认是None# 定义类class Car:# 定义类的属性wheel = "四个轮子"# 定义init方法，并且在init中定义了2个对象的属性，cl和lgprint(f"正在生成一辆车···")
python类和对象
JOJOY的博客
11-26 2244
类和对象（1） 对象是什么？ 对象=属性（静态）+方法（动态）； 属性一般是一个个变量；方法是一个个函数； 例子： class Turtle:#python 中类名约定以大写字母开头 '''关于类的简单例子。。。''' #属性 color ="green" weight="10kg" legs=4 shell=True mouth='big'
python中类与对象
11-07
类是一种面向对象编程的概念，它是一种抽象的数据类型，用于描述具有相同属性和方法的对象的集合。对象是类的实例，它是具有唯一标识符的实体，具有状态和行为。在Python中，可以使用class关键字定义一个类，类中可以包含属性和方法。属性是类的数据成员，方法是类的函数成员。类的实例化可以通过类名后跟一对括号来完成，实例化后的对象可以访问类的属性和方法。 下面是一个简单的Python类和对象的示例： ```python # 定义一个Person类 class Person: # 类属性 species = 'human' # 构造方法 def __init__(self, name, age): # 实例属性 self.name = name self.age = age # 实例方法 def say_hello(self): print('Hello, my name is', self.name) # 实例化一个Person对象 person1 = Person('Alice', 25) # 访问类属性 print(person1.species) # 访问实例属性 print(person1.name) print(person1.age) # 调用实例方法 person1.say_hello() ```
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

打赏作者

程序猿-瑞瑞

打赏不准超过你的一半工资哦~

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

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

打赏作者

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

抵扣说明：

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

余额充值