Python 基础入门笔记（四）——— 文件操作、面向对象、异常、模块包

左手的ㄟ右手 2023-10-11 17:02 12阅读 0赞

#### 文章目录 ####

*  一、文件操作
 *   *  1.1 文件的基本操作
     *   *  1.1.1 打开
         *  1.1.2 打开文件模式
         *  1.1.3 文件对象方法
         *   *  1.1.3.1 写
             *  1.1.3.2 读
             *  1.1.2.3 seek()
         *  1.1.4 关闭
     *  1.2 文件备份
     *  1.3 文件和文件夹操作
     *   *  1.3.1 文件/文件夹重命名
         *  1.3.2 删除文件
         *  1.3.3 创建文件夹
         *  1.3.4 删除文件夹
         *  1.3.5 获取当前目录
         *  1.3.6 改变默认目录
         *  1.3.7 获取目录列表
 *  二、面向对象基础
 *   *  2.1 面向对象的实现方法
     *   *  2.1.1 定义类
         *  2.1.2 创建对象
         *  2.1.3 self
     *  2.2 添加和获取对象属性
     *  2.3 魔法方法
     *   *  2.3.1 \_\_init\_\_()
         *  2.3.2 \_\_str\_\_()
         *  2.3.3 \_\_del\_\_()
 *  三、面向对象继承
 *   *  3.1 旧式类与新式类
     *  3.2 单继承
     *  3.3 多继承
     *  3.4 子类重写父类同名方法和属性
     *  3.5 子类调用父类同名方法和属性
     *  3.6 多层继承
     *  3.7 super()调用父类方法
     *  3.8 私有权限
 *  三、面向对象其他
 *   *  3.1 面向对象三大特征
     *  3.2 多态
     *  3.3 类属性和实例属性
     *   *  3.3.1 类属性
         *  3.3.2 实例属性
     *  3.4 类方法和静态方法
     *   *  3.4.1 类方法
         *  3.4.2 静态方法
 *  四、异常
 *   *  4.1 异常语法
     *  4.2 自定义异常
 *  五、模块和包
 *   *  5.1 导入模块
     *   *  5.1.1 导入方式
         *  5.1.2 定义别名
     *  5.2 自定义模块
     *  5.3 模块定位顺序
     *  5.4 all 列表
     *  5.5 包
     *   *  5.5.1 导包方式
         *  5.5.2 注意事项

--------------------

## 一、文件操作 ##

### 1.1 文件的基本操作 ###

#### 1.1.1 打开 ####

打开文件操作步骤：

1.  打开文件
2.  读写等操作
3.  关闭文件

用 open 函数，打开已经存在的文件，或者创建一个新文件，**语法：** `open(name, mode)`

*  `name`：是要打开的目标文件名的字符串（可以包含文件所在的具体路径）。
 *  `mode`：设置打开文件的模式（访问模式）：只读、写入、追加等。

#### 1.1.2 打开文件模式 ####

<table> 
 <thead> 
  <tr> 
   <th>模式</th> 
   <th align="left">描述</th> 
  </tr> 
 </thead> 
 <tbody> 
  <tr> 
   <td><code>r</code></td> 
   <td align="left">以只读方式打开文件。文件的指针将会放在文件的开头。这是默认模式。</td> 
  </tr> 
  <tr> 
   <td><code>rb</code></td> 
   <td align="left">以二进制格式打开一个文件用于只读。文件指针将会放在文件的开头。这是默认模式。</td> 
  </tr> 
  <tr> 
   <td><code>r+</code></td> 
   <td align="left">打开一个文件用于读写。文件指针将会放在文件的开头。</td> 
  </tr> 
  <tr> 
   <td><code>rb+</code></td> 
   <td align="left">以二进制格式打开一个文件用于读写。文件指针将会放在文件的开头。</td> 
  </tr> 
  <tr> 
   <td><code>w</code></td> 
   <td align="left">打开一个文件只用于写入。如果该文件已存在则打开文件，并从开头开始编辑，即原有内容会被删除。如果该文件不存在，创建新文件。</td> 
  </tr> 
  <tr> 
   <td><code>wb</code></td> 
   <td align="left">以二进制格式打开一个文件只用于写入。如果该文件已存在则打开文件，并从开头开始编辑，即原有内容会被删除。如果该文件不存在，创建新文件。</td> 
  </tr> 
  <tr> 
   <td><code>w+</code></td> 
   <td align="left">打开一个文件用于读写。如果该文件已存在则打开文件，并从开头开始编辑，即原有内容会被删除。如果该文件不存在，创建新文件。</td> 
  </tr> 
  <tr> 
   <td><code>wb+</code></td> 
   <td align="left">以二进制格式打开一个文件用于读写。如果该文件已存在则打开文件，并从开头开始编辑，即原有内容会被删除。如果该文件不存在，创建新文件。</td> 
  </tr> 
  <tr> 
   <td><code>a</code></td> 
   <td align="left">打开一个文件用于追加。如果该文件已存在、文件指针将会放在文件的结尾。也就是说，新的内容将会被写入到已有内容之后。如果该文件不存在，创建新文件进行写入。</td> 
  </tr> 
  <tr> 
   <td><code>ab</code></td> 
   <td align="left">以二进制格式打开一个文件用于追加。如果该文件已存在，文件指针将会放在文件的结尾。也就是说，新的内容将会被写入到已有内容之后。如果该文件不存在，创建新文件进行写入。</td> 
  </tr> 
  <tr> 
   <td><code>a+</code></td> 
   <td align="left">打开一个文件用于读写。如果该文件已存在，文件指针将会放在文件的结尾。文件打开时会是追加模式。如果该文件不存在，创建新文件用于读写。</td> 
  </tr> 
  <tr> 
   <td><code>ab+</code></td> 
   <td align="left">以二进制格式打开一个文件用于追加。如果该文件已存在，文件指针将会放在文件的结尾。如果该文件不存在，创建新文件用于读写。</td> 
  </tr> 
 </tbody> 
