对象独有的功能

class Person:
    h_type = '人类'

    def __init__(self, name):  # 让对象拥有独有的数据
        self.name = name

    # 定义在类中的函数 我们称之为方法
    def eat(self):  # 是多个对象公共的方法 也算多个对象独有的方法 对象来调用就会将对象当做第一个参数传入
        print('%s正在干饭' % self.name)

    def others(self,a,b):
        print('others哈哈哈')
'''
针对对象独有的方法 我们无法真正实现
    1.如果在全局则不是独有的
    2.如果在类中则是公共的
python解释器针对上述问题添加了一个非常牛的特性
    定义在类中的函数默认是绑定给对象的（相当于是对象独有的方法）
'''
p1 = Person('jason')
p1.eat()  # jason正在干饭
p2 = Person('kevin')
p2.eat()  # kevin正在干饭
# 如何理解绑定二字
p3 = Person('oscar')
Person.eat(p3)  # oscar正在干饭

p1 = Person('jason')
p1.others(1, 2)  # others哈哈哈
Person.others(p1,1,2)  # others哈哈哈

动静态方法

专门针对在类体代码中编写的函数
1.绑定给对象的方法
	直接在类体代码中编写即可
    	对象调用会自动将对象当做第一个参数传入
        类调用则有几个形参就传几个实参
2.绑定给类的方法
3.静态方法（普普通通的函数）
class Student:
    school = '清华大学'

    # 绑定给对象的方法
    def run(self):  # self用于接收对象
        print('老刘赶紧跑！！！', self)

    @classmethod  # 绑定给类的方法
    def eat(cls):  # cls用于接收类
        print('老刘你可真有才', cls)

    @staticmethod  # 静态方法
    def sleep(a, b):  # 无论谁来调用都必须按照普普通通的参数传参方式
        print('老六快去睡觉吧')


stu1 = Student()
# 调用绑定给类的方法
Student.eat()  # 类调用会自动将类当做第一个参数传入  eat(Student)
stu1.eat()  # 对象调用会自动将产生该对象的类当做第一个参数传入
eat(Student)
# 调用静态方法
Student.sleep(1,2)
stu1.sleep(1,2)

面向对象三大特性之继承

"""
面向对象三大特性分别是
	继承、封装、多态
"""
1、继承的含义
	在现实生活中继承其实就是用来描述人与人之间资源的关系
    	eg：儿子继承父亲的财产（拥有了父亲所有的资源）
	在编程世界里继承其实是用来描述类与类之间数据的关系
    	eg：类A继承类B（拥有了类B里面所有的数据和功能）
2、继承的目的
	现实生活中继承就是想占有别人的财产
    	eg：亲身父亲 干爹 干妈 
    编程世界里继承是为了节省代码编写
    	eg：可以继承一个类 也可以继承多个类
3、继承的操作
	class 类名（类名）：
    	pass
    1.定义类的时候在类名后加括号
    2.括号内填写你需要继承的类名
    3.括号内可以填写多个父类 逗号隔开即可
    """
    我们将被继承的类称之为：父类或基类或超类
    我们将继承类的类称之为：子类或派生类
    ps：平时最常用的就是父类和子类
    """
    class Myclass(F1,F2,F3):
    pass
	ps:目前掌握从左到右查找每个父类中的属性即可

名字的查找顺序

# 1.不继承的情况下名字的查找顺序
# 先从对象自身查找 没有的话 再去产生该对象的类中查找
class Student:
    school = '清华大学'

    def choice_course(self):
        print('正在选课')


stu1 = Student()
print(stu1.school)  # 对象查找school 自身名称空间没有 所以查找的是类的 清华大学
stu1.school = '北京大学'  # 在自身的名称空间中产生了新的school
"""对象点名字并写了赋值符号和数据值 那么操作的肯定是自己的名称空间"""
print(stu1.school)  # 北京大学
print(Student.school)  # 清华大学


# 对象>>>类
# 2。单继承的情况下名字的查找顺序
#     先从对象自身查找 然后是产生该对象的类 然后是一个个父类
class A:
    name = 'from A'
    pass


class B(A):
    name = 'from B'
    pass


class C(B):
    name = 'from C'
    pass


class MyClass(C):
    name = 'from MyClass'
    pass
obj = MyClass
obj.name = '我很困呀'
print(obj.name)
# 对象>>>类>>>父类...
class A1:
    def func1(self):
        print('from A1 func1')
    def func2(self):
        print('from A1 func2')
        self.func1()  # obj.func1()
class MyClass(A1):
    def func1(self):
        print('from MyClass func1')
obj = MyClass()
obj.func2()
'''只要涉及到对象查找名字 几乎要回到最开始的位置查找'''
3.多继承的情况下名字的查找顺序
	非菱形继承（最后不会归总到一个我们自定义类上）
    	深度优先（每个分支都走到底 再切换）
    菱形继承（最后归总到一个我们自定义类上）
    	广度优先（前面几个分支都不会走最后一个类 最后一个分支才会走）
 也可以使用类点mro（）方法查看该类产生的对象名字的查找顺序
主要涉及到对象查找名字 几乎都是
	对象自身	类	父类

经典类与新式类及派生

经典类
	不继承object或其子类的类(什么都不继承)
新式类
	继承了object或其子类的类
"""
在python3中所有的类默认都会继承object
	也就意味着python3里面只有新式类
在python2中有经典类和新式类
	由于经典类没有核心的功能 所以到了python3直接砍掉了
	
以后我们在定义类的时候  如果没有想要继承的父类 一般推荐以下写法
    class MyClass(object):
        pass
目的是为了兼容python2
"""
子类中定义类与父类一模一样的方法并且扩展了该功能>>>:派生