首页 > 代码库 > 匿名函数、内置函数与模块

匿名函数、内置函数与模块

2024-11-22 23:28:02   202人阅读

一、匿名函数

Python使用lambda来创建匿名函数，不再使用def语句这样标准的形式定义一个函数

  • lambda只是一个表达式，函数体比def简单很多
  • lambda的主体是一个表达式，而不是一个代码块。仅仅能在lambda表达式中封装有限的逻辑进去
  • lambda函数拥有自己的名称空间，且不能访问自有参数列表之外或全局名称空间里的参数
  • 虽然lambda函数看起来只能写一行，却不等同于C或C++的内联函数，后者的目的是调用小函数时不占用栈内存从而增加运行效率
  • 适合临时的一次性的使用场景

语法：

lambda [arg1 [,arg2,.....argn]]:expression

实例：

my_sum = lambda x,y,z:x+y+z                    #1、形参不用加括号2、函数体自带return
print(my_sum(1,2,3))

#执行结果：
6

 

二、内置函数

Python所有的内置函数

参考链接：https://docs.python.org/3/library/functions.html

   

Built-in Functions

    

abs()

dict()

help()

min()

setattr()

all()

dir()

hex()

next()

slice()

any()

divmod()

id()

object()

sorted()

ascii()

enumerate()

input()

oct()

staticmethod()

bin()

eval()

int()

open()

str()

bool()

exec()

isinstance()

ord()

sum()

bytearray()

filter()

issubclass()

pow()

super()

bytes()

float()

iter()

print()

tuple()

callable()

format()

len()

property()

type()

chr()

frozenset()

list()

range()

vars()

classmethod()

getattr()

locals()

repr()

zip()

compile()

globals()

map()

reversed()

__import__()

complex()

hasattr()

max()

round()

 

delattr()

hash()

memoryview()

set()

 

数学运算（abs、round、pow、divmod、max、min、sum）

print(abs(-6))                      #取绝对值，也就是6
print(round(2.21,1))                #返回浮点数的四舍五入值，保留1位小数
print(pow(2,3))                     #返回 xy（x的y次方） 的值，如果第三个参数存在，则再对结果进行取模，其结果等效于pow(x,y) %z
print(divmod(9,2))                  #返回商和余数，也就是4, 1
print(max(-1,1,2))                  #返回给定参数的最大值，参数可以为序列
print(min(-1,1,2))                  #返回给定参数的最小值，参数可以为序列
print(sum([1,2,3]))                 #求和

类型转换（int、float、str、complex、list、tuple、dict、set、frozenset、ord、chr、bool、bin、hex、oct、slice、bytes）

print(int(5))                       #转为整数
print(float(2))                     #转为浮点数，也就是2.0
print(str(1.2))                     # 转为字符串
print(complex(3,9))                 #返回复数3+9j
print(list((1,2,3)))                #转为列表
print(tuple([1,2,3]))               #转为元组
print(dict(a=1,b=2,c=3))            #构建字典
print(set({‘a‘,‘b‘,‘c‘,‘d‘}))       #构建集合
print(frozenset({‘a‘,‘b‘,‘c‘,‘d‘})) #构建不可变集合
print(ord(‘A‘))                     #"A"字符对应的数值，也就是65
print(chr(65))                      #数值65对应的字符，也就是A。（范围：65-90）
print(bool(0))                      #返回真假值。在Python中，这些对象都相当于False： [], (), {}, 0, None, 0.0, ‘‘
print(bin(10))                      #转换为二进制，也就是0b1010
print(hex(10))                      #转为十六进制，也就是0xa
print(oct(10))                      #转为八进制，也就是0o12
l = [1,2,3,4,5]
print(l[slice(0,4,2)])                      #实现切片对象，主要用在切片操作函数里的参数传递
print(bytes(‘hello‘,encoding=‘utf-8‘))      #转为bytes类型，也就是b‘hello‘

序列操作（all、any、sorted、reversed）

all([True, 1, "hello!"])            #是否所有的元素都相当于True值
any(["", 0, False, [], None])       #是否有任意一个元素相当于True值
l = [-1,-2,2,9]
print(sorted(l))                    #对所有可迭代的对象进行排序操作
l = [1,2,3]
print(list(reversed(l)))            #反向列表中元素

类，对象，属性（class、hasattr、getattr、setattr、delattr、isinstance、issubclass）

a = 2
isinstance (a,int)                  #判断一个对象是否是一个已知的类型，类似 type()

编译，执行（repr、compile、eval、exec）

print(repr(‘Yim‘))                  #返回对象的字符串表达
compile("print(‘Hello‘)",‘test.py‘,‘exec‘)      #将一个字符串编译为字节代码
print(eval(‘1+1‘))                  #执行一个字符串表达式，并返回表达式的值
exec("print(‘Hello‘)")              #执行储存在字符串或文件中的Python语句，相比于 eval，exec可以执行更复杂的 Python 代码

基本数据类型（type）

x=1
print(type(x))                      #返回表达式的值的类型

文件的输入输出（open）

f = open(‘test.txt‘)                #用于打开一个文件，创建一个file对象
f.read()

循环设计（range、enumerate、zip）

print(range(10))                       #创建一个整数列表，一般用在 for 循环中
for i,j in enumerate((‘a‘,‘b‘,‘c‘)):   #遍历序列中的元素以及它们的下标
    print(i,j)

s = ‘hello‘
l = [1,2,3,4,5]
print(list(zip(s,l)))                   #将可迭代的对象作为参数，将对象中对应的元素打包成一个个元组，然后返回由这些元组组成的列表

循环对象（iter、next）

list = [1,2,3,4,5]
g = list.__iter__()                 #iter() 函数用来生成迭代器
print(g.__next__())                 #next() 返回迭代器的下一个项目

函数对象（map、filter、reduce）

