目录:

                collections模块                                                           

  在置放数据类型(dict、list、set、tuple)的功底上,collections模块还提供了多少个附加的数据类型:Counter、deque、defaultdict、namedtuple和OrderedDict等。

    1.namedtuple:
生成能够运用名字来访问成分内容的tuple

    2.deque:
双端队列,能够不慢的从其它一侧追加和推出对象

    3.Counter: 计数器,首要用来计数

    4.OrderedDict: 有序字典

    5.defaultdict: 带有私下认可值的字典

后天内容:

什么是模块:———–

 1.time和datetime模块

  namedtuple (名称元祖)

  描述一类东西的时候,那类东西都有相同的特征,想一向用特色的名字就讲述这几个值的的时候就能够用命名元祖

  namedtuple是3个函数,它用来创制1个自定义的tuple指标,并且明确了tuple要素的个数,并得以用属性而不是索引来引用tuple的某部成分。

那样一来,大家用namedtuple能够很有益于地定义一种数据类型,它拥有tuple的不变性,又足以遵照属性来引用,使用越发利于。

namedtuple定义

  #namedtuple('名称', [属性list]):
  Circle = namedtuple('Circle', ['x', 'y', 'r'])

金沙注册送58 1金沙注册送58 2

1 from collections import namedtuple
2 point = namedtuple('Point', ['x', 'y'])
3 p = point(3, 4)
4 
5 print(p.x)
6 print(p.y)

View Code

  1.时间模块 (time)

科学普及的风貌:三个模块正是贰个暗含了python定义和表明的文件,文件名便是模块名字加上.py的后缀。

 2. random模块

deque (双端队列)

   使用list储存数据时,按索引访问成分十分的快,可是插入和删除成分就极慢了,因为list是线性存款和储蓄,数据量大的时候,插入和删除效用相当的低。

  
deque是为了飞速落实插入和删除操作的双向列表,适合用来队列和栈

deque除了那么些之外落到实处list的append()pop()外,还支持appendleft()popleft(),这样就足以10分快速地往尾部添加或删除元素

金沙注册送58 3金沙注册送58 4

1 from collections import deque
2 
3 dq = deque(['a', 'b', 'c'])
4 dq.append('x')
5 dq.appendleft('y')
6 
7 dq.pop()
8 dq.popleft()
9 print(dq)

deque

  2.随机数 (random)

模块分类:1—-松开模块

3. OS模块(是与操作系统交互的三个接口)

OrderedDict

  使用dict时,Key是无序的。在对dict做迭代时,大家无能为力分明Key的相继。

  假如要维持Key的一一,能够用OrderedDict

  注意,OrderedDict的Key会遵照插入的顺序排列,不是Key本人排序:

金沙注册送58 5金沙注册送58 6

 1 from collections import OrderedDict
 2 
 3 d = dict([('a', 2), ('c', 4), ('b', 6)])
 4 # dict的key是无序的
 5 print(d)
 6 
 7 od = OrderedDict([('a', 1), ('c', 3), ('b', 5)])
 8 # OrderedDict的key是有序的
 9 print(od)
10 
11 od['z'] = 6
12 od['y'] = 7
13 od['x'] = 8
14 print(od.keys())  # 按照插入的Key的顺序返回
15 
16 
17 {'a': 2, 'c': 4, 'b': 6}
18 OrderedDict([('a', 1), ('c', 3), ('b', 5)])
19 odict_keys(['a', 'c', 'b', 'z', 'y', 'x'])

OrderedDict

  3.sys模块

    
2—-扩张模块()

4. sys模块(sys模块是与python解释器交互的二个接口)

defaultdict

  使用dict时,假若引用的Key不设有,就会抛出KeyError。要是愿意key不存在时,重回3个默许值,就能够用defaultdict

  注意默许值是调用函数再次来到的,而函数在创建defaultdict对象时传出。

   
除了在Key不设有时再次来到暗许值,defaultdict的其余表现跟dict是完全相同的

 

金沙注册送58 7金沙注册送58 8

 1 from collections import defaultdict
 2 values = [11, 22, 33, 44, 55, 66, 77, 88, 99]
 3 my_dict = defaultdict(list)
 4 
 5 for value in values:
 6     if value > 66:
 7         my_dict['k1'].append(value)
 8     elif value < 66:
 9         my_dict['k2'].append(value)
10 
11 print(my_dict)
12 
13 
14 defaultdict(<class 'list'>, {'k2': [11, 22, 33, 44, 55], 'k1': [77, 88, 99]})

defaultdict

 

  4.os模块

              
3—-自定义模块     本身写的公文

5.种类化模块 

Counter

 

  Counter目标是用来跟踪值出现的次数。它是一个严节的容器类型,以字典的键值对情势储存,其兰月素作为key,其计数作为value。计数值能够是随机的Interger(蕴含0和负数)。Counter类和别的语言的bags或multisets很相像。

金沙注册送58 9金沙注册送58 10

1 from collections import Counter
2 c = Counter('hello')
3 c1 = Counter({'a': 4, 'b': 2})
4 c2 = Counter(a=4, b=6)
5 print(c1)
6 print(c)
7 print(c2)

Counter

  当所访问的键不存在时,再次来到0,而不是KeyError;不然再次回到它的计数。

金沙注册送58 11金沙注册送58 12

1 from collections import Counter
2 c = Counter('abcdefgab')
3 print(c['a'])
4 print(c['h'])
5 print(c['d'])
6 
7 2
8 0
9 1

计数值的走访

  可以应用1个iterable对象也许另三个Counter对象来更新键值。

  计数器的翻新包含扩大和压缩三种。当中,扩充使用update()方法和削减则动用subtract()方法

金沙注册送58 13金沙注册送58 14

 1 from collections import Counter
 2 c = Counter('which')
 3 c.update('witch')
 4 print(c['h'])
 5 
 6 d = Counter('watch')
 7 c.update(d)
 8 print(c['h'])
 9 
10 c = Counter('which')
11 c.subtract('witch')
12 print(c['h'])
13 
14 d = Counter('watch')
15 c.subtract(d)
16 print(c['a'])
17 
18 
19 3
20 4
21 1
22 -1

View Code

 

  5.连串化模块

为啥要使用模块?

6.hashlib模块

键的修改和删除

常用模块,python之常用模块。当计数值为0时,并不代表元素被删去,删除成分应当接纳del。 

键的去除

>>> c = Counter("abcdcba")
>>> c
Counter({'a': 2, 'c': 2, 'b': 2, 'd': 1})
>>> c["b"] = 0
>>> c
Counter({'a': 2, 'c': 2, 'd': 1, 'b': 0})
>>> del c["a"]
>>> c
Counter({'c': 2, 'b': 2, 'd': 1})

 

1.时间模块(time)

代表时间的三种方法:

  1.时间戳(timestamp)

  2.格式化的时光字符串(Format String) 

  3.元组(结构化) (struct time)

1.时间戳:

time.sleep()  #使程序滞留一段时间,该时间以 秒 为单位。
time.time()  #时间戳, 即 记录某个时间点

2.格式化时间字符串的各样参数用法:如下

金沙注册送58 15金沙注册送58 16

%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 当前时区的名称
%% %号本身


print(time.strftime('%Y.%m.%d %X'))
print(time.strftime('%Y.%m.%d %x'))
print(time.strftime('%y%m%d %H%M%S '))
print(time.strftime('%y%m%d %I%M%S %a'))
print(time.strftime('%y%m%d %I%M%S %A'))
print(time.strftime('%y%m%d %I%M%S %A %b'))
print(time.strftime('%y%m%d %I%M%S %A %B'))
print(time.strftime('%y%m%d %I%M%S %A %B %c'))
print(time.strftime('%y%m%d %I%M%S %A %B %c %j'))
print(time.strftime('%y%m%d %I%M%S %A %B %c %j %p'))
print(time.strftime('%y%m%d %I%M%S %A %B %c %j %p %U'))
print(time.strftime('%y%m%d %I%M%S %A %B %c %j %p %U %w'))
print(time.strftime('%y%m%d %I%M%S %A %B %c %j %p %U %W'))
print(time.strftime('%y%m%d %I%M%S %A %B %c %j %p %U %W %Z'))




结果:
2017.08.08 18:51:58
2017.08.08 08/08/17
170808 185158 
170808 065158 Tue
170808 065158 Tuesday
170808 065158 Tuesday Aug
170808 065158 Tuesday August
170808 065158 Tuesday August Tue Aug  8 18:51:58 2017
170808 065158 Tuesday August Tue Aug  8 18:51:58 2017 220
170808 065158 Tuesday August Tue Aug  8 18:51:58 2017 220 PM
170808 065158 Tuesday August Tue Aug  8 18:51:58 2017 220 PM 32
170808 065158 Tuesday August Tue Aug  8 18:51:58 2017 220 PM 32 2
170808 065158 Tuesday August Tue Aug  8 18:51:58 2017 220 PM 32 32
170808 065158 Tuesday August Tue Aug  8 18:51:58 2017 220 PM 32 32 ?D1¨²¡À¨º¡Á?¨º¡À??

View Code

3.元组(结构化):struct_time元组共有九个因素共多少个因素:(年,月,日,时,分,秒,一年中第几周,一年中第几天等)

金沙注册送58 17

m = time.localtime()   #类似命名元组  用于计算比对。
print(m)
print(m.tm_year)

结果:

time.struct_time(tm_year=2017, tm_mon=8, tm_mday=8, tm_hour=18, tm_min=54, tm_sec=21, tm_wday=1, tm_yday=220, tm_isdst=0)
2017

Process finished with exit code 0

 小结:时间戳是电脑能够识其他时间;时间字符串是人能够看懂的年华;元组则是用来操作时间的

三种格式之间的变换:

  1.时间戳(timestamp)

  2.格式化的时间字符串(Format String) 

  3.元组(结构化) (struct time)

金沙注册送58 18

金沙注册送58 19金沙注册送58 20

#时间戳  转  结构化    和      结构化 转  时间戳
print(time.gmtime())   #伦敦时间
print(time.localtime()) #北京时间
s = time.gmtime(1500000000) #时间戳  转  结构化
d = time.localtime(1500000000) #时间戳  转  结构化
print(s)
print(d)
print(time.mktime(s))   #结构化 转  时间戳
print(time.mktime(d))  #结构化 转  时间戳

结果:
time.struct_time(tm_year=2017, tm_mon=8, tm_mday=8, tm_hour=11, tm_min=26, tm_sec=54, tm_wday=1, tm_yday=220, tm_isdst=0)

time.struct_time(tm_year=2017, tm_mon=8, tm_mday=8, tm_hour=19, tm_min=26, tm_sec=54, tm_wday=1, tm_yday=220, tm_isdst=0)

time.struct_time(tm_year=2017, tm_mon=7, tm_mday=14, tm_hour=2, tm_min=40, tm_sec=0, tm_wday=4, tm_yday=195, tm_isdst=0)

time.struct_time(tm_year=2017, tm_mon=7, tm_mday=14, tm_hour=10, tm_min=40, tm_sec=0, tm_wday=4, tm_yday=195, tm_isdst=0)

1499971200.0
1500000000.0

Process finished with exit code 0

#结构化  转  字符串    和   字符串  转   结构化
print(time.strftime('%Y%m%d %X'))  #结构化转 字符串
print(time.strptime('2017-03-16','%Y-%m-%d'))   #字符串  转   结构化

结果:
20170808 19:29:32
time.struct_time(tm_year=2017, tm_mon=3, tm_mday=16, tm_hour=0, tm_min=0, tm_sec=0, tm_wday=3, tm_yday=75, tm_isdst=-1)

Process finished with exit code 0

View Code

 
 若是您退出python解释器然后再也进入,那么你此前定义的函数或许变量都将遗失,由此我们经常将次第写到文件中以便永久保存下来,须求时就因此python
test.py方式去履行,此时test.py被称为脚本script。

7.configparser

elements()

回来3个迭代器。成分被重新了略微次,在该迭代器中就隐含多少个该因素。成分排列无规定顺序,个数小于1的因素不被含有。

elements()方法 

>>> c = Counter(a=4, b=2, c=0, d=-2)
>>> list(c.elements())
['a', 'a', 'a', 'a', 'b', 'b']

 

2.随机数(random)模块:

import random
#随机小数
print(random.random()) #大于0且小于1的小数。
print(random.uniform(1,3)) #大于1小于3的小数

#随机整数
print(random.randint(1,5))  #随机1-5的之间的整数。顾头顾尾
print(random.randrange(10))
print(random.randrange(1,10,2))

#随机选择一个返回
print(random.choice([1,2,3,4,[11,111,1111],'zxc']))

#随机选择多个返回,返回的个数为函数的第二个参数
print(random.sample([1,2,3,4,[5,6,7,8]],2))  #任意返回多个值,后面参数2 是用户之间定义的。

#打乱列表顺序
item = [1,3,5,7,9]
print(item)
random.shuffle(item)
print(item)


结果:
0.8872507582462091
1.3964555681725257
1
3
7
4
[[5, 6, 7, 8], 4]
[1, 3, 5, 7, 9]
[7, 1, 3, 9, 5]

Process finished with exit code 0

1.写一个验证码 1.要有数字, 2,要有字母  3,一共四位  4 可以重复
拿字母,用acsii 码, 拿到后,就转换成字符串。 65-90  97-122。

金沙注册送58 21金沙注册送58 22

第一种方法:
def v_code ():
    code = '' \
           ''
    for i in range (4):
        num = random.randint(0,9)
        alf = chr(random.randint(65,90))
        alp = chr(random.randint(97,122))
        add = random.choice([num,alf,alp])
        code = ''.join([code,str(add)])
    return code
print(v_code())


第二种方法:
list1 = list (range(10))
new_list = list(map(str,list1))
alf = list(range(65,91))
alp = list(range(95,123))
alf_l=[]
for i in range (65,91):
    alf = chr(i)
    alf_l.append(alf)
alp_l=[]
for i in range (95,123):
    alp = chr(i)
    alp_l.append(alp)
new_list.extend(alf_l)
new_list.extend(alp_l)
ret = []
ret = random.sample(new_list,4)
print(''.join(ret))

View Code

   
随着程序的前行,功能越多,为了方便管理,我们平常将次第分成1个个的文本,那样做程序的组织更显明,方便管理。那时大家不光能够把这几个文件作为脚本去履行,仍是能够把她们作为模块来导入到其他的模块中,已毕了职能的再一次使用,

8.logging  (记录日志的模块)

most_common([n])

回来一个TopN列表。借使n没有被内定,则赶回全部因素。当七个成分计数值相同时,排列是无规定顺序的。

most_common()方法

 

