Python面向对象（静态方法和类方法）

1.类和对象

面向对象：
     一种基于面向过程的新的编程思想，顾名思义该思想是站在对象角度思考问题，我们把多个功能合理放到不同对象里，强调的是具备某些功能的对象。

类：
    实际上是对某种类型的对象定义变量和方法的原型。它表示对现实生活中一类具有共同特征的事物的抽象，是面向对象编程的基础。
　　 类是对某个对象的定义。它包含有关对象动作方式的信息，包括它的名称、方法、属性和事件。实际上它本身并不是对象，因为它不存在于内存中。
    当引用类的代码运行时，类的一个新的实例，即对象，就在内存中创建了。虽然只有一个类，但能从这个类在内存中创建多个相同类型的对象。

 

2.类的格式

在程序开发过程中，设计一个类，通常需要满足三个要求：
1.类名：这类事物的名字，满足大驼峰命名法
2.属性：这类事物具有的特征
3.方法：这类事物具有的行为
当一个类定义完成后，要使用这个类来定义对象，语法格式： 对象名 = 类名（）

 

（1）格式

class 类名(object):
   成员(方法)

 

（2）python中如何通过类创建对象

对象名 = 类名()

 

3.定义一个Phone类

 

class Phone:
    brand = 'xiaomi'
    price = 4999
    type = 'mate 80'

    # Phone类里面的方法：call
    def call(self):
        print(self)  # 地址：0x000001EFF727FE48
        print('正在访问通讯录:')
        print('正在打电话...')


phone1 = Phone()  # 通过类创建对象
print(phone1)  # 地址：0x000001EFF727FE48
phone1.call()  # call(phone1)

phone2 = Phone()
print(phone2)
phone2.call()  # call(phone2)
phone：

<__main__.Phone object at 0x00000215015FFDC8>
<__main__.Phone object at 0x00000215015FFDC8>
正在访问通讯录:
正在打电话...

phone2
<__main__.Phone object at 0x00000215015FD108>
<__main__.Phone object at 0x00000215015FD108>
正在访问通讯录:
正在打电话...

 4.__init__方法

class Phone():
    #魔术方法之一：__名字__()
    def __init__(self):
        print("=====init===")
    # Phone类里面的方法：call
    def call(self):
        print("===price==")

phone1 =Phone()

>> =====init===

底层实现流程：
1.phone1 = Phone（）利用类创建对象，读到phone（）时，首先查找Phone（）类。
2.利用Phone类，向内存申请一块和类同样大小的空间。
3.向Phone类中查找有没有__init__方法；若没有，则则将新空间赋值给phone1；
4.若有，则进入__init__方法，执行相应内容，再将内存赋值给对象phone1。
5.__init__中的self为新创建的空间地址，也就是对象phone1。

 

class Phone:
    # 魔术方法之一： __名字__()-----> 称作魔术方法
    def __init__(self):  # init初始的，初始化--->标准化，保证每一个空间里面都有brand和price两个属性
        self.brand = 'xioami'  # 动态的给self空间中添加了两个属性
        self.price = 4999

    def call(self):  # self是不断变化的
        print('-------->call')
        print('价格', self.price)  # 不能保证每个self里面都有price


p = Phone()
p.call()
p1 = Phone()
p1.price = 5999
p1.call()

'''
-------->call
价格 4999
-------->call
价格 5999
'''

　　

　　其中，self.brand和self.price两句是在执行__init__方法时，在各自的对象内存中动态的创建了各自的属性。

 

class Person:
    def __init__(self, name, age):
        self.name = name
        self.age = age

    def eat(self, food):
        print('{}正在吃{}！'.format(self.name,food))
        print('今年{}岁了'.format(self.age))

    def run(self):
        print('{}，今年{}岁了，正在跑步！'.format(self.name, self.age))


p = Person('李四', '18')
p.name = '李四'
p.age = 20  # 将上面的age=18覆盖
p.eat('红烧肉')
p.run()

p1 = Person('王五', 15)
p1.name = '王三' # 覆盖了上面的name='王五'
p1.age = 25
p1.eat('馒头')
p1.run()
p2 = Person('李琪', 17)
p2.run()