</table>

**注意：**

*  基本模式有：`r w a`，其他的模式是在其基础上泛生而来。
 *  模式中带有 b，代表二进制。模式中带有 +，代表可读可写。

**示例1：**

# r: 如果文件不存在，则报错：不支持写入操作，表示只读
    f = open('test.txt', 'r')
    # f = open('test1.txt', 'r')  # 文件不存在，报错
    # f.write('aa')  # 报错
    con = f.read()
    print(con)
    f.close()
    
    # w：只写，如果文件不存在，新建文件：执行写入，会覆盖原有内容
    f = open('text1.txt', 'w')
    f.write('bbb')
    f.close()
    
    # a：追加，如果文件不存在，新建文件：在原有内容基础上，追加新内容
    f = open('test.txt', 'a')
    f.write('lalala')
    f.close()
    
    # 访问模式参数可以省略，如果省略表示访问模式为 r
    f = open('text.txt')
    f.close()

**示例2：**

# w+：没有该文件会新建；w 特点，文件指针在开头，用新内容覆盖原内容
    # 如果只读不写，文件内容会空
    f = open('test.txt', 'w+')
    f.write("haha")  # 此时文件新内容覆盖原内容，文件指针在末尾
    con = f.read()  # 因此接着读，将不会读出内容
    print(con)
    f.close()

--------------------

#### 1.1.3 文件对象方法 ####

##### 1.1.3.1 写 #####

**语法：** `文件对象.write( '内容')`

# 1. 打开文件
    f = open('test.txt', 'w')
    # 2.文件写入
    f.write('hello world')
    # 3. 关闭文件
    f.close()

**注意：**

1.  w 和 a 模式：如果文件不存在则创建该文件如果文件存在，w 模式先清空再写入，a 模式直接末尾追加。
2.  r 模式：如果文件不存在则报错。

--------------------

##### 1.1.3.2 读 #####

*  设 test.txt 文件中内容如下：  
    ![在这里插入图片描述][97f682e18266415eae25364a66543ee1.png_pic_left]
 *  `read()`
    
    **语法：** `文件对象.read( num)`  
    num 表示要从文件中读取的数据的长度（单位是字节)，如果没有传入 num，那么就表示读取文件中所有的数据。
    
        f = open('test.txt', 'r')
        # 换行符 \n 会有字节占位
        # read 不写参数表示读取所有
        print(f.read())
        print(f.read(4))  # 此时文件的指针在末尾， 所以不会读取任何数据
        f.close()
    
    结果如下：  
    ![在这里插入图片描述][1717c6342a2d4a3cac2d550a23a3d5a3.png_pic_left]
 *  `readlines()`
    
    readlines 可以按照行的方式把整个文件中的内容进行一次性读取，并且返回的是一个列表，其中每一行的数据为一个元素。
    
        f = open('test.txt', 'r')
        con = f.readlines()
        print(con)  # ['aaa\n', 'bbb\n', 'ccc']
        f.close()
 *  `readline()`  
    readline 每次打印一行数据，文件指针会后移。
    
        f = open('test.txt', 'r')
        con = f.readline()
        print(f'第⼀⾏：{
                con}')
        con = f.readline()
        print(f'第二⾏：{
                con}')
        con = f.readline()
        print(f'第三⾏：{
                con}')
        f.close()
    
    结果如下：  
    ![在这里插入图片描述][9880cbf551b04741a0a62c1c873f28d1.png_pic_left]

