一天速成Python教程

2019/04/10 10:10
阅读数 18

一、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)

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

有时我们还会用到时间的运算,这里必须结合datetimetimedelta

>>> 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的含义同上。它则是以行为单位返回字符串,也就是<b>每次只读一行</b>,依次循环,如果不限定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

原文出处:https://www.cnblogs.com/harrylyx/p/12388692.html

展开阅读全文
打赏
0
0 收藏
分享
加载中
更多评论
打赏
0 评论
0 收藏
0
分享
返回顶部
顶部