作者：上官佳雨
第一讲知识导图
变量、运算符与数据类型
注释
单行注释：#
多行注释：''' ''' 或者 """ """
运算符
算术运算符：+ - * / // % **
比较运算符：> >= < <= == !=
逻辑运算符：and, or, not
位运算符：~ & | ^ << >>
三元运算符
三元运算符通常在Python里被称为条件表达式，它可以使用一条语句来完成条件判断和赋值操作。
语法形式：True_statements if expression else False_statements
其他运算符：in, not in, is, is not
❗ is, is not （是&不是）对比的是两个变量的<u>内存地址</u>，==, != （等于&不等于）对比的是两个变量的<u>值</u>。
比较的两个变量，指向的都是<u>地址不可变</u>的类型（str等），那么is，is not 和 ==，！= 是<u>完全等价</u>的。
对比的两个变量，指向的是<u>地址可变</u>的类型（list，dict，tuple等），则两者是有区别的。
运算符的优先级
一元运算符优于二元运算符。
先算术运算，后移位运算，最后位运算。
逻辑运算最后结合。
变量和赋值
使用变量前，需要对其先赋值。
变量名可以包括字母、数字、下划线、但变量名不能以数字开头。
Python 变量名是大小写敏感的。
数据类型与转换
整型（int）
浮点型（float）
⭐调整精度
str.format() 方法：使用字符串格式化来产生限定长度的有效位数。
<figcaption>例如：print("{:.2f}".format(3.1415926)) —>输出3.14</figcaption>
round() 函数：不精确但可以用来“事后舍入”，使得实际的结果值可以做相互比较。
语法形式：round(number[, ndigits])返回 number 舍入到小数点后 ndigits 位精度的值。 如果 ndigits 被省略或为 None，则返回最接近输入值的整数。decimal 模块：如果需要非常精确的结果（如会计方面的应用），可以用 decimal 包里的 Decimal 对象和 getcontext() 方法来实现，用用 getcontext().prec 来调整精度。
布尔型（bool）
数字运算中，用 1 和 0 代表 True 和 False。
⭐确定bool(X) 的值是 True 还是 False，就看 <u>X 是不是空</u>。
对于数值变量，0, 0.0 都可认为是空的。
print(type(10.31), bool(0.00), bool(10.31))
运行结果为：
<class 'float'> False True
- 对于<u>容器变量</u>，里面没元素就是空的。eg. '', (), [], {}, set()
print(type(''), bool(''), bool('python'))
运行结果为：
<class 'str'> False True
获取类型信息
type(object)
isinstance(object, classinfo)
classinfo -- 可以是直接或间接类名、基本类型或者由它们组成的元组。eg. int，float，bool，complex，str(字符串)，list，dict(字典)，set，tuple两个函数的区别：
type() 不会认为子类是一种父类类型，不考虑继承关系。
isinstance() 会认为子类是一种父类类型，考虑继承关系。
如果要<u>判断两个类型是否相同</u>推荐使用 isinstance()。
类型转换
转换为整型 int(x, base=10)
转换为字符串 str(object='')
转换为浮点型 float(x)
转化为布尔型 bool(x)
print() 函数
语法形式：print(*objects, sep=' ', end='\n', file=sys.stdout, flush=False)
sep是实现分隔符。
end是输出结束时的字符，默认是换行符\n。
file是定义流输出的文件。
flush是立即把内容输出到流文件，不作缓存。
位运算
二进制3种表示形式：原码、反码和补码
符号位：最高位为符号位，0表示正数，1表示负数。在位运算中符号位也参与运算。
原码：就是其二进制表示，有一位符号位。
反码：正数的反码就是原码，负数的反码是符号位不变，其余位取反（对应正数按位取反）。
补码：正数的补码就是原码，负数的补码是反码+1。
计算机内部使用补码来表示。按位非操作 ~
~ 把num的补码中的 0 和 1 全部取反（0 变为 1，1 变为 0）
按位与操作 &
只有两个对应位都为 1 时才为 1
按位或操作 |
只要两个对应位中有一个 1 时就为 1
按位异或操作 ^
只有两个对应位不同时才为 1
异或操作的性质：满足交换律和结合律
按位左移操作 <<
num << i 将num的二进制表示向左移动i位所得的值。
按位右移操作 >>
num >> i 将num的二进制表示向右移动i位所得的值。
利用位运算实现快速计算
通过 <<，>> 快速计算2的倍数问题。
n << 1 -> 计算 n*2
n >> 1 -> 计算 n/2，负奇数的运算不可用
n << m -> 计算 n*(2^m)，即乘以 2 的 m 次方
n >> m -> 计算 n/(2^m)，即除以 2 的 m 次方
1 << n -> 2^n
通过 ^ 快速交换两个整数。
a ^= b
b ^= a
a ^= b
# 相当于 a, b = b, a
通过 a & (-a) 快速获取a的最后为 1 位置的整数。
利用位运算实现整数集合
一个数的二进制表示可以看作是一个集合（0 表示不在集合中，1 表示在集合中）。
元素与集合的操作：
a | (1<<i) -> 把 i 插入到集合中
a & ~(1<<i) -> 把 i 从集合中删除
a & (1<<i) -> 判断 i 是否属于该集合（零不属于，非零属于）
集合之间的操作：
a 补 -> ~a
a 交 b -> a & b
a 并 b -> a | b
a 差 b -> a & (~b)
条件语句
if 语句
单个 if 语句中的 expression 条件表达式可以通过布尔操作符 and，or和not 实现<u>多重条件判断</u>。
if 2 > 1 and not 2 > 3:
print('Correct Judgement!')
运行结果为：
Correct Judgement!
if - else 语句
if语句支持嵌套，即在一个if语句中嵌入另一个if语句，从而构成<u>不同层次的选择结构</u>。
hi = 6
if hi > 2:
if hi > 7:
print('好棒！好棒！')
else:
print('切~')
运行结果为：
无输出
if - elif - else 语句
elif 语句即为 else if，用来检查多个表达式是否为真，并在为真时执行<u>特定代码块</u>中的代码。
assert 关键词
assert这个关键词称为“断言”，当这个关键词后边的条件为 False 时，程序自动崩溃并抛出<u>AssertionError</u>的异常。
在进行<u>单元测试</u>时，可以用来在程序中置入检查点，只有条件为 True 才能让程序正常工作。
assert 3 > 7
运行报错：
AssertionError
循环语句
while 循环
while后可以写入一个<u>非零整数</u>，也可以写入<u>str、list或任何序列</u>，值/长度非零则视为真值，执行循环体；否则视为假值，不执行循环体。
while - else 循环
当while循环<u>正常执行完</u>的情况下，执行else输出。
如果while循环中执行了<u>跳出循环</u>的语句，比如 break，将<u>不执行else代码块</u>的内容。
for 循环
for循环是迭代循环，相当于一个通用的序列迭代器，可以遍历任何<u>有序序列</u>（str、list、tuple等），也可以遍历任何<u>可迭代对象</u>（dict）。
for 循环实际上创建了一个迭代器对象，并为每个循环执行 next() 方法。每次循环，迭代变量被设置为可迭代对象的当前元素，提供给代码块使用。
for - else 循环
与while - else语句类似。当for循环<u>正常执行完</u>的情况下，执行else输出。
如果for循环中执行了<u>跳出循环</u>的语句，比如 break，将<u>不执行else代码块</u>的内容
range() 函数（是BIF（Built-in functions））
语法形式：range([start,] stop, [step=1])
start和step两个参数可选
step参数的默认值是1
❕ range 生成的序列包含start的值但<u>不包含stop的值</u>。
enumerate()函数
语法形式：enumerate(sequence, [start=0])
sequence：一个序列、迭代器或其他支持迭代对象。
start：下标起始位置。用 enumerate(A, j) 还可以确定索引起始值为 j。
返回值： enumerate(枚举) 对象，
例如：[(0, 'Spring'), (1, 'Summer'), (2, 'Fall'), (3, 'Winter')]
用 enumerate(A) 不仅返回了 A 中的<u>元素</u>，还顺便给该元素一个<u>索引值</u> (默认从 0 开始)。
enumerate()与 for 循环的结合使用。
for i, a in enumerate(A)
do something with a
break 语句
break语句可以跳出<u>当前所在层的循环</u>。（while，for语句等......）
continue 语句
continue终止本轮循环并开始下一轮循环。
pass 语句
pass是空语句，不做任何操作，只起到<u>占位</u>的作用，其作用是为了保持程序结构的完整性。
尽管pass语句不做任何操作，但如果<u>暂时不确定要在一个位置放上什么样的代码</u>，可以先放置一个pass语句，让代码可以正常运行。
推导式
列表推导式：[ expr forvalue in collection [ifcondition] ]
a = [(i, j) for i in range(0, 3) for j in range(0, 3)]
print(a)
运行结果为：
[(0, 0), (0, 1), (0, 2), (1, 0), (1, 1), (1, 2), (2, 0), (2, 1), (2, 2)]
- 元组推导式：( expr forvalue in collection [ifcondition] )
a = (x for x in range(10))
print(a)
运行结果为：
<generator object <genexpr> at 0x0000025BE511CC48>
print(tuple(a))
运行结果为：
(0, 1, 2, 3, 4, 5, 6, 7, 8, 9)
元组推导式生成的结果是一个生成器对象（与列表推导式不同）。
获得新元组或新元组中的元素，有以下三种方式：
1. 使用 tuple() 函数，可以直接将生成器对象转换成元组。
a = (x for x in range(1,10))
print(tuple(a))
运行结果为：
(1, 2, 3, 4, 5, 6, 7, 8, 9)
- 2. 直接使用 for 循环遍历生成器对象，可以获得各个元素。
a = (x for x in range(1,10))
for i in a:
print(i,end=' ')
print(tuple(a))
运行结果为：
1 2 3 4 5 6 7 8 9 ()
- 3. 使用next() 方法遍历生成器对象，也可以获得各个元素。
a = (x for x in range(3))
print(a.__next__())
print(a.__next__())
print(a.__next__())
a = tuple(a)
print("转换后的元组：",a)
运行结果为：
0
1
2
转换后的元组： ()
- 注意<u>遍历后原生成器对象将不复存在</u>，会得到空元组！
- 字典推导式：{ key_expr: value_expr for value in collection [if condition] }
b = {i: i % 2 == 0 for i in range(10) if i % 3 == 0}
print(b)
运行结果为：
{0: True, 3: False, 6: True, 9: False}
- 集合推导式：{ expr for value in collection [if condition] }
c = {i for i in [1, 2, 3, 4, 5, 5, 6, 4, 3, 2, 1]}
print(c)
运行结果为：
{1, 2, 3, 4, 5, 6}
其它：next(iterator[, default])
Return the next item from the iterator. If default is given and the iterator is exhausted, it is returned instead of raising StopIteration.
异常处理
- Python 标准异常总结（常见）
<figcaption>上图为Python异常体系中的部分关系。</figcaption>
BaseException：所有异常的基类
Exception：常规异常的基类
OverflowError：数值运算超出最大限制
ZeroDivisionError：除数为零
AssertionError：断言语句（assert）失败
AttributeError：尝试访问未知的对象属性
OSError：操作系统产生的异常（例如打开一个不存在的文件）
ImportError：导入模块失败的时候
IndexError：索引超出序列的范围
KeyError：字典中查找一个不存在的关键字
MemoryError：内存溢出（可通过删除对象释放内存）
NameError：尝试访问一个不存在的变量
SyntaxError：语法错误导致的异常
TypeError：不同类型间的无效操作
ValueError：传入无效的参数
Python 标准警告总结
try - except 语句
语法形式：
try:
检测范围
except Exception[as reason]:
出现异常后的处理代码
工作方式：
首先，执行try子句。
如果没有异常发生，忽略except子句，try子句执行后结束。
如果在执行try子句的过程中发生了异常，那么try子句余下的部分将被忽略。如果异常的类型和except之后的名称相符，那么对应的except子句将被执行。最后执行try - except语句之后的代码。
如果一个异常没有与任何的except匹配，那么这个异常将会传递给上层的try中。
注意：
使用except而不带任何异常类型，不是一个很好的方式。我们不能通过该程序识别出具体的异常信息，因为<u>它捕获所有的异常</u>。
一个try语句可能包含多个except子句，分别来处理不同的特定的异常。<u>最多只有一个分支会被执行。</u>
使用多个except代码块时，必须坚持对其规范排序，要<u>从最具针对性的异常到最通用的异常。</u>
dict1 = {'a': 1, 'b': 2, 'v': 22}
try:
x = dict1['y']
except KeyError:
print('键错误')
except LookupError:
print('查询错误')
else:
print(x)
运行结果为：
键错误
- 一个 except 子句可以同时处理多个异常，这些异常将被放在一个括号里成为一个<u>元组</u>。
try:
s = 1 + '1'
int("abc")
f = open('test.txt')
print(f.read())
f.close()
except (OSError, TypeError, ValueError) as error:
print('出错了！\n原因是：' + str(error))
运行结果为：
出错了！
原因是：unsupported operand type(s) for +: 'int' and 'str'
try - except - finally 语句
语法形式：
try:
检测范围
except Exception[as reason]:
出现异常后的处理代码
finally:
不管try子句里面有没有发生异常,都会被执行的代码
如果一个异常在try子句里被抛出，而又没有任何的except把它截住，那么这个异常会在finally子句执行后被抛出。
try - except - else 语句
语法形式：
try:
检测范围
except:
出现异常后的处理代码
else:
如果没有异常执行这块代码
注意：else语句的存在必须以except语句的存在为前提，在没有except语句的try语句中使用else语句，会引发语法错误。
raise语句
Python 使用raise语句抛出一个指定的异常。
try:
raise NameError('HiThere')
except NameError:
print('An exception flew by!')
运行结果为：
An exception flew by!
python 多重嵌套循环跳出方法记录
目的:多重嵌套循环的情况下,最里面一层循环中止时,直接中止整个多重嵌套循环.
for i in range(10): # 循环2
for j in range(9): # 循环1
print(j)
if i ==3 and j == 2:
break # break1
else:
continue
break # break2
重点在于 continue 和 break 的配合使用
循环1为 for-else模式
循环1的结果只会有2种情况: 1.循环结束,执行else部分; 2.符合if判断条件,循环中断,执行if下的break.
那么就是说,如果循环1完成一个循环,那么就继续进行循环2的下一个循环,如果循环1的循环中断,那么循环2也必须要中断,跳出整个嵌套循环(目的)
也就是说,
循环1的情况2,循环break中断之后,循环2也必须break,因此与循环1同级,在循环1之后放了break2.
循环1的情况1,循环结束,此时不能执行循环2的break2,因此在else下放了continue,在循环1结束后会执行else部分的continue,这个continue是对循环2起作用,因此会跳过执行break2,进行循环2的下一轮循环.
至此,目的达到.