>>> c = Counter('abracadabra')
>>> c.most_common()
[('a', 5), ('r', 2), ('b', 2), ('c', 1), ('d', 1)]
>>> c.most_common(3)
[('a', 5), ('r', 2), ('b', 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下为"\t\n",Linux下为"\n"
os.pathsep    输出用于分割文件路径的字符串 win下为;,Linux下为:
os.name    输出字符串指示当前使用平台。win->'nt'; Linux->'posix'
os.system("bash command")  运行shell命令,直接显示
os.popen("bash command)  运行shell命令,获取执行结果
os.environ  获取系统环境变量

os.path
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的大小
'''

类别化模块:

9.collections模块(使用counter举行记数总结)

浅拷贝copy

浅拷贝copy

>>> c = Counter("abcdcba")
>>> c
Counter({'a': 2, 'c': 2, 'b': 2, 'd': 1})
>>> d = c.copy()
>>> d
Counter({'a': 2, 'c': 2, 'b': 2, 'd': 1})

 

4.sys模块:

sys模块是与python解释器交互的二个接口

sys.argv           命令行参数List,第一个元素是程序本身路径
sys.exit(n)        退出程序,正常退出时exit(0)
sys.version        获取Python解释程序的版本信息
sys.maxint         最大的Int值
sys.path           返回模块的搜索路径,初始化时使用PYTHONPATH环境变量的值
sys.platform       返回操作系统平台名称

怎样叫系列化??

模块:

  总计机程序的支付进程中,随着程序代码越写越来越多,在七个文书里代码就会更为长,越来越不便于保证。为了编写制定可体贴的代码,大家把众多函数分组,分别放到差异的文件里,那样,各个文件包括的代码就相对较少,很多编制程序语言都选拔那种组织代码的方法。在
Python 中,二个.py 文件就称为三个模块(Module)。

模块分类:

  内置模块  python安装时自带的

  扩张模块  外人写好的,安装之后方可一向运用

        itchat模块(和微信相关), beautifulsoap(爬虫模块),
selenium(网页自动化测试工具)

        django tornado(框架)

  自定义模块 本人写的模块 

算术和集纳操作

+、-、&、|操作也能够用来Counter。个中&和|操作分别重回七个Counter对象各因素的最小值和最大值。需求留意的是,获得的Counter对象将去除小于1的因素。

Counter对象的算术和集聚操作

>>> c = Counter(a=3, b=1)
>>> d = Counter(a=1, b=2)
>>> c + d  # c[x] + d[x]
Counter({'a': 4, 'b': 3})
>>> c - d  # subtract(只保留正数计数的元素)
Counter({'a': 2})
>>> c & d  # 交集:  min(c[x], d[x])
Counter({'a': 1, 'b': 1})
>>> c | d  # 并集:  max(c[x], d[x])
Counter({'a': 3, 'b': 2})

 

5.体系化模块:

怎么样叫体系化——将本来的字典、列表等剧情转换到一个字符串的进程就叫做序列化

系列化的指标

壹 、以某种存款和储蓄情势使自定义指标持久化;

贰 、将指标从3个地点传递到另三个地点。

叁 、使程序更具维护性。

金沙注册送58 23

json:

  Json模块提供了四个职能:dumps、dump、loads、load

金沙注册送58 24金沙注册送58 25

import json
d = {'k':1}
ret1= json.dumps(d)   #字典转字符串
print(ret1,type(ret1))
ret2= json.loads(ret1)   #字符串转字典
print(ret2,type(ret2))

f = open('json_file','w')
dic = {'k1':'v1','k2':'v2','k3':'v3'}
json.dump(dic,f)    #dump方法接收一个文件句柄,直接将字典转换成json字符串写入文件
f.close()
print(dic)

f = open('json_file')
dic2 = json.load(f)   #load方法接收一个文件句柄,直接将文件中的json字符串转换成数据结构返回
f.close()
print(type(dic2),dic2)

结果:
{"k": 1} <class 'str'>
{'k': 1} <class 'dict'>
{'k1': 'v1', 'k2': 'v2', 'k3': 'v3'}
<class 'dict'> {'k1': 'v1', 'k2': 'v2', 'k3': 'v3'}

Process finished with exit code 0

View Code

pickle:

用来种类化的四个模块

 

  • json,用于字符串 和 python数据类型间举行转换
  • pickle,用于python特有的类型 和 python的数据类型间实行更换

 

pickle模块提供了多少个功效:dumps、dump(连串化,存)、loads(反体系化,读)、load
 (不仅可以系列化字典,列表…能够把python中私自的数据类型系列化

那里大家要注明一下,json是一种具有的言语都能够分辨的数据结构。
假诺大家将叁个字典也许种类化成了二个json存在文件里,那么java代码只怕js代码也足以拿来用。
只是只要大家用pickle实行系列化,别的语言就不可能读懂那是何等了~
之所以,假设你种类化的内容是列表也许字典,我们13分推荐你利用json模块
但假若出于某种原因你不得不系列化其余的数据类型,近期后你还会用python对那个数据开始展览反体系化的话,那么就足以使用pickle

shelve:

shelve也是python提供给大家的种类化学工业具,比pickle用起来更简约一些。
shelve只提需求我们三个open方法,是用key来访问的,使用起来和字典类似。

金沙注册送58 26金沙注册送58 27

import shelve
f = shelve.open('shelve_file')
f['key'] = {'int':10, 'float':9.5, 'string':'Sample data'}  #直接对文件句柄操作,就可以存入数据
f.close()

import shelve
f1 = shelve.open('shelve_file')
existing = f1['key']  #取出数据的时候也只需要直接用key获取即可,但是如果key不存在会报错
f1.close()
print(existing)

View Code

本条模块有个限制,它不协理多个应用同一时间往同八个DB进行写操作。所以当大家知晓大家的运用假如只实行读操作,大家能够让shelve通过只读情势打开DB

金沙注册送58 28金沙注册送58 29

import shelve
f = shelve.open('shelve_file', flag='r')
existing = f['key']
f.close()
print(existing)

View Code

出于shelve在默许意况下是不会记录待持久化对象的任何改动的,所以我们在shelve.open()时候需求修改默许参数,不然对象的改动不会保留。

金沙注册送58 30金沙注册送58 31

import shelve
f1 = shelve.open('shelve_file')
print(f1['key'])
f1['key']['new_value'] = 'this was not here before'
f1.close()

f2 = shelve.open('shelve_file', writeback=True)
print(f2['key'])
f2['key']['new_value'] = 'this was not here before'
f2.close()

View Code

writeback格局有独到之处也反常。优点是裁减了大家失误的概率,并且让对象的持久化对用户特别的晶莹了;但那种措施并不是兼具的场地下都要求,首先,使用writeback以后,shelf在open()的时候会扩充额外的内部存款和储蓄器消耗,并且当DB在close()的时候会将缓存中的每1个指标都写入到DB,这也会带来相当的等候时间。因为shelve没有办法知道缓存中怎么着对象修改了,哪些对象没有改动,由此有所的对象都会被写入。

 

 

利用模块好处:

  进步了代码的可维护性。

  当3个模块编写完结,就足以被其它市方引用。

  使用模块能够制止函数名和变量名争持。

其他常用操作

上面是一对Counter类的常用操作,来源于Python官方文书档案

Counter类常用操作

sum(c.values())  # 所有计数的总数
c.clear()  # 重置Counter对象,注意不是删除
list(c)  # 将c中的键转为列表
set(c)  # 将c中的键转为set
dict(c)  # 将c中的键值对转为字典
c.items()  # 转为(elem, cnt)格式的列表
Counter(dict(list_of_pairs))  # 从(elem, cnt)格式的列表转换为Counter类对象
c.most_common()[:-n:-1]  # 取出计数最少的n个元素
c += Counter()  # 移除0和负值

序列化 (Serialization)将对象的情景音讯转换为能够储存或传输的样式的进度

 1.time和datetime模块

time模块

python中,日常由以下二种艺术来代表时间:

  • 时光戳(timestamp):日常来说,时间戳表示的是从1966年八月1六日00:00:00从头按秒总括的撼动,运转“type(time.time())”,重回的是float类型。
  • 格式化的时间字符串(Format
    String):如‘2018-4-24′
  • 结构化的时日(struct_time):元祖情势。struct_time元组共有7个成分共7个成分:(年,月,日,时,分,秒,一年中第几周,一年中第几天,夏令时)

    import time
    # 时间戳:     
    print(time.time())     # 1520503969.847386
    # 字符串格式化时间(两种结果一样):
    print(time.strftime('%x,%X'))   # 04/24/18,16:09:53
    print(time.strftime('%c'))   # Tue Apr 24 16:11:12 2018
    print(time.strftime('%Y-%M-%d,%H:%M:%S'))   # 2018-14-24,16:14:08
    print(time.strftime('%Y-%m-%d %X'))    # 2018-03-08 18:12:49
    print(time.strftime('%Y-%m-%d %H:%M:%S'))
    # 结构化时间:   
    print(time.localtime())   # 本地时区的struct_time
    print(time.gmtime())     # UTC时区的struct_time
    

     

   个中总括机认识的时日只好是’时间戳’格式,而程序员可处理的也许说人类能看懂的日子有:
‘格式化的光阴字符串’,’结构化的光阴’ 

两种时光格式之间的转换:

金沙注册送58 32  

切实用法:

import time
# 时间戳转化为结构化时间
# time.gmtime(时间戳)     # UTC时间
# time.localtime(时间戳)  # 当地时间
ret = time.localtime(2000000000)
print(ret)
# time.struct_time(tm_year=2033, tm_mon=5, tm_mday=18, tm_hour=11, tm_min=33, tm_sec=20, tm_wday=2, tm_yday=138, tm_isdst=0)

# 结构化时间转化为格式化时间
print(time.strftime('%Y-%m-%d %H:%M:%S', ret))
# 2033-05-18 11:33:20

# 把一个结构化时间转化为格式化时间
print(time.strftime("%Y-%m-%d %X", time.localtime()))
# 把一个格式化时间字符串转化为struct_time
print(time.strptime('2018-04-24 17:37:06', '%Y-%m-%d %X'))

 

 金沙注册送58 33

# 结构化时间 –> %a %b %d %H:%M:%S %Y串

# ctime,把一个时间戳转化为time.asctime()的形式
# 如果参数未给或者为None的时候,将会默认time.time()为参数
a = time.ctime(2000000000)
print(a)   # Wed May 18 11:33:20 2033
print(time.ctime(time.time()))
# Tue Apr 24 17:41:56 2018

# asctime,把一个表示时间的元组或者struct_time表示为这种形式:'Sun Jun 20 23:21:05 1993'。
# 如果没有参数,则默认将time.localtime()作为参数传入。
print(time.asctime())
# Tue Apr 24 17:41:56 2018

python中时间日期格式化符号:

 1 %y 两位数的年份表示(00-99)
 2 %Y 四位数的年份表示(000-9999)
 3 %m 月份(01-12)
 4 %d 月内中的一天(0-31)
 5 %H 24小时制小时数(0-23)
 6 %I 12小时制小时数(01-12)
 7 %M 分钟数(00=59)
 8 %S 秒(00-59)
 9 %a 本地简化星期名称
10 %A 本地完整星期名称
11 %b 本地简化的月份名称
12 %B 本地完整的月份名称
13 %c 本地相应的日期表示和时间表示
14 %j 年内的一天(001-366)
15 %p 本地A.M.或P.M.的等价符
16 %U 一年中的星期数(00-53)星期天为星期的开始
17 %w 星期(0-6),星期天为星期的开始
18 %W 一年中的星期数(00-53)星期一为星期的开始
19 %x 本地相应的日期表示
20 %X 本地相应的时间表示
21 %Z 当前时区的名称

datetime模块:

import datetime

print(datetime.datetime.now())    # 2018-03-08 21:04:15.544213     

# y-m-d h:M:S       2018-04-24 17:00:00
# 计算从方今时刻开始 比起y-m-d h:M:S过去了略微年 多少月 多少天
多少h,多少m,多少s

金沙注册送58 34金沙注册送58 35

import time
def pass_time(times):
    pass_time = time.strptime(times, '%Y-%m-%d %X')  # 结构化时间
    pass_time_stamp = time.mktime(pass_time)   # 时间戳
    time_stamp = time.time()-pass_time_stamp  # 已经过去的时间戳
    pass_times = time.localtime(time_stamp)   # 结构化时间
    now = zip(tuple(pass_times),tuple(time.localtime(0)))
    now1 = [(i[0]-i[1]) for i in now]  # 数字型列表,对应年,月---
    return '从当前时间开始,距离%s过去了%s年%s月%s日%s时%s分%s秒' %(times,now1[0],now1[1],now1[2],now1[3],now1[4],now1[5])

print(pass_time('2018-04-24 17:00:00'))

View Code

                      时间模块                                                                                           

  表示时间的三种办法

    在Python中,日常有那两种方法来表示时间:时间戳、元组(struct_time)、格式化的小时字符串:

    (1)时间戳(timestamp)
:常常来说,时间戳表示的是从一九七零年10月21日00:00:00起来按秒总计的偏移量。大家运转“type(time.time())”,重回的是float类型。

    (2)格式化的年月字符串(Format String): ‘1998-12-06’

金沙注册送58 36

%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 当前时区的名称
%% %号本身

    (3)元组(struct_time)
:struct_time元组共有7个因素共九个要素:(年,月,日,时,分,秒,一年中第几周,一年中第几天等)

索引(Index) 属性(Attribute) 值(Values)
0 tm_year(年) 比如2011
1 tm_mon(月) 1 – 12
2 tm_mday(日) 1 – 31
3 tm_hour(时) 0 – 23
4 tm_min(分) 0 – 59
5 tm_sec(秒) 0 – 60
6 tm_wday(weekday) 0 – 6(0表示周一)
7 tm_yday(一年中的第几天) 1 – 366
8 tm_isdst(是否是夏令时) 默认为0

 

金沙注册送58 37金沙注册送58 38

 1 import time
 2 # time.sleep(10)
 3 # 时间戳
 4 print(time.time())
 5 
 6 # 时间串
 7 print(time.strftime('%Y-%m-%d %H:%M:%S'))
 8 print(time.strftime('%A'))
 9 print(time.strftime('%a'))
10 print(time.strftime('%x'))
11 print(time.strftime('%c'))
12 
13 # 时间元祖
14 print(time.localtime())
15 
16 
17 1510645831.6729546
18 2017-11-14 15:50:31
19 Tuesday
20 Tue
21 11/14/17
22 Tue Nov 14 15:50:31 2017
23 time.struct_time(tm_year=2017, tm_mon=11, tm_mday=14, tm_hour=15, tm_min=50, tm_sec=31, tm_wday=1, tm_yday=318, tm_isdst=0)

View Code

 

三种格式之间的变换

金沙注册送58 39

金沙注册送58 40

金沙注册送58 41金沙注册送58 42

 1 # 时间元祖
 2 print(time.localtime(1500000000))  # 时间戳转换时间元祖
 3 print(time.gmtime(1200000000))  # 英国时间
 4 print(time.mktime(time.localtime(1500000000)))  # 时间元祖转换时间戳
 5 
 6 print(time.strftime('%Y-%m-%d', time.localtime(1500000000)))  # 时间元祖转换时间串
 7 print(time.strptime("2017-08-03", '%Y-%m-%d'))  # 时间串转换时间元祖
 8 print(time.strptime('2018/05/12', '%Y/%m/%d'))
 9 
10 print(time.asctime(time.localtime(2000000000)))  # 时间元祖转换时间串
11 print(time.ctime())
12 print(time.ctime(1600000000))  # 时间戳转换时间串

练习

金沙注册送58 43金沙注册送58 44

1 import time
2 true_time=time.mktime(time.strptime('2017-09-11 08:30:00','%Y-%m-%d %H:%M:%S'))
3 time_now=time.mktime(time.strptime('2017-09-12 11:00:00','%Y-%m-%d %H:%M:%S'))
4 dif_time=time_now-true_time
5 struct_time=time.gmtime(dif_time)
6 print('过去了%d年%d月%d天%d小时%d分钟%d秒'%(struct_time.tm_year-1970,struct_time.tm_mon-1,
7                                        struct_time.tm_mday-1,struct_time.tm_hour,
8                                        struct_time.tm_min,struct_time.tm_sec))

测算时间差

 

sys模块

  sys模块是与python解释器交互的3个接口

sys.argv           命令行参数List,第一个元素是程序本身路径
sys.exit(n)        退出程序,正常退出时exit(0),错误退出sys.exit(1)
sys.version        获取Python解释程序的版本信息
sys.path           返回模块的搜索路径,初始化时使用PYTHONPATH环境变量的值
sys.platform       返回操作系统平台名称

金沙注册送58 45金沙注册送58 46

 1 import sys
 2 print(sys.platform)
 3 print(sys.version)
 4 print(sys.path)
 5 print(sys.argv)
 6 print(sys.exit())
 7 
 8 
 9 win32
10 3.6.1 (v3.6.1:69c0db5, Mar 21 2017, 18:41:36) [MSC v.1900 64 bit (AMD64)]
11 ['C:\\Users\\panhw\\Desktop\\学习文档\\python\\day19作业', 'C:\\Users\\panhw\\Desktop\\学习文档\\python', 'C:\\Users\\panhw\\AppData\\Local\\Programs\\Python\\Python36\\python36.zip', 'C:\\Users\\panhw\\AppData\\Local\\Programs\\Python\\Python36\\DLLs', 'C:\\Users\\panhw\\AppData\\Local\\Programs\\Python\\Python36\\lib', 'C:\\Users\\panhw\\AppData\\Local\\Programs\\Python\\Python36', 'C:\\Users\\panhw\\AppData\\Local\\Programs\\Python\\Python36\\lib\\site-packages']
12 ['C:/Users/panhw/Desktop/学习文档/python/day19作业/作业.py']

View Code

random模块

 

金沙注册送58 47金沙注册送58 48

 1 import random
 2 
 3 # 随机小数
 4 print(random.random())  # 随机生成0到1之间的小数
 5 print(random.uniform(1, 10))  # 随机获取n到m之间的小数
 6 
 7 # 0.11930423761507436
 8 # 9.136906780912456
 9 
10 # 随机整数
11 print(random.randint(1, 5))  # 随机生成n到m之间的整数
12 print(random.randrange(10))  # 随机获取0到m之间的整数
13 print(random.randrange(2, 10))  # 随机生成n到m之间的整数
14 print(random.randrange(3, 15, 3))  # 随机生成n到m之间的整数 n的倍数
15 
16 # 2
17 # 4
18 # 5
19 # 6
20 
21 # 随机选择序列的一个元素返回
22 print(random.choice(['a', 'b', 3, 4, 5, 8, 'v']))
23 # 随机返回选择序列的多个元素 返回的个数为取决于第二个参数
24 print(random.sample(['a', 'b', 3, 4, 5, 8, 'v'], 3))
25 
26 # a
27 # ['a', 'b', 3]
28 
29 # 打乱原列表的顺序
30 item = [1, 2, 4, 5, 6, 7]
31 print(item)
32 random.shuffle(item)
33 print(item)
34 
35 # [1, 2, 4, 5, 6, 7]
36 # [1, 2, 4, 5, 6, 7]

View Code

金沙注册送58 49金沙注册送58 50

 1 import random
 2 
 3 
 4 def verify(n=6):
 5     """
 6     随机验证码
 7     :param n: 验证码个数 (int)
 8     :return: 返回验证码 (str)
 9     """
10     li = []
11     for i in range(n):
12         num = str(random.randint(0, 9))  # 随机整数转字符串
13         alpha = chr(random.randint(65, 90))  # 大写字母 ASCII
14         alpha2 = chr(random.randint(97, 122))  # 小写字母 ASCII
15         ret = random.choice([num, alpha, alpha2])  # 随机选择一个
16         li.append(ret)
17     return ''.join(li)  # 列表转字符串
18 
19 print(verify(8))

轻易验证码

os模块

 os模块是与操作系统交互的2个接口

 

金沙注册送58 51金沙注册送58 52

 1 import os
 2 # 和系统路径相关
 3 print(os.getcwd())  # 获取当前工作目录,即当前python脚本工作的目录路径os.chdir('C:\\Users')  # 改变当前脚本工作目录;相当于shell下cd
 4 print(os.getcwd())
 5 print(os.curdir)  # 返回当前目录: ('.')
 6 print(os.pardir)  # 获取当前目录的父目录字符串名:('..')
 7 
 8 
 9 # 和系统文件或文件夹相关的
10 os.mkdir('name1')  # 生成单级目录;相当于shell中mkdir dirname
11 os.makedirs('name1/name2')  # 可生成多层递归目录
12 os.rmdir('name1/name2')  # 删除单级空目录,若目录不为空则无法删除,报错;相当于shell中rmdir dirname
13 os.removedirs(r'C:\Users\panhw\Desktop\学习文档\python\day20\name1\name2')  # 若目录为空,则删除,并递归到上一级目录,如若也为空,则删除,依此类推
14 print(os.listdir(r'C:\Users\panhw\Desktop\学习文档\python\day20\name1'))  # 列出指定目录下的所有文件和子目录,包括隐藏文件,并以列表方式打印
15 os.remove(r'C:\Users\panhw\Desktop\学习文档\python\day4.py')  # 删除一个文件
16 os.rename(r'name3/name4', 'name3/name')  # 重命名文件/目录
17 
18 
19 # 和操作系统特征相关
20 print(os.stat(r'C:\Users\panhw\Desktop\学习文档\python\day4.py'))  # 获取文件/目录信息
21 print(os.sep)  # 输出操作系统特定的路径分隔符,win下为"\\",Linux下为"/"
22 print(os.linesep)  # 输出当前平台使用的行终止符,win下为"\t\n",Linux下为"\n"
23 print(os.pathsep)  # 输出用于分割文件路径的字符串 win下为;,Linux下为:
24 print(os.name)  # 输出字符串指示当前使用平台。win->'nt'; Linux->'posix'
25 print(os.environ)  # 获取系统环境变量
26 
27 
28 # 和操作系统命令相关
29 print(os.system('dir'))  # 运行shell命令,直接显示
30 ret = os.popen('dir')  # 运行shell命令,获取执行结果
31 print(ret.read())
32 
33 
34 # 和系统路径相关
35 print(os.path)
36 print(os.path.abspath('name3'))  # 返回path规范化的绝对路径 os.path.split(path) 将path分割成目录和文件名二元组返回
37 print(os.path.dirname(r'C:\Users\panhw\Desktop\学习文档\python\day20\name3'))  # 返回path的目录。其实就是os.path.split(path)的第一个元素
38 print(os.path.split(r'C:\Users\panhw\Desktop\学习文档\python\day20\name3'))  # 返回path最后的文件名。如何path以/或\结尾,那么就会返回空值。
39 print(os.path.basename(r'C:\Users\panhw\Desktop\学习文档\python\day20\name3'))  # 即os.path.split(path)的第二个元素
40 print(os.path.exists(r'C:\Users\panhw\Desktop\学习文档\python\day9.py'))  #  如果path存在,返回True;如果path不存在,返回False
41 print(os.path.isabs(r'C:\Users\panhw\Desktop\学习文档\python\day9.py'))  # 如果path是绝对路径,返回True
42 print(os.path.isfile(r'C:\Users\panhw\Desktop\学习文档\python\day9.py'))  # 如果path是一个存在的文件,返回True。否则返回False
43 print(os.path.isdir(r'C:\Users\panhw\Desktop\学习文档\python\day9.py'))  # 如果path是一个存在的目录,则返回True。否则返回False
44 print(os.path.join(r'C:\Users\panhw\Desktop', '学习文档', 'python', 'day9.py'))  # 将多个路径组合后返回,第一个绝对路径之前的参数将被忽略
45 print(os.path.getsize(r'C:\Users\panhw\Desktop\学习文档\python\day9.py'))  # 返回path的大小
46 print(os.path.getatime(r'C:\Users\panhw\Desktop\学习文档\python\day9.py'))  # 返回path所指向的文件或者目录的最后访问时间
47 print(os.path.getmtime(r'C:\Users\panhw\Desktop\学习文档\python\day9.py'))  # 返回path所指向的文件或者目录的最后修改时间

View Code

 

 

专注:os.stat(‘path/filename’)  获取文件/目录音信 的布局表达

  stat 结构:

  st_mode: inode 保护模式
  st_ino: inode 节点号。
  st_dev: inode 驻留的设备。
  st_nlink: inode 的链接数。
  st_uid: 所有者的用户ID。
  st_gid: 所有者的组ID。
  st_size: 普通文件以字节为单位的大小;包含等待某些特殊文件的数据。
  st_atime: 上次访问的时间。
  st_mtime: 最后一次修改的时间。
  st_ctime: 由操作系统报告的"ctime"。
  在某些系统上(如Unix)是最新的元数据更改的时间,在其它系统上(如Windows)是创建时间(详细信息参见平台的文档)。

 

体系化模块

 

 

  什么叫连串化——将原先的字典、列表等内容转换来贰个字符串的长河就称为序列化

 

  体系化的目标

 

    一 、以某种存款和储蓄格局使自定义对象持久化;

 

    贰 、将对象从二个地点传递到另三个地方。

 

    ③ 、使程序更具维护性。

 

金沙注册送58 53

 

 

通俗点说——-将原来的字典、列表等内容转换到贰个字符串的历程就叫做序列化

2. random模块

 1 import random
 2 # ----------------------------
 3 # 1.随机小数,发红包可用
 4 print(random.random()) #0到1之间的随机小数
 5 print(random.uniform(1,3))  #大于1且小于3的随机小数
 6 
 7 # ----------------------------
 8 # 2.随机整数,验证码可用
 9 print(random.randint(1,5)) #大于1且小于等于5之间的整数
10 print(random.randrange(1,10,2))  #大于等于1且小于3之间的整数(且是所有的奇数)
11 
12 # ----------------------------
13 # 3.随机选择一个返回,抽奖
14 print(random.choice([1,'23',[4,5]]))
15 # ----------------------------
16 # 4.随机选择返回多个,一次抽取多个
17 print(random.sample([1,'23',[4,5]],2))  #列表元素任意两个组合输出,后缀为输出个数
18 # ----------------------------
19 
20 
21 # ----------------------------
22 # 5.打乱列表顺序,洗牌
23 item=[1,5,2,3,4]
24 random.shuffle(item)  #打乱次序
25 print(item)

运用随意数随机生成伍人验证码:

金沙注册送58 54金沙注册送58 55

import random
def ver_code(num):
    strs = ''
    lis1 = [chr(i) for i in range(65, 91)]
    lis2 = [str(i) for i in range(10)]
    ver1 = random.sample(lis1+lis2,num)
    for i in ver1:
        strs += i
    return strs

print(ver_code(6))

View Code

金沙注册送58 56金沙注册送58 57

def id_code(num):  # num 字母在每一位被取到的概率相同
    ret = ''
    for i in range(num):
        number = str(random.randint(0,9))
        alph_num = random.randint(97,122)   # A65 a97 +25
        alph_num2 = random.randint(65,90)   # A65 a97 +25
        alph = chr(alph_num)
        alph2 = chr(alph_num2)
        choice = random.choice([alph,alph2])
        choice = random.choice([number,choice])
        ret += choice
    return ret
print(id_code(6))

View Code

选拔随机数完毕三个发红包的编制程序

金沙注册送58 58金沙注册送58 59

import random
inp_money = float(input('红包金额:'))
inp_count = int(input('红包个数:'))
def red_packet(money, count):
    li = []
    money = int(money*100)
    money_site = random.sample(range(1, money), count-1)
    money_site.extend([0, money])
    money_site = sorted(money_site)
    for i in range(count):
        li.append(round((money_site[i+1]-money_site[i])*0.01, 2))
    return li
    # 上面的定义li列表、for循环以及return 可以简写成下面一行。
    # return [round((sorted(money_site)[i + 1] - sorted(money_site)[i]) * 0.01, 2) for i in range(count)]
ret = red_packet(inp_money, inp_count)
print(ret)

View Code

应用自由数随机生成2个人验证码,并带模糊效果

from PIL import Image, ImageDraw, ImageFont, ImageFilter

import random

# 随机字母:
def rndChar():
    return chr(random.randint(48, 57))

# 随机颜色1:
def rndColor():
    return (random.randint(64, 255), random.randint(64, 255), random.randint(64, 255))

# 随机颜色2:
def rndColor2():
    return (random.randint(32, 127), random.randint(32, 127), random.randint(32, 127))

# 240 x 60:
width = 60 * 4
height = 60
image = Image.new('RGB', (width, height), (255, 255, 255))
# 创建Font对象:
font = ImageFont.truetype('ariblk.ttf', 40)
# 创建Draw对象:
draw = ImageDraw.Draw(image)
# 填充每个像素:
for x in range(width):
    for y in range(height):
        draw.point((x, y), fill=rndColor())
# 输出文字:
for t in range(4):
    draw.text((60 * t + 10, 10), rndChar(), font=font, fill=rndColor2())
# 模糊:
image = image.filter(ImageFilter.BLUR)
image.save('code.jpg', 'jpeg')

json

 

  Json模块提供了七个功用:dumps、dump、loads、load

 

金沙注册送58 60金沙注册送58 61

 1 import json
 2 dic = {'k1': 'v1', 'k2': 'v2', 'k3': 'v3', 'k4': 'v4'}
 3 str_dic = json.dumps(dic)  # 序列化:将一个字典转换成一个字符串
 4 print(str_dic, type(str_dic))
 5 # 注意,json转换完的字符串类型的字典中的字符串是由""表示的
 6 
 7 dic2 = json.loads(str_dic)  # 反序列化:将一个字符串格式的字典转换成一个字典
 8 print(dic2, type(dic2))
 9 #注意,要用json的loads功能处理的字符串类型的字典中的字符串必须由""表示
10 
11 list_dic = [1, ['a', 'b', 'c'], 3, {'k1': 'v1', 'k2': 'v2'}]
12 str_dic = json.dumps(list_dic)  # 也可以处理嵌套的数据类型
13 print(type(str_dic), str_dic)
14 
15 list_dic2 = json.loads(str_dic)
16 print(type(list_dic2), list_dic2)

dumps/loads

 

金沙注册送58 62金沙注册送58 63

 1 import json
 2 f = open('json_file', 'w', encoding='utf8')
 3 dic = {'k1': 'v1', 'k2': 'v2', 'k3': 'v3'}
 4 json.dump(dic, f)  # dump方法接收一个文件句柄,直接将字典转换成json字符串写入文件
 5 f.close()
 6 
 7 f = open('json_file')
 8 dic2 = json.load(f)  # load方法接收一个文件句柄,直接将文件中的json字符串转换成数据结构返回
 9 f.close()
10 print(type(dic2), dic2)

dump/load

金沙注册送58 64金沙注册送58 65

 1 import json
 2 f = open('file', 'w', encoding='utf8')
 3 json.dump({'国籍': '中国'}, f)
 4 ret = json.dumps({'国籍': '中国'})
 5 f.write(ret + '\n')
 6 
 7 json.dump({'国籍': '美国'}, f, ensure_ascii=False)
 8 ret = json.dumps({'国籍': '美国'}, ensure_ascii=False)
 9 f.write(ret + '\n')
10 f.close()

View Code

金沙注册送58 66金沙注册送58 67

3. OS模块(是与操作系统交互的3个接口)

#
有的文本恐怕转义大概会并发难点,一般要在双引号前加r,废除转义,只怕用双斜杠表示

# 和当前执行的python文件工作目录相关的工作路径
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.popen(“bash
command).read() 
运行shell命令,获取执行结果,可看懂,如os.popen(‘dir’).read()

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的大小,文件夹的大小不准确,只显示最大值4096字节,文件准确

ret = os.path.join('F:\每天视频以及笔记','day5视频')
print(ret)
---F:\每天视频以及笔记\day5视频    # 组合成一个完整路径

设想怎样计算文件夹中颇具文件大小?示例路径:F:\每一天录像以及笔记\python11期day01

金沙注册送58 68金沙注册送58 69

import os
def ram(file_name):
    sum = 0
    for file in os.listdir(file_name):
        path = os.path.join(file_name, file)  # 组合成一个完整路径
        if os.path.isfile(path):   # 路径下是文件
            sum += os.path.getsize(path)
        else:
            sum += ram(path)
    return sum

print(ram('F:\每天视频以及笔记\python11期day01'))

选取递归思想

金沙注册送58 70金沙注册送58 71

import os
def get_size(path):
    l = [path]
    sum_size = 0
    while l:
        path = l.pop()    # l = ['D:\python11\day2','D:\python11\day3'...]
        for item in os.listdir(path):    #path = 'D:\python11'
            path2 = os.path.join(path, item)   # path2 = 'D:\python11\day2'
            if os.path.isfile(path2):
                sum_size += os.path.getsize(path2)   # sum = 文件的大小 + 0
            else:                           
                l.append(path2)
    return sum_size
print(get_size('D:\python11'))

栈的合计

  #
复制文件的函数在os模块中并不存在,因为复制文件并非由操作系统提供的连串调用。不过大家能够调用shuti模块中的copyfile()完成,该模块也等于os模块的二个填补。

pickle

 

用以种类化的五个模块

 

 

 

  • json,用于字符串 和 python数据类型间开展转换
  • pickle,用于python特有的类型 和 python的数据类型间开始展览转换

 

 

 

pickle模块提供了四个职能:dumps、dump(种类化,存)、loads(反种类化,读)、load
 (不仅能够体系化字典,列表…能够把python中自由的数据类型体系化

 

金沙注册送58 72金沙注册送58 73

 1 import pickle
 2 dic = {'k1': 'v1', 'k2': 'v2', 'k3': 'v3'}
 3 str_dic = pickle.dumps(dic)
 4 print(str_dic, type(str_dic))  # 一串二进制内容
 5 
 6 dic2 = pickle.loads(str_dic)
 7 print(dic2, type(dic2))  # 字典
 8 
 9 import time
10 struct_time = time.localtime(1000000000)
11 print(struct_time)
12 f = open('pickle_file', 'wb')
13 pickle.dump(struct_time, f)
14 f.close()
15 
16 f = open('pickle_file', 'rb')
17 struct_time2 = pickle.load(f)
18 print(struct_time2.tm_year)
19 f.close()

pickle

 

一旦大家将叁个字典恐怕类别化成了1个json存在文件里,那么java代码也许js代码也得以拿来用。
但是即便大家用pickle举行系列化,其余语言就不可能读懂那是怎样了~
就此,假诺您系列化的故事情节是列表恐怕字典,咱们卓绝推荐你使用json模块
但只要由于某种原因你只好种类化别的的数据类型,近期后您还会用python对那些数据开始展览反体系化的话,那么就可以使用pickle

 

比如,我们在python代码中计算的一个数据需要给另外一段程序使用,那我们怎么给?
现在我们能想到的方法就是存在文件里,然后另一个python程序再从文件里读出来。
但是我们都知道,对于文件来说是没有字典这个概念的,所以我们只能将数据转换成字典放到文件中。
你一定会问,将字典转换成一个字符串很简单,就是str(dic)就可以办到了,为什么我们还要学习序列化模块呢?
没错序列化的过程就是从dic 变成str(dic)的过程。现在你可以通过str(dic),将一个名为dic的字典转换成一个字符串,
但是你要怎么把一个字符串转换成字典呢?
聪明的你肯定想到了eval(),如果我们将一个字符串类型的字典str_dic传给eval,就会得到一个返回的字典类型了。
eval()函数十分强大,但是eval是做什么的?e官方demo解释为:将字符串str当成有效的表达式来求值并返回计算结果。
BUT!强大的函数有代价。安全性是其最大的缺点。
想象一下,如果我们从文件中读出的不是一个数据结构,而是一句"删除文件"类似的破坏性语句,那么后果实在不堪设设想。
而使用eval就要担这个风险。
所以,我们并不推荐用eval方法来进行反序列化操作(将str转换成python中的数据结构)

4. sys模块(sys模块是与python解释器交互的一个接口)

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       返回操作系统平台名称

shelve

 

  shelve也是python提须求大家的种类化学工业具,比pickle用起来更简便一些。
  shelve只提须求我们二个open方法,是用key来访问的,使用起来和字典类似。

 

金沙注册送58 74金沙注册送58 75

1 import shelve
2 f = shelve.open('shelve_file')
3 f['key'] = {'int': 10, 'float': 9.5, 'string': 'sample data'}  # 直接对文件句柄操作,就可以存入数据
4 f.close()
5 
6 f1 = shelve.open('shelve_file')  # 取出数据的时候也只需要直接用key获取即可,但是如果key不存在会报错
7 existing = f1['key'] 
8 f1.close()
9 print(existing)

shelve

金沙注册送58 , 

  那些模块有个限制,它不帮助八个利用同权且间往同2个DB举行写操作。所以当大家理解我们的应用倘诺只实行读操作,我们得以让shelve通过只读格局打开DB

 

金沙注册送58 76金沙注册送58 77

1 import shelve
2 f = shelve.open('shelve_file', flag='r')
3 existing = f['key']
4 f.close()
5 print(existing)

shelve只读

 

  由于shelve在暗中同意情形下是不会记录待持久化对象的别的改动的,所以咱们在shelve.open()时候须要修改私下认可参数,不然对象的改动不会保留

金沙注册送58 78金沙注册送58 79

 1 import shelve
 2 f1 = shelve.open('shelve_file')
 3 print(f1['key'])
 4 f1['key']['new_value'] = 'this was not here before'
 5 f1.close()
 6 
 7 f2 = shelve.open('shelve_file', writeback=True)
 8 print(f2['key'])
 9 f2['key']['new_value'] = 'this was not here after'
10 f2.close()

writeback=True

  writeback格局有亮点也有通病。优点是缩短了笔者们失误的票房价值,并且让对象的持久化对用户越发的透明了;但这种措施并不是有所的意况下都亟待,首先,使用writeback今后,shelf在open()的时候会增多额外的内部存款和储蓄器消耗,并且当DB在close()的时候会将缓存中的每贰个对象都写入到DB,那也会带来额外的等待时间。因为shelve没有办法知道缓存中如何对象修改了,哪些对象没有改动,因而有所的靶子都会被写入。

常用模块二 

hashlib模块

干什么要有连串化

5.体系化模块 

序列化

把对象(变量)从内部存款和储蓄器中成为可存款和储蓄或传输的进度称之为体系化,在Python中叫pickling,在其他语言中也被称之为serialization,marshalling,flattening等等,都以贰个意思。

体系化目标

  • 持续化某种情形。在断电可能关机从前能够将日前内部存款和储蓄器中全体的多寡保存下来,下次程序运营时得以从脚下封存的文本内容继续执行。
  • 跨平台数据交互。

体系化有三个模块json和pickle,shelve

  json   全数编程语言都通用的系列化格式,不过它帮助的数据类型格外有限(只支持数字,字符串,体系,字典等,不帮忙元祖

  pickle  只可以在python语言的次第之间传递数据使用,它援救python中有所数据类型

  shelve  在py3之后才有,python专有的连串化模块,只针对文件。它只提供3个open方法,并且不得不用字典格局拜访内容

json

 Json模块提供了多少个效益:dumps、loads,这三个只在内存中操作数据,主要在互联网传输中使用,和四个数据类型与公事打交道

             dump、load
,那七个是一贯将目的连串化之后写入文件,它依靠于二个文件句柄

import json
dic={'k1':'v1','k2':'v2','k3':'v3'}
str_dic = json.dumps(dic) #将字典转换成字符串,转换后的字典中的元素是由双引号表示的
print(str_dic,type(str_dic))#{"k1": "v1", "k2": "v2", "k3": "v3"} <class 'str'>

dic2 = json.loads(str_dic)#将一个字符串转换成字典类型
print(dic2,type(dic2))#{'k1': 'v1', 'k2': 'v2', 'k3': 'v3'} <class 'dict'>

import json
dic={'k1':'v1','k2':'v2','k3':'v3'}
f = open('a.txt','w',encoding='utf-8')
json.dump(dic,f,ensure_ascii=False)  # 先接收要序列化的对象 再接受文件句柄
f.close()

f = open('a.txt','r',encoding='utf-8')
ret = json.load(f)
print(type(ret),ret)

 # json在写入数十次dump的时候,不可能对应履行多次load来去除数据,pickle能够

#
json如果要写入八个要素,应先将成分dumps体系化,再f.write(连串化+‘\n’)写入文件。读的时候先按行读取,再选取loads将读出来的字符串转换到相应数据类型。

pickle(能够把python中的任意数据类型类别化)

  在硬盘上囤积文件有很种种办法,文本文件只是中间一种,即便想囤积列表恐怕指标之类的内容,能够把指标转换来字符串的款式写入文本文件,可是只要要从文件中苏醒对象,则这一个就复杂化了。而python提供的pickle恰好能一气浑成这点:

# 通过pickle存储python原生对象:
import pickle
D = {'a': 1, 'b': 2}
F = open('datafile.pkl', 'wb')
pickle.dump(D, F)       # pickle.dump()可以把任意对象序列化成一个bytes,然后就可以把bytes写入文件
F.close()

# 取回字典,再用pickle模块中load函数进行一次重建
F = open('datafile.pkl', 'rb')
E = pickle.load(F)
F.close()


import pickle
file = 'wish.data'
lis = ['apple', 'banban']
f = open(file, 'wb')
pickle.dump(lis, f)
f.close()

del lis
f = open(file, 'rb')
storedlis = pickle.load(f)
print(storedlis)    # 又得到了列表

关于连串化自定义类的对象:

class A:
    def __init__(self,name,age):
        self.name=name
        self.age=age
a = A('luffy',18)
# import json
# json.dumps(a)   # 报错,说明json无法存储实例化对象
import pickle
ret = pickle.dumps(a)
print(ret)   # 打印出来的是一串字节
obj = pickle.loads(ret)
print(obj)    # 打印出对象地址
print(obj.__dict__)   # {'name': 'luffy', 'age': 18}

在load的时候,必须有所被load数据类型对应的类在内部存款和储蓄器里面

shelve(用法律专科高校讲链接)

  python专有的体系化模块,只针对文件,只提供了三个open方法,且是用key来访问的,使用起来和字典类似。

import shelve
f = shelve.open('a.txt')
f['key'] = {'int': 10, 'float': 9.5, 'string': 'Sample data'}
f['ds'] = '范围分为we分我发'
f.close()
# 直接对文件句柄进行操作,就可以存储文件,而且程序会给我们自动创建三个后缀为dir,bak,dat的文件,其中以bat结尾的文件存储的就是b字节数据类型的数据

f1 = shelve.open('a.txt')
a = f1['ds']   # 用key直接取出存储的内容,如果key不存在则会报错
f1.close()
print(a)

# 设置只读模式
f2 = shelve.open('a.txt', flag='r')
f2['key']['float'] = 3.14    # 修改结构中得值,不可以
f2['space'] = 'dwd'          # 覆盖原来的结构,可以
f1.close()

f3 = shelve.open('a.txt')
b = f3['key']['float']       # 对结构的值作修改,但是失败了
f3.close()
print(b)    # 9.5

算法介绍

Python的hashlib提供了广大的摘要算法,如MD5,SHA1等等。

什么是摘要算法呢?摘要算法又称哈希算法、散列算法。它通过二个函数,把自由长度的数目转换为2个长短固定的数据串(常常用16进制的字符串表示)。

摘要算法正是透过摘要函数f()对轻易长度的数量data计算出稳定长度的摘要digest,目标是为着发现原来数据是不是被人篡改过。

摘要算法之所以能建议数据是还是不是被篡改过,正是因为摘要函数是贰个单向函数,计算f(data)很简单,但由此digest反推data却分外辛苦。而且,对本来数据做一个bit的改动,都会招致总括出的摘要完全分化。

大家以广阔的摘要算法MD5为例,总计出三个字符串的MD5值:

金沙注册送58 80金沙注册送58 81

1 import hashlib
2  
3 md5 = hashlib.md5()
4 md5.update('how to use md5 in python hashlib?')
5 print md5.hexdigest()
6 
7 计算结果如下:
8 d26a53750bc40b38b65a520292f69306

md5

假诺数据量不小,能够分块多次调用update(),最后计算的结果是平等的:

金沙注册送58 82金沙注册送58 83

1 import hashlib
2  
3 sha1 = hashlib.sha1()
4 sha1.update('how to use sha1 in ')
5 sha1.update('python hashlib?')
6 print sha1.hexdigest()

分组MD5

SHA1的结果是160
bit字节,日常用3个44位的16进制字符串代表。比SHA1更安全的算法是SHA256和SHA512,不过越安全的算法越慢,而且摘要长度更长。

体系化的目标

6.hashlib模块

  摘要算法,也称哈希算法,它能将字符串转成数字,不一致的字符串转成的数字肯定差异,常常用16进制表示。无论在哪台机器上,在怎么样时候总计,对同样的字符串结果总是一样的

  任何摘要算法都以把最佳多的多寡集合映射到三个少于的联谊中。由此几个不等的数量经过有个别摘要算法也说不定获得相同的摘要,这种气象被称作碰撞

用处:

  密文验证的时候加密

  文件的一致性校验

# md5算法:产业界通用算法

#
sha算法:安全周密更高,它有很多样(sha1,sha2,sha3等),前边数字越大,安全全面越高,且取得的数字结果越长,总结时间越长。它的用法和md5相同,只需把md5换来sha1即可。

密文验证的时候加密:

# hashhlib基本用法
import hashlib
m = hashlib.md5()                     # 创建了一个md5算法对象
m.update('aptx4869'.encode('utf-8'))  # 必须将字符串转换成utf-8格式
print(m.hexdigest())                  # 固定格式
# 6d1ce7aa0a1d988dc96a2abcd187b45a

import hashlib
m = hashlib.md5()
m.update('apt'.encode('utf-8'))   # 对源码进行拆分加密,得到的结果与整体加密一致
m.update('x4869'.encode('utf-8'))
print(m.hexdigest())
# 6d1ce7aa0a1d988dc96a2abcd187b45a
# 一段字符串直接进行摘要和分成几段摘要的结果是相同的


# 如果数字过于简单,就可以根据密文进行暴力破解获得源码,安全性不是太好,因此可以采用加盐的方式加密
# 加盐:在源码的基础上提前加一层静态码‘aptx4869’进行二次加密
m3 = hashlib.md5('aptx4869'.encode('utf-8'))
m3.update('123456'.encode('utf-8'))
print(m3.hexdigest())
# 21a36cc3275d352d92ee741b5425c330

# 这种方式较第一种比较安全性有所提高

# 动态加盐: 对于用户登录,可以通过相应的用户登录名进行一次加密,用密码二次加密,密码随着用户账户的变化而变化
username = 'Learning'
password = 'aptx4869'
m4 = hashlib.md5(username.encode('utf-8'))
m4.update(password .encode('utf-8'))
print(m4.hexdigest())
# b9112f155c08b48bba0e595236facc40

# 这种方式安全性大大的有所提高,登陆过程建议使用 

文本的一致性校验:(用来证实文件内容是或不是被曲解)

# 该函数一次性全部交验,如果文件较大,则耗时较大
import hashlib
def check(filename):
    md5obj = hashlib.md5()
    with open(filename,'rb') as f:
            content = f.read()
            md5obj.update(content)
    return md5obj.hexdigest()

# 该函数对于较大的文件,一次性以一定的字节数读取验证来验证一致性
def check(filename):
    md5obj = hashlib.md5()
    with open(filename,'rb') as f:
        while True:
            content = f.read(1024)  
            if content:
                md5obj.update(content)
            else:    # 如果文件为空
                break
    return md5obj.hexdigest()


ret1 = check('file1.txt')     
ret2 = check('file2.txt')
print(ret1)
print(ret2)   

那么问题来了,怎么着表明多少个公文的一致性呢?

金沙注册送58 84金沙注册送58 85

import hashlib
def compare(filename1,filename2):
    md5sum = []
    for file in [filename1,filename2]:
        md5 = hashlib.md5()
        with open(file,'rb') as f:
            while True:
                content = f.read(1024)
                if content:
                    md5.update(content)
                else:break
            md5sum.append(md5.hexdigest())
    if md5sum[0] == md5sum[1]:return True
    else :return False

print(compare('f1','f2'))

View Code

金沙注册送58 86金沙注册送58 87

import hashlib
def loc(filname1, filname2):
    def check(filename):
        md5obj = hashlib.md5()
        with open(filename,'rb') as f:
            while True:
                content = f.read(5)
                if content:
                    md5obj.update(content)
                else:    # 非空
                    break
        return md5obj.hexdigest()
    if  check(filname1) == check(filname2):
        return True
    else:
        return False

print(loc('a.txt', 'a1.txt'))

View Code

摘要算法应用

别的允许用户登录的网站都会存款和储蓄用户登录的用户名和口令。如何存储用户名和口令呢?方法是存到数据库表中:

name    | password
--------+----------
michael | 123456
bob     | abc999
alice   | alice2008

一经以公开保存用户口令,假设数据库败露,全体用户的口令就落入黑客的手里。别的,网站运行职员是能够访问数据库的,也正是能博获得全部用户的口令。正确的保存口令的点子是不存款和储蓄用户的公开口令,而是存款和储蓄用户口令的摘要,比如MD5:

username | password
---------+---------------------------------
michael  | e10adc3949ba59abbe56e057f20f883e
bob      | 878ef96e86145580c38c87f0410ad153
alice    | 99b1c2188db85afee403b1536010c2c9

考虑这么个情景,很多用户喜爱用123456,888888,password这几个回顾的口令,于是,黑客能够优先总括出那个常用口令的MD5值,得到2个反推表:

'e10adc3949ba59abbe56e057f20f883e': '123456'
'21218cca77804d2ba1922c33e0151105': '888888'
'5f4dcc3b5aa765d61d8327deb882cf99': 'password'

如此,无需破解,只必要比较数据库的MD5,黑客就赢得了采纳常用口令的用户账号。

对此用户来讲,当然绝不采纳过度简短的口令。可是,我们是还是不是在程序设计上对简易口令抓牢爱慕呢?

是因为常用口令的MD5值很简单被总括出来,所以,要保管存款和储蓄的用户口令不是那一个已经被总计出来的常用口令的MD5,这一艺术通过对原始口令加一个错落有致字符串来落到实处,俗称“加盐”:

hashlib.md5("salt".encode("utf8"))

由此Salt处理的MD5口令,只要Salt不被黑客知道,就算用户输入简单口令,也很难通过MD5反推明文口令。

而是一旦有四个用户都施用了一致的简便口令比如123456,在数据库中,将积存两条相同的MD5值,这注明那七个用户的口令是相同的。有没有点子让动用同样口令的用户存款和储蓄分歧的MD5呢?

万一假诺用户不可能修改登录名,就能够透过把登录名作为Salt的一局地来计量MD5,从而达成平等口令的用户也蕴藏不一致的MD5。

摘要算法在重重地点都有常见的利用。要注意摘要算法不是加密算法,不能够用来加密(因为非常小概通过摘要反推明文),只能用来防篡改,不过它的单向计算性情决定了能够在不存款和储蓄明文口令的状态下验证用户口令。

 

logging模块

① 、以某种存款和储蓄格局使自定义目的持久化;

7.configparser

在布署文件里必须有分组(节),分组的组名能够不管起
,可以分包3个或多少个组,能够叫DEFAULT,它都具备尤其的含义(暗许的是全局变量)

# 创建ini文件
import configparser
config = configparser.ConfigParser()
config["DEFAULT"] = {'luffy':'香蕉人',
                     'zero':'三把刀',
                     'sanzhi':'秋刀鱼'}
config['name'] = {'rojie':'onepiece',
                  'BB':'c',
                  'dd':'N'}
# config['www.onepiece.online'] = {'我就试试集合行不行'}  # 报错,只能是字典形式
config['www.onepiece.online'] = {'我就试试集合行不行':'不行啊'}
with open('one.ini', 'w') as f:
   config.write(f)

 写入后内容格局(那里笔者是平昔用电脑自带的文本阅读器打开的,私下认可是gbk格式,用任何阅读器非gbk会发生乱码):

[DEFAULT]
zero = 三把刀
sanzhi = 秋刀鱼
luffy = 香蕉人

[name]
dd = N
bb = c
rojie = onepiece

[www.onepiece.online]
自小编就试试集合能够还是不能够 = 不行啊

增加和删除改操作

# 增删改操作
import configparser
config=configparser.ConfigParser()
config.read('one.ini')
# 删除节'name'
config.remove_section('name')
# 删除节下的某个value值
config.remove_option('www.onepiece.online','我就试试集合行不行')
# 判断是否存在某个标题
print(config.has_section('name'))
# 判断标题section1下是否有user
print(config.has_option('www.onepiece.online','我就试试集合行不行'))
# 添加一个标题
config.add_section('EGG')
#在标题EGG下添加name=egon,age=18的配置
config.set('EGG','name','egon')
config.set('EGG','age','18')

总结:

# section  能够间接操作他的对象来赢得具有的节音信

# option  可以经过找到的节来查看全数的项

函数式简单布署

import logging  
logging.debug('debug message')  
logging.info('info message')  
logging.warning('warning message')  
logging.error('error message')  
logging.critical('critical message') 

暗中认可景况下Python的logging模块将日志打字与印刷到了正规化输出中,且只突显了过量等于WALacrosseNING级其余日记,那表达暗中认可的日志级别设置为WA翼虎NING(日志级别阶段C奥迪Q3ITICAL
> E瑞鹰RO奇骏 > WA景逸SUVNING > INFO >
DEBUG),暗中同意的日志格式为日志级别:Logger名称:用户输出音信。

利落布置日志级别,日志格式,输出地方:

金沙注册送58 88金沙注册送58 89

 1 import logging  
 2 logging.basicConfig(level=logging.DEBUG,  
 3                     format='%(asctime)s %(filename)s[line:%(lineno)d] %(levelname)s %(message)s',  
 4                     datefmt='%a, %d %b %Y %H:%M:%S',  
 5                     filename='/tmp/test.log',  
 6                     filemode='w')  
 7   
 8 logging.debug('debug message')  
 9 logging.info('info message')  
10 logging.warning('warning message')  
11 logging.error('error message')  
12 logging.critical('critical message')

一言以蔽之的日志

配置参数:

logging.basicConfig()函数中可通过具体参数来更改logging模块默认行为,可用参数有:

filename:用指定的文件名创建FiledHandler,这样日志会被存储在指定的文件中。
filemode:文件打开方式,在指定了filename时使用这个参数,默认值为“a”还可指定为“w”。
format:指定handler使用的日志显示格式。
datefmt:指定日期时间格式。
level:设置rootlogger(后边会讲解具体概念)的日志级别
stream:用指定的stream创建StreamHandler。可以指定输出到sys.stderr,sys.stdout或者文件(f=open(‘test.log’,’w’)),默认为sys.stderr。若同时列出了filename和stream两个参数,则stream参数会被忽略。

format参数中可能用到的格式化串:
%(name)s Logger的名字
%(levelno)s 数字形式的日志级别
%(levelname)s 文本形式的日志级别
%(pathname)s 调用日志输出函数的模块的完整路径名,可能没有
%(filename)s 调用日志输出函数的模块的文件名
%(module)s 调用日志输出函数的模块名
%(funcName)s 调用日志输出函数的函数名
%(lineno)d 调用日志输出函数的语句所在的代码行
%(created)f 当前时间,用UNIX标准的表示时间的浮 点数表示
%(relativeCreated)d 输出日志信息时的,自Logger创建以 来的毫秒数
%(asctime)s 字符串形式的当前时间。默认格式是 “2003-07-08 16:49:45,896”。逗号后面的是毫秒
%(thread)d 线程ID。可能没有
%(threadName)s 线程名。可能没有
%(process)d 进程ID。可能没有
%(message)s用户输出的消息

二 、将目的从一个地点传递到另几个地方。

8.logging  (记录日志的模块)

  不会帮你活动抬高日志的始末,只可以根据程序员写的代码达成功效

  能够透过一个参数去决定全局的日记输出情状

  能够协助开发者同时向文件和显示器输出内容

  logging模块提供5中国和日本记级别,从低到高3回:debug info warning error
critical

  默许是从warning情势起先彰显

日志级别
CRITICAL = 50  #FATAL = CRITICAL
ERROR = 40
WARNING = 30  #WARN = WARNING
INFO = 20
DEBUG = 10

默许级别为warning,它会暗中认可打字与印刷在终点上

粗略用法:basicconfig

# 默认情况下 只显示警告(warning)及警告级别以上信息
import logging
logging.basicConfig(level=logging.DEBUG,format='%(asctime)s %(filename)s[line:%(lineno)d] %(levelname)s %(message)s',datefmt='%a, %d %b %y %H:%M:%S',filename = 'userinfo.log')

logging.debug('debug message')       # debug 调试模式 级别最低
logging.info('info message')         # info  显示正常信息
logging.warning('warning message')   # warning 显示警告信息
logging.error('error message')       # error 显示错误信息
logging.critical('critical message') # critical 显示严重错误信息

---WARNING:root:warning message
---ERROR:root:error message
---CRITICAL:root:critical message
---WARNING:root:warning message

logging.basicconfig()函数可配参数:

金沙注册送58 90金沙注册送58 91

filename:用指定的文件名创建FiledHandler,这样日志会被存储在指定的文件中。
filemode:文件打开方式,在指定了filename时使用这个参数,默认值为“a”还可指定为“w”。
format:指定handler使用的日志显示格式。 
datefmt:指定日期时间格式。 
level:设置rootlogger(后边会讲解具体概念)的日志级别 
stream:用指定的stream创建StreamHandler。可以指定输出到sys.stderr,sys.stdout或者文件,默认为sys.stderr。若同时列出了filename和stream两个参数,则stream参数会被忽略。

#格式
%(name)s:Logger的名字,并非用户名,详细查看

%(levelno)s:数字形式的日志级别

%(levelname)s:文本形式的日志级别

%(pathname)s:调用日志输出函数的模块的完整路径名,可能没有

%(filename)s:调用日志输出函数的模块的文件名

%(module)s:调用日志输出函数的模块名

%(funcName)s:调用日志输出函数的函数名

%(lineno)d:调用日志输出函数的语句所在的代码行

%(created)f:当前时间,用UNIX标准的表示时间的浮 点数表示

%(relativeCreated)d:输出日志信息时的,自Logger创建以 来的毫秒数

%(asctime)s:字符串形式的当前时间。默认格式是 “2003-07-08 16:49:45,896”。逗号后面的是毫秒

%(thread)d:线程ID。可能没有

%(threadName)s:线程名。可能没有

%(process)d:进程ID。可能没有

%(message)s:用户输出的消息

View Code

logging模块组件:

# Logger 产生日志对象
# Handler 接收日志然后控制打印到不同地方:
#     FileHandler用来打印到文件中,
#     StreamHandler用来打印到终端
# Filter 过滤日志对象
# Formatter 指定日志显示格式

logger对象配置:

import logging
logger = logging.getLogger()    # Logger用于产生日志,实例化一个logger对象
# Handler对象:接收logger传来的日志,并控制输出
fh = logging.FileHandler('test.log',encoding='utf-8')
# 实例化一个文件句柄,并打印到文件
ch = logging.StreamHandler()
# 打印到终端,没有这步则只在文件中打印,在终端不显示,终端就是电脑输出界面
fmt = logging.Formatter('%(asctime)s-%(name)s-%(levelname)s-%(message)s')
# 定制化显示格式
fh.setFormatter(fmt)
ch.setFormatter(fmt)
# 为Handler对象绑定格式

logger.addHandler(fh)
logger.addHandler(ch)
# 和logger关联的只有文件句柄
logger.setLevel(logging.WARNING)
# 对象警告级别,从该级别以上开始警报
# 这里我是直接给对象设置的该级别,意味着文件和终端都是同一级别,这里可以
# 对文件和终端分别设置不同的级别

logger.debug('debug message')       # debug 调试模式 级别最低
logger.info('info message')         # info  显示正常信息
logger.warning('warning message')   # warning 显示警告信息
logger.error('error message')       # error 显示错误信息
logger.critical('critical message')

logger对象配置

金沙注册送58 92金沙注册送58 93

 1 import logging
 2 
 3 logger = logging.getLogger()
 4 # 创建一个handler,用于写入日志文件
 5 fh = logging.FileHandler('test.log')
 6 
 7 # 再创建一个handler,用于输出到控制台
 8 ch = logging.StreamHandler()
 9 # 格式化输出或写入信息
10 formatter = logging.Formatter('%(asctime)s - %(name)s - %(levelname)s - %(message)s')
11 # 文件流绑定格式
12 fh.setFormatter(formatter)
13 # 屏幕流绑定格式
14 ch.setFormatter(formatter)
15 
16 logger.addHandler(fh) #logger对象可以添加多个fh和ch对象
17 logger.addHandler(ch)
18 
19 logger.debug('logger debug message')
20 logger.info('logger info message')
21 logger.warning('logger warning message')
22 logger.error('logger error message')
23 logger.critical('logger critical message')

logging对象配置

logging库提供了七个零部件:Logger、Handler、Filter、Formatter。Logger对象提供应用程序可径直行使的接口,Handler发送日志到非常的目标地,Filter提供了过滤日志音信的办法,Formatter钦点日志展现格式。其它,能够由此:logger.setLevel(logging.Debug)设置级别,当然,也得以通过

fh.setLevel(logging.Debug)单对文本流设置有些级别。

 

configparser模块

该模块适用于配置文件的格式与windows
ini文件类似,能够蕴含一个或三个节(section),各类节能够有多个参数(键=值)。

③ 、使程序更具维护性。

9.collections模块

放置数据类型基础上,collections模块还提供了多少个附加数据类型:

  counter:计数器

  deque:双端排列,能够便捷从此外一侧追加对象

  namedtuple:生成能够采纳名字来做客成分内容的tuple

  orderdict:有序字典

  defaultdict:带有暗许值的字典

namedtuple:

from collections import namedtuple
point = namedtuple('point', ['x','y','z'])
p = point(1,4,9)
print(p.x)  # 1
print(p.z)  # 9

# 用来计算长方体体积
square = namedtuple('length',('x','y','z'))
v = square(5,2,8)
volume = v.x *v.y * v.z
print(volume)   # 80

deque:

  它是为了落成插入和删除操作的双向列表,适用于队列和栈

from collections import deque
lis = deque(['a','c','b'])
lis.append(3)
lis.appendleft(5)
print(lis)    # deque([5, 'a', 'c', 'b', 3])
# 这里直接用list()可以转换成列表形式

Counter:

  它的效果是用来跟踪值出现的次数,属于三个冬日,冬辰的器皿类型,以字典的键值对方式储存

着力用法:

from collections import Counter
c = Counter('abcdeabcdabcaba')
print(dict(c))    # {'e': 1, 'b': 4, 'd': 2, 'a': 5, 'c': 3}

print(c['a'])   # 5
print(c['b'])   #4

计数器的换代,包括扩展(update)和压缩(subtract)二种 

from collections import Counter

# update
c = Counter('smile')
c.update('lie')
print(c['e'])   # 2

d = Counter('beautiful')
f = Counter('bee')
d.update(f)
print(d['e'])  # 3

# subtract
c = Counter('smile')
c.subtract('lie')
print(c['e'])   # 0

d = Counter('beautiful')
f = Counter('bee')
d.subtract(f)
print(d['e'])   # -1

键的修改和删除(del)

from collections import Counter
c = Counter("abcdcba")
c['a'] = 0
print(dict(c))   # {'d': 1, 'a': 0, 'c': 2, 'b': 2}
del c['b']
print(dict(c))   # {'a': 0, 'c': 2, 'd': 1}

算数和集合操作

  +、-、&、|操作也能够用来Counter。个中&和|操作分别再次来到三个Counter对象各要素的最小值和最大值。须要留意的是,获得的Counter对象将去除小于1的因素。

c = Counter(a=8, b=1)
d = Counter(a=5, b=2)
print(dict(c+d))   # {'a': 13, 'b': 3}
print(dict(c-d))   # {'a': 3}          注意,它只保留正数计数的元素
print(dict(c&d))   # {'a': 5, 'b': 1}  求交集,min(c[x], d[x])
print(dict(c|d))   # {'b': 2, 'a': 8}  求并集,max(c[x], d[x])

Counter类常用操作

金沙注册送58 94金沙注册送58 95

sum(c.values())  # 所有计数的总数
c.clear()  # 重置Counter对象,注意不是删除,最终返回None
list(c)  # 将c中的键转为列表
set(c)  # 将c中的键转为set
dict(c)  # 将c中的键值对转为字典
c.items()  # 转为(elem, cnt)格式的列表
Counter(dict(list_of_pairs))  # 从(elem, cnt)格式的列表转换为Counter类对象
c.most_common()[:-n:-1]  # 取出计数最少的n个元素
c += Counter()  # 移除0和负值

View Code

#
总计一篇英文文章内种种单词现身频率,并再次来到出现频率最高的前13个单词及其出现次数


对[‘a’,’2′,2,4,5,’2′,’b’,4,7,’a’,5,’d’,’a’,’z’]该列表的数量举行计数总结

#
方法链接:

Orderedict

  保持key的顺序

from collections import OrderedDict
d = dict([('a', 3), ('b', 5), ('c', 3)])
print(d)  # {'b': 5, 'c': 3, 'a': 3}

d = OrderedDict([('a', 3), ('b', 5), ('c', 3)])
print(d)  # OrderedDict([('a', 3), ('b', 5), ('c', 3)])
# 给这个样子感觉作用不大啊,用dict转型过来顺序又变了

defaultdict(暗许字典,是给字典中的value值设置私下认可值)

  它最大的益处在于永远不会在您选拔key获取值的时候报错

  有如下值集合 [``11``,``22``,``33``,``44``,``55``,``66``,``77``,``88``,``99``,``90.``..],将所有大于 ``66 的值保存至字典的第一个key中,将小于 ``66 的值保存至第二个key的值中。

from collections import defaultdict

values = [11, 22, 33,44,55,66,77,88,99,90]

my_dict = defaultdict(list)

for value in  values:
    if value>66:
        my_dict['k1'].append(value)
    else:
        my_dict['k2'].append(value)
print(dict(my_dict))

 

 

 

 

 

  

 

创办理文件件

来看3个众多软件的周边文档格式如下:

[DEFAULT]
ServerAliveInterval = 45
Compression = yes
CompressionLevel = 9
ForwardX11 = yes

[bitbucket.org]
User = hg

[topsecret.server.com]
Port = 50022
ForwardX11 = no

比方想用python生成一个那样的文书档案如何是好啊?

金沙注册送58 96金沙注册送58 97

 1 import configparser
 2 
 3 config = configparser.ConfigParser()
 4 
 5 config["DEFAULT"] = {'ServerAliveInterval': '45',
 6                       'Compression': 'yes',
 7                      'CompressionLevel': '9',
 8                      'ForwardX11':'yes'
 9                      }
10 
11 config['bitbucket.org'] = {'User':'hg'}
12 
13 config['topsecret.server.com'] = {'Host Port':'50022','ForwardX11':'no'}
14 
15 with open('example.ini', 'w') as configfile:
16 
17    config.write(configfile)

View Code

金沙注册送58 98金沙注册送58 99

 1 import configparser
 2 
 3 config = configparser.ConfigParser()
 4 
 5 #---------------------------查找文件内容,基于字典的形式
 6 
 7 print(config.sections())        #  []
 8 
 9 config.read('example.ini')
10 
11 print(config.sections())        #   ['bitbucket.org', 'topsecret.server.com']
12 
13 print('bytebong.com' in config) # False
14 print('bitbucket.org' in config) # True
15 
16 
17 print(config['bitbucket.org']["user"])  # hg
18 
19 print(config['DEFAULT']['Compression']) #yes
20 
21 print(config['topsecret.server.com']['ForwardX11'])  #no
22 
23 
24 print(config['bitbucket.org'])          #<Section: bitbucket.org>
25 
26 for key in config['bitbucket.org']:     # 注意,有default会默认default的键
27     print(key)
28 
29 print(config.options('bitbucket.org'))  # 同for循环,找到'bitbucket.org'下所有键
30 
31 print(config.items('bitbucket.org'))    #找到'bitbucket.org'下所有键值对
32 
33 print(config.get('bitbucket.org','compression')) # yes       get方法Section下的key对应的value

查找文件

金沙注册送58 100金沙注册送58 101

 1 import configparser
 2 
 3 config = configparser.ConfigParser()
 4 
 5 config.read('example.ini')
 6 
 7 config.add_section('yuan')
 8 
 9 
10 
11 config.remove_section('bitbucket.org')
12 config.remove_option('topsecret.server.com',"forwardx11")
13 
14 
15 config.set('topsecret.server.com','k1','11111')
16 config.set('yuan','k2','22222')
17 
18 config.write(open('new2.ini', "w"))

增加和删除改操作

 

金沙注册送58 102

1—->>>>json

适用于分裂语言之间,协助的数据类型
  str  int   list   dict   bool 

 

金沙注册送58 103金沙注册送58 104

import json
# dic = {"alex": ('women','women','老女人')}
# dic2 = {"alex1": ('women','women','老女人')}
# dic3 = {"alex2": ('women','women','老女人')}
# with open("json-file",mode="w",encoding="utf-8")as f:
#     s1=json.dumps(dic)
#     s2=json.dumps(dic2)
#     s3=json.dumps(dic3)
#     f.write(s1+"\n")
#     f.write(s2+"\n")
#     f.write(s3+"\n")
# with open("json-file",mode="r",encoding="utf-8")as f1:
#     for line in f1:
#         print(json.loads(line))

json文件多多少操作

写入多数据用dumps 和 loads

dump一次只能读取和写入七个类别化字符串

金沙注册送58 105金沙注册送58 106

Serialize obj to a JSON formatted str.(字符串表示的json对象) 
Skipkeys:默认值是False,如果dict的keys内的数据不是python的基本类型(str,unicode,int,long,float,bool,None),设置为False时,就会报TypeError的错误。此时设置成True,则会跳过这类key 
ensure_ascii:,当它为True的时候,所有非ASCII码字符显示为\uXXXX序列,只需在dump时将ensure_ascii设置为False即可,此时存入json的中文即可正常显示。) 
If check_circular is false, then the circular reference check for container types will be skipped and a circular reference will result in an OverflowError (or worse). 
If allow_nan is false, then it will be a ValueError to serialize out of range float values (nan, inf, -inf) in strict compliance of the JSON specification, instead of using the JavaScript equivalents (NaN, Infinity, -Infinity). 
indent:应该是一个非负的整型,如果是0就是顶格分行显示,如果为空就是一行最紧凑显示,否则会换行且按照indent的数值显示前面的空白分行显示,这样打印出来的json数据也叫pretty-printed json 
separators:分隔符,实际上是(item_separator, dict_separator)的一个元组,默认的就是(‘,’,’:’);这表示dictionary内keys之间用“,”隔开,而KEY和value之间用“:”隔开。 
default(obj) is a function that should return a serializable version of obj or raise TypeError. The default simply raises TypeError. 
sort_keys:将数据根据keys的值进行排序。 
To use a custom JSONEncoder subclass (e.g. one that overrides the .default() method to serialize additional types), specify it with the cls kwarg; otherwise JSONEncoder is used.

任何参数表达

金沙注册送58 107金沙注册送58 108

import json
data = {'username':['李华','二愣子'],'sex':'male','age':16}
json_dic2 = json.dumps(data,sort_keys=True,indent=2,separators=(',',':'),ensure_ascii=False)
print(json_dic2)

json的格式化输出

 

2——>>>>pickle

 

用于类别化的八个模块

 

  • json,用于字符串 和 python数据类型间展开转移
  • pickle,用于python特有的类型 和 python的数据类型间展开转移

 

pickle模块提供了多少个效率:dumps、dump(种类化,存)、loads(反体系化,读)、load
 (不仅能够系列化字典,列表…能够把python中自由的数据类型连串化

 

 

金沙注册送58 109金沙注册送58 110

# dic = {'alex': ('women','women','老女人')}
# dic2 = {"alex1": ('women','women','老女人')}
# dic3 = {"alex2": ('women','women','老女人')}
# with open("pickle_file",mode="wb")as f:
#     pickle.dump(dic,f)
#     pickle.dump(dic2,f)
#     pickle.dump(dic3,f)
# with open("pickle_file",mode="rb")as f:
#     while 1:
#         try:
#             print(pickle.load(f))
#         except EOFError:
#             break

pickle文件多多少操作

留神:文件读写方式问btyes:

 

3—–>>>>shelve

shelve也是python提供给大家的体系化学工业具,比pickle用起来更简短一些。
shelve只提要求我们2个open方法,是用key来访问的,使用起来和字典类似。

 

金沙注册送58 111金沙注册送58 112

import shelve
f = shelve.open('shelve_file')
f['key'] = {'int':10, 'float':9.5, 'string':'Sample data'}  #直接对文件句柄操作,就可以存入数据
f.close()

import shelve
f1 = shelve.open('shelve_file')
existing = f1['key']  #取出数据的时候也只需要直接用key获取即可,但是如果key不存在会报错
f1.close()
print(existing)

View Code

 

本条模块有个限制,它不协助三个应用同近期间往同多个DB举办写操作。所以当我们领略大家的应用如若只实行读操作,大家能够让shelve通过只读格局打开DB

 

 

金沙注册送58 113金沙注册送58 114

import shelve
f = shelve.open('shelve_file', flag='r')
existing = f['key']
f.close()
print(existing)

View Code

出于shelve在暗中同意情形下是不会记录待持久化对象的任何修改的,所以大家在shelve.open()时候须求修改暗中同意参数,不然对象的改动不会保留。

 

金沙注册送58 115金沙注册送58 116

import shelve
f1 = shelve.open('shelve_file')
print(f1['key'])
f1['key']['new_value'] = 'this was not here before'
f1.close()

f2 = shelve.open('shelve_file', writeback=True)
print(f2['key'])
f2['key']['new_value'] = 'this was not here before'
f2.close()

View Code

writeback方式有独到之处也有难点。优点是削减了我们失误的可能率,并且让对象的持久化对用户越来越的晶莹了;但那种方法并不是富有的事态下都须要,首先,使用writeback未来,shelf在open()的时候会扩充额外的内部存款和储蓄器消耗,并且当DB在close()的时候会将缓存中的每贰个指标都写入到DB,那也会拉动12分的等候时间。因为shelve没有主意知道缓存中怎样对象修改了,哪些对象没有改动,由此有所的对象都会被写入。

——–>>>>hashlib<<<<——-

算法介绍

 

Python的hashlib提供了大面积的摘要算法,如MD5,SHA1等等。

 

何以是摘要算法呢?摘要算法又称哈希算法、散列算法。它通过四个函数,把自由长度的数码转换为三个尺寸固定的数据串(经常用16进制的字符串表示)。

 

摘要算法正是通过摘要函数f()对自由长度的数目data总结出稳定长度的摘要digest,指标是为着发现原来数据是或不是被人篡改过。

 

摘要算法之所以能提议数据是还是不是被篡改过,就是因为摘要函数是3个单向函数,计算f(data)很不难,但透过digest反推data却百般拮据。而且,对原来数据做2个bit的改动,都会导致计算出的摘要完全分裂。

 

咱俩以宽广的摘要算法MD5为例,总括出1个字符串的MD5值:

import hashlib

md5 = hashlib.md5()
md5.update('how to use md5 in python hashlib?')
print md5.hexdigest()

计算结果如下:
d26a53750bc40b38b65a520292f69306

 

即便数据量极大,能够分块数十次调用update(),最终总括的结果是一模一样的:

md5 = hashlib.md5()
md5.update('how to use md5 in ')
md5.update('python hashlib?')
print md5.hexdigest()

MD5是最广大的摘要算法,速度高速,生成结果是定点的128
bit字节,常常用贰个叁十四个人的16进制字符串代表。另一种常见的摘要算法是SHA1,调用SHA1和调用MD5通通类似:

import hashlib

sha1 = hashlib.sha1()
sha1.update('how to use sha1 in ')
sha1.update('python hashlib?')
print sha1.hexdigest()

SHA1的结果是160
bit字节,日常用3个四十四人的16进制字符串表示。比SHA1更安全的算法是SHA256和SHA512,可是越安全的算法越慢,而且摘要长度更长。

摘要算法应用——–

其它允许用户登录的网站都会存储用户登录的用户名和口令。怎么样存款和储蓄用户名和口令呢?方法是存到数据库表中:

金沙注册送58 117

万一以公开保存用户口令,如若数据库走漏,全部用户的口令就落入黑客的手里。其它,网站运营人士是能够访问数据库的,也正是能博取到具备用户的口令。正确的保留口令的章程是不存款和储蓄用户的公开口令,而是存款和储蓄用户口令的摘要,比如MD5:

金沙注册送58 118

考虑这么个情状,很多用户喜好用123456,888888,password那些简单的口令,于是,黑客能够优先计算出那些常用口令的MD5值,获得二个反推表:

 金沙注册送58 119

如此那般,无需破解,只须求相比较数据库的MD5,黑客就获得了利用常用口令的用户账号。

对于用户来讲,当然绝不接纳过度简短的口令。不过,大家能或不可能在程序设计上对简易口令加强保卫安全呢?

出于常用口令的MD5值很不难被总计出来,所以,要保管存款和储蓄的用户口令不是那个曾经被总计出来的常用口令的MD5,这一格局通过对原始口令加多个犬牙相错字符串来落实,俗称“加盐”:

金沙注册送58 120

透过Salt处理的MD5口令,只要Salt不被黑客知道,固然用户输入简单口令,也很难通过MD5反推明文口令。

但是一旦有多少个用户都接纳了扳平的简练口令比如123456,在数据库中,将积存两条相同的MD5值,那表达那八个用户的口令是平等的。有没有法子让使用同一口令的用户存款和储蓄差异的MD5呢?

比方要是用户不能够修改登录名,就能够透过把登录名作为Salt的一局地来总结MD5,从而完结均等口令的用户也蕴藏差异的MD5。

摘要算法在许多地方都有广泛的运用。要留意摘要算法不是加密算法,无法用于加密(因为不能够透过摘要反推明文),只好用于防篡改,可是它的单向总括性情决定了足以在不存款和储蓄明文口令的气象下验证用户口令。

顺手文件分段验证代码:

 

金沙注册送58 121金沙注册送58 122

import hashlib
def file(file_name,modes):
    ret=hashlib.md5()
    with open(file_name,mode=modes)as f:
        while 1:
            content = f.read(1024)
            if content:
                ret.update(content.encode("utf-8"))
            else:
                break
    return ret.hexdigest()
print(file("a.txt","r"))

文件分段验证

 

 configparser模块
                       

该模块适用于配置文件的格式与windows
ini文件类似,能够分包3个或四个节(section),种种节能够有四个参数(键=值)。

 

金沙注册送58 123金沙注册送58 124

"""
Django settings for webwx project.

Generated by 'django-admin startproject' using Django 1.10.3.

For more information on this file, see
https://docs.djangoproject.com/en/1.10/topics/settings/

For the full list of settings and their values, see
https://docs.djangoproject.com/en/1.10/ref/settings/
"""

import os

# Build paths inside the project like this: os.path.join(BASE_DIR, ...)
BASE_DIR = os.path.dirname(os.path.dirname(os.path.abspath(__file__)))


# Quick-start development settings - unsuitable for production
# See https://docs.djangoproject.com/en/1.10/howto/deployment/checklist/

# SECURITY WARNING: keep the secret key used in production secret!
SECRET_KEY = 'mpn^n-s-&+ckg_)gl4sp^@8=89us&@*^r1c_81#x-5+$)rf8=3'

# SECURITY WARNING: don't run with debug turned on in production!
DEBUG = True

ALLOWED_HOSTS = []


# Application definition

INSTALLED_APPS = [
    'django.contrib.admin',
    'django.contrib.auth',
    'django.contrib.contenttypes',
    'django.contrib.sessions',
    'django.contrib.messages',
    'django.contrib.staticfiles',
    'web',
]

MIDDLEWARE = [
    'django.middleware.security.SecurityMiddleware',
    'django.contrib.sessions.middleware.SessionMiddleware',
    'django.middleware.common.CommonMiddleware',
    # 'django.middleware.csrf.CsrfViewMiddleware',
    'django.contrib.auth.middleware.AuthenticationMiddleware',
    'django.contrib.messages.middleware.MessageMiddleware',
    'django.middleware.clickjacking.XFrameOptionsMiddleware',
]

ROOT_URLCONF = 'webwx.urls'

TEMPLATES = [
    {
        'BACKEND': 'django.template.backends.django.DjangoTemplates',
        'DIRS': [os.path.join(BASE_DIR, 'templates')]
        ,
        'APP_DIRS': True,
        'OPTIONS': {
            'context_processors': [
                'django.template.context_processors.debug',
                'django.template.context_processors.request',
                'django.contrib.auth.context_processors.auth',
                'django.contrib.messages.context_processors.messages',
            ],
        },
    },
]

WSGI_APPLICATION = 'webwx.wsgi.application'


# Database
# https://docs.djangoproject.com/en/1.10/ref/settings/#databases

DATABASES = {
    'default': {
        'ENGINE': 'django.db.backends.sqlite3',
        'NAME': os.path.join(BASE_DIR, 'db.sqlite3'),
    }
}


# Password validation
# https://docs.djangoproject.com/en/1.10/ref/settings/#auth-password-validators

AUTH_PASSWORD_VALIDATORS = [
    {
        'NAME': 'django.contrib.auth.password_validation.UserAttributeSimilarityValidator',
    },
    {
        'NAME': 'django.contrib.auth.password_validation.MinimumLengthValidator',
    },
    {
        'NAME': 'django.contrib.auth.password_validation.CommonPasswordValidator',
    },
    {
        'NAME': 'django.contrib.auth.password_validation.NumericPasswordValidator',
    },
]


# Internationalization
# https://docs.djangoproject.com/en/1.10/topics/i18n/

LANGUAGE_CODE = 'en-us'

TIME_ZONE = 'UTC'

USE_I18N = True

USE_L10N = True

USE_TZ = True


# Static files (CSS, JavaScript, Images)
# https://docs.djangoproject.com/en/1.10/howto/static-files/

STATIC_URL = '/static/'
STATICFILES_DIRS = (
    os.path.join(BASE_DIR,'static'),
)

View Code

 

创办理文件件
               

 看贰个过多软件的常用文书档案

金沙注册送58 125金沙注册送58 126

[DEFAULT]
ServerAliveInterval = 45
Compression = yes
CompressionLevel = 9
ForwardX11 = yes

[bitbucket.org]
User = hg

[topsecret.server.com]
Port = 50022
ForwardX11 = no

安顿文件

若是想用python生成1个如此的文档怎么办吗?

金沙注册送58 127金沙注册送58 128

import configparser

config = configparser.ConfigParser()

config["DEFAULT"] = {'ServerAliveInterval': '45',
                      'Compression': 'yes',
                     'CompressionLevel': '9',
                     'ForwardX11':'yes'
                     }

config['bitbucket.org'] = {'User':'hg'}

config['topsecret.server.com'] = {'Host Port':'50022','ForwardX11':'no'}

with open('example.ini', 'w') as configfile:

   config.write(configfile)

View Code

查找文件      
 

 

import configparser

config = configparser.ConfigParser()

#---------------------------查找文件内容,基于字典的形式

print(config.sections())        #  []

config.read('example.ini')

print(config.sections())        #   ['bitbucket.org', 'topsecret.server.com']

print('bytebong.com' in config) # False
print('bitbucket.org' in config) # True


print(config['bitbucket.org']["user"])  # hg

print(config['DEFAULT']['Compression']) #yes

print(config['topsecret.server.com']['ForwardX11'])  #no


print(config['bitbucket.org'])          #<Section: bitbucket.org>

for key in config['bitbucket.org']:     # 注意,有default会默认default的键
    print(key)

print(config.options('bitbucket.org'))  # 同for循环,找到'bitbucket.org'下所有键

print(config.items('bitbucket.org'))    #找到'bitbucket.org'下所有键值对

print(config.get('bitbucket.org','compression')) # yes       get方法Section下的key对应的value

 

增加和删除改操作
        

 

import configparser

config = configparser.ConfigParser()

config.read('example.ini')

config.add_section('yuan')



config.remove_section('bitbucket.org')
config.remove_option('topsecret.server.com',"forwardx11")


config.set('topsecret.server.com','k1','11111')
config.set('yuan','k2','22222')

config.write(open('new2.ini', "w"))

 

 

 

 

 logging模块
                                                       

函数式不难计划

 

import logging  
logging.debug('debug message')  
logging.info('info message')  
logging.warning('warning message')  
logging.error('error message')  
logging.critical('critical message') 

 

默许情形下Python的logging模块将日志打字与印刷到了正规化输出中,且只展现了过量等于WAPAJERONING级其余日记,这表明暗中认可的日志级别设置为WAEnclaveNING(日志级别阶段CHighlanderITICAL
> ESportageRO凯雷德 > WAGL450NING > INFO >
DEBUG),暗中认可的日志格式为日志级别:Logger名称:用户输出音信。

利落配置日志级别,日志格式,输出地方:

import logging  
logging.basicConfig(level=logging.DEBUG,  
                    format='%(asctime)s %(filename)s[line:%(lineno)d] %(levelname)s %(message)s',  
                    datefmt='%a, %d %b %Y %H:%M:%S',  
                    filename='/tmp/test.log',  
                    filemode='w')  

logging.debug('debug message')  
logging.info('info message')  
logging.warning('warning message')  
logging.error('error message')  
logging.critical('critical message')

logging.basicConfig()函数中可通过具体参数来更改logging模块默认行为,可用参数有:

filename:用指定的文件名创建FiledHandler,这样日志会被存储在指定的文件中。
filemode:文件打开方式,在指定了filename时使用这个参数,默认值为“a”还可指定为“w”。
format:指定handler使用的日志显示格式。
datefmt:指定日期时间格式。
level:设置rootlogger(后边会讲解具体概念)的日志级别
stream:用指定的stream创建StreamHandler。可以指定输出到sys.stderr,sys.stdout或者文件(f=open(‘test.log’,’w’)),默认为sys.stderr。若同时列出了filename和stream两个参数,则stream参数会被忽略。

format参数中可能用到的格式化串:
%(name)s Logger的名字
%(levelno)s 数字形式的日志级别
%(levelname)s 文本形式的日志级别
%(pathname)s 调用日志输出函数的模块的完整路径名,可能没有
%(filename)s 调用日志输出函数的模块的文件名
%(module)s 调用日志输出函数的模块名
%(funcName)s 调用日志输出函数的函数名
%(lineno)d 调用日志输出函数的语句所在的代码行
%(created)f 当前时间,用UNIX标准的表示时间的浮 点数表示
%(relativeCreated)d 输出日志信息时的,自Logger创建以 来的毫秒数
%(asctime)s 字符串形式的当前时间。默认格式是 “2003-07-08 16:49:45,896”。逗号后面的是毫秒
%(thread)d 线程ID。可能没有
%(threadName)s 线程名。可能没有
%(process)d 进程ID。可能没有
%(message)s用户输出的消息

logger对象配置             

 

import logging

logger = logging.getLogger()
# 创建一个handler,用于写入日志文件
fh = logging.FileHandler('test.log',encoding='utf-8') 

# 再创建一个handler,用于输出到控制台 
ch = logging.StreamHandler() 
formatter = logging.Formatter('%(asctime)s - %(name)s - %(levelname)s - %(message)s')
fh.setLevel(logging.DEBUG)

fh.setFormatter(formatter) 
ch.setFormatter(formatter) 
logger.addHandler(fh) #logger对象可以添加多个fh和ch对象 
logger.addHandler(ch) 

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

 

logging库提供了两个零件:Logger、Handler、Filter、Formatter。Logger对象提供应用程序可直接运用的接口,Handler发送日志到适合的指标地,Filter提供了过滤日志音讯的方法,Formatter钦命日志显示格式。别的,可以通过:logger.setLevel(logging.Debug)设置级别,当然,

也得以通过 
fh.setLevel(logging.Debug)单对文件流设置某个级别。

 

 金沙注册送58 129

金沙注册送58 130

金沙注册送58 131

金沙注册送58 132

 

     
                           collections模块                              
                                     

 

在放权数据类型(dict、list、set、tuple)的底子上,collections模块还提供了多少个附加的数据类型:Counter、deque、defaultdict、namedtuple和OrderedDict等。

 

1.namedtuple:
生成能够行使名字来做客元素内容的tuple

 

2.deque:
双端队列,能够长足的从此外一侧追加和推出对象

 

3.Counter: 计数器,主要用来计数

 

4.OrderedDict: 有序字典

 

5.defaultdict: 带有暗中同意值的字典

       namedtuple         

大家知道tuple能够代表不变集合,例如,三个点的二维坐标就足以象征成:

>>> p =
(1, 2)

可是,看到(1,
2),极难看出那一个tuple是用来代表2个坐标的。

这时,namedtuple就派上了用途:

>>> from collections import namedtuple
>>> Point = namedtuple('Point', ['x', 'y'])
>>> p = Point(1, 2)
>>> p.x
1
>>> p.y
2

看似的,假如要用坐标和半径表示二个圆,也得以用namedtuple定义:

 

 

#namedtuple('名称', [属性list]):
Circle = namedtuple('Circle', ['x', 'y', 'r'])

deque
                     

 

选择list存款和储蓄数据时,按索引访问元素十分的快,可是插入和删除成分就极慢了,因为list是线性存储,数据量大的时候,插入和删除效能十分的低。

 

deque是为了急速落到实处插入和删除操作的双向列表,适合用于队列和栈:

 

 

>>> from collections import deque
>>> q = deque(['a', 'b', 'c'])
>>> q.append('x')
>>> q.appendleft('y')
>>> q
deque(['y', 'a', 'b', 'c', 'x'])

deque除了落到实处list的append()pop()外,还支持appendleft()popleft(),那样就足以极度便捷地往尾部添加或删除成分。

 OrderedDict                    

 

动用dict时,Key是严节的。在对dict做迭代时,大家无能为力分明Key的依次。

借使要保全Key的顺序,能够用OrderedDict

>>> from collections import OrderedDict
>>> d = dict([('a', 1), ('b', 2), ('c', 3)])
>>> d # dict的Key是无序的
{'a': 1, 'c': 3, 'b': 2}
>>> od = OrderedDict([('a', 1), ('b', 2), ('c', 3)])
>>> od # OrderedDict的Key是有序的
OrderedDict([('a', 1), ('b', 2), ('c', 3)])

注意,OrderedDict的Key会根据插入的顺序排列,不是Key本身排序:

>>> od = OrderedDict()
>>> od['z'] = 1
>>> od['y'] = 2
>>> od['x'] = 3
>>> od.keys() # 按照插入的Key的顺序返回
['z', 'y', 'x']

defaultdict          
 

 

有如下值集合 [``11``,``22``,``33``,``44``,``55``,``66``,``77``,``88``,``99``,``90.``..],将所有大于 ``66 的值保存至字典的第一个key中,将小于 ``66 的值保存至第二个key的值中。

 

即: {``'k1'``: 大于``66 , ``'k2'``: 小于``66``}

 

金沙注册送58 133金沙注册送58 134

li = [11,22,33,44,55,77,88,99,90]
result = {}
for row in li:
    if row > 66:
        if 'key1' not in result:
            result['key1'] = []
        result['key1'].append(row)
    else:
        if 'key2' not in result:
            result['key2'] = []
        result['key2'].append(row)
print(result)

原生字典解决办法

金沙注册送58 135金沙注册送58 136

from collections import defaultdict

values = [11, 22, 33,44,55,66,77,88,99,90]

my_dict = defaultdict(list)

for value in  values:
    if value>66:
        my_dict['k1'].append(value)
    else:
        my_dict['k2'].append(value)

defaultdict消除办法

使用dict时,要是引用的Key不存在,就会抛出KeyError。倘诺愿意key不存在时,重回一个暗中认可值,就足以用defaultdict

金沙注册送58 137金沙注册送58 138

>>> from collections import defaultdict
>>> dd = defaultdict(lambda: 'N/A')
>>> dd['key1'] = 'abc'
>>> dd['key1'] # key1存在
'abc'
>>> dd['key2'] # key2不存在,返回默认值
'N/A'

例2

Counter
          

Counter类的目标是用来跟踪值出现的次数。它是一个无序的器皿类型,以字典的键值对格局储存,其八月素作为key,其计数作为value。计数值能够是随意的Interger(包罗0和负数)。Counter类和此外语言的bags或multisets很相似。

 

 

金沙注册送58 139金沙注册送58 140

c = Counter('abcdeabcdabcaba')
print c
输出:Counter({'a': 5, 'b': 4, 'c': 3, 'd': 2, 'e': 1})

计算个数

     
                                     random模块                        
                         

 

>>> import random
#随机小数
>>> random.random()      # 大于0且小于1之间的小数
0.7664338663654585
>>> random.uniform(1,3) #大于1小于3的小数
1.6270147180533838
#恒富:发红包

#随机整数
>>> random.randint(1,5)  # 大于等于1且小于等于5之间的整数
>>> random.randrange(1,10,2) # 大于等于1且小于10之间的奇数


#随机选择一个返回
>>> random.choice([1,'23',[4,5]])  # #1或者23或者[4,5]
#随机选择多个返回,返回的个数为函数的第二个参数
>>> random.sample([1,'23',[4,5]],2) # #列表元素任意2个组合
[[4, 5], '23']


#打乱列表顺序
>>> item=[1,3,5,7,9]
>>> random.shuffle(item) # 打乱次序
>>> item
[5, 1, 3, 7, 9]
>>> random.shuffle(item)
>>> item
[5, 9, 7, 1, 3]

 

习题:生成随机验证码

金沙注册送58 141金沙注册送58 142

import random

def v_code():

    code = ''
    for i in range(5):

        num=random.randint(0,9)
        alf=chr(random.randint(65,90))
        add=random.choice([num,alf])
        code="".join([code,str(add)])

    return code

print(v_code())

演练参考

 

     
                               time模块                                
   

和时间有关系的大家将要用到时刻模块。在采纳模块从前,应该率起初入那么些模块。

#常用方法
1.time.sleep(secs)
(线程)推迟指定的时间运行。单位为秒。
2.time.time()
获取当前时间戳

表示时间的二种艺术

在Python中,常常有那三种办法来代表时间:时间戳、元组(struct_time)、格式化的岁月字符串:

(1)时间戳(timestamp)
:平时来说,时间戳表示的是从一九六八年3月1二十三日00:00:00起先按秒总计的偏移量。大家运营“type(time.time())”,重回的是float类型。

(2)格式化的命宫字符串(Format String): ‘1996-12-06’

金沙注册送58 143金沙注册送58 144

%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 当前时区的名称
%% %号本身

python中时间日期格式化符号:

python中时间日期格式符号

(3)元组(struct_time)
:struct_time元组共有8个因素共九个因素:(年,月,日,时,分,秒,一年中第几周,一年中第几天等)

索引(Index) 属性(Attribute) 值(Values)
0 tm_year(年) 比如2011
1 tm_mon(月) 1 – 12
2 tm_mday(日) 1 – 31
3 tm_hour(时) 0 – 23
4 tm_min(分) 0 – 59
5 tm_sec(秒) 0 – 60
6 tm_wday(weekday) 0 – 6(0表示周一)
7 tm_yday(一年中的第几天) 1 – 366
8 tm_isdst(是否是夏令时) 默认为0

 

 首先,大家起始入time模块,来认识一下python中代表时间的二种格式:

#导入时间模块
>>>import time

#时间戳
>>>time.time()
1500875844.800804

#时间字符串
>>>time.strftime("%Y-%m-%d %X")
'2017-07-24 13:54:37'
>>>time.strftime("%Y-%m-%d %H-%M-%S")
'2017-07-24 13-55-04'

#时间元组:localtime将一个时间戳转换为当前时区的struct_time
time.localtime()
time.struct_time(tm_year=2017, tm_mon=7, tm_mday=24,
          tm_hour=13, tm_min=59, tm_sec=37, 
                 tm_wday=0, tm_yday=205, tm_isdst=0

总括:时间戳是电脑能够识其他时间;时间字符串是人能够看懂的时日;元组则是用来操作时间的

 两种格式之间的变换

金沙注册送58 145

# 格式化时间 ---->  结构化时间
ft = time.strftime('%Y/%m/%d %H:%M:%S')
st = time.strptime(ft,'%Y/%m/%d %H:%M:%S')
print(st)
# 结构化时间 ---> 时间戳
t = time.mktime(st)
print(t)

# 时间戳 ----> 结构化时间
t = time.time()
st = time.localtime(t)
print(st)
# 结构化时间 ---> 格式化时间
ft = time.strftime('%Y/%m/%d %H:%M:%S',st)
print(ft)

金沙注册送58 146

#结构化时间 --> %a %b %d %H:%M:%S %Y串
#time.asctime(结构化时间) 如果不传参数,直接返回当前时间的格式化串
>>>time.asctime(time.localtime(1500000000))
'Fri Jul 14 10:40:00 2017'
>>>time.asctime()
'Mon Jul 24 15:18:33 2017'

#时间戳 --> %a %d %d %H:%M:%S %Y串
#time.ctime(时间戳)  如果不传参数,直接返回当前时间的格式化串
>>>time.ctime()
'Mon Jul 24 15:19:07 2017'
>>>time.ctime(1500000000)
'Fri Jul 14 10:40:00 2017' 

t = time.time()
ft = time.ctime(t)
print(ft)

st = time.localtime()
ft = time.asctime(st)
print(ft)

金沙注册送58 147金沙注册送58 148

import time
true_time=time.mktime(time.strptime('2017-09-11 08:30:00','%Y-%m-%d %H:%M:%S'))
time_now=time.mktime(time.strptime('2017-09-12 11:00:00','%Y-%m-%d %H:%M:%S'))
dif_time=time_now-true_time
struct_time=time.gmtime(dif_time)
print('过去了%d年%d月%d天%d小时%d分钟%d秒'%(struct_time.tm_year-1970,struct_time.tm_mon-1,
                                       struct_time.tm_mday-1,struct_time.tm_hour,
                                       struct_time.tm_min,struct_time.tm_sec))

计算时间差

测算时间差

 

     
                                     os模块                            
       

 os模块是与操作系统交互的1个接口

 

#当前执行这个python文件的工作目录相关的工作路径
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.popen("bash command).read()  运行shell命令,获取执行结果
os.environ  获取系统环境变量

#path系列,和路径相关
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的大小

 

金沙注册送58 149金沙注册送58 150

import os
'''
路径:
    绝对路径: E:\sylar\python_workspace\day27\04 os 模块.py
    相对路径:当前文件所在的文件夹
文件名: 04 os 模块.py
工作目录,父级目录,当前目录(本文件所在的文件夹的绝对路径): 
    E:\sylar\python_workspace\day27
'''
#1,当前执行这个python文件的工作目录相关的工作路径
# print(os.getcwd())  # 获取本文件的工作目录  *
# os.chdir('d:') # 修改本文件的工作目录.
# print(os.getcwd())
# print(os.curdir) # 当前目录 .
# print(os.pardir)  # 上上级目录 ..
# 例子:
# print(os.getcwd())
# os.chdir(os.pardir)
# print(os.getcwd())

# 和文件夹相关
# os.mkdir('文件夹1')
# os.mkdir('文件夹2\文件夹3')
# os.mkdir('文件夹4\文件夹5') # 只创建一个文件夹. *
# os.makedirs('dirname1/dirname2/dirname3')  #递归创建多个文件夹 *

# os.rmdir('文件夹1')  #  删除单个文件夹,文件夹必须是空的.
# os.removedirs('dirname1/dirname2/dirname3')   # 删除多个空文件夹,如果有内容,停止删除.
# l1 = os.listdir('E:\sylar\python_workspace\day27')  # *
# print(l1)

# 和文件相关
# os.remove()  删除一个文件  *
# os.rename("oldname","newname")  重命名文件/目录  *
# ret = os.stat('04 os 模块.py')  #获取文件/目录信息
# print(ret)
# 和操作系统差异相关
# 如果项目凌驾于不同的操作系统,这样可能需要下面的方法.
# win: E:\sylar\python_workspace\day27
# linux: E:/sylar/python_workspace/day27
# print(repr(os.linesep))
# print(os.pathsep)
# print(os.name)

# 和执行系统命令相关
# os.system('dir')  exec()
# ret = os.popen('dir').read()  # 运行shell命令,获取执行结果  *
# print(ret)   # eval()
# ret = eval('1+2')
# print(ret)
# code = '''if 2 > 1:    print(666)'''
# exec(code)
# print(os.environ)

# path系列,和路径相关
# p1 = os.path.abspath('04 os 模块.py')  # 获取本文件的绝对路径 *
# print(os.path.split(os.path.abspath('04 os 模块.py')))  # 将path分割成目录和文件名二元组返回 *
# print(os.path.split('E:\\sylar\\python_workspace\\day27'))  # 将path分割成目录和文件名二元组返回
# print(os.path.dirname(os.path.abspath('04 os 模块.py')))  #返回工作目录
# print(os.path.basename(os.path.abspath('04 os 模块.py'))) # 通过绝对路径返回当前的文件名
# print(os.path.exists('E:\\sylar\\python_workspace\\day27'))
# print(os.path.exists('E:\\sylar\\python_workspace\\day28'))
print(os.path.join('E:\\sylar\\python_workspace', '\\day28', '\\day29'))  # * 拼接路径
# print(os.path.getsize('E:\\sylar\\python_workspace\\day27\\04 os 模块.py'))

尝试代码

留神:os.stat(‘path/filename’)  获取文件/目录消息 的构造表明

 

 

金沙注册送58 151金沙注册送58 152

stat 结构:

st_mode: inode 保护模式
st_ino: inode 节点号。
st_dev: inode 驻留的设备。
st_nlink: inode 的链接数。
st_uid: 所有者的用户ID。
st_gid: 所有者的组ID。
st_size: 普通文件以字节为单位的大小;包含等待某些特殊文件的数据。
st_atime: 上次访问的时间。
st_mtime: 最后一次修改的时间。
st_ctime: 由操作系统报告的"ctime"。在某些系统上(如Unix)是最新的元数据更改的时间,在其它系统上(如Windows)是创建时间(详细信息参见平台的文档)。

stat结构

                                         sys模块                                         

sys模块是与python解释器交互的3个接口

sys.argv           命令行参数List,第一个元素是程序本身路径
sys.exit(n)        退出程序,正常退出时exit(0),错误退出sys.exit(1)
sys.version        获取Python解释程序的版本信息
sys.path           返回模块的搜索路径,初始化时使用PYTHONPATH环境变量的值
sys.platform       返回操作系统平台名称

 

相关文章

网站地图xml地图