6.27

解释型语言

Python 作为解释型语言，在执行过程中通过解释器逐行解释每一行源代码，执行速度要慢于编译型语言（C语言等），但编译时间更快、平台间的可移植性更好

常用内置函数

`input()`

input([prompt]) ：prompt 内容作为提示信息显示在控制台中，引导用户输入，默认读入的类型为 str 类型

通常情形下需要进行格式转换，可以使用 <type>(input()) 进行转换， type 是转换的目标格式类型

一行读入多个由空格等分隔符读入的信息可以用 spilt() 进行分割，如：

a, b = input().spilt()
# 对多个同时读入的数据进行数据转换可以使用：
a, b = map(int, input().spilt())
# 返回的数据可以再进行包装（外部加 list）

type() 函数可以提供输入变量的类型，可以 print 查看

`print()`

常用输出函数，当输出多个内容时使用 , 进行分隔，在控制台中会通过空格进行分隔，并输出在同一行内，输出结束后默认换行

格式化输出方法：

使用 % 符作为占位符：

字符串内类似C语言写入占位符，在字符串结束后直接追加 %(varName1, varName2) 进行补充，括在一个 % 符号后

school = "BUAA"
subject = "Python"
print('this is %s %s class' % (school, subject))

str.format() 函数：

通过大括号作为占位符，调用 str 类型的 format() 方法，可以用数字表示占位的变量顺序

school = "BUAA"
subject = "Python"
print("this is {1} {0}".format(subject, school))

f-string：

Python 3.6 后添加的格式化方法

school = "BUAA"
subject = "Python"
print(f'this is {school} {subject}')

代码结构

block & indentation：block 是代码块，在 Python 中以缩进（indentation）表示一个代码块，通常缩进为一个 tab
module：一个单独的 .py 文件，可以通过 import 的方式进行引入
package：多个 module 所在的文件夹，package 必定包含 __init__.py 文件

运算符

/ ：除法，返回为浮点型
// ：整数除法，返回除法向下取整后的整数结果
% ：取模，对负数而言可以带公式： $x - x\ //\ y * y$
** : 乘方运算，支持指数为负的情况
Python 的浮点数比较会自动控制精度，通常在 $10^{-8}$ 内即判断两数相等/不等
Bitwise Operation - 位运算 &|~ ：按位与或非
Logic Operation - 逻辑运算 and or not ：逻辑与或非

要注意的是，逻辑运算中的返回值：举例 x and y ，当 x 为真时，则会直接返回 y ，例如 1 and 4 则会直接返回 4 作为结果，并且 Python 逻辑运算也满足短路效应

字符串操作

Python 中不包含字符类型，单个字符也会被视为字符串；正向索引时从 0 开始，反向索引则从 -1 开始
切片：便捷取出某些字符序列，str[a:b:c] 意为下标从 a 开始到 b 结束，以间隔为 c 取出字符返回一个字符串；特别的 str[::-1] 代表反转字符串，其中 a、b 的正负可以混用，切片方向由 c 决定
常用的一些函数：len() - 长度；isdigit() - 全数字；isalpha - 全字母；startwith() - 以特定字符开头

6.29

布尔类型

任何数据类型都可以转换为布尔类型，并且任何非空的数据几乎都会被判断为 True：

非零数字类型
非空字符串
非空容器

常用容器

list - 列表

列表使用方括号创建，构造方式如下：

list1 = []
list2 = list()

列表是有序可重复的，可以通过索引（下标）获取列表内容。值得注意的是，对一个 str 类型的数据使用 list() 进行包裹，会按字符将其切分并置入列表中

查询操作

同时列表的元素可以为任何类型，也就是说 list1 = [[1, 2, 3], [1], []] 这样一个列表也是合法的

在访问列表时可以使用下标进行索引（正负索引均可），同时也可以采用切片获取列表的子列表

in 关键字可以查找列表中是否包含待查找的元素：

if element in list1:
    print(True)

修改操作

可以对索引出的列表元素进行直接修改，这样不会改变列表元素的数量

list1[0] = "new element"
list1[1:3] = ["new 1", "new 2"]

添加操作可以使用 append、insert 或 extend 几个函数

list1.append("new element")       # 追加至列表末尾
list1.insert(0, "index = 0")      # 在 index 处插入元素
list1.extend(["new 1", "new 2"])  # 追加容器内的所有元素

其中 extend 方法不限制参数的元素类型（列表、元组、集合、字典等均可）

删除操作可以使用 remove、pop、clear：

list1.remove("removed") # 删除指定内容的元素
list1.pop(index)        # 删除指定索引的元素
list1.clear()           # 清空整个列表

循环操作

对列表的循环有时可以用列表推导式进行替换：

list2 = [x if x == "target" else "target" for x in list1]

这个操作会遍历所有的元素，并将等于 target 的元素直接置入 list2，遍历到其余元素时，每个元素都会向列表插入一个 target 元素。列表表达式可以简化对列表的 for 循环操作

排序操作

使用 sort 函数进行排序：

list1.sort()  # 字典序排序，默认升序
list1.sort(reverse=True)  # 降序
list1.sort(key=str.lower) # 使用小写作为 key 进行排序
list1.sort(key=cmp_to_key(cmp1))

关于第四项： python3 中不再支持使用比较函数 cmp 进行 sort 地比较，所以如若自定义函数控制排序顺序，可以使用 cmp_to_key 函数进行转化，从而在 key 字段使用，需要在代码使用前进行引入

from functools import cmp_to_key

tuple - 元组