--------------------

##### 1.1.2.3 seek() #####

**作用：** 用来移动文件指针

**语法：** `文件对象.seek(偏移量，起始位置)`

**起始位置：** 0：文件开头 1：当前位置  2：文件结尾

f = open('test.txt', 'r+')
    f.seek(2, 0)  # 开头偏移两个字符
    con = f.read()
    print(con)
    f.close()

结果如下：  
![在这里插入图片描述][54c5520dcb114ee8a1e6fba4f316637f.png]

--------------------

#### 1.1.4 关闭 ####

`文件对象.close()`

--------------------

### 1.2 文件备份 ###

**备份文件步骤：**

1.  接收用户输入的文件名
2.  规划备份文件名
3.  备份文件写入数据

代码如下：

# 1. 用户输入目标文件名字 
    old_name = input('请输入要备份的文件名：')
    
    # 2. 规划备份文件的名字
    # 2.1 提取目标文件后缀
    index = old_name.rfind('.')  # 从右侧找 '.'，如：sound.txt.mp3  是 mp3 文件类型
    
    if index > 0: # 限制文件格式为 “xxx.后缀” 才可备份 
        postfix = old_name[index:]
    
    # 2.2 组织备份文件名， xx[备份]后缀
    new_name = old_name[:index] + '[备份]' + postfix
    
    # 3. 备份文件写入数据（数据和原文件一样）
    # 3.1 打开 原文件 和 备份文件
    old_f = open(old_name, 'rb')  # 以二进制打开
    new_f = open(new_name, 'wb')
    
    # 3.2 原文件读取，备份文件写入
    # 如果不确定目标文件大小，循环读取写入，当读取出来的数据没有了则终止循环
    while True:
        con = old_f.read(1024)
        if len(con) == 0:
            break
        new_f.write(con)
    
    # 3.2 关闭文件
    old_f.close()
    new_f.close()

--------------------

### 1.3 文件和文件夹操作 ###

在 Python 中文件和文件夹的操作要借助 os 模块里面的相关功能。

导入 os 模块：`import os`

#### 1.3.1 文件/文件夹重命名 ####

`os.rename(目标文件名,新文件名)`

#### 1.3.2 删除文件 ####

`os.remove(目标文件名)`

#### 1.3.3 创建文件夹 ####

`os.mkdir(文件夹名字)`

#### 1.3.4 删除文件夹 ####

`os.rmdir(文件夹名字)`

#### 1.3.5 获取当前目录 ####

`os.getcwd()`

#### 1.3.6 改变默认目录 ####

`os.chdir(目录)`

#### 1.3.7 获取目录列表 ####

`os.listdir(⽬目录)`

**应用：批量重命名**

# flag = 1：把文件夹所有文件重命名 python-xxx
    # flag = 2：删除python-重命名
    
    import os
    
    # 构造内置条件的数据
    flag = 2
    
    # 1. 找到所有文件：获取文件夹的目录列表
    file_list = os.listdir()
    print(file_list)
    
    # 2. 重构名字
    for i in file_list:
        if flag == 1:
            new_name = 'python-' + i
        elif flag == 2:
            num = len('python-')
            new_name = i[num:]
    
    	# 3. 重命名
        os.rename(i, new_name)

--------------------

## 二、面向对象基础 ##

### 2.1 面向对象的实现方法 ###

#### 2.1.1 定义类 ####

**语法：**

class 类名():
    	代码
    	......

**注意：** 类名遵循大驼峰命名习惯，即首字母大写

扩展

#### 2.1.2 创建对象 ####

**语法：** `对象名 = 类名()`

**注意：** 创建对象的过程也叫实例化对象。

#### 2.1.3 self ####

self 指的是调用该函数的对象。

**示例：**

# 定义洗衣机类
    class Washer():
        def wash(self):
            print("洗衣服")
            print(self)
    
    # 创建对象
    haier1 = Washer()
    print(haier1)  # <__main__.Washer object at 0x000001455A806D70>
    
    # 使用实例方法
    haier1.wash()  # 洗衣服
                   # <__main__.Washer object at 0x000001455A806D70>
                   # self 指的是调用该函数的对象
                   # self 和 对象得到的结果是一致的，都是当前对象的内存中存储地址。
    
    # 创建两个对象
    haier2 = Washer()  # 不同对象存储地址不一样
    print(haier2)

--------------------

### 2.2 添加和获取对象属性 ###

添加对象属性的方式有两种：类外面添加、类里面添加

1.  **类外面添加和获取对象属性**
    
    语法：`对象名.属性名`
2.  **类里面添加获取对象属性**
    
    语法：`self.属性名`

**示例：**

