面向对象中级

面向对象中级

abc

November 6, 2022

843views

关闭评论

5861字数

python笔记

## 面向对象中级

### 动静态方法

```python
在类中定义的函数有多种特性
'''
    Author:clever-cat
    time  :2022/11/3-16:26
'''

class Student:
    schoo_name = '清华大学'

"""
    类中直接定义函数 默认绑定给对象 类调用有几个参数传几个 对象
    调用第一个参数就是对象自身
    """
    
    def func1(self):
        print('绑定方法')

# 被@classmenthod修饰的函数 默认绑定给类 类调用第一个参数
    # 类自身 对象也可以调用并且会自动将产生该对象的类当作第一个参数传入

@classmethod
    def func2(cls):
        print('我是类方法 classmenthod', cls)

"""
    普通函数 无论是类还是对象调用 都必须自己手动传参
    
    """

@staticmethod
    def func3(a):
        print('我是静态方法,staticmenthod', a)

st1 = Student()
Student.func1(1231)  # 绑定方法
st1.func1()  # 绑定方法

st1.func2()  # 我是类方法 classmenthod <class '__main__.Student'>
Student.func2()  # 我是类方法 classmenthod <class '__main__.Student'>

st1.func3(1231)  # 我是静态方法,staticmenthod 1231
Student.func3(1231)  # 我是静态方法,staticmenthod 1231

```

### 面向对象之继承的概念

面向对象三大特征

1. 封装

2. 继承

3. 多态

三者中继承最为核心（实操最多 体验最强）
   封装和多态略微抽象

1. 继承的含义
   在现实生中继承表示人与人之间支援的从属关系
      eg:儿子继承父亲 干女儿继承干爹
   在编程世界中继承表示类与类之间资源的从属关系
     eg:类A继承类B

2. 继承的目的
   在现实生活中儿子继承父亲就拥有了父亲所有资源的支配权限
   在编程世界中类A继承类B就拥有了类B中所有的数据和方法使用权限

3. 继承的实操

```python
   
   class Father:
       name = 'Father'
       pass
   
   
   class son(Father):
       name = 'son'
   1.在定义类的时候类名后面可以夹括号填写其它类名 意味着继承其他类
   2.在python中支持多继承 括号内填写多个类名碧池逗号隔开即可
   
   class F1:
       pass
   
   class F2:
       pass
   
   class F3:
       pass
   
   class Son(F1,F2,F3):
       pass
   
   
   1.继承其他类的类 Son
   	我们称之为子类、派生类
   2.被继承的类 F1,F2,F3
   	我们称之为父类、基类、超类
   我们最常用的就是子类和父类
   ```

继承的本质

```python
   """
   对象：数据与方法的结合体
   类(子类)：多个对象相同数据与方法的结合体
   父类：多个类(子类)想要数据与方法的结合体
   类与父类本质都是为了节省代码
   
   """
   ```

继承本质应该分为两个部分

1. 抽象：将多个类相同的东西抽出去形成一个新的类
   2. 继承：将多个类继承刚刚抽象出去的新类

### 名字的查找顺序

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

```
   对象查找名字的顺序
       1.先从对象自己的名称空间中查找
       2.自己没有再去产生该对象的类中查找
       3.如果类中也没有则会报错
       对象 》》》 产生对象的类
   ```

```python
   class Son:
       # name = 'Son'
   
       def func1(self):
           print('Son func1')
   
   
   obj = Son()
   # obj.name = 'All'
   # print(obj.name)  # All 先找对象名称空间
   
   # print(obj.name)  # All 先找对象名称空间  #Son 在查找实例化对象类中的命名空间
   # obj.name = 'All'
   
   
   print(obj.name)  # AttributeError: 'Son' object has no attribute 'name'
   
   ```

2. 单继承情况下名字的查找顺序、
   对象自身》》产生对象的类》》父类

```python
   class A:
       # name = 'A'
       pass
   
   
   class B(A):
       # name = 'B'
       pass
   
   
   class C(B):
       # name = 'C'
       pass
   
   
   # obj = C()
   
   # obj.name = 'ALL'
   # print(obj.name)  # ALL
   
   # print(obj.name)  # C
   # print(obj.name)  # B
   # print(obj.name)  #A
   
   # 查找不到直接报错
   
   # print(obj.name)  # AttributeError: 'C' object has no attribute 'name'
   
   
   # 烧脑小案例
   
   class AA:
       def func1(self):
           print('我是AA func1')
   
       def func2(self):
           print('我是AA func2')
           self.func1()
   
   
   class AB(AA):
       def func1(self):
           print('我是AB func1')
   
   
   obj = AB()
   obj.func2()
   # 我是AA func2
   # 我是AB func1
   """
   1.首先查找自己，没有，去产生对象的类中查找没有
   2.再去父类中查找，查早到，调用，打印 我是AA func2 继续执行，self.func1()
   3.重点看self，类中的绑定方法，谁调用谁是主人公,说要就是obj对象
   4.从obj对象名称空间开始查找
   5.在产生对象的类中找到了，执行代码。打印 我是AB func1
   """
   
   ```

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

1. 菱形继承

广度优先搜索(最后才会找闭环的顶点)

2. 非菱形继承

深度优先搜索(从左往右每条道走完为止)

3. mro()方法了可以直接获取名字的查找顺序

对象自身》》产生对象的类》》父类(从左往右)

