python

• 一.概论
  • 介绍
    • 特征
      • 开源、简单直观容易理解、适用于短期开发的日常任务
      • 完全面向对象（一切皆对象）
        函数、模块、数字、字符串都是对象，在 Python 中一切皆对象完全支持继承、重载、多重继承支持重载运算符，也支持泛型设计
      • 拥有一个强大的标准库
        Python 语言的核心只包含 数字、字符串、列表、字典、文件 等常见类型和函数，而由 Python 标准库提供了 系统管理、网络通信、文本处理、数据库接口、图形系统、XML 处理 等额外的功能
      • 大量的第三方模块
        使用方式与标准库类似。它们的功能覆盖 科学计算、人工智能、机器学习、Web 开发、数据库接口、图形系统 多个领域
    • 优点
      简单、易学免费、开源面向对象丰富的库可扩展性​
    • 缺点
      运行速度国内市场较小中文资料匮乏​
  • 程序执行原理
    • 计算机中的三大件
      CPU 负责处理数据内存 负责临时存储数据，空间小速度快硬盘 负责永久存储数据​​​​
    • 执行原理
      程序 运行之前，程序是 保存在硬盘 中的当要运行一个程序时操作系统会首先让 CPU 把程序复制到 内存 中CPU 执行 内存 中的 程序代码
    • python执行原理
      操作系统会首先让 CPU 把 Python 解释器 的程序复制到 内存 中Python 解释器 根据语法规则，从上向下 让 CPU 翻译 Python 程序中的代码CPU 负责执行翻译完成的代码
  • 编码规范
    • 避免错误
      • 每个import语句只导入一个模块
        尽量避免一次导入多个模块
      • 行尾不要；
        不要在行尾添加分号“;”，也不要用分号将两条命令放在同一行。
      • 建议每行不超过80个字符
      • 避免在循环中使用+和+=运算符累加字符串
      • 适当使用异常处理结构提高程序容错性
    • 可读性
      • 使用必要的空行可以增加代码的可读性
      • 运算符两侧、函数参数之间、逗号“,”两侧建议使用空格进行分隔
