python 类

已于 2024-06-29 11:49:25 修改
阅读量1.5k 收藏 49
点赞数 33
文章标签： python
于 2024-06-29 11:44:31 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/EveyD/article/details/140061576
版权

文章目录

类

python的类变量和C++的静态变量不同，并不是由类的所有对象共享。

类本身拥有自己的类变量（保存在内存），当一个 TestClass 类的对象被构造时，会将当前类变量拷贝一份给这个对象，当前类变量的值是多少，这个对象拷贝得到的类变量的值就是多少；而且，通过对象来修改类变量，并不会影响其他对象的类变量的值，因为大家都有各自的副本，更不会影响类本身所拥有的那个类变量的值；只有类自己才能改变类本身拥有的类变量的值。

对于类数据属性和实例数据属性，可以总结为：

  • 类数据属性属于类本身，可以通过类名进行访问/修改
  • 类数据属性也可以被类的所有实例访问/修改
  • 在类定义之后，可以通过类名动态添加类数据属性，新增的类属性也被类和所有实例共有
  • 实例数据属性只能通过实例访问
  • 在实例生成后，还可以动态添加实例数据属性，但是这些实例数据属性只属于该实例
class TestClass(object):
    # 类变量
    val1 = 100

    def __init__(self):
        # 成员变量
        self.val2 = 200

    def fcn(self, val=400):
        val3 = 300
        self.val4 = val
        self.val5 = 500

inst = TestClass()

print(TestClass.val1)  # 100
print(inst.val1)  # 100
print(inst.val2)  # 200

print(inst.val3)  # 'TestClass' object has no attribute 'val3'
print(inst.val4)  # 'TestClass' object has no attribute 'val4'
print(inst.val5)  # 'TestClass' object has no attribute 'val5'

inst1 = TestClass()
inst2 = TestClass()

print(inst1.val1)  # 100

inst1.val1 = 1000
print(inst1.val1)  # 1000

print(TestClass.val1)  # 100
print(inst2.val1)  # 100

TestClass.val1 = 2000
print(TestClass.val1)  # 2000
print(inst1.val1)  # 1000     被重新赋值后，就跟类变量没关系了
print(inst2.val1)  # 2000     没有重新赋值，跟类变量保存一致

inst3 = TestClass()
print(inst3.val1)  # 2000
不可变对象与可变对象

python内置的一些类型中

  • 可变对象：list dict set

  • 不可变对象：tuple string int float bool

Python中万物皆对象，每个对象包含3个属性，id，type，value

  • id就是对象地址，可以通过内置函数id()查看对象引用的地址。

  • type就是对象类型，可以通过内置函数type()查看对象的类型。

  • value就是对象的值

is 和==

  • is比较的是id是不是一样

  • ==比较的是值是不是一样。

a = 1
b = a
c = 1
d = 1.0
print(id(a))  # 140729241962160
print(id(b))  # 140729241962160
print(id(c))  # 140729241962160
print(id(d))  # 2070028299024
print(a is d)  # False
print(a == d)  # True

  • 判断a is d的时候，实际上比较的是id(d)==id(d)，结果为False。

  • 判断a==d的时候，实际上比较的是id(a)这个地址指向的值是不是和id(d)这个地址指向值一样。结果为True。

python为了实现对内存的有效利用，对小整数[-5,256]内的整数会进行缓存，不在该范围内的则不会缓存。

注意在python交互式界面有内存池缓存机制，只适用于-5~256，在python脚本编程中则没有这个限制:

a = 255
b = 255
print(a is b)  # True

c = 257
d = 257
print(c is d)  # True

Python console：

a = 255
b = 255
id(a)
Out[10]: 2922684620976
id(b)
Out[11]: 2922684620976
a is b
Out[4]: True

c = 257
d = 257
id(c)
Out[8]: 2920614082448
id(d)
Out[9]: 2920614081904    
c is d
Out[7]: False
类属性
class Person(object):
    tall = 180
    hobbies = []

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

    def inform(self):
        print('%s is %s weights %s' % (self.name, self.age, self.weight))

特殊的类属性：对于所有的类，都有一组特殊的属性

