内置函数、匿名函数、正则表达式、time模块、rangdom模块、os模块、序列化

内置函数
abs(-1)#绝对值
all([1,2,'a',None])#可迭代对象中每一个值都为真结果为真
any([''])#None,空，0，False 当都为假的时候为假，否则为真
bin()#10进制转化2进制
oct()#10进制8进制
hex()#10进制转16进制
bool()#判断值为false或true None,False,空串、字典、列表、元组、集合,0
bytes('hello',encoding='utf-8') = 'hello'.encode('utf-8') #unicode转为bytes
callable(bytes)#判断是否能被调用
chr(65)#A 数字对应的ascii码
ord('A')#65 字母对应的ascii码
compile()

eval(cmd,{全局},{局部})#
#cmd='print(x)'
#x=1 
#eval(cmd,{'x':0},{'x':10000}) //10000
#eval(cmd,{'x':0},{'y':10000})// 0
exec()
例子：
s = 'for i in range(10):print(i)'
code = compile(s,'','exec')#编译成exec可执行的
exec(code)
int()#整形
complex()#复数
float()#浮点
str()#字符串
list()#列表
tuple#元组
dict()#字典
set()#可变集合
frozenset()#不可变集合  s=set({1,2,3,4}) == s1 = frozenset({1,2,3,4})
dir(sys)#显示内置函数下的属性
divmod(10,3)#（3，1）求商与余数
enumerate()#l =['a','b','c'] 
es = enumerate(l)  for i in res:print(i) 显示索引与值
globals()#查看全局作用域的名字（字典） 
locals()#查看局部作用域
help(函数名)#查看函数的注释
id()#id号，变量在内存中的位置
isinstance(x,int)#判断x是不是整形的实例
max()#求最大值，序列值为同类型
min()#最小值
pow(x,y,z)#x的y平方，取模2
range()#
repr()#与str相似，转化为字符串
reversed([1，'a',2,'c'])#反转产生新的序列 结果为迭代器 
round(3.567,2)#4舍5入 保留第二个参数两位小数
slice(起始位置,结束位置,步长)#截取函数
sorted(l)#排序
sorted(l,reverse = True)#倒叙
sum([1,2,3])#求和 sum(i for i in range(10)) 生成器表达式
vars()#没有参数相当于locals() 有参数相当于__dict__
zip()#拉链s = 'hello' l = [1,2,3,4,5] print(list(zip(s,l))) [('h',1),('e',2),('l',3),('l',4),('o',5)]
__import__('sys')#将字符串转化为可引用的函数名
#inp = input('》》》')
#sys = __import__(inp)
#print(sys.path)

匿名函数

利用匿名函数求最大工资
salariy ={'alex':10000000,
          'egon':3000,
          'yuanhao':2000,
          'wupeiqi':10000
          }
#方法一
 print(list(zip(salariy.values(),salariy.keys())))
 print(max(zip(salariy.values(),salariy.keys()))[1])

 print(max(salariy,key = lambda name:salariy[name]))
 #max分部拿取salariy的key，key= 比较依据
 #按薪资排序人名
 print(sorted(salariy,key=lambda name:salariy[name]))
 print(sorted(salariy,key=lambda name:salariy[name],reverse = True))

--map映射
 names = ['alex','wupeiqi','yuanhao','yanglei','egon']
 res = map(lambda x:x+'_sb',names)
 res = map(lambda x:x if x=='egon' else  x+'_sb',names)
 print(list(res))

--reduce合并
from functools import reduce
#没有第三个参数的时候，会把第一个range()的值作为初始值
 print(reduce(lambda x,y:x+y,range(101),100))

--filter过滤
 names = ['alex_SB','wupeiqi_SB','yuanhao','yanglei','egon']
 print(list(filter(lambda x:x.endswith('_SB'),names)))

正则表达式

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 
 	')) #匹配空