class Washer():
    	def __init__(self):
            self.height = 300  # 类内 添加属性，一般在 __init()__ 方法中添加类内属性，即实例属性
            
        def print_info(self):
            print(f'洗衣机的宽度：{
          self.width}')  # 类内 获取属性
    
    haier = Washer()
    haier.width = 400  # 类外 添加属性
    print(f'洗衣机的宽度：{
          haier.width}')  # # 类外 获取属性
    
    haier.print_info()

--------------------

### 2.3 魔法方法 ###

`__xx__()` 的函数叫做魔法方法，指的是具有特殊功能的函数。

#### 2.3.1 **init**() ####

`__init__()` 方法的作用：初始化对象，分为带参数和不带参数两种。

1.  不带参数：
    
        class Washer():
            # __init__ 初始化
            def __init__(self):
                self.width = 400
                self.height = 400
        
            def print_info(self):
                print(f'洗衣机的宽度：{
                self.width}')  # 洗衣机的宽度：400
                print(f'洗衣机的宽度：{
                self.width}')  # 洗衣机的宽度：400
        
        haier = Washer()
        haier.print_info()
2.  带参数：
    
        class Washer():
            # 带参数__init__ 初始化
            def __init__(self, width, height):
                self.width = width
                self.height = height
        
            def print_info(self):
                print(f'洗衣机的宽度：{
                self.width}')  # 洗衣机的宽度：100
                print(f'洗衣机的宽度：{
                self.width}')  # 洗衣机的宽度：200
        
        haier1 = Washer(100,200)
        haier1.print_info()
        
        # haier2 = Washer()  # 报错

**注意︰**

1.  `__init__()` 方法，在创建一个对象时默认被调用，不需要手动调用
2.  `__init__(self)` 中的 self 参数，不需要开发者传递，python解释器会自动把当前的对象引用传递过去。

--------------------

#### 2.3.2 **str**() ####

当使用 print 输出对象的时候，默认打印对象的内存地址。如果类定义了`__str__`方法，那么就会打印从在这个方法中 return 的数据。

**示例：**

class Washer():
        def __str__(self):
            return '洗衣机类的解释说明'
    
    haier1 = Washer()
    print(haier1)  # 洗衣机类的解释说明

--------------------

#### 2.3.3 **del**() ####

当删除对象时，解释器也会默认调用 `__del__()` 方法。

class Washer():
        def __del__(self):
           print('删除')
    
    haier = Washer()
    del haier  # 删除

--------------------

## 三、面向对象继承 ##

### 3.1 旧式类与新式类 ###

*  **经典类或旧式类：**
    
    不由任意内置类型派生出的类，称之为经典类。
    
        class类名:
        	代码
        	......
 *  **新式类：**  
    Python中，所有类默认继承 object 类，object 类是顶级类或基类，其他子类叫做派生类。
    
        class类名(object):
        	代码
        	......

--------------------

### 3.2 单继承 ###

# 父类 A
    class A(object):
        def __init__(self):
            self.num = 1
    
        def info_print(self):
            print(self.num)
    
    # 子类 B
    class B(A):
        pass  # 作用是省略
    
    result = B()
    result.info_print()  # 1
    print(result.num)  # 1

--------------------

### 3.3 多继承 ###

多继承：一个类同时继承了多个父类。

# 父类A
    class A(object):
        def __init__(self):
            self.num_a = 1
    
        def info_print(self):
            print(f'A类：{
          self.num_a}')
    
    # 父类B
    class B(object):
        def __init__(self):
            self.num_a = 2
    
        def info_print(self):
            print(f'B类：{
          self.num_a}')
    
    # 子类
    class C(A, B):
        pass
    
    cc = C()
    print(cc.num_a)  # 1
    cc.info_print()  # A类：1

**注意：**

1.  如果一个类继承多个父类，默认使用第一个父类的同名属性和方法
2.  单继承中，子类默认继承父类的所有属性和方法
3.  多继承中，子类继承第一个父类的所有属性和所有类的方法
4.  两种继承方式子类都可以重写父类属性和方法

如：

# 父类A
    class A(object):
        def __init__(self):
            self.num_a = 1
            self.num_aa = 2
    
        def info_print(self):
            print(f'A类：{
          self.num_a}')
    
    # 父类B
    class B(object):
        def __init__(self):
            self.num_a = 3
            self.num_b = 4
    
        def info_print(self):
            print(f'B类：{
          self.num_a}')
    
        def info_print2(self):
            print(f'B类：{
          self.num_a}')
    
    # 子类
    class C(A, B):
        pass
    
    cc = C()
     # vars(object)：返回对象的属性
    print(vars(cc)) # {'num_a': 1, 'num_aa': 2}
    print(cc.num_a)   # 1
    print(cc.num_aa)  # 2  -- 第一个父类特有的属性
    # print(cc.num_b)   # 报错  -- 第二个父类特有的属性
    cc.info_print()   # A类：1  
    cc.info_print2()   # B类：1  -- 第二个父类特有的方法