__name__：类的名字（字符串）

__doc__ ：类的文档字符串

__bases__：类的所有父类组成的元组

__dict__：类的属性组成的字典

__module__：类所属的模块

__class__：类对象的类型

print(Person.__name__)  # Person
print(Person.__doc__)  # None
print(Person.__bases__)  # (<class 'object'>,)
print(Person.__dir__)  # <method '__dir__' of 'object' objects>
print(Person.__module__)  # __main__
print(Person.__class__)  # <class 'type'>

__dict__与dir()区别

  • __dict__属性：
    • 类的__dict__存储所有实例共享的变量和函数(类属性，方法等)，类的__dict__并不包含其父类的属性。
    • 实例的__dict__属性仅仅是那个实例的实例属性的集合，并不包含该实例的所有有效属性，正是因为实例的__dict__属性，每个实例的实例属性才会互不影响。
    • python一切皆对象，并不是所有对象都拥有__dict__属性。许多内建类型就没有__dict__属性，如list，此时就需要用dir()来列出对象的所有属性。
  • dir()函数：
    dir()是Python提供的一个API函数，dir()函数会自动寻找一个对象的所有属性(包括从父类中继承的属性)。
    所以如果想获取一个对象所有有效属性，应使用dir()。
# 类数据属性属于类本身，可以通过类名进行访问/修改，此处添加"football"、"woman"两个
Person.hobbies.extend(["football", "woman"])
print(Person.hobbies)  # ['football', 'woman']

# 在类定义之后，可以通过类名动态添加类数据属性，新增的类属性也被类和所有实例共有
Person.hobbies2 = ["reading", "jogging", "swimming"]
print(Person.hobbies2)  # ['reading', 'jogging', 'swimming']

# 实例数据属性只能通过实例访问
Bruce = Person("Bruce", 25, 60)
print(f"{Bruce.name} is {Bruce.age} years old")  # Bruce is 25 years old

# 在实例生成后，还可以动态添加实例数据属性，但是这些实例数据属性只属于该实例
Bruce.gender = "male"
print("{Bruce.name} is {Bruce.gender}")  # Bruce is male

# class instance can access class attribute
Bruce.hobbies.append("C#")
print(Bruce.hobbies)  # ['football', 'woman', 'C#']
print(Bruce.hobbies2)  # ['reading', 'jogging', 'swimming']

类数据属性属于类本身，被所有该类的实例共享并且，通过实例可以去访问/修改类属性。但是，在通过实例中访问类属性的时候一定要谨慎，因为可能出现**属性"隐藏"**的情况

对于不可变类型的类属性，隐藏属性可以总结为：

  • 对于不可变类型的类属性 person.tall，可以通过实例Bruce进行访问，并且"person.tall is Bruce.tall"
  • 当通过实例赋值/修改tall属性的时候，将为实例Bruce新建一个tall实例属性，这时，“person.tall is not Bruce.tall”
  • 当通过"del Bruce.tall"语句删除实例的tall属性后，再次成为"person.tall is Bruce.tall"
# 对于不可变类型的类属性person.tall，可以通过实例Bruce进行访问
print(Person.tall is Bruce.tall)  # True

# 重新赋值或者修改
Bruce.tall = 185
print(Bruce.tall)  # 185
print(Person.tall is Bruce.tall)  # False

# 再次删除实例的赋值
del Bruce.tall
print(Bruce.tall)  # 180
print(Person.tall is Bruce.tall)  # True

对于可变类型的类属性，隐藏属性可以总结为：

  • 同样对于可变类型的类属性person.hobbies，可以通过实例Bruce进行访问，并且"person.hobbies is Bruce hobbies"
  • 当通过实例赋值hobbies 属性的时候，都将为实例Bruce新建一个hobbies实例属性，这时，“person.hobbies is not Bruce hobbies”
  • 当通过"del Bruce. hobbies"语句删除实例的hobbies属性后，再次成为"person. hobbies is Bruce hobbies"
  • 当通过实例修改hobbies属性的时候，将修改Bruce. hobbies指向的内存地址（即person.hobbies），此时，“person.hobbies is Bruce. hobbies”
