一天速成Python教程

一、Python基础

Python是对象有类型，变量无类型的动态类型语言，追求简单优雅易读。可以在终端中逐行运行，也可以编写成大型的面向对象的工程。在开始写之前，注意Python 2.X中，开头要写上#coding:utf-8，并且Python通过缩进知道一个特定的代码块于周围的代码保持独立。所用的空格数很重要，因此应该使用编辑器确定缩进，并且不要手动改变空格数。根据PEP的规定，必须使用4个空格来表示每级缩排。使用Tab字符和其它数目的空格虽然都可以编译通过，但不符合编码规范。

1.数字和字符

1. Python本身支持整数与浮点数，计算如下表

运算符	描述	示例	运算结果
+	加	7 + 2	9
-	减	7 - 2	5
*	乘	7 * 2	14
/	浮点数除法	7 / 2	3.5
//	整数除法	7 // 2	3
%	求余	7 % 2	1
**	幂	7 ** 2	49

强制类型转换使用int(num)与float(num)进行。

1. 字符串

使用引号包裹，例如：

>>> 'python'
'python'
>>> "python"
'python'

可见可以使用两种引号进行创建，这样的好处是可以创建本身就包含引号的字符串，而不用使用转义符。可以在双引号包裹的字符串使用单引号，或者在单引号包裹的字符串中使用双引号：

>>> "'She' is a boy."
"'She' is a boy."
>>> 'A "boy" likes her.'
'A "boy" likes her.'

还可以使用三个单引号创建字符串：

>>> '''
... 我们去看烟火好吗
... 去，去看那
... 繁花之中如何再生繁花
... 梦境之上如何再现梦境
... '''
'\n我们去看烟火好吗\n去，去看那\n繁花之中如何再生繁花\n梦境之上如何再现梦境\n'

• 在字符串中使用str(value)进行强制类型转换。

• 使用\进行转义

>>> print('a\tbc')
a       bc

• 使用+进行拼接

>>> a = 'apple'
>>> b = 'pen'
>>> a + ' ' + b
'apple pen'

• 使用*复制

>>> s = 'apple'
>>> s * 3
'appleappleapple'

• 使用[]提取字符

>>> letters = 'abcdefg'
>>> letters[0]
'a'
>>> letters[4]
'e'

• 使用[start:end:step]分片

# [:] 提取全部
# [start:] 从start到结尾
# [:end] 从开头到end - 1
# [start:end] 从strat到end - 1
# [start:end:step] 从start到end - 1，每step个字符提取一个
>>> letters = 'abcdefghijklmn'
>>> letters[:]
'abcdefghijklmn'
>>> letters[3:]
'defghijklmn'
>>> letters[:3]
'abc'
>>> letters[3:7]
'defg'
>>> letters[0:4:2]
'ac'
>>> letters[-1::]
'n'
>>> letters[::-1]
'nmlkjihgfedcba'

• 使用len(value)获得长度

>>> letters = 'abcdefghijklmn'
>>> len(letters)
14

• 使用split(value)进行分割，value填写分割字符，返回一个列表

>>> letters = 'a,b,c,d,e,f'
>>> letters.split(',')
['a', 'b', 'c', 'd', 'e', 'f']

• 同样可以使用join()将列表进行合并成字符串

>>> letters_list = letters.split(',')
>>> ','.join(letters_list)
'a,b,c,d,e,f'