--------------------

### 3.4 子类重写父类同名方法和属性 ###

如果一个类继承多个父类，子类会调用子类同名属性和方法。

# 父类A
    class A(object):
        def __init__(self):
            self.num = 1
    
        def info_print(self):
            print(f'A父类：{
          self.num}')
    
    # 父类B
    class B(object):
        def __init__(self):
            self.num = 2
    
        def info_print(self):
            print(f'B父类：{
          self.num}')
    
    # 子类
    class C(A, B):
        def __init__(self):
            self.num = 33
    
        def info_print(self):
            print(f'子类：{
          self.num}')
    
    
    cc = C()
    print(cc.num)  # 33
    cc.info_print()  # 子类：33
    
    print(C.__mro__)  # 通过__mro__方法来获取这个类的调用顺序
    # (<class '__main__.C'>, <class '__main__.A'>, <class '__main__.B'>, <class 'object'>)

--------------------

### 3.5 子类调用父类同名方法和属性 ###

# 父类 A
    class A(object):
        def __init__(self):
            self.num = 11
    
        def info_print(self):
            print(f'A父类：{
          self.num}')
    
    # 父类 B
    class B(object):
        def __init__(self):
            self.num = 22
    
        def info_print(self):
            print(f'B父类：{
          self.num}')
    
    # 子类 C
    # 父类A
    class A(object):
        def __init__(self):
            self.num = 11
    
        def info_print(self):
            print(f'A父类：{
          self.num}')
    
    # 父类B
    class B(object):
        def __init__(self):
            self.num = 22
    
        def info_print(self):
            print(f'B父类：{
          self.num}')
    
    # 子类C
    class C(A, B):
        def __init__(self):
            self.num = 33
    
        def info_print(self):
            # 加自己的初始化的原因：如果不加这个自己的初始化， num 属性值是上次调用的 init 内的 num 属性值
            self.__init__()
            print(f'子类：{
          self.num}')
    
        # 子类调用父类同名方法和属性
        def info_a_print(self):
            # 父类类名.函数()
            # 再次调用初始化的原因：这里想要调用父类的同名方法和属性，属性在 init 初始化位置，所以需要再次调用 init
            A.__init__(self)
            A.info_print(self)
    
        def info_b_print(self):
            B.__init__(self)
            B.info_print(self)
    
    cc = C()
    print(cc.num)  # 33
    
    cc.info_a_print()  # A父类：11  --- 若没有 A.__init__(self)，则同名属性为 子类C 属性值
    cc.info_b_print()  # B父类：22  --- 若没有 A.__init__(self)，则同名属性为上一个 A类 属性值
    cc.info_print()  # 子类：33  --- 若没有 self.__init__()，则同名属性为上一个 B类 属性值

--------------------

### 3.6 多层继承 ###

--------------------

### 3.7 super()调用父类方法 ###

使用super() 可以自动查找父类。调用顺序遵循 `__mro__`类属性的顺序。比较适合单继承使用。  
super() 包括 有参数 和 无参数 两种方式。

*  B类继承A类，C类继承B类，一次性调用父类的同名属性和方法，代码如下：
    
        # 父类A
        class A(object):
            def __init__(self):
                self.num = 11
        
            def info_print(self):
                print(f'A父类：{
                self.num}')
        
        # 父类B
        class B(A):
            def __init__(self):
                self.num = 22
        
            def info_print(self):
                print(f'B父类：{
                self.num}')
                # 有参数 super：super(当前类名, self).函数()
                # super(B, self).__init__()
                # super(B, self).info_print()
        
                # 无参数super
                super().__init__()
                super().info_print()
        
        # 子类C
        class C(B):
            def __init__(self):
                self.num = 33
        
            def info_print(self):
                # 加自己的初始化的原因：如果不加这个自己的初始化， num 属性值是上次调用的 init 内的 num 属性值
                self.__init__()
                print(f'子类：{
                self.num}')
        
            # 一次性调用父类的同名属性和方法
            def info_a_b_info(self):
                # 法一：
                # A.__init__(self)
                # A.info_print(self)
                # B.__init__(self)
                # B.info_print(self)
        
                # 法二：super()
                # 有参数 super：super(当前类名, self).函数()
                # super(C, self).__init__()
                # super(C, self).info_print()
        
                # 无参数super
                super().__init__()
                super().info_print()
        
        cc = C()
        cc.info_a_b_info()  # B父类：22  A父类：11
 *  C 类同时继承 A 类与 B 类，代码如下：

