Day32 对象的动静态方法 面向对象的三大特性 继承

Day32 对象的动静态方法 面向对象的三大特性 继承

1、对象的独有功能

针对 对象的独有方法我们无法真正实现

1. 如果在全局则不是独有的
2. 如果在类中则是公共的

python解释器针对上诉问题添加了一个非常牛的特性

• 定义在类中的函数默认是绑定给对象（相当于是对象独有的方法）

class Person:
    h_type = '人类'

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

    # 定义 类中的函数 我们称之为 方法
    # 是该类出来的 对象的公共的方法，也是算该类出来的对象的独有方法，对象上来就调用 就会将对象当作第一个参数传入一个参数传入
    def eat(self):
        print(f'{self.name}在干饭')


p1 = Person('kk')
p1.eat()
>>>>>>>>>>>>>>>>>>>>>>>>>>>>
kk在干饭

2、动静态方法

动静态方法算是定义在类体代码中的函数的方式

动态方法

1. 绑定给对象的方法

   1. 直接在类体代码中编写即可
   2. 对象调用会自动将对象当作第一个参数传入
   3. 类调用则有几个形参就传入几个实参

2. 绑定给类的方法

   1. 类调用会自动将类当作第一个参数 作为实参传入

   2. 独享调用会自动将 对象的类当作第一个参数传入

# 对象调用 动态方法
class Person:

    # 定义 类中的函数 我们称之为 方法
    # 是该类出来的 对象的公共的方法，也是算该类出来的对象的独有方法，对象上来就调用 就会将对象当作第一个参数传入一个参数传入
    #动态方法
    def eat(self):
        print('绑定给对象的方法',self)
    @classmethod
    def run(cls):
        print('绑定给类的方法',cls)
    @staticmethod
    def sleep(a,b):
        print('静态方法，是谁类调用都必须自己传参',a,b)



p1=Person()
# 对象 调用 静态方法
p1.eat()
p1.run()
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
绑定给对象的方法 <__main__.Person object at 0x00000240C464E048>
绑定给类的方法 <class '__main__.Person'>

#类调用静态方法
Person.eat('必须嘚传的参数')
Person.run()
>>>>>>>>>>>>>>>>>>>>>>
绑定给对象的方法 必须嘚传的参数
绑定给类的方法 <class '__main__.Person'>

静态方法

• 就是普普通通的函数

• 对象或者类来调用 都必须传固定的参数个数

class Person:

    # 定义 类中的函数 我们称之为 方法
    # 是该类出来的 对象的公共的方法，也是算该类出来的对象的独有方法，对象上来就调用 就会将对象当作第一个参数传入一个参数传入
    #动态方法
    def eat(self):
        print('绑定给对象的方法',self)
    @classmethod
    def run(cls):
        print('绑定给类的方法',cls)
    @staticmethod
    def sleep(a,b):
        print('静态方法，是谁类调用都必须自己传参',a,b)

# 对象调用静态方法
p2=Person()
p2.sleep('第一个参数','第二个参数')

# 类调用 静态方法
Person.sleep('第一个参数','第二个参数')
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
静态方法，是谁类调用都必须自己传参 第一个参数 第二个参数
静态方法，是谁类调用都必须自己传参 第一个参数 第二个参数

3、面向对象 的三大特性之继承

面向对象的三大特性
**继承、封装、多态 **

继承的含义
在现实生活中继承其实就是用来描述人与人之间资源的关系
例如：儿子继承父亲的财产 （拥有父亲的所有资源）
在编程世界里 继承其实就是用来描述 类与类之间的数据关系
例如：类A 继承 类B（拥有了 类B 里面所有的数据与功能）

继承的目的
现实生活中 继承就是向想占有别人的财产
例如：亲生父亲、干爹、富婆
编程世界里 继承就是为了节省代码的编写
例如：可以继承一个类 也可以继承多个类

继承的操作

1. 定义类的时候 需要在类名后面加括号
2. 括号内填写你需要继承的类名
3. 括号内可以填写 多个父类，逗号隔开即可 （可以继承多个类）

class 类名(要继承的类名):
    pass
=============================
class MyClass(A,B,C):
    pass
#当 此时继承多个类时 查找顺序为从左往右

我们将被继承的类称之为：父类 、 基类 、 超生类
将继承类的类称之为：子类、派生类
平常最常用的就是 父类 与 子类

3.1、继承的本质

抽象： 将多给类共同的数据或功能抽取出来形成一个基类

继承： 从上往下白嫖各自基类里面的资源

对象、类、父类的概念规律
对象： 数据功能的结合体
类： 多个对象 相同的数据和功能的结合体
父类： 多个类相同的数据和功能的结合体
类 与 父类 最主要目的 都是为了节省代码

3.2、名字的查找顺序

不继承的情况下 名字的查找顺序

• 先从对象自身潮州啊 如果没有的话 再去 产生 该对象的类中查找

class Person:
    name='jack'

    def eat(self):
        print('绑定给对象的方法',self)


p1=Person()
p1.name='jason'
print(p1.name)
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
jason

当对象本身没有时

#当对象本身没有时
class Person:
    name='jack'

    def eat(self):
        print('绑定给对象的方法',self)


p1=Person()
# p1.name='jason'
print(p1.name)
>>>>>>>>>>>>>>>>>>>>>>>>>
jack

对象 >>> 类

单继承的情况下 名字的查找顺序

• 先从对象自身查找 然后是产生该对象的类 然后是一个个父类

class Person:
    name='jack'

class Stundent(Person):
    naem='oscar'
	pass

p1=Person()
p1.name='jason'
print(p1.name)

对象 >>> 类 >>> 父类

多继承的情况下 名字的查找顺序

1. 非菱形继承

   ​ 深度优先（每个分支都走到底 再切换）

2. 菱形继承（最后归总到一个自定义类上）

   ​ 广度优先（前几个分支都不会走到最后一个类 最后一个分支才会走到底）

可以通过类 .mro()方法查看该类产生的对象名字的查找顺序

只要涉及到对象的查找顺序 那么几乎都是：

对象自身>>> 类>>> 父类

3.3、经典类与新式类

经典类

• 不继承object或其子类的类（什么都不继承）

新式类

• 继承了object或其他子类

在python3 中所有类都会默认继承object
意味着python3 里面只有新式类

在python2 中有经典类 和 新式类
由于我们在定义类的时候 如果没有想要继承的父类 一般推荐直接继承object

class MyClass(object):
    pass

• 这样可以让让代码 兼容python2

3.4、派生方法

派生：

子类 中 定义类与父类 一摸一样的方法并且扩展了该功能

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

class Stundent(Person):
    def __init__(self,name,age,gender,student_id,):
        super().__init__(name,age,gender)
        self.student_id=student_id
        self.gender=gender

p1=Stundent('jack',18,'male',10,)
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
{'name': 'jack', 'age': 18, 'gender': 'male', 'student_id': 10}

作业

2、利用派生重写列表、字典、字符串的常见方法 自己添加功能

# 只能添加 整型
class MyClass(list):
    def append(self, args):
        if not type(args) == int:
            print('只能添加整数')
            return
        super().append(args)


p1 = MyClass()
p1.append(12)
p1.append('13')
print(p1)
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
只能添加整数
[12]