首页 > 代码库 > python基础-匿名函数、内置函数、正则表达式、模块
python基础-匿名函数、内置函数、正则表达式、模块
1. 匿名函数
1.1 有名函数
有名函数：定义了一个函数名，函数名指向内存地址；通过函数名进行访问。函数名加括号就可以运行有名函数，例如：func()
def func(x, y, z = 1): return x + y + z print(func(1,5,2))
1.2 匿名函数
匿名函数：没有名字的函数，定义的时候不需要函数名；定义匿名函数的关键字是：lambda
特点：
1.没有函数名
2.函数自带return
应用场景：
1.应用于一次性的地方
2.临时使用
salaries={ ‘egon‘:3000, ‘alex‘:100000000, ‘wupeiqi‘:10000, ‘yuanhao‘:2000 } # 打印工资最高的人名，利用匿名函数很好的解决此问题 print(max(salaries,key=lambda name:salaries[name]))
2. 内置函数
官方内置函数网址：https://docs.python.org/3/library/functions.html
2.1 概览
2.2 abs all any
1.abs 求绝对值
2.all 可迭代对象取出所有值，进行判断，所有为真就返回True
如果可迭代对象为空，返回True 例如：all([])
3.any
可迭代对象取出所有值，进行判断，任何一个为真就返回True
如果可迭代对象为空，返回False 例如：any([])
print(abs(-100)) print(all([1,-20,None])) # 只要有一个为假，返回False print(all([1,-20,"a"])) # 只要所有为真，返回True print(all([])) # 可迭代对象为空，返回True print(any([1,-20,None])) # 只要有一个为真，返回True print(any([])) # 可迭代对象为空，返回False print(any([‘‘,None,False])) #所有为假，返回False
2.3 bool
bool值为假的情况
1.None
2.空
3.False
4.0
2.4 bin oct hex
1.bin 十进制转换为二进制
2.oct 十进制转换为八进制
3.hex十进制转化为十六进制
print(bin(10)) # 0b1010 print(oct(10)) # 0o12 print(hex(10)) # 0xa
2.5 bytes
print(‘hello‘.encode(‘utf-8‘)) # unicode----encode----->bytes print(bytes(‘hello‘,encoding=‘utf-8‘)) # 利用bytes把unicode转化为bytes
2.6 callable
callable：判断一个对象是否可调用，是否可用加括号运行的，例如：函数
print(callable(bytes)) print(callable(abs))
2.7 chr ord
chr：用一个十进制数字，利用chr函数，转换为一个ascii表中的一个字符
ord：字符转化为数字
A—Z 65到90
print(chr(65)) # A print(chr(90)) # Z print(ord(‘H‘)) # 72
2.8 数据类型
内置函数，又被称为工厂函数
目前了解的数据类型如下：
1.int 整形
2.complex 复数
3.float 浮点
4.str 字符串
5.list 列表
6.tuple 元组
7.dict 字典
8.set 可变集合
9.frozenset 不可变集合
x=1 #x=int(1) print(type(x)) # <class ‘int‘> x=int(2) s={1,2,3,4} #s=set({1,2,3,4}) print(type(s)) # <class ‘set‘> s1=frozenset({1,2,3,4}) print(type(s1)) # <class ‘frozenset‘>
2.9 dir
利用dir，可以查看一个模块可以调用的属性和方法
import sys sys.path # path是sys的属性 print(dir(sys)) # 查看sys点可以调用的属性和方法
2.10 divmod
利用divmod，获得被除数除以除数，得到商和余数
print(divmod(10,3)) # (3, 1) print(divmod(102,20)) # (5, 2)
2.11 enumerate
enumerate，把一个可迭代对象，生成一个迭代器
l=[‘a‘,‘b‘,‘c‘] res = enumerate(l) for i in res: print(i) for index,item in enumerate(l): print(index,item)
2.12 hash
hash，校验一个字符串值，只要字符串的值一样，hash结果就一样
print(hash(‘abcdefg123‘)) # hash 结果为：-203804489563080217 print(hash(‘abcdefg123‘)) # hash 结果为：-203804489563080217 print(hash(‘abcdefg123‘)) # hash 结果为：-203804489563080217
2.13 help
利用help，查看函数的文档信息；给函数加文档解释，用到单引号，双引号，三引号
def func(): ‘‘‘ test function :return: ‘‘‘ pass print(help(func))
2.14 id
id:是python解释器实现的功能，只是反映了变量在内存的地址，但并不是真实的内存地址
x=1 print(id(x)) def func():pass print(id(func)) print(func) # 最精准的内存地址反映
2.15 isinstance
isinstance，判断一个变量是否属于一个数据类型
x=1 print(type(x) is int) print(isinstance(x,int))
2.16 max min
max：求最大值，同类型之间进行比较
min：求最小值，同类型之间进行比较
print(max([1,2,3,10])) print(max([‘a‘,‘b‘])) print(min([1,2,3,10]))
2.17 pow
pow求幂运算
print(pow(3,5)) print(pow(3,2,2)) #3**2%2
2.18 repr str
repr、str都是把数字转化为字符串
repr：给解释器用的
str： 给用户用的
print(type(str(100))) # 输出结果： <class ‘str‘> print(type(repr(100))) # 输出结果： <class ‘str‘>
2.19 reversed
reversed：反转，也就是倒排序
l=[1,‘a‘,2,‘c‘] print(list(reversed(l))) # [‘c‘, 2, ‘a‘, 1] 反转产生新列表，并不反转原列表 print(l) # [1, ‘a‘, 2, ‘c‘]
2.20 round
利用round，保留小数位数，并进行四舍五入
示例
print(round(2.764,2)) # 运行结果：2.76 print(round(2.768,2)) # 运行结果：2.77
2.21 slice
slice，是切片的意思，调用slice函数，生产切片对象，方便进行重用，为很多列表所用。
l=[1,2,3,4,5,6] print(l[0:4:2]) s=slice(0,4,2) print(l[s])
2.22 sorted
排序，同类型之间进行排序
l=[1,10,4,3,-1] print(sorted(l)) # 排序，从小到大排序，运行结果：[-1, 1, 3, 4, 10] print(sorted(l,reverse=True)) #从大到小排序，运行结果：[10, 4, 3, 1, -1]
2.23 sum
利用sum求和
print(sum([1, 2,3])) print(sum(i for i in range(10)))
2.24 zip
zip拉链，把两个序列类型生成一个小元组列表
s=‘hello‘ l=[1,2,3,4,5] print(list(zip(s,l))) # 运行结果：[(‘h‘, 1), (‘e‘, 2), (‘l‘, 3), (‘l‘, 4), (‘o‘, 5)]
2.25 __import__
__import__，导入模块，把字符串转化为模块类型
m_name=input(‘module>>: ‘) if m_name == ‘sys‘: m=__import__(m_name) print(m) print(m.path) sys=__import__(‘sys‘) print(sys)
2.26 内置函数补充
薪资字典
salaries={ ‘egon‘:3000, ‘alex‘:100000000, ‘wupeiqi‘:10000, ‘yuanhao‘:2000 }
2.26.1 max
获取薪资最大的人名
print(max(salaries,key=lambda name:salaries[name])) print(min(salaries,key=lambda name:salaries[name]))
内置函数max、min的实质是通过循环，比较最大值和最小值，只是默认比较key，可以通过函数的第二个参数key选择比较value值
通过max内部实现机制：通过for循环，只获取一个值，传给匿名函数lambda name:salaries[name])，把执行结果作为比较依据，然后进行比较，比较的依据是max的第二个参数的运行结果
salaries={ ‘egon‘:3000, ‘alex‘:100000000, ‘wupeiqi‘:10000, ‘yuanhao‘:2000 } # 利用zip实现需求，十分复杂 # 知识储备 t1=(10000000,‘alex‘) t2=(3000,‘egon‘) print(t1 > t2) # 运行结果：True print(max(salaries)) # 最大的name值，运行结果：yuanhao print(max(salaries.values())) # 最大的values值，运行结果：100000000 # 取出name和value，利用zip转为元组，最后进行比较 print(max(zip(salaries.values(),salaries.keys()))[1]) def get_value(name): return salaries[name] print(max(salaries,key=get_value)) print(max(salaries,key=lambda name:salaries[name])) # 薪资最大的人名：alex print(min(salaries,key=lambda name:salaries[name])) # 薪资最小的人名：yuanhao
2.26.2 sorted
比较薪资从小到大的人名
salaries = { "egon":3000, "alex":100000000, "wupeiqi":100000, "yuanhao":2000, } def get_value(name): return salaries[name] print(sorted(salaries,key=get_value)) # 运行结果： [‘yuanhao‘, ‘egon‘, ‘wupeiqi‘, ‘alex‘] print(sorted(salaries,key=lambda name:salaries[name],reverse=True)) #运行结果：[‘alex‘, ‘wupeiqi‘, ‘egon‘, ‘yuanhao‘]
2.26.3 map
filter、map、reduce，都是对一个集合进行处理；filter很容易理解用于过滤，map用于映射，reduce用于归并. 是Python列表方法的三架马车。
map函数：func作用于给定序列的每个元素，并用一个列表来提供返回值
names=[‘alex‘,‘wupeiqi‘,‘yuanhao‘,‘yanglei‘,‘egon‘] res=map(lambda x:x if x == ‘egon‘ else x+‘SB‘,names) print(res) # 运行结果：<map object at 0x0000000002219B70> print(list(res)) # 运行结果：[‘alexSB‘, ‘wupeiqiSB‘, ‘yuanhaoSB‘, ‘yangleiSB‘, ‘egon‘] N1=[1,2,3] N2=[6,5,4] print(list(map(lambda x,y:x+y,N1,N2))) # 运行结果：[7, 7, 7] print(list(map(lambda x:x+3,N1))) # 运行结果：[4, 5, 6]
2.26.4 reduce
reduce函数：func为二元函数，将func作用于seq序列的元素，每次携带一对（先前的结果以及下一个序列的元素），连续的将现有的结果和下一个值作用在获得的随后的结果上，最后减少我们的序列为一个单一的返回值
from functools import reduce print(reduce(lambda x,y:x+y,range(101),100)) # 运行结果：5150 print(reduce(lambda x,y:x+y,range(101))) # 运行结果：5050 # 用map和reduce实现5的阶乘相加（5!+4!+3!+2!+1!） print(reduce(lambda x,y:x*y,range(1,6))) print(reduce(lambda x,y:x*y,range(1,5))) print(reduce(lambda x,y:x*y,range(1,4))) print(reduce(lambda x,y:x*y,range(1,3))) print(reduce(lambda x,y:x*y,range(1,2))) #把上一步的结果变成一个阶乘列表 print(list(map(lambda a:reduce(lambda x,y:x*y,range(1,a+1)),range(1,6)))) # 运行结果：[1, 2, 6, 24, 120] #最后把阶乘列表相加 print(reduce(lambda m,n:m+n,map(lambda a:reduce(lambda x,y:x*y,range(1,a+1)),range(1,6)))) # 运行结果：153
2.26.5 filter
filter函数的功能相当于过滤器。调用一个布尔函数bool_func来迭代遍历每个seq中的元素；返回一个使bool_seq返回值为true的元素的序列。
names=[‘alex_SB‘,‘wupeiqi_SB‘,‘yuanhao_SB‘,‘yanglei_SB‘,‘egon‘] print(list(filter(lambda name:name.endswith(‘SB‘),names))) # 运行结果：[‘alex_SB‘, ‘wupeiqi_SB‘, ‘yuanhao_SB‘, ‘yanglei_SB‘] N=range(10) print(list(filter(lambda x:x>5,N))) # 运行结果：[6, 7, 8, 9]
3. 正则表达式
3.1 概览
|
模式 |
描述 |
|
\w |
匹配字母数字下划线 |
|
\W |
匹配非字母数字下划线 |
|
\s |
匹配任意空白字符，等价于[\t\n\r\f] |
|
\S |
匹配任意非空字符 |
|
\d |
匹配任意数字，等价于[0-9] |
|
\D |
匹配任意非数字 |
|
\A |
匹配字符串开始 |
|
\Z |
匹配字符串结束，如果是存在换行，只匹配到换行前的结束字符串 |
|
\z |
匹配字符串结束 |
|
\G |
匹配最后匹配完成的位置 |
|
\n |
匹配一个换行符 |
|
\t |
匹配一个制表符 |
|
^ |
匹配字符串开头 |
|
$ |
匹配字符串的结尾 |
|
. |
匹配任意字符，除了换行符，当re.DOTALL标记被指定时，则可以匹配包括换行符的任意字符。 |
|
[…] |
用来表示一组字符，单独列出：[amk]匹配’a’,’m’或者’k’ |
|
[^…] |
不在[]中的字符：[^abc]匹配除了a,b,c之外的字符 |
|
* |
匹配0个或多个的表达式 |
|
+ |
匹配1个或多个的表达式 |
|
? |
匹配0个或1个由前面的正则表达式定义的片段，非贪婪方式 |
|
{n} |
精准匹配n个前面表达式 |
|
{n,m} |
匹配n到m次，由前面的曾泽表达式定义的片段，贪婪方式 |
|
a|b |
匹配a或则b |
|
() |
匹配括号内的表达式，也表示一个组 |
3.2 基本正则
import re print(re.findall(‘\w‘,‘hello_ | egon 123‘)) # 运行结果：[‘h‘, ‘e‘, ‘l‘, ‘l‘, ‘o‘, ‘_‘, ‘e‘, ‘g‘, ‘o‘, ‘n‘, ‘1‘, ‘2‘, ‘3‘] print(re.findall(‘\W‘,‘hello_ | egon 123‘)) # 运行结果：[‘ ‘, ‘|‘, ‘ ‘, ‘ ‘] print(re.findall(‘\s‘,‘hello_ | egon 123 \n \t‘)) # 运行结果：[‘ ‘, ‘ ‘, ‘ ‘, ‘ ‘, ‘\n‘, ‘ ‘, ‘\t‘] print(re.findall(‘\S‘,‘hello_ | egon 123 \n \t‘)) # 运行结果：[‘h‘, ‘e‘, ‘l‘, ‘l‘, ‘o‘, ‘_‘, ‘|‘, ‘e‘, ‘g‘, ‘o‘, ‘n‘, ‘1‘, ‘2‘, ‘3‘] print(re.findall(‘\d‘,‘hello_ | egon 123 \n \t‘)) # 运行结果：[‘1‘, ‘2‘, ‘3‘] print(re.findall(‘\D‘,‘hello_ | egon 123 \n \t‘)) # 运行结果：[‘h‘, ‘e‘, ‘l‘, ‘l‘, ‘o‘, ‘_‘, ‘ ‘, ‘|‘, ‘ ‘, ‘e‘, ‘g‘, ‘o‘, ‘n‘, ‘ ‘, ‘ ‘, ‘\n‘, ‘ ‘, ‘\t‘] print(re.findall(‘h‘,‘hello_ | hello h egon 123 \n \t‘)) # 运行结果：[‘h‘, ‘h‘, ‘h‘] print(re.findall(‘\Ahe‘,‘hello_ | hello h egon 123 \n \t‘)) # 运行结果：[‘he‘] print(re.findall(‘^he‘,‘hello_ | hello h egon 123 \n \t‘)) # 运行结果：[‘he‘] print(re.findall(‘123\Z‘,‘hello_ | hello h egon 123 \n \t123‘)) # 运行结果：[‘123‘] print(re.findall(‘123$‘,‘hello_ | hello h egon 123 \n \t123‘)) # 运行结果：[‘123‘] print(re.findall(‘\n‘,‘hello_ | hello h egon 123 \n \t123‘)) # 运行结果：[‘\n‘] print(re.findall(‘\t‘,‘hello_ | hello h egon 123 \n \t123‘)) # 运行结果：[‘\t‘]
3.3 . [] [^]
.本身代表任意一个字符
[]内部可以有多个字符，但是本身只配多个字符中的一个
[^…]不在[]中的字符：[^abc]匹配除了a,b,c之外的字符
import re #.本身代表任意一个字符 print(re.findall(‘a.c‘,‘a a1c a*c a2c abc a c aaaaaac‘)) # 运行结果：[‘a1c‘, ‘a*c‘, ‘a2c‘, ‘abc‘, ‘a c‘, ‘aac‘] print(re.findall(‘a.c‘,‘a a1c a*c a2c abc a\nc‘,re.DOTALL)) # 运行结果：[‘a1c‘, ‘a*c‘, ‘a2c‘, ‘abc‘, ‘a\nc‘] print(re.findall(‘a.c‘,‘a a1c a*c a2c abc a\nc‘,re.S)) #运行结果：[‘a1c‘, ‘a*c‘, ‘a2c‘, ‘abc‘, ‘a\nc‘] #[]内部可以有多个字符，但是本身只配多个字符中的一个 print(re.findall(‘a[0-9][0-9]c‘,‘a a12c a1c a*c a2c a c a\nc‘,re.S)) #运行结果： [‘a12c‘] print(re.findall(‘a[a-zA-Z]c‘,‘aac abc aAc a*c a2c a c a\nc‘,re.S)) #运行结果：[‘aac‘, ‘abc‘, ‘aAc‘] #[^…]不在[]中的字符：[^abc]匹配除了a,b,c之外的字符 print(re.findall(‘a[^a-zA-Z]c‘,‘aac abc aAc a*c a2c a c a\nc‘,re.S)) #运行结果：[‘a*c‘, ‘a2c‘, ‘a c‘, ‘a\nc‘] print(re.findall(‘a[\+\/\*\-]c‘,‘a-c a+c a/c a1c a*c a2c a\nc‘,re.S)) #运行结果：[‘a-c‘, ‘a+c‘, ‘a/c‘, ‘a*c‘]
3.4 \:转义
原生字符串r rawstring；正则表达式前面加r，表示原生的
import re #\:转义 r代表rawstring print(re.findall(r‘a\\c‘,‘a\c abc‘)) # 运行结果[‘a\\c‘]
3.5 ? * + {}
? * + {}：左边有几个字符，如果有的话，贪婪匹配
?左边那一个字符有0个或者1个
*左边那一个字符有0个或者无穷个
+左边那一个字符有1个或者无穷个
{n,m}左边的字符有n-m次
import re #? * + {}：左边有几个字符，如果有的话，贪婪匹配 #?左边那一个字符有0个或者1个 print(re.findall(‘ab?‘,‘aab a ab‘)) # 运行结果： [‘a‘, ‘ab‘, ‘a‘, ‘ab‘] #*左边那一个字符有0个或者无穷个 print(re.findall(‘ab*‘,‘a ab abb abbb abbbb‘)) # 运行结果：[‘a‘, ‘ab‘, ‘abb‘, ‘abbb‘, ‘abbbb‘] print(re.findall(‘ab{0,}‘,‘a ab abb abbb abbbb‘)) # 运行结果：[‘a‘, ‘ab‘, ‘abb‘, ‘abbb‘, ‘abbbb‘] #+左边那一个字符有1个或者无穷个 print(re.findall(‘ab+‘,‘a ab abb abbb abbbb‘)) # 运行结果：[‘ab‘, ‘abb‘, ‘abbb‘, ‘abbbb‘] print(re.findall(‘ab{1,}‘,‘a ab abb abbb abbbb‘)) # 运行结果：[‘ab‘, ‘abb‘, ‘abbb‘, ‘abbbb‘] #{n,m}左边的字符有n-m次 print(re.findall(‘ab{3}‘,‘a ab abb abbb abbbb‘)) # 运行结果：[‘abbb‘, ‘abbb‘] print(re.findall(‘ab{2,3}‘,‘a ab abb abbb abbbb‘)) # 运行结果：[‘abb‘, ‘abbb‘, ‘abbb‘]
3.6 .* .*?
import re # .* .*? #.*贪婪匹配，匹配所有字符 print(re.findall(‘a.*c‘,‘a123c456c‘)) # 运行结果：[‘a123c456c‘] #.*?非贪婪匹配，获取最短的 print(re.findall(‘a.*?c‘,‘a123c456c‘)) # 运行结果：[‘a123c‘]
3.7 |
| 表示或者，左侧条件成立，不会匹配右侧条件；左侧条件不成立，才匹配右侧条件
print(re.findall(‘company|companies‘,‘Too many companies have gone bankrupt, and the next one is my company‘)) # 运行结果：[‘companies‘, ‘company‘]
3.8 ():分组
import re # (ab)，匹配成功，显示组内内容ab # (?:ab) 匹配成功，显示匹配最完全的内容 print(re.findall(‘ab+‘,‘abababab123‘)) # 运行结果：[‘ab‘, ‘ab‘, ‘ab‘, ‘ab‘] print(re.findall(‘ab+123‘,‘abababab123‘)) # 运行结果：[‘ab123‘] print(re.findall(‘ab‘,‘abababab123‘)) # 运行结果：[‘ab‘, ‘ab‘, ‘ab‘, ‘ab‘] print(re.findall(‘(ab)‘,‘abababab123‘)) # 运行结果：[‘ab‘, ‘ab‘, ‘ab‘, ‘ab‘] print(re.findall(‘(a)b‘,‘abababab123‘)) # 运行结果：[‘a‘, ‘a‘, ‘a‘, ‘a‘] print(re.findall(‘a(b)‘,‘abababab123‘)) # 运行结果：[‘b‘, ‘b‘, ‘b‘, ‘b‘] print(re.findall(‘(ab)+‘,‘abababab123‘)) # 运行结果：[‘ab‘] print(re.findall(‘(?:ab)+‘,‘abababab123‘)) # 运行结果：[‘abababab‘] print(re.findall(‘(ab)+123‘,‘abababab123‘)) # 运行结果：[‘ab‘] print(re.findall(‘(?:ab)+123‘,‘abababab123‘)) # 运行结果：[‘abababab123‘] print(re.findall(‘(ab)+(123)‘,‘abababab123‘)) # 运行结果：[(‘ab‘, ‘123‘)] print(re.findall(‘compan(y|ies)‘,‘Too many companies have gone bankrupt, and the next one is my company‘)) # 运行结果：[‘ies‘, ‘y‘] print(re.findall(‘compan(?:y|ies)‘,‘Too many companies have gone bankrupt, and the next one is my company‘)) # 运行结果：[‘companies‘, ‘company‘]
4. 模块
4.1 re模块
4.1.1 findall
匹配成功，接着匹配，查找匹配成功的所有内容
print(re.findall(‘ab‘,‘abababab123‘)) # 运行结果：[‘ab‘, ‘ab‘, ‘ab‘, ‘ab‘]
4.1.2 search
匹配成功一次，直接返回；只找到匹配成功一次结果。利用group查看内容
print(re.search(‘ab‘,‘ababab123‘).group()) # 运行结果：ab print(re.search(‘ab‘,‘12aasddds‘)) # 运行结果：None print(re.search(‘ab‘,‘12aasab3ss‘).group()) # 运行结果：ab
4.1.3 match
从开头开始查找，可以用search代替
print(re.search(‘ab‘,‘123ab456‘)) print(re.match(‘ab‘,‘123ab456‘)) # 等价于print(re.search(‘^ab‘,‘123ab456‘))
4.1.4 split
切分
print(re.split(‘b‘,‘abcde‘)) # 运行结果：[‘a‘, ‘cde‘] # 利用a切分之后，再用b进行切分 print(re.split(‘[ab]‘,‘abcde‘)) # 运行结果：[‘‘, ‘‘, ‘cde‘]
4.1.5 sub
sub：替换
print(re.sub(‘alex‘,‘SB‘,‘alex make love alex alex‘)) # 运行结果：SB make love SB SB # 指定替换次数 print(re.sub(‘alex‘,‘SB‘,‘alex make love alex alex‘,2)) # 运行结果：SB make love SB alex print(re.subn(‘alex‘,‘SB‘,‘alex make love alex alex‘,2)) # 运行结果：(‘SB make love SB alex‘, 2) print(re.sub(‘(\w+)( .* )(\w+)‘,r‘\3\2\1‘,‘alex make love‘))# 运行结果：love make alex
4.2 time模块
三种形式的时间：时间戳、结构化时间、格式化的字符串时间
各种时间之间的转换关系
import time print(time.time()) #时间戳， 运行结果：1502011120.8090527 print(time.strftime(‘%Y-%m-%d %X‘)) # 格式化字符串时间 运行结果：2017-08-06 17:18:40 print(time.localtime()) # 格式化时间运行结果：time.struct_time(tm_year=2017, tm_mon=8, tm_mday=6, tm_hour=17, tm_min=18, tm_sec=40, tm_wday=6, tm_yday=218, tm_isdst=0) print(time.gmtime()) #UTC 运行结果：time.struct_time(tm_year=2017, tm_mon=8, tm_mday=6, tm_hour=9, tm_min=18, tm_sec=40, tm_wday=6, tm_yday=218, tm_isdst=0) print(time.localtime().tm_mon) # 运行结果：8 print(time.localtime(123123123)) # 运行结果：time.struct_time(tm_year=1973, tm_mon=11, tm_mday=26, tm_hour=8, tm_min=52, tm_sec=3, tm_wday=0, tm_yday=330, tm_isdst=0) print(time.gmtime(123123123)) # 运行结果：time.struct_time(tm_year=1973, tm_mon=11, tm_mday=26, tm_hour=0, tm_min=52, tm_sec=3, tm_wday=0, tm_yday=330, tm_isdst=0) print(time.mktime(time.localtime())) # 运行结果：1502011120.0 print(time.strftime(‘%Y‘,time.gmtime())) # 运行结果：2017 print(time.strptime(‘2017-03-01‘,‘%Y-%m-%d‘)) # 运行结果：time.struct_time(tm_year=2017, tm_mon=3, tm_mday=1, tm_hour=0, tm_min=0, tm_sec=0, tm_wday=2, tm_yday=60, tm_isdst=-1) print(time.ctime(12312312)) # 运行结果：Sat May 23 20:05:12 1970 print(time.asctime(time.gmtime())) # 运行结果：Sun Aug 6 09:18:40 2017
4.3 random
import random print(random.random()) # (0,1)----float 大于0且小于1之间的小数 print(random.randint(1, 3)) # [1,3] 大于等于1且小于等于3之间的整数 print(random.randrange(1, 3)) # [1,3) 大于等于1且小于3之间的整数 print(random.choice([1, ‘23‘, [4, 5]])) # 1或者23或者[4,5] print(random.sample([1, ‘23‘, [4, 5]], 2)) # 列表元素任意2个组合 print(random.uniform(1, 3)) # 大于1小于3的小数，如1.927109612082716 item = [1, 3, 5, 7, 9] random.shuffle(item) # 打乱item的顺序,相当于"洗牌" print(item)
生成随机验证码
import random def make_code(n): res = "" for i in range(n): s1 = str(random.randint(0,9)) s2 = chr(random.randint(65,90)) res += random.choice([s1,s2]) return res print(make_code(10)) # 运行结果：92324635B3
4.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下为"\t\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的大小
示例：
import os print(os.listdir(‘.‘)) print(os.stat(‘m1.py‘).st_size) print(os.sep) print(os.linesep) print(os.pathsep) print([os.sep,os.linesep,os.pathsep]) res=os.system(‘dir .‘) # 运行结果：返回命令执行结果 print(os.path.dirname(r‘C:\a\b\c\d\a.txt‘)) # 运行结果：C:\a\b\c\d print(os.path.basename(r‘C:\a\b\c\d\a.txt‘))# 运行结果：a.txt print(os.path.split(r‘C:\a\b\c\d\a.txt‘)) # 运行结果：(‘C:\\a\\b\\c\\d‘, ‘a.txt‘) print(os.stat(‘m1.py‘).st_atime) # 运行结果：1502012851.6810527 print(os.stat(‘m1.py‘).st_size) # 运行结果：49 print(os.path.getsize(‘m1.py‘)) # 运行结果：49 print(os.path.join(‘C:\\‘,‘a‘,‘b‘,‘c‘,‘d.txt‘)) # 运行结果：C:\a\b\c\d.txt print(os.path.join(‘C:\\‘,‘a‘,‘b‘,‘D:\\‘,‘c‘,‘d.txt‘)) # 运行结果：D:\c\d.txt print(os.path.normcase(‘c:/wiNdows\\system32\\‘)) # 运行结果：c:\windows\system32\ print(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 print(os.path.dirname(os.path.dirname(os.path.abspath(__file__)))) # 运行结果：D:\python\code\Learning BASE_DIR=os.path.normpath(os.path.join( os.path.abspath(__file__), ‘..‘, ‘..‘ ) ) print(BASE_DIR) # 运行结果：D:\python\code\Learning
4.5 Sys模块
4.5.1 介绍
1 sys.argv 命令行参数List，第一个元素是程序本身路径
2 sys.exit(n) 退出程序，正常退出时exit(0)
3 sys.version 获取Python解释程序的版本信息
4 sys.maxint 最大的Int值
5 sys.path 返回模块的搜索路径，初始化时使用PYTHONPATH环境变量的值
6 sys.platform 返回操作系统平台名称
4.5.2 sys.stdout实现进度条
import sys,time for i in range(1,100): sys.stdout.write(‘\r%s‘ %(‘#‘*i)) sys.stdout.flush() time.sleep(0.5)
4.5.3 print实现进度条实现
import sys,time for i in range(1,100): print(‘\r%s‘ %(‘#‘*i),file=sys.stdout,flush=True,end=‘‘) time.sleep(0.05)
4.5.4进度条应用
知识储备
# 通过传入参数，指定滚动条的固定宽度 print(‘<%s>‘ %‘hello‘) print(‘<%-10s>‘ %‘hello‘) print(‘<%-10s>‘ %‘#‘) print(‘<%-10s>‘ %‘##‘) print(‘<%-10s>‘ %‘###‘) print(‘<%-10s>‘ %‘####‘) print(‘<%-10s>‘ %‘#####‘) width=20 print(‘<%%-%ds>‘ %width) #<%-10s> print((‘<%%-%ds>‘ %width) %(‘hello‘)) # <%-10s> %(‘hello‘) print((‘[%%-%ds]‘ %width) %(‘#‘)) print((‘[%%-%ds]‘ %width) %(‘##‘)) print((‘[%%-%ds]‘ %width) %(‘###‘))
import sys,time def progress(percent,width=50): if percent >= 100: percent=100 show_str=(‘[%%-%ds]‘ %width) %(int(width*percent/100)*‘#‘) print(‘\r%s %d%%‘ %(show_str,percent),file=sys.stdout,flush=True,end=‘‘) total_size=80251 recv_size=0 while recv_size < total_size: time.sleep(0.3) #模拟下载的网络延迟 recv_size+=1024 recv_per=int(100*recv_size/total_size) progress(recv_per,width=50)
4.6 序列化
为什么要序列化？
1.持久保存状态
2.跨平台数据交互
4.6.1 json
JSON不仅是标准格式，并且比XML更快，而且可以直接在Web页面中读取，非常方便。
JSON表示的对象就是标准的JavaScript语言的对象，JSON和Python内置的数据类型对应如下：
import json dic={‘name‘:‘egon‘,‘age‘:18} # 利用dumps序列化 print(type(json.dumps(dic))) with open(‘a.json‘,‘w‘) as f: f.write(json.dumps(dic)) # 利用loads反序列化 with open(‘a.json‘,‘r‘) as f: data=f.read() dic=json.loads(data) print(dic[‘name‘]) dic={‘name‘:‘egon‘,‘age‘:18} # 利用dump序列化 json.dump(dic,open(‘b.json‘,‘w‘)) # 利用load反序列化 print(json.load(open(‘b.json‘,‘r‘))[‘name‘])
4.6.2 pickle
Pickle的问题和所有其他编程语言特有的序列化问题一样，就是它只能用于Python，并且可能不同版本的Python彼此都不兼容，因此，只能用Pickle保存那些不重要的数据，不能成功地反序列化也没关系。
import pickle dic={‘name‘:‘egon‘,‘age‘:18} # dumps序列化 print(pickle.dumps(dic)) with open(‘d.pkl‘,‘wb‘) as f: f.write(pickle.dumps(dic)) # loads反序列化 with open(‘d.pkl‘,‘rb‘) as f: dic=pickle.loads(f.read()) print(dic[‘name‘]) dic={‘name‘:‘egon‘,‘age‘:18} # dump序列化 pickle.dump(dic,open(‘e.pkl‘,‘wb‘)) # load反序列化 print(pickle.load(open(‘e.pkl‘,‘rb‘))[‘name‘])
利用pickle进行序列化python的函数，然后进行反序列化
import pickle def func(): print(‘反序列化的文件‘) # 利用dump把函数进行序列化 pickle.dump(func,open(‘func.pkl‘,‘wb‘)) # 利用load把函数进行反序列化 f=pickle.load(open(‘func.pkl‘,‘rb‘)) print(f) f()
4.7 shelve模块
shelve模块比pickle模块简单，只有一个open函数，返回类似字典的对象，可读可写;key必须为字符串，而值可以是python所支持的数据类型
4.7.1 序列化
import shelve # 进行序列化 f=shelve.open(r‘sheve.shl‘) f[‘alex‘]={‘age‘:28,‘pwd‘:‘alex3714‘} f[‘egon‘]={‘age‘:18,‘pwd‘:‘3714‘} f.close()
4.7.2 反序列化
import shelve obj=shelve.open(r‘sheve.shl‘) print(obj[‘alex‘]) print(obj[‘egon‘]) for i in obj: print(i,obj[i]) obj.close()
python基础-匿名函数、内置函数、正则表达式、模块
声明：以上内容来自用户投稿及互联网公开渠道收集整理发布，本网站不拥有所有权，未作人工编辑处理，也不承担相关法律责任，若内容有误或涉及侵权可进行投诉： 投诉/举报 工作人员会在5个工作日内联系你，一经查实，本站将立刻删除涉嫌侵权内容。