print(list(map(lambda x:x ** 2, [1,2,3,4,5])))    #根据提供的函数对指定序列做映射,第一个参数 function 以参数序列中的每一个元素调用 function 函数，返回包含每次 function 函数返回值的新列表

from functools import reduce
print(reduce(lambda x,y:x + y, [1,2,3,4,5]))      #对参数序列中元素进行累积。用传给reduce中的函数 function（有两个参数）先对集合中的第 1、2 个元素进行操作，得到的结果再与第三个数据用 function 函数运算，最后得到一个结果。可以指定初始值（可选参数，默认是None），例如：print(reduce(lambda x,y:x + y, [1,2,3,4,5],1000))，结果是：1015

print(list(filter(lambda x:x % 2 == 0, [1,2,3,4,5,6])))    #，过滤掉不符合条件的元素，返回由符合条件元素组成的新列表。第一个为函数，第二个为序列，序列的每个元素作为参数传递给函数进行判，然后返回 True 或 False，最后将返回 True 的元素放到新列表中

其他（input、globals、locals、callable、dir、hash、help、id、len、vars、__import__）

a = input("input:")             #相等于 eval(raw_input(prompt)) ，用来获取控制台的输入
print(globals())                #查看全局名称空间
print(locals())                 #查看局部名称空间
print(callable(bytes))          #检查是否为可调用对象
import sys
print(dir(sys))                 #找到模块内定义的所有名称，以一个字符串列表的形式返回
print(hash(‘123‘))              #校验字符串
help(max)                       #查看函数或模块用途的详细说明
print(id(x))                    #获取对象的内存地址
print(len(‘12345‘))             #返回对象（字符、列表、元组等）长度或项目个数
print(vars())                   #返回对象object的属性和属性值的字典对象
m_name = input(‘module>>>:‘)
if m_name == ‘sys‘:
    m = __import__(m_name)                 #用于动态加载类和函数 。如果一个模块经常变化就可以使用 __import__() 来动态载入。
    print((m.path))

 

三、内置函数补充

salaries={
‘A‘:300,
‘B‘:1000,
‘C‘:900,
‘D‘:200
}

#找出薪资最高的那个人
#方法一：
# print(salaries.values())            #取出薪资
# print(salaries.keys())              #取出名字
# print(list(zip(salaries.values(),salaries.keys())))     #将对象中对应的元素打包成一个个元组，然后返回由这些元组组成的列表
# print(max(list(zip(salaries.values(),salaries.keys()))))   #得到薪资最高的那个由名字和薪资组成的元组
print(max(list(zip(salaries.values(),salaries.keys())))[1])  #取第二个元素，即名字

#方法二：
print(max(salaries,key=lambda name:salaries[name]))

#薪资从低到高排序
print(sorted(salaries,key=lambda name:salaries[name]))

#薪资从高到低排序
print(sorted(salaries,key=lambda name:salaries[name],reverse=True))

 

四、模块

1 re模块-正则表达式

正则表达式是一个特殊的字符序列，它能帮助我们很方便的检查一个字符串是否与某种模式匹配

它内嵌在Python中，并通过 re 模块实现。正则表达式模式被编译成一系列的字节码，然后由用 C 编写的匹配引擎执行

1.1 re.match函数

re.match尝试从字符串的起始位置匹配一个模式。如果不是起始位置匹配成功的话，match()就返回None

语法：

re.match(pattern, string, flags=0)

函数参数说明：

参数

描述

pattern

匹配的正则表达式

string

要匹配的字符串。

flags

标志位，用于控制正则表达式的匹配方式，如：是否区分大小写，多行匹配等等。

匹配成功re.match方法返回一个匹配的对象，否则返回None

可以使用group(num)或groups()匹配对象函数来获取匹配表达式

匹配对象方法

描述

group(num=0)

匹配的整个表达式的字符串，group() 可以一次输入多个组号，在这种情况下它将返回一个包含那些组所对应值的元组。

groups()

返回一个包含所有小组字符串的元组，从 1 到 所含的小组号。

实例：

import re
print(re.match(‘hello‘,‘hello world‘).span())           #在起始位置匹配
print(re.match(‘world‘,‘hello world‘))                  #不在起始位置匹配

#执行结果：
(0, 5)
None 

1.2 re.search函数

re.search扫描整个字符串并返回第一个成功的匹配

语法：

re.search(pattern, string, flags=0)

函数参数说明：

参数

描述

pattern

匹配的正则表达式

string

要匹配的字符串。

flags

标志位，用于控制正则表达式的匹配方式，如：是否区分大小写，多行匹配等等。

匹配成功re.search方法返回一个匹配的对象，否则返回None

我们可以使用group(num) 或 groups() 匹配对象函数来获取匹配表达式

匹配对象方法

描述

group(num=0)

匹配的整个表达式的字符串，group() 可以一次输入多个组号，在这种情况下它将返回一个包含那些组所对应值的元组。

groups()

返回一个包含所有小组字符串的元组，从 1 到 所含的小组号。

实例：

import re
print(re.search(‘hello‘,‘hello world‘).span())          #在起始位置匹配
print(re.search(‘world‘,‘hello world‘).span())          #不在起始位置匹配

#执行结果：
(0, 5)
(6, 11) 

1.3 re.sun函数-检索和替换

re模块提供了re.sub用于替换字符串中的匹配项

语法：

re.sub(pattern, repl, string, count=0)

函数参数说明：

参数

描述

pattern

匹配的正则表达式

repl

替换的字符串，也可为一个函数

string

要匹配的字符串

count

模式匹配后替换的最大次数。默认是0，表示替换所有的匹配

实例：

