生成Python类图 python 类图

类

• 类的简介
• 类的创建、使用方法

• 创建方法
• 使用方法
• self的含义
• 类和实例

• \_\_init__（魔术方法）
• 属性与方法

• 类属性
• 实例属性
• 实例方法
• 类方法
• 静态方法

类的简介

类是一个创建对象的图纸，同时类本身也是一个对象，简单的说类就是一个创建对象的对象（类本身是一个type类型的对象）

class Prople:
    pass
print(type(Prople)) # <class 'type'>

类的创建、使用方法

创建方法

用class关键字来定义，根据约定类名首字母大写
语法

class 类名([父类]):
            公共属性
            
            对象的初始方法
            def __init__(self):
                ...            
            def 方法1 (self):
                ...
            def 方法2 (self):
                ...

使用方法

被类赋值的变量称之为类的实例。
类中的变量称之为属性。
类中的函数称之为方法
在类的中我们可以定义属性和方法，在类中定义的内容会变成所有实例的公共内容。
通过（实例.属性名 = 属性值）可以改变此实例属性
通过（实例.方法名）来调用
通过isinstance(变量，类名)来验证变量是否在此类中。

class Prople:
    name = '寻觅'
    def eat(self):
        print('%s很能吃' %self.name)

a = Prople()
b = Prople()
# 通过（实例.属性名 = 属性值）可以改变此实例属性
a.name = '绿巨人'
# 通过（实例.方法名）来调用
a.eat() # 绿巨人很能吃
b.eat() # 寻觅很能吃
# 通过isinstance(变量，类名)来验证变量是否在此类中。
print(isinstance(a, Prople)) # True

self的含义

在函数中，形参和实参数量相同，但是在方法中形参永远比实参多一个，如果创建的方面中没有形参则会报错。多出的形参为解释器自动传递，传递的值为调用方法的本身，一般我们会将这个函数命名为self。

class Prople:
    def eat(self):
        print(self)

a = Prople()
a.eat() # <__main__.Prople object at 0x000001E6DE675610>
print(a) # <__main__.Prople object at 0x000001E6DE675610>

类和实例

当我们调用一个实例的属性时，解析器会先在当前实例中寻找是否有该属性，如果有，则直接返回当前实例的属性值如果没有，则去当前实例的类对象中去寻找，如果有则返回类对象的属性在没有则报错。
类对象和实例中的属性和方法不会因为调用结束而销毁。
如果这个属性或方法是所有实例共享，则应该将其保存在类对象中
如果这个属性或方法是某个实例独有的，则应该保存到实例对象中

__init__（魔术方法）

魔术方法是一种不需要自己调用的特殊方法，它会在特殊的时候自动调用。
在魔术变量中，我们最常用的就是__init__方法，下面我们就来详细介绍一下它的用法。

1. 此魔术方法会在创建实例后立即执行，用来将内部的内容自动存入到每个实例之中

class Prople:

    def __init__(self):
        self.name = '寻觅'
        print('我的名字是', self.name)

    def can(self):
        print('我很能吃')


data = Prople()
data.can() # 我的名字是 寻    我很能吃
#这里会把self中的内容输出

将属性放入__init__和将属性直接放入class中虽然看似效果相同，但实际两种方法在处理中却截然不同。
如果直接将属性放入类中，属性会变为类中的公共属性，如果修改此公共属性，则公共属性被改变，使用此类创建的实例中此属性也会被改变，而在__init__中的属性则会自动放入每个实例中，及时在某个实例中此属性被修改，也不会影响到其他调用此类创建的实例对象。
我会专门写一篇关于各种魔术方法的介绍和用处，需要的话可以关注我的博客。

属性与方法

类属性

自己在类中定义的属性。可以直接通过类来访问（类.属性），类的实例化对象可以访问类属性，类属性只能通过类对象来修改，无法通过实例对象来修改

class Prople:
    name = '寻觅'
    def eat(self):
        print('%s很能吃' % self.name)
a = Prople()
a.name = '测试'
a.eat()
print(a.name, Prople.name) # 测试 寻觅

实例属性

通过类对象添加的属性。只能通过实例对象来访问和修改，无法使用类对象访问或修改。

实例方法

在类中定义，以self为参数的方法都是实例方法。 => (类.方法(实例) 等价于 实例.方法())

class Prople:
    def __init__(self):
        self.name = '寻觅'
    def can(self):
        print('%s很能吃' % self.name, self)
data = Prople()
data.can() # 寻觅很能吃 <__main__.Prople object at 0x000001A3F6856C40>
Prople.can(data) # 寻觅很能吃 <__main__.Prople object at 0x000001A3F6856C40>

类方法

在类的内部使用@classmethod 来修饰的方法叫做类方法。类方法可以跳过实例，直接通过类进行调用。
（在实例方法中第一个参数为self，而在类方法中第一个参数为cls 。注意： cls和self一样，并不是强制性的命名）
cls是当前类对象

静态方法

在类内部使用@staticmethod来装饰的方法属于静态方法，静态方法不需要指定任何参数，可以通过类和实例去调用。

class Prople(object):
    name = '寻觅'
    @classmethod
    def eat(cls):
        print('%s贼能吃' % cls.name, cls)
    @staticmethod
    def can():
        print('能睡很久')
data = Prople()
data.eat() # 寻觅贼能吃 <class '__main__.Prople'>
Prople.eat() # 寻觅贼能吃 <class '__main__.Prople'>
data.can() # 能睡很久
Prople.can() # 能睡很久

class Animal:

    looks = '各不相同'

    def __init__(self, name, age):
        self.__name = name
        self.__age = age

    # 实例方法
    def sleep(self):
        print('%d岁的%s会睡觉' % (self.__age, self.__name))

    # 类方法
    @classmethod
    def eat(cls):
        # 类方法无法调用实例中的属性，魔术方法中的属性在这里就无法使用
        print('动物吃的东西%s' % cls.looks)

    @property
    def name(self):
        return self.__name

    @name.setter
    def name(self, name):
        self.__name = name

    # 静态方法,静态方法在类中使用很少，静态方法就相当于把外部的函数放到了类中
    @staticmethod
    def xunmi():
        print('静态方法不用设置self，他不会向自身传递self')


# 类属性
print(Animal.looks)
cat = Animal('猫', 11)
# 修改实例中的类属性
cat.looks = '可爱'
# 类属性没有改变
print(cat.looks, Animal.looks)
# 只能通过类属性来修改类属性
Animal.looks = '多种多样'
print(Animal.looks)

# 实例属性
cat.target = '占领地球'
print(cat.target)
# print(Animal.target)

cat.sleep()
cat.eat()
cat.xunmi()