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 编码的一种编码格式