# 对于可变类型的类属性person.hobbies，可以通过实例Bruce进行访问
print(Person.hobbies is Bruce.hobbies)  # True

Bruce.hobbies.append("CSS")
print(Person.hobbies is Bruce.hobbies)  # True
print(Person.hobbies)  # ['football', 'woman', 'C#', 'CSS']

Will = Person("Will", 27, 60)
print(f"{Will.name} is {Will.age} years old") # Will is 27 years old

# Will shares the same class attribute with wilber
# Will don't have the "gender" attribute that belongs to wilber
print(Will.hobbies)  # ['football', 'woman', 'C#', 'CSS']
print(Will.gender)  # AttributeError: 'Person' object has no attribute 'gender'

注意，虽然通过实例可以访问类属性，但是，不建议这么做，最好还是通过类名来访问类属性，从而避免属性隐藏带来的不必要麻烦

__del__
class Test:
    # 当内存不需要的时候调用这个删除方法，python解释器自动调用
    def __del__(self):
        print("Over")


t1 = Test()
t2 = t1
del t1
del t2
print("==========")

# Over
# ==========

class Test:
    # 当内存不需要的时候调用这个删除方法，python解释器自动调用
    def __del__(self):
        print("Over")

t1 = Test()
t2 = t1
del t1
print("==========")

# ==========
# Over

当删除了t1，内存空间还没有结束，还不会调用__del__方法，当调用完最后一条语句时，内存空间被释放，调用__del__方法

类class的访问控制

"_“和”__"的使用 更多的是一种规范/约定，并没有真正达到限制的目的

单下划线"_"

以单下划线开头的表示的是 protected 类型的变量，即只能允许其本身与子类进行访问；同时表示弱内部变量标示，如"from moduleName import * " 将不会引入以单下划线 "_"开头的函数。

双下划线"__"

双下划线的表示的是private类型的变量。只能是允许这个类本身进行访问了，连子类也不可以，这类属性在运行时属性名会加上单下划线和类名。

  • 对于Python中的类属性，可以通过双下划线**"__“来实现一定程度的私有化**，因为双下划线开头的属性在运行时会被"混淆”（mangling）

  • 双下划线的另一个重要的目地是，避免子类对父类同名属性的冲突

  • 单下划线，可被重写，调用子类方法

  • 双下划线，不能被重写，调用的还是父类方法

class A(object):
    def __init__(self):
        self.__private()
        self.public()

    def __private(self):
        print('A.__private()')

    def public(self):
        print('A.public()')


class B(A):
    def __private(self):
        print('B.__private()')

    def public(self):
        print('B.public()')


b = B()

# A.__private()
# B.public()
类class的继承

在Python中，同时支持单继承与多继承

实现继承之后，子类将继承父类的属性(除了文档字符串)，也可以使用内建函数insubclass()来判断一个类是不是另一个类的子孙类

类型比较
  • type()不会认为子类是一种父类类型
  • isinstance()会认为子类是一种父类类型。
class Foo(object):
  pass

class Bar(Foo):
  pass

print(type(Foo()) == Foo)  # True
print(type(Bar()) == Foo)  # False
print(isinstance(Foo(), Foo))  # True
print(isinstance(Bar(), Foo))  # True

**Example 1 **

class A:
    def __init__(self):
        self.__j = 1
        self.number = 5

class B(A):
    def __init__(self):
        self.__j = 2
        self.number = 7

    def show(self):
        print(self.__j, self.number)

b = B()
b.show() # 2 7

**Example 2 **

class A(object):
    def __method(self):
        print("I'm a method in A")

    def method(self):
        self.__method()

class B(A):
    def __method(self):
        print("I'm a method in B")


B().method()  # I'm a method in A
A().method()  # I'm a method in A

Example 3

class Parent(object):
    """
    parent class
    """
    pass


class Child(Parent):
    pass


# doc属性不会被继承
print(Parent.__doc__)  # parent class
print(Child.__doc__)  # None

super的使用