• 二.注释 #
  TODO注释 ​"""文档注释todo，​在 # 后跟上 TODO，用于标记需要去做的工作文档注释，
• 三.变量
  • 概述
    • 定义变量
      • 赋值，不需要指定类型
        Python 可以根据 = 等号右侧的值，自动推导出变量中存储数据的类型
      • 命名
        • 不能以数字开头，可以包含字母、数字和下划线，不能与关键字重名
        • 小写字母，单词与单词之间用_连接或者用驼峰命名法
          qq_number、firstName
    • 局部变量--函数内的变量
    • global x 全局变量--函数内的变量
  • 数据类型
    • 类型
      • 数字型
        • int float bool
        • complex
          主要用于科学计算，例如：平面场问题、波动问题、电感电容等问题​
      • 非数字型
        特点：​
        • 特点/公共方法
          都是一个 序列 sequence，也可以理解为 容器
          • 索引取值 []
            • greeting[-1] 负数索引
              ​>>> greeting = 'chongshi'>>> greeting[0]'c'>>> greeting[-1]'i'>>> greeting[-2]'h'
            • 'chongshi'[-1] 直接字符串索引
              ​>>> 'chongshi'[0]'c'>>> 'chongshi'[-1]'i'​
            • input('year:')[3] 函数索引
              >>> fourth = raw_input('year:')[3]year:2013>>> fourth'3'
          • 遍历 for in
          • 分片 [:]
            • tag[32:-4] 负数分片
              >>> tag = '<a href="http://www.python.org">Python web site</a>'>>> tag[9:30] # 取第9个到第30个之间的字符'http://www.python.org'>>> tag[32:-4] #取第32到第-4（倒着数第4个字符）'Python web site'>>> ​
            • numbers[0:10:2] 步长/每2个取一个
              ​>>> numbers = [0,1,2,3,4,5,6,7,8,9]>>> numbers[0:10:1] #求0到10之间的数，步长为1[0, 1, 2, 3, 4, 5, 6, 7, 8, 9]>>> numbers[0:10:2] #步长为2[0, 2, 4, 6, 8]>>> numbers[0:10:3] #步长为3[0, 3, 6, 9]
            • num_str[:] 完整的字符串
            • num_str[::-1] 字符串的逆序
          • 序列相连接 +
            两种相同类型的序列才能进行连接操作​>>> 'hello.'+'world!''hello.world!'>>> [1,2,3] + 'world!'Traceback (most recent call last): File "<pyshell#20>", line 1, in <module> [1,2,3] + 'world!'TypeError: can only concatenate list (not "str") to list​​
          • 序列重复 *
            ​>>> 'python ' * 5'python python python python python '>>> [25] * 10[25, 25, 25, 25, 25, 25, 25, 25, 25, 25]>>> sequence = [None] * 10>>> sequence[None, None, None, None, None, None, None, None, None, None]​
          • in 成员资格 not in
            >>> permissions = 'rw'>>> 'w' in permissionsTrue>>> 'y' in permissionsFalse>>> users = ['zhangsan', 'lisi','wangwu']>>> raw_input('Enter your user name: ') in usersEnter your user name: lisiTrue>>> subject ='$$$ Get rich now!!! $$$'>>> '$$$' in subjectTrue​
          • len(x) 长度、min(x) 最小值、max(x) 最大值
            >>> numbers = [100,34,678]>>> len (numbers)3>>> max(numbers)678>>> min(numbers)34>>> max(2,3)3>>> min(9,3,2,5)2​
          • 删除 del
        • 类型
          • string
            • 定义
              • 单引号和双引号
                如果字符串内部需要使用 "，可以使用 ' 定义字符串如果字符串内部需要使用 '，可以使用 " 定义字符串
              • 转义字符
                转义字符是指使用“\”对一些特殊字符进行转义​
                • \\ 反斜杠符号， ​\' 单引号， \" 双引号
                • \n 换行， \t 横向制表符，​ \​​​r 回车
              • 长字符串
                • ‘‘‘ ’’’
                  如果需要写一个非常非常长的字符串，它需要跨多行，那么，可以使用三个引号带点普通引号。
                • \
                  普通字符串也可以跨行。如果一行之中最后一个字符是反斜线，那么，换行符本身就“转义”了，也就是被忽略了。>>> 1+2+\...​ 4+512​​
            • 操作
              • hello_str.
                太多了，具体看md文档吧
                • 判断
                • 查找 替换
                • 大小写转换
                • 文本对齐
                • 去除空白字符
                • 拆分和连接
            • 应用场景
          • list []
            列表 数组 元素有序且可修改
            • 定义
              List（列表） 是 Python 中使用 最频繁 的数据类型，在其他语言中通常叫做 数组专门用于存储 一串 信息列表用 [] 定义，数据 之间使用 , 分隔列表的 索引 从 0 开始索引 就是数据在 列表 中的位置编号，索引 又可以被称为 下标注意：从列表中取值时，如果 超出索引范围，程序会报错​
            • 操作
              • name_list.
                name_list.append   name_list.count    name_list.insert   name_list.reversename_list.clear    name_list.extend   name_list.pop      name_list.sortname_list.copy     name_list.index    name_list.remove 
              • 转换成元组 tuple(列表)
            • 应用场景
              尽管 Python 的 列表 中可以 存储不同类型的数据但是在开发中，更多的应用场景是列表 存储相同类型的数据通过 迭代遍历，在循环体内部，针对列表中的每一项元素，执行相同的操作
          • tuple ()
            元组元素不可修改
            • 定义
              Tuple（元组）与列表类似，不同之处在于元组的 元素不能修改元组 表示多个元素组成的序列元组 在 Python 开发中，有特定的应用场景用于存储 一串 信息，数据 之间使用 , 分隔元组用 () 定义元组的 索引 从 0 开始索引 就是数据在 元组 中的位置编号​
            • 操作
              • 赋值
                创建空元组info_tuple = ()​元组中 只包含一个元素 时，需要 在元素后面添加逗号​info_tuple = (50, )
              • info_tuple.
                info.count  info.index
              • 转换成列表 list(元组) 
            • 应用场景
              尽管可以使用 for in 遍历 元组但是在开发中，更多的应用场景是：函数的 参数 和 返回值，一个函数可以接收 任意多个参数，或者 一次返回多个数据有关 函数的参数 和 返回值，在后续 函数高级 给大家介绍格式字符串，格式化字符串后面的 () 本质上就是一个元组让列表不可以被修改，以保护数据安全
          • dictionary {}
            字典元素无序，但有键值对
            • 定义
              dictionary（字典） 是 除列表以外 Python 之中 最灵活 的数据类型字典同样可以用来 存储多个数据通常用于存储 描述一个 物体 的相关信息 和列表的区别列表 是 有序 的对象集合字典 是 无序 的对象集合字典用 {} 定义
              • 键值对
                • {key1:value1,key2:value2}
                • 键必须是唯一的,且只能使用 字符串、数字或 元组
                • 值 可以取任何数据类型
            • 操作
              • in 在对 字典 操作时，判断的是 字典的键
              • xiaoming.
                xiaoming.clear       xiaoming.items       xiaoming.setdefaultxiaoming.copy        xiaoming.keys        xiaoming.updatexiaoming.fromkeys    xiaoming.pop         xiaoming.valuesxiaoming.get         xiaoming.popitem  
              • dict 通过映射建立字典
                >>> items = [('name','gumby'),('age',42)]>>> d = dict(items)>>> d{'age': 42, 'name': 'gumby'}>>> d['name']'gumby'​
              • popitem 获取/删除键值对
                scoundrel ={'name':'robin','girlfriend':'marion'}key,value=scoundrel.popitem()print(key) girlfriendprint(value)​ marion
            • 应用场景
              尽管可以使用 for in 遍历 字典但是在开发中，更多的应用场景是：使用 多个键值对，存储 描述一个 物体 的相关信息 —— 描述更复杂的数据信息将 多个字典 放在 一个列表 中，再进行遍历，在循环体内部针对每一个字典进行 相同的处理
              • 栗子
                #简单数据库#使用人名作为键的字典，每个人用另一个字典表示，其键‘phone’和‘addr’分别表示他们的电话号和地址，people ={ 'zhangsan':{ 'phone':'2341', 'addr':'foo drive 23' }, 'lisi':{ 'phone':'9102', 'addr':'bar street 42' }, 'wangwu':{ 'phone':'3158', 'addr':'baz avenue 90' }}#针对电话号码和地址使用的描述性标签，会在打印输出的时候用到labels = { 'phone':'phone number', 'addr':'address'}name = input('Name:')#查找电话号码还是地址？ 使用正确的键：request = input('phone number(p) or address (a)?')#使用正确的键：if request == 'p':key = 'phone'if request == 'a':key = 'addr'#如果名字是字典中的有效键才打印信息：if name in people: print("%s's %s is %s." %(name, labels[key], peo​ple[name][key]))
    • 类型转换
      • int(x) float(x)
      • str(x) hex(x)16 oct(x)8
    • type函数可以查看变量的类型
  • 计算
    • +-*/%
      10/20=0.5，10//20=0
    • // 取整除
    • ** 幂运算
    • 赋值运算符
      = += -= *= /= //= %= **=
    • 不同类型变量之间的计算
      • 数字型变量 之间可以直接计算
      • 字符串变量 可以和 整数 使用 * 重复拼接相同的字符串
      • 数字型变量 和 字符串 之间 不能进行其他计算
  • 其他
    • 引用
      • 概念
        ​在 Python 中变量 和 数据 是分开存储的数据 保存在内存中的一个位置变量 中保存着数据在内存中的地址变量 中 记录数据的地址，就叫做 引用注意：如果变量已经被定义，当给一个变量赋值的时候，本质上是 修改了数据的引用变量 不再 对之前的数据引用变量 改为 对新赋值的数据引用
      • 函数的 实参、返回值 都是是 引用
        多个返回值，其实返回的是元组；使用多个变量接收结果时，变量的个数应该和元组中元素的个数保持一致
      • id() 查看变量中保存数据所在的 内存地址
    • 可变类型--只有list和dictionary
      函数内部给变量赋值，这个变量改值了；可变类型的数据变化，是通过 方法 来实现
      • 注意
        • 变量 不再 对之前的数据引用， 变量 改为 对新赋值的数据引用
        • 可变类型+=的操作，本质上是在调用列表的 extend 方法，所以也会
    • 全局变量
      全局变量名前应该增加 g_ 或者 gl_ 的前缀
      • global
        如果在函数中需要修改全局变量，需要使用 global 进行声明
• 四.函数
  • def f(x):定义函数
    >>> def fibs(num): result = [0,1] for i in range(num-2): result.append(result[-2]+result[-1]) return result#直接调用fibs函数>>> fibs(10)[0, 1, 1, 2, 3, 5, 8, 13, 21, 34]>>> fibs(15)[0, 1, 1, 2, 3, 5, 8, 13, 21, 34, 55, 89, 144, 233, 377]​
    • 命名
      函数名称 的命名应该 符合 标识符的命名规则可以由 字母、下划线 和 数字 组成不能以数字开头不能与关键字重名​
    • 文档注释
      ​在开发中，如果希望给函数添加注释，应该在 定义函数 的下方，使用 连续的三对引号在 连续的三对引号 之间编写对函数的说明文字在 函数调用 位置，使用快捷键 CTRL + Q 可以查看函数的说明信息注意：因为 函数体相对比较独立，函数定义的上方，应该和其他代码（包括注释）保留 两个空行
    • 默认参数
      def say(message,times=1): print message*timessay('Hello')say('World',5)#输出>>> HelloWorldWorldWorldWorldWorld​
    • 关键参数
      def func(a,b=5,c=10): print 'a is',a, 'and b is',b,'and c is',cfunc(3,7)func(24,c=32)func(c=23,a=14)#输出>>> a is 3 and b is 7 and c is 10a is 24 and b is 5 and c is 32a is 14 and b is 5 and c is 23​
  • 基本
    • pow(,) 幂函数
    • abs() 绝对值
    • round() 四舍五入
    • round(99,0,-1) round(0,100) round(5)
  • 递归
    def f(n): if n == 1: return 1 else: return n*f(n-1)​
  • 其他
    • 缺省参数
      定义函数时，可以给 某个参数 指定一个默认值，具有默认值的参数就叫做 缺省参数调用函数时，如果没有传入 缺省参数 的值，则在函数内部使用定义函数时指定的 参数默认值函数的缺省参数，将常见的值设置为参数的缺省值，从而 简化函数的调用
      • def print_info(name, gender=True): ...
      • 必须保证 带有默认值的缺省参数 在参数列表末尾
      • 调用函数时，如果有 多个缺省参数，需要指定参数名
    • 可变参数
      def assert_body(self, body, *body_msg, expected_msg): ​msg = body for n in body_msg: msg = msg[n] assert msg == expected_msg return True
    • 多值参数
      有时可能需要 一个函数 能够处理的参数 个数 是不确定的
      • 参数名前增加 一个 * 可以接收 元组
      • 参数名前增加 两个 * 可以接收 字典
      • 拆包
        def demo(*args, **kwargs): print(args) print(kwargs)# 元组变量/字典变量gl_nums = (1, 2, 3)gl_dict = {"name": "小明", "age": 18}# demo(gl_nums, gl_dict)# 拆包语法，简化元组变量/字典变量的传递demo(*gl_nums, **gl_dict)demo(1, 2, 3, name="小明", age=18)
    • eval函数
      将字符串 当成 有效的表达式 来求值 并 返回计算结果
      • 栗子
        # 基本的数学计算In [1]: eval("1 + 1")Out[1]: 2​# 字符串重复In [2]: eval("'*' * 10")Out[2]: '**********'​# 将字符串转换成列表In [3]: type(eval("[1, 2, 3, 4, 5]"))Out[3]: list​# 将字符串转换成字典In [4]: type(eval("{'name': 'xiaoming', 'age': 18}"))Out[4]: dict
    • random.randint(a, b)
      返回 [a, b] 之间的整数，包含 a 和 b
• 五.语句
  • 导入 模块
    • math.floor(4.4) 舍去小数
      import math
    • sqrt(9) 平方根
      from math import sqrt 防止导入多个同名文件
    • 模块名
      标示符可以由 字母、下划线 和 数字 组成不能以数字开头不能与关键字重名注意：如果在给 Python 文件起名时，以数字开头 是无法在 PyCharm 中通过导入这个模块的
  • 输入输出
    • input("") 获取用户输入
      price = float(input("请输入价格:"))
    • print("") 打印输出（会自动换行）
      print("%s's %s is %s" %(name, labels[key], peo​ple[name][key]))
      • 不希望末尾增加换行，可以在 print 函数输出内容的后面增加 , end=""
        # 向控制台输出内容结束之后，不会换行print("*", end="")# 单纯的换行print("")
      • %s 字符串
      • %d 有符号十进制整数
        %06d 表示输出的整数显示位数，不足的地方使用 0 补全
      • %f 浮点数
      • %% 输出%
  • 赋值语句
    • 序列解包
      >>> x,y,z = 1,2,3>>> x,y=y,x>>> print (x,y,z)2 1 3
    • x = y = 42 链式赋值
    • x += 1 增理赋值
  • 控制语句
    • if ; if else ; if elif else
      • if 条件:操作
        ​>>> if 1==2 : print 'one equals two' ... >>> if 1==1 : print 'one equals one' ... one equals one
      • if 条件:操作 else:操作
      • if 条件:操作 elif 条件:操作 else:操作
    • assert断言
      确保程序中的某个条件一定为真才能让程序正常工作​>>> age = 10>>> assert 0 < age < 100>>> age = -1>>> assert 0 < age < 100 , 'the age must be realistic'Traceback (most recent call last): File "<pyshell#8>", line 1, in <module> assert 0 < age < 100 , 'the age must be realistic'AssertionError: the age must be realistic​​
  • 循环语句
    • while
      name = ''while not name: name = raw_input('please enter your name:')print 'hello.%s!' %name​
    • for
      ​for number in range(1,101):　　print number​d = {'x':1,'y':2,'z':3}for key in d:　　print key,'corresponds to',d[key]#输出>>> y corresponds to 2x corresponds to 1z corresponds to 3​​
      • 遍历语句
        # for 循环内部使用的变量 in 列表、元组、字典 以及 字符串元组for item in info:    循环内部针对元组元素进行操作    print(item)​
      • 完整的 for 循环语法
        for 变量 in 集合:    循环体代码else:    没有通过 break 退出循环，循环结束后，会执行的代码
        • 遍历嵌套的数据类型
          students = [    {"name": "阿土",     "age": 20,     "gender": True,     "height": 1.7,     "weight": 75.0},    {"name": "小美",     "age": 19,     "gender": False,     "height": 1.6,     "weight": 45.0},]find_name = "阿土"for stu_dict in students:    print(stu_dict)    # 判断当前遍历的字典中姓名是否为find_name    if stu_dict["name"] == find_name:        print("找到了")        # 如果已经找到，直接退出循环，就不需要再对后续的数据进行比较        breakelse:    print("没有找到")print("循环结束")
    • break 结束循环
      from math import sqrtfor n in range(99,0,-1): root = sqrt(n) if root == int(root): print n break#输出>>> 81​
    • continue 跳到下一轮循环
      while True: s=raw_input('enter something:') if s == 'quit': break if len(s) < 3: continue　　print 'Input is of sufficient length'#输入>>> enter something:huzhiheng#输入长度大于3，提示信息Input is of sufficient lengthenter something:ha #输入长度小于3，要求重输enter something:hah#输入长度等于3，提示信息Input is of sufficient lengthenter something:quit #输入内容等于quit，结果​
  • 其他
    • 空语句 pass
• 六.面向对象
  • 概念
    • 定义
      面向对象 是 更大 的 封装，根据 职责 在 一个对象中 封装 多个方法
      • 在完成某一个需求前，首先确定 职责 —— 要做的事情（方法）
      • 根据 职责 确定不同的 对象，在 对象 内部封装不同的 方法（多个）
      • 最后完成的代码，就是顺序地让 不同的对象 调用 不同的方法
    • 特点
      • 注重 对象和职责，不同的对象承担不同的职责
      • 更加适合应对复杂的需求变化，是专门应对复杂项目开发，提供的固定套路
      • 需要在面向过程基础上，再学习一些面向对象的语法
    • 封装 继承 多态
      • 封装
        根据 职责 将 属性 和 方法 封装 到一个抽象的 类 中，对外部世界隐藏对象的工作细节
      • 继承
        实现代码的重用
      • 多态
        可对 不同类的对象使用同样的操作，增加代码灵活度
  • 类和对象
    • 类
      类 是对一群具有 相同 特征（属性） 或者 行为（方法） 的事物的一个统称，是抽象的，不能直接使用
      • 命名
        • 大驼峰命名法 CapWords
      • 创建类
        • self参数
          self是对于对象自身的引用
        • dir 内置函数
          • 在 标识符 / 数据 后输入一个 .
          • __方法名__
            • __new__ 和 __init__
              init配置属性，xiaoming = Person("小明", 75.0)
            • __del__
              del，对象最后一定都会自动del的
            • __str__​​​
              print(xiaoming)
        • 私有属性和私有方法
          • 定义方式 __age
            在 定义属性或方法时，在 属性名或者方法名前 增加 两个下划线，定义的就是 私有 属性或方法
          • 其实是伪私有 xiaofang._Women__age
            在 名称 前面加上 _类名 => _类名__名称
        • 类属性
          • 类属性放平常位置
          • 对象属性放_init_方法里面
          • 如果使用 对象.类属性 = 值 赋值语句，只会 给对象添加一个属性，而不会影响到 类属性的值
        • 类方法
          标识符@classmethod
          • 类方法的 第一个参数 应该是 cls
        • 静态方法
          标识符@staticmethod
          • 定义
            既 不需要 访问 实例属性 或者调用 实例方法也 不需要 访问 类属性 或者调用 类方法
      • 新式类
        在 Python 3.x 中定义类时，如果没有指定父类，会 默认使用 object 作为该类的 基类 —— Python 3.x 中定义的类都是 新式类
    • 对象
      类 是对一群具有 相同 特征 或者 行为 的事物的一个统称，是抽象的，不能直接使用。由 哪一个类 创建出来的 对象，就拥有在 哪一个类 中定义的：属性、方法​
      • 创建对象
        • 对象变量 = 类名()
      • 访问特性 .
      • 身份运算符
        • is和is not
          针对 None 比较时，建议使用 is 判断
          • is 用于判断 两个变量 引用对象是否为同一个
          • == 用于判断 引用变量的值 是否相等
    • 单例
      让 类 创建的对象，在系统中 只有 唯一的一个实例
      • __new__
        • 作用
          • 1) 在内存中为对象 分配空间
          • 2) 返回 对象的引用
        • 重写
          • return super().__new__(cls)
            否则 Python 的解释器 得不到 分配了空间的 对象引用，就不会调用对象的初始化方法。注意：__new__ 是一个静态方法，在调用时需要 主动传递 cls 参数。
      • 实现步骤
        • 1.定义一个 类属性，初始值是 None，用于记录 单例对象的引用
        • 2.重写 __new__ 方法
        • 3.如果 类属性 is None，调用父类方法分配空间，并在类属性中记录结果
        • 4.返回 类属性 中记录的 对象引用
      • 只执行一次初始化工作
        • 定义一个类属性 init_flag 标记是否 执行过初始化动作，初始值为 False
        • 在 __init__ 方法中，判断 init_flag，如果为 False 就执行初始化动作
        • 然后将 init_flag 设置为 True
        • 这样，再次 自动 调用 __init__ 方法时，初始化动作就不会被再次执行 了
  • 继承
    每一个类都可能拥有一个或多个超类（父类）
    • class Zi(Fu): 创建子类
      • 方法重写
      • 拓展父类方法
        • super函数
          只能在新式类使用
        • 父类名.方法(self)
          和super不要混用
        • 如果使用 当前子类名 调用方法，会出现死循环
      • 父类的 私有属性 和 私有方法
        • 子类对象 不能 在自己的方法内部，直接 访问 父类的 私有属性 或 私有方法
        • 子类对象 可以通过 父类 的 公有方法 间接 访问到 私有属性 或 私有方法
      • 多继承同名方法
        • __mro__ 查看方法搜索顺序
      • property 创建属性
        __metaclass__ = typeclass Rectangle: def __int__(self): self.width = 0 self.height = 0 def setSize(self,size): self.width, self.height = size def getSize(self): return self.width ,self.height size = property(getSize ,setSize)>>> r = Rectangle()>>> r.width = 10>>> r.height = 5>>> r.size(10, 5)>>> r.size = 150,100>>> r.width150​
    • issubclass 调查继承
      >>> issubclass(SPAMFilter, Filter)True>>> issubclass(Filter,SPAMFilter)False​
  • 异常
    • 概念
      • 定义
        • 程序在运行时，如果 Python 解释器 遇到 到一个错误，会停止程序的执行，并且提示一些错误信息，这就是 异常
        • 程序停止执行并且提示错误信息 这个动作，我们通常称之为：抛出(raise)异常
        • 程序开发时，很难将 所有的特殊情况 都处理的面面俱到，通过 异常捕获 可以针对突发事件做集中的处理，从而保证程序的 稳定性和健壮性
    • 捕获异常
      • 语法
        try:    尝试执行的代码except:    出现错误的处理
        • 捕获未知错误
          except Exception as result:    print("未知错误 %s" % result)
        • 完整语法
          except Exception as result:    print("未知错误 %s" % result)
    • 异常的传递
      • 概念
        异常的传递 —— 当 函数/方法 执行 出现异常，会 将异常传递 给 函数/方法 的 调用一方如果 传递到主程序，仍然 没有异常处理，程序才会被终止
      • 方法
        • 在开发中，可以在主函数中增加 异常捕获
        • 而在主函数中调用的其他函数，只要出现异常，都会传递到主函数的 异常捕获 中
        • 这样就不需要在代码中，增加大量的 异常捕获，能够保证代码的整洁
    • 抛出 raise 异常
      • 概念
        • 在开发中，除了 代码执行出错 Python 解释器会 抛出 异常之外
        • 还可以根据 应用程序 特有的业务需求 主动抛出异常
      • 方法
        • 创建 一个 Exception 的 对象
        • 使用 raise 关键字 抛出 异常对象
  • 模块和包
    • 模块
      • 概念
        • 每一个以扩展名 py 结尾的 Python 源代码文件都是一个 模块
        • 其他
          • 模块名 同样也是一个 标识符，需要符合标识符的命名规则
          • 在模块中定义的 全局变量 、函数、类 都是提供给外界直接使用的 工具
          • 模块 就好比是 工具包，要想使用这个工具包中的工具，就需要先 导入 这个模块
      • 模块的导入
        • 方式
          • import 导入
          • from...import 导入
        • 同名冲突
          如果 两个模块，存在 同名的函数，那么 后导入模块的函数，会 覆盖掉先导入的函数开发时 import 代码应该统一写在 代码的顶部，更容易及时发现冲突一旦发现冲突，可以使用 as 关键字 给其中一个工具起一个别名
        • 模块的搜索顺序
          内置属性 __file__ 表示文件本身，可以 查看模块 的 完整路径
          • 搜索 当前目录 指定模块名的文件，如果有就直接导入
          • 如果没有，再搜索 系统目录
        • 原则 — 每一个文件都应该是可以被导入的
          • 一个 独立的 Python 文件 就是一个 模块
          • 在导入文件时，文件中 所有没有任何缩进的代码 都会被执行一遍！
        • __name__ 属性
          __name__ 属性可以做到，测试模块的代码 只在测试情况下被运行，而在 被导入时不会被执行！
          • __name__ 是 Python 的一个内置属性，记录着一个 字符串
          • 如果 是被其他文件导入的，__name__ 就是 模块名
          • 如果 是当前执行的程序 __name__ 是 __main__
    • 包
      • 概念
        使用 import 包名 可以一次性导入 包 中 所有的模块
        • 包 是一个 包含多个模块 的 特殊目录
        • 目录下有一个 特殊的文件 __init__.py
        • 包名的 命名方式 和变量名一致，小写字母 + _
      • __init__.py
        # 从 当前目录 导入 模块列表from . import send_messagefrom . import receive_message
      • 发布模块
        • 。。。
  • 文件
    • 函数和方法
      • open函数
        f = open("文件名", "访问方式")频繁的移动文件指针，会影响文件的读写效率，开发中更多的时候会以 只读、只写 的方式来操作文件​
        • 如果文件 存在，返回 文件操作对象
        • 如果文件 不存在，会 抛出异常
      • read write close 方法
        打开文件，并且返回文件对象
        • read 可以一次性 读入 并 返回 文件的 所有内容
          read 方法执行后，会把 文件指针 移动到 文件的末尾
        • close 负责 关闭文件
          如果 忘记关闭文件，会造成系统资源消耗，而且会影响到后续对文件的访问
        • readline 方法
          readline 方法可以一次读取一行内容方法执行后，会把 文件指针 移动到下一行，准备再次读取
    • 文件/目录的常用管理操作
      • 导入os模块
        创建、重命名、删除、改变路径、查看目录内容、……
      • 文件操作
        • rename
          os.rename(源文件名, 目标文件名)
        • remove 删除
          os.remove(文件名)
      • 目录操作
        • listdir
        • mkdir
        • rmdir
        • getcwd 获取当前目录
        • chdir 修改工作目录
        • path.isdir 判断是否是文件
    • 其他
      • 文件指针
        文件指针 标记 从哪个位置开始读取数据
        • 第一次打开 文件时，通常 文件指针会指向文件的开始位置
        • 当执行了 read 方法后，文件指针 会移动到 读取内容的末尾
          默认情况下会移动到 文件末尾
      • 文本文件的编码格式
        • 常见的编码
          • ASCII编码
            计算机中只有 256 个 ASCII 字符一个 ASCII 在内存中占用 1 个字节 的空间
          • UTF-8编码
            计算机中使用 1~6 个字节 来表示一个 UTF-8 字符，涵盖了 地球上几乎所有地区的文字大多数汉字会使用 3 个字节 表示UTF-8 是 UNICODE 编码的一种编码格式