'''
李四正在吃红烧肉！
今年20岁了
李四，今年20岁了，正在跑步！
王三正在吃馒头！
今年25岁了
王三，今年25岁了，正在跑步！
李琪，今年17岁了，正在跑步！
'''

　　

　　可以为方法指定参数，那么不同的对象就有不同的属性和方法。参数需要调用时动态传入。

 

5.类方法

特定：
1、定义需要依赖装饰器@classmethod
2、类方法中的参数不是一个对象（self），而是当前类。
3、类方法中只可以使用类属性。不依赖对象self
4、类方法中不可以使用普通方法。

作用：
　　由于只能访问类属性和方法，所以可以在对象创建之前，完成一些需要的动作（功能）。

class Dog:

    def __init__(self, nickname):
        self.nickname = nickname

    # 普通方法
    def run(self):  # #self-->对象， 这个方法依赖于对象
        print('{}在院子里跑来跑去'.format(self.nickname))

    def eat(self):
        print('吃饭...')
        self.run() # 类方法中的调用，需要通过self.方法名()
    @classmethod
    def test(cls):  # class的简写 类方法依赖于类
        print('------>')
        print(cls)  # <class '__main__.Dog'>
        # print(cls.nickname)  #报错 因为类方法只存在在类空间，不能用对象调用。


dog = Dog('大黄')
dog.run()
dog.eat()
dog.test()
Dog.test() # 可以直接调用类方法

'''
大黄在院子里跑来跑去
吃饭...
大黄在院子里跑来跑去
------>
<class '__main__.Dog'>
------>
<class '__main__.Dog'>
'''

 

修改类属性

 

对象方法可以调用类属性，但是不能修改，只能用类修改。

 

class Person():
    age = 18

    def show(self):
        print('age--------->', Person.age)  # self.age 也可以


p1 = Person()
p1.show()
p1.age = p1.age + 1  # 修改的对象的年龄 --》不能修改
p1.show()

Person.age = Person.age + 1  # 修改的类的年龄
p1.show()

'''
age---------> 18
age---------> 18
age---------> 19
'''

　　

　　应用与实际中，一般不允许外部修改类属性，所有将类属性私有化

 

class Person():
    __age = 18  # 加一个__就变成了私有的

    def show(self):
        print('age-------->', Person.__age)  # self.age 也可以

    @classmethod
    def update_age(cls):
        cls.__age = 20
        print('===更新年龄===')

    @classmethod
    def show_age(cls):
        print('修改后的年龄时{}'.format(cls.__age))


p2 = Person()
p2.show()
Person.update_age()
Person.show_age()

'''
age--------> 18
===更新年龄===
修改后的年龄时20
'''

 

 

 

6.静态方法

静态方法：很类似于类方法
    1.需要装饰器@staticmethod
    2.静态方法是无需去传递参数（cls、self）
    3.里面也只能访问类的属性和方法，对象的是无法访问的
    4.加载的时机同类方法
    
总结：类方法和静态方法
相同点：
    1.只能访问类的属性和方法，对象是无法访问的
    2.都可以通过类名去调用访问
    3.都可以在创建对象之前使用，因为是不依赖于对象
不同点：
    1.装饰器不同，类方法装饰器为@classmethod，静态方法装饰器为@staticmethod
    2.类方法有参数(cls),静态方法没有参数
    
普通方法 与 类方法和静态方法
不同：
    1.普通方法没有装饰器
    2.普通方法永远是依赖对象，因为每个普通方法都有一个self
    3.普通方法在创建了对象才可以调用对象的方法。

class Person():
    __age = 18  # 加一个__就变成了私有的

    def __init__(self, name):
        self.name = name  # 对象的在类方法和静态方法中无法访问

    def show(self):
        print('age-------->', Person.__age)  # self.age 也可以

    @classmethod
    def update_age(cls):
        cls.__age = 20
        print('===更新年龄===')

    @classmethod
    def show_age(cls):
        print('修改后的年龄时{}'.format(cls.__age))

    @staticmethod
    def test():
        print('---------->静态方法')
        # print(self.name) 语法错误
        print(Person.__age)


p2 = Person('Tom')
p2.show()
Person.update_age()
Person.show_age()
Person.test()

'''
age--------> 18
===更新年龄===
===更新年龄===
修改后的年龄时20
---------->静态方法
20
'''