super主要显式调用父类，在子类中，一般会定义与父类相同的属性（数据属性，方法），从而来实现子类特有的行为。也就是说，子类会继承父类的所有的属性和方法，子类也可以覆盖父类同名的属性和方法

调用父类的方法：

  1. 将“self”显式的传递进去：
class Parent(object):
    Value = "Hi, Parent value"
    def fun(self):
        print("This is from Parent")

class Child(Parent):
    Value = "Hi, Child  value"
    def fun(self):
        print("This is from Child")
        # 调用父类Parent的fun函数方法
        Parent.fun(self)  

c = Child()
c.fun()

# This is from Child
# This is from Parent
  1. 使用Python中的super关键字
class Parent(object):
    Value = "Hi, Parent value"
    def fun(self):
        print("This is from Parent")

class Child(Parent):
    Value = "Hi, Child  value"
    def fun(self):
        print("This is from Child")
        # 相当于用super的方法与上一调用父类的语句置换
        super(Child, self).fun()

c = Child()
c.fun()

# This is from Child
# This is from Parent
super()

对于你定义的每一个类，Python会计算出一个所谓的方法解析顺序(MRO)列表。 这个MRO列表就是一个简单的所有基类的线性顺序表。为了实现继承，Python会在MRO列表上从左到右开始查找基类，直到找到第一个匹配这个属性的类为止。

而这个MRO列表的构造是通过一个C3线性化算法来实现的。 实际上就是合并所有父类的MRO列表并遵循如下三条准则：

  • 子类会先于父类被检查
  • 多个父类会根据它们在列表中的顺序被检查
  • 如果对下一个类存在两个合法的选择，选择第一个父类

虽然名义上来说super是用来调用父类中的方法，但是super实际上是在MRO表中找到下一个匹配的类。super原型如下：

def super(cls, inst):
    mro = inst.__class__.mro()
    return mro[mro.index(cls) + 1]

两个参数 cls 和 inst 分别做了两件事：

  1. inst 负责生成 MRO 的 list
  2. 通过 cls 定位当前 MRO 中的 index, 并返回mro[index + 1]

但是根据我们上面说的super本质知道 super 和父类其实没有实质关联，我们就不难理解为什么 enter B 下一句是 enter C 而不是 enter A了（如果认为 super 代表“调用父类的方法”，会想当然的认为下一句应该是enter A）。

可以用　self.__class__.__mro__ 方法来查询当前MRO

