# 天文匿名函数、内置函数与常用模块

• 三月 19, 2019
• 天文
• 没有评论

## 壹 、匿名函数

Python使用lambda来创建匿名函数，不再行使def语句那样标准的款型定义贰个函数

• lambda只是二个表达式，函数体比def简单很多
• lambda的主旨是一个表明式，而不是三个代码块。仅仅能在lambda表明式中封装有限的逻辑进去
• lambda函数拥有和谐的名号空间，且无法访问自有参数列表之外或全局名称空间里的参数
• 虽说lambda函数看起来只可以写一行，却不平等C或C++的内联函数，后者的目标是调用小函数时不占用栈内部存款和储蓄器从而增添运行作用
• 切合近来的1回性的利用景况

``````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全体的放权函数

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()

``````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]))                 #求和
``````

``````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'
``````

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

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

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

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

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

``````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)))                   #将可迭代的对象作为参数，将对象中对应的元素打包成一个个元组，然后返回由这些元组组成的列表
``````

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

``````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 的元素放到新列表中
``````

``````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()))))  #取第二个元素，即名字

#方法二：
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模块-正则表明式

#### 1.1 re.match函数

re.match尝试从字符串的发端地方匹配1个方式。就算不是开第二地点匹配成功的话，match()就赶回None

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

 参数 描述 pattern 匹配的正则表达式 string 要匹配的字符串。 flags 标志位，用于控制正则表达式的匹配方式，如：是否区分大小写，多行匹配等等。

 匹配对象方法 描述 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 标志位，用于控制正则表达式的匹配方式，如：是否区分大小写，多行匹配等等。

 匹配对象方法 描述 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']
``````

按Yi Zhongtian的话说，郭嘉的这段话有三层意思：
第3层意思，正是三个了然的人，尤其是多少个准备做顾问的人，要力所能及善于为团结挑选二个好老

“一沐三握发，一饭三吐哺”，正是说他正在洗头，突然有人通报说有2个姿首来了，立时结束洗头，

#### 1.5 re.split函数

``````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.武皇帝三战吕布，士卒疲倦，准备撤军时，郭嘉却力主再战，而且断定此战必胜。结果吕布被擒；

2.曹孟德和袁本初争论在官渡之时，蜚言孙策准备偷袭曹孟德在许都的根据地，新闻扩散，曹军不少人

3.曹阿瞒征战袁谭、袁尚(袁绍的后来人)。此时，全体的人都主张战，而郭嘉却主持退兵。结果袁

4.征乌丸，当时游人如织人都不主张打，可是郭嘉却认为，第①，乌丸是远，但正因为远，他们自然
“恃其远”而“不配备”，如此我们一定能打她个措手不及。第①，若乌丸和袁家缔盟，大家将面临

#### 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函数

``````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 正则表达式修饰符-可选标志

OHaval(|) 它们来钦定。如 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(‘ac’,’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] 匹配任何数字。类似于  [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模块能够用来格式化日期和岁月

``````#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
``````

``````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遍求见最后见到诸葛卧龙时，问及当前天下大事，便是历史上有名的《隆中对》了。恰

CEO都亲身上

#### 2.2 格式化日期

``````time.strftime(format[, t])
``````

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

%Y　　3位数的年份表示（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 1994’情势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 1992’情势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
``````

但用Yi Zhongtian先生的话说:

#### 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模块包括了以下三个特别主要的个性：

 序号 属性及描述 1 time.timezone 属性time.timezone是当地时区（未启动夏令时）距离格林威治的偏移秒数（>0，美洲;<=0大部分欧洲，亚洲，非洲）。 2 time.tzname 属性time.tzname包含一对根据情况的不同而不同的字符串，分别是带夏令时的本地时区名称，和不带的。

诸葛孔明做的那个“隆中对”此刻依旧空谈，不是智囊没有能力，而是诸葛卧龙和汉烈祖都有忌

“而其主无法守，此殆天所以资将军。”

### 3 random模块

所以要表明的正是，如若赏心悦目的远志与CEO的个人追求，人生愿望相平等，而与此同时此人才又是

#### 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模块是与操作系统交互的一个接口，提供了相当丰盛的不二法门用来拍卖文件和目录

鲁肃，字子敬，临淮东城人。从小丧父，靠祖母抚养。他少有雄心壮志，轻财好施，喜欢习武骑射，

公元
198年，贰拾5岁的鲁肃来到东吴，投奔孙策，然而一贯尚未获取孙策的选定。本想大展宏

（周公瑾举荐）,貌取人和鲁肃合榻对饮。这一个时候,孙仲谋感叹：

#### 常用的艺术

``````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)
print(sys.argv)

#执行命令：
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模块

JSON表示的靶子就是正经的JavaScript语言的对象，JSON和Python内置的数据类型对应如下： json函数：

 函数 描述 json.dumps 将 Python 对象编码成 JSON 字符串 json.loads 将已编码的 JSON 字符串解码为 Python 对象

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

dump和load也是相近的功能，只是与公事操作结合起来了

``````#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
``````

``````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、序列化
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
``````

``````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是一种不难的数目存款和储蓄方案，它唯有2个open()函数，那个函数接收三个参数正是文件名

``````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
``````

而同等有像样下场的就是沮授了，作者在“关于三国谋士之IT从业可行性报告”中曾经说过她的忠

“孤早相得，天下不足虑。”那句话也成了她人生巅峰所收获的褒贬。而选错首席营业官或然是沮授一

接着再聊天陈宫，那是一个比他的业主还要像老总的人，与其让她做顾问，还不如让他去做CEO。
{"ft_lang_label":"__label__zh","ft_lang_prob":0.67909527,"math_prob":0.98636824,"size":31246,"snap":"2019-35-2019-39","text_gpt3_token_len":22398,"char_repetition_ratio":0.12015876,"word_repetition_ratio":0.09394904,"special_character_ratio":0.32688984,"punctuation_ratio":0.18720293,"nsfw_num_words":0,"has_unicode_error":false,"math_prob_llama3":0.961417,"pos_list":[0,1,2,3,4,5,6],"im_url_duplicate_count":[null,1,null,1,null,1,null],"WARC_HEADER":"{\"WARC-Type\":\"response\",\"WARC-Date\":\"2019-08-26T03:24:03Z\",\"WARC-Record-ID\":\"<urn:uuid:3da0cffb-b6b5-4685-9a60-2fb13257f14c>\",\"Content-Length\":\"102608\",\"Content-Type\":\"application/http; msgtype=response\",\"WARC-Warcinfo-ID\":\"<urn:uuid:286ae1e1-34a1-440c-b482-b0e5ca5a6c47>\",\"WARC-Concurrent-To\":\"<urn:uuid:c19025fa-db41-48dc-a36c-62dba04af878>\",\"WARC-IP-Address\":\"45.192.72.113\",\"WARC-Target-URI\":\"https://www.kokororyu.com/tw/3441.html\",\"WARC-Payload-Digest\":\"sha1:YKI3622B4XZCXIXN5LFYZRZXD2FW2PSP\",\"WARC-Block-Digest\":\"sha1:XRADBIEEFFVDCITHO267ZDWHO3UDOASD\",\"WARC-Identified-Payload-Type\":\"text/html\",\"warc_filename\":\"/cc_download/warc_2019/CC-MAIN-2019-35/CC-MAIN-2019-35_segments_1566027330962.67_warc_CC-MAIN-20190826022215-20190826044215-00505.warc.gz\"}"}