Linux黑马笔记

Python快速入门语法

一、基础语法

1.前言

1.1 Python 源程序的基本概念

1. Python 源程序就是一个特殊格式的文本文件，可以使用任意文本编辑软件做 Python 的开发
2. Python 程序的 文件扩展名 通常都是 .py

1.2 演练步骤

• 在桌面下，新建 认识Python 目录
• 在 认识Python 目录下新建 01-HelloPython.py 文件
• 使用 gedit 编辑 01-HelloPython.py 并且输入以下内容：
  python print("hello python") print("hello world")
• 在终端中输入以下命令执行 01-HelloPython.py
bash $ python 01-HelloPython.py

print 是 python 中我们学习的第一个 函数
print 函数的作用，可以把 “” 内部的内容，输出到屏幕上

1.3 执行 Python 程序的方式

1. 解释器 python / python3
   Python 的解释器
   ```bash

使用 python 2.x 解释器
$ python xxx.py
使用 python 3.x 解释器
$ python3 xxx.py
其他解释器（知道）
Python 的解释器 如今有多个语言的实现，包括：

• CPython —— 官方版本的 C 语言实现
• Jython —— 可以运行在 Java 平台
• IronPython —— 可以运行在 .NET 和 Mono 平台
• PyPy —— Python 实现的，支持 JIT 即时编译

2. 交互式运行 Python 程序
   • 直接在终端中运行解释器，而不输入要执行的文件名
   • 在 Python 的 Shell 中直接输入 Python 的代码，会立即看到程序执行结果
   1. 交互式运行 Python 的优缺点
      优点
      适合于学习/验证 Python 语法或者局部代码
      缺点
      代码不能保存
      不适合运行太大的程序
   2. 退出 官方的解释器
      1. 直接输入exit()
      2. 使用热键退出
         在 python 解释器中，按热键 ctrl + d 可以退出解释器

2.基础语法

2.1 注释

• 单行注释（行注释）

  • 以#开头，#右边的所有东西都被当做说明文字，而不是真正要执行的程序，只起到辅助说明作用

• 多行注释（块注释）

  • 要在 Python 程序中使用多行注释，可以用 一对 连续的 三个 引号(单引号和双引号都可以)

  # 单行注释
  """
    多行注释
  """

2.2 算数运算符

• 算数运算符是 运算符的一种

• 是完成基本的算术运算使用的符号，用来处理四则运算

  运算符	描述	实例
  +	加	10 + 20 = 30
  -	减	10 - 20 = -10
  *	乘	10 * 20 = 200
  /	除	10 / 20 = 0.5
  //	取整除	返回除法的整数部分（商） 9 // 2 输出结果 4
  %	取余数	返回除法的余数 9 % 2 = 1
  **	幂	又称次方、乘方，2 ** 3 = 8

• 在 Python 中 * 运算符还可以用于字符串，计算结果就是字符串重复指定次数的结果
  python In [1]: "-" * 50 Out[1]: '----------------------------------------'

• 算数运算符的优先级

  • 先乘除后加减
  • 同级运算符是 从左至右 计算
  • 可以使用 () 调整计算的优先级

  运算符	描述
  **	幂 (最高优先级)
  * / % //	乘、除、取余数、取整除
  + -	加法、减法

2.3 变量的基本使用

变量定义：

• 在 Python 中，每个变量 在使用前都必须赋值，变量 赋值以后 该变量 才会被创建
• 等号（=）用来给变量赋值
  • = 左边是一个变量名
  • = 右边是存储在变量中的值
  • 变量名 = 值

变量的类型:

• 在 Python 中定义变量是 不需要指定类型（在其他很多高级语言中都需要）
• 数据类型可以分为 数字型 和 非数字型
• 数字型
  • 整型 (int)
  • 浮点型（float）
  • 布尔型（bool）
  • 真 True 非 0 数 —— 非零即真
  • 假 False 0
  • 复数型 (complex)
    • 主要用于科学计算，例如：平面场问题、波动问题、电感电容等问题
• 非数字型
  • 字符串
  • 列表
  • 元组
  • 字典
• 使用 type 函数可以查看一个变量的类型
  • type(name)

变量的输入:

函数	说明
print(x)	将 x 输出到控制台
type(x)	查看 x 的变量类型

input 函数实现键盘输入

• 在 Python 中可以使用 input 函数从键盘等待用户的输入
• 用户输入的 任何内容 Python 都认为是一个 字符串
• 语法如下：
  字符串变量 = input("提示信息：")

类型转换函数:

函数	说明
int(x)	将 x 转换为一个整数
float(x)	将 x 转换到一个浮点数

变量的格式化输出:

• 在 Python 中可以使用print函数将信息输出到控制台
• 如果希望输出文字信息的同时，一起输出数据，就需要使用到格式化操作符
• %被称为格式化操作符，专门用于处理字符串中的格式
  • 包含 % 的字符串，被称为格式化字符串
  • % 和不同的字符连用，不同类型的数据需要使用不同的格式化字符

格式化字符	含义
%s	字符串
%d	有符号十进制整数，%06d 表示输出的整数显示位数，不足的地方使用 0 补全
%f	浮点数，%.2f 表示小数点后只显示两位
%%	输出 %

a = "hello"
print("格式化字符串%s" %a)

变量的命名:

• 标识符
  • 标示符可以由 字母、下划线 和 数字 组成
  • 不能以数字开头
  • 不能与关键字重名
• 关键字
  • 关键字就是在 Python 内部已经使用的标识符
  • 关键字具有特殊的功能和含义
  • 开发者不允许定义和关键字相同的名字的标示符

2.4 运算符

• 算数运算符

  运算符	描述	实例
  +	加	10 + 20 = 30
  -	减	10 - 20 = -10
  *	乘	10 * 20 = 200
  /	除	10 / 20 = 0.5
  //	取整除	返回除法的整数部分（商） 9 // 2 输出结果 4
  %	取余数	返回除法的余数 9 % 2 = 1
  **	幂	又称次方、乘方，2 ** 3 = 8

• 比较（关系）运算符

  运算符	描述
  ==	检查两个操作数的值是否 相等，如果是，则条件成立，返回 True
  !=	检查两个操作数的值是否 不相等，如果是，则条件成立，返回 True
  >	检查左操作数的值是否 大于 右操作数的值，如果是，则条件成立，返回 True
  <	检查左操作数的值是否 小于 右操作数的值，如果是，则条件成立，返回 True
  >=	检查左操作数的值是否 大于或等于 右操作数的值，如果是，则条件成立，返回 True
  <=	检查左操作数的值是否 小于或等于 右操作数的值，如果是，则条件成立，返回 True

• 逻辑运算符

  运算符	逻辑表达式	描述
  and	x and y	只有 x 和 y 的值都为 True，才会返回 True否则只要 x 或者 y 有一个值为 False，就返回 False
  or	x or y	只要 x 或者 y 有一个值为 True，就返回 True只有 x 和 y 的值都为 False，才会返回 False
  not	not x	如果 x 为 True，返回 False如果 x 为 False，返回 True

• 赋值运算符

  运算符	描述	实例
  =	简单的赋值运算符	c = a + b 将 a + b 的运算结果赋值为 c
  +=	加法赋值运算符	c += a 等效于 c = c + a
  -=	减法赋值运算符	c -= a 等效于 c = c - a
  *=	乘法赋值运算符	c *= a 等效于 c = c * a
  /=	除法赋值运算符	c /= a 等效于 c = c / a
  //=	取整除赋值运算符	c //= a 等效于 c = c // a
  %=	取 模 (余数)赋值运算符	c %= a 等效于 c = c % a
  **=	幂赋值运算符	c **= a 等效于 c = c ** a

• 运算符的优先级

  运算符	描述
  **	幂 (最高优先级)
  * / % //	乘、除、取余数、取整除
  + -	加法、减法
  <= < > >=	比较运算符
  == !=	等于运算符
  = %= /= //= -= += *= **=	赋值运算符
  not or and	逻辑运算符

2.5 条件语句

if 要判断的条件: 
  条件成立时，要做的事情 ……

if 要判断的条件: 
  条件成立时，要做的事情 …… 
else: 
  条件不成立时，要做的事情 ……

if 条件1: 
  条件1满足执行的代码 …… 
elif 条件2: 
  条件2满足时，执行的代码 …… 
elif 条件3: 
  条件3满足时，执行的代码 …… 
else: 
  以上条件都不满足时，执行的代码 ……

逻辑运算:

• 在程序开发中，通常在判断条件时，会需要同时判断多个条件
• 只有多个条件都满足，才能够执行后续代码，这个时候需要使用到逻辑运算符
• 逻辑运算符 可以把多个条件按照逻辑进行连接，变成更复杂的条件
• Python 中的 逻辑运算符 包括：与 and、或 or、非 not 三种

2.6 循环语句

while 条件: 
  条件满足时，做的事情....

while 条件: 
  条件满足时，做的事情....
else:
  正常循环结束执行的代码

• break ，退出循环
• continue，退出当前循环，执行下一次循环

字符串中的转义字符:

转义字符	描述
\\	反斜杠符号
\'	单引号
\"	双引号
\n	换行
\t	横向制表符
\r	回车

i = 1
print("九九乘法表：")
while i < 10:
  j = 1
  while j <= i:
    print("%d*%d=%d\t" % (j, i, i*j), end="")
    j = j + 1
  print()
  i += 1

2.7 函数基础

函数的定义:

def 函数名():

1. def 是英文 define 的缩写
2. 函数名称应该能够表达函数封装代码的功能，方便后续的调用
3. 函数名称的命名应该 符合标识符的命名规则
   1. 可以由字母、下划线和数字组成
   2. 不能以数字开头
   3. 不能与关键字重名
4. 调用函数很简单的，通过函数名()即可完成对函数的调用

函数的文档注释:

1. 在开发中，如果希望给函数添加注释，应该在 定义函数 的下方，使用 连续的三对引号
2. 在连续的三对引号 之间编写对函数的说明文字
3. 在函数调用 位置，使用快捷键 CTRL + Q 可以查看函数的说明信息

def sum(num1, num2):
  """对两个数字的求和"""
  return num1+num2

2.8 高级变量类型

• 列表

  • 列表的定义
    • List（列表）是 Python 中使用最频繁的数据类型，在其他语言中通常叫做 数组
    • 专门用于存储一串信息
    • 列表用 [] 定义，数据之间使用 , 分隔
    • 列表的索引从 0 开始
      • 索引就是数据在列表中的位置编号，索引又可以被称为下标
  • 列表常用操作

  序号	分类	关键字 / 函数 / 方法	说明
  1	增加	列表.insert(索引, 数据)	在指定位置插入数据
  		列表.append(数据)	在末尾追加数据
  		列表.extend(列表2)	将列表2 的数据追加到列表
  2	修改	列表[索引] = 数据	修改指定索引的数据
  3	删除	del 列表[索引]	删除指定索引的数据
  		列表.remove[数据]	删除第一个出现的指定数据
  		列表.pop	删除末尾数据
  		列表.pop(索引)	删除指定索引数据
  		列表.clear	清空列表
  4	统计	len(列表)	列表长度
  		列表.count(数据)	数据在列表中出现的次数
  5	排序	列表.sort()	升序排序
  		列表.sort(reverse=True)	降序排序
  		列表.reverse()	逆序、反转

  • del 关键字

    • 使用 del 关键字(delete) 同样可以删除列表中元素
    • del 关键字本质上是用来 将一个变量从内存中删除的
    • 如果使用 del 关键字将变量从内存中删除，后续的代码就不能再使用这个变量了

  • 循环遍历

    • 遍历就是从头到尾依次从列表中获取数据

    for 循环内部使用的变量 in 列表:
      循环体

• 元组

  • Tuple（元组）与列表类似，不同之处在于元组的元素不能修改
  • 用于存储一串信息，数据之间使用,分隔
  • 元组用() 定义
  • 元组的索引 从 0 开始
  • 常用操作与循环遍历与列表相同

• 字典

  • dictionary（字典）是除列表以外 Python 之中 最灵活的数据类型
  • 和列表的区别
    • 列表 是 有序 的对象集合
    • 字典 是 无序 的对象集合
  • 字典用 {} 定义
  • 字典使用 键值对存储数据，键值对之间使用 , 分隔
    • 键 key 是索引
    • 值 value 是数据
    • 键 和 值 之间使用 : 分隔
    • 键必须是唯一的
    • 值 可以取任何数据类型，但 键 只能使用 字符串、数字或 元组
  • 常用操作

  序号	分类	关键字 / 函数 / 方法	说明
  1	增加	字典[key] = value	新增键值对
  		字典.setdefault(key,value)	新增键值对
  		字典.update(字典2)	将字典2的数据合并到字典中
  2	修改	字典[key] = value	修改指定key的数据
  3	删除	del 字典[key]	删除指定键值对的数据
  		字典.popitem()	随机删除一个键值对
  		字典.pop(key)	删除指定键值对数据
  		字典.clear()	清空字典
  4	统计	len(字典)	字典的键值对数量
  5	查询	字典.keys()	所有key列表
  		字典.values()	所有value列表
  		字典.items()	所有(key,value)元组列表
  		字典[key]	获取key对应的值
  		字典.get(key)	获取key对应的值

  • 循环遍历

  for key in 字典:
    循环体
  
  for key,value in 字典:
    循环体

• 集合

  • 创建集合
    • a = {1,2,3}
    • a = set{}
  • 是乱序的
  • 数据具有唯一性，有去重的功能

  序号	分类	关键字 / 函数 / 方法	说明
  1	增加	集合.add(value)	新增数据
  		集合.update(列表)	将列表的数据合并到集合中
  2	删除	集合.discard()	删除指定数据
  		集合.pop()	随机删除一个数据
  		集合.remove()	删除指定数据
  3	查询	value in 集合	判断数据是否在集合序列
  		value not in 集合	判断数据是否不在集合序列

• 字符串

  • 字符串的定义

    • 字符串 就是 一串字符，是编程语言中表示文本的数据类型
    • 在 Python 中可以使用 一对双引号"或者 一对单引号'定义一个字符串
    • 可以使用 索引 获取一个字符串中 指定位置的字符，索引计数从 0 开始
    • 也可以使用 for 循环遍历 字符串中每一个字符

  • 字符串的常用操作

    • 判断类型

    方法	说明
    string.isspace()	如果 string 中只包含空格，则返回 True
    string.isalnum()	如果 string 至少有一个字符并且所有字符都是字母或数字则返回 True
    string.isalpha()	如果 string 至少有一个字符并且所有字符都是字母则返回 True
    string.isdecimal()	如果 string 只包含数字则返回 True，全角数字
    string.isdigit()	如果 string 只包含数字则返回 True，全角数字、⑴、\u00b2
    string.isnumeric()	如果 string 只包含数字则返回 True，全角数字，汉字数字
    string.istitle()	如果 string 是标题化的(每个单词的首字母大写)则返回 True
    string.islower()	如果 string 中包含至少一个区分大小写的字符，并且所有这些(区分大小写的)字符都是小写，则返回 True
    string.isupper()	如果 string 中包含至少一个区分大小写的字符，并且所有这些(区分大小写的)字符都是大写，则返回 True

    • 查找和替换

    方法	说明
    string.startswith(str)	检查字符串是否是以 str 开头，是则返回 True
    string.endswith(str)	检查字符串是否是以 str 结束，是则返回 True
    string.find(str, start=0, end=len(string))	检测 str 是否包含在 string 中，如果 start 和 end 指定范围，则检查是否包含在指定范围内，如果是返回开始的索引值，否则返回 -1
    string.rfind(str, start=0, end=len(string))	类似于 find()，不过是从右边开始查找
    string.index(str, start=0, end=len(string))	跟 find() 方法类似，不过如果 str 不在 string 会报错
    string.rindex(str, start=0, end=len(string))	类似于 index()，不过是从右边开始
    string.replace(oldstr, newstr, num=string.count(old))	把 string 中的 oldstr 替换成 newstr，如果 num 指定，则替换不超过 num 次

    • 大小写转换

    方法	说明
    string.capitalize()	把字符串的第一个字符大写
    string.title()	把字符串的每个单词首字母大写
    string.lower()	转换 string 中所有大写字符为小写
    string.upper()	转换 string 中的小写字母为大写
    string.swapcase()	翻转 string 中的大小写

    • 文本对齐

    方法	说明
    string.ljust(width)	返回一个原字符串左对齐，并使用空格填充至长度 width 的新字符串
    string.rjust(width)	返回一个原字符串右对齐，并使用空格填充至长度 width 的新字符串
    string.center(width)	返回一个原字符串居中，并使用空格填充至长度 width 的新字符串

    • 去除空白字符

    方法	说明
    string.lstrip()	截掉 string 左边（开始）的空白字符
    string.rstrip()	截掉 string 右边（末尾）的空白字符
    string.strip()	截掉 string 左右两边的空白字符

    • 拆分和连接

    方法	说明
    string.partition(str)	把字符串 string 分成一个 3 元素的元组 (str前面, str, str后面)
    string.rpartition(str)	类似于 partition() 方法，不过是从右边开始查找
    string.split(str=””, num)	以 str 为分隔符拆分 string，如果 num 有指定值，则仅分隔 num + 1 个子字符串，str 默认包含 ‘\r’, ‘\t’, ‘\n’ 和空格
    string.splitlines()	按照行(‘\r’, ‘\n’, ‘\r\n’)分隔，返回一个包含各行作为元素的列表
    string.join(seq)	以 string 作为分隔符，将 seq 中所有的元素（的字符串表示）合并为一个新的字符串

• 字符串的切片

  • 切片 方法适用于 字符串、列表、元组
    • 切片 使用 索引值 来限定范围，从一个大的 字符串 中 切出 小的 字符串
    • 列表 和 元组 都是 有序 的集合，都能够 通过索引值 获取到对应的数据
    • 字典 是一个 无序 的集合，是使用 键值对 保存数据
  • 语法： 字符串[开始索引:结束索引:步长]
  • 在 Python 中不仅支持 顺序索引，同时还支持 倒序索引
    • 所谓倒序索引就是 从右向左 计算索引
    • 最右边的索引值是 -1，依次递减

2.9 公共方法

Python 包含了以下内置函数：

函数	描述	备注
len(item)	计算容器中元素个数
del(item)	删除变量	del 有两种方式
max(item)	返回容器中元素最大值	如果是字典，只针对 key 比较
min(item)	返回容器中元素最小值	如果是字典，只针对 key 比较
cmp(item1, item2)	比较两个值，-1 小于/0 相等/1 大于	Python 3.x 取消了 cmp 函数

切片:

描述	Python 表达式	结果	支持的数据类型
切片	“0123456789”[::-2]	“97531”	字符串、列表、元组

运算符:

运算符	Python 表达式	结果	描述	支持的数据类型
+	[1, 2] + [3, 4]	[1, 2, 3, 4]	合并	字符串、列表、元组
*	[“Hi!”] * 4	[‘Hi!’, ‘Hi!’, ‘Hi!’, ‘Hi!’]	重复	字符串、列表、元组
in	3 in (1, 2, 3)	True	元素是否存在	字符串、列表、元组、字典
not in	4 not in (1, 2, 3)	True	元素是否不存在	字符串、列表、元组、字典
> >= == < <=	(1, 2, 3) < (2, 2, 3)	True	元素比较	字符串、列表、元组

成员运算符:

运算符	描述	实例
in	如果在指定的序列中找到值返回 True，否则返回 False	3 in (1, 2, 3) 返回 True
not in	如果在指定的序列中没有找到值返回 True，否则返回 False	3 not in (1, 2, 3) 返回 False

for 循环语法:

for 变量 in 集合:
  循环体代码
else: 
  没有通过 break 退出循环，循环结束后，会执行的代码

2.10 变量进阶

变量的引用:

• 变量 和 数据 都是保存在 内存 中的
• 在 Python 中 函数 的 参数 传递以及 返回值 都是靠 引用 传递的
• 变量 和 数据 是分开存储的
• 数据 保存在内存中的一个位置
• 变量 中保存着数据在内存中的地址
• 变量 中 记录数据的地址，就叫做 引用
• 使用id()函数可以查看变量中保存数据所在的内存地址

可变和不可变类型:

• 不可变类型，内存中的数据不允许被修改：
  • 数字类型 int, bool, float, complex, long(2.x)
  • 字符串 str
  • 元组 tuple
• 可变类型，内存中的数据可以被修改：
  • 列表 list
  • 字典 dict
• 注意
  • 可变类型的数据变化，是通过 方法 来实现的
  • 如果给一个可变类型的变量，赋值了一个新的数据，引用会修改
    • 变量 不再 对之前的数据引用
    • 变量 改为 对新赋值的数据引用

哈希：

• Python 中内置有一个名字叫做 hash(o) 的函数
  • 接收一个 不可变类型 的数据作为 参数
  • 返回 结果是一个 整数
• 哈希 是一种 算法，其作用就是提取数据的 特征码（指纹）
  • 相同的内容 得到 相同的结果
  • 不同的内容 得到 不同的结果
• 在 Python 中，设置字典的 键值对 时，会首先对 key 进行 hash 已决定如何在内存中保存字典的数据，以方便 后续 对字典的操作：增、删、改、查
  • 键值对的 key 必须是不可变类型数据
  • 键值对的 value 可以是任意类型的数据

2.11 函数进阶

局部变量：函数内部定义的，只能在函数内部使用
全局变量：函数外部定义的，所有函数都能使用

• 函数返回值
  • 利用元组返回多个值 return (a,b)
  • 利用数组解构接收多值 a,b = fun()
• 缺省参数
  • 指定一个参数有默认值fun(a,b=1)
• 多值参数
  • 参数名前添加*可以接收元组
  • 参数名前添加**可以接收字典
  • 参数名前添加*可以对元组拆包
  • 参数名前添加**可以对字典拆包
• Lambda表达式
  • 参数 = lambda 参数列表: 表达式
  • 无参数 fn = lambda: 100
  • 一个参数 fn = lambda a: a
  • 默认参数 fn = lambda a,b=1: a+b
  • 可变参数 fn = lambda *args: args
• 高阶函数
  • 把函数作为参数传入
• 内置高阶函数
  • map(func,list)
    • 将传入的函数func作用于list的每一个元素，并将结果组成迭代器返回
    • 使用list(res)将结果转化为列表
  • reduce(func,list)
    • 定义func函数必须有两个参数
    • 让func函数计算结果与list下一个元素作累计运算
    • 需要导入functools模块
  • filter(func,list)
    • 根据func过滤不符合条件的元素，返回一个filter对象
    • 使用list(res)将结果转化为列表

2.12 文件操作

• 打开文件
  • f = open(name, mode)
  • 打开一个已经存在的文件或者创建一个新文件
  • name文件名，mode表示打开文件方式：只读w、只写r、追加a
• 写入文件
  • f.write(内容)
• 读取文件
  • f.read(num)
    • num表示要读取的长度（字节）
  • f.readlines()
    • 读取全部文件，返回一个列表，每一行为一个元素
  • f.readline()
    • 读取一行内容
  • f.seek(偏移量,起始位置)
    • 移动文件指针位置，起始位置：0：文件开头，1：当前位置，2：文件结尾
• 关闭文件
  • f.close()
• 文件重命名
  • 导入 os 模块
  • os.rename(原文件名,新文件名)
• 删除文件
  • os.remove(文件名)
• 创建文件夹
  • os.mkdir(文件名)
• 删除文件夹
  • os.rmdir(文件名)
• 获取当前目录
  • os.getcwd()
• 改变默认目录
  • os.chdir(目录)
• 获取目录列表
  • os.listdir(目录)

3.进阶语法

3.1 类

# 定义类
class 类名:

  # 类属性，可以被实例对象和类对象访问
  # 仅占用一份内存，节省空间
  # 不能通过实例对象修改，只能通过类对象修改
  age = 18

  def __init__(self):
    # 初始化方法

  def __str__(self):
    return "类的说明，由print函数触发该方法"

  def __del__(self):
    # 对象删除后调用此方法

  def mode(self):
    # 定义方法
  
  def __mode(self):
    # 定义私有方法
    self.__name = "z" # 私有属性
  
  @classmethod
  def mode1(cls):
    # 类方法
    # 需要用装饰器表示 @classmethod
    # 第一个参数必须为类对象，用来访问类属性
  
  @staticmethod
  def mode2():
    # 静态方法
    # 没有必须参数的方法
    # 可以被实例对象和类对象访问


# 创建对象
对象名 = 类名()

# 类外面添加属性
对象名.属性名 = 值

# 类里面获取属性
self.属性名

3.2 继承

子类可以继承父类所有属性和方法：

class Father:
  def mode:
    pass

class Chidren(Father):

class Son(Father,Chidren):
  # 多继承，当由同名属性和方法时，优先使用第一个
  def __init__(self):
    # 调用父类方法
    super().mode()

3.3 多态

是一种对象使用方法，通过多个子类继承相同父类并分别重写父类的方法，再通过统一调用父类方法来产生不同的结果

3.4 异常

try:
  # 可能发生错误的代码
except 异常类型:
  # 捕获异常的处理代码

try:
  # 可能发生错误的代码
except (异常类型1,异常类型2):
  # 捕获多个异常的处理代码

try:
  # 可能发生错误的代码
except (异常类型1,异常类型2) as result:
  # 捕获异常描述信息result

try:
  # 可能发生错误的代码
except Exception as result:
  # 捕获所有异常信息result
else:
  # 没有异常执行的代码
finally:
  # 无论有没有异常都会执行的代码

class InputError(Exception):
  # 自定义异常类

# 抛出异常
raise InputError()

3.5 模块与包

• 导入模块的方法
  • import 模块名,模块名2
  • from 模块名 import 功能名，功能名2
  • from 模块名 import *
  • import 模块名 as 别名
  • from 模块名 import 功能名 as 别名
• 制作模块
  • 每一个文件都是一个模块，模块名就是文件名
  • __all__
    • 在模块文件中存在变量 __all__ = ['mode1']
    • 该模块只能被调用放在改变量里面的函数
• 包
  • 在文件夹下有__init__.py文件，该文件夹称为包
  • 导入包
    • import 包名.模块名.功能名
    • 在__init__.py文件，写__all__ = ['mode1']开表示导出的模块

3.6 迭代器与生成器

迭代器从对象的第一个元素开始访问，直到对象的所有元素被访问完结束
迭代器有两个基本的方法：iter() 和 next()
字符串，列表或元组对象都可用于创建迭代器

list=[1,2,3,4]
it = iter(list)    # 创建迭代器对象
next(it)           # 输出迭代器的下一个元素

把一个类作为一个迭代器使用需要在类中实现两个方法__iter__() 与 __next__()
__iter__() 方法返回一个特殊的迭代器对象， 这个迭代器对象实现了 __next__() 方法并通过抛出 StopIteration 异常标识迭代的完成。

class MyNumbers:
  def __iter__(self):
    self.a = 1
    return self
 
  def __next__(self):
    if self.a <= 20:
      x = self.a
      self.a += 1
      return x
    else:
      raise StopIteration

生成器是一个返回迭代器的函数，只能用于迭代操作
在调用生成器运行的过程中，每次遇到 yield 时函数会暂停并保存当前所有的运行信息，返回 yield 的值, 并在下一次执行 next() 方法时从当前位置继续运行

class MyNumber:
  '''利用生成器产生斐波那契数列'''
  def __init__(self,count):
    self.a = 0
    self.b = 1
    self.count = 0
    self.max = count
  
  def __iter__(self):
    while True:
      if self.count < self.max:
        yield self.a
        self.a, self.b = self.b, self.a + self.b
        self.count += 1
      else:
        raise StopIteration
  
if __name__ == '__main__':
  for i in MyNumber(10):
    print(i)

3.7 装饰器

给函数无修改的情况下添加新功能

def Medthod(fun):
  print("This is a decorator")
  fun()

@Medthod
def Fun():
  print("This is a function")
  
if __name__ == '__main__':
  Fun()

4.常用库的使用

4.1 Matplotlib

作用：数据可视化

import matplotlib.pyplot as plt

plt.figure()
plt.plot([1, 2, 3, 4], [1, 4, 9, 16])
plt.show()

Matplotlib三层结构

1. 容器层
   1. (Canvas)画板层，最底层
   2. (Figure)画布层，建立在画板之上
   3. (Axes)绘图区/坐标系，建立在画布之上，一个画布有多个绘图区
2. 辅助显示层
3. 图像层：坐标轴(axis)、图例(legend)建立在绘图区上

Matplotlib模块:

• Matplotlib.pyplot
  • figure() 创建默认画布
  • figure(figsize=(),dpi=) 创建指定画布
    • figsize，指定图的长宽
    • dpi：图像的清晰度
  • savefig(“图像路径”)，保存图像
  • plot(x,y) x轴数据，y轴数据
    • plot(x,y1,label=’y1’,color=’red’,linestyle=’–’,marker=’o’)
  • show() 显示图像
  • xticks(x,**kwargs), x为要显示的刻度
  • yticks(y,**kwargs), y为要显示的刻度
  • 中文显示问题
    • matplotlib.matplotlib_fname()方法找到配置文件，添加下面文字
    • font.sans-serif: Microsoft YaHei
    • 从本地的字体库中找到C:\Windows\Fonts\Microsoft YaHei UI字体
    • 复制到matplotlib\mpl-data\fonts\ttf文件夹中
  • grid(True,linestyle=’–’,color=’gray’,linewidth=1,alpha=0.5) 坐标图的网格线
  • xlabel x坐标轴信息
  • ylabel y坐标轴信息
  • title 标题
  • 多个图画在一起
    • 多次使用plot(x,y)进行画图就行了
  • 多个图组合一起
    • subplot(2,1,1) 两行一列第一个图，后面写全部的画图代码
    • subplot(2,1,2) 两行一列第二个图，后面写全部的画图代码
  • 折线图 plot()
  • 散点图 scatter()
  • 柱状图 bar()
  • 直方图 histogram()
  • 饼图 pie()

from matplotlib.pyplot import *

x= range(1,11)
y1= [i*i for i in x]
y2= [i*i*i for i in x]
figure(figsize=(10,10),dpi=100)
subplot(2,1,1)
plot(x,y1,label='y1',color='red',linestyle='--',marker='o')
xticks(x)
yticks(range(0,1000,100))
grid(True,linestyle='--',color='gray',linewidth=1,alpha=0.5)
subplot(2,1,2)
plot(x,y2,label='y2',color='green',linestyle='-.',marker='*')
xticks(x)
yticks(range(0,1000,100))
grid(True,linestyle='--',color='gray',linewidth=1,alpha=0.5)
show()

4.2 Numpy

数值计算库，用于快速处理数组

import numpy as np

a = np.array([[1, 2, 3],
          [4, 5, 6]])

type(a)
# =========
# numpy.ndarray

• numpy
  • 数组里面的数据都是相同的数据类型
  • 支持向量化运算
  • ndarray
    • 属性
    • shape 数组维度的元组 (行数,列数)
    • ndim 数组维度
    • size 数组中元素的数量
    • itemsize 一个数组元素的长度
    • dtype 数组元素类型
  • 生成数组的方法
    • 生成0和1
      • zeros(shape=[行,列],dtype="float32")
      • ones(shape=[行,列],dtype="float32")
    • 从现有数组生成
      • array([1,2,3])
      • asarray(a) 浅拷贝
      • copy(a) 深拷贝
    • 生成固定范围的数组
      • linspace(0,100,1000) 左闭右闭的数据
      • arange(0，100，0.1) 左闭右开
    • 生成随机数组
      • 均匀分布 random.uniform(low = -1,high = 1,size = 1000)
      • 正态分布 random.randn(loc = 0,scale = 1,size = (2,8))
  • 索引数据
    • a[1,2]
  • 修改数据
    • reshape((行，列)) 可以把任意行列的数组，转化为需要的行列，返回新的数组
    • resize((行，列)) 修改效果与上面一样，但是会修改原数组
    • T 对数组进行转置操作
  • 类型修改
    • astype(新类型)
  • 序列化
    • tostring()
  • 去重
    • set(数组) 无法转化一维以上数据
    • unique(数组) 全部转化为一维
  • 运算
    • 逻辑运算
      • 数组[数组 > 1]
      • all(布尔值) 只要有一个False返回False
      • any(布尔值) 只要有一个True返回True
      • where(三元运算符) where(布尔值，True操作，False操作)
    • 统计运算
      • 统计指标函数
        • min 最小值 min(axis=0) 按列求最小值 min(axis=1) 按列求最大值
        • max 最大值
        • mean 平均值
        • median 中位数
        • var 方差
        • std 标准差
      • argmax(数组,axis=0)
      • argmin(数组,axis=1)
    • 数组运算
      • 数组可以直接与数进行运算
      • 不同形状的数组需要满足广播机制，不同形状的其中一个是1
    • 矩阵运算
      • 矩阵乘法
        • matmul(矩阵1，矩阵2) 普通乘
        • dot(矩阵1，矩阵2) 点乘
  • 合并与分割
    • hstack((矩阵1,矩阵2,...)) 水平拼接
    • vstack((矩阵1,矩阵2,...)) 垂直拼接
    • concatenate((矩阵1，矩阵2,...),axis=0) 根据axis判断水平还是垂直拼接
    • split(矩阵,[索引1,索引2,...]) 根据索引作为终点来依次分割矩阵
  • IO操作与数据处理
    • 读取
      • genfromtxt(文件路径,delimiter=",") 根据分隔符的规则读取文件数据，非数字和缺失值会显示nan

4.3 Pandas

读取文件方便，封装了Numpy、Matplotlib

• 核心数据结构
  • DataFrame(数组)
    • 具有行索引和列索引的二维数组，让数组更直观的表现
    • DataFrame(数组，index=行索引矩阵，columns=列索引矩阵) 给数据表添加行表头和列表头
    • 属性
      • shape 行数和列数元组
      • index 行表头
      • columns 列表头
      • values 中间的有效数据
      • T 转置
    • 方法
      • head(n) 返回前n行数据
      • tail(n) 返回后n行数据
    • 修改行列表头
      • 利用属性index进行修改，只能统一修改不能单独修改
  • MultiIndex
    • 多级或分层索引对象，三维数据表示
    • 属性
      • index
        • names levels的名称
        • levels 每个level的元组值
  • Series
    • 带索引的一维数组
    • 只有行索引
    • 属性
      • index
      • values
• 数据操作
  • 索引操作
    • drop(行/列索引矩阵,axis=0/1) 删除部分行/列数据
    • 直接索引
    • 按名字索引
    • 按数字索引
    • 组合索引
  • 赋值操作
  • 排序