--------------------

### 3.8 私有权限 ###

python中，实例属性和方法若设置为私有权限，则 该实例属性或实例方法不继承给子类，并且一般定义函数名 get\_xx 用来获取私有属性，定义set\_xx用来修改私有属性值。

设置私有权限的方法：在属性名和方法名前面加上两个下划线\_\_\_。

# 父类 A
    class A(object):
        def __init__(self):
            self.num = 11
            # 定义私有属性  两道下划线
            self.__num = 22
    
        def info_print(self):
            print(f'A父类：{
          self.num}')
            self.__info_print()
    
        # 定义私有方法
        def __info_print(self):
            print(f'私有方法：{
          self.__num}')
    
        def get_num(self):
            return self.__num
    
        def set_num(self):
            self.__num = 500
    
    # 子类 B
    class B(A):
        pass
    
    bb = B()
    # print(bb.num)  # 11
    # print(bb.__num)   # 报错
    # bb.__info_print()  # 报错 私有方法报错，继承不了
    bb.info_print()  # A父类：11 私有方法：22
    
    print(bb.get_num())  # 22
    bb.set_num()
    print(bb.get_num())  # 500

--------------------

## 三、面向对象其他 ##

### 3.1 面向对象三大特征 ###

*  **封装**：将属性和方法书写到类的里面的操作即为封装，并且封装可以为属性和方法添加私有权限。
 *  **继承**：
    
     *  单继承中，子类默认继承父类的所有属性和方法
     *  多继承中，子类继承第一个父类的所有属性和所有类的方法
     *  两种继承方式子类都可以重写父类属性和方法。
 *  **多态**：传入不同的对象，产生不同的结果。

--------------------

### 3.2 多态 ###

**定义︰** 多态是一种使用对象的方式，子类重写父类方法，调用不同子类对象的相同父类方法，可以产生不同的结果。

class Dog(object):
        def work(self): # 父类提供统一的⽅方法，哪怕是空方法
            print('指哪打哪...')
    
    class ArmyDog(Dog): # 继承Dog类
        def work(self):  # ⼦子类重写⽗父类同名⽅方法
            print('追击敌人...')
    
    class DrugDog(Dog):
        def work(self):
            print('追查毒品...')
    
    class Person(object):
        def work_with_dog(self, dog): # 传⼊入不不同的对象，执⾏行行不不同的代码，即不不同的work函数
            dog.work()
    
    
    ad = ArmyDog()
    dd = DrugDog()
    person = Person()
    person.work_with_dog(ad)  # 追击敌人...
    person.work_with_dog(dd)  # 追查毒品...

--------------------

### 3.3 类属性和实例属性 ###

#### 3.3.1 类属性 ####

*  **设置和访问类属性**  
    类属性就是类对象所拥有的属性，它被该类的所有实例对象 所共有。类属性可以使用类对象或实例对象访问。
 *  **修改类属性**  
    类属性只能通过类对象修改，不能通过实例对象修改。 如果通过实例对象修改类属性，表示的是创建了一个**实例属性**。

示例：

class Dog(object):
        tooth = 10  # 类属性
    
    dog = Dog()
    
    # 访问
    print(Dog.tooth)  # 10
    print(dog.tooth)  # 10
    
    # 修改
    # 1. 通过类来修改
    Dog.tooth = 20
    print(Dog.tooth)  # 20
    
    # 2. 通过对象来修改
    dog.tooth = 40  # 不是修改类属性值，而是为 dog 对象添加一个属性
    print(Dog.tooth)  # 20  -- 修改失败
    print(dog.tooth)  # 40

--------------------

#### 3.3.2 实例属性 ####

示例属性，也叫对象属性。其可通过类内类外都可修改和获取。

**示例：**

**注意：** 实例属性要求每个对象为其 单独开辟一份内存空间来记录数据，而类属性为全类所共有，仅占用一份内存，更加节省内存空间。

--------------------

### 3.4 类方法和静态方法 ###

#### 3.4.1 类方法 ####

**类方法特点：**

*  **第一个形参是类对象的方法**
 *  需要用装饰器 `@classmethod` 来标识其为类方法，对于类方法，第一个参数必须是类对象，一般以`cls`作为第一个参数。

**示例：**

class Dog(object):
        __tooth = 10
    
        @classmethod  # 类方法：与类属性配合使用
        def get_tooth(cls):
            return cls.__tooth
    
    dog = Dog()
    result = dog.get_tooth()
    print(result)  # 10

**使用场景：**

*  类方法一般和类属性配合使用。
 *  当方法中需要使用 **类对象**（如：访问私有类属性等）时，定义类方法

--------------------

#### 3.4.2 静态方法 ####

