本文已参与「新人创作礼」活动，一起开启掘金创作之路。
Python基础知识（一）
（一）Python语言简介
1. Python语言概述
python是一门跨平台,开源，免费的解释型计算机程序设计语言。
2. Python语言特点
语法简洁，清晰，比较容易学习和掌握。
python是一门跨平台，开源，免费的解释型高级动态编程语言。
python支持命令式编程，函数式编程，完全支持面向对象程序设计，拥有大量的拓展库。
采用强制空格缩进的方式使得代码具有较好的可读性。
3. Python的版本
python目前存在2.x和3.x两个系列的版本，互相之间不兼容。
python2.x系列最迟将于2020年全年放弃维护和更新。
4. Python编程规范
(1) 缩进
类定义、函数定义、选择结构、循环结构、with块，行尾的冒号表示缩进的开始。
python程序是依靠代码块的缩进来体现代码之间的逻辑关系的，缩进结束就表示一个代码块结束了。
同一级别的代码块的缩进量必须相同。
一般而言，以4个空格位基本缩进单位。
(2) 每一个import语句只能导入一个模块，最好按标准库，拓展库，自定义库的顺序依次导入。
(3) 在每个类、函数定义和一段完整的功能代码之后增加一个空行，在运算符两侧各增加一个空格，逗号后面增加一个空格。
(4) 尽量不要写过长的语句。如果语句过长，可以考虑拆分成多个短一些的语句，以保证代码具有较好的可读性。如果语句确实太 长代码具有较好的可读性。如果语句确实太长而超过屏幕宽度，最好使用续行符“ \ ”，或者使用圆括号将多行代码括起来表示 是一条语句。
(5) 虽然Python运算符有明确的优先级，但对于复杂的表达式建议在适当的位置使用括号使得各种运算的隶属关系和顺序更加明 确、清晰。
(6) 注释
以符号#开始，表示本行#之后的内容为注释。
包含在一对三引号'''...'''或""".…"""之间且不属于任何语句的内容将被解释器认为是注释。
（二）Python语言基础语法
1. 库的导入和使用
python标准库和拓展库中的对象必须先导入才能使用。有三种导入方式。
import 模块名 [as 别名]
这种方法一次可以导入多个模块。但在使用模块中的类，方法，函数，常数等内容时，需要在它前面加上模块名。
import math
print(math.pow(2, 3))
#8.0
import math as ma
print(ma.pow(2, 3))
#8.0
from 模块名 import*
这种方法一次导入一个模块中的所有内容，如某个函数。使用时不需要添加模块名为前缀。可读性较差。
from math import*
print(pow(2,3))
print(sqrt(9))
print(pi)
#8.0
#3.0
#3.141592653589793
from 模块名 import 对象名 [as 别名]
这种方法一次导入一个模块中的指定内容，如某个函数。调用时不需要添加模块名为前缀。
from math import pow,pi
print(pow(2,pi))
#8.824977827076287
2. Python常用内置对象
在python中处理的一切都是对象，整数，实数，复数，字符串，列表，元组，字典，集合都是对象，zip，map，enumerate，filter等函数返回的也是对象，函数和类也是对象。
python中有内置对象，标准库对象和扩展库对象，其中内置对象可以直接使用。
非内置对象需要导入模块才能使用，如正弦函数sin(x)，随机数产生函数random( )等
2.1 常量与变量
在Python中，不需要事先声明变量名及其类型，直接赋值即可创建各种类型的对象变量。这一点适用于Python任意类型的对象。
赋值语句的执行过程是：首先把等号右侧表达式的值计算出来，然后在内存中寻找一个位置把值存放进去，最后创建变量并指向这个内存地址。
Python中的变量 并不直接存储值， 而是存储了值的内存地址或者引用， 这也是变量类型随时可以改变的原因。
Python属于强类型编程语言，Python解释器会根据赋值或运算来自动推断变量类型。
Python还是一种动态类型语言，变量的类型也是可以随时变化的。
# 查看变量类型
x = 4
print(type(x))
x = 'hello word'
print(type(x))
x = [1,2,3]
print(type(x))
# 测试对象是否是某个类型的实例
print(isinstance(3, int))
print(isinstance('hello word',str))
<class 'int'>
<class 'str'>
<class 'list'>
True
True
在定义变量名的时候，需要注意以下问题：
变量名必须以字母或下划线开头，但以下划线开头的变量在Python中有特殊含义。
变量名中不能有空格以及标点符号（括号、引号、逗号、斜线、反斜线、冒号、句号、问号等等）。
不能使用关键字作变量名，可以导入keyword模块后使用print(keyword.kwlist)查看所有Python关键字。
变量名对英文字母的大小写敏感，例如student和Student是不同的变量。
不建议使用系统内置的模块名、类型名或函数名以及已导入的模块名及其成员名作变量名，这将会改变其类型和含义。
2.2 数字
在Python中，内置的数字类型有整数、实数和复数。
整数类型除了常见的十进制整数，还有：
二进制。以0b开头，每一位只能是0或1。
八进制。以0o开头，每一位只能是0、1、2、3、4、5、6、7这八个数字之一。
十六进制。以0x开头，每一位只能是0、1、2、3、4、5、6、7、8、9、a、b、c、d、e、f之一。
python支持任意大的数字（经受内存大小的限制）
print(99999 ** 99)
999010484943188636608805980402802915400434536979655386654009490813859457598616206837179821412302692420911878238392114694353872205705469979997758000847544074497398071603034467574810862492956315403164145181317850364010376300213453752437982265518464568325790559557401725276413045564927258325699353130042548208064924009216093547546101231747525975999315735437260590254281341103015581933843191009768771215462495272328209801935290153265929807401919949633636861142033871459231063562556848951490009899999
由于精度的问题，对于实数运算可能会有一定的误差，应尽量避免在实数之间直接进行相等性测试，而是应该以二者之差的绝对值是否足够小作为两个实数是否相等的依据。
print(0.3-0.2==0.1) # False
print(abs(0.4-0.1 - 0.3) < 1e-6) # True
在数字的算术运算表达式求值时会进行隐式的类型转换，如果存在复数则都变成复数，如果没有复数但是有实数就都变成实数，如果都是整数则不进行类型转换。
x = 3 + 4j #使用j或J表示复数虚部
y = 5 + 6j
print(x + y) #支持复数之间的加、减、乘、除以及幂乘等运算
print(x*y)
print(abs(x)) #内置函数abs()可用来计算复数的模
print(x.imag) #虚部
print(x.real) #实部
print(x.conjugate()) #共轭复数
(8+10j)
(-9+38j)
5.0
4.0
3.0
(3-4j)
2.3 字符串
在Python中，没有字符常量和变量的概念，只有字符串类型的常量和变量，单个字符也是字符串。使用单引号、双引号、三单引号、三双引号作为定界符来表示字符串，并且不同的定界符之间可以互相嵌套。
Python 3.x全面支持中文，中文和英文字母都作为一个字符对待，甚至可以使用中文作为变量名。
除了支持使用加号运算符连接字符串以外，Python字符串还提供了大量的方法支持格式化、查找、替换、排版等操作。
2.4 列表 元组 字典 集合
x_list = [1, 2, 3] #创建列表对象
x_tuple = (1, 2, 3) #创建元组对象
x_dict = {'a': 97, 'b': 98, 'c': 99} #创建字典对象
x_set = {1, 2, 3} #创建集合对象
print(x_list[1]) #使用下标访问指定位置的元素
print(x_tuple[1]) #元组也支持使用序号作为下标
print(x_dict['a']) #字典对象的下标是“键”
print(3 in x_set) #成员测试
2
2
97
True
2.5 Python运算符与表达式
算术运算符
print([1, 2, 3] + [4, 5, 6]) # 连接两个列表 [1, 2, 3, 4, 5, 6]
print((1, 2, 3) + (4,)) # 连接两个元组 (1, 2, 3, 4)
print('abcd' + '1234') # 连接两个字符串 abcd1234
# print('A' + 1) # 不支持字符与数字相加，抛出异常
print(True + 3) # Python内部把True当作1处理 4
print(False + 3) # 把False当作0处理 3
print(True * 3) # 3
print(False * 3) # 0
print([1, 2, 3] * 3) # [1, 2, 3, 1, 2, 3, 1, 2, 3]
print((1, 2, 3) * 3) # (1, 2, 3, 1, 2, 3, 1, 2, 3)
print('abc' * 3) # abcabcabc
print(3 / 2) # 数学意义上的除法 1.5
print(15 // 4) # 如果两个操作数都是整数，结果为整数 3
print(15.0 // 4) # 如果操作数中有实数，结果为实数形式的整数值 3.0
print(-15//4) # 向下取整 -4
print(789 % 23) # 余数 7
print(123.45 % 3.2) # 可以对实数进行余数运算，注意精度问题 1.849999999999996
print('%c, %d' % (65, 65)) # 把65分别格式化为字符和整数 A, 65
print('%f,%s' % (65, 65)) # 把65分别格式化为实数和字符串 65.000000,65
print(3 ** 2) # 3的2次方，等价于pow(3, 2) 9
print(pow(3, 2, 8)) # 等价于(3**2) % 8 1
print(9 ** 0.5) # 9的0.5次方，平方根 3.0
print((-9) ** 0.5) # 可以计算负数的平方根 (1.8369701987210297e-16+3j)
关系运算符
print(1 < 3 < 5) # 等价于1 < 3 and 3 < 5 True
print(3 < 5 > 2) # True
print(1 > 6 < 8) # False
print(1 > 6 < math.sqrt(9)) # 具有惰性求值或者逻辑短路的特点 False
print(1 < 6 < math.sqrt(9)) # 还没有导入math模块，抛出异常 NameError: name 'math' is not defined
import math
print(1 < 6 < math.sqrt(9)) # False
print('Hello' > 'world') #比较字符串大小 False
print([1, 2, 3] < [1, 2, 4]) #比较列表大小 True
# print('Hello' > 3) #字符串和数字不能比较 TypeError: unorderable types: str() > int()
print({1, 2, 3} < {1, 2, 3, 4}) #测试是否子集 True
print({1, 2, 3} == {3, 2, 1}) #测试两个集合是否相等 True
print({1, 2, 4} > {1, 2, 3}) #集合之间的包含测试 False
print({1, 2, 4} < {1, 2, 3}) #False
print({1, 2, 4} == {1, 2, 3}) #False
成员测试运算符in
print(3 in [1, 2, 3]) # 测试3是否存在于列表[1, 2, 3]中 True
print(5 in range(1, 10, 1)) # range()是用来生成指定范围数字的内置函数 True
print('abc' in 'abcdefg') # 子字符串测试 True
for i in (3, 5, 7): # 循环，成员遍历 3 5 7
print(i, end='\t')
集合运算符
print({1, 2, 3} | {3, 4, 5}) # 并集，自动去除重复元素 {1, 2, 3, 4, 5}
print({1, 2, 3} & {3, 4, 5}) # 交集 {3}
print({1, 2, 3} ^ {3, 4, 5}) # 对称差集 {1, 2, 4, 5}
print({1, 2, 3} - {3, 4, 5}) # 差集
逻辑运算符
print(3>5 and a>3) # 注意，此时并没有定义变量a False
# print(3>5 or a>3 ) # 3>5的值为False，所以需要计算后面表达式 NameError: name 'a' is not defined
print(3<5 or a>3 ) # 3<5的值为True，不需要计算后面表达式 True
print(3 and 5) # 最后一个计算的表达式的值作为整个表达式的值 5
print(3 and 5>2) # True
print(3 not in [1, 2, 3]) # 逻辑非运算not False
print(3 is not 5) # not的计算结果只能是True或False之一 True
print(not 3) # False
print(not 0) # True
逻辑运算符and、or、not常用来连接条件表达式构成更加复杂的条件表达式，并且and和or具有惰性求值或逻辑短路的特点，当连接多个表达式时只计算必须要计算的值。
运算符and和or并不一定会返回True或False，而是得到最后一个被计算的表达式的值，但是运算符not一定会返回True或False。
Python还有赋值运算符=和+=、-=、*=、/=、//=、**=、|=、^=等大量复合赋值运算符。
Python不支持++和--运算符，虽然在形式上有时候似乎可以这样用，但实际上是另外的含义，要注意和其他语言的区别。
i = 3
print(++i) #正正得正 3
print(+(+3)) #与++i等价 3
print(i++) #Python不支持++运算符，语法错误 SyntaxError: invalid syntax
print(--i) #负负得正，等价于-(-i) 3
print(---i) #等价于-(-(-i)) -3
print(i--) #Python不支持--运算符，语法错误 SyntaxError: invalid syntax
3. Python常用内置函数
内置函数 bin()、oct()、hex()用来将整数转换为二进制、八进制和十六进制形式，这三个函数都要求参数必须为整数。
内置函数float()用来将其他类型数据转换为实数，complex()可以用来生成复数。
§ord()和chr()是一对功能相反的函数，ord()用来返回单个字符的Unicode码，而chr()则用来返回Unicode编码对应的字符，str()则直接将其任意类型参数转换为字符串。
>>> ord('a') #查看指定字符的Unicode编码
97
>>> chr(65) #返回数字65对应的字符
'A'
>>> chr(ord('A')+1) #Python不允许字符串和数字之间的加法操作
'B'
>>> chr(ord('国')+1) #支持中文
'图'
>>> ord('董') #这个用法仅适用于Python 3.x
33891
list()、tuple()、dict()、set()用来把其他类型的数据转换成为列表、元组、字典、集合，或者创建空列表、空元组、空字典和空集合。
>>> list(range(5)) #把range对象转换为列表
[0, 1, 2, 3, 4]
>>> tuple(_) #一个下划线表示上一次正确的输出结果
(0, 1, 2, 3, 4)
>>> dict(zip('1234', 'abcde')) #创建字典
{'4': 'd', '2': 'b', '3': 'c', '1': 'a'}
>>> set('1112234') #创建可变集合，自动去除重复
{'4', '2', '3', '1'}
内置函数type()和isinstance()可以用来判断数据类型，常用来对函数参数进行检查，可以避免错误的参数类型导致函数崩溃或返回意料之外的结果。
内置函数eval()用来计算字符串的值，在有些场合也可以用来实现类型转换的功能。
>>> eval('3+5')
8
>>> eval('9') #把数字字符串转换为数字
9
>>> eval('09') #抛出异常，不允许以0开头的数字
SyntaxError: invalid token
>>> int('09') #这样转换是可以的
9
>>> list(str([1, 2, 3, 4])) #字符串中每个字符都变为列表中的元素
['[', '1', ',', ' ', '2', ',', ' ', '3', ',', ' ', '4', ']']
eval(str([1, 2, 3, 4])) #字符串求值
[1, 2, 3, 4]
max()、min()、sum()这三个内置函数分别用于计算列表、元组或其他包含有限个元素的可迭代对象中所有元素最大值、最小值以及所有元素之和。
sum()默认（可以通过start参数来改变）支持包含数值型元素的序列或可迭代对象，max()和min()则要求序列或可迭代对象中的元素之间可比较大小。
函数max()和min()还支持default参数和key参数，其中default参数用来指定可迭代对象为空时默认返回的最大值或最小值，而key参数用来指定比较大小的依据或规则，可以是函数或lambda表达式。
>>> max(['2', '111']) #不指定排序规则
'2'
>>> max(['2', '111'], key=len) #返回最长的字符串
'111'
>>> print(max([], default=None)) #对空列表求最大值，返回空值None
None
input()和print()是Python的基本输入输出函数，前者用来接收用户的键盘输入，后者用来把数据以指定的格式输出到标准控制台或指定的文件对象。不论用户输入什么内容，input()一律返回字符串对待，必要的时候可以使用内置函数int()、float()或eval()对用户输入的内容进行类型转换。
内置函数print()用于输出信息到标准控制台或指定文件，语法格式为：
print(value1, value2, ..., sep=' ', end='\n', file=sys.stdout, flush=False)
sep参数之前为需要输出的内容（可以有多个）。
sep参数用于指定数据之间的分隔符，默认为空格。
end参数用于指定输出完数据之后再输出什么字符。
>>> print(1, 3, 5, 7, sep='\t') #修改默认分隔符
1 3 5 7
>>> for i in range(10): #修改end参数，每个输出之后不换行
print(i, end=' ')
0 1 2 3 4 5 6 7 8 9
sorted()对列表、元组、字典、集合或其他可迭代对象进行排序并返回新列表，
reversed()对可迭代对象（生成器对象和具有惰性求值特性的zip、map、filter、enumerate等类似对象除外）进行翻转（首尾交换）并返回可迭代的reversed对象。
>>> x = list(range(11))
>>> import random
>>> random.shuffle(x) #打乱顺序
>>> x
[2, 4, 0, 6, 10, 7, 8, 3, 9, 1, 5]
>>> sorted(x) #以默认规则排序
[0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10]
>>> sorted(x, key=lambda item:len(str(item)), reverse=True) #按转换成字符串以后的长度降序排列
[10, 2, 4, 0, 6, 7, 8, 3, 9, 1, 5]
>>> sorted(x, key=str) #按转换成字符串以后的大小升序排列
[0, 1, 10, 2, 3, 4, 5, 6, 7, 8, 9]
>>> x = ['aaaa', 'bc', 'd', 'b', 'ba']
>>> sorted(x, key=lambda item: (len(item), item)) #先按长度排序，长度一样的正常排序
['b', 'd', 'ba', 'bc', 'aaaa']
>>> reversed(x) #逆序，返回reversed对象
<list_reverseiterator object at 0x0000000003089E48>
>>> list(reversed(x)) #reversed对象是可迭代的
[5, 1, 9, 3, 8, 7, 10, 6, 0, 4, 2]
enumerate()函数用来枚举可迭代对象中的元素，返回可迭代的enumerate对象，其中每个元素都是包含索引和值的元组。
>>> list(enumerate('abcd')) #枚举字符串中的元素
[(0, 'a'), (1, 'b'), (2, 'c'), (3, 'd')]
>>> list(enumerate(['Python', 'Greate'])) #枚举列表中的元素
[(0, 'Python'), (1, 'Greate')]
>>> list(enumerate({'a':97, 'b':98, 'c':99}.items())) #枚举字典中的元素
[(0, ('c', 99)), (1, ('a', 97)), (2, ('b', 98))]
>>> for index, value in enumerate(range(10, 15)): #枚举range对象中的元素
print((index, value), end=' ')
(0, 10) (1, 11) (2, 12) (3, 13) (4, 14)
内置函数map()把一个函数func依次映射到序列或迭代器对象的每个元素上，并返回一个可迭代的map对象作为结果，map对象中每个元素是原序列中元素经过函数func处理后的结果。
>>> list(map(str, range(5))) #把列表中元素转换为字符串
['0', '1', '2', '3', '4']
>>> def add5(v): #单参数函数
return v+5
>>> list(map(add5, range(10)))#把单参数函数映射到一个序列的所有元素
[5, 6, 7, 8, 9, 10, 11, 12, 13, 14]
>>> def add(x, y): #可以接收2个参数的函数
return x+y
>>> list(map(add, range(5), range(5,10))) #把双参数函数映射到两个序列上
[5, 7, 9, 11, 13]
>>> import random
>>> x = random.randint(1, 1e30) #生成指定范围内的随机整数
>>> x
839746558215897242220046223150
>>> list(map(int, str(x))) #提取大整数每位上的数字
[8, 3, 9, 7, 4, 6, 5, 5, 8, 2, 1, 5, 8, 9, 7, 2, 4, 2, 2, 2, 0, 0, 4, 6, 2, 2, 3, 1, 5, 0]
标准库functools中的函数reduce()可以将一个接收2个参数的函数以迭代累积的方式从左到右依次作用到一个序列或迭代器对象的所有元素上，并且允许指定一个初始值。
>>> from functools import reduce
>>> seq = list(range(1, 10))
>>> reduce(lambda x, y: x+y, seq)
45
内置函数filter()将一个单参数函数作用到一个序列上，返回该序列中使得该函数返回值为True的那些元素组成的filter对象，如果指定函数为None，则返回序列中等价于True的元素。
>>> seq = ['foo', 'x41', '?!', '***']
>>> def func(x):
return x.isalnum() #测试是否为字母或数字
>>> filter(func, seq) #返回filter对象
<filter object at 0x000000000305D898>
>>> list(filter(func, seq)) #把filter对象转换为列表
['foo', 'x41']
range()是Python开发中非常常用的一个内置函数，语法格式为range([start,] end [, step] )，有range(stop)、range(start, stop)和range(start, stop, step)三种用法。该函数返回具有惰性求值特点的range对象，其中包含左闭右开区间[start,end)内以step为步长的整数。参数start默认为0，step默认为1。
>>> range(5) #start默认为0，step默认为1
range(0, 5)
>>> list(_)
[0, 1, 2, 3, 4]
>>> list(range(1, 10, 2)) #指定起始值和步长
[1, 3, 5, 7, 9]
>>> list(range(9, 0, -2)) #步长为负数时，start应比end大
[9, 7, 5, 3, 1]
zip()函数用来把多个可迭代对象中的元素压缩到一起，返回一个可迭代的zip对象，其中每个元素都是包含原来的多个可迭代对象对应位置上元素的元组，如同拉拉链一样。
>>> list(zip('abcd', [1, 2, 3])) #压缩字符串和列表
[('a', 1), ('b', 2), ('c', 3)]
>>> list(zip('123', 'abc', ',.!')) #压缩3个序列
[('1', 'a', ','), ('2', 'b', '.'), ('3', 'c', '!')]
>>> x = zip('abcd', '1234')
>>> list(x)
[('a', '1'), ('b', '2'), ('c', '3'), ('d', '4')]