```python
   class F1:
       name = 'jason'
       pass
   
   
   class F2:
       # name = 'oscar'
       pass
   
   
   class F3:
       # name = 'jerry'
       pass
   
   
   class S1(F1, F2, F3):
       # name = '嘿嘿嘿'
       pass
   
   
   obj = S1()
   # obj.name = '想干饭'
   print(obj.name)
   
   
   
   '''
       对象自身   >>>   产生对象的类     >>>    父类(从左往右)
   '''
   class G:
       name = 'from G'
       pass
   class A:
       # name = 'from A'
       pass
   class B:
       # name = 'from B'
       pass
   class C:
       # name = 'from C'
       pass
   class D(A):
       # name = 'from D'
       pass
   class E(B):
       # name = 'from E'
       pass
   class F(C):
       # name = 'from F'
       pass
   
   class S1(D,E,F):
       pass
   obj = S1()
   # print(obj.name)
   
   print(S1.mro())
   ```

### 经典类与新式类

1. 经典类：不继承object或者其子类的类

2. 新式类：继承object或者其子类的类

+ 在python2中有经典类与新式类
   + 在python3中只有新式类(所有类默认继承object)

class Student(object):pass

以后在定义的时候 如果没有其他父类继承 也可以习惯性的写上可以增加兼容python2

### 派生方法

```python
# 子类基于父类的方法做了扩展
class Father(object):
    def __init__(self, name, age, pwd):
        self.name = name
        self.age = age
        self.pwd = pwd

class Son(Father):
    def __init__(self, name, age, pwd, gender):
        # 子类调用父类的方法
        super().__init__(name, age, pwd)
        self.gender = gender

obj = Son('张三', 18, '123', 'male')

print(obj.name)  # 张三
print(obj.gender)  # male
```

### super()方法使用注意事项

```python
class E:
    def a(self):
        print('class E')

pass

class A:
    def a(self):
        print('class A')

pass

class B(A):
    def a(self):
        print('class B')

pass

class C(B):
    def a(self):
        print('class C')
        super().a()  # class B
        super(C, self).a()  # class B 正常情况下
        super(B, self).a()  # class A 可以指定重哪个类想向上一级调用父类方法
        # super(A, self).a()  # 可以指定从哪个类想向上一级调用父类方法，如果父级没有则报错
        # super(E, self).a()  # 可以指定从哪个类想向上一级调用父类方法，如果这个类不是本类的父类则报错

pass

obj = C()
obj.a()

print(C.__bases__)

print(C.__base__)
print(C.mro())

```

面向对象中级

abc • 2022 年 11 月 06 日

## 面向对象中级

### 动静态方法

```python
在类中定义的函数有多种特性
'''
    Author:clever-cat
    time  :2022/11/3-16:26
'''

class Student:
    schoo_name = '清华大学'

# 被@classmenthod修饰的函数 默认绑定给类 类调用第一个参数
    # 类自身 对象也可以调用并且会自动将产生该对象的类当作第一个参数传入

@classmethod
    def func2(cls):
        print('我是类方法 classmenthod', cls)

"""
    普通函数 无论是类还是对象调用 都必须自己手动传参
    
    """

@staticmethod
    def func3(a):
        print('我是静态方法,staticmenthod', a)

st1 = Student()
Student.func1(1231)  # 绑定方法
st1.func1()  # 绑定方法

st1.func2()  # 我是类方法 classmenthod <class '__main__.Student'>
Student.func2()  # 我是类方法 classmenthod <class '__main__.Student'>

st1.func3(1231)  # 我是静态方法,staticmenthod 1231
Student.func3(1231)  # 我是静态方法,staticmenthod 1231

```

### 面向对象之继承的概念

面向对象三大特征

1. 封装

2. 继承

3. 多态

三者中继承最为核心（实操最多 体验最强）
   封装和多态略微抽象

2. 继承的目的
   在现实生活中儿子继承父亲就拥有了父亲所有资源的支配权限
   在编程世界中类A继承类B就拥有了类B中所有的数据和方法使用权限

3. 继承的实操

继承的本质

继承本质应该分为两个部分

1. 抽象：将多个类相同的东西抽出去形成一个新的类
   2. 继承：将多个类继承刚刚抽象出去的新类

### 名字的查找顺序

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

2. 单继承情况下名字的查找顺序、
   对象自身》》产生对象的类》》父类

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

1. 菱形继承

广度优先搜索(最后才会找闭环的顶点)

2. 非菱形继承

深度优先搜索(从左往右每条道走完为止)

3. mro()方法了可以直接获取名字的查找顺序

对象自身》》产生对象的类》》父类(从左往右)

### 经典类与新式类

1. 经典类：不继承object或者其子类的类

2. 新式类：继承object或者其子类的类

+ 在python2中有经典类与新式类
   + 在python3中只有新式类(所有类默认继承object)

class Student(object):pass

以后在定义的时候 如果没有其他父类继承 也可以习惯性的写上可以增加兼容python2

### 派生方法

```python
# 子类基于父类的方法做了扩展
class Father(object):
    def __init__(self, name, age, pwd):
        self.name = name
        self.age = age
        self.pwd = pwd

class Son(Father):
    def __init__(self, name, age, pwd, gender):
        # 子类调用父类的方法
        super().__init__(name, age, pwd)
        self.gender = gender

obj = Son('张三', 18, '123', 'male')

print(obj.name)  # 张三
print(obj.gender)  # male
```

### super()方法使用注意事项

```python
class E:
    def a(self):
        print('class E')

pass

class A:
    def a(self):
        print('class A')

pass

class B(A):
    def a(self):
        print('class B')

pass

obj = C()
obj.a()

print(C.__bases__)

print(C.__base__)
print(C.mro())

```

NETFLIX奈非/网飞 2020-7月最新奈非NETFLIX共享账号

校园网快速上线/下线

wifi密码

免费域名

typora markdown基础使用

校园网快速上线/下线

mysql配置与mysql数据类型

网络编程socket粘包解决与进程概念

魔法方法与元类

drf9个视图子类，2个视图集，路由系统，认证组件

面向对象中级