Task1
一：变量、运算符、数据类型
1.注释
单行注释：#123
多行注释：’’’ ‘’’,""" “”"
‘’‘1
2
3 ‘’’
2.运算符
a = “hello”
b = “hello”
print(a is b, a == b) # True True
（以上a,b为字符串类型）
a = [“hello”]
b = [“hello”]
print(a is b, a == b) # False True
print(a is not b, a != b) # True False
注意：
is, is not 对比的是两个变量的内存地址
==, != 对比的是两个变量的值
比较的两个变量，指向的都是地址不可变的类型（str等），那么is，is not 和 ==，！= 是完全等价的。
对比的两个变量，指向的是地址可变的类型（list，dict，tuple等），则两者是有区别的。
运算符的优先级：
一元运算符优于二元运算符。例如3 ** -2等价于3 ** (-2)。
先算术运算，后移位运算，最后位运算。例如 1 << 3 + 2 & 7等价于 (1 << (3 + 2)) & 7。
逻辑运算最后结合。例如3 < 4 and 4 < 5等价于(3 < 4) and (4 < 5)。
3.变量和赋值
在使用变量之前，需要对其先赋值。
变量名可以包括字母、数字、下划线、但变量名不能以数字开头。
Python 变量名是大小写敏感的，foo != Foo。
4.数据类型与转换
（1）小数位数
a = 1031
print(bin(a)) # 0b10000000111
print(a.bit_length()) # 11，a的二进制位数
想保留浮点型的小数点后 n 位，可以用 decimal 包里的 Decimal 对象和 getcontext() 方法来实现。
import decimal
from decimal import Decimal
a = decimal.getcontext()#getcontext() 显示了 Decimal 对象的默认精度值是 28 位 (prec=28)
print(a)
输出： Context(prec=28, rounding=ROUND_HALF_EVEN, Emin=-999999, Emax=999999,
capitals=1, clamp=0, flags=[], traps=[InvalidOperation, DivisionByZero, Overflow])
decimal.getcontext().prec = 4
eg:
c = Decimal(1) / Decimal(3)
print©
#0.3333
（2）bool(x)创建变量
X 可以是基本类型：整型、浮点型、布尔型
容器类型：字符串、元组、列表、字典和集合
bool 作用在基本类型变量：X 只要不是整型 0、浮点型 0.0，bool(X) 就是 True，其余就是 False
bool 作用在容器类型变量：X 只要不是空的变量，bool(X) 就是 True，其余就是 False。接：确定
bool(X) 的值是 True 还是 False，就看 X 是不是空，空的话就是 False，不空的话就是 True。对于
数值变量，0, 0.0 都可认为是空的，对于容器变量，里面没元素就是空的。获取类型信息 type(object)
（3）type()和 isinstance()
type() 不会认为子类是一种父类类型，不考虑继承关系。
isinstance() 会认为子类是一种父类类型，考虑继承关系。
如果要判断两个类型是否相同推荐使用 isinstance()。
5.print()
print(*objects, sep=’ ‘, end=’\n’, file=sys.stdout, flush=False)
将对象以字符串表示的方式格式化输出到流文件对象file里。其中所有非关键字参数都按str()方式进行转换为字符串输出；
关键字参数sep是实现分隔符，比如多个参数输出时想要输出中间的分隔字符；
关键字参数end是输出结束时的字符，默认是换行符\n；
关键字参数file是定义流输出的文件，可以是标准的系统输出sys.stdout，也可以重定义为别的文件；
关键字参数flush是立即把内容输出到流文件，不作缓存。
item值与’another string’两个值之间用sep设置的参数&分割。由于end参数没有设置，
因此默认是输出解释后换行，即end参数的默认值为\n，若设置可为end=’ ‘,即可不换行
shoplist = [‘apple’, ‘mango’]
for item in shoplist:
print(item, ‘another string’, sep=’&’)
输出：
apple&another string
mango&another string
二：位运算
1.原码、反码和补码
注：计算机内部使用补码来表示
原码：就是其二进制表示（注意，有一位符号位）。
00 00 00 11 -> 3
10 00 00 11 -> -3
反码：正数的反码就是原码，负数的反码是符号位不变，其余位取反（对应正数按位取反）。
00 00 00 11 -> 3
11 11 11 00 -> -3
补码：正数的补码就是原码，负数的补码是反码+1。
00 00 00 11 -> 3
11 11 11 01 -> -3
符号位：最高位为符号位，0表示正数，1表示负数。在位运算中符号位也参与运算。
2.按位运算
-
按位非操作 ~
- 1 = 0
-
0 = 1
~把num的补码中的 0 和 1 全部取反（0 变为 1，1 变为 0）有符号整数的符号位在~运算中同样会取反。
按位与操作 &
只有两个对应位都为 1 时才为 1，否则为0
1 & 1 = 1
1 & 0 = 0
0 & 1 = 0
0 & 0 = 0
按位或操作 |
只要两个对应位中有一个 1 时就为 1
1 | 1 = 1
1 | 0 = 1
0 | 1 = 1
0 | 0 = 0
按位异或操作 ^
只有两个对应位不同时才为 1
1 ^ 1 = 0
1 ^ 0 = 1
0 ^ 1 = 1
0 ^ 0 = 0
异或操作的性质：满足交换律和结合律
A: 00 00 11 00
B: 00 00 01 11
A^B: 00 00 10 11
B^A: 00 00 10 11
A^A: 00 00 00 00
A^0: 00 00 11 00
ABA: = AAB = B = 00 00 01 11
按位左移操作 <<，空位补0
num << i 将num的二进制表示向左移动i位所得的值。
00 00 10 11 -> 11
11<<3
01 01 10 00 -> 88
按位右移操作 >>，空位补0
num >> i 将num的二进制表示向右移动i位所得的值。
00 00 10 11 -> 11
11 >> 2
00 00 00 10 -> 2
3. 利用位运算实现快速计算
通过 <<，>> 快速计算2的倍数问题：
n << 1 -> 计算 n2
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 & (-a) 快速获取a的最后为 1 位置的整数：
00 00 01 01 -> 5
&
11 11 10 11 -> -5
00 00 00 01 -> 1
00 00 11 10 -> 14
&
11 11 00 10 -> -14
00 00 00 10 -> 2
4. 利用位运算实现整数集合
一个数的二进制表示可以看作是一个集合（0 表示不在集合中，1 表示在集合中）。
比如集合 {1, 3, 4, 8}，可以表示成 01 00 01 10 10 而对应的位运算也就可以看作是对集合进行的操作。
元素与集合的操作：
a | (1<
a & ~(1<
a & (1<
集合之间的操作：
a 补 -> ~a
a 交 b -> a & b
a 并 b -> a | b
a 差 b -> a & (~b)
注意：整数在内存中是以补码的形式存在的，输出自然也是按照补码输出。
print(bin(3)) # 0b11
print(bin(-3)) # -0b11
print(bin(-3 & 0xffffffff))
#0b11111111111111111111111111111101
print(bin(0xfffffffd))
#0b11111111111111111111111111111101
print(0xfffffffd) # 4294967293
Python中bin一个负数（十进制表示），输出的是它的原码的二进制表示加上个负号，巨坑。
Python中的整型是补码形式存储的。
Python中整型是不限制长度的不会超范围溢出。
所以为了获得负数（十进制表示）的补码，需要手动将其和十六进制数0xffffffff进行按位与操作，
再交给bin()进行输出，得到的才是负数的补码表示。
三.条件语句
1. if elif else
temp = input(‘请输入成绩:’)//input 函数将接收的任何数据类型都默认为 str。
source = int(temp)
if 100 >= source >= 90:
print(‘A’)
elif 90 > source >= 80:
print(‘B’)
elif 80 > source >= 60:
print(‘C’)
elif 60 > source >= 0:
print(‘D’)
else:
print(‘输入错误！’)
- assert 关键词
assert这个关键词我们称之为“断言”，当这个关键词后边的条件为 False 时，程序自动崩溃并抛出AssertionError的异常。
四.循环语句
- while 循环
while语句最基本的形式包括一个位于顶部的布尔表达式，一个或多个属于while代码块的缩进语句。
while 布尔表达式:
代码块
while循环的代码块会一直循环执行，直到布尔表达式的值为布尔假。
如果布尔表达式不带有<、>、==、！=、in、not in等运算符，仅仅给出数值之类的条件，也是可以的。
当while后写入一个非零整数时，视为真值，执行循环体；写入0时，视为假值，不执行循环体。也可以写
入str、list或任何序列，长度非零则视为真值，执行循环体；否则视为假值，不执行循环体。
string = ‘abcd’
while string:
print(string)
string = string[1:]
#abcd
#bcd
#cd
#d
2. while - else 循环
当while循环正常执行完的情况下，执行else输出，如果while循环中执行了跳出循环的语句，比如 break，将不执行else代码块的内容
while 布尔表达式:
代码块
break
else:
代码块
3. for 循环
for循环是迭代循环，在Python中相当于一个通用的序列迭代器，可以遍历任何有序序列，如str、list、tuple等，
也可以遍历任何可迭代对象，如dict。
for 迭代变量 in 可迭代对象:
代码块
dic = {‘a’: 1, ‘b’: 2, ‘c’: 3, ‘d’: 4}
for key, value in dic.items():
print(key, value, sep=’:’, end=’ ‘)
for key in dic.keys():
print(key, end=’ ‘)
for value in dic.values():
print(value, end=’ ')
#a:1 b:2 c:3 d:4
#a b c d
#1 2 3 4
4. for - else 循环
for 迭代变量 in 可迭代对象:
代码块
else:
代码块
for num in range(10, 20): # 迭代 10 到 20 之间的数字
for i in range(2, num): # 根据因子迭代
if num % i == 0: # 确定第一个因子
j = num / i # 计算第二个因子
print(’%d 等于 %d * %d’ % (num, i, j))
break # 跳出当前循环
else: # 循环的 else 部分
print(num, ‘是一个质数’)
#10 等于 2 * 5
#11 是一个质数
#12 等于 2 * 6
#13 是一个质数
#14 等于 2 * 7
#15 等于 3 * 5
#16 等于 2 * 8
#17 是一个质数
#18 等于 2 * 9
#19 是一个质数
5. range() 函数
range([start,] stop[, step=1])
这个BIF（Built-in functions）有三个参数，其中用中括号括起来的两个表示这两个参数是可选的。
step=1 表示第三个参数的默认值是1，即遍历取值之间数值差为1。
range 这个BIF的作用是生成一个从start参数的值开始到stop参数的值结束的数字序列，该序列包含start的值但不包含stop的值。
6. enumerate()函数
enumerate(sequence, [start=0])//默认为0，如果不自己赋值
sequence：一个序列、迭代器或其他支持迭代对象。
start：下标起始位置。
返回 enumerate(枚举) 对象
seasons = [‘Spring’, ‘Summer’, ‘Fall’, ‘Winter’]
lst = list(enumerate(seasons, start=1)) # 下标从 1 开始
print(lst)
[(1, ‘Spring’), (2, ‘Summer’), (3, ‘Fall’), (4, ‘Winter’)]
enumerate()与 for 循环的结合使用。
for i, a in enumerate(A)
do something with a
用 enumerate(A) 不仅返回了 A 中的元素，还顺便给该元素一个索引值 (默认从 0 开始)。此外，
用 enumerate(A, j) 还可以确定索引起始值为 j
for i, language in enumerate(languages, 2):
print(i, ‘I love’, language)
print(‘Done!’)
#2 I love Python
#3 I love R
#4 I love Matlab
#5 I love C++
#Done!
7. break 语句
break语句可以跳出当前所在层的循环。
8. continue 语句
continue终止本轮循环并开始下一轮循环。
9. pass 语句
pass 语句的意思是“不做任何事”，如果你在需要有语句的地方不写任何语句，那么解释器会提示出错，
而 pass 语句就是用来解决这些问题的
def a_func():
SyntaxError: unexpected EOF while parsing
def a_func():
pass
pass是空语句，不做任何操作，只起到占位的作用，其作用是为了保持程序结构的完整性。尽管pass语句不
做任何操作，但如果暂时不确定要在一个位置放上什么样的代码，可以先放置一个pass语句，让代码可以正常运行
10. 推导式
列表推导式
[ expr for value in collection [if condition] ]，expr为输出的，condition为条件
x = [-4, -2, 0, 2, 4]
y = [a * 2 for a in x]
print(y)
#[-8, -4, 0, 4, 8]
x = [i ** 2 for i in range(1, 10)]
print(x)
[1, 4, 9, 16, 25, 36, 49, 64, 81]
x = [(i, i ** 2) for i in range(6)]
print(x)
#[(0, 0), (1, 1), (2, 4), (3, 9), (4, 16), (5, 25)]
x = [i for i in range(100) if (i % 2) != 0 and (i % 3) == 0]
print(x)
#[3, 9, 15, 21, 27, 33, 39, 45, 51, 57, 63, 69, 75, 81, 87, 93, 99]
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)]
a = [(i, j) for i in range(0, 3) if i < 1 for j in range(0, 3) if j > 1]
print(a)
[(0, 2)]
元组推导式
( expr for value in collection [if condition] )
a = (x for x in range(10))
print(a)
print(tuple(a))
#(0, 1, 2, 3, 4, 5, 6, 7, 8, 9)
字典推导式
{ 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©
#{1, 2, 3, 4, 5, 6}
其它
next(iterator[, default])
e = (i for i in range(10))
print(e)
print(next(e)) # 0
print(next(e)) # 1
for each in e:
print(each, end=’ ')
#2 3 4 5 6 7 8 9
五.异常处理
1. try - except 语句
try:
检测范围
except Exception[as reason]:
出现异常后的处理代码
try 语句按照如下方式工作：
首先，执行try子句（在关键字try和关键字except之间的语句）
如果没有异常发生，忽略except子句，try子句执行后结束。
如果在执行try子句的过程中发生了异常，那么try子句余下的部分将被忽略。如果异常的类型和except之后的名称相符，那么对应的except子句将被执行。最后执行try - except语句之后的代码。
如果一个异常没有与任何的except匹配，那么这个异常将会传递给上层的try中
一个try语句可能包含多个except子句，分别来处理不同的特定的异常。最多只有一个分支会被执行
try:
f = open(‘test.txt’)
print(f.read())
f.close()
except OSError as error:
print(‘打开文件出错\n原因是：’ + str(error))
#打开文件出错
原因是：[Errno 2] No such file or directory: ‘test.txt’
dict1 = {‘a’: 1, ‘b’: 2, ‘v’: 22}
try:
x = dict1[‘y’]
except LookupError:
print(‘查询错误’)
except KeyError:
print(‘键错误’)
else:
print(x)
#查询错误
try-except-else语句尝试查询不在dict中的键值对，从而引发了异常。这一异常准确地说应属于KeyError，
但由于KeyError是LookupError的子类，且将LookupError置于KeyError之前，因此程序优先执行该except代码块。
所以，使用多个except代码块时，必须坚持对其规范排序，要从最具针对性的异常到最通用的异常。
一个 except 子句可以同时处理多个异常，except (OSError, TypeError, ValueError) as error:
2. try - except - finally 语句
不管try子句里面有没有发生异常，finally子句都会执行
finally:
print(“executing finally clause”)
3. try - except - else 语句
try:
检测范围
except:
出现异常后的处理代码
else:
如果没有异常执行这块代码
注意：else语句的存在必须以except语句的存在为前提，在没有except语句的try语句中使用else语句，会引发语法错误
4. raise语句
可以抛出一个指定的异常
try:
raise NameError(‘HiThere’)
except NameError:
print(‘An exception flew by!’)
#An exception flew by!