• 最后，可以使用`replace(sub, newsub, n), sub是需要被替换的子串，newsub是用于替换的新子串,n是需要替换多少处

>>> setup = 'a boy likes playing basketball.'
>>> setup.replace('boy','girl')
'a girl likes playing basketball.'
>>> setup.replace('a', 'b')
'b boy likes plbying bbsketbbll.'
>>> setup.replace('a', 'b', 1)
'b boy likes playing basketball.'

2.语句

1.import语句，导入模块使用，两种形式：

形式1：import module-name。import后面跟空格，然后是模块名称，例如：import os

形式2：from module1 import module11。module1是一个大模块，里面还有子模块module11，只想用module11，就这么写了。

2.条件语句：

if...elif...else语句

if 条件1:
执行的内容1
elif 条件2:
执行的内容2
elif 条件3：
执行的内容3
else:
执行的内容4

3.循环语句：

for语句

for 循环规则：
操作语句

for循环所应用的对象，应该是可迭代的。

判断一个对象是否可迭代使用collections模块的Iterable类型判断：

>>> from collections import Iterable
>>> isinstance('abc',Iterable)
True
>>> isinstance([1,2,3,4],Iterable)
True
>>> isinstance(1234,Iterable)
False

while语句

和C语言中大同小异，只不过可以使用while...else...,同理，在for语句中也可以使用for... else...

#test.py
a = 3
b = 2
while a > b:
print('a>b')
a -= 1
else:
print('a<b')

$ python test.py
a>b
a<b

循环（loop），指的是在满足条件的情况下，重复执行同一段代码。比如，while语句。

迭代（iterate），指的是按照某种顺序逐个访问列表中的每一项。比如，for语句。

递归（recursion），指的是一个函数不断调用自身的行为。比如，以编程方式输出著名的斐波纳契数列。

遍历（traversal），指的是按照一定的规则访问树形结构中的每个节点，而且每个节点都只访问一次。

3.函数

1.定义函数

使用def:函数的开头，define的缩写，后面跟函数名称和参数，最后一点要加“：”冒号。例如 def add(x,y):

2.函式体的第一个语句可以是字串（即为注释）; 这个字串就是函式的文档字符串, 或称为 docstring。例如：

def split_data_set(dataSet, axis, value):
"""
输入：数据集，选择维度，选择值
输出：划分数据集
描述：按照给定特征划分数据集；去除选择维度中等于选择值的项
"""

3.命名规范，这里参考PEP8

b（单个小写字母）

B（单个大写字母）

小写（小写）

lower_case_with_underscores（含底线的小写）

大写（UPPERCASE）

UPPER_CASE_WITH_UNDERSCORES（含底线的大写）

大写字母（字首大写，又称CapWords或CamelCase - 如此称呼是因为字母看起来崎岖不平[4]），有时也称为StudlyCaps。

注意：如果有缩写字，将缩写字的每个字母大写。也就是写HTTPServerError比HttpServerError好。

mixedCase（类似字首大写，只差开头单字的第一个字母是小写）

Capitalized_Words_With_Underscores（字首大写加底线）

来自命名惯例

4.参数与变量

形参与实参：

函数名后面的括号里如果有变量，它们通常被称为“形参”。调用函数的时候，给函数提供的值叫做“实参”，或者“参数”。个人理解，实参是在函数调用前就实际存在的参数，而形参是在调用函数的时候，用于将实参的值传入函数用的。

参数与变量的区别，每个形参的名称均可作为过程内的局部变量。形参名称的使用方法与其他任何变量的使用方法相同。

实参表示在您调用过程时传递给过程形参的值。

局部变量与全局变量：

在函数里面的就是局部变量，在函数外面的就是局部变量。在C和JAVA中主要是有一个主函数或主方法开始运行的地方，而Python并没有，Python是逐行运行的。但可以使用if __name__ == '__main__'来规定当前程序的程序入口是什么，防止模块之间相互引用导致入口混乱。

4.初级内建函数

1.print(value, seq=' ', end='\n') 在Python 3.X中，为一个函数，其中参数seq=' '为分隔符，参数end='\n'为结尾换行符号，可以自己修改。

Tips:

print实质是将输出重定向到sys.stdout.write标准输出，可以修改参数file，指定输出到文件。

print()是同步阻塞的，所以频繁的print会大大降低程序运行速度，比如在训练模型时注意减少print的次数。

2.id(obj)查看对象内存地址。

3.type(obj)查看对象的类型。

4.round(value, n)四舍五入到小数点后n位。

5.a = input(msg)打印出msg，并从键盘输入一个变量赋值给a，a为str类型。

6.dir(module)查看module模块的工具（方法）。

7.help(math.pow)查看math工具下pow工具的帮助，按q返回交互模式。

使用例子：

# -*- coding:utf-8 -*-
import sys
import math
import time
integer_1 = 1
float_2 = 2.35
string = 'abc'
print(id(integer_1))	#查看内存地址
print(type(integer_1), type(float_2), type(string), sep='|') #查看类型，并用|分割
print(round(float_2))	#四舍五入
print(dir(math))	#查看math下的方法
input_test = input("请输入")
print(input_test, type(input_test))	#输入测试，并打印类型
help(math.pow)

输出：

94520588557952
<class 'int'>|<class 'float'>|<class 'str'>
2
['__doc__', '__loader__', '__name__', '__package__', '__spec__', 'acos', 'acosh', 'asin', 'asinh', 'atan', 'atan2', 'atanh', 'ceil', 'copysign', 'cos', 'cosh', 'degrees', 'e', 'erf', 'erfc', 'exp', 'expm1', 'fabs', 'factorial', 'floor', 'fmod', 'frexp', 'fsum', 'gamma', 'gcd', 'hypot', 'inf', 'isclose', 'isfinite', 'isinf', 'isnan', 'ldexp', 'lgamma', 'log', 'log10', 'log1p', 'log2', 'modf', 'nan', 'pi', 'pow', 'radians', 'sin', 'sinh', 'sqrt', 'tan', 'tanh', 'trunc']
请输入3
3 <class 'str'>
Help on built-in function pow in module math:
pow(...)
pow(x, y)
Return x**y (x to the power of y).
(END)

二、Python容器：列表、元组、字典与集合

1.列表

1.使用[]或list()来创建列表

>>> [1,2,3,4,5] #使用[]创建
[1, 2, 3, 4, 5]
>>> list(12345) #不可迭代报错
Traceback (most recent call last):
File "<stdin>", line 1, in <module>
TypeError: 'int' object is not iterable
>>> list('1,2,3,4,5') #按照字符分割
['1', ',', '2', ',', '3', ',', '4', ',', '5']
>>> list('12345')
['1', '2', '3', '4', '5']

如果使用list()是不允许将不可迭代的转换成列表，如果是可迭代的，例如字符串，则会按照字符分割成列表。

2.使用[offset]选取元素，并修改。

>>> l = [1,2,3,4,5]
>>> l[0] #选取
1
>>> l[0] = 2 #修改
>>> l
[2, 2, 3, 4, 5]
>>> matrix = [[1,2,3], #创建三阶行列式
...           [4,5,6],
...           [7,8,9]]
>>> matrix
[[1, 2, 3], [4, 5, 6], [7, 8, 9]]
>>> matrix[0][0] #和矩阵写法一样，行优先，只不过从0开始
1

list类似于数组，但数组只有一个类型，而list里面可以包含多个类型。列表的一个重要特征：列表是可以修改的。这种修改，不是复制一个新的，而是在原地进行修改。

3.使用append()与extend()扩充列表

列表扩容的函数append()和extend()都是原地修改列表,所以没有返回值，所以不能赋给某个变量。

>>> lst1 = [1,2,3]
>>> lst1.append(["lyx","xyl"])
>>> lst1
[1, 2, 3, ['lyx', 'xyl']]  #append的结果
>>> len(lst1)
4
>>> lst2 = [1,2,3]
>>> lst2.extend(["lyx","xyl"])
>>> lst2
[1, 2, 3, 'lyx', 'xyl']   #extend的结果
>>> len(lst2)
5

总结以下就是append是整建制地追加，extend是个体化扩编。

4.使用insert()插入，使用del,remove()与pop()删除

>>> lst = [1,2,3,4]
>>> lst.insert(0,0)
>>> lst
[0, 1, 2, 3, 4]
>>> lst.insert(3,3.5)
>>> lst
[0, 1, 2, 3.5, 3, 4]
>>> lst.insert(10,5)
>>> lst
[0, 1, 2, 3.5, 3, 4, 5]

使用insert(offset,value),当offset为0时则插入到头部，当offset超过了尾部，则会插入到最后，并不会引起异常。

>>> lst = [1,2,3,4,5]
>>> del lst[0]
>>> lst
[2, 3, 4, 5]
>>> lst.remove(3)
>>> lst
[2, 4, 5]
>>> lst.pop()
5
>>> lst
[2, 4]

使用del则是删除指定位置的元素，使用remove()则是删除指定值的数，使用pop()则是弹栈操作，返回最后一位元素，即栈顶元素。

5.使用in判断元素是否存在，count()记录特定值出现次数，index()查询具有特定值的元素位置

>>> word = [1,2,3,4,5,1,1,2]
>>> 1 in word
True
>>> 6 in word
False
>>> word.count(1)
3
>>> word.index(1)
0
>>> word.index(1,1)
5
>>> word.index(1,6)
6

index(str, beg=0, end=len(string)),其中beg规定开始索引，end默认为列表长度，返回开始索引位置后第一次出现的str的位置。

6.使用sort()与sorted()排列数组

默认都是升序排列，加上参数reverse=True则降序排列。

• sort()会对原列表进行排序，改变原列表内容。
• sorted()则会返回排序好的列表副本，原列表内容不变。

>>> lst = [4,3,2,5,2,1,5,7,0]
>>> lst_copy = sorted(lst)
>>> lst_copy
[0, 1, 2, 2, 3, 4, 5, 5, 7]
>>> lst
[4, 3, 2, 5, 2, 1, 5, 7, 0]
>>> lst.sort()
>>> lst
[0, 1, 2, 2, 3, 4, 5, 5, 7]
>>> lst.sort(reverse=True)
>>> lst
[7, 5, 5, 4, 3, 2, 2, 1, 0]

7.使用=赋值，copy()复制

>>> a = [1,2,3]
>>> b = a
>>> b
[1, 2, 3]
>>> a[0] = 0
>>> b
[0, 2, 3]
>>> c = a.copy() #使用copy()复制
>>> d = list(a) #使用list()函数复制
>>> f = a[:] #使用列表分片
>>> a[0] = 1
>>> c
[0, 2, 3]
>>> d
[0, 2, 3]
>>> f
[0, 2, 3]

即使用=赋值后，b与a是同一个对象，修改任意一个都会修改对方，使用copy(),list()与[:]都可以做到创建一个新对象的作用。

8.使用range()生成列表

在Python3中，range()的返回值已经变为range类型，不再是原来的list类型，但依旧可以使用list函数转换过去。range(start, end, step)，即生成一个从start开始，end - 1结束的列表，step为步长，多用于循环之中。

>>> range(0,5)
range(0, 5)
>>> type(range(0,5))
<class 'range'>
>>> for i in range(0,5):
...     print(i)
...
0
1
2
3
4

2.元组

1.使用()与tuple()创建元组

>>> tup = [1,2,3]
>>> tup =  tuple(tup)
>>> tup
(1, 2, 3)
>>> (1,2,3)
(1, 2, 3)
>>> tup[0]
1
>>> tup[0] = 2
Traceback (most recent call last):
File "<stdin>", line 1, in <module>
TypeError: 'tuple' object does not support item assignment

元组与列表使用方法基本都是相同的，但最大的区别就是一旦创建元组就不能修改，所以所有修改列表的操作元组这里都不能用，dir(tuple)可知，对元组进行操作的只有['count','index']。所以使用场景就是元组的占用空间小，你不会意外修改元组的值和它可以作为字典的键。

3.字典

字典与列表类似，可以原地修改，即它是可变的，但它的顺序无关紧要，因为其本质就是键值对。在字典中的“键”，必须是不可变的数据类型；“值”可以是任意数据类型。

1.使用{}与dict()来创建字典

>>> mydict = {"1":"a","2":"b"} #初始化字典
>>> mydict
{'1': 'a', '2': 'b'}
>>> lst = [[1,2],[3,4],[5,6]] #将二维列表转换成字典
>>> mydict = dict(lst)
>>> mydict
{1: 2, 3: 4, 5: 6}
>>> string = ('12','34','56') #将双字符的字符串元组转换成字典
>>> mydict = dict(string)
>>> mydict
{'1': '2', '3': '4', '5': '6'}

2.使用[key]添加或修改元素，使用in判断键是否存在于字典

>>> mydict = {1: 2, 3: 4, 5: 6}
>>> mydict[7] = 8
>>> mydict
{1: 2, 3: 4, 5: 6, 7: 8}
>>> if 2 in mydict:
...     mydict[2] = 0
... else:
...     mydict[3] = 0
...
>>> mydict
{1: 2, 3: 0, 5: 6, 7: 8}

3.使用update()合并字典

>>> a = {1:2,3:4}
>>> a
{1: 2, 3: 4}
>>> b = {5:6,7:8}
>>> b
{5: 6, 7: 8}
>>> a.update(b)
>>> a
{1: 2, 3: 4, 5: 6, 7: 8}
>>> c = {1:'a'}	#如果使用同样的键，则新归入字典的值会取代原有的值
>>> a.update(c)
>>> a
{1: 'a', 3: 4, 5: 6, 7: 8}

4.使用del删除指定键元素与clear()清空字典

>>> a
{1: 'a', 3: 4, 5: 6, 7: 8}
>>> del a[1]
>>> a
{3: 4, 5: 6, 7: 8}
>>> a.clear()
>>> a
{}

5.使用[key]与get()获取元素

>>> a = {1:2,3:4}
>>> a[1]
2
>>> a[2]
Traceback (most recent call last):
File "<stdin>", line 1, in <module>
KeyError: 2
>>> a.get(1)
2
>>> a.get(2)

使用[key]获取，如果键不存在则会抛出异常，所以改用get()方法，不存在的话会返回None。

6.使用keys()，values()与items()

>>> a = {1: 2, 3: 4, 5: 6, 7: 8}
>>> a.keys() #使用keys()返回所有key值
dict_keys([1, 3, 5, 7])
>>> type(a.keys())
<class 'dict_keys'>
>>> list(a.keys())
[1, 3, 5, 7]
>>> a.values() #使用values()返回所有value值
dict_values([2, 4, 6, 8])
>>> a.items() #使用items()返回所有键值对
dict_items([(1, 2), (3, 4), (5, 6), (7, 8)])

我们可以看到，在Python3中，返回的类型已经变成'dict_keys'等等这种方法，这样做的目的是list占用空间较大，且效率不高，所以如果需要用到list，再使用list函数即可。

4.集合

集合的概念与数学中的集合概念是相同的，即集合中的元素是互异的。

1.使用{}与set()创建集合

>>> s = {1,2,3,4,1}
>>> s
{1, 2, 3, 4}
>>> a = [1,1,1,2,3,4,3,3,4,5]
>>> s = set(a)
>>> s
{1, 2, 3, 4, 5}

可见，在Python中去重是非常简单的事情，直接转换成集合就行了。

同样也可以使用in来判断一个元素是否存在于集合之中，这里就不在举例。

2.集合中运算

>>> a = {1,2,3}
>>> b = {2,3}
>>> a > b #使用>=与<=判断是否是子集，使用>与<判断是否是真子集
True
>>> a > a
False
>>> a & b #使用&做交集
{2, 3}
>>> a | b #使用|做并集
{1, 2, 3}
>>> a - b #使用-做差集
{1}
>>> b - a
set()
>>> b ^ a #使用^做异或集
{1}

5.进一步的内建函数

1.zip(*iterables),使用它可以做到并行迭代，举例说明：

>>> a = (1,2,3)
>>> b = (4,5,6)
>>> for i,j in zip(a,b):
...     print(i,j)
...
1 4
2 5
3 6

所以可以使用其进行生成字典操作：

>>> a = (1,2,3)
>>> b = (4,5,6)
>>> dict(zip(a,b))
{1: 4, 2: 5, 3: 6}

2.map(function, iterable, ...),类似于MapReduce中的Map阶段，即将后面的iterable作用于前面的function，举例说明：

>>> def add(x):
...     return x + 10
...
>>> lst = [1,2,3,4]
>>> map(add, lst)
<map object at 0x000002C359ACC9B0>
>>> list(map(add, lst))
[11, 12, 13, 14]

同样我们可以看到，在Python3中返回的是一个map对象，依旧是节省时间的作用，也就是lazy evaluation。

3.enumerate(iterable, start=0),其实就是枚举，具体看下面的例子:

>>> seasons = ['Spring', 'Summer', 'Fall', 'Winter']
>>> list(enumerate(seasons))
[(0, 'Spring'), (1, 'Summer'), (2, 'Fall'), (3, 'Winter')]
>>> list(enumerate(seasons, start=1))
[(1, 'Spring'), (2, 'Summer'), (3, 'Fall'), (4, 'Winter')]

6.可变长度的函数参数

在Python中，有两种变长参数，分别是元组（非关键字参数）和字典（关键字参数）。其调用方式是：func( *args, **kwargs )

因为有时候不知道传进去多少个参数，所以要用可变长的参数，在参数前加一个星号*代表传入的参数会被储存为元组，加两个星号**代表传入的会被储存为字典，要使用键值对的方式传入，具体见下例

>>> def print_args(*args):
...     print('tuple',args)
...
>>> print_args() #如果不传参，则返回空的tuple()
tuple ()
>>> print_args(1,3,12,'asd',[1,2])
tuple (1, 3, 12, 'asd', [1, 2])
>>> def print_kwargs(**kwargs):
...     print('dict',kwargs)
...
>>> print_kwargs(a='a',b='b',c='c')
dict {'a': 'a', 'b': 'b', 'c': 'c'}

那么这样做有什么用呢？下面举一些例子说明：

#转置一个矩阵
>>> matrix = [[1,2,3],[4,5,6],[7,8,9]]
>>> matrix = list(map(list, zip(*matrix)))
>>> matrix
[[1, 4, 7], [2, 5, 8], [3, 6, 9]]

zip(*value)因为在函数调用中使用*list/tuple的方式表示将list/tuple分开，作为位置参数传递给对应函数，所以起到了转置矩阵的作用。

三、Python高级用法

1.列表推导式

例如我们要创建一个0到10的列表，那么我们可能首先会想到使用range()

>>> list(range(0,11))
[0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10]

然而更加Pythonic的方法是使用列表推导式，即[expression for item in iterable if condition],举例说明

>>> [x for x in range(0,11)]
[0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10]
>>> [x**2 for x in range(0,11)]
[0, 1, 4, 9, 16, 25, 36, 49, 64, 81, 100]
>>> [x**2 for x in range(0,11) if x < 5]
[0, 1, 4, 9, 16]

这里我们可以用它构建一个空的二维数组，即一个m*n的矩阵

>>> [[0 for col in range(5)] for row in range(3)]
[[0, 0, 0, 0, 0], [0, 0, 0, 0, 0], [0, 0, 0, 0, 0]]

再举一个例子，取出有相同值的列表中第n次出现的下标

>>> nums = [1,2,3,2,1,3,4,5,6,1,3,5,6,4,2,1]
>>> index = [idx for idx, e in enumerate(nums) if e == 1] #其中idx是下标，1为目标值，即取出了所有1的位置下标
>>> index
[0, 4, 9, 15]

2.匿名函数：lambda()函数

Python中，为实现函数式编程，lambda不能少，它是用于语句表达的匿名函数，可以用来代替小的函数，下面举例说明。

#判断一个数是否是偶数
>>> f = lambda x: True if x % 2 == 0 else False
>>> print(f(4))
True
>>> print(f(5))
False

#字典按values排序
>>> dict = {'four': 4, 'three': 3, 'two': 2, 'one': 1}
>>> dict_lst = sorted(dict.items(), key=lambda x:x[1])
>>> dict_lst
[('one', 1), ('two', 2), ('three', 3), ('four', 4)]

3.日期与时间

使用python处理日期与时间，需要用到datetime模块，例如获取当前时间

>>> from datetime import datetime
>>> now = datetime.now()
>>> print(now)
2018-01-17 19:55:50.371107

很多时候使用时间戳来表示时间，我们把1970年1月1日 00:00:00 UTC+00:00时区的时刻称为epoch time，记为0（1970年以前的时间timestamp为负数），当前时间就是相对于epoch time的秒数，称为timestamp。

>>> now.timestamp()
1516190150.371107
#相应的转回来使用
>>> t = now.timestamp()
>>> print(datetime.fromtimestamp(t))
2018-01-17 19:55:50.371107
#还可以转成UTC时间
>>> print(datetime.utcfromtimestamp(t))
2018-01-17 11:55:50.371107

然而这些都是datetime类型的数据，不便于处理，所以我们要将其转换成字符串类型，字符串'%Y-%m-%d %H:%M:%S'规定了日期和时间部分的格式。

>>> print(now.strftime('%Y-%m-%d %H:%M:%S'))
2018-01-17 19:55:50
>>> print(now.strftime('%Y-%m-%d'))
2018-01-17
>>> print(now.strftime('%Y%m%d'))
20180117
#当然也可以字符串转datetime
>>> now = now.strftime('%Y%m%d')
>>> now
'20180117'
>>> now = datetime.strptime(now, '%Y%m%d')
>>> now
datetime.datetime(2018, 1, 17, 0, 0)

可以随意调整你需要的格式。

有时我们还会用到时间的运算，这里必须结合datetime和timedelta

>>> from datetime import datetime, timedelta
>>> now = datetime.now()
>>> now
datetime.datetime(2018, 1, 17, 20, 3, 53, 221673)
>>> now + timedelta(hours=1)
datetime.datetime(2018, 1, 17, 21, 3, 53, 221673)
>>> now - timedelta(days=7)
datetime.datetime(2018, 1, 10, 20, 3, 53, 221673)
>>> (now - timedelta(days=7)).strftime('%Y-%m-%d-%H-%M-%S')
'2018-01-10-20-03-53'
>>> (now - timedelta(days=7)).strftime('%Y-%m-%d-%H-%M-%S').split('-')
['2018', '01', '10', '20', '03', '53']

把分隔符号统一便于分隔，分隔成list后便于进行时间粒度划分处理。

最后一个实用的是判断星期几：

>>> from datetime import datetime
>>> text = '2012-09-20'
>>> y = datetime.strptime(text, '%Y-%m-%d')
>>> y.weekday()
3

4.高级内建函数

1.reduce(function, iterable[, initializer]),有map当然就会有reduce，在Python3中，reduce()已经从全局命名空间中移除，放到了functools模块中，如果要是用，需要用from functools import reduce引入之。

map是上下运算，reduce是横着逐个元素进行运算，下面举个例子：

#基础用法
>>> reduce(lambda x,y: x+y,[1,2,3,4,5])
15
#进阶
>>> a = [1,2,3,4,5]
>>> b = [6,7,8,9,10]
>>> list(zip(a,b))
[(1, 6), (2, 7), (3, 8), (4, 9), (5, 10)]
>>> sum(x*y for x,y in zip(a,b))
130
>>> reduce(lambda x,y:x+y,map(lambda x,y:x*y,a,b))
130

2.filter(function, iterable),filter的中文含义是“过滤器”，在python中，它就是起到了过滤器的作用。

>>> numbers = range(-5,5)
>>> numbers
[-5, -4, -3, -2, -1, 0, 1, 2, 3, 4]
>>> filter(lambda x: x>0, numbers)
[1, 2, 3, 4]
>>> [x for x in numbers if x>0]     #与上面那句等效
[1, 2, 3, 4]

3.yield生成器，返回值 变为一个生成器对象

#例如输出斐波那契数列前N个数字
>>> def fab(max):
...     n, a, b = 0, 0, 1
...     while n < max:
...         print(b)
...         a, b = b, a + b
...         n = n + 1
...
>>> fab(5)
1
1
2
3
5
#修改后变为
>>> def fab(max):
...     n, a, b = 0, 0, 1
...     while n < max:
...         yield(b)
...         a, b = b, a + b
...         n = n + 1
...
>>> fab(5)
<generator object fab at 0x000002C359B6F410>
>>> for i in fab(5):
...     print(i)
...
1
1
2
3
5

这样做的好处是它不是全部存在内存里，它只在要调用的时候在内存里生成，这样就能和上述一样做到lazy evaluation,需要的时候才迭代。

5.文件操作

1.打开文件：

fp = open("test.txt",w)

直接打开一个文件，如果文件不存在则创建文件

关于open 模式：

w 以写方式打开，

a 以追加模式打开 (从 EOF 开始, 必要时创建新文件)

r+ 以读写模式打开

w+ 以读写模式打开 (参见 w )

a+ 以读写模式打开 (参见 a )

2.关闭文件：

使用file.close()或者with open("131.txt","w") as f:来关闭，建议使用第二种操作

>>> with open("131.txt","w") as f:
...     f.write("This is a file")
...
14

3.read/readline/readlines

• read：如果指定了参数size，就按照该指定长度从文件中读取内容，否则，就读取全文。被读出来的内容，全部塞到一个字符串里面。这样有好处，就是东西都到内存里面了，随时取用，比较快捷；也是因为这点，如果文件内容太多了，内存会吃不消的。
• readline：那个可选参数size的含义同上。它则是以行为单位返回字符串，也就是每次只读一行，依次循环，如果不限定size，直到最后一个返回的是空字符串，意味着到文件末尾了(EOF)。
• readlines：size同上。它返回的是以行为单位的列表，即相当于先执行readline()，得到每一行，然后把这一行的字符串作为列表中的元素塞到一个列表中，最后将此列表返回。

>>> with open("airport_gz_passenger_24.csv","r") as f:
...    text = f.read()
...
>>> text = text.split('\n')
>>> text[0]
'passengerCount,WIFIAPTag,slice10min'
>>> with open("airport_gz_passenger_24.csv","r") as f:
...     f.readline()
...
'passengerCount,WIFIAPTag,slice10min\n'
>>> with open("airport_gz_passenger_24.csv","r") as f:
...     text = f.readlines()
...
>>> text[0]
'passengerCount,WIFIAPTag,slice10min\n'

5.多进程实现并行处理

在Python中使用multiprocessing模块来实现多进程，下面举例说明

#一个简单的查找程序
import multiprocessing
import time
def find(flag):
    num = 99
    if flag == 0:
    	s1 = time.time()
    for i in range(0, 101):
    	time.sleep(0.1)
        if num == i:
            print("顺序找到")
            print("耗时" + str(time.time() - s1))
    if flag == 1:
    	s2 = time.time()
    for i in range(101, 0, -1):
    	time.sleep(0.1)
		if num == i:
            print("逆序找到")
            print("耗时" + str(time.time() - s2))
if __name__ == "__main__":
    pool = multiprocessing.Pool(processes = 2)
    for i in range(2):
        pool.apply_async(find, (i, )) #维持执行的进程总数为processes，当一个进程执行完毕后会添加新的进程进去
        print("开始")
        pool.close()
        pool.join() #调用join之前，先调用close函数，否则会出错。执行完close后不会有新的进程加入到pool,join函数等待所有子进程结束
    print("结束")

结果如下：

C:\Users\Cabbage\Desktop\毕业设计\code\first>python mulprocess_1.py
开始
逆序找到
耗时0.30155348777770996
顺序找到
耗时10.043102502822876
结束

6.异常处理

1.错误与异常

语法错误，或者称之为解析错误：

>>> while True print('Hello world')
File "<stdin>", line 1, in ?
while True print('Hello world')
^
SyntaxError: invalid syntax

异常

即使一条语句或表达式在语法上是正确的，在运行它的时候，也有可能发生错误。在执行期间检测到的错误被称为异常并且程序不会无条件地崩溃：你很快就会知道如何在 Python 程序中处理它们。然而大多数异常都不会被程序处理，导致产生类似下面的错误信息：

>>> 10 * (1/0)
Traceback (most recent call last):
File "<stdin>", line 1, in ?
ZeroDivisionError: division by zero
>>> 4 + spam*3
Traceback (most recent call last):
File "<stdin>", line 1, in ?
NameError: name 'spam' is not defined
>>> '2' + 2
Traceback (most recent call last):
File "<stdin>", line 1, in ?
TypeError: Can't convert 'int' object to str implicitly

最后一行的错误消息指示发生了什么事。异常有不同的类型,下面列出常见异常：

异常	描述
NameError	尝试访问一个没有申明的变量
ZeroDivisionError	除数为0
SyntaxError	语法错误
IndexError	索引超出序列范围
KeyError	请求一个不存在的字典关键字
IOError	输入输出错误（比如你要读的文件不存在）
AttributeError	尝试访问未知的对象属性

2.使用try...except处理异常

抛出异常

可以通过编程来选择处理部分异常。看一下下面的例子，它会一直要求用户输入直到输入一个合法的整数为止，但允许用户中断这个程序（使用Control-C或系统支持的任何方法）；注意用户产生的中断引发的是 KeyboardInterrupt 异常。

while True:
try:
x = int(input("输入一个数字： "))
break
except ValueError:
print("这不是数字，重新输入。")

输出为：

C:\Users\Cabbage\Desktop\毕业设计\code\first>python error.py
输入一个数字： a
这不是数字，重新输入。
输入一个数字： b
这不是数字，重新输入。
输入一个数字： 1

引发异常

raise语句允许程序员强行引发一个指定的异常。例如：

inputValue = input("请输入a,b或c:")
if inputValue in "abc":
print(inputValue)
else:
raise(ValueError)

结果为：

C:\Users\Cabbage\Desktop\毕业设计\code\first>python raise.py
请输入a,b或c:f
Traceback (most recent call last):
File "raise.py", line 5, in <module>
raise(ValueError)
ValueError
C:\Users\Cabbage\Desktop\毕业设计\code\first>python raise.py
请输入a,b或c:a
a