import re
num = ‘0123456789#阿拉伯数字‘
print(re.sub(r‘#.*$‘,‘‘,num))                       #去掉注释

#执行结果
0123456789
print(re.sub(‘(\w+)(\W+)(\w+)(\W+)(\w+)(\W+)(\w+)‘,r‘\7\2\3\4\5\6\1‘,‘one two three four‘))

#执行结果
four two three one 

1.4 re.findall函数

re.findall遍历匹配，可以获取字符串中所有匹配的字符串，返回一个列表

语法：

re.findall(pattern, string, flags=0)

函数参数说明：

参数

描述

pattern

匹配的正则表达式

string

要匹配的字符串。

flags

标志位，用于控制正则表达式的匹配方式，如：是否区分大小写，多行匹配等等。

实例：

import re
print(re.findall(‘\d‘,‘a2g1c35‘))

#执行结果
[‘2‘, ‘1‘, ‘3‘, ‘5‘]

1.5 re.split函数

按照能够匹配的子串将string分割后返回列表

语法：

re.split(pattern, string[, maxsplit])

函数参数说明：

参数

描述

pattern

匹配的正则表达式

string

要匹配的字符串。

maxsplit

用于指定最大分割次数，不指定将全部分割

实例：

print(re.split(‘\d+‘,‘one1two2three3four4five5‘))
print(re.split(‘\d+‘,‘one1two2three3four4five5‘,1))

#执行结果
[‘one‘, ‘two‘, ‘three‘, ‘four‘, ‘five‘, ‘‘]
[‘one‘, ‘two2three3four4five5‘] 

1.6 re.subn函数

替换并返回替换次数

语法：

subn(pattern, repl, string, count=0, flags=0)

函数参数说明：

参数

描述

pattern

匹配的正则表达式

repl

替换的字符串，也可为一个函数

string

要匹配的字符串

count

模式匹配后替换的最大次数。默认是0，表示替换所有的匹配

flags

标志位，用于控制正则表达式的匹配方式，如：是否区分大小写，多行匹配等等。

实例：

print(re.subn(‘1‘,‘A‘,‘123456123456‘))
print(re.subn(‘1‘,‘A‘,‘123456123456‘,count=1))

#执行结果：
(‘A23456A23456‘, 2)
(‘A23456123456‘, 1) 

1.7 re.compile函数

编译正则表达式模式，返回一个对象的模式。（可以把那些常用的正则表达式编译成正则表达式对象，这样可以提高一点效率）

语法：

re.compile(pattern,flags=0)

函数参数说明：

参数

描述

pattern

匹配的正则表达式

flags

标志位，用于控制正则表达式的匹配方式，如：是否区分大小写，多行匹配等等。

实例：

obj = re.compile(‘\d{2}‘)
print(obj.findall(‘abc123eee‘))

#执行结果
[‘12‘]

1.8 re.finditer函数

搜索string，返回一个顺序访问每一个匹配结果（Match对象）的迭代器。找到 RE 匹配的所有子串，并把它们作为一个迭代器返回。

语法：

re.finditer(pattern, string, flags=0)

函数参数说明：

参数

描述

pattern

匹配的正则表达式

string

要匹配的字符串

flags

标志位，用于控制正则表达式的匹配方式，如：是否区分大小写，多行匹配等等。

实例：

iter = re.finditer(r‘\d+‘,‘12 drumm44ers drumming, 11 ... 10 ...‘)
for i in iter:
    print(i.group())

#执行结果：
12
44
11
10 

1.9 正则表达式修饰符-可选标志

正则表达式可以包含一些可选标志修饰符来控制匹配的模式。修饰符被指定为一个可选的标志。多个标志可以通过按位 OR(|) 它们来指定。如 re.I | re.M 被设置成 I 和 M 标志：

修饰符

描述

re.I

使匹配对大小写不敏感

re.L

做本地化识别（locale-aware）匹配

re.M

多行匹配，影响 ^ 和 $

re.S

使 . 匹配包括换行在内的所有字符

re.U

根据Unicode字符集解析字符。这个标志影响 \w, \W, \b, \B.

re.X

该标志通过给予你更灵活的格式以便你将正则表达式写得更易于理解。

1.10 正则表达式模式

字母和数字表示它们自身，一个正则表达式模式中的字母和数字匹配同样的字符串

多数字母和数字前加一个反斜杠时，会拥有不同的含义

标点符号只有被转义时才匹配自身，否则它们表示特殊的含义

反斜杠本身需要使用反斜杠转义，最好使用原始字符串来表示它们。模式元素(如 r‘/t‘，等价于‘//t‘)匹配相应的特殊字符

模式

描述

实例

^

匹配字符串的开头

print(re.findall(‘^a‘,‘abc*!123‘))

[‘a‘]

$

匹配字符串的末尾。

print(re.findall(‘3$‘,‘abc*!123‘))

[‘3‘]

.

匹配任意字符，除了换行符，当re.DOTALL标记被指定时，则可以匹配包括换行符的任意字符。

print(re.findall(‘a.c‘,‘a a1c a*c a2c c aaaaac a c‘))

[‘a1c‘, ‘a*c‘, ‘a2c‘, ‘aac‘, ‘a c‘]

print(re.findall(‘a.c‘,‘a a1c a*c a2c c aaaaac a c a\nc‘,re.DOTALL))

[‘a1c‘, ‘a*c‘, ‘a2c‘, ‘aac‘, ‘a c‘, ‘a\nc‘]

[...]

用来表示一组字符,单独列出：[amk] 匹配 ‘a‘，‘m‘或‘k‘

print(re.findall(‘a[12]c‘,‘a a1c a*c a2c c aaaaac a c‘))

[‘a1c‘, ‘a2c‘]

[^...]

不在[]中的字符：[^abc] 匹配除了a,b,c之外的字符。

print(re.findall(‘a[^12]c‘,‘a a1c a*c a2c c aaaaac a c‘))

[‘a*c‘, ‘aac‘, ‘a c‘]

re*

匹配0个或多个前面的表达式。

print(re.findall(‘ab*‘,‘a ab abb abbb abbbbb bbbbb‘))

[‘a‘, ‘ab‘, ‘abb‘, ‘abbb‘, ‘abbbbb‘]

re+

匹配1个或多个前面的表达式。

print(re.findall(‘ab+‘,‘a ab abb abbb abbbbb bbbbb‘))

[‘ab‘, ‘abb‘, ‘abbb‘, ‘abbbbb‘]

re?

匹配0个或1个由前面的正则表达式定义的片段，非贪婪方式

print(re.findall(‘ab?‘,‘a ab abb abbb abbbbb bbbbb‘))

[‘a‘, ‘ab‘, ‘ab‘, ‘ab‘, ‘ab‘]

.*

匹配0个或多个字符

print(re.findall(‘a.*c‘,‘a123c456c‘))

[‘a123c456c‘]

re{ n}

精确匹配n个前面表达式

print(re.findall(‘ab{2}‘,‘a ab abb abbb abbbbb bbbbb‘))

[‘abb‘, ‘abb‘, ‘abb‘]

re{ n,}

精确匹配n个或多个前面表达式。

print(re.findall(‘ab{2,}‘,‘a ab abb abbb abbbbb bbbbb‘))

[‘abb‘, ‘abbb‘, ‘abbbbb‘]

re{ n, m}

匹配 n 到 m 次由前面的正则表达式定义的片段，贪婪方式

print(re.findall(‘ab{2,3}‘,‘a ab abb abbb abbbbb bbbbb‘))

[‘abb‘, ‘abbb‘, ‘abbb‘]

a| b

匹配a或b

print(re.findall(‘ab|ac‘,‘ab abc acc‘))

[‘ab‘, ‘ab‘, ‘ac‘]

(re)

G匹配括号内的表达式，也表示一个组

print(re.findall(‘(ab)‘,‘abababab123‘))

[‘ab‘, ‘ab‘, ‘ab‘, ‘ab‘]

print(re.findall(‘(ab)+‘,‘abababab123‘))

[‘ab‘]

print(re.findall(‘(?:ab)+‘,‘abababab123‘))

[‘abababab‘]

(?imx)

正则表达式包含三种可选标志：i, m, 或 x 。只影响括号中的区域。

 

(?-imx)

正则表达式关闭 i, m, 或 x 可选标志。只影响括号中的区域。

 

(?: re)

类似 (...), 但是不表示一个组

 

(?imx: re)

在括号中使用i, m, 或 x 可选标志

 

(?-imx: re)

在括号中不使用i, m, 或 x 可选标志

 

(?#...)

注释.

 

(?= re)

前向肯定界定符。如果所含正则表达式，以 ... 表示，在当前位置成功匹配时成功，否则失败。但一旦所含表达式已经尝试，匹配引擎根本没有提高；模式的剩余部分还要尝试界定符的右边。

 

(?! re)

前向否定界定符。与肯定界定符相反；当所含表达式不能在字符串当前位置匹配时成功

 

(?> re)

匹配的独立模式，省去回溯。

 

\w

匹配字母数字

print(re.findall(‘\w‘,‘abc*!123‘))

[‘a‘, ‘b‘, ‘c‘, ‘1‘, ‘2‘, ‘3‘]

\W

匹配非字母数字

print(re.findall(‘\W‘,‘abc*!123‘))

[‘*‘, ‘!‘]

\s

匹配任意空白字符，等价于 [\t\n\r\f].

print(re.findall(‘\s‘,‘abc\n 123\t‘))

[‘\n‘, ‘ ‘, ‘\t‘]

\S

匹配任意非空字符

print(re.findall(‘\S‘,‘abc\n 123\t‘))

[‘a‘, ‘b‘, ‘c‘, ‘1‘, ‘2‘, ‘3‘]

\d

匹配任意数字，等价于 [0-9].

print(re.findall(‘\d‘,‘abc*!123‘))

[‘1‘, ‘2‘, ‘3‘]

\D

匹配任意非数字

print(re.findall(‘\D‘,‘abc*!123‘))

[‘a‘, ‘b‘, ‘c‘, ‘*‘, ‘!‘]

\A

匹配字符串开始，等价于^

print(re.findall(‘\Aab‘,‘abc123abc‘))

[‘ab‘]

\Z

匹配字符串结束，如果是存在换行，只匹配到换行前的结束字符串,等价于$

print(re.findall(‘bc\Z‘,‘abc123abc‘))

[‘bc‘]

\z

匹配字符串结束

 

\G

匹配最后匹配完成的位置。

 

\b

匹配一个单词边界，也就是指单词和空格间的位置。例如， ‘er\b‘ 可以匹配"never" 中的 ‘er‘，但不能匹配 "verb" 中的 ‘er‘。

 

\B

匹配非单词边界。‘er\B‘ 能匹配 "verb" 中的 ‘er‘，但不能匹配 "never" 中的 ‘er‘。

 

\n,

匹配一个换行符。

print(re.findall(‘\n‘,‘abc\n 123\t‘))

[‘\n‘]

\t

匹配一个制表符。

print(re.findall(‘\t‘,‘abc\n 123\t‘))

[‘\t‘]

\1...\9

匹配第n个分组的内容。

print(re.sub(‘(\w+)(\W+)(\w+)(\W+)(\w+)(\W+)(\w+)‘,r‘\7\2\3\4\5\6\1‘,‘one two three four‘))

four two three one

\10

匹配第n个分组的内容，如果它经匹配。否则指的是八进制字符码的表达式。

 

\,r

转义

r就是rawstring，原生的字符串

print(re.findall(‘a\\\c‘,‘a\c, acc‘))

[‘a\\c‘]

print(re.findall(r‘a\\c‘,‘a\c, acc‘))

[‘a\\c‘]

1.11 正则表达式实例

字符匹配

实例

描述

python

匹配 "python".

字符类

实例

描述

[Pp]ython

匹配 "Python" 或 "python"

rub[ye]

匹配 "ruby" 或 "rube"

[aeiou]

匹配中括号内的任意一个字母

[0-9]

匹配任何数字。类似于 [0123456789]

[a-z]

匹配任何小写字母

[A-Z]

匹配任何大写字母

[a-zA-Z0-9]

匹配任何字母及数字

[^aeiou]

除了aeiou字母以外的所有字符

[^0-9]

匹配除了数字外的字符

特殊字符类

实例

描述

.

匹配除 "\n" 之外的任何单个字符。要匹配包括 ‘\n‘ 在内的任何字符，请使用 ‘[.\n]‘ 的模式。

\d

匹配一个数字字符。等价于 [0-9]。

\D

匹配一个非数字字符。等价于 [^0-9]。

\s

匹配任何空白字符，包括空格、制表符、换页符等等。等价于 [ \f\n\r\t\v]。

\S

匹配任何非空白字符。等价于 [^ \f\n\r\t\v]。

\w

匹配包括下划线的任何单词字符。等价于‘[A-Za-z0-9_]‘。

\W

匹配任何非单词字符。等价于 ‘[^A-Za-z0-9_]‘。

 2 time模块

Python提供了一个time和calendar模块可以用于格式化日期和时间

时间间隔是以秒为单位的浮点小数

每个时间戳都以自从1970年1月1日午夜经过了多长时间来表示

实例：

#time.time()获取当前时间戳
import time                     #引入time模块
print(time.time())

#执行结果
1502155966.0468564
#时间戳单位最适于做日期运算。但是无法表示1970年之前的日期，也不支持太遥远的日期，UNIX和Windows只支持到2038年

2.1 获取当前时间

结构化的时间

import time
print(time.localtime())
print(time.localtime().tm_mon)              #查看月份

#执行结果：
time.struct_time(tm_year=2017, tm_mon=8, tm_mday=8, tm_hour=10, tm_min=15, tm_sec=19, tm_wday=1, tm_yday=220, tm_isdst=0)
8

格林威治天文时间（UTC）：

import time
print(time.gmtime())

#执行结果：
time.struct_time(tm_year=2017, tm_mon=8, tm_mday=8, tm_hour=2, tm_min=24, tm_sec=27, tm_wday=1, tm_yday=220, tm_isdst=0)

2.2 格式化日期

可以使用time模块的strftime方法来格式化日期

语法：

time.strftime(format[, t])

时间日期格式化符号：

　　%y        两位数的年份表示（00-99）

　　%Y              四位数的年份表示（000-9999）

%m              月份（01-12）

%d        天（0-31）

%H              24小时制（0-23）

%I        12小时制（01-12）

%M             分钟（00-59）

%S        秒（00-59）

%a        本地简化星期名称（Mon…Sun）

%A              本地完整星期名称（Monday…Sunday）

%b        本地简化的月份名称（Jan…Dec）

%B              本地完整的月份名称（January…December）

%c        本地相应的日期表示和时间表示（Tue Aug  8 10:00:02 2017）

%j         年内的一天（001-366）

%p        本地AM或PM的等价符

%U              一年中的星期数（00-53），星期天为星期的开始

%w              星期（0-6），星期天为星期的开始

%W      一年的星期数（00-53），星期一为星期的开始

%x        本地相应的日期表示（日/月/年，如：08/08/17）

%X              本地相应的时间表示（时:分:秒，如：10:09:00）

%z        当前时区的名称（+0800）

%%              %号本身

实例：

import time
print(time.strftime(‘%Y-%m-%d %X‘))                     # 格式化成2017-08-08 09:39:31形式
print(time.strftime(‘%Y-%m-%d %H:%M:%S‘))               # 格式化成2017-08-08 09:39:31形式

#执行结果
2017-08-08 09:39:31
2017-08-08 09:39:31

2.3 时间格式的转换

 技术分享

 

1.实例：时间戳转结构化的时间localtime([secs]

import time
print(time.localtime())                 #未指定secs参数，则以当前时间为准
print(time.localtime(1473525444.037215))

#执行结果
time.struct_time(tm_year=2017, tm_mon=8, tm_mday=8, tm_hour=10, tm_min=39, tm_sec=2, tm_wday=1, tm_yday=220, tm_isdst=0)
time.struct_time(tm_year=2016, tm_mon=9, tm_mday=11, tm_hour=0, tm_min=37, tm_sec=24, tm_wday=6, tm_yday=255, tm_isdst=0)

2.实例：结构化的时间转时间戳mktime(t)

import time
print(time.mktime(time.localtime()))
print(time.mktime((2017, 8, 8, 10, 39, 2, 1, 220, 0)))

#执行结果：
1502162703.0
1502159942.0

3.实例：结构化的时间转格式化的时间字符串strftime(format[, t])

import time
print(time.strftime(‘%Y-%m-%d %H:%M:%S‘,time.localtime()))              #如果t未指定，也将传入time.localtime()
print(time.strftime(‘%Y-%m-%d %H:%M:%S‘,(2017, 8, 8, 10, 39, 2, 1, 220, 0)))

#执行结果：
2017-08-08 11:32:35
2017-08-08 10:39:02

4.实例：格式化的时间字符串转结构化的时间time.strptime(string[, format])

import time
print(time.strptime(‘2017-08-08 11:32:35‘,‘%Y-%m-%d %H:%M:%S‘))

#执行结果：
time.struct_time(tm_year=2017, tm_mon=8, tm_mday=8, tm_hour=11, tm_min=32, tm_sec=35, tm_wday=1, tm_yday=220, tm_isdst=-1) 

技术分享

5.实例：结构化的时间转‘Sun Jun 20 23:21:05 1993‘形式asctime([t])

import time
print(time.asctime())                   #如果t未指定，将传入time.localtime()
print(time.asctime((2017, 8, 8, 10, 39, 2, 1, 220, 0)))

#执行结果：
Tue Aug  8 11:49:14 2017
Tue Aug  8 10:39:02 2017

6.实例：时间戳转‘Sun Jun 20 23:21:05 1993‘形式ctime([secs])

import time
print(time.ctime())             #None的时候，将会默认time.time()为参数,相当于time.asctime(time.localtime(secs))
print(time.ctime(1502161211.630944))

#执行结果：
Tue Aug  8 11:54:00 2017
Tue Aug  8 11:00:11 2017

2.4 time模块函数

Time 模块包含了以下内置函数：

序号

函数及描述

实例

1

time.altzone
返回格林威治西部的夏令时地区的偏移秒数。如果该地区在格林威治东部会返回负值（如西欧，包括英国）。对夏令时启用地区才能使用。

以下实例展示了 altzone()函数的使用方法：

>>> import time

>>> print ("time.altzone %d " % time.altzone)

time.altzone -28800

2

time.asctime([tupletime])
接受时间元组并返回一个可读的形式为"Tue Dec 11 18:07:14 2008"（2008年12月11日 周二18时07分14秒）的24个字符的字符串。

以下实例展示了 asctime()函数的使用方法：

>>> import time

>>> t = time.localtime()

>>> print ("time.asctime(t): %s " % time.asctime(t))

time.asctime(t): Thu Apr  7 10:36:20 2016

3

time.clock()
用以浮点数计算的秒数返回当前的CPU时间。用来衡量不同程序的耗时，比time.time()更有用。

实例

4

time.ctime([secs])
作用相当于asctime(localtime(secs))，未给参数相当于asctime()

以下实例展示了 ctime()函数的使用方法：

>>> import time

>>> print ("time.ctime() : %s" % time.ctime())

time.ctime() : Thu Apr  7 10:51:58 2016

5

time.gmtime([secs])
接收时间辍（1970纪元后经过的浮点秒数）并返回格林威治天文时间下的时间元组t。注：t.tm_isdst始终为0

以下实例展示了 gmtime()函数的使用方法：

>>> import time

>>> print ("gmtime :", time.gmtime(1455508609.34375))

gmtime : time.struct_time(tm_year=2016, tm_mon=2, tm_mday=15, tm_hour=3, tm_min=56, tm_sec=49, tm_wday=0, tm_yday=46, tm_isdst=0)

6

time.localtime([secs]
接收时间辍（1970纪元后经过的浮点秒数）并返回当地时间下的时间元组t（t.tm_isdst可取0或1，取决于当地当时是不是夏令时）。

以下实例展示了 localtime()函数的使用方法：

>>> import time

>>> print ("localtime(): ", time.localtime(1455508609.34375))

localtime():  time.struct_time(tm_year=2016, tm_mon=2, tm_mday=15, tm_hour=11, tm_min=56, tm_sec=49, tm_wday=0, tm_yday=46, tm_isdst=0)

7

time.mktime(tupletime)
接受时间元组并返回时间辍（1970纪元后经过的浮点秒数）。

实例

8

time.sleep(secs)
推迟调用线程的运行，secs指秒数。

以下实例展示了 sleep()函数的使用方法：

#!/usr/bin/python3

import time

 

print ("Start : %s" % time.ctime())

time.sleep( 5 )

print ("End : %s" % time.ctime())

9

time.strftime(fmt[,tupletime])
接收以时间元组，并返回以可读字符串表示的当地时间，格式由fmt决定。

以下实例展示了 strftime()函数的使用方法：

>>> import time

>>> print (time.strftime("%Y-%m-%d %H:%M:%S", time.localtime()))

2016-04-07 11:18:05

10

time.strptime(str,fmt=‘%a %b %d %H:%M:%S %Y‘)
根据fmt的格式把一个时间字符串解析为时间元组。

以下实例展示了 strftime()函数的使用方法：

>>> import time

>>> struct_time = time.strptime("30 Nov 00", "%d %b %y")

>>> print ("返回元组: ", struct_time)

返回元组:  time.struct_time(tm_year=2000, tm_mon=11, tm_mday=30, tm_hour=0, tm_min=0, tm_sec=0, tm_wday=3, tm_yday=335, tm_isdst=-1)

11

time.time( )
返回当前时间的时间戳（1970纪元后经过的浮点秒数）。

以下实例展示了 time()函数的使用方法：

>>> import time

>>> print(time.time())

1459999336.1963577

12

time.tzset()
根据环境变量TZ重新初始化时间相关设置。

实例

Time模块包含了以下2个非常重要的属性：

序号

属性及描述

1

time.timezone
属性time.timezone是当地时区（未启动夏令时）距离格林威治的偏移秒数（>0，美洲;<=0大部分欧洲，亚洲，非洲）。

2

time.tzname
属性time.tzname包含一对根据情况的不同而不同的字符串，分别是带夏令时的本地时区名称，和不带的。

3 random模块

可以生成随机浮点数、整数、字符串，甚至帮助你随机选择列表序列中的一个元素，打乱一组数据等

3.1 random模块函数

序号

函数及描述

实例

1

random.random()

随机生成一个浮点数，范围在0.0~1.0之间

>>> import random

>>> print(random.random())

0.5710264615564344

2

random.uniform(a,b)

随机生成一个指定范围内的浮点数，两个参数其中一个是上限，一个是下限

>>> import random

>>> print(random.uniform(10,20))

19.260586981617095

3

random.randint(a,b)

随机生成一个指定范围内的整数，两个参数其中一个是上限，一个是下限（包含a|b）

>>> import random

>>> print(random.randint(10,20))

14

4

random.choice(lst)

可以从任何序列中选取一个随机的元素返回

>>> import random

>>> print(random.choice([1,2,[4,5],{8,9}]))

{8, 9}

5

random.shuffle(lst)

随机打乱一个序列中的元素

>>> import random

>>> list = [1,2,3,4,5,6]

>>> random.shuffle(list)

>>> print(list)

[1, 6, 4, 3, 5, 2]

6

random.sample(sequence, k)

从指定序列中随机获取指定长度的片断。不会修改原有序列

>>> import random

>>> print(random.sample([1,2,3,4,5,6],3))

[5, 1, 4]

7

random.randrange([start], stop[, step])

从指定范围内，按指定基数递增的集合中获取一个随机数

>>> import random

>>> print(random.randrange(10,100,2))#相当于从[10,... 96, 98]获取1个随机数

12

3.2 生成随机验证码

#生成随机验证码
import random

def make_code(n):
    res = ‘‘
    for i in range(n):
        s1 = str(random.randint(0,9))            #整型数字无法与字符串拼接，这里用str转换成字符串
        s2 = chr(random.randint(65,90))          #利用chr内置函数，产生随机的大写字母
        res += random.choice([s1,s2])
    return res

print(make_code(10)) 

4 os模块

os模块是与操作系统交互的一个接口，提供了非常丰富的方法用来处理文件和目录

常用的方法

os.getcwd()                         获取当前工作目录，即当前python脚本工作的目录路径
os.chdir("dirname")                 改变当前脚本工作目录；相当于shell下cd
os.curdir                           返回当前目录: (‘.‘)
os.pardir                           获取当前目录的父目录字符串名：(‘..‘)
os.makedirs(‘dirname1/dirname2‘)    可生成多层递归目录
os.removedirs(‘dirname1‘)           若目录为空，则删除，并递归到上一级目录，如若也为空，则删除，依此类推
os.mkdir(‘dirname‘)                 生成单级目录；相当于shell中mkdir dirname
os.rmdir(‘dirname‘)                 删除单级空目录，若目录不为空则无法删除，报错；相当于shell中rmdir dirname
os.listdir(‘dirname‘)               列出指定目录下的所有文件和子目录，包括隐藏文件，并以列表方式打印
os.remove()                         删除一个文件
os.rename("oldname","newname")      重命名文件/目录
os.stat(‘path/filename‘)            获取文件/目录信息
os.sep                              输出操作系统特定的路径分隔符，win下为"\\",Linux下为"/"
os.linesep                          输出当前平台使用的行终止符，win下为"\r\n",Linux下为"\n"
os.pathsep                          输出用于分割文件路径的字符串 win下为;,Linux下为:
os.name                             输出字符串指示当前使用平台。win->‘nt‘; Linux->‘posix‘
os.system("bash command")           运行shell命令，直接显示
os.environ                          获取系统环境变量
os.path.abspath(path)               返回path规范化的绝对路径
os.path.split(path)                 将path分割成目录和文件名二元组返回
os.path.dirname(path)               返回path的目录。其实就是os.path.split(path)的第一个元素
os.path.basename(path)              返回path最后的文件名。如何path以／或\结尾，那么就会返回空值。即os.path.split(path)的第二个元素
os.path.exists(path)                如果path存在，返回True；如果path不存在，返回False
os.path.isabs(path)                 如果path是绝对路径，返回True
os.path.isfile(path)                如果path是一个存在的文件，返回True。否则返回False
os.path.isdir(path)                 如果path是一个存在的目录，则返回True。否则返回False
os.path.join(path1[, path2[, ...]]) 将多个路径组合后返回，第一个绝对路径之前的参数将被忽略
os.path.getatime(path)              返回path所指向的文件或者目录的最后存取时间
os.path.getmtime(path)              返回path所指向的文件或者目录的最后修改时间
os.path.getsize(path)               返回path的大小
1、在Linux和Mac平台上，该函数会原样返回path，在windows平台上会将路径中所有字符转换为小写，并将所有反斜杠转换为斜杠。
>>> os.path.normcase(‘c:/windows\\system32\\‘)  
‘c:\\windows\\system32\\‘  

2、规范化路径，如..和/
>>> os.path.normpath(‘c://windows\\System32\\../Temp/‘)  
‘c:\\windows\\Temp‘  

>>> a=‘/Users/jieli/test1/\\\a1/\\\\aa.py/../..‘
>>> print(os.path.normpath(a))
/Users/jieli/test1 
#os路径处理
#方式一：推荐使用
import os
#具体应用
import os,sys
possible_topdir = os.path.normpath(os.path.join(
    os.path.abspath(__file__),
    os.pardir, #上一级
    os.pardir,
    os.pardir
))
sys.path.insert(0,possible_topdir)

#方式二：不推荐使用
os.path.dirname(os.path.dirname(os.path.dirname(os.path.abspath(__file__)))) 

5 sys模块

sys 模块提供了许多函数和变量来处理 Python 运行时环境的不同部分

5.1 sys模块常见函数列表

sys.argv                实现从程序外部向程序传递参数,第一个元素是程序本身路径
sys.exit([arg])         退出程序，正常退出是exit(0)
sys.version             获取Python解释程序的版本信息
sys.maxint              最大的Int值
sys.path                返回模块的搜索路径，初始化时使用PYTHONPATH环境变量的值
sys.platform            返回操作系统平台名称

5.2 sys模块常见函数的使用

#sys_test.py如下：
import sys
print(sys.argv[0])
print(sys.argv[1])

#执行命令：
F:\Python\Code>python sys_test.py argv1

#执行结果：
sys_test.py
argv1 
#sys.path功能：获取指定模块搜索路径的字符串集合，可以将写好的模块放在得到的某个路径下，就可以在程序中import时正确找到
>>> import sys
>>> sys.path
[‘‘, ‘C:\\Python36\\python36.zip‘, ‘C:\\Python36\\DLLs‘, ‘C:\\Python36\\lib‘, ‘C:\\Python36‘, ‘C:\\Python36\\lib\\site-packages‘]

>>> sys.path.append("F:\Python\test")               #添加自定义模块路径 
#=========知识储备==========
#指定宽度
print(‘<%-10.3f>‘ %3.22) #总宽度为10,保留3位小数点
#打印结果
#<3.220     >

#打印%号,用%%
width=10
print(‘<%%-%ds>‘ %width)
#打印结果
# <%-10s>

#嵌套的%
width=10
print((‘<%%-%ds>‘ %width) %(‘hello‘))
#打印结果
# <hello     >

#=========实现打印进度条函数==========
import sys
import time
def progress(percent,width=50):
    if percent >= 100:
        print(‘\r[%s] %d%%‘ %(‘#‘*width,100)) #print的end默认为回车
        return

    show_str=(‘[%%-%ds]‘ %width) %(int(width * percent / 100) * "#") #字符串拼接的嵌套使用
    print("\r%s %d%%" %(show_str, percent),end=‘‘,file=sys.stdout,flush=True)

#=========应用==========
data_size=3030333
recv_size=0
while recv_size < data_size:
    time.sleep(0.001) #模拟数据的传输延迟
    recv_size+=1024 #每次收1024

    recv_per=int(100*(recv_size/data_size)) #接收的比例
    progress(recv_per,width=30) #进度条的宽度30

6 json与pickle模块

序列化 (Serialization)将对象的状态信息转换为可以存储或传输的形式的过程。在序列化期间，对象将其当前状态写入到临时或持久性存储区。以后，可以通过从存储区中读取或反序列化对象的状态，重新创建该对象

序列化的作用：持久保存状态、跨平台数据交互

6.1 json模块

如果我们要在不同的编程语言之间传递对象，就必须把对象序列化为标准格式，比如XML，但更好的方法是序列化为JSON，因为JSON表示出来就是一个字符串，可以被所有语言读取，也可以方便地存储到磁盘或者通过网络传输。JSON不仅是标准格式，并且比XML更快，而且可以直接在Web页面中读取，非常方便

JSON表示的对象就是标准的JavaScript语言的对象，JSON和Python内置的数据类型对应如下：

技术分享

json函数：

函数

描述

json.dumps

将 Python 对象编码成 JSON 字符串

json.loads

将已编码的 JSON 字符串解码为 Python 对象

dumps是将dict转化成str格式，loads是将str转化成dict格式

dump和load也是类似的功能，只是与文件操作结合起来了

实例1：

#1、序列化，将 Python 对象编码成 JSON 字符串
import json
data = {‘a‘:1,‘b‘:2,‘c‘:3}
with open(‘a.json‘,‘w‘) as f:
    f.write(json.dumps(data))

#2、反序列化，将已编码的 JSON 字符串解码为 Python 对象
import json
with open(‘a.json‘,‘r‘) as f:
    data = json.loads(f.read())
    print(data[‘a‘])

#执行结果：
1

实例2：另一种实现方法

import json
data = {‘a‘:1,‘b‘:2,‘c‘:3}
json.dump(data,open(‘b.json‘,‘w‘))

import json
print(json.load(open(‘b.json‘,‘r‘))[‘a‘])

#执行结果：
1 

6.2 pickle模块

pickle提供了一个简单的持久化功能。可以将对象以文件的形式存放在磁盘上

pickle模块只能在Python中使用，python中几乎所有的数据类型（列表，字典，集合，类等）都可以用pickle来序列化

pickle序列化后的数据可读性差，人一般无法识别

实例1：

#1、序列化
import pickle
data = {‘a‘:1,‘b‘:2,‘c‘:3}
with open(‘a.pkl‘,‘wb‘) as f:
    f.write(pickle.dumps(data))

#2、反序列化
import pickle
with open(‘a.pkl‘,‘rb‘) as f:
    data = pickle.loads(f.read())
    print(data[‘a‘])

#执行结果：
1

实例2：另一种实现方法

import pickle
data = {‘a‘:1,‘b‘:2,‘c‘:3}
pickle.dump(data,open(‘b.pkl‘,‘wb‘))

import pickle
print(pickle.load(open(‘b.pkl‘,‘rb‘))[‘a‘])

#执行结果：
1 

7 shelve模块

shelve是一种简单的数据存储方案，它只有一个open()函数，这个函数接收一个参数就是文件名

调用shelve.open()会返回一个shelf对象用来存储内容，将它当做一个普通的字典来存储数据（字典的键一定要是字符串），在存储完毕之后要调用close()函数，关闭文件。

保存对象至shelve文件中：

import shelve

f = shelve.open(‘shelveDict‘)              #打开一个文件
f[‘baidu‘] = ‘www.baidu.com‘               #向文件中添加内容，添加方式与给字典添加键值对相同
f[‘taobao‘] = ‘www.taobao.com‘
f.close()                                  #关闭文件

从文件中读取对象：

import shelve

f = shelve.open(‘shelveDict‘)              #打开文件
print(f[‘baidu‘])                          #跟字典一样读取内容
print(f[‘taobao‘])
f.close()                                  #关闭文件

#执行结果
www.baidu.com
www.taobao.com

更新文件中的数据：

import shelve

f = shelve.open(‘shelveDict‘)               #打开文件
f[‘baidu‘] = ‘map.baidu.com‘                #直接对对象进行修改
print(f[‘baidu‘])
f.close()                                   #关闭文件

#执行结果：
map.baidu.com
www.taobao.com 

匿名函数、内置函数与模块


联系
我们