通过装饰器函数修改一个类属性

class MyClass:

    NAME = 'My CLASS HAHAHA'

    def __init__(self):

        pass

print(MyClass.__dict__['NAME'])

My CLASS HAHAHA

等价于：

def setname(name):

    def warpper(cls):   

        cls.NAME = name

        return cls

    return warpper

@setname('MY CLASS enen')  #

class MyClass:

    pass

print(MyClass.__dict__['NAME'])

MY CLASS enen

例2：

class MyClass:

    def foo(self):

        print('foo')

    def bar():

        print('bar')

a = MyClass()

a.bar()

报错如下：

  File "E:\python_project\class_test.py", line 12, in <module>

    a.bar()

TypeError: bar() takes 0 positional arguments but 1 was given

提示最少需要给予一个参数才可以

这么写的意思是，函数是普通函数，但是实例化之后是无法使用

这样是不符合规定的

改进：

使用装饰器，第一个装饰器使用类方法

@classmethod

class MyClass:

    xxx = 'hahaha'

    def foo(self):

        print('foo')

    def bar():

        print('bar')

    @classmethod

    def clsmtd(cls):

        print('{}.xxx = {}'.format(cls.__name__,cls.xxx))

a = MyClass()

a.foo()

MyClass.bar()

print(MyClass.__dict__)

foo

bar

{'xxx': 'hahaha', 'bar': <function MyClass.bar at 0x0000000000DD0488>, '__weakref__': <attribute '__weakref__' of 'MyClass' objects>, '__doc__': None, 'foo': <function MyClass.foo at 0x0000000000DD0400>, '__dict__': <attribute '__dict__' of 'MyClass' objects>, '__module__': '__main__', 'clsmtd': <classmethod object at 0x0000000000DD70F0>}

a.clsmtd()

MyClass.xxx = hahaha

静态方法使用

staticmethod

class MyClass:

    def foo(slef):

        return('foo')

    def bar():

        return('bar')

    @staticmethod

    def staticmtd():

        return('static')

a = MyClass()

print(MyClass.staticmtd())

print(a.staticmtd())

static

static

是类的方法即是所有对象的方法

py中的静态方法，表示最一般的函数放在静态方法中，但是受其管辖

然后测试bar方法是否可用

    @staticmethod

    def bar():

        return('bar')

a = MyClass()

print(a.bar())

bar

类方法

class Person:

    def haha():

        print('haha')

Person.haha()

haha

由于没有跟self，没有完成实例的绑定，所以不能完成实例对象的绑定，所以不能用

Person().haha()

TypeError: haha() takes 0 positional arguments but 1 was given

Person().haha()

语法是对的，但是禁止这么调用

@classmethod

class Person:

    HEIGHT = 16

    @classmethod

    def class_method(cls):

        print('class = {0.__name__} ({0})'.format(cls))

        cls.HEIGHT = 17

Person.class_method()

print(Person.HEIGHT)

for i in Person.__dict__.items():

    print(i)

返回如下：

class = Person (<class '__main__.Person'>)

17

('class_method', <classmethod object at 0x0000000000DA1278>)

('__weakref__', <attribute '__weakref__' of 'Person' objects>)

('__doc__', None)

('HEIGHT', 17)

('__module__', '__main__')

('__dict__', <attribute '__dict__' of 'Person' objects>)

在类定义中，使用@classmethod装饰器修饰方法

至少有一个参数，而且第一个参数留给了cls，cls表示调用即类对象自身

cls表示标识符，可以是任意名称，但是为了易读性

类方法是可以直接调用，而实例的方法要求实例必须存在，但是类存在的时候实例可能不存在

只要类方法定义过了，类对象就产生了，那么找属性即可找到

调用方法总结

代码如下：

class Person:

    def no():

        print('no')

    def method(self):

        print('{} method'.format(self))

    @classmethod

    def class_method(cls):

        print('class = {0.__name__} ({0})'.format(cls))

        cls.HEIGHT = 170

    @staticmethod

    def static_method():

        print(Person.HETGHT)

方法调用

类的调用

print(Person.class_method())

class = Person (<class '__main__.Person'>)

print(Person.static_method())

不能调用

print(tom.method())

<__main__.Person object at 0x0000000000A97160> method

print(tom.class_method())

class = Person (<class '__main__.Person'>)

print(tom.static_method())

不可以，没有传递对象

除了普通方法都可以调用，但是普通方法都需要对象的实例作为第一参数

实例可以调用所有类中定义的方法，类和静态方法

访问控制

访问控制主要为了保护封装不被破坏，但是python对外是可见的

私有属性

属性名前加入两个下划线表示当前方法不被破坏

class Person:

    age = 3

    height = 170

    def __init__(self,name,age=18):

        self.name = name

        self.age = age

    def growup(self,incr=1):

        if 0 < incr < 150:

            self.__age + incr

tom = Person('tom')

tom.age = 200

class Person:

    age = 3

    height = 170

    def __init__(self,name,age=18):

        self.name = name

        self.age = age

    def growup(self,incr=1):

        if 0 < incr < 150:

            self.__age + incr

    def getage(self):

        return self.__age

print(Person('tom').getage)

<bound method Person.getage of <__main__.Person object at 0x0000000000827208>>

class Person:

    def __init__(self,name,age=18):

        self.name = name

        self.__age = age

    def growup(self,incr=1):

        if 0 < incr < 150:

            self.__age += incr

    # 获取内部属性

    def getage(self):

        return self.__age

tom = Person('tom')

tom.growup(10)

print(tom.getage())

28

修改tom._Person__age

print(tom.getage())

tom._Person__age = 200

print(tom.getage())

200

查看tom.__dict__

print(tom.__dict__)

{'_Person__age': 200, 'name': 'tom'}

得到的字典中，其实是新加了一个key，而并非被覆盖

所以py的外界是可以修改的隐藏方法的

新增加key：

tom._Person__ages = 200

print(tom.getage())

print(tom.__dict__)

{'name': 'tom', '_Person__age': 20, '_Person__ages': 200}

私有变量的本质

使用__变量名 时，会将其改名，转为_类名+前缀，所以原来名字访问不到了

知道了这个名称则可以直接修改

print(a.__dict__)

{'name': 'tom', '_Person__age': 19}

保护变量

在变量前加一个下划线,共同的约定，表示提醒你这个是一个内部私有的

而解释器认为私有的是私有变量