**静态方法特点：**

*  需要通过装饰器 `@staticmethod` 来进行修饰，静态方法既不需要传递类对象也不需要传递实例对象(形参没有self/cls)
 *  静态方法也能够通过 **实例对象** 和 **类对象** 去访问。

**示例：**

class Dog(object):
        @staticmethod
        def info_print():
            print('这是静态方法')
    
    dog = Dog()
    # 静态方法既可以使用对象访问有可以使用类访问
    dog.info_print()  # 这是静态方法
    Dog.info_print()  # 这是静态方法

**使用场景：**

*  当方法中 **既不需要使用实例对象（如：实例对象，实例属性），也不需要使用类对象（如：类属性、类方法、创建实例等）时**，定义静态方法。
 *  取消不需要的参数传递，有利于减少不必要的内存占用和性能消耗

--------------------

## 四、异常 ##

### 4.1 异常语法 ###

*  **一般写法**
    
        try:
        	可能发生错误的代码
        except :
        	如果出现异常执行的代码
 *  捕获指定异常
    
        try:
        	可能发生错误的代码
        except 异常类型:
        	如果捕获到该异常类型执行的代码
 *  捕获多个指定异常
    
        try:
        	可能发生错误的代码
        except (异常类型1, 异常类型2, ...):
        	如果捕获到该异常类型执行的代码
 *  捕获异常描述信息
    
        try:
        	可能发生错误的代码
        except 异常类型 as result:
        	print(result)  # 打印描述信息
        	如果捕获到该异常类型执行的代码
 *  **捕获所有异常** ★
    
        try:
        	可能发生错误的代码
        except Exception:
        	如果捕获到该异常类型执行的代码
    
    Exception是所有程序异常类的父类。
 *  异常的 else
    
        try:
        	可能发生错误的代码
        except 异常类型:
        	如果捕获到该异常类型执行的代码
        else:
        	print('else是没有异常的时候执行的代码')
 *  **异常的 finally** ★
    
        try:
        	可能发生错误的代码
        except 异常类型:
        	如果捕获到该异常类型执行的代码
        else:
        	print('else是没有异常的时候执行的代码')
        finally:
        	print('finally是有无异常都要执行的代码')

**示例：**

try:
        f = open('test.txt', 'r')
    except Exception :
        f = open('test.txt', 'w')
    else:
        print('没有异常执行的代码')
    finally:
        f.close()

--------------------

### 4.2 自定义异常 ###

**Python中，抛出自定义异常的语法为raise异常类对象。**

示例：密码长度不足，则报异常（用户输入密码，如果输入的长度不足5位，则报错，即抛出自定义异常，并捕获该异常)。

# 自定义异常类，继承 Exception
    class ShortInputError(Exception):
        def __init__(self, length, min_len):
            self.length = length
            self.min_len = min_len
    
        # 设置抛出异常的描述信息
        def __str__(self):
            return f'你输入的长度是{
          self.length}，不能少于{
          self.min_len}个字符'
    
    def main():
        try:
            con = input('请输入密码：')
            if len(con) < 5:
                # 抛出异常类创建对象
                raise ShortInputError(len(con), 5)
        except Exception as result:
            print(result)
        else:
            print('密码已经输入完成')
    
    main()

运行结果：  
![在这里插入图片描述][ef7fc5d85764433ba85d99d8c15324b4.png_pic_left]

--------------------

## 五、模块和包 ##

python 模块是一个 python 文件，导入模块就是导入 pthon 文件。

### 5.1 导入模块 ###

#### 5.1.1 导入方式 ####

1.  `import 模块名`
2.  `from 模块名 import 功能1, 功能2, ...`
3.  `from 模块名 import *`

**示例：**

# 方式一：
    # import 模块名
    # import 模块名1, 模块名2, ...  (不推荐)
    # 调用功能：模块名.功能名()
    import math
    print(math.sqrt(3))  # 开平方计算
    
    # 方式二：
    # from 模块名 import 功能1， 功能2 ...;
    # 功能调用：(不需要书写模块名.功能)
    from math import sqrt
    print(sqrt(9))
    
    # 方式三：
    # from 模块名 import *
    from math import *
    print(sqrt(9))

--------------------

#### 5.1.2 定义别名 ####

*  **模块定义别名：** `import 模块名 as 别名`
 *  **功能定义别名：**`from 模块名 import 功能 as 别名`
 *  **注意：** 定义别名，就不能用原来的模块和功能名字
    
        # 模块别名
        import time as tt
        tt.sleep(2)
        # time.sleep(2) # 报错
        print('hello')
        
        # 功能别名
        from time import sleep as sl
        sl(2)
        print('hello')

--------------------

### 5.2 自定义模块 ###