>[' ', ' ', ' ', ' ', '
', ' ', '	']

print(re.findall('S','hello_ | egon 123 
 	'))#匹配非空
>['h', 'e', 'l', 'l', 'o', '_', '|', 'e', 'g', 'o', 'n', '1', '2', '3']

print(re.findall('d','hello_ | egon 123 
 	'))#匹配数字
>['1', '2', '3']

print(re.findall('D','hello_ | egon 123 
 	'))#匹配非数字
>['h', 'e', 'l', 'l', 'o', '_', ' ', '|', ' ', 'e', 'g', 'o', 'n', ' ', ' ', '
', ' ', '	']

print(re.findall('h','hello_ | egon 123 
 	'))#匹配h
>['h']

print(re.findall('^he','hello_ | egon 123 
 	'))#he开头
>['he']

print(re.findall('123$','hello_ | egon 123 
 	 123'))#123结尾
>['123']


print(re.findall('a.c','a aaccacc a1c aaac'))
>['aac', 'acc', 'a1c', 'aac']
# []内部可以有多个字符，但本身只配多个字符的一个
print(re.findall('a[a-zA-Z]c','a a12cc a1c a*c a2c aac a
c',re.S))
>['aac']
print(re.findall('a[.]c','a a12cc a1c a*c a2c aac a
c',re.DOTALL))#re.S 可以匹配/n
['a1c', 'a*c', 'a2c', 'aac', 'a
c']

print(re.findall('a[^a-zA-Z]c','a a12cc a1c a*c a2c aac a
c',re.S))#匹配a非a-zA-Z c
>['a1c', 'a*c', 'a2c', 'a
c']


#re.I(re.IGNORECASE): 忽略大小写（括号内是完整写法，下同）
#M(MULTILINE): 多行模式，改变'^'和'$'的行为（参见上图）
#S(DOTALL): 点任意匹配模式，改变'.'的行为
#L(LOCALE): 使预定字符类 w W  B s S 取决于当前区域设定
#U(UNICODE): 使预定字符类 w W  B s S d D 取决于unicode定义的字符属性
#X(VERBOSE): 详细模式。这个模式下正则表达式可以是多行，忽略空白字符，并可以加入注释。以下两个正则表达式是等价的：

print(re.findall(r'a\c','a a12cc ac a*c a2c  a
c'))#r原生

#？左边那一个字符有0个或1个
print(re.findall('ab?','aab a ab aaaa'))
>['a', 'ab', 'a', 'ab', 'a', 'a', 'a', 'a']
print(re.findall('ab{0,1}','aab a ab aaaa'))
>['a', 'ab', 'a', 'ab', 'a', 'a', 'a', 'a']
#* 左边哪一个字符有0个或无穷个
print(re.findall('ab*','aab a ab aaaa abbbbbabb'))
>['a', 'ab', 'a', 'ab', 'a', 'a', 'a', 'a', 'abbbbb', 'abb']
print(re.findall('ab{0,}','aab a ab aaaa abbbbbabb'))
>['a', 'ab', 'a', 'ab', 'a', 'a', 'a', 'a', 'abbbbb', 'abb']
#+ 左边哪一个字符有1个或无穷个
print(re.findall('ab+','aab a ab aaaa abbbbbabb'))
>['ab', 'ab', 'abbbbb', 'abb']
print(re.findall('ab{1,}','aab a ab aaaa abbbbbabb'))
>['ab', 'ab', 'abbbbb', 'abb']
#{}左边的字符有n-m次
print(re.findall('ab{3}','aab a ab aaaa abbbbbabb'))
>['abbb']

#.* 贪婪匹配
print(re.findall('a.*c','a123c456c'))
>['a123c456c']
#.*?非贪婪匹配
print(re.findall('a.*?c','a123c456c'))
>['a123c']
print(re.findall('company|companies','Too many companies hava gone bankrupt,and the next one is my company'))
>['companies', 'company']
print(re.findall('compan(?:y|ies)','Too many companies hava gone bankrupt,and the next one is my company'))
>['companies', 'company']

正则表达式分组

#():分组
print(re.findall('ab+','abababab123'))#匹配a*n个b
>['ab', 'ab', 'ab', 'ab']
print(re.findall('ab+123','abababab123'))#匹配a*n个b*123
>['ab123']
print(re.findall('ab','abababab123'))#匹配ab
>['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'))
>['ab', 'ab', 'ab', 'ab']

time模块

time.time()#1970年到现在的时间戳
>1502378474.6239138
time.strftime('%Y-%m-%d %X')#格式化时间
>2017-08-10 23:21:14
time.localtime()#结构化时间(可加时间戳)
>time.struct_time(tm_year=2017, tm_mon=8, tm_mday=10, tm_hour=23, tm_min=21, tm_sec=14, tm_wday=3, tm_yday=222, tm_isdst=0)
time.mktime(time.localtime())#结构化时间转为时间戳
>1502378474.0
time.strftime('%Y',time.localtime())#结构化转为格式化
>2017
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)
time.ctime()#格式为：Sat Aug 5 8:29:23 2017 可将时间戳转为前面的格式
>Thu Aug 10 23:21:14 2017

random模块

random.random()#0-1之间的小数
random.randint(1,3)#1到等于3之间的整数
random.randrange(1,3)#1到小于3之间的整数
random.choice([1,'23'])#任意去一个元素
random.sample([1,'23',[4,5]],2)#任意取第三个参数个值
random.uniform(1,3)#大于1小于3的小数
random.shuffle([1,2,3])#打乱顺序

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下为"	
",Linux下为"
"
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的大小

shutil模块

将文件内容拷贝到另一个文件中
shutil.copyfileobj(fsrc, fdst[, length])
例：

import shutil 
shutil.copyfileobj(open('old.xml','r'), open('new.xml', 'w'))

shutil.copyfile(src, dst)
拷贝文件

shutil.copyfile('f1.log', 'f2.log') #目标文件无需存在

shutil.copymode(src, dst)
仅拷贝权限。内容、组、用户均不变

shutil.copymode('f1.log', 'f2.log') #目标文件必须存在

shutil.copystat(src, dst)
仅拷贝状态的信息，包括：mode bits, atime, mtime, flags

shutil.copystat('f1.log', 'f2.log') #目标文件必须存在

shutil.copy(src, dst)
拷贝文件和权限

 import shutil
 shutil.copy('f1.log', 'f2.log')

shutil.copy2(src, dst)
拷贝文件和状态信息

import shutil
 shutil.copy2('f1.log', 'f2.log')

shutil.ignore_patterns(*patterns)
shutil.copytree(src, dst, symlinks=False, ignore=None)
递归的去拷贝文件夹

 import shutil
 shutil.copytree('folder1', 'folder2', ignore=shutil.ignore_patterns('*.pyc', 'tmp*')) #目标目录不能存在，注意对folder2目录父级目录要有可写权限，ignore的意思是排除 

shutil.rmtree(path[, ignore_errors[, onerror]])
递归的去删除文件

 import shutil
 shutil.rmtree('folder1')

shutil.move(src, dst)
递归的去移动文件，它类似mv命令，其实就是重命名。

 import shutil
shutil.move('folder1', 'folder3')

序列化

--序列化
我们把对象（变量）从内存中变成可存储或传输的过程称为序列化
序列化的作用：１、持久保存状态　２、跨平台数据交互
json：如果我们要在不同编程语言之间传递对象，就必须把对象序列化为标准格式，比如xml
但更好的方法是转化为json，因为json标识出来就是一个字符串，可以被所有语言读取。

import json
dic = {'name':'egon','age':18}
print(type(json.dumps(dic)))#将字典转化为json形式的字符串

--存

with open('a.json','w') as f :
    f.write(json.dumps(dic))

--读

with open('a.json','r') as f:
    data = json.loads(f.read())

--dump直接打开文件存入

dic = {'name':'egon','age':18}
    json.dump(dic,open('b.json','w'))

--load 直接打开文件读取

a = json.load(open('b.json','r'))
print(a['name'])

注意：
import json
#dct="{'1':111}"#json 不认单引号
#dct=str({"1":111})#报错,因为生成的数据还是单引号:{'one': 1}

dct='{"1":"111"}'
print(json.loads(dct))

#conclusion:
# 无论数据是怎样创建的，只要满足json格式，就可以json.loads出来,不一定非要dumps的数据才能loads

--pickle Pickle的问题和所有其他编程语言特有的序列化问题一样，就是它只能用于Python，并且可能不同版本的Python彼此都不兼容，因此，只能用Pickle保存那些不重要的数据，不能成功地反序列化也没关系。