【Python】学习笔记总结2（Python面向对象）

﹏ヽ暗。殇╰゛Y 2023-02-27 15:54 43阅读 0赞

### 文章目录 ###

*  二、Python面向对象
 *   *  1.类（Class）
     *   *  1.1.定义类
         *  1.2.类属性
         *  1.3.实例属性
         *   *  1.3.1.内部添加
             *  1.3.2.外部添加
         *  1.4.实例方法
         *  1.5.类方法
         *  1.6.静态方法
         *  1.7.\_\_init\_\_方法（初始化）
         *  1.8.Self(当前对象的引用)
         *  1.9.魔术方法
         *   *  1.9.1.魔术方法介绍大全
     *  2.方法、继承、多态
     *   *  2.1.析构方法\`\_\_del\_\_ \`
         *   *  2.1.1.释放对象时调用
             *  2.1.2.手动清空对象
         *  2.2.继承
         *   *  2.2.1.单继承
             *  2.2.2.多继承
             *  2.2.3.重写父类方法
             *  2.2.4.重写\`\_\_init\_\_\`方法
             *  2.2.4多态
         *  2.3类属性和实例属性区别
         *  2.4类方法和实例方法和静态方法
     *  3.封装与单例
     *   *  3.1.封装
         *  3.2.单例模式
         *  3.3.异常处理
         *   *  3.3.1.异常类型
             *  3.3.2.自定义异常类型
         *  3.4.动态添加属性和方法

# 二、Python面向对象 #

## 1.类（Class） ##

### 1.1.定义类 ###

class Person :
        name = '小明'#类属性
        age = '20'#类属性
        def eat(self):
            print('吃饭')
            pass
        pass

*  使用

xiaoming =  Person()

### 1.2.类属性 ###

在类的内部，使用def关键字定义且有类似(self)的，使用权归实例所有

name = '小明'#类属性

### 1.3.实例属性 ###

#### 1.3.1.内部添加 ####

在方法的内部，使用self引用的属性

def __init__(self):
            self.friend = '小红'

#### 1.3.2.外部添加 ####

class People :
        def eat(self):
            print(self)
            pass
        pass
    
    xiaoming = People()
    xiaoming.name = '小明'
    xiaoming.age = 20
    print(xiaoming.name)

### 1.4.实例方法 ###

在类的内部，使用def关键字定义且有类似(self)的，使用权归实例所有

def eat(self):
            print('吃饭')
            pass
        pass

### 1.5.类方法 ###

类对象所拥有的方法，用装饰器@classmethod来标  
识其为类方法，对于类方法，第一个参数必须是类对象，  
一般以cls作为第- -个参数，  
类方法可以通过类对象，实例对象调用

类方法可以访问、修改类属性

name = '小明'
        @classmethod
        def findNameInfo(cls):
            return cls.name
            pass

### 1.6.静态方法 ###

静态方法不需要传参例如（cls/self）  
静态方法不可以访问类属性  
通常用类直接访问静态方法，本身和类与实例无关

import time
    class Test :
        def __init__(self,hour,min,second):
            self.hour = hour
            self.min = min
            self.second = second
    
        @staticmethod
        def showTime():
            return time.strftime("%H:%M:%S" ,time.localtime())
        pass
    pass
    
    print(Test(1,2,3).showTime())

### 1.7.\_\_init\_\_方法（初始化） ###

\*类似于构造函数，对self的属性进行构造  
自动执行的初始化方法,自带的内置函数

class People :
        def __init__(self,name,age):
            self.name = name
            self.age = age
            pass
        def showInfo(self):
            print(self.name+'年龄'+self.age)
            pass
        pass
    
    xiaoming = People('小明',20)

### 1.8.Self(当前对象的引用) ###

实例化后，python解释器会把当前对象自动传递给self

### 1.9.魔术方法 ###

*  `__str__`  
    打印时调用的方法

class People :
        def __init__(self,name,age):
            self.name = name
            self.age = age
            pass
        def __str__(self):
            return  '姓名：%s 年龄：%d'%(self.name,self.age)
            pass
        pass
    
    xiaoming = People('小明',20)
    print(xiaoming)

*  `__new__`  
    创建对象实例的方法，调用一次就会生成新的对象cls（class）cls自动提供  
    真正创建实例的方法，经常单例模式使用，必须返回实例

class People :
        def __init__(self,name,age):
            self.name = name
            self.age = age
            print('__init__')
            pass
        def __new__(cls, *args, **kwargs):
            print('__new__')
            return object.__new__(cls)
            pass
        pass
    
    xiaoming = People('小明',20)

*  区别`__new __`和`__init__`

*  `__new __`类的实例化方法必须要返回该实例否则对象就创建不成功
 *  `__init__`用来做数据属性的初始化工作也可以认为是实例的构造方法接受类的实例self并对其进行构造
 *  `__new __`至少有一个参数是cls代表要实例化的类，此参数在实例化时由python解释器自动提供
 *  `__new __`函数执行要是于`__init__`函数

#### 1.9.1.魔术方法介绍大全 ####

[魔术方法介绍大全][Link 1]

## 2.方法、继承、多态 ##

### 2.1.析构方法`__del__` ###

当一个对象被删除或者被销毁时，python解释器也会默认调用一个方法，这个方法为`__del__ ()`方  
法，也称为析构方法

#### 2.1.1.释放对象时调用 ####

class People :
        def __init__(self,name,hp):
            self.name = name
            self.hp = hp
            pass
        def __del__(self):
            print('销毁了')
            pass
    
        pass
    
    xiaohong = People('xiaohong',100)

#### 2.1.2.手动清空对象 ####

del xiaohong

### 2.2.继承 ###

#### 2.2.1.单继承 ####

class Animal :
        def eat(self):
            print('吃')
            pass
        pass
    
    class Dog(Animal) :
        def wwj(self):
            print('汪汪叫')
            pass
        pass

#### 2.2.2.多继承 ####

class Animal :
        def eat(self):
            print('吃')
            pass
        pass
    
    class God:
        def fly(self):
            print('飞')
            pass
        pass
    
    class Wukong(Animal,God):
        def Dayaoguai(self):
            print('打妖怪')
            pass
        pass

*  多继承，同名方法查找父类，如没有则向父类的父类查找（广度优先）
 *  `__mro__`方法解析顺序，用来了解继承顺序

#### 2.2.3.重写父类方法 ####

class Animal :
        def eat(self):
            print('吃')
            pass
        pass
    
    class Dog(Animal) :
        def eat(self):
            print('大口吃')
            pass
        pass

#### 2.2.4.重写`__init__`方法 ####

class People :
        def __init__(self,name,hp):
            self.name = name
            self.hp = hp
            print('调用People__init__')
            pass
        pass
    
    class Man(People):
        def __init__(self,name,hp):
            People.__init__(self,name,hp)#调用父类方法1
            #super().__init__(name,hp)#调用父类方法2,可在父类逐个查找
            print('调用Man__init__')
            pass
    
        pass
    
    man = Man('xxx',100)

#### 2.2.4多态 ####

继承并扩展父类代码，不需要修改父类代码

class Animal :
        def eat(self):
            print('吃')
            pass
        pass
    
    class Dog(Animal) :
        def eat(self):
            print('大口吃')
            pass
        pass
    
    class Cat(Animal) :
        def eat(self):
            print('小口吃')
            pass
        pass
    
    
    def commonInvoke(obj) :
        obj.eat()
    
        listObj = [Animal(),Cat(),Dog()]
    
        for item in listObj :
            commonInvoke(item)

### 2.3类属性和实例属性区别 ###

![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzI1NjAxMzQ1_size_16_color_FFFFFF_t_70]  
实例对象不可以修改类属性，类属性所有权归类所有

### 2.4类方法和实例方法和静态方法 ###

1.类方法的第一个参数是类对象cls，通过cls引用的类对象的属性和方法  
2.实例方法的第一个参数是实例对象self,通过self引用的可能是类属性、也有可能是实例属  
性(这个需要具防分析)，不过在存在相同名称的类属性和实例属性的情况下，实例属性优先  
级更高。  
3.静态方法中不需要额外定义参数，因此在静态方法中引用类属性的话，必须通过类对象来引  
用。

## 3.封装与单例 ##

### 3.1.封装 ###

*  属性私有化，无法外部访问，不能被继承，只能内部类使用

class Person :
    	__age = 20 #类属性私有化
        def __init__(self):
            self.__name = '小明'#实例属性私有化
            pass
        pass

*  方法私有化，无法外部访问，不能被继承，只能内部类使用

class Person :
        def __run(self): #实例方法私有化
            print('跑')
            pass
        pass

*  下划线类型

<table> 
 <thead> 
  <tr> 
   <th>下划线</th> 
   <th>说明</th> 
  </tr> 
 </thead> 
 <tbody> 
  <tr> 
   <td><code>_xxx</code></td> 
   <td>protected类型（只允许本身和子类访问）</td> 
  </tr> 
  <tr> 
   <td><code>__xxx</code></td> 
   <td>private类型（只允许本身访问）</td> 
  </tr> 
  <tr> 
   <td><code>__xxx__</code></td> 
   <td>魔术方法，Python内置方法</td> 
  </tr> 
  <tr> 
   <td><code>xxx_</code></td> 
   <td>避免属性名与python关键字冲突</td> 
  </tr> 
 </tbody> 
</table>

*  property（属性函数）
 *  类属性的方式实现

class Person :
        def __init__(self):
            self.__name = '小明'
            pass
        def get_name(self):
            return self.__name
        def set_name(self,name):
            if name < 0:
                print('no')
            else :
                self.__name = name
                pass
    
        name = property(get_name, set_name)
    pass
    person = Person()
    print(person.name)#访问类属性name

*  装饰器方式实现

class Person :
        def __init__(self):
            self.__name = '小明'
            pass
        @property #添加装饰器 添加属性标志
        def name(self):
            return self.__name
        @name.setter #提供一个setter方法
        def name(self,name):
            if name == '小明':
                print('no')
            else :
                self.__name = name
                pass
    pass
    person = Person()
    person.name = '小红'
    print(person.name)#访问类属性name

*  `__new__`实例化方法

class Person :
        def __init__(self):
            self.__name = '小明'
            pass
        def __new__(cls, *args, **kwargs):
            return super().__new__(cls, *args, **kwargs)
            pass
        pass

### 3.2.单例模式 ###

不能使用自身new方法，会产生深度递归

class Person :
        __instance = None
        def __new__(cls, *args, **kwargs):
            if not hasattr(cls,'_instance') :
                cls.__instance = super().__new__(cls, *args, **kwargs)
            return cls.__instance
            pass
        pass

### 3.3.异常处理 ###

try
      #可能出现错误的代码块
    except:
     #出错之后执行的代码块
    else:
     #没有出错的代码块
    finally:
     #不管出没出错都会执行的代码块

根据错误类型来捕获的（NameError 、IndexError …）  
自上而下依次判断

try :
        print(b)
        li = [1,2,3,4]
        print(li[100])
    except NameError as msg:
        print('出错')
        print(msg)
    except IndexError as msg:
        print('出错')
        print(msg)
    except Exception as msg:#所有异常
        print('出错')
        print(msg)

#### 3.3.1.异常类型 ####

当前函数没找到，则向上层一层层传递查找

<table> 
 <thead> 
  <tr> 
   <th>异常</th> 
   <th>导致的错误</th> 
  </tr> 
 </thead> 
 <tbody> 
  <tr> 
   <td>AssertionError</td> 
   <td>当assert语句失败时引发。</td> 
  </tr> 
  <tr> 
   <td>AttributeError</td> 
   <td>当 属性分配或引用失败时引发。</td> 
  </tr> 
  <tr> 
   <td>EOFError</td> 
   <td>当input()函数达到文件结束条件时引发。</td> 
  </tr> 
  <tr> 
   <td>FloatingPointError</td> 
   <td>当浮 点运算失败时引发。</td> 
  </tr> 
  <tr> 
   <td>GeneratorExit</td> 
   <td>调用 生成器的close()方法时引发。</td> 
  </tr> 
  <tr> 
   <td>ImportError</td> 
   <td>找不到导入的模块时引发。</td> 
  </tr> 
  <tr> 
   <td>IndexError</td> 
   <td>当序 列的索引超出范围时引发。</td> 
  </tr> 
  <tr> 
   <td>KeyError</td> 
   <td>在字典中找不到键时引发。</td> 
  </tr> 
  <tr> 
   <td>KeyboardInterrupt</td> 
   <td>当用户 按下中断键(Ctrl+c或delete)时引发。</td> 
  </tr> 
  <tr> 
   <td>MemoryError</td> 
   <td>当操作耗尽内存时引发。</td> 
  </tr> 
  <tr> 
   <td>NameError</td> 
   <td>在局部或全局范围内找不到变量时引发。</td> 
  </tr> 
  <tr> 
   <td>NotImplementedError</td> 
   <td>由抽象方法提出。</td> 
  </tr> 
  <tr> 
   <td>OSError</td> 
   <td>当系统操作导致系统相关错误时引发。</td> 
  </tr> 
  <tr> 
   <td>Overf lowError</td> 
   <td>当算术运算的结果太大而无法表示时引发。</td> 
  </tr> 
  <tr> 
   <td>ReferenceError</td> 
   <td>使用弱引用代理访问垃圾收集的引用时引发。</td> 
  </tr> 
  <tr> 
   <td>Runt imeError</td> 
   <td>当错误不属于任何其他类别时引发。</td> 
  </tr> 
  <tr> 
   <td>StopIteration</td> 
   <td>函数引发，以指示迭代器不再返回任何项。</td> 
  </tr> 
  <tr> 
   <td>SyntaxError</td> 
   <td>遇到语法错误时由解析器引发。</td> 
  </tr> 
  <tr> 
   <td>Indentat ionError</td> 
   <td>当缩进不正确时引发。</td> 
  </tr> 
  <tr> 
   <td>TabError</td> 
   <td>当缩进由不一致的制表符和空格组成时引发。</td> 
  </tr> 
  <tr> 
   <td>SystemError</td> 
   <td>当解释器检测到内部错误时引发。</td> 
  </tr> 
  <tr> 
   <td>Sys temExit</td> 
   <td>由sys. exit()函数引发。</td> 
  </tr> 
  <tr> 
   <td>TypeError</td> 
   <td>将函数或操作应用于类型不正确的对象时引发。</td> 
  </tr> 
  <tr> 
   <td>UnboundLocalError</td> 
   <td>当在函数或方法中引用局部变量，但没有将值绑定到该变量时引发。</td> 
  </tr> 
  <tr> 
   <td>UnicodeError</td> 
   <td>当 发生与unicode相关的编码或解码错误时引发。</td> 
  </tr> 
  <tr> 
   <td>UnicodeEncodeError</td> 
   <td>当编码过程中发生与unicode相关的错误时引发。</td> 
  </tr> 
  <tr> 
   <td>UnicodeDecodeError</td> 
   <td>当解码过程中出现与unicode相关的错误时引发。</td> 
  </tr> 
  <tr> 
   <td>UnicodeTrans lateError</td> 
   <td>翻译过程中发生与unicode相关的错误时引发。</td> 
  </tr> 
  <tr> 
   <td>ValueError</td> 
   <td>当函数得到类型正确但值不正确的参数时引发。</td> 
  </tr> 
  <tr> 
   <td>ZeroDivisionError</td> 
   <td>当除法或模运算的第二个操作数为零时引发。</td> 
  </tr> 
 </tbody> 
</table>

#### 3.3.2.自定义异常类型 ####

class LenException(Exception):
    
        def __init__(self,leng):
    
            self.len = leng
            pass
    
        def __str__(self):
            return '长度超了'
            pass
    
    def name_Test():
    
        try :
            name = '1111111111'
            if len(name)>5:
                raise LenException(len(name))
            else:
                print(name)
                pass
            pass
        except LenException as msg:
            print(msg)
    pass
    
    
    name_Test()

### 3.4.动态添加属性和方法 ###

*  动态添加属性

class Student :
        def __init__(self,name):
            self.name = name
            pass
        def __str__(self):
            return '姓名:%s' %(self.name)
    student = Student('小明')
    student.age = 20 # 动态添加实例属性
    Student.age = 20 # 动态添加类属性
    print(student)
    print(student.age)

*  动态添加实例方法

import types #添加方法的库
    
    def runA(self):
        print(self.name)
        pass
    
    class Student :
        def __init__(self):
            self.name = '小明'
            pass
        pass
    stu = Student()
    stu.run = types.MethodType(runA , stu)#动态添加实例方法
    stu.run()#调用

*  动态添加类方法

@classmethod
    def runA(self):
        print(self.name)
        pass
    
    class Student :
        name = '小明'
        pass
    Student.run = runA#动态添加实例方法
    Student.run()#调用

*  动态添加静态方法

@staticmethod
    def runA():
        print('55555')
        pass
    
    class Student :
        name = '小明'
        pass
    Student.run = runA#动态添加实例方法
    Student.run()#调用

*  `__slots__`属性  
    来限制该class能添加的属性。  
    子类不会继承，只有在当前类中有效。  
    子类声明`__slots__`属性才会继承
 *  限制添加的属性

class Student(object) :
        __slots__ = ('name','age') # 限制添加的属性，避免存储多余的数据
        def __str__(self):
            return '{},{}' .format(self.name,self.age)
            pass
        pass
    
    stu = Student()
    stu.name = '1'
    stu.age = 20
    stu.high = 20 # 添加不了报错了
    print(stu)
    print(stu.__dict__)#所有可以用的属性都在这里，占空间大
    print(stu.__slots__ )#存储限制添加的属性，避免存储多余的数据

*  `__call__`属性

class Student(object) :
        def __call__(self, *args, **kwargs):
            print('1111')
        pass
    
    stu = Student()
    stu()

[Link 1]: https://www.cnblogs.com/nmb-musen/p/10861536.html
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzI1NjAxMzQ1_size_16_color_FFFFFF_t_70]: /images/20230209/b96e8807b880471e936596a0115b321c.png