一个多继承中的MRO是固定的(只要每个类之间都有继承关系）

Example:

class A(object):
    def __init__(self):
        print("Enter A")

class B(A):
    def __init__(self):
        print('Enter B')
        super(B, self).__init__()
        print('Leave B')

class C(A):
    def __init__(self):
        print('Enter C')
        super(C, self).__init__()
        print('Leave C')

class D(B, C):
    def __init__(self):
        print('Enter D')
        super(D, self).__init__()
        print("Leave D")
        print(self.__class__.__mro__)
        
d = D()

# Enter D
# Enter B
# Enter C
# Enter A
# Leave C
# Leave B
# Leave D
# (<class '__main__.D'>, <class '__main__.B'>, <class '__main__.C'>, <class '__main__.A'>, <class 'object'>)

上方例子的中流程：

  1. class D中，输出“Enter D" , 然后就会调用super方法，super()方法，第一个参数是D，在MRO列表中的下标（index）为0，那么调用的下一个类就是下标为（index+1）的类，即class B,

  2. 进入class B，输出"Enter B" ,再次调用super()，此时的index为1，那么调用的下一个类的index为2，即class C，输出“Enter C” .

  3. 在class C中，调用super()，进入class A，输出“Enter A”，

  4. 回到class C ，输出 “Leave C” , 再回到class B ，输出“Leave B”, 然后回到class D，输出“Leave D”。结束

当你使用 super() 函数时，Python会在MRO列表上继续搜索下一个类。 只要每个重定义的方法统一使用 super()并只调用它一次， 那么控制流最终会遍历完整个MRO列表，每个方法也只会被调用一次。

__new__

__new__方法：类级别的方法

  1. 是在类准备将自身实例化时调用，并且至少需要传递一个参数**cls**，此参数在实例化时由python解释器自动提供
  2. 始终是类的类方法，即使没有被加上类方法装饰器；
  3. 必须要有返回值，返回实例化出来的实例；在自己实现__new__()时需要注意：可以return父类（通过super(当前类名，cls)）.__new__出来的实例，或者直接是object的__new__出来的实例
class A(object):
    pass

# 默认调用父类object的__new__()方法来构造该类的实例
a = A()
print(a)  # <__main__.A object at 0x000001BE6F8CD520>

class A(object):
    def __new__(cls):
        "重写__new__方法"
        return "abc"

a = A()
print(a)  # 'abc'
print(type(a))  # <class 'str'>

通过__new__()方法实现单例

class Singleton(object):
    def __new__(cls, *args, **kwargs):
        if not hasattr(cls, "_instance"):
            cls._instance = super(Singleton, cls).__new__(cls)
        return cls._instance


a = Singleton()
b = Singleton()
c = Singleton()
print(a)  # <__main__.Singleton object at 0x000001F0B57D86D0>
print(b)  # <__main__.Singleton object at 0x000001F0B57D86D0>
print(c)  # <__main__.Singleton object at 0x000001F0B57D86D0>
__init__

__init__方法：实例级别的方法

  1. 有一个参数self, 该self参数就是__new__()返回的实例；

  2. __init__()在__new()__的基础上完成初始化动作，不需要返回值；

若__new__()没有正确返回当前类cls的实例，那__init__()将不会被调用

创建的每个实例都有自己的属性，方便类中的实例方法调用；

class A:
    def __new__(cls, *args, **kwargs):
        print("A' __new__")
        # return super(A,cls).__new__(cls)
        return object.__new__(cls)

    def __init__(self):
        print("A' __init__")


class B(A):
    def __new__(cls, *args, **kwargs):
        print("B' __new__")

    def __init__(self):
        print("B' __init__")

a = A()
# B' __new__  没有创建真正的类B，所以类B的构造函数没有调用
b = B()


# A' __new__
# A' __init__
# B' __new__

当在Python中出现继承的情况时，一定要注意初始化函数__init__的行为:

  • 如果子类没有定义自己的初始化函数，父类的初始化函数会被默认调用；但是如果要实例化子类的对象，则只能传入父类的初始化函数对应的参数，否则会出错

  • 如果子类定义了自己的初始化函数，而在子类中没有显式调用父类的初始化函数，则父类的属性不会被初始化

  • 如果子类定义了自己的初始化函数，在子类中显式调用父类，子类和父类的属性都会被初始化

元类

类是能够创建出类实例的对象。类本身也是实例，它们是元类的实例。

Python中的一切都是对象，它们要么是类的实例，要么是元类的实例，除了type。type实际上是它自己的元类，在纯Python环境中这可不是你能够做到的，这是通过在实现层面耍一些小手段做到的。

其次，元类是很复杂的。对于非常简单的类，你可能不希望通过使用元类来对类做修改。你可以通过其他两种技术来修改类：

class A:
    pass

print(type(1))  # <class 'int'>
print(type(type(1)))  # <class 'type'>
print(type(int))  # <class 'type'>
print(type(A))  # <class 'type'>

元类是类的类，常可以用在类工厂中；

  • Python中所有的类都是对象，可以通过type()来创建元类
  • 在定义类时，可用过metaclass参数来指定此类的元类
  • Python类语句执行时，会先查找其类本身的metaclass属性，如果没找到，会继续在父类中找，还没找到，则到模块中找，最后再用内置的type来创建此类对象
  • 使用类、函数都可以当作元类，通常在**__new__**方法中通过type来自定义自己的元类
  • 从设计的复杂度来讲，尽量少用元类，多用普通类或函数
折寒语风
关注
  • 33
    点赞
  • 踩
  • 49
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
python 类传值的两种方法
机器学习深度学习业余选手
08-06 1472
python 类传值的两种方法
Python类的定义和使用
热门推荐
精益求精，永无止境，永远在路上！
05-03 10万+
优秀是一种属性，只要我们这类努力学习的人才能调用，带大家一起学习类的定义与使用（一起努力，咱们顶峰相见）
python类方法
喵酱
02-08 4748
参考： 史上最全 Python 面向对象编程 - 知乎 类方法 类方法由类调用，采用@classmethod装饰，至少传入一个cls（代指类本身，类似self）参数。执行类方法时，自动将调用该方法的类赋值给cls。建议只使用类名.类方法的调用方式。（虽然也可以使用实例名.类方法的方式调用） 实际案例 如果要构造一个类，接受一个网站和这个网站的状态码，然后打印出来。就像这样： class gg: def __init__(self,url,stat): self.url=
python创建person类_python类的创建
weixin_39551366的博客
12-01 2309
广告关闭回望2020，你在技术之路上，有什么收获和成长么？对于未来，你有什么期待么？云+社区年度征文，各种定制好礼等你！0x00 前言在python中，类也是作为一种对象存在的，因此可以在运行时动态创建类，这也是python灵活性的一种体现。 本文介绍了如何使用type动态创建类，以及相关的一些使用方法与技巧。 0x01 类的本质何为类？ 类是对现实生活中一类具有共同特征的事物的抽象，它描述了所创...
python类中包含类_彻底搞懂Python中的类
weixin_39768695的博客
12-15 3625
Python类的定义Python 中定义一个类使用 class 关键字实现，其基本语法格式如下：class类名：多个(≥0)类属性...多个(≥0)类方法...注意，无论是类属性还是类方法，对于类来说，它们都不是必需的，可以有也可以没有。另外，Python 类中属性和方法所在的位置是任意的，即它们之间并没有固定的前后次序。和变量名一样，类名本质上就是一个标识符，因此我们在给类起名字时，必须让其符...
python类的继承
qimo601的专栏
01-26 4925
目录 一、概述　 二、类的继承 2.1 继承的定义 2.2 构造函数的继承　 2.3 子类对父类方法的重写 三、类继承的事例 回到顶部 一、概述　 　　面向对象编程 (OOP) 语言的一个主要功能就是“继承”。继承是指这样一种能力：它可以使用现有类的所有功能，并在无需重新编写原来的类的情况下对这些功能进行扩展。 　　通过继承创建的新类称为“子类”或“派生类”，被继承的类称为“基类”、“父类”或“超类”，继承的过程，就是从一般到特殊的过程。在某些 OOP 语言中，一个子.....
python类有哪些成员_Python类之类的成员
weixin_39845206的博客
12-11 2229
对于一个学C++的朋友来说，Python类中，哪些是私有成员，哪些是共有成员，估计一直傻傻分不清。一、本篇博客要解决的问题：Python类中，哪些是私有成员？哪些是共有成员？二、 关于Python的类要想了解Python的类，就必须认识到，当你在Python中写了一个类的时候，你就已经构建了一个新的类型。所以，你写的类型其本身有属性和方法，而类型对应的实例，也有自己的属性，不过并没有方法。也就是说...
Python 类中的object是什么
yingxuanzhang的博客
05-30 1万+
在python中，object是一个我们会经常遇到的词汇，那么这个词汇究竟有什么含义呢？通过查阅一些文档，我们发现，object其实是一个类的实例，而这个类的名字是Object(默认类的命名首字母大写)，它是所有类的父类，换句话说，python是默认所有的类都继承自Object类。而如abc(抽象基类)等其他的内置的类都是基于Object类的一些功能实现的。可以说，Object类规定了类的结构，加载方式，常用函数等。对Object类的常见应用主要有以下两个形式，python2和python3 #以前的写
Python类中的self是什么意思？
m0_62346827的博客
07-28 7765
在学习Python会发现，类的方法（构造方法和实例方法）中都会有一个固定参数self 。这个self就是指实例对象自身，用来作为参数代替实例对象。
Python类和构造方法
python学习者的博客
12-17 4983
1.面向对象介绍 描述：是函数的一个变种,在Python中,有函数式编程和面向对象编程,java和C#之类只能把函数写到类里,没有函数式编程,所以只有面向对象,所以在Python中有了选择,可能就变得有点麻烦,但是在Python里,函数式编程是可以完成所有的功能的,人都是想把事情变得越来越简单,机械化,而在函数式编程中可以使用的代码量和设计比较多,而可能几行代码面向对象就可以实现 分析: a、Py...
Python 类的介绍
m0_74760082的博客
03-20 2102
在Python中的，类时一种面向对象编程的机制，用于描述具有相同属性的和方法的对象的集合。类定义了一组属性和方法，可以用来创建对象的模板。类定义了一组属性和方法，可以用来创建对象的模板。类可以看作一种自定义的数据类型，它可以包含多个实例，每个实例都具有相同的属性和方法。类的定义通常包括类名、属性和方法在类定义中，我们可以定义类属性、类方法、实例属性和实例方法等。类属性是整个类的属性，可以通过类名来访问。实例属性是属于实例的属性，只能通过实例名来访问。类方法和实例方法是类中的函数，可以用来执行特定的操作。
java与python类对比
weixin_43178406的博客
03-17 1万+
本文主要介绍了java与python类对比，希望能对学习Python和java的同学们有所帮助。 文章目录 1. 构造器 2. 方法和变量 3. super、self、this 4. python代码实例 5. java代码实例
python类属性初始化_Python类定义、属性、初始化和析构
weixin_33443932的博客
02-04 2630
类的定义，属性和方法概念方法中self的作用和意义初始化( __init__ ) 和 析构方法( __del__ )类的定义class 类名实例实例名 = 类名()一个“实例”的“特征”，就是“属性”私有属性在python中有两种私有属性，分别是在属性前加 一个下换线(_) 和 两个下划线(__)一个下滑线外部可以直接访问(用运算符“.”，点不出来，在知道有的情况下，可以直接使用)两个下划线外部...
python中类的嵌套_python类的嵌套
weixin_39797381的博客
11-25 2208
广告关闭腾讯云11.11云上盛惠 ，精选热门产品助力上云，云服务器首年88元起，买的越多返的越多，最高返5000元！在.net和java语言中看到过嵌套类的实现，作为外部类一个局部工具还是很有用的，今天在python也看到了很不错支持一下。 动态语言中很好的嵌套类的实现，应该说嵌套类解决设计问题同时简化了程序，值得学习。 #! usrbinenv python import threading, ...
爆改YOLOv8|使用MobileNetV4替换yolov8的Backbone
weixin_43986124的博客
09-12 587
MobileNetV4，yolov8改进backbone, yolov8改进， 即插即用
【python】—— Python爬虫实战：爬取珠海市2011-2023年天气数据并保存为CSV文件
weixin_63106307的博客
09-05 1147
本文将介绍如何使用Python编写一个简单的爬虫程序，以爬取珠海市2011年至2023年的天气数据，并将这些数据保存为CSV文件。
JUC从实战到源码：中断机制与API实现
最新发布
qq_43843951的博客
09-12 744
在Java中，线程中断是一种机制，用于通知线程应该停止当前正在执行的任务。中断通常用于协同线程之间的合作，以便让线程在适当的时候终止其工作，尤其是在长时间运行的任务或阻塞操作中。通过学了多线程以及synchronized的相关知识，接下来就到了学习线程中断知识。
蒙特卡罗方法——布丰投针实验近似计算圆周率python代码实现
2301_79376014的博客
09-09 410
蒙特卡罗——布丰实验
Python实现多线程、多进程及协程
qq_42568323的博客
09-09 1014
本文详细介绍了 Python 中多线程、多进程和协程的并发模型及其实现方式，并通过具体场景演示了如何使用面向对象思想实现这些模型。在实际应用中，应根据任务的类型和需求选择合适的并发模型，从而优化程序的性能和资源利用率。本文将详细介绍 Python 中的多线程、多进程和协程的概念及其实现方式，并通过具体场景展示如何在 Python 中使用面向对象的思想实现这些并发模型。接下来，我们通过一个计算密集型任务的示例来演示多进程的实现：计算一系列大数字的阶乘。主程序中创建并启动了多个计算进程，并使用。
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值