python类和对象

先来看一个类

class Student(object):
    teacher = 'Alice'  # 共有类属性（常量），类和实例方法都可以访问，访问方法：类名.xxx
    
    def __init__(self, age, name):  # 魔法函数，实例化对象时自动调用。实例属性一般放在这里
        self.age = age  # 实例属性,只有类可以访问,访问方法：self.xxx 或者 对象.xxx
        self.name = name
        self._score = 2000  # 浅度私有属性，类和对象都可以访问
        self.__money = 4000  # 深度私有属性，只有类内部可以访问
        
    def info(self, name):  # 这里都函数就是实例方法，或者叫实例对象
        # 在方法内部，可以通过self.属性/方法 来调用或者修改对象的其它属性或者方法。
        # self.name = name # 实例属性，但是一般放在init下面
        pass
    
    @classmethod  # 装饰器的语法糖，java叫注解
    def course(cls):  # 类方法(所有实例方法共有)，cls代表当前类对象
        pass
    
    @staticmethod  # 装饰器的语法糖，java叫注解
    def school():  # 静态方法，可以没有参数/self/cls
      pass
    
    # 可以通过这个方法得到深度私有属性的值。
    def get_money(self):
        print(self.__money)
        
    def __myself(self):  # 私有方法
      pass
    
# 通过类名来访问类属性
print(Student.teacher)
# 实例化对象=实例化类，创建对象。Student是类，stu是对象。根据init函数传参
stu = Student('18', 'lili')
# 通过对象来访问类属性:对象名.属性
print(stu.name)
# 通过对象来调用实例方法:对象名.方法()
stu.info()
# 通过对象来访问浅度私有属性
print(stu._score)
# 通过对象是不能访问到深度私有属性的，下面的print会报错
# print(stu.__money) 
# 可以通过上面定义的获取深度私有属性的函数来获取深度私有属性值
print(stu.get_money())

个人理解

• 属性一般是指变量，也有定义常量属性的
• 在定义类的时候，并不知道对象是谁。用self来表示对象。所以实例化对象是谁，self就代表谁。
• 类里面可以创建多个对象（即函数），每个对象都是独立的，并且每个对象都拥有类里的所有方法。
• 类：抽象的，对象共有的特征。对象：具体的存在，有很多个。
  ==上面的Student是类，传参数后实例赋给stu，stu就是类对象。
  ==定义一个def函数，函数有方法/有参数，这个函数是一个实例对象。
  ==python里面造对象：实例化
• 类名使用大驼峰命名；函数名需要小写，可以使用小驼峰
• 实例属性和类属性的优先级：对于对象（def函数）来说，自己有就用自己的，自己没有就要类的。都没有会报错
• 关于object：python3中，class A 默认类都会继承object；python2中，class A(object)，需要自己带上object

名词解释（公有）

实例属性
在def函数内部定义的属性
类属性
类所有的属性，定义在函数外面，类和实例都可以访问
实例方法
实例方法就是def函数，第一个参数是self。也叫实例对象
类方法
需要修饰器@classmethod，标示其为类方法，类方法的第一个参数必须为类对象，一般用cls表示，通过cls引用的必须是类属性和类方法。
静态方法
需要修饰器@staticmethod，标示其为静态方法。需要做一些功能，和类相关，但不需要类和对象参与，此时可以使用静态方法，静态方法可以不需要参数。
三种方法的区别
实例方法：用self,对象去调用
类方法：@classmethod 修饰，用cls。类和对象都可以调用，一般是类去调用
静态方法：@staticmethod 修饰。没有一定要传self或者cls，类和对象都可以调用
魔法方法
def init(): 函数叫魔法方法，存放实例属性（公共变量）。做初始化的动作，可以初始化函数，实例化对象的时会自动调用

关于私有化

书写格式
1，属性名/方法名
浅度私有，约定俗成的。通过对象.属性名/方法名实际是可以访问的，但它的意思是：别访问我，我是私有的。
2，属性名/方法名
深度私有。通过对象.属性名/方法名不能访问，只有类内部可以访问。
3，_ 和 __ 私有化方式同样在模块(.py)当中也支持。模块内私有，仅想在模块内使用，其它模块导的时候，表示这些不想被外部访问。
什么情况下需要私有化
当模块/类要实现一个大功能，而这个功能由很多个内部的小功能(函数不应该太复杂)组成的。但是这些小功能对于使用者而言不需要看见/不需要使用。我们就会做成私有化。
私有属性
类外通过类对象引用不能直接更改，只能通过实例方法调用类对象更改。
私有方法
只能在类内调用，如果类外调用，则需要类内的公有方法调用类内的私有方法，在类外调用这个公有方法，则间接调用了私有方法。

继承

• 子类可以继承父类
• 浅度私有属性/方法可以继承，深度私有属性/类不可以继承
• 子类继承父类，拥有父类所有属性和方法，除了深度私有化的以外。
• python多继承：可以继承多个父类。但是我们一般只继承一个父类
• 继承的语法：class 子类(父类1, 父类2...):
• 继承后可以做的事
  1，在父类的功能或者属性以外，添加属于你自己的方法/属性。
  2，子类重写父类方法：在父类原有的基础和功能上去优化。
  2.1,不动父类的共能，只增加一些新的功能
  2.2，推翻父类的功能，重新写一遍
• 在与父类同名的方法内，想调用父类的同名方法super（super叫做超类）
• 子类有的用自己的，子类没有的用父类的
• 方法重栽：Java里面有，python里面没有。（处理场景：参数个数不一样，参数类型不一样）

以下是关于继承的简单使用

class Father(object):

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

    def earn_money(self, work):
        print(f'{self.name}通过{work}来赚钱')

    def hobby(self, hobby):
        print(f'{self.name,}的爱好是:{hobby}')


class Son(Father): # 继承父类Father

    # 新增一个实例方法，在父类方法以外，只属于自己的方法
    def study(self, content):
        print("我通过学习 {} 来提升自己".format(content))

    # 定义一个与父类方法重名父的方法，在此方法上新增自己的内容
    def earn_money(self, work):
        # 在与父类同名方法的内，想调用父类的同名方法，使用super（超类）
        print(f'使用父类方法：{super().earn_money(work)}')
        print(f'{self.name} 通过投资理财再赚了2000块钱！！')  # 在父类的基础上，额外增加的

    # 完全重写
    # def earn_money(self, work1):
    #     # 在与父类同名方法,但是我要完全重写。不用父类的代码。
    #     print("{} 通过 {} 来赚米米！".format(self.name, work1))