元组是一个有序、不可更改的容器，类似 const

tuple1 = tuple()
tuple2 = (1, )

在通过 () 创建单一元素的元组时，需要多加一个逗号进行分隔，否则会自动转型为其他数据类型。可以通过下标对元组进行访问

修改操作

元组创建后不可更改，但是可以令两个元组使用 + 运算符组合（类似 extend），但是不允许对元素进行删除

所以实在想改的话可以先通过 list(tuple1) 变化为列表类型，随后对元素进行操作，最后再用 tuple() 将列表还原为元组

set - 集合

集合是一个无序容器，因此不允许同时出现两个相同的元素，使用 {} 进行标识，同时不能使用下标进行索引（毕竟无序）

修改操作

set1.add(element)     # 添加一个元素
set1.update(set2)     # 添加一个容器的所有元素
set1.intersection_update(set2) # 保留两集合交集
set1.discard(element) # 删除元素

discard 方法若删除不存在的元素时不会发生报错，使用 remove 则会，所以建议使用 discard

dictionary - 字典

字典类似于 java 中的 map 容器，通过键值对进行索引，key 不允许重复。在 python 3.7 及其之后，字典是一个有序容器，在此之前是无序的。其访问通过下标索引，下标为 key 值

dict1 = {key1: value1, key2: value2}
value = dict1[key1]
keys = dict1.keys()
values = dict1.values()
items = dict1.items()

修改操作

更改已有的键值对可以使用两种方法：

dict1[key] = newValue
dict1.update({key: newValue})

添加新的键值对同理，也是使用上面两个方法

删除时对 key 进行删除：

dict1.pop(key)

7.5

函数

函数使用 def 关键字进行声明，参数数量可以选择变长参数表进行处理

def func1(*tuple)
def func2(**dict)

使用一个星号可以把调用时所有的参数转化为一个元组，两个星号则是字典，第二种情况要求调用时必须写出 argname=parameter 的显式参数，否则字典就没有 key 用了（

7.9

lambda 函数

lambda 函数是一个单行的便捷函数，它可以接受若干参数，但只能进行一行表达式的执行

func = lambda arg0, arg1 : expression # 声明
func(x, y)                            # 使用

可以通过 lambda 函数完成一些简单的函数功能

类与对象

类通过 class 关键字定义，创建对象时不需要使用 new。

class Sleep:
    def __init__(self, para1, para2):
        self.para1 = para1
        self._para2 = para2
        
    def toString(self):
        print("Sleep now!")

sleep = Sleep(1, 2)
sleep.toString()

继承与其他 oop 语言类似，使用 super 进行引用（super.__init__()）

Python 允许多重继承，并且方法的继承顺序按照 C3 linearization 进行标定，继承顺序可以通过 class.mro() 查看

日期库 - datetime

datetime 库通过创建一个变量来保存运行时的日期信息：

import datetime

x = datetime.datetime.now()
print(x, x.year)
print(x.strftime("<Directive>"))

可以通过 strftime 方法对日期进行格式化输出，格式取决于字符串 <Directive>

JSON 解析 - json

Python 内置了简单的 json 解析库：json。json 库能实现 json 字符串和字典的双向转化。

import json

json_str = "{"x": "1", "y": "2"}"
json_dict = json.loads(json_str) # 解析 json 为字典
print(json_dict) # 字典类型

json_str = json.dumps(json_dict) # 将字典转化为 json 字符串
print(json_str) # 字符串

7.17 异常处理

异常处理流程

在 python 中使用 try-except-finally 块表示异常的捕获与处理，同时也可以尝试捕获不同类型的异常，进入不同的处理分支，如下例：

try:
    print(an_undifined_object)
except IndexError :
    print("print index error!")
except ValueError:
    print("print value error!")
except Exception:
    print("print other exception!")
finally:
    print("finish try-except")

最后使用的 Exception 指代所有异常，也就是说如果发生了除前两种异常外的异常时，会进入这个分支最后转入 finally 内。

异常的触发

除了捕获原本定义的异常类型外，我们也可以通过 raise 关键字主动触发异常并申请程序处理。也可以定义一个新的异常类，如下例：

class NewException(Exception):
    def __init__(self, msg):
        self.msg = msg
        
    def __str__(self):
        return self.msg
    
    
try:
    raise NewException("Manmade Exception!")
except Exception as e:
    print(e)

正则表达式

引入

正则表达式可以通过引入 re 软件包实现

正则函数

常用的函数如下：

res1 = re.findall([字符串 | 数组等容器], src)
# 返回按顺序匹配到的项，可以同时寻找多个词
res2 = re.search(regex, src)
# 返回符合正则表达 regex 的串第一次出现的 Match 对象，未匹配则返回 None
res3 = re.spilt(regex, src[, max_spilt_time])
# 返回匹配到 regex 后便拆分后的元素集合，通常用 '\s' 拆空白符，第三个参数可选，控制拆分操作的执行次数上限
res4 = re.sub(regex, repl, src[, max_count])
# 将 src 中所有匹配 regex 的内容更换为 repl 指的字符串，同样可以选用第四个参数表示替换次数
# 需要额外注意 repl 亦可以使用函数，函数的参数默认只有一个，是当前匹配到的 Match 对象

Match 对象

当通过 search 或 sub 方法匹配后，会返回一个 Match 对象，它包含了这次匹配所用到的相关信息，常用的方法 or 属性共三个：

matcher.span()  # 匹配项所在的字符下标范围，为元组形式
matcher.string  # 匹配项的匹配文本
matcher.group() # 和 java 一样