自定义模块 my\_module.py：

def testA(a, b):
        print(a + b)
    
    # 只在当前文件中调用该函数，其他导入的文件内不符合该条件，则不执行  testA(4, 4) 函数调用
    # 只在自身模块时，系统变量 __name__ 是 __main__
    if __name__ == '__main__':  # 用于测试 
        testA(4, 4)

调用自定义模块：

import my_module
    
    my_module.testA(2,3)  # 5

**注意：** 如果使用 `from .. import ..`或 `from .. import *` 导入多个模块的时候，且模块内有同名功能。当调用这个同名功能的时候，调用到的是 后导入的模块的功能。

--------------------

### 5.3 模块定位顺序 ###

当导入一个模块，Python解析器对模块位置的搜索顺序是:

1.  当前目录
2.  如果不在当前目录，Python则搜索在shell变量PYTHONPATH下的每个目录。
3.  如果都找不到，Python会察看默认路径。UNIX下，默认路径一般为/usr/local/lib/pythonl/

**示例：**

# 现假设当前目录下存在自定义模块 random ，和 python 中的 random 模块名重复，且没有自定义 randint 方法
    import random
    num = random.randint(0, 5) # 报错 -- 先搜索当前目录，所以导入的模块是自定义的 random 模块
    print(num)

**拓展：**

# 数据通过引用传递，因此变量可以覆盖模块
    import time
    print(time)
    
    time = 1
    print(time)  # 1

--------------------

### 5.4 all 列表 ###

如果模块文件中有 `__all__` 变量，当使用 `from xxx import *` 导入时，只能导入这个列表中的元素。

自定义模块 my\_modeule2.py：

# 定义多个功能，把某个功能添加到 __all__
    __all__ = ['testA']
    
    def testA():
        print('testA函数')
    
    def testB():
        print('testB函数')

测试代码：

from my_module_2 import *
    testA()  # testA函数
    # testB()  # 报错  -- testB没有在 all 列表中

--------------------

### 5.5 包 ###

如果一个文件夹中含有`__init__.py` 文件，那么这个文件夹就称之为包。

包是模块的一个集合，将模块以文件夹的方式集中在一起。

#### 5.5.1 导包方式 ####

*  方式一：
    
        import 包名.模块名
        
        调用方式：包名.模块名.目标
 *  方式二：
    
        from 包名 import *
        
        调用方式：模块名.目标
    
    **注意：** 必须在 `__init__.py` 文件中添加 `__all__ = []` ，控制允许导入的模块列表。

--------------------

**包结构：**  
![在这里插入图片描述][9143e6bdd5824a198898ffb37ff72db9.png]

**方式一示例：**

my\_module1.py：

def info_print1():
        print('my_module1')

测试代码：

import mypackage.my_module1
    mypackage.my_module1.info_print1()  # my_module1

**方式二示例：**

my\_module2.py：

def info_print2():
        print('my_module2')

\_\_init\_\_.py：

__all__ = ['my_module1']

测试代码：

from mypackage import *  # 导入模块1、2
    my_module1.info_print1()  # my_module1
    my_module1.info_print2()  # my_module2

--------------------

#### 5.5.2 注意事项 ####

方式一在不引入 all 列表的时候方法也可以正常使用，但 pycharm 不会提示。  
![在这里插入图片描述][b12cb63c7e6b427cb5b82ea3ea6952ed.png_pic_left]

[97f682e18266415eae25364a66543ee1.png_pic_left]: https://img-blog.csdnimg.cn/97f682e18266415eae25364a66543ee1.png#pic_left
[1717c6342a2d4a3cac2d550a23a3d5a3.png_pic_left]: https://img-blog.csdnimg.cn/1717c6342a2d4a3cac2d550a23a3d5a3.png#pic_left
[9880cbf551b04741a0a62c1c873f28d1.png_pic_left]: https://img-blog.csdnimg.cn/9880cbf551b04741a0a62c1c873f28d1.png#pic_left
[54c5520dcb114ee8a1e6fba4f316637f.png]: https://img-blog.csdnimg.cn/54c5520dcb114ee8a1e6fba4f316637f.png
[ef7fc5d85764433ba85d99d8c15324b4.png_pic_left]: https://img-blog.csdnimg.cn/ef7fc5d85764433ba85d99d8c15324b4.png#pic_left
[9143e6bdd5824a198898ffb37ff72db9.png]: https://img-blog.csdnimg.cn/9143e6bdd5824a198898ffb37ff72db9.png
[b12cb63c7e6b427cb5b82ea3ea6952ed.png_pic_left]: https://img-blog.csdnimg.cn/b12cb63c7e6b427cb5b82ea3ea6952ed.png#pic_left