<--目录-->
1、getpass
2、os
3、sys
4、subprocess
5、hashlib
6、json
7、pickle
8、shutil
9、time
10、datetime
11、re
12、random
13、configparser
14、traceback
15、yaml
16、itertools
17、logging
1、getpass模块详解
pwd = getpass.getpass("请输入密码:") #输入密码不可见
yh= getpass.getuser() #显示当前登录系统用户名;
2、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#输出用于分割文件路径的字符串
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所指向的文件或者目录的最后修改时间
View Code
#获取当前文件(或文件夹)所在的路径
CUR_PATH = os.path.dirname(__file__)#路径拼接:拼接文件的’绝对路径‘
TEST_PATH = os.path.join(CUR_PATH,'test.txt')#判断文件或文件夹是否存在
res =os.path.exists(TEST_PATH)#判断文件夹是否存在
res =os.path.isdir(TEST_PATH})#创建文件夹
os.mkdir(DIR_PATH)#删除文件夹
os.rmdir(DIR_PATH)#删除文件
os.remove(file_name)#获取指定文件夹下面的所有文件夹名和文件名
os.listdir(DIR_PATH)
3、sys模块(与python解释器交互)
sys.argv #命令行参数List,第一个元素是程序本身路径
sys.exit(n)#退出程序,正常退出时exit(0)
sys.version#获取Python解释程序的版本信息
sys.maxint#最大的Int值
sys.path#返回模块的搜索路径,初始化时使用PYTHONPATH环境变量的值
sys.platform#返回操作系统平台名称
sys.stdout.write('please:')
val= sys.stdin.readline()[:-1]#获取当前的python解释器的环境变量
sys.path#将当前项目添加到环境变量中
BASE_PATH = os.path.dirname(os.path.dirname(__file__))
sys.path.append(BASE_PATH)#获取cmd终端命令,以空格分割,返回列表
print(sys.argv)
View Code
4、subprocess模块 执行系统命令
os.system
commands.* --废弃,3.x中被移除
result= commands.getoutput('cmd')
以上执行shell命令的相关的模块和函数的功能均在 subprocess 模块中实现,并提供了更丰富的功能。
call
执行命令,返回状态码
ret= subprocess.call(["ls", "-l"], shell=False)
ret= subprocess.call("ls -l", shell=True)
shell=True ,允许 shell 命令是字符串形式
check_call
执行命令,如果执行状态码是 0 ,则返回0,否则抛异常
subprocess.check_call(["ls", "-l"])
subprocess.check_call("exit 1", shell=True)
check_output(此下两条命令在2.6执行失败,要是2.7应该才可以)
执行命令,如果状态码是 0 ,则返回执行结果,否则抛异常
subprocess.check_output(["echo", "Hello World!"])
subprocess.check_output("exit 1", shell=True)
subprocess.Popen(...)
用于执行复杂的系统命令
参数:
args:#shell命令,可以是字符串或者序列类型(如:list,元组)
bufsize:#指定缓冲。0 无缓冲,1 行缓冲,其他 缓冲区大小,负值 系统缓冲
stdin, stdout, stderr:#分别表示程序的标准输入、输出、错误句柄
preexec_fn:#只在Unix平台下有效,用于指定一个可执行对象(callable object),它将在子进程运行之前被调用
close_sfs:#在windows平台下,如果close_fds被设置为True,则新创建的子进程将不会继承父进程的输入、输出、错误管道。所以不能将close_fds设置为True同时重定向子进程的标准输入、输出与错误(stdin, stdout, stderr)。
shell:#同上
cwd:#用于设置子进程的当前目录
env:#用于指定子进程的环境变量。如果env = None,子进程的环境变量将从父进程中继承。
universal_newlines:#不同系统的换行符不同,True -> 同意使用 \n
startupinfo与createionflags#只在windows下有效
将被传递给底层的CreateProcess()函数,用于设置子进程的一些属性,如:主窗口的外观,进程的优先级等等importsubprocess
ret1= subprocess.Popen(["mkdir","t1"])
ret2= subprocess.Popen("mkdir t2", shell=True)
View Code
5、hashlib模块
用于加密相关的操作,代替了md5模块和sha模块,主要提供 SHA1, SHA224, SHA256, SHA384, SHA512 ,MD5 算法
importhashlib######### md5 ########
hash =hashlib.md5()
hash.update('admin')printhash.hexdigest()######### sha1 ########
hash =hashlib.sha1()
hash.update('admin')printhash.hexdigest()######### sha256 ########
hash=hashlib.sha256()
hash.update('admin')printhash.hexdigest()######### sha384 ########
hash=hashlib.sha384()
hash.update('admin')printhash.hexdigest()######### sha512 ########
hash=hashlib.sha512()
hash.update('admin')printhash.hexdigest()
以上加密算法虽然依然非常厉害,但时候存在缺陷,即:通过撞库可以反解。所以,有必要对加密算法中添加自定义key再来做加密。importhashlib######### md5 ########
hash= hashlib.md5('898oaFs09f')
hash.update('admin')printhash.hexdigest()
还不够吊?python 还有一个 hmac 模块,它内部对我们创建 key 和 内容 再进行处理然后再加密importhmac
h= hmac.new('wueiqi')
h.update('hellowo')print h.hexdigest()
View Code
importhashlibdefpwd_md5(pwd):
md5_obj=hashlib.md5()
md5_obj.update(pwd.encode('utf-8'))
var= '宝塔镇河妖'md5_obj.update(val.encode('utf-8'))
pwd=md5_obj.hexdigest()return pwd
6,7、json 和 pickle
用于序列化的两个模块
用于序列化的两个模块
json,用于字符串 和 python数据类型间进行转换
pickle,用于python特有的类型 和 python的数据类型间进行转换
Json模块提供了四个功能:dumps、dump、loads、load
pickle模块提供了四个功能:dumps、dump、loads、load
pickle>>> importpickle>>> data = {'k1' : 123, 'k2' : 'hello'}>>> p_str = pickle.dumps(data) #序列化
>>> printp_str>>> loadsed = pickle.loads(p_str) #反序列化
>>> printloadsed
序列化到文件>>> li = ['wsyht',11,22,'ok','yes']>>> pickle.dump(li,open('test.txt','w')) #序列化到文件
>>> pickle.load(open('test.txt')) #从文件反序列化出来
json>>> importjson>>> data = {'k1':123,'k2':'abc'}>>> str =json.dumps(data)>>> stt=json.loads(str)
序列化到文件>>> li = ['wsyht',11,22,'ok','yes']>>> json.dump(li,open('test.txt','w')) #序列化到文件
>>> json.load(open('test.txt')) #从文件反序化出来
View Code
8、shutil模块
shutil.make_archive(base_name, format,...)
创建压缩包并返回文件路径,例如:zip、tar
base_name: 压缩包的文件名,也可以是压缩包的路径。只是文件名时,则保存至当前目录,否则保存至指定路径,
如:www=>保存至当前路径
如:/Users/wupeiqi/www =>保存至/Users/wupeiqi/format: 压缩包种类,“zip”, “tar”, “bztar”,“gztar”
root_dir: 要压缩的文件夹路径(默认当前目录)
owner: 用户,默认当前用户
group: 组,默认当前组
logger: 用于记录日志,通常是logging.Logger对象#将 /Users/wupeiqi/Downloads/test 下的文件打包放置当前程序目录
importshutil
ret= shutil.make_archive("wwwwwwwwww", 'gztar', root_dir='/Users/wupeiqi/Downloads/test')#将 /mnt下的文件打包放置 /tmp目录
importshutil
ret= shutil.make_archive("/tmp/www", 'gztar', root_dir='/mnt') #2.6用不了,2.7或许可以
类似于高级API,而且主要强大之处在于其对文件的复制与删除操作更是比较支持好。
相关API介绍
copyfile(src, dst)
从源src复制到dst中去。当然前提是目标地址是具备可写权限。抛出的异常信息为
IOException. 如果当前的dst已存在的话就会被覆盖掉。
copyfile( src, dst) 从源src复制到dst中去。当然前提是目标地址是具备可写权限。抛出的异常信息为IOException. 如果当前的dst已存在的话就会被覆盖掉
copymode( src, dst) 只是会复制其权限其他的东西是不会被复制的
copystat( src, dst) 复制权限、最后访问时间、最后修改时间
copy( src, dst) 复制一个文件到一个文件或一个目录
copy2( src, dst) 在copy上的基础上再复制文件最后访问时间与修改时间也复制过来了,类似于cp –p的东西
copy2( src, dst) 如果两个位置的文件系统是一样的话相当于是rename操作,只是改名;如果是不在相同的文件系统的话就是做move操作
copytree(olddir,newdir,True/Flase) 把olddir拷贝一份newdir,如果第3个参数是True,则复制目录时将保持文件夹下的符号连接,如果第3个参数是False,则将在复制的目录下生成物理副本来替代符号连接
shutil.rmtree("te") 删除一个目录importshutil
shutil.copyfile('f:/temp.txt', 'f:/os.txt') #复制文件
shutil.copytree('f:/temp', 'f:/os') #复制目录
######### zip的用法 ########
shutil 对压缩包的处理是调用 ZipFile 和 TarFile 两个模块来进行的,详细:importzipfile#压缩
z= zipfile.ZipFile('laxi.zip', 'w')
z.write('a.log') #压缩包写入a.log
z.write('data.data') #写入data文件
z.close()#解压
z= zipfile.ZipFile('laxi.zip', 'r')
z.extractall()
z.close()
View Code
9、time模块
python中的三种时间表示形式
1、时间戳
- 自1970-01-01 00:00:00到当前时间,单位为秒
2、格式化时间
- 返回的是时间的字符串
3、格式化时间对象(struct_time)
- 9个值分别代表:年、月、日、时、分、秒、一周中第几天、一年中的第几天、夏令时
#1、获取时间戳
now_time =time.time()#==>1573885266.3314579#2、获取格式化时间
now_time = time.strftime('%Y-%m-%d %H:%M:%S')==>2019-11-16 14:21:06
#3、获取时间对象
time_obj =time.localtime()print(time_obj.tm_year)print(time_obj.tm_mon)print(time_obj.tm_mday)print(time_obj.tm_hour)print(time_obj.tm_min)print(time_obj.tm_sec)#4、时间对象-->字符串格式化时间
time_str=time.strftime('%Y-%m-%d %H:%M:%S',time_obj)#5、字符串格式化的时间-->时间对象
time_boj = time.strptime('2019-01-01','%Y-%m-%d')
View Code
三种表示主式:1、时间戳 1970年1月1日后的秒2、元组包含了:年、日、星期等...time.struct_time3、格式化的字符串 2014-11-11 11:11 printtime.time()#时间戳形式存在
printtime.time()print time.mktime(time.localtime()) #print (time.localtime())此为元组形式,这一整句意思是把元组形式转化成时间戳形式
#元组形式存在
print time.gmtime() #可加时间戳参数
print time.localtime() #可加时间戳参数
print time.strptime('2014-11-11','%Y-%m-%d') #字符串形式转换成元组形式
#字符串形式存在
print time.strftime('%Y-%m-%d') #默认当前时间,必须记住,工作中用得最多
print time.strftime('%Y-%m-%d',time.localtime()) #默认当前时间
printtime.asctime()printtime.asctime(time.localtime())printtime.ctime(time.time())
时间的三种表示方式演示>>> importtime>>> printtime.time()1469014348.5 #秒,时间戳的方式
>>> printtime.gmtime()
time.struct_time(tm_year=2016, tm_mon=7, tm_mday=20, tm_hour=11, tm_min=25, tm_sec=53, tm_wday=2, tm_yday=202, tm_isdst=0)>>> print time.strftime('%Y-%m-%d %H:%M:%S')2016-07-20 19:36:16
View Code
10、datetime模块
importdatetime'''datetime.date:表示日期的类。常用的属性有year, month, day
datetime.time:表示时间的类。常用的属性有hour, minute, second, microsecond
datetime.datetime:表示日期时间
datetime.timedelta:表示时间间隔,即两个时间点之间的长度
timedelta([days[, seconds[, microseconds[, milliseconds[, minutes[, hours[, weeks]]]]]]])
strftime("%Y-%m-%d")'''
importdatetimeprintdatetime.datetime.now()print datetime.datetime.now() - datetime.timedelta(days=5)
View Code
#1、获取当前年月日
print(datetime.date.today())#==>2020-04-08#2、获取当前年月日时分秒
print(datetime.datetime.today())print(datetime.datetime.now())print(datetime.datetime.utcnow()) #格林尼治时间#==>2020-04-08 14:54:34.496536#==>2020-04-08 14:54:34.496536#==>2020-04-08 06:54:34.496536
View Code
#日期/时间的计算#日期时间 = 日期时间 + - 时间对象
current_time =datetime.datetime.now()
time_obj= date.timedelta(days=7)
later_time= current_time +time_obj#时间对象 = 日期时间 + - 日期时间
current_time =datetime.datetime.now()
later_time=datetime.datetime.utcnow()
time_obj= later_time - current_time
View Code
11、re模块
compile
match search findall
group groups
正则表达式常用格式:
字符:\d \w \t .
次数:* +? {m} {m,n}
示例:#!#/usr/bin/env python
#coding:utf-8
importre
result1= re.match('\d+', '1afsfweasfcxvsfd123') #在你给的字符串起始位置去匹配,\d从数字开始找,+表示一个到多个
if result1: #当result1等于True的时候,就是匹配,如果匹配就输出里面的内容
print result1.group() #用group方法把他匹配的内容输出出来
else:print 'nothing'result2= re.search('\d+', 'alsfj3af') #在整个内容里面去匹配,\d从数字开始找,+表示一个到多个
ifresult2:print result2.group() #用group方法把他匹配的内容输出出来
result3= re.findall('\d+', 'asfaf11sf22lj33') #只要匹配全都拿出来
printresult3
com= re.compile('\d+')print com.findall('asfaf11sf22lj33')
result5= re.search('(\d+)\w*(\d+)','aasflsjfa12aaljsf22lj13bb')print result5.group() #所有匹配内容输出
print result5.groups() #只把括号\d,也就是组里面的内容输出
result6= re.search('a{3,5}','aaaaaa') #匹配3到5次的aaaaa输出出来
print result6.group()
View Code
总结:
match:只在第一个字符串开始找,如果没有匹配,则不再继续找,如果第一个字符串中有,则只输出第一个
searh: 在所有内容里找,直到找到为止,但只输出找到的第一个
findall:把所有找到的匹配的内容,都通过列表的形式打印出来
compile: 编译之后再去匹配,这样可以加快匹配的速度
group: 把他匹配的内容输出出来
groups:分组
匹配的字符:
\d:表示数字的意思
\w: 代表下划线,字母,数字
\t:制表符,除了回车以外的所有字符
匹配的次数:*大于等于0,0到多个+大于等于1,1个到多个
? 0或1
{m} 次数,如a{6},出现6次a的进行匹配
{m,n} 如a{3,7} 出现3到7次的就进行匹配
例子1:
法1>>> ip = '12.23.84.dsfa.23s.3234~lsjfw+23sfaf192.168.32.43_w342d~@#9436'
>>> importre>>> re.findall('[0-9]{1,3}',ip)
['12', '23', '84', '23', '323', '4', '23', '192', '168', '32', '43', '342', '943', '6']>>> re.findall('[0-9]{1,3}\.[0-9]{1,3}',ip)
['12.23', '192.168', '32.43']>>> re.findall('[0-9]{1,3}\.[0-9]{1,3}\.[0-9]{1,3}',ip)
['12.23.84', '192.168.32']>>> re.findall('[0-9]{1,3}\.[0-9]{1,3}\.[0-9]{1,3}\.[0-9]{1,3}',ip)
['192.168.32.43']
法2:>>> re.findall('(\d+)',ip)
['12', '23', '84', '23', '3234', '23', '192', '168', '32', '43', '342', '9436']>>> re.findall('(\.+\d+){1,3}',ip)
['.84', '.23', '.3234', '.43']>>> re.findall('(?:\.+\d+){1,3}',ip) #?:表示匹配括号的那一组数据,必须连着
['.23.84', '.23', '.3234', '.168.32.43']>>> re.findall('[0-9]{1,3}(?:\.+\d+){3}',ip)
['192.168.32.43']
法3:>>> re.findall('(?:\d+\.+){3}\d{1,3}',ip)
['192.168.32.43']
法4:>>> re.findall('(?:\d{1,3}\.){3}\d{1,3}',ip)
['192.168.32.43']
View Code
12、random模块
importrandom#随机从1-9中返回一个整数
res = random.int(1,9)#返回0-1之间的浮点数
res =random.random()#shuffle(洗牌)有索引的可变可迭代对象
my_list = [1, 2, 3, 3, 7]
random.shuffle(my_list)print(my_list)#choice(随机选择)有索引的可迭代对象
my_str = 'yyh NO.1'random.choice(my_str)
View Code
importrandomprintrandom.random()print random.randint(1,2)print random.randrange(1,10)#随机验证码实例:
importrandom
checkcode= ''
for i in range(4):
current= random.randrange(0,4)if current !=i:
temp= chr(random.randint(65,90))else:
temp= random.randint(0,9)
checkcode+=str(temp)printcheckcode
View Code
#例题:生成随机验证码
defrandom_code(n):
char_range= [chr(i) for i in range(65, 91)] +\
[chr(i)for i in range(97, 123)] +\
[str(i)for i in range(10)]
result= ''
for i inrange(n):
result+=random.choice(char_range)returnresultprint(random_code(6))
View Code
13、ConfigParser模块
用于对特定的配置进行操作,当前模块的名称在 python 3.x 版本中变更为 configparser。1.读取配置文件-read(filename) 直接读取ini文件内容-sections() 得到所有的section,并以列表的形式返回-options(section) 得到该section的所有option-items(section) 得到该section的所有键值对-get(section,option) 得到section中option的值,返回为string类型-getint(section,option) 得到section中option的值,返回为int类型2.写入配置文件-add_section(section) 添加一个新的section-set( section, option, value) 对section中的option进行设置
需要调用write将内容写入配置文件。
[root@test1 mnt]#cat data.txt
[sec_a]
a_key1= 20a_key2= 10[sec_b]
b_key1= 121b_key2=b_value2
b_key3=$r
b_key4= 127.0.0.1
>>> importConfigParser>>> cf =ConfigParser.ConfigParser()>>> cf.read("data.txt")
['data.txt']>>> secs = cf.sections() #获得所有区域
>>> print 'sections:', secs
sections: ['sec_b', 'sec_a']>>> opts = cf.options("sec_a")>>> print 'options:', opts
options: ['a_key1', 'a_key2']>>>
>>> for sn insecs:
...print cf.options(sn) #打印出每个区域的所有属性
...
['b_key4', 'b_key1', 'b_key2', 'b_key3']
['a_key1', 'a_key2']>>> str_val = cf.get("sec_a", "a_key1")>>> int_val = cf.getint("sec_a", "a_key2")>>> print "value for sec_a's a_key1:", str_val
valuefor sec_a's a_key1: 20
>>> print "value for sec_a's a_key2:", int_val
valuefor sec_a's a_key2: 10
>>> cf.set("sec_b", "b_key3", "new-$r")>>> cf.set("sec_b", "b_newkey", "new-value")>>> cf.add_section('a_new_section')>>> cf.set('a_new_section', 'new_key', 'new_value')>>> cf.write(open("data.txt", "w"))>>> cf.has_section('a_new_section') #判断存不存在[sec_a]
True>>> cf.remove_section('sec_a') #删除[sec_a]
True>>> cf.has_section('a_section') #判断存不存在[sec_a]
False>>> cf.write(open("data.txt", "w"))
View Code
14、traceback模块
[root@test1 mnt]#cat test.py
#!/usr/bin/env python
#coding:utf-8
importtracebacktry:1/0exceptException,e:#print e
traceback.print_exc(file=open('tb.txt','w+'))else:print 'success'
View Code
15、yaml模块的使用
yaml在python上的具体实现:PyYaml
将yaml写成配置脚本test.yaml ,以下介绍如何读写yaml配置。
使用python的yaml库PyYAML。http://pyyaml.org/安装到python lib下后就可以正常使用了。#加载yaml
importyaml
f= open('test.yaml') #读取文件
x= yaml.load(f) #导入
printx
f.close()importyaml
f= open('d:/newtree.yaml', "w")
yaml.dump(dataMap, f)
f.close()
View Code
16、itertools模块的使用
[root@test1 mnt]#cat test.py
######### count(1) ########
importitertools
natuals= itertools.count(1) #count创建无限个迭代器
for n innatuals:printn######### cycle() ########
cycle()会把传入的一个序列无限重复下去:>>> importitertools>>> cs = itertools.cycle('ABC') #注意字符串也是序列的一种
>>> for c incs:
...printc######### repeat() ########
repeat()负责把一个元素无限重复下去,不过如果提供第二个参数就可以限定重复次数:>>> ns = itertools.repeat('A', 10)>>> for n inns:
...printn
...
打印10次'A'
######### takewhile() ########
>>> natuals = itertools.count(1)>>> ns = itertools.takewhile(lambda x: x <= 10, natuals)>>> for n inns:
...printn
...
打印出1到10######### chain() ########
for c in itertools.chain('ABC', 'XYZ'):printc#迭代效果:'A' 'B' 'C' 'X' 'Y' 'Z'
######### groupby() ########
groupby()把迭代器中相邻的重复元素挑出来放在一起:>>> for key, group in itertools.groupby('AAABBBCCAAA'):
...print key, list(group) #为什么这里要用list()函数呢?
...
A ['A', 'A', 'A']
B ['B', 'B', 'B']
C ['C', 'C']
A ['A', 'A', 'A']######### groupby() ########
实际上挑选规则是通过函数完成的,只要作用于函数的两个元素返回的值相等,这两个元素就被认为是在一组的,而函数返回值作为组的key。如果我们要忽略大小写分组,就可以让元素'A'和'a'都返回相同的key:>>> for key, group in itertools.groupby('AaaBBbcCAAa', lambdac: c.upper()):
...printkey, list(group)
...
A ['A', 'a', 'a']
B ['B', 'B', 'b']
C ['c', 'C']
A ['A', 'A', 'a']######### imap() ########
>>> for x in itertools.imap(lambda x, y: x * y, [10, 20, 30], itertools.count(1)):
...printx
itertools
阅读:5044Python的内建模块itertools提供了非常有用的用于操作迭代对象的函数。
首先,我们看看itertools提供的几个“无限”迭代器:>>> importitertools>>> natuals = itertools.count(1)>>> for n innatuals:
...printn
...1
2
3...
因为count()会创建一个无限的迭代器,所以上述代码会打印出自然数序列,根本停不下来,只能按Ctrl+C退出。
cycle()会把传入的一个序列无限重复下去:>>> importitertools>>> cs = itertools.cycle('ABC') #注意字符串也是序列的一种
>>> for c incs:
...printc
...'A'
'B'
'C'
'A'
'B'
'C'...
同样停不下来。
repeat()负责把一个元素无限重复下去,不过如果提供第二个参数就可以限定重复次数:>>> ns = itertools.repeat('A', 10)>>> for n inns:
...printn
...
打印10次'A'无限序列只有在for迭代时才会无限地迭代下去,如果只是创建了一个迭代对象,它不会事先把无限个元素生成出来,事实上也不可能在内存中创建无限多个元素。
无限序列虽然可以无限迭代下去,但是通常我们会通过takewhile()等函数根据条件判断来截取出一个有限的序列:>>> natuals = itertools.count(1)>>> ns = itertools.takewhile(lambda x: x <= 10, natuals)>>> for n inns:
...printn
...
打印出1到10
itertools提供的几个迭代器操作函数更加有用:
chain()
chain()可以把一组迭代对象串联起来,形成一个更大的迭代器:for c in itertools.chain('ABC', 'XYZ'):printc#迭代效果:'A' 'B' 'C' 'X' 'Y' 'Z'
groupby()
groupby()把迭代器中相邻的重复元素挑出来放在一起:>>> for key, group in itertools.groupby('AAABBBCCAAA'):
...print key, list(group) #为什么这里要用list()函数呢?
...
A ['A', 'A', 'A']
B ['B', 'B', 'B']
C ['C', 'C']
A ['A', 'A', 'A']
实际上挑选规则是通过函数完成的,只要作用于函数的两个元素返回的值相等,这两个元素就被认为是在一组的,而函数返回值作为组的key。如果我们要忽略大小写分组,就可以让元素'A'和'a'都返回相同的key:>>> for key, group in itertools.groupby('AaaBBbcCAAa', lambdac: c.upper()):
...printkey, list(group)
...
A ['A', 'a', 'a']
B ['B', 'B', 'b']
C ['c', 'C']
A ['A', 'A', 'a']
imap()
imap()和map()的区别在于,imap()可以作用于无穷序列,并且,如果两个序列的长度不一致,以短的那个为准。>>> for x in itertools.imap(lambda x, y: x * y, [10, 20, 30], itertools.count(1)):
...printx
注意imap()返回一个迭代对象,而map()返回list。当你调用map()时,已经计算完毕:>>> r = map(lambda x: x*x, [1, 2, 3])>>> r #r已经计算出来了
[1, 4, 9]
当你调用imap()时,并没有进行任何计算:>>> r = itertools.imap(lambda x: x*x, [1, 2, 3])>>>r
#r只是一个迭代对象
itertools
阅读:5044Python的内建模块itertools提供了非常有用的用于操作迭代对象的函数。
首先,我们看看itertools提供的几个“无限”迭代器:>>> importitertools>>> natuals = itertools.count(1)>>> for n innatuals:
...printn
...1
2
3...
因为count()会创建一个无限的迭代器,所以上述代码会打印出自然数序列,根本停不下来,只能按Ctrl+C退出。
cycle()会把传入的一个序列无限重复下去:>>> importitertools>>> cs = itertools.cycle('ABC') #注意字符串也是序列的一种
>>> for c incs:
...printc
...'A'
'B'
'C'
'A'
'B'
'C'...
同样停不下来。
repeat()负责把一个元素无限重复下去,不过如果提供第二个参数就可以限定重复次数:>>> ns = itertools.repeat('A', 10)>>> for n inns:
...printn
...
打印10次'A'无限序列只有在for迭代时才会无限地迭代下去,如果只是创建了一个迭代对象,它不会事先把无限个元素生成出来,事实上也不可能在内存中创建无限多个元素。
无限序列虽然可以无限迭代下去,但是通常我们会通过takewhile()等函数根据条件判断来截取出一个有限的序列:>>> natuals = itertools.count(1)>>> ns = itertools.takewhile(lambda x: x <= 10, natuals)>>> for n inns:
...printn
...
打印出1到10
itertools提供的几个迭代器操作函数更加有用:
chain()
chain()可以把一组迭代对象串联起来,形成一个更大的迭代器:for c in itertools.chain('ABC', 'XYZ'):printc#迭代效果:'A' 'B' 'C' 'X' 'Y' 'Z'
groupby()
groupby()把迭代器中相邻的重复元素挑出来放在一起:>>> for key, group in itertools.groupby('AAABBBCCAAA'):
...print key, list(group) #为什么这里要用list()函数呢?
...
A ['A', 'A', 'A']
B ['B', 'B', 'B']
C ['C', 'C']
A ['A', 'A', 'A']
实际上挑选规则是通过函数完成的,只要作用于函数的两个元素返回的值相等,这两个元素就被认为是在一组的,而函数返回值作为组的key。如果我们要忽略大小写分组,就可以让元素'A'和'a'都返回相同的key:>>> for key, group in itertools.groupby('AaaBBbcCAAa', lambdac: c.upper()):
...printkey, list(group)
...
A ['A', 'a', 'a']
B ['B', 'B', 'b']
C ['c', 'C']
A ['A', 'A', 'a']
imap()
imap()和map()的区别在于,imap()可以作用于无穷序列,并且,如果两个序列的长度不一致,以短的那个为准。>>> for x in itertools.imap(lambda x, y: x * y, [10, 20, 30], itertools.count(1)):
...printx
...10
40
90注意imap()返回一个迭代对象,而map()返回list。当你调用map()时,已经计算完毕:>>> r = map(lambda x: x*x, [1, 2, 3])>>> r #r已经计算出来了
[1, 4, 9]
当你调用imap()时,并没有进行任何计算:>>> r = itertools.imap(lambda x: x*x, [1, 2, 3])>>>r
#r只是一个迭代对象
必须用for循环对r进行迭代,才会在每次循环过程中计算出下一个元素:>>> for x inr:
...printx
...1
4
9这说明imap()实现了“惰性计算”,也就是在需要获得结果的时候才计算。类似imap()这样能够实现惰性计算的函数就可以处理无限序列:>>> r = itertools.imap(lambda x: x*x, itertools.count(1))>>> for n in itertools.takewhile(lambda x: x<100, r):
...print n
View Code
17、logging模块
用于便捷记录日志且线程安全的模块importlogging
logging.basicConfig(filename='log.log',
format='%(asctime)s - %(name)s - %(levelname)s -%(module)s: %(message)s',
datefmt='%Y-%m-%d %H:%M:%S %p',
level=5)
logging.debug('debug')
logging.info('info')
logging.warning('warning')
logging.error('error')
logging.critical('critical')
logging.log(10,'log')
对于等级:
CRITICAL= 50FATAL=CRITICAL
ERROR= 40WARNING= 30WARN=WARNING
INFO= 20DEBUG= 10NOTSET= 0
View Code
出处:http://blog.51cto.com/yht1990/1845737