Python学习（三）
一、正则表达式
正则表达式(regular expression)描述了一种字符串匹配的模式（pattern），可以用来检查一个串是否含有某种子串、将匹配的子串替换或者从某个串中取出符合某个条件的子串等。正则表达式有两部分参数，一个是匹配规则pattern，另一个是待匹配的数据源，data_source，用正则表达式时需要导入模块re，import re
import re m = re.match('abc','abcdef') # 其中abc为pattern，abcdef为data_source，re.match(pattern,data_source)方法， # 从data_source的左边开头进行匹配，若匹配上返回一个对象并且停止匹配，即只能匹配一次，匹配不上返回None print(m) if m: print(m.group()) # obj.group()方法，查看匹配到的内容
<_sre.SRE_Match object; span=(0, 3), match='abc'>
abc
但以上的方法pattern写的固定，只能匹配abc不够灵活，且只能匹配一次
import re m1 = re.findall('[0-9]{0,10}','146567abc576def') # 其中[0-9]{0,10}为pattern，[0-9]代表匹配的为0-9的数字， # {0,10}代表前面定义的类型可以为相同的0-10个进行匹配，可以写一个数字代表确定的个数进行匹配 # 146567abc576def为data_source，re.match(pattern,data_source)方法， # 把data_source的符合匹配规则的子字符全部匹配出来返回一个列表， # {0,10}存在0，则返回的列表会出现空的，一般是从1开始，例如{1，10} m2 = re.findall('[0-9]{1,10}','146567abc576def') m3 = re.findall('[a-zA-Z]{1,10}','146567abc576def') # [a-zA-Z]代表匹配为所有字母，大小写均可 m4 = re.findall('.*','146567abc576def') # 其中.代表可以匹配换行符以外的所有字符，*代表0到多个，功能类似{0，10} m5 = re.findall('.+','146567abc576def') # 其中+代表1到多个，功能类似于{1，10} m6 = re.search('\d+','146567abc576def') # re.search()方法，从data_source的左边开头进行匹配，直到找到一个符合的结果然后结束， # 或者找遍data_source都没有发现结束，其中\d代表匹配任意数字，类似[0-9], # \D代表匹配任意非数字，\s代表匹配任意空白字符，\S代表匹配任意非空字符， # \w匹配字母数字，\W匹配非字母数字 m7 = re.search('^\d+','146567abc576def') # 其中^代表从data_source的第一个字符开始就要求符合匹配规则，否则找不到NoneType， # $代表从data_source的最后一个字符要符合匹配规则 m8 = re.sub('\d+','-','146567abc576def') # re.sub(pattern,str,data_source，count= )方法，从data_source的左边开始， # 把匹配到的子字符串替换为设定的str,count=num可以指定替换的个数,默认全部替换 if m1 or m2 or m3 or m4 or m5 or m6 or m7 or m8: # print(m.group()) # re.findall没有obj.group()方法，直接使用print(obj)查看匹配到的内容 print(m1) print(m2) print(m3) print(m4) print(m5) print(m6.group()) # 查看re.search()中匹配到的子字符串 print(m7.group()) print(m8)
['146567', '', '', '', '576', '', '', '', '']
['146567', '576']
['abc', 'def']
['146567abc576def', '']
['146567abc576def']
146567
146567
-abc-def
对于较大的文件，可以先定义出pattern，然后再进行后面的匹配，避免每一次匹配都要编译一次pattern
import re p = re.compile("^[0-9]+") # 先定义出匹配规则pattern m1 = p.match("145sdfea") print(m1.group()) IP_pattern = re.compile('([0-9]{1,3}\.){3}\d{1,9}') # 定义IP地址的匹配规则 IP_pattern1 = re.compile(r'([0-9]{1,3}.){3}\d{1,9}') # pattern外面加上r，代表pattern的一些字符不转义， # 例如，.就代表一个.字符，而不再代表任意字符 IP_string = 'my ip is 192.168.1.56 you know' IP_result = IP_pattern.search(IP_string) IP_result1 = IP_pattern1.search(IP_string) print(IP_result.group()) print(IP_result1.group()) m2 = re.split('[0-9]','alngo8song9aoeia4asong5sefj') # re.split(pattern,data_source)方法，将匹配到的子字符串当做分割点， # 把data_source分割为一个一个字符串，返回一个列表，列表中字符串不包括匹配到的子字符串 print(m2)
145
192.168.1.56
192.168.1.56
['alngo', 'song', 'aoeia', 'asong', 'sefj']
二、模块调用
模块，就是一堆代码，实现了某个功能的代码集合，对于一个复杂功能可能需要多个函数才能完成（函数可以写在不同的.py文件中），这些n个.py文件组成的代码集合就是模块。创建一个模块的文件夹，不是用dictionary而是python package，他们的区别就是python package中有一个空的__init__.py文件，有这个文件模块才能被调用，由于模块要能被不同使用者调用，所以写模块时要用到解耦的思想，即使不同的功能程序之间的关联度降低。模块之间相互导入时文件寻找范围是文件所在同一文件夹下的内容，所以同级文件可以直接导入 import xxx，导入下级目录文件可以按目录寻找导入from dirname import xxx，但需要导入上级目录的文件时要添加上级文件的路径才行
1 # 同级之间调用 2 -- src 3 |-- mod1.py 4 |-- test1.py 5 # 程序test1.py中导入模块mod1, 则直接使用 6 import mod1 7 # 或 8 from mod1 import * 9 10 # 子级之间调用 11 -- src 12 |-- mod1.py 13 |-- lib 14 | |-- mod2.py 15 |-- test1.py 16 # 程序test1.py中导入模块mod2，使用 17 from lib.mod2 import * 18 # 或 19 import lib.mod2 20 21 # 上级模块调用 22 -- src 23 |-- mod1.py 24 |-- lib 25 | |-- mod2.py 26 |-- sub 27 | |-- test2.py 28 # 想要实现test2.py调用mod1.py和mod2.py，做法是我们先跳到src目录下面 29 import sys 30 sys.path.append("..") # 需要添加上级模块路径，.. 表示当前目录的上级目录，想要调用更上级的模块，则需要添加对应模块的绝对路径， 31 # sys.path.append('../')，导入os模块import os， 32 # os.path.abspath(__file__)方法找到文件的绝对路径， 33 # os.path.dirname()方法，去掉最后一级文件或目录，利用os.path.dirname(os.path.dirname(os.path.abspath(__file__)))方法，逐层嵌套直至绝对路径的最后一级目录为需要导入模块的目录，可以把这个路径结果赋予一个变量，然后添加路径 34 import mod1 35 import lib.mod2
三、模块介绍
time & datatime模块，提供的函数和方法可以获取与时间相关的操作，例如：获取系统时间，统计程序执行时间，WEB程序的响应时间等。
import time print(time.time()) # time.time()，返回从1970年1月1日0点0分以来的秒数,在编程中用来做时间戳 print(time.clock()) # time.clock()，第一次调用的时候，返回的是程序运行到这行代码的实际时间 for i in range(3): print(i) time.sleep(1) # time.sleep(num)，挂起当前的进程，参数num表示进程挂起的时间,单位是秒 print(time.ctime(1234567.89)) # 将一个时间戳(默认为当前时间)转换成一个时间字符串,时间戳单位为秒 print(time.clock()) # time.clock()，第二次及其之后的调用，返回的是自第一次调用后,到再次调用的时间间隔 print(time.gmtime()) # time.gmtime()，传入时间参数，单位为秒，以UTC格式返回struct_time对象时间，默认参数为time.time() print(time.localtime()) # time.localtime(),传入时间参数，单位为秒，返回struct_time对象本地时间或者系统时间，默认参数为time.time() print(time.mktime(time.gmtime())) # time.mktime()，传入struct_time格式时间，返回对应秒数时间 print(time.strptime(time.ctime(time.time()))) # time.strptime()，按指定格式解析一个表示时间的字符串，返回struct_time对象时间 print(time.strftime('%Y-%m-%d')) # time.strftime()，将日期格式化符号转化为时间字符串， # python中时间日期格式化符号： # %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 本地简化星期名称 # %A 本地完整星期名称 # %b 本地简化的月份名称 # %B 本地完整的月份名称 # %c 本地相应的日期表示和时间表示 # %j 年内的一天（001-366） # %p 本地A.M.或P.M.的等价符 # %U 一年中的星期数（00-53）星期天为星期的开始 # %w 星期（0-6），星期天为星期的开始 # %W 一年中的星期数（00-53）星期一为星期的开始 # %x 本地相应的日期表示 # %X 本地相应的时间表示 # %Z 当前时区的名称
1498483996.0492818
0.0
0
1
2
Thu Jan 15 14:56:07 1970
3.001460992756618
time.struct_time(tm_year=2017, tm_mon=6, tm_mday=26, tm_hour=13, tm_min=33, tm_sec=19, tm_wday=0, tm_yday=177, tm_isdst=0)
time.struct_time(tm_year=2017, tm_mon=6, tm_mday=26, tm_hour=21, tm_min=33, tm_sec=19, tm_wday=0, tm_yday=177, tm_isdst=0)
1498455199.0
time.struct_time(tm_year=2017, tm_mon=6, tm_mday=26, tm_hour=21, tm_min=33, tm_sec=19, tm_wday=0, tm_yday=177, tm_isdst=-1)
2017-06-26
datetime模块包含三个类，date、time、datetime，date类表示一个日期，日期由年、月、日组成，time类表示时间，由时、分、秒以及微秒组成，datetime是date与time的结合体，包括date与time的所有信息。
1 from datetime import date 2 print(date.max,date.min) # 所能表示的最大、最小日期 3 print(date.resolution) # 表示日期的最小单位，这里是天 4 print(date.today()) # 返回一个当前的本地日期 5 print(date.fromtimestamp(1234567.89)) # 给一个时间戳参数，返回一个日期 6 test_date = date(2015,8,23) 7 print(test_date) # 给出年、月、日参数，返回一个日期的格式 8 print(test_date.replace(2016,5,day=9)) # obj.replace(year,mouth,day)，给出年月日的参数，代替原来的时间 9 print(test_date.timetuple()) # obj.timetuple()，返回日期对应的time.struct_time对象 10 print(test_date.toordinal()) # obj.toordinal()，返回日期对应的Gregorian Calendar日期 11 print(test_date.weekday()) # obj.weekday()，返回weekday，如果是星期一，返回0；如果是星期2，返回1，以此类推 12 print(test_date.isoweekday()) # obj.isoweekday()，返回weekday，如果是星期一，返回1；如果是星期2，返回2，以此类推 13 print(test_date.isocalendar()) # obj.isocalendar()，返回格式如(year，month，day)的元组 14 print(test_date.isoformat()) # obj.isoformat()，返回格式如'YYYY-MM-DD'的字符串 15 print(test_date.strftime('%a-%b-%c-%H')) # obj.strftime(日期格式)，将原本日期重新定义格式后返回,日期格式 16 # %a 星期的简写,如星期三为Web 17 # %A 星期的全写,如星期三为Wednesday 18 # %b 月份的简写,如4月份为Apr 19 # %B 月份的全写,如4月份为April 20 # %c 日期时间的字符串表示。（如： 04/07/10 10:43:39） 21 # %d 日在这个月中的天数（是这个月的第几天） 22 # %f 微秒（范围[0,999999]） 23 # %H 小时（24小时制，[0, 23]） 24 # %I 小时（12小时制，[0, 11]） 25 # %j 日在年中的天数 [001,366]（是当年的第几天） 26 # %m 月份（[01,12]） 27 # %M 分钟（[00,59]） 28 # %p AM或者PM 29 # %S 秒（范围为[00,61]） 30 # %U 周在当年的周数当年的第几周），星期天作为周的第一天 31 # %w 今天在这周的天数，范围为[0, 6]，6表示星期天 32 # %W 周在当年的周数（是当年的第几周），星期一作为周的第一天 33 # %x 日期字符串（如：04/07/10） 34 # %X 时间字符串（如：10:43:39） 35 # %y 2个数字表示的年份 36 # %Y 4个数字表示的年份 37 # %z 与utc时间的间隔 （如果是本地时间，返回空字符串） 38 # %Z 时区名称（如果是本地时间，返回空字符串） 39 # %% %% => % 40 # date还对一些操作进行了重载，允许对日期进行如下一些操作：日期加上一个间隔timedelta，返回一个新的日期对象, 41 # 日期隔去间隔，返回一个新的日期对象,两个日期相减，返回一个时间间隔对象,两个日期进行比较, 42 # 对日期进行操作时，要防止日期超出它所能表示的范围。 43 now = date.today() 44 tomorrow = now.replace(day = 11) 45 delta = tomorrow - now 46 print('now:', now, ' tomorrow:', tomorrow) 47 print('timedelta:', delta) 48 print(now + delta) 49 print(tomorrow > now)
9999-12-31 0001-01-01
1 day, 0:00:00
2017-06-28
1970-01-15
2015-08-23
2016-05-09
time.struct_time(tm_year=2015, tm_mon=8, tm_mday=23, tm_hour=0, tm_min=0, tm_sec=0, tm_wday=6, tm_yday=235, tm_isdst=-1)
735833
6
7
(2015, 34, 7)
2015-08-23
Sun-Aug-Sun Aug 23 00:00:00 2015-00
now: 2017-06-28 tomorrow: 2017-06-11
timedelta: -17 days, 0:00:00
2017-06-11
False
from datetime import time print(time.max,time.min) # 所能表示的最大、最小时间 print(time.resolution) # 表示时间的最小单位，这里是微秒 tm = time(7, 17, 10) # 给出时间参数，返回一个时间格式的类 print(type(tm)) print('tm:', tm) print('hour: %d, minute: %d, second: %d, microsecond: %d' % (tm.hour, tm.minute, tm.second, tm.microsecond)) # obj.hour,obj.minute,obj.second,obj.microsecond， # 分别返回时间格式的小时、分钟、秒、微妙 tm1 = tm.replace(hour = 8) # 给出新的时间参数，返回新的时间代替原来的时间 print('tm1:', tm1) print('isoformat():', tm.isoformat()) # 返回时间格式的字符串 print(type(tm.isoformat())) # 像date一样，time也可以对两个time对象进行比较，或者相减返回一个时间间隔对象
23:59:59.999999 00:00:00
0:00:00.000001
<class 'datetime.time'>
tm: 07:17:10
hour: 7, minute: 17, second: 10, microsecond: 0
tm1: 08:17:10
isoformat(): 07:17:10
<class 'str'>
from datetime import datetime print(datetime.max,datetime.min) # datetime所能表示的最小值与最大值 print(datetime.resolution) # datetime所能表示的最小单位 print(datetime.today(),type(datetime.today())) # 返回本地的时间对象 print(datetime.now(),type(datetime.now())) # 返回一个表示当前本地时间的datetime对象 print(datetime.utcnow(),type(datetime.utcnow())) # 返回一个当前utc时间的datetime对象 print(datetime.fromtimestamp(123456.78)) # 给一个时间戳参数，返回一个datetime对象 print(datetime.utcfromtimestamp(123456.78)) # 给一个时间戳参数，返回一个utc格式datetime对象 dt = datetime.fromtimestamp(12345678.9) print(dt,type(dt)) print(dt.day) print(dt.year,dt.month,dt.day,dt.hour,dt.minute,dt.second,dt.microsecond) # obj.year,obj.month,obj.day,obj.hour, # obj.mimute,obj.second,obj.microsecond, # 分别得到datetime对象的年、月、日、小时、分、秒、微秒 print(dt.date()) # obj.date(),得到datetime对象的日期 print(dt.time()) # obj.time(),得到datetime对象的时间 print(dt.replace(year=1990,month=6,day=10,microsecond=2333)) # obj.replace(year,month,day,hour,minute,second,microsecond), # 传入年、月、日等参数，取代原来datetime对象中的值得到新的datetime对象，原来的datetime对象不变 print(dt.timetuple()) # obj.timetuple(),返回datetime对象的struct_time格式时间 print(dt.weekday()) # obj.weekday(),返回weekday，如果是星期一，返回0；如果是星期2，返回1，以此类推 print(dt.isoweekday()) # obj.isoweekday()，返回weekday，如果是星期一，返回1；如果是星期2，返回2，以此类推 print(dt.isocalendar()) # obj.isocalendar()，返回格式如(year，month，day)的元组 print(dt.isoformat(),type(dt.isoformat())) # obj.isoformat()，返回格式如'YYYY-MM-DD'的字符串 print(dt.ctime(),type(dt.ctime())) # obj.ctime(),返回一个日期时间格式的字符串 print(dt.strftime('%a %b')) # obj.strftime(日期格式)，将原本日期重新定义格式后返回,日期格式 # %a 星期的简写,如星期三为Web # %A 星期的全写,如星期三为Wednesday # %b 月份的简写,如4月份为Apr # %B 月份的全写,如4月份为April # %c 日期时间的字符串表示。（如： 04/07/10 10:43:39） # %d 日在这个月中的天数（是这个月的第几天） # %f 微秒（范围[0,999999]） # %H 小时（24小时制，[0, 23]） # %I 小时（12小时制，[0, 11]） # %j 日在年中的天数 [001,366]（是当年的第几天） # %m 月份（[01,12]） # %M 分钟（[00,59]） # %p AM或者PM # %S 秒（范围为[00,61]） # %U 周在当年的周数当年的第几周），星期天作为周的第一天 # %w 今天在这周的天数，范围为[0, 6]，6表示星期天 # %W 周在当年的周数（是当年的第几周），星期一作为周的第一天 # %x 日期字符串（如：04/07/10） # %X 时间字符串（如：10:43:39） # %y 2个数字表示的年份 # %Y 4个数字表示的年份 # %z 与utc时间的间隔 （如果是本地时间，返回空字符串） # %Z 时区名称（如果是本地时间，返回空字符串） # %% %% => %
9999-12-31 23:59:59.999999 0001-01-01 00:00:00
0:00:00.000001
2017-06-29 15:03:04.261054 <class 'datetime.datetime'>
2017-06-29 15:03:04.261053 <class 'datetime.datetime'>
2017-06-29 07:03:04.261053 <class 'datetime.datetime'>
1970-01-02 18:17:36.780000
1970-01-02 10:17:36.780000
1970-05-24 05:21:18.900000 <class 'datetime.datetime'>
24
1970 5 24 5 21 18 900000
1970-05-24
05:21:18.900000
1990-06-10 05:21:18.002333
time.struct_time(tm_year=1970, tm_mon=5, tm_mday=24, tm_hour=5, tm_min=21, tm_sec=18, tm_wday=6, tm_yday=144, tm_isdst=-1)
6
7
(1970, 21, 7)
1970-05-24T05:21:18.900000 <class 'str'>
Sun May 24 05:21:18 1970 <class 'str'>
Sun May
random模块，用于生成随机数，一下是random模块中最常用的几个函数
import random print(random.random()) # random.random(),随机生成一个(0,1)之间的浮点数 print(random.uniform(3,5)) # random.uniform(a,b),随机生成一个(a,b)之间的浮点数 print(random.randint(6,9)) # random.randint(a,b),随机生成一个(a,b)之间的整数 print(random.randrange(7,20,3)) # random.randrange(a,b,c),随机在一个从a开始按c递增到b的集合中选取一个 print(random.choice('Arelax')) # random.choice(sequence),随机从一个序列中选取一个，列表、元组、字符串都属于序列 test_list = ['zhu','shanwei','is','handsome'] random.shuffle(test_list) # random.shuffle(list),将列表中的元素打乱顺序 print(test_list) new_list = random.sample(test_list,3) # random.sample(sequence,k),从序列中随机选取三个元素，组成一个新列表返回， # 原来序列不会被改变，列表、元组、字符串都属于序列 print(new_list)
0.30439801060116023
4.031051910060102
9
19
a
['handsome', 'zhu', 'is', 'shanwei']
['handsome', 'is', 'shanwei']
os & os.path模块，提供对操作系统进行调用的接口，不受平台限制，可以处理文件和目录这些我们日常手动需要做的操作
import os import os.path print(os.name) # 输出字符串指示当前使用的平台，win-->nt,linux-->posix print(os.getcwd()) # 获取当前程序文件的所在路径 # os.chdir(path) 改变工作路径 print(os.curdir) # 得到当前目录字符串 print(os.pardir) # 得到当前目录的父目录字符串 # os.makedirs('dirname1/dirname2/dirname2') 生成多级文件夹，若已有文件夹则报错 # os.mkdir('dirname') 生成单极文件夹 # os.removedirs('dirname1/dirname2') 检查最后一级文件夹是否为空，若为空则删除文件夹，并返回到上一级，若文件夹仍为空继续删除，以此类推 # os.rmdir('dirname') 删除单极空文件夹，若目录不为空则无法删除，报错 print(os.listdir('day1')) # os.listdir(path),列出所给路径下的所有文件夹和文件，包括隐藏文件，并以列表方式给出 # os.remove(path) 删除所给路径的文件 # os.rename('olddirname','newdirname') 重命名文件/文件夹 print(os.stat('day1')) # os.stat(path/filename),获取目录/文件的信息 # os.symlink(src,dst) 把源地址src与目标地址dst创建一个软连接，没有返回值 dir_list = [] folder_list = [] file_list = [] for dir1,folder1,file1 in os.walk('day1'): # os.walk(path) 返回包含(dir,folder,file)三种信息的generator，其中file为文件名、dir为file的目录、folder为dir下的目录,可循环读出 dir_list.append(dir1) folder_list.append(folder1) file_list.append(file1) print(dir_list) print(folder_list) print(file_list) # os.system('dir') os.system(command),给命令参数可直接运行 a= os.popen('dir').read() # os.popen(command),把命令的运行结果生成一个对象，可以直接读出，也可以赋给一个变量然后读出 b = os.popen('dir') print(a) print(b.read()) print(os.environ) # os.environ,获取系统环境变量 print(os.path.abspath('exercise.py')) # os.path.abspath(dirname/filename),返回文件规范化的绝对路径 c = os.path.split('E:\python exercise\exercise.py') # os.path.split(path),将路径分割成目录和文件名两部分，以元组返回 print(c) print(os.path.dirname('E:\python exercise\exercise.py')) # os.path.dirname(path),返回path的目录，其实就是os.path.split(path)的第一个元素 print(os.path.basename('E:\python exercise\exercise.py')) # os.path.basename(path),返回path最后的文件名 # os.path.join(path1,path2[, ...]]) 将多个路径组合后返回 # os.path.commonprefix(list) 列表中元素为路径，返回list中所有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 print(os.path.normpath('E:\/python exercise//exercise.py')) # os.path.normpath(path),规范化路径 print(os.path.splitdrive('E:\python exercise\exercise.py')) # os.path.splitdrive(path),拆分驱动器名和路径为两部分，以元组返回 print(os.path.splitext('E:\python exercise\exercise.py')) # os.path.splitext(path),分离文件名与扩展名为两部分，以元组返回 print(os.path.getsize('E:\python exercise\exercise.py')) # os.path.getsize(path),返回path的大小（字节） print(os.path.getatime('E:\python exercise\exercise.py')) # os.path.getatime(path),返回path所指向的文件或者目录的最后存取时间 print(os.path.getmtime('E:\python exercise\exercise.py')) # os.path.getmtime(path),返回path所指向的文件或者目录的最后修改时间 print(os.path.getctime('E:\python exercise\exercise.py')) # os.path.getctime(path),返回path所指向的文件或者目录的创建时间
nt
E:\python exercise
.
..
['guess_number.py', 'guess_number1.py', 'information.py', 'work1', 'work2']
os.stat_result(st_mode=16895, st_ino=281474976712310, st_dev=428346, st_nlink=1, st_uid=0, st_gid=0, st_size=4096, st_atime=1496668362, st_mtime=1496668362, st_ctime=1496663193)
['day1', 'day1\\work1', 'day1\\work2']
[['work1', 'work2'], [], []]
[['guess_number.py', 'guess_number1.py', 'information.py'], ['local.log', 'readme.txt', 'user_password.py', '流程图.vsdx'], ['menu.py', '流程图.vsdx']]
驱动器 E 中的卷是 文档
卷的序列号是 0006-893A
E:\python exercise 的目录
2017/06/30 11:53 <DIR> .
2017/06/30 11:53 <DIR> ..
2017/06/30 11:54 <DIR> .idea
2017/05/10 15:26 30,966 1.jpg
2017/05/05 15:47 167,844,260 123.avi
2017/05/14 15:44 59 123.txt
2017/01/04 20:35 41,126 2.jpg
2017/01/04 19:39 11,434 3.jpg
2017/06/13 10:12 60 456.txt
2017/01/04 21:23 30,785 5.jpg
2017/01/04 21:24 18,451 6.jpg
2017/04/06 19:21 7,923,035 car_vidio.flv
2017/06/05 21:12 <DIR> classify
2017/06/05 21:12 <DIR> day1
2017/06/05 21:12 <DIR> day2
2017/06/05 21:12 <DIR> day3
2017/06/30 11:53 3,957 exercise.py
2017/01/13 20:43 7,496,789 hog.txt
2017/06/25 21:47 12,849 Matplotlib.py
2017/06/19 00:57 19,061 numpy&pandas.py
2017/06/27 22:03 <DIR> save_model
2017/06/27 22:02 9,889 Sklearn.py
2017/06/19 00:58 65 test.csv
2017/06/28 14:49 897 test.py
16 个文件 183,443,683 字节
8 个目录 50,338,816,000 可用字节
驱动器 E 中的卷是 文档
卷的序列号是 0006-893A
E:\python exercise 的目录
2017/06/30 11:53 <DIR> .
2017/06/30 11:53 <DIR> ..
2017/06/30 11:54 <DIR> .idea
2017/05/10 15:26 30,966 1.jpg
2017/05/05 15:47 167,844,260 123.avi
2017/05/14 15:44 59 123.txt
2017/01/04 20:35 41,126 2.jpg
2017/01/04 19:39 11,434 3.jpg
2017/06/13 10:12 60 456.txt
2017/01/04 21:23 30,785 5.jpg
2017/01/04 21:24 18,451 6.jpg
2017/04/06 19:21 7,923,035 car_vidio.flv
2017/06/05 21:12 <DIR> classify
2017/06/05 21:12 <DIR> day1
2017/06/05 21:12 <DIR> day2
2017/06/05 21:12 <DIR> day3
2017/06/30 11:53 3,957 exercise.py
2017/01/13 20:43 7,496,789 hog.txt
2017/06/25 21:47 12,849 Matplotlib.py
2017/06/19 00:57 19,061 numpy&pandas.py
2017/06/27 22:03 <DIR> save_model
2017/06/27 22:02 9,889 Sklearn.py
2017/06/19 00:58 65 test.csv
2017/06/28 14:49 897 test.py
16 个文件 183,443,683 字节
8 个目录 50,338,816,000 可用字节
environ({'USERDOMAIN_ROAMINGPROFILE': 'ZSW', 'HOMEPATH': '\\Users\\Arelax', 'SYSTEMDRIVE': 'C:', 'COMSPEC': 'C:\\Windows\\system32\\cmd.exe', 'PROGRAMFILES': 'C:\\Program Files', 'LOGONSERVER': '\\\\ZSW', 'TMP': 'C:\\Users\\Arelax\\AppData\\Local\\Temp', 'USERPROFILE': 'C:\\Users\\Arelax', 'SESSIONNAME': 'Console', 'TEMP': 'C:\\Users\\Arelax\\AppData\\Local\\Temp', 'COMPUTERNAME': 'ZSW', 'COMMONPROGRAMFILES(X86)': 'C:\\Program Files (x86)\\Common Files', 'PROCESSOR_LEVEL': '6', 'PROCESSOR_IDENTIFIER': 'Intel64 Family 6 Model 60 Stepping 3, GenuineIntel', 'PROCESSOR_REVISION': '3c03', 'NUMBER_OF_PROCESSORS': '4', 'SYSTEMROOT': 'C:\\Windows', 'LOCALAPPDATA': 'C:\\Users\\Arelax\\AppData\\Local', 'HOMEDRIVE': 'C:', 'PATHEXT': '.COM;.EXE;.BAT;.CMD;.VBS;.VBE;.JS;.JSE;.WSF;.WSH;.MSC', 'USERNAME': 'Arelax', 'PROGRAMW6432': 'C:\\Program Files', 'ALLUSERSPROFILE': 'C:\\ProgramData', 'PROGRAMDATA': 'C:\\ProgramData', 'USERDOMAIN': 'ZSW', 'WINDIR': 'C:\\Windows', 'COMMONPROGRAMW6432': 'C:\\Program Files\\Common Files', 'PATH': 'D:\\Anaconda3\\Library\\bin;C:\\Windows\\system32;C:\\Windows;C:\\Windows\\System32\\Wbem;C:\\Windows\\System32\\WindowsPowerShell\\v1.0\\;D:\\Anaconda3;D:\\Anaconda3\\Scripts;D:\\Anaconda3\\Library\\bin;D:\\Anaconda3\\MinGW\\bin;D:\\Anaconda3\\MinGW\\x86_64-w64-mingw32\\lib', 'APPDATA': 'C:\\Users\\Arelax\\AppData\\Roaming', 'PROCESSOR_ARCHITECTURE': 'AMD64', 'OS': 'Windows_NT', 'PYTHONIOENCODING': 'UTF-8', 'FP_NO_HOST_CHECK': 'NO', 'COMMONPROGRAMFILES': 'C:\\Program Files\\Common Files', 'PYTHONPATH': 'E:\\python exercise', 'PSMODULEPATH': 'C:\\Windows\\system32\\WindowsPowerShell\\v1.0\\Modules\\', 'PYTHONUNBUFFERED': '1', 'PROGRAMFILES(X86)': 'C:\\Program Files (x86)', 'PUBLIC': 'C:\\Users\\Public', 'PYCHARM_HOSTED': '1'})
E:\python exercise\exercise.py
('E:\\python exercise', 'exercise.py')
E:\python exercise
exercise.py
E:\python exercise\exercise.py
('E:', '\\python exercise\\exercise.py')
('E:\\python exercise\\exercise', '.py')
3957
1498794827.3380208
1498794827.4012773
1496663186.4562693
sys模块，用来处理Python运行时配置以及资源，从而可以与前当程序之外的系统环境交互
import sys print(sys.path) # 返回模块的搜索路径 print(sys.maxsize) # 获取64位系统正整数的最大值 print(sys.version) # 获取python解释程序的版本信息 print(sys.platform) # 返回操作系统平台 sys.stdout.write('123\n') # 打印输出，功能等同与print() test_in = sys.stdin.readline()[:-1] # 从键盘接受输入，功能等同与input() print(test_in) # print("sys.argv[0]---------",sys.argv[0]) # print("sys.argv[1]---------",sys.argv[1]) # print("sys.argv[2]---------",sys.argv[2]) if len(sys.argv) < 2: # sys.argv,返回本文件的路径 print('No action specified.') sys.exit() if sys.argv[1].startswith('--'): # obj.starswith(str),表示判断obj是否以str开头，如果是返回True option = sys.argv[1][2:] # sys.argv[1][2:],表示所接受的第二个参数从第三个字符开始往后的内容 # fetch sys.argv[1] but without the first two characters if option == 'version': print('Version 1.2') # sys.argv[],用来获取命令行参数的,sys.argv[0]表示代码本身文件路径，当由CMD进入命令窗口， # 并进入到本文件所在目录（例如，进入E盘的命令为 E:，然后进入到E盘的文件夹目录命令为 cd dirname）, # 输入python exercise.py --version help,则会执行该程序，并且argv接收所给命令参数， # 由于从argv[0]开始接收命令参数，所以第一个参数必需为文件名，然后argv[1]接收第二个参数，以此类推 # sys.exit(n) 退出程序命令，正常退出为exit(0)
['E:\\python exercise', 'E:\\python exercise', 'D:\\Anaconda3\\python35.zip', 'D:\\Anaconda3\\DLLs', 'D:\\Anaconda3\\lib', 'D:\\Anaconda3', 'D:\\Anaconda3\\lib\\site-packages', 'D:\\Anaconda3\\lib\\site-packages\\Sphinx-1.3.5-py3.5.egg', 'D:\\Anaconda3\\lib\\site-packages\\win32', 'D:\\Anaconda3\\lib\\site-packages\\win32\\lib', 'D:\\Anaconda3\\lib\\site-packages\\Pythonwin', 'D:\\Anaconda3\\lib\\site-packages\\setuptools-27.2.0-py3.5.egg']
9223372036854775807
3.5.3 |Anaconda 2.5.0 (64-bit)| (default, May 15 2017, 10:43:23) [MSC v.1900 64 bit (AMD64)]
win32
123
输入：456
456
shutil模块，对文件、文件夹、压缩包的处理模块
import shutil file1 = open('hog.txt','r') with open('hog1.txt','w') as file2: shutil.copyfileobj(file1,file2) # shutil.copyfileobj(filesrc,filedst,length)方法， # 将一个对象的内容拷贝到另一个文件，参数为文件对象， # 即打开后的文件变量名，可指定拷贝的文件长度 file1.close() shutil.copyfile('hog.txt','hog2.txt') # shutil.copyfile(src,dst)方法，将一个文件的内容拷贝到另一个文件中， # 参数为文件名,目标文件可以不存在（不存在自动创建）# shutil.copymode('f1.log', 'f2.log') 仅拷贝权限，内容、组、用户均不变，目标文件必须存在 # shutil.copystat('f1.log', 'f2.log') 仅拷贝状态的信息，包括：mode bits, atime, mtime, flags，目标文件必须存在 shutil.copy('hog.txt','hog3.txt') # 拷贝文件内容和权限，目标文件可以不存在 shutil.copy2('hog.txt','hog4.txt') # 拷贝文件内容和状态信息，目标文件可以不存在 shutil.copytree('classify','classify2',ignore=shutil.ignore_patterns('*.py','car*')) # 把一个文件夹中的内容拷贝到另外一个文件夹， # 参数为文件夹名，目标文件夹不能存在，目标文件夹的父级目录要有可写权限， # ignore的意思是排除 ，例子中是以.py结尾和以car开头的文件不拷贝 shutil.rmtree('classify2') # 删除一个目录 shutil.move('classify','123') # 把源文件夹中的内容移动到目标文件夹中，然后把源文件夹删除，目标文件夹可以不存在，功能相当于重命名 shutil.make_archive('classify','zip','E:\python exercise\classify') # make_archive(base_name, format, root_dir)方法，把文件夹或者文件压缩成压缩包， # base_name是压缩包的文件名，也可以是压缩包的路径，只是文件名时，则保存至当前目录，否则保存至指定路径， # format是压缩包种类，“zip”, “tar”, “bztar”，“gztar”， # root_dir是要压缩的文件夹路径，即要压缩的对象（默认为压缩当前目录的所以文件）
pickle和json模块，把内存中的数据进行序列化，序列化之后就可以存储到磁盘上，或通过网络传输到别的机器上，有序列化就有反序列化，把内容从序列化对象重新读取到内存的过程称之为反序列化。json只能处理基本数据类型（例如，列表、元组、字典）；pickle能处理所有的Python数据类型，json多用于各个语言之间的网络传输；pickle多用于Python程序对象的持久化或Python程序之间的网络传输
import pickle import json d = {"a":1,"b":2} f1 = open("pickle_test1.txt","wb") # 用pickle进行序列化，序列化为二进制形式，保存的文件需要二进制形式打开 pickle_d = pickle.dumps(d) # 将一个字典序列化 print(pickle_d) print(type(pickle_d)) f1.write(pickle_d) # 将序列化的内容写入文件 f1.close() f2 = open("pickle_test2.txt","wb") pickle.dump(d,f2) # 可以把序列化和写入文件的操作合并在一起 f2.close() f3 = open("pickle_test1.txt","rb") # 用二进制写入的文件，读的时候也为二进制 dd = f3.read() pickle_d2 = pickle.loads(dd) # 或者pickle.loads(f3.read()),读出文件中的内容然后反序列化 print(pickle_d2) print(type(pickle_d2)) f3.close() f4 = open("pickle_test2.txt","rb") pickle_d3 = pickle.load(f4) # 把读文件和序列化合并到一起 print(pickle_d3) f4.close() # json提供和pickle同样的功能，json序列化成的是字符串，不是二进制 f5 = open("pickle_test3.txt","w") f6 = open("pickle_test4.txt","w") json_d1 = json.dumps(d) print(json_d1) print(type(json_d1)) f5.write(json_d1) json.dump(d,f6) f5.close() f6.close() f7 = open("pickle_test3.txt","r") f8 = open("pickle_test4.txt","r") dd2 = f7.read() json_d2 = json.loads(dd2) print(json_d2) print(type(json_d2)) json_d3 = json.load(f8) print(json_d3) print(type(json_d3)) f7.close() f8.close()
b'\x80\x03}q\x00(X\x01\x00\x00\x00aq\x01K\x01X\x01\x00\x00\x00bq\x02K\x02u.'
<class 'bytes'>
{'a': 1, 'b': 2}
<class 'dict'>
{'a': 1, 'b': 2}
{"a": 1, "b": 2}
<class 'str'>
{'a': 1, 'b': 2}
<class 'dict'>
{'a': 1, 'b': 2}
<class 'dict'>
shelve模块，是一个简单的数据存储方案，只有一个函数open()，接收参数是文件名，然后返回一个类似字典的对象
import shelve file = shelve.open('shelve_data') # 创建一个文件，不需要存在，会自动创建，不需要后缀名 file['baidu'] = 'www.baidu.com' # 以字典的形式传入文件，进行序列化 file['qq'] = 'www.qq.com' file['360'] = 'www.360.cn' file.close() # 保存文件 file1 = shelve.open('shelve_data') key_value1 = file1.get('qq') # 以字典的键形式，得到对应的值 key_value2 = file1['360'] print(key_value1) print(key_value2)
www.qq.com
www.360.cn
xml模块，实现不同语言和程序之间进行数据交换的协议，和json类似，但json使用起来更简单，xml通过<>节点来区分数据结构，xml文档的格式如下
<data> <country name="Liechtenstein"> <rank updated="yes">2</rank> <year>2023</year> <gdppc>141100</gdppc> <neighbor direction="E" name="Austria" /> <neighbor direction="W" name="Switzerland" /> </country> <country name="Singapore"> <rank updated="yes">5</rank> <year>2026</year> <gdppc>59900</gdppc> <neighbor direction="N" name="Malaysia" /> </country> <country name="Panama"> <rank updated="yes">69</rank> <year>2026</year> <gdppc>13600</gdppc> <neighbor direction="W" name="Costa Rica" /> <neighbor direction="E" name="Colombia" /> </country> </data>
import xml.etree.ElementTree as ET test_tree = ET.parse('test.xml') # 解析xml文件 test_root = test_tree.getroot() # 得到xml文件的根节点以及根节点下的元素对象 print(test_root) print(test_root.tag) # 得到根节点的名称 for test_child in test_root: # 循环得到根节点下的子节点 print(test_child.tag,test_child.attrib) # 得到子节点的名称和属性 for i in test_child: # 循环得到子节点下的子节点 print('---->',i.tag,i.attrib,i.text) # 得到子节点下的名称、属性和值 for test_node in test_root.iter('year'): # 循环某一节点 print(test_node.tag,test_node.text) for node1 in test_root.iter('year'): new_year = int(node1.text)+1 # 由于读出来的值为字符串，变为整数形式之后才能修改，加1 node1.text = str(new_year) # 把int形式改为str形式更新year节点为新的值 node1.set('updated','yes') # 为year节点添加设置属性 test_tree.write('new_test.xml') # 把改后的xml保存为新的xml文件,可以不事先存在 for country in test_root.findall('country'): # 找到所有的country节点 rank = int(country.find('rank').text) # 找到country节点下的rank节点的值 if rank>50: test_root.remove(country) # 移除符和条件的country节点 test_tree.write('new_test1.xml') # 自己创建一个xml文件 new_tree = ET.Element('namelist') # 设置一个根节点 name1 = ET.SubElement(new_tree,'name1',attrib={'zhu':'shanwei'}) # 创建父节点下的一个子节点，参数为父节点变量名、子节点名称、子节点属性 sex1 = ET.SubElement(name1,'sex1',attrib={'age':'man'}) # 创建子节点下的一个子节点 age1 = ET.SubElement(name1,'age1') age1.text = str(27) sex1.text = 'man' name2 = ET.SubElement(new_tree,'name2',attrib={'feng':'jin'}) # 创建父节点下的另一个子节点，参数为父节点变量名、子节点名称、子节点属性 sex2 = ET.SubElement(name2,'sex2',attrib={'age':'woman'}) # 创建子节点下的一个子节点 age2 = ET.SubElement(name2,'age2') age2.text = str(25) sex2.text = 'woman' new_xml = ET.ElementTree(new_tree) # 生成所创建的文件 new_xml.write('new_xml.xml',encoding='utf-8',xml_declaration=True,short_empty_elements=False) ET.dump(new_xml) # 打印显示出生成的文件内容
<Element 'data' at 0x0000002AD16D02C8>
data
country {'name': 'Liechtenstein'}
----> rank {'updated': 'yes'} 2
----> year {} 2023
----> gdppc {} 141100
----> neighbor {'name': 'Austria', 'direction': 'E'} None
----> neighbor {'name': 'Switzerland', 'direction': 'W'} None
country {'name': 'Singapore'}
----> rank {'updated': 'yes'} 5
----> year {} 2026
----> gdppc {} 59900
----> neighbor {'name': 'Malaysia', 'direction': 'N'} None
country {'name': 'Panama'}
----> rank {'updated': 'yes'} 69
----> year {} 2026
----> gdppc {} 13600
----> neighbor {'name': 'Costa Rica', 'direction': 'W'} None
----> neighbor {'name': 'Colombia', 'direction': 'E'} None
year 2023
year 2026
year 2026
<namelist><name1 zhu="shanwei"><sex1 age="man">man</sex1><age1>27</age1></name1><name2 feng="jin"><sex2 age="woman">woman</sex2><age2>25</age2></name2></namelist>
configparser模块，用于生产和修改常见的配置文档，配置文件的格式与windows ini文件类似，配置文件（INI文件）由节（section）、键、值组成，可以包含一个或多个节（section），每个节可以有多个参数（键=值），配置文件格式如下，配置文件中用的是冒号，也可以用等号
[book] title:ConfigParser模块教程 time:2012-09-20 22:04:55 [size] size:1024 [other] blog:csdn.net
import configparser config = configparser.ConfigParser() # 先声明定义一个configparser配置文档对象 config["default"] = {'name':'zhu shanwei', 'age':'27', 'hobby':'game'} # 定义一个节，和节中的键和值 config['bitbucket.org'] = {} # 定义一个新的节，内容为空 config['bitbucket.org']['User'] = 'hg' # 向节中写入键和值 config['topsecret.server.com'] = {} topsecret = config['topsecret.server.com'] # 可以把节赋给一个变量 topsecret['Host Port'] = '50022' # 向节中写入键和值 topsecret['ForhardX11'] = 'no' config['default']['ForhardX11'] = 'yes' with open('example.ini','w') as configfile: config.write(configfile) # 保存配置文件 config.read('example.ini') # 读取配置文件，读取之前要先声明一下配置文件对象，即上面的configparser.ConfigParser() section_list = config.sections() print(section_list) # 得到配置文件的节名称，返回一个列表 key_list = config.options(section_list[0]) print(key_list) # 得到某个节中的键名称，返回一个列表 value_test = config.get(section_list[0],key_list[0]) # 得到某个节中某一键的值 print(value_test) key_value = config.items(section_list[1]) # 得到某一个节的键和值,返回一个列表，列表中每一个元素为键和值组成的一个元组 print(key_value) result_section = config.has_section(section_list[2]) # 判断节是否在配置文件中，若在返回True print(result_section) result_key = config.has_option(section_list[2],key_list[0]) # 判断节中是否有某个键，若在返回True print(result_key) config.add_section('add_section') # 向配置文件中添加节点 config.set('add_section','sex','man') # 向节点中添加键和值 config.remove_section(section_list[1]) # 删除某一节及节中的内容 config.remove_option(section_list[0],key_list[1]) # 删除节中某一键及其键的内容 with open('example1.ini','w') as configfile: config.write(configfile) # 保存配置文件
['default', 'bitbucket.org', 'topsecret.server.com']
['age', 'hobby', 'name', 'forhardx11']
27
[('user', 'hg')]
True
False
hashlib模块，用于加密相关的操作，3.x里代替了md5模块和sha模块，主要提供 SHA1, SHA224, SHA256, SHA384, SHA512 ，MD5 算法
import hashlib m = hashlib.md5() # 声明用什么方式加密 m1 = hashlib.md5() m.update(b'zhu shanwei') # 添加要加密的内容 m1.update(b'zhu shanwei') print(m.digest()) # 2进制格式hash print(m.hexdigest()) # 16进制格式hash print(m1.hexdigest()) # 在同一种加密方式下，相同的内容加密后的结果相同 m.update(b"is handsome") print(m.hexdigest()) # 根据加密的内容的添加，返回不同的加密内容，加密内容不可被反解
b'*2x\xce\x0f\xbe^\x92\x8e~s7\x801\x97\xac'
2a3278ce0fbe5e928e7e7337803197ac
2a3278ce0fbe5e928e7e7337803197ac
05a1e96bb6473b8009ecaf63452ae2bb
logging模块，程序日志相关模块，通过它可以存储各种格式的日志，提供有debug()、info()、warning()、error()、critical()五种级别的日志，级别依次提高
import logging logging.basicConfig(format='%(asctime)s %(filename)s [line:%(lineno)d] %(levelname)s %(message)s', datefmt='%a, %d %b %Y %H:%M:%S', filename='logging_example.log',level=logging.INFO) # 把日志写的文件里,文件不需要预先存在， # level的级别设定是把同级别和以上的级别存档，以下级别不存储, # 要设置日志的格式，需要先format定义，以上定义的内容分别为时间、 # 文件名、日志程序所在的行数、日志等级、日志信息，datefmt为所定义的时间格式filename: 指定日志文件名
filemode: 和file函数意义相同，指定日志文件的打开模式，'w'或'a'
filemode: 和file函数意义相同，指定日志文件的打开模式，'w'或'a'
format: 指定输出的格式和内容，format可以输出很多有用信息，如上例所示:
%(levelno)s: 打印日志级别的数值
%(levelname)s: 打印日志级别名称
%(pathname)s: 打印当前执行程序的路径，其实就是sys.argv[0]
%(filename)s: 打印当前执行程序名
%(funcName)s: 打印日志的当前函数
%(lineno)d: 打印日志的当前行号
%(asctime)s: 打印日志的时间
%(thread)d: 打印线程ID
%(threadName)s: 打印线程名称
%(process)d: 打印进程ID
%(message)s: 打印日志信息
datefmt: 指定时间格式，同time.strftime()
level: 设置日志级别，默认为logging.WARNING logging.warning("user [Arelax] attempted wrong password more than 3 times") # logging.类型("内容")，可以直接显示出来 logging.critical("the server is down") logging.debug('This message should go to the log file') logging.info('So should this') logging.warning('And this too')
import logging # 把日志同时显示在屏幕和写入文件中 logger = logging.getLogger('LOG_TEST') # 定义一个logging对象，参数为自定义的名称 logger.setLevel(logging.WARNING) # 定义全局的日志级别 ch = logging.StreamHandler() # 定义显示屏幕的handle ch.setLevel(logging.DEBUG) # 定义屏幕显示级别，和全局日志级别比较，取较二者高级别作为日志等级 fh = logging.FileHandler('logging_example1.log') # 定义写入文件的handle，同时定义文件名 fh.setLevel(logging.ERROR) # 定义写入文件级别，和全局日志级别比较，取较二者高级别作为日志等级 formater = logging.Formatter('%(asctime)s-%(name)s-%(levelname)s-%(message)s') # 定义日志的格式，其中%(name)s为logging对象自定义的名称 ch.setFormatter(formater) # 将日志格式赋予handle fh.setFormatter(formater) logger.addHandler(ch) # 将handle赋予logging的对象，在此定义的是logger logger.addHandler(fh) # 以对象logger给出日志的信息 logger.debug('logger debug message') logger.info('logger info message') logger.warning('logger warning message') logger.error('logger error message') logger.critical('logger critical message')
2017-07-14 12:36:34,543-LOG_TEST-WARNING-logger warning message
2017-07-14 12:36:34,543-LOG_TEST-ERROR-logger error message
2017-07-14 12:36:34,543-LOG_TEST-CRITICAL-logger critical message
浙公网安备 33010602011771号