模块

目录：

　　十三、re模块(* * * * *)

一、模块&包(* * * * *)

模块(modue)的概念：

 1 # 怎么判断这个模块已经被导入过了???
 2 # import sys
 3 # print(sys.modules)
 4 
 5 # 模块导入的过程中发生了什么?
 6     # 找到这个模块
 7     # 判断这个模块是否被导入过了
 8     # 如果没有被导入过
 9         # 创建一个属于这个模块的命名空间
10         # 让模块的名字 指向 这个空间
11         # 执行这个模块中的代码
12 
13 # import的命名空间,模块和当前文件在不同的命名空间中
14 # name = 'egon'
15 # def read1():
16 #     print('main read1')
17 #
18 # print(name)
19 # print(my_module.name)  #这里只会去找模块中的name
20 
21 # 导入一个模块就是执行一个模块，模块的重复导入不会重复执行
22 # 导入多个模块
23 # import os,time
24 # import os as o,time as t
25 # 规范建议 模块应该一个一个的导入 : 自定义模块,第三方模块,内置模块
26 #          先导入内置模块
27 #          再导入扩展(第三方)模块
28 #          最后导入自定义模块
29 
30             import os
31 
32             import django
33 
34             import my_module
35 # 给模块起别名,起了别名之后,使用这个模块就都使用别名引用变量了
36 # import my_module as m
37 # m.read1()
38 
39 # def func(dic, t='json'):
40 #     if t == 'json':
41 #         import json as aaa
42 #     elif t == 'pickle':
43 #         import pickle as aaa
44 #     return aaa.dumps(dic)

模块 import

 1 # from import的过程中仍然执行了这个被导入的文件
 2 # import谁就只能用谁
 3 
 4 # 当前文件命名空间和模块的命名空间的问题
 5 # from my_module import read1
 6 # def read1():
 7 #     print('in my read1')
 8 # read1()  #执行最近的read1，导入的read1被覆盖了
 9 
10 # from import导入的过程中发生了什么事儿?
11 # 1.找到要被导入的模块
12 # 2.判断这个模块是否被导入过
13 # 3.如果这个模块没被导入过
14     # 创建一个属于这个模块的命名空间
15     # 执行这个文件
16     # 找到你要导入的变量
17     # 给你要导入的变量创建一个引用,指向要导入的变量
18 
19 # 导入多个名字
20 # from my_module import read1,read2
21 # read1()
22 # read2()
23 
24 # 给导入的名字起别名
25 # from my_module import read1 as r1,read2 as r2
26 # def read1():
27 #     print('in my read1')
28 # r1()
29 # r2()
30 # read1()
31 
32 # * 和 __all__ __all__能够约束*导入的变量的内容，all是一个列表，列表中都是字符串，如，在my_module中__all__=['name','read1'],则read2会报错
33 # from my_module import *
34 # print(name)  # alex
35 # read1()   #。。。
36 # read2()   #报错，not defined

from import

 1 1.模块之间不允许循环引用
 2 2.已经被导入的模块发生了修改，是不会被感知到的
 3    要想修改的模块被正在运行中的程序感知到，重启这个程序，不要用importlib.reload()
 4 3.把模块当成脚本执行
 5    # 都是py文件
 6          # 直接运行这个文件 这个文件就是一个脚本
 7          # 导入这个文件     这个文件就是一个模块
 8     if __name__ == '__main__':
 9              代码
10     写在这里面的代码只有这个文件被当做脚本执行的时候才执行
11 4.模块的搜索路径
12     和被当做脚本执行的文件 同目录下的模块,可以被直接导入
13     除此之外其他路径下的模块 在被导入的时候需要自己修改sys.path列表
14           import sys
15           # print(sys.path)
16           path = r'D:\sylar\s15\day21\5模块的循环引用'
17           sys.path.append(path)
18           import a        
19

注

在计算机程序的开发过程中，随着程序代码越写越多，在一个文件里代码就会越来越长，越来越不容易维护。

为了编写可维护的代码，我们把很多函数分组，分别放到不同的文件里，这样，每个文件包含的代码就相对较少，很多编程语言都采用这种组织代码的方式。在Python中，一个.py文件就称之为一个模块（Module）。

使用模块有什么好处？

最大的好处是大大提高了代码的可维护性。

其次，编写代码不必从零开始。当一个模块编写完毕，就可以被其他地方引用。我们在编写程序的时候，也经常引用其他模块，包括Python内置的模块和来自第三方的模块。

所以，模块一共三种：

python标准库
第三方模块
应用程序自定义模块

另外，使用模块还可以避免函数名和变量名冲突。相同名字的函数和变量完全可以分别存在不同的模块中，因此，我们自己在编写模块时，不必考虑名字会与其他模块冲突。但是也要注意，尽量不要与内置函数名字冲突。

模块导入方法

1 import 语句

import module1[, module2[,... moduleN]

当我们使用import语句的时候，Python解释器是怎样找到对应的文件的呢？答案就是解释器有自己的搜索路径，存在sys.path里。　　

['', '/usr/lib/python3.4', '/usr/lib/python3.4/plat-x86_64-linux-gnu',
'/usr/lib/python3.4/lib-dynload', '/usr/local/lib/python3.4/dist-packages', '/usr/lib/python3/dist-packages']　　

因此若像我一样在当前目录下存在与要引入模块同名的文件，就会把要引入的模块屏蔽掉。

2 from…import 语句

from modname import name1[, name2[, ... nameN]]

这个声明不会把整个modulename模块导入到当前的命名空间中，只会将它里面的name1或name2单个引入到执行这个声明的模块的全局符号表。

3 From…import* 语句

from modname import *

这提供了一个简单的方法来导入一个模块中的所有项目。然而这种声明不该被过多地使用。大多数情况， Python程序员不使用这种方法，因为引入的其它来源的命名，很可能覆盖了已有的定义。

4 运行本质　

#1 import test
#2 from test import add　　

无论1还是2，首先通过sys.path找到test.py,然后执行test脚本（全部执行），区别是1会将test这个变量名加载到名字空间，而2只会将add这个变量名加载进来。　　

包(package)

 1 # 直接导入包 ,需要通过设计init文件,来完成导入包之后的操作
 2 # 导入一个包
 3     # 不意味着这个包下面的所有内容都是可以被使用的
 4     # 导入一个包到底发生什么了?
 5         # 相当于执行了这个包下面的__init__.py文件
 6 
 7 # 绝对导入 :
 8 # 在执行一个py脚本的时候,这个脚本以及和这个脚本同级的模块中只能用绝对导入
 9 # 缺点
10 # 所有的导入都要从一个根目录下往后解释文件夹之间的关系
11 # 如果当前导入包的文件和被导入的包的位置关系发生了变化,那么所有的init文件都要做相应的调整
12 
13 # 相对导入 :
14 # 不需要去反复的修改路径
15     # 只要一个包中的所有文件夹和文件的相对位置不发生改变
16 # 也不需要去关心当前这个包和被执行的文件之间的层级关系
17 # 缺点
18 # 含有相对导入的py文件不能被直接执行
19 # 必须放在包中被导入的调用才能正常的使用
20 # from . import bbbbb   # 含有相对导入的文件不能被直接执行

包

如果不同的人编写的模块名相同怎么办？为了避免模块名冲突，Python又引入了按目录来组织模块的方法，称为包（Package）。

举个例子，一个abc.py的文件就是一个名字叫abc的模块，一个xyz.py的文件就是一个名字叫xyz的模块。

现在，假设我们的abc和xyz这两个模块名字与其他模块冲突了，于是我们可以通过包来组织模块，避免冲突。方法是选择一个顶层包名：

引入了包以后，只要顶层的包名不与别人冲突，那所有模块都不会与别人冲突。现在，view.py模块的名字就变成了hello_django.app01.views，类似的，manage.py的模块名则是hello_django.manage。

请注意，每一个包目录下面都会有一个__init__.py的文件，这个文件是必须存在的，否则，Python就把这个目录当成普通目录(文件夹)，而不是一个包。__init__.py可以是空文件，也可以有Python代码，因为__init__.py本身就是一个模块，而它的模块名就是对应包的名字。

调用包就是执行包下的__init__.py文件

注意点（important）

1--------------

在nod1里import hello是找不到的，有同学说可以找到呀，那是因为你的pycharm为你把myapp这一层路径加入到了sys.path里面，所以可以找到，然而程序一旦在命令行运行，则报错。有同学问那怎么办？简单啊，自己把这个路径加进去不就OK啦：

import sys,os
BASE_DIR=os.path.dirname(os.path.dirname(os.path.abspath(__file__)))
sys.path.append(BASE_DIR)
import hello
hello.hello1()

2 --------------

if __name__=='__main__':
    print('ok')

“Make a .py both importable and executable”

如果我们是直接执行某个.py文件的时候，该文件中那么”__name__ == '__main__'“是True,但是我们如果从另外一个.py文件通过import导入该文件的时候，这时__name__的值就是我们这个py文件的名字而不是__main__。

这个功能还有一个用处：调试代码的时候，在”if __name__ == '__main__'“中加入一些我们的调试代码，我们可以让外部模块调用的时候不执行我们的调试代码，但是如果我们想排查问题的时候，直接执行该模块文件，调试代码能够正常运行！s

##-------------cal.py
def add(x,y):
 
    return x+y
##-------------main.py
import cal      #from module import cal
 
def main():
 
    cal.add(1,2)
     
##--------------bin.py
from module import main
 
main.main()

# from module import cal 改成 from . import cal同样可以，这是因为bin.py是我们的执行脚本，
# sys.path里有bin.py的当前环境。即/Users/yuanhao/Desktop/whaterver/project/web这层路径，
# 无论import what ,  解释器都会按这个路径找。所以当执行到main.py时，import cal会找不到，因为
# sys.path里没有/Users/yuanhao/Desktop/whaterver/project/web/module这个路径，而
#  from  module/.  import cal 时，解释器就可以找到了。

注意

二、time模块(* * * *)

三种时间表示

在Python中，通常有这几种方式来表示时间：

时间戳(timestamp) ：通常来说，时间戳表示的是从1970年1月1日00:00:00开始按秒计算的偏移量。我们运行“type(time.time())”，返回的是float类型。
格式化的时间字符串
元组(struct_time) ： struct_time元组共有9个元素共九个元素:(年，月，日，时，分，秒，一年中第几周，一年中第几天，夏令时)

import time
 
# 1 time() :返回当前时间的时间戳
time.time()  #1473525444.037215
 
#----------------------------------------------------------
 
# 2 localtime([secs])
# 将一个时间戳转换为当前时区的struct_time。secs参数未提供，则以当前时间为准。
time.localtime() #time.struct_time(tm_year=2016, tm_mon=9, tm_mday=11, tm_hour=0,
# tm_min=38, tm_sec=39, tm_wday=6, tm_yday=255, tm_isdst=0)
time.localtime(1473525444.037215)
 
#----------------------------------------------------------
 
# 3 gmtime([secs]) 和localtime()方法类似，gmtime()方法是将一个时间戳转换为UTC时区（0时区）的struct_time。
 
#----------------------------------------------------------
 
# 4 mktime(t) : 将一个struct_time转化为时间戳。
print(time.mktime(time.localtime()))#1473525749.0
 
#----------------------------------------------------------
 
# 5 asctime([t]) : 把一个表示时间的元组或者struct_time表示为这种形式：'Sun Jun 20 23:21:05 1993'。
# 如果没有参数，将会将time.localtime()作为参数传入。
print(time.asctime())#Sun Sep 11 00:43:43 2016
 
#----------------------------------------------------------
 
# 6 ctime([secs]) : 把一个时间戳（按秒计算的浮点数）转化为time.asctime()的形式。如果参数未给或者为
# None的时候，将会默认time.time()为参数。它的作用相当于time.asctime(time.localtime(secs))。
print(time.ctime())  # Sun Sep 11 00:46:38 2016
 
print(time.ctime(time.time()))  # Sun Sep 11 00:46:38 2016
 
# 7 strftime(format[, t]) : 把一个代表时间的元组或者struct_time（如由time.localtime()和
# time.gmtime()返回）转化为格式化的时间字符串。如果t未指定，将传入time.localtime()。如果元组中任何一个
# 元素越界，ValueError的错误将会被抛出。
print(time.strftime("%Y-%m-%d %X", time.localtime()))#2016-09-11 00:49:56
 
# 8 time.strptime(string[, format])
# 把一个格式化时间字符串转化为struct_time。实际上它和strftime()是逆操作。
print(time.strptime('2011-05-05 16:37:06', '%Y-%m-%d %X'))
 
#time.struct_time(tm_year=2011, tm_mon=5, tm_mday=5, tm_hour=16, tm_min=37, tm_sec=6,
#  tm_wday=3, tm_yday=125, tm_isdst=-1)
 
#在这个函数中，format默认为："%a %b %d %H:%M:%S %Y"。
 
 
# 9 sleep(secs)
# 线程推迟指定的时间运行，单位为秒。
 
# 10 clock()
# 这个需要注意，在不同的系统上含义不同。在UNIX系统上，它返回的是“进程时间”，它是用秒表示的浮点数（时间戳）。
# 而在WINDOWS中，第一次调用，返回的是进程运行的实际时间。而第二次之后的调用是自第一次调用以后到现在的运行
# 时间，即两次时间差。

help(time)
help(time.asctime)

 1 # 时间戳换成字符串时间
 2 # print(time.time())
 3 # struct_time = time.localtime(1500000000)
 4 # # print(time.gmtime(1500000000))
 5 # ret = time.strftime('%y-%m-%d %H:%M:%S',struct_time)
 6 # print(ret)
 7 
 8 # 字符串时间 转 时间戳
 9 # struct_time = time.strptime('2018-8-8','%Y-%m-%d')
10 # print(struct_time)
11 # res = time.mktime(struct_time)
12 # print(res)
13 
14 # 1.查看一下2000000000时间戳时间表示的年月日
15 # 时间戳 - 结构化 - 格式化
16 # struct_t = time.localtime(2000000000)
17 # print(struct_t)
18 # print(time.strftime('%y-%m-%d',struct_t))
19 
20 # 2.将2008-8-8转换成时间戳时间
21 # t = time.strptime('2008-8-8','%Y-%m-%d')
22 # print(time.mktime(t))
23 
24 # 3.请将当前时间的当前月1号的时间戳时间取出来 - 函数
25 # 2018-8-1
26 # def get_time():
27 #     st = time.localtime()
28 #     st2 = time.strptime('%s-%s-1'%(st.tm_year,st.tm_mon),'%Y-%m-%d')
29 #     return time.mktime(st2)
30 # print(get_time())
31 
32 # 4.计算时间差 - 函数
33     # 2018-8-19 22:10:8 2018-8-20 11:07:3
34     # 经过了多少时分秒
35 # str_time1 = '2018-8-19 22:10:8'
36 # str_time2 = '2018-8-20 11:07:3'
37 # struct_t1 = time.strptime(str_time1,'%Y-%m-%d %H:%M:%S')
38 # struct_t2 = time.strptime(str_time2,'%Y-%m-%d %H:%M:%S')
39 # timestamp1 = time.mktime(struct_t1)
40 # timestamp2 = time.mktime(struct_t2)
41 # sub_time = timestamp2 - timestamp1
42 # gm_time = time.gmtime(sub_time)
43 # # 1970-1-1 00:00:00
44 # print('过去了%d年%d月%d天%d小时%d分钟%d秒'%(gm_time.tm_year-1970,gm_time.tm_mon-1,
45 #                                  gm_time.tm_mday-1,gm_time.tm_hour,
46 #                                  gm_time.tm_min,gm_time.tm_sec))

补充

calendar模块

    calendar模块定义了Calendar类，其中封装了一些值的计算，如给定的一个月或一年中的周日期。另外，TextCalendar和HTMLCalendar类可以生成经过预格式化的输出。

1、指定年月，显示出日期

import calendar

print(calendar.month(2020, 3))

View Code

import calendar

c = calendar.TextCalendar(calendar.SUNDAY)
c.prmonth(2020,5)

View Code

运行效果

      May 2020
Su Mo Tu We Th Fr Sa
                1  2
 3  4  5  6  7  8  9
10 11 12 13 14 15 16
17 18 19 20 21 22 23
24 25 26 27 28 29 30
31

View Code

2、指定年月，打印出元组的日期

import calendar
import pprint

cal = calendar.Calendar(calendar.SUNDAY)

cal_data = cal.yeardays2calendar(2020, 5)
print('len(cal_data)      :', len(cal_data))

top_months = cal_data[0]
print('len(top_months)    :', len(top_months))

first_month = top_months[0]
print('len(first_month)   :', len(first_month))

print('first_month:')
pprint.pprint(first_month, width=65)

calendar_yeardays2calendar.py

运行效果

len(cal_data)      : 3
len(top_months)    : 5
len(first_month)   : 5
first_month:
[[(0, 6), (0, 0), (0, 1), (1, 2), (2, 3), (3, 4), (4, 5)],
 [(5, 6), (6, 0), (7, 1), (8, 2), (9, 3), (10, 4), (11, 5)],
 [(12, 6), (13, 0), (14, 1), (15, 2), (16, 3), (17, 4), (18, 5)],
 [(19, 6), (20, 0), (21, 1), (22, 2), (23, 3), (24, 4), (25, 5)],
 [(26, 6), (27, 0), (28, 1), (29, 2), (30, 3), (31, 4), (0, 5)]]

View Code

3、打印出完整的年份日历

import calendar

cal = calendar.TextCalendar(calendar.SUNDAY)
print(cal.formatyear(2020, 2, 1, 1, 3))

View Code

运行效果

2020

      January               February               March
Su Mo Tu We Th Fr Sa  Su Mo Tu We Th Fr Sa  Su Mo Tu We Th Fr Sa
          1  2  3  4                     1   1  2  3  4  5  6  7
 5  6  7  8  9 10 11   2  3  4  5  6  7  8   8  9 10 11 12 13 14
12 13 14 15 16 17 18   9 10 11 12 13 14 15  15 16 17 18 19 20 21
19 20 21 22 23 24 25  16 17 18 19 20 21 22  22 23 24 25 26 27 28
26 27 28 29 30 31     23 24 25 26 27 28 29  29 30 31

       April                  May                   June
Su Mo Tu We Th Fr Sa  Su Mo Tu We Th Fr Sa  Su Mo Tu We Th Fr Sa
          1  2  3  4                  1  2      1  2  3  4  5  6
 5  6  7  8  9 10 11   3  4  5  6  7  8  9   7  8  9 10 11 12 13
12 13 14 15 16 17 18  10 11 12 13 14 15 16  14 15 16 17 18 19 20
19 20 21 22 23 24 25  17 18 19 20 21 22 23  21 22 23 24 25 26 27
26 27 28 29 30        24 25 26 27 28 29 30  28 29 30
                      31

        July                 August              September
Su Mo Tu We Th Fr Sa  Su Mo Tu We Th Fr Sa  Su Mo Tu We Th Fr Sa
          1  2  3  4                     1         1  2  3  4  5
 5  6  7  8  9 10 11   2  3  4  5  6  7  8   6  7  8  9 10 11 12
12 13 14 15 16 17 18   9 10 11 12 13 14 15  13 14 15 16 17 18 19
19 20 21 22 23 24 25  16 17 18 19 20 21 22  20 21 22 23 24 25 26
26 27 28 29 30 31     23 24 25 26 27 28 29  27 28 29 30
                      30 31

      October               November              December
Su Mo Tu We Th Fr Sa  Su Mo Tu We Th Fr Sa  Su Mo Tu We Th Fr Sa
             1  2  3   1  2  3  4  5  6  7         1  2  3  4  5
 4  5  6  7  8  9 10   8  9 10 11 12 13 14   6  7  8  9 10 11 12
11 12 13 14 15 16 17  15 16 17 18 19 20 21  13 14 15 16 17 18 19
18 19 20 21 22 23 24  22 23 24 25 26 27 28  20 21 22 23 24 25 26
25 26 27 28 29 30 31  29 30                 27 28 29 30 31

View Code

4、指定年月，获取不同国家的日历格式

import calendar

c = calendar.LocaleTextCalendar(locale='en_US')
c.prmonth(2017, 7)

print()

c = calendar.LocaleTextCalendar(locale='zh_CN')
c.prmonth(2017, 7)

calendar_locale.py

运行效果

     July 2017
Mo Tu We Th Fr Sa Su
                1  2
 3  4  5  6  7  8  9
10 11 12 13 14 15 16
17 18 19 20 21 22 23
24 25 26 27 28 29 30
31

      七月 2017
一  二  三  四  五  六  日
                1  2
 3  4  5  6  7  8  9
10 11 12 13 14 15 16
17 18 19 20 21 22 23
24 25 26 27 28 29 30
31

View Code

5、指定年月，打印出一个按周拆分的列表，默认第一个元素是周一

import calendar
import pprint

pprint.pprint(calendar.monthcalendar(2020, 5))

View Code

运行效果

[[0, 0, 0, 0, 1, 2, 3],
 [4, 5, 6, 7, 8, 9, 10],
 [11, 12, 13, 14, 15, 16, 17],
 [18, 19, 20, 21, 22, 23, 24],
 [25, 26, 27, 28, 29, 30, 31]]

6、计算每个月第2周，周四的日期的示例

import calendar

year = 2020

# 计算每个月第2周，周四的日期
for month in range(1, 13):

    # 计算每个星期与月份重叠的日期
    c = calendar.monthcalendar(year, month)
    first_week = c[0]
    second_week = c[1]
    third_week = c[2]

    # 如果第一周有星期四，第二个星期四是第二周的。否则，第二个星期四必须在第三周
    if first_week[calendar.THURSDAY]:
        meeting_date = second_week[calendar.THURSDAY]
    else:
        meeting_date = third_week[calendar.THURSDAY]

    print('{:>3}: {:>2}'.format(calendar.month_abbr[month],
                                meeting_date))

calendar_secondthursday.py

运行效果

Jan:  9
Feb: 13
Mar: 12
Apr:  9
May: 14
Jun: 11
Jul:  9
Aug: 13
Sep: 10
Oct:  8
Nov: 12
Dec: 10

运行效果

三、random模块(* *)

import random
 
print(random.random())#(0,1)----float
 
print(random.randint(1,3))  #[1,3]
 
print(random.randrange(1,3)) #[1,3)
 
print(random.choice([1,'23',[4,5]]))#23
 
print(random.sample([1,'23',[4,5]],2))#[[4, 5], '23']
 
print(random.uniform(1,3))#1.927109612082716
 
item=[1,3,5,7,9]  #在原列表上打乱元素顺序
random.shuffle(item)
print(item)

 1 import random
 2 
 3 def v_code():
 4 
 5     code = ''
 6     for i in range(5):
 7 
 8         num=random.randint(0,9)
 9         alf=chr(random.randint(65,90))
10         add=random.choice([num,alf])
11         code += str(add)
12     return code
13 
14 print(v_code())

验证码

 1 import random
 2 
 3 # 取随机小数 : 数学计算
 4 # print(random.random()) # 取0-1之间的小数
 5 # print(random.uniform(1,2)) # 取1-2之间的小数
 6 
 7 # 取随机整数 : 彩票 抽奖
 8 # print(random.randint(1,2)) # [1,2]
 9 # print(random.randrange(1,2)) # [1,2)
10 # print(random.randrange(1,200,2)) # [1,2)
11 
12 # 从一个列表中随机抽取值 : 抽奖
13 # l = ['a','b',(1,2),123]
14 # print(random.choice(l))
15 # print(random.sample(l,2))
16 
17 # 打乱一个列表的顺序,在原列表的基础上直接进行修改,节省空间
18 # 洗牌
19 # random.shuffle(l)
20 # print(l)
21 
22 # 验证码
23 # 4位数字验证码
24 # 6位数字验证码
25 # def code(n=6):
26 #     s = ''
27 #     for i in range(n):
28 #         num = random.randint(0,9)
29 #         s += str(num)
30 #     return s
31 #
32 # print(code(4))
33 # print(code())
34 
35 
36 # 4位数字验证码
37 # 6位数字验证码
38 # 6位数字+字母验证码
39 # def code(n = 6,alpha = True):
40 #     s = ''
41 #     for i in range(n):
42 #         num = str(random.randint(0,9))
43 #         if alpha:
44 #             alpha_upper = chr(random.randint(65,90))
45 #             alpha_lower = chr(random.randint(97,122))
46 #             num = random.choice([num,alpha_upper,alpha_lower])
47 #         s += num
48 #     return s
49 # print(code(4,False))
50 # print(code(alpha=False))

补充

 1 # import random
 2 # def red_packet(money,num):  #以200元 10个人为例
 3 #     money = money * 100    #转换成20000分
 4 #     ret = random.sample(range(1,money),num-1)#取num-1(即9个人)个节点，每个节点取值范围为1分-20000分间的随机数
 5 #     ret.sort()  #将节点从小到大排序
 6 #     ret.insert(0,0)   #在节点开头加一个0节点
 7 #     ret.append(money)   #在节点结尾加一个money分节点
 8 #     for i in range(len(ret)-1):
 9 #         yield (ret[i+1] - ret[i])/100  #(每两个节点分数值相减)/100就得到一个红包数值(元)大小，两位小数
10 #
11 # ret_g = red_packet(200,10)
12 # for money in ret_g:
13 #     print(money)
14 
15 # import random
16 # def Bonus(person,money):  # 5,200
17 #     dict_person_money = {}
18 #     for i in range(person):
19 #         num = random.randint(1,100)  # 99 99 99 99 99
20 #         dict_person_money["Person%s"%(i+1)] = num  # person1:99
21 #     num_sum = 0
22 #     for i in dict_person_money:
23 #         num_sum += dict_person_money[i]  # 5 * 99 = 495
24 #     for i in dict_person_money:    # 99/495 1/5 * 200 = 40
25 #         x =round(dict_person_money[i]/num_sum*money,2)
26 #         dict_person_money[i] = '$%s'%x
27 #     return dict_person_money
28 
29 # result = Bonus(10,1)
30 # print(result)
31 
32 # import random
33 # def hongbao(sum,n):
34 #     lst = []
35 #     for i in range(n-1):
36 #         number=random.uniform(0,sum)
37 #         number=round(number,2)  #保留两位小数
38 #         sum=sum-number
39 #         lst.append(number)
40 #     lst.append(sum)
41 #     random.shuffle(lst)
42 #     return lst
43 # lst=hongbao(100,3)
44 # print(lst)
45 
46 # import random
47 # def red_envelopes(money, numbers=10):
48 #     name_list = ['梁慧', '蒲雪', '刘宁谦', '侯明魏', '尚红运',
49 #                  '刘晓蕾', '杨文状', '姚尚', '冯俊才', '宋华生']
50 #     sum_n = 0
51 #     balance = money
52 #
53 #     for index, name in enumerate(name_list):
54 #         random_money = random.uniform(0, balance / 3)
55 #         if index == numbers - 1:
56 #             print('%s grabbed %.2f element'
57 #                   % (name, money - sum_n))
58 #         else:
59 #             balance -= random_money
60 #             sum_n += random_money
61 #             print('%s grabbed %.2f element'
62 #                   % (name, random_money))
63 #
64 # money = int(input('please enter the amount of your red envelope!'))
65 # red_envelopes(money)

random练习：发红包

四、os模块(* * * *)

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

 1 os.getcwd() 获取当前工作目录，即当前python脚本工作的目录路径
 2 os.chdir("dirname")  改变当前脚本工作目录；相当于shell下cd
 3 os.curdir  返回当前目录: ('.')
 4 os.pardir  获取当前目录的父目录字符串名：('..')
 5 os.makedirs('dirname1/dirname2')    可生成多层递归目录
 6 os.removedirs('dirname1')    若目录为空，则删除，并递归到上一级目录，如若也为空，则删除，依此类推
 7 os.mkdir('dirname')    生成单级目录；相当于shell中mkdir dirname
 8 os.rmdir('dirname')    删除单级空目录，若目录不为空则无法删除，报错；相当于shell中rmdir dirname
 9 os.listdir('dirname')    列出指定目录下的所有文件和子目录，包括隐藏文件，并以列表方式打印
10 os.remove()  删除一个文件
11 os.rename("oldname","newname")  重命名文件/目录
12 os.stat('path/filename')  获取文件/目录信息
13 os.sep    输出操作系统特定的路径分隔符，win下为"\\",Linux下为"/"
14 os.linesep    输出当前平台使用的行终止符，win下为"\t\n",Linux下为"\n"
15 os.pathsep    输出用于分割文件路径的字符串 win下为;,Linux下为:
16 os.name    输出字符串指示当前使用平台。win->'nt'; Linux->'posix'
17 os.system("bash command")  运行shell命令，直接显示
18 os.environ  获取系统环境变量
19 os.path.abspath(path)  返回path规范化的绝对路径
20 os.path.split(path)  将path分割成目录和文件名二元组返回
21 os.path.dirname(path)  返回path的目录。其实就是os.path.split(path)的第一个元素
22 os.path.basename(path)  返回path最后的文件名。如何path以／或\结尾，那么就会返回空值。即os.path.split(path)的第二个元素
23 os.path.exists(path)  如果path存在，返回True；如果path不存在，返回False
24 os.path.isabs(path)  如果path是绝对路径，返回True
25 os.path.isfile(path)  如果path是一个存在的文件，返回True。否则返回False
26 os.path.isdir(path)  如果path是一个存在的目录，则返回True。否则返回False
27 os.path.join(path1[, path2[, ...]])  将多个路径组合后返回，第一个绝对路径之前的参数将被忽略
28 os.path.getatime(path)  返回path所指向的文件或者目录的最后存取时间
29 os.path.getmtime(path)  返回path所指向的文件或者目录的最后修改时间

View Code

 1 # exec/eval执行的是字符串数据类型的 python代码
 2 # os.system和 os.popen是执行字符串数据类型的 命令行代码
 3 
 4 # os.'system('dir')  # 执行操作系统的命令,没有返回值,实际的操作/删除一个文件 创建一个文件夹 exec
 5 # 程序要处理这些路径
 6 # ret = os.popen('dir) # 适合做查看类的操作
 7 # s =ret.read()
 8 # print(s)
 9 # print(s.split('\n'))
10 
11 # os.listdir / os.path.join
12 # file_lst = os.listdir('D:\sylar\s15')
13 # for path in file_lst:
14 #     print(os.path.join('D:\sylar\s15',path))
15 
16 # print('-->',os.getcwd())  # current work dir 当前工作目录
17 # # 并不是指当前文件所在的目录
18 # # 当前文件是在哪个目录下执行的
19 # ret = os.popen('dir') # 适合做查看类的操作
20 # s =ret.read()
21 # print(s)
22 
23 # os.chdir('D:\sylar\s15\day18')  # 切换当前的工作目录
24 # ret = os.popen('dir') # 适合做查看类的操作
25 # s =ret.read()
26 # print(s)

补充

 1 # 使用python代码统计一个文件夹中所有文件的总大小
 2 # 你需要统计文件夹大小
 3 # D:\sylar\s15\ 文件夹的大小
 4     # 拿到这个文件夹下所有的文件夹 和 文件
 5     # 是文件就取大小
 6     # 是文件夹 再打开这个文件夹 : 文件/文件夹
 7 # 递归
 8 def func(path):    # r'D:\sylar\s15'
 9     size_sum = 0
10     name_lst = os.listdir(path)
11     for name in name_lst:
12         path_abs = os.path.join(path,name)
13         if os.path.isdir(path_abs):
14             size = func(path_abs)
15             size_sum += size
16         else:
17             size_sum += os.path.getsize(path_abs)
18     return size_sum
19 
20 ret = func(r'D:\sylar\s15')
21 print(ret)
22 
23 
24 # 循环 # 堆栈思想
25 # 列表 满足一个顺序 先进来的后出去
26 lst = [r'D:\sylar\s15',]  # 列表的第一个目录就是我要统计的目录
27 size_sum = 0
28 while lst:   # [r'D:\sylar\s15',]  lst = ['D:\sylar\s15\day01','D:\sylar\s15\day01'..]
29     path = lst.pop()  # path = 'D:\sylar\s15' lst = []
30     path_list = os.listdir(path)  # path_list = ['day01',day02',aaa,day15.py]
31     for name in path_list:  # name = day01
32         abs_path = os.path.join(path,name)
33         if os.path.isdir(abs_path):   # 文件夹的逻辑
34             lst.append(abs_path)        # lst.append('D:\sylar\s15\day01')  lst = ['D:\sylar\s15\day01']
35         else:
36             size_sum += os.path.getsize(abs_path)
37 print(size_sum)

os.path.getsize

 1 import os
 2 # 1、写一个函数，接受一个参数，如果是文件，就执行这个文件，如果是文件夹，就执行这个文件夹下所有的py文件
 3 # def func(path):
 4 #     # 先判断这个path是文件还是文件夹,isdir isfile
 5 #     # 如果是文件,.py结尾的
 6 #     if os.path.isfile(path) and path.endswith('.py'):
 7 #         # 执行这个文件 :
 8 #         os.system('python %s'%path)  # 模拟了在cmd中执行代码的过程
 9 #     # 如果是文件夹
10 #     elif os.path.isdir(path):
11 #         # 查看这个文件夹下的所有内容  listdir
12 #         for name in os.listdir(path):
13 #             abs_path = os.path.join(path,name)
14 #             # 如果是文件 .py结尾的
15 #             if abs_path.endswith('.py'):
16 #                 # 执行这个文件
17 #                 os.system('python %s' % abs_path)
18 # func(r'D:\sylar\s15\day19\7.json模块.py')
19 # func(r'D:\sylar\s15\day19')
20 
21 # 2、写一个copy函数，接受两个参数，第一个参数是源文件的位置，第二个参数是目标位置，将源文件copy到目标位置。
22 # 还需要判断一下这个文件之前是否存在
23 # def copy(path1,path2):
24 #     filename = os.path.basename(path1)
25 #     if os.path.isfile(path1) and os.path.isdir(path2):
26 #         path2_filename = os.path.join(path2,filename)
27 #         if os.path.exists(path2_filename):
28 #             print('已有同名文件')
29 #         else:
30 #             with open(path1,'rb') as f1,open(path2_filename),'wb') as f2:
31 #                 content = f1.read()
32 #                 f2.write(content)
33 # copy(r'D:\sylar\s15\day19\1.内容回顾.py',r'D:\sylar\s15\day18')
34 
35 # 3、获取某个文件所在目录的上一级目录。
36 # 例如'D:\sylar\s15\day19\6.序列化模块.py'目录的结果 ：D:\sylar\s15
37 # 方法1
38 # path = os.path.dirname(r'D:\sylar\s15\day19\6.序列化模块.py')
39 # base_name = os.path.dirname(path)
40 # print(base_name)
41 # 方法2
42 # base_name = os.path.dirname(os.path.dirname(r'D:\sylar\s15\day19\6.序列化模块.py'))
43 # print(base_name)
44 
45 # 4、使用os模块创建如下目录结构
46 # glance/
47 #
48 # ├── __init__.py
49 #
50 # ├── api
51 #
52 # │   ├── __init__.py
53 #
54 # │   ├── policy.py
55 #
56 # │   └── versions.py
57 #
58 # ├── cmd
59 #
60 # │   ├── __init__.py
61 #
62 # │   └── manage.py
63 #
64 # └── db
65 #
66 #     ├── __init__.py
67 #
68 #     └── models.py
69 # 创建文件夹
70 # 创建文件
71 # os.makedirs('glance/api')
72 # os.makedirs('glance/cmd')
73 # os.makedirs('glance/db')
74 # open('glance/api/__init__.py','w').close()
75 # open('glance/api/policy.py','w').close()
76 # open('glance/api/versions.py','w').close()
77 # open('glance/cmd/__init__.py','w').close()
78 # open('glance/cmd/manage.py','w').close()
79 # open('glance/db/__init__.py','w').close()
80 # open('glance/db/models.py','w').close()

os练习

五、sys模块(* * *) sys模块是与python解释器交互的一个接口

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

进度条：

1 import sys,time
2 for i in range(10):
3     sys.stdout.write('#')
4     time.sleep(1)
5     sys.stdout.flush()

View Code

 1 import sys
 2 # sys.argv
 3 # print(sys.argv)  # argv的第一个参数 是python这个命令后面的值
 4 # usr = input('username')
 5 # pwd = input('password')
 6 # usr = sys.argv[1]
 7 # pwd = sys.argv[2]
 8 # if usr == 'alex' and pwd == 'alex3714':
 9 #     print('登录成功')
10 # else:
11 #     exit()
12 
13 # 1. 程序员 运维人员  在命令行运行代码
14 # 2. 操作系统input事件 阻塞 退出了CPU的竞争
15 
16 # sys.path
17 # print(sys.path)
18 # 模块是存在解释器里的么??? 不是
19 # 模块应该是存在硬盘上
20 # 但是在使用的时候 import --> 这个模块才到内存中
21 
22 # 一个模块能否被顺利的导入 全看sys.path下面有没有这个模块所在
23 # 自定义模块的时候 导入模块的时候 还需要再关注 sys.path
24 
25 import re
26 # sys.modules
27 # print(sys.modules)  # 是我们导入到内存中的所有模块的名字 : 这个模块的内存地址
28 # print(sys.modules['re'].findall('\d','abc126'))

补充

 1     # sys.argv
 2         # 当你在命令行执行python文件,而不是在pycharm中执行这个文件的时候
 3             # 你的命令>>> python python文件的路径 参数1 参数2 参数3 ...
 4             # sys.argv = ['python文件的路径','参数1','参数2','参数3'...]
 5             # 好处:这些需要输入的参数不需要在程序中以input的形式输入了
 6         # 文件名: 文件路径不能有中文 所有的文件名都应该符合变量命名规范
 7             # 整个文件路径不能有空格 不支持中文
 8     # sys.path 模块搜索路径 是一个列表,这个列表中存的都是文件夹的绝对路径
 9         # 一个模块能被导入,是因为这个模块所在的文件夹在sys.path的列表中
10         # 内置模块和第三方模块安装之后,不需要操作sys.path,直接用就行了
11         # 如果一个模块导入不进来,那把这个模块的文件夹添加到sys.path中就行了

补充1

六、json & pickle(* * * *)

 1 序列化
 2 import json
 3 dic={'a':'b','aa':'bb'}
 4 f=open('e:/test/aa.txt','w')
 5 json.dump(dic,f)
 6 <br>
 7 j=json.dumps(dic)
 8 f.write(j)
 9 
10 import pickle
11 f=open('e:/test/aa.txt','wb')
12 pickle.dump(dic,f)
13 <br>
14 j=pickle.dumps(dic)
15 f.write(j)
16 反序列化
17 import json
18 f=open('e:/test/aa.txt','r')
19 data=json.load(f)
20 data['a'] #b
21 <br>
22 f=open('e:/test/aa.txt')
23 data=json.loads(f.read())
24 data['a'] #b
25 
26 import pickle
27 f=open('e:/test/aa.txt','rb')
28 data=pickle.load(f)
29 data['a'] #b
30 <br>
31 f=open('e:/test/aa.txt','rb')
32 data=pickle.loads(f.read())
33 data['a'] #b

json pickle用法简单示例

  1 # dic = {'key' : 'value','key2' : 'value2'}
  2 # import json
  3 # ret = json.dumps(dic)  # 序列化
  4 # print(dic,type(dic))
  5 # print(ret,type(ret))
  6 
  7 # res = json.loads(ret) # 反序列化
  8 # print(res,type(res))
  9 
 10 # 问题1
 11 # dic = {1 : 'value',2 : 'value2'}
 12 # ret = json.dumps(dic)  # 序列化
 13 # print(dic,type(dic))
 14 # print(ret,type(ret))
 15 #
 16 # res = json.loads(ret) # 反序列化
 17 # print(res,type(res))
 18 
 19 # 问题2
 20 # dic = {1 : [1,2,3],2 : (4,5,'aa')}
 21 # ret = json.dumps(dic)  # 序列化
 22 # print(dic,type(dic))
 23 # print(ret,type(ret))
 24 
 25 # res = json.loads(ret) # 反序列化
 26 # print(res,type(res))
 27 
 28 # 问题3
 29 # s = {1,2,'aaa'}
 30 # json.dumps(s)
 31 
 32 # 问题4 # TypeError: keys must be a string
 33 # json.dumps({(1,2,3):123})
 34 
 35 # json 在所有的语言之间都通用 : json序列化的数据 在python上序列化了 那在java中也可以反序列化
 36 # 能够处理的数据类型是非常有限的 : 字符串 列表 字典 数字
 37 # 字典中的key只能是字符串
 38 
 39 # 向文件中记录字典
 40 import json
 41 # dic = {'key' : 'value','key2' : 'value2'}
 42 # ret = json.dumps(dic)  # 序列化
 43 # with open('json_file','a') as f:
 44 #     f.write(ret)
 45 
 46 # 从文件中读取字典
 47 # with open('json_file','r') as f:
 48 #     str_dic = f.read()
 49 # dic = json.loads(str_dic)
 50 # print(dic.keys())
 51 
 52 # dump load 是直接操作文件的
 53 # dic = {'key1' : 'value1','key2' : 'value2'}
 54 # with open('json_file','a') as f:
 55 #     json.dump(dic,f)
 56 
 57 # with open('json_file','r') as f:
 58 #     dic = json.load(f)
 59 # print(dic.keys())
 60 
 61 # 问题5 不支持连续的存 取
 62 # dic = {'key1' : 'value1','key2' : 'value2'}
 63 # with open('json_file','a') as f:
 64 #     json.dump(dic,f)
 65 #     json.dump(dic,f)
 66 #     json.dump(dic,f)
 67 
 68 # with open('json_file','r') as f:
 69 #     dic = json.load(f)
 70 # print(dic.keys())
 71 
 72 # 需求 :就是想要把一个一个的字典放到文件中,再一个一个取出来???
 73 # dic = {'key1' : 'value1','key2' : 'value2'}
 74 #
 75 # with open('json_file','a') as f:
 76 #     str_dic = json.dumps(dic)
 77 #     f.write(str_dic+'\n')
 78 #     str_dic = json.dumps(dic)
 79 #     f.write(str_dic + '\n')
 80 #     str_dic = json.dumps(dic)
 81 #     f.write(str_dic + '\n')
 82 
 83 # with open('json_file','r') as f:
 84 #     for line in f:
 85 #         dic = json.loads(line.strip())
 86 #         print(dic.keys())
 87 
 88 # json
 89 # dumps loads
 90     # 在内存中做数据转换 :
 91         # dumps 数据类型 转成 字符串 序列化
 92         # loads 字符串 转成 数据类型 反序列化
 93 # dump load
 94     # 直接将数据类型写入文件,直接从文件中读出数据类型
 95         # dump 数据类型 写入 文件 序列化
 96         # load 文件 读出 数据类型 反序列化
 97 # json是所有语言都通用的一种序列化格式
 98     # 只支持 列表 字典 字符串 数字
 99     # 字典的key必须是字符串
100 
101 
102 # dic = {'key':'你好'}
103 # print(json.dumps(dic,ensure_ascii=False))
104 
105 # import json
106 # data = {'username':['李华','二愣子'],'sex':'male','age':16}
107 # json_dic2 = json.dumps(data,sort_keys=True,indent=4,separators=(',',':'),ensure_ascii=False)
108 # print(json_dic2)
109 
110 # 存文件/传网络

注意json

 1 import pickle
 2 # 支持在python中几乎所有的数据类型
 3 dic = {(1,2,3):{'a','b'},1:'abc'}
 4 
 5 # ret = pickle.dumps(dic)
 6 # print(ret)
 7 #2. dumps 序列化的结果只能是字节
 8 # print(pickle.loads(ret))
 9 # 3.只能在python中使用
10 # 4.在和文件操作的时候,需要用rb wb的模式打开文件
11 # 5.可以多次dump 和 多次load
12 # dump
13 # with open('pickle_file','wb') as f:
14 #     pickle.dump(dic,f)
15 
16 # load
17 # with open('pickle_file','rb') as f:
18 #     ret = pickle.load(f)
19 #     print(ret,type(ret))
20 
21 # dic = {(1,2,3):{'a','b'},1:'abc'}
22 # dic1 = {(1,2,3):{'a','b'},2:'abc'}
23 # dic2 = {(1,2,3):{'a','b'},3:'abc'}
24 # dic3 = {(1,2,3):{'a','b'},4:'abc'}
25 # with open('pickle_file','wb') as f:
26 #     pickle.dump(dic, f)
27 #     pickle.dump(dic1, f)
28 #     pickle.dump(dic2, f)
29 #     pickle.dump(dic3, f)
30 
31 # with open('pickle_file','rb') as f:
32 #     ret = pickle.load(f)
33 #     print(ret,type(ret))
34 #     ret = pickle.load(f)
35 #     print(ret,type(ret))
36 #     ret = pickle.load(f)
37 #     print(ret, type(ret))
38 #     ret = pickle.load(f)
39 #     print(ret, type(ret))
40 #     ret = pickle.load(f)
41 #     print(ret, type(ret))
42 
43 with open('pickle_file','rb') as f:
44     while True:
45         try:
46             ret = pickle.load(f)
47             print(ret,type(ret))
48         except EOFError:
49             break

注意pickle

 1 写一个用户注册登陆的程序，每一个用户的注册都要把用户名和密码用字典的格式写入文件userinfo。
 2 # 在登陆的时候，再从文件中读取信息进行验证。
 3 ## {'usr':'alex','pwd':'alex3714'}
 4 # import pickle
 5 # def register():
 6 #     usr = input('username :')
 7 #     pwd = input('password : ')
 8 #     dic = {'usr':usr,'pwd':pwd}
 9 #     with open('userinfo','ab') as f:
10 #         pickle.dump(dic,f)
11 #     print('注册成功')
12 #
13 # def login():
14 #     flag = True
15 #     usr = input('username :')
16 #     pwd = input('password : ')
17 #     with open('userinfo', 'rb') as f:
18 #         while flag:
19 #             try :
20 #                 dic = pickle.load(f)
21 #                 if dic['usr'] == usr and dic['pwd'] == v:
22 #                     print('登录成功')
23 #                     flag = False
24 #                     break
25 #             except EOFError:
26 #                 print('登录失败')
27 #                 break
28 
29 # register()
30 # login()

pickle练习：注册登录

之前我们学习过用eval内置方法可以将一个字符串转成python对象，不过，eval方法是有局限性的，对于普通的数据类型，json.loads和eval都能用，但遇到特殊类型的时候，eval就不管用了,所以eval的重点还是通常用来执行一个字符串表达式，并返回表达式的值。

import json
x="[null,true,false,1]"
print(eval(x))
print(json.loads(x))

什么是序列化？

我们把对象(变量)从内存中变成可存储或传输的过程称之为序列化，在Python中叫pickling，在其他语言中也被称之为serialization，marshalling，flattening等等，都是一个意思。

序列化之后，就可以把序列化后的内容写入磁盘，或者通过网络传输到别的机器上。

反过来，把变量内容从序列化的对象重新读到内存里称之为反序列化，即unpickling。

json

如果我们要在不同的编程语言之间传递对象，就必须把对象序列化为标准格式，比如XML，但更好的方法是序列化为JSON，因为JSON表示出来就是一个字符串，可以被所有语言读取，也可以方便地存储到磁盘或者通过网络传输。JSON不仅是标准格式，并且比XML更快，而且可以直接在Web页面中读取，非常方便。

JSON表示的对象就是标准的JavaScript语言的对象，JSON和Python内置的数据类型对应如下：

#----------------------------序列化
import json
 
dic={'name':'alvin','age':23,'sex':'male'}
print(type(dic))#<class 'dict'>
 
j=json.dumps(dic)
print(type(j))#<class 'str'>
 
 
f=open('序列化对象','w')
f.write(j)  #-------------------等价于json.dump(dic,f)
f.close()
#-----------------------------反序列化<br>
import json
f=open('序列化对象')
data=json.loads(f.read())#  等价于data=json.load(f)

1 import json
2 #dct="{'1':111}"#json 不认单引号
3 #dct=str({"1":111})#报错,因为生成的数据还是单引号:{'one': 1}
4 
5 dct='{"1":"111"}'
6 print(json.loads(dct))
7 
8 #conclusion:
9 #        无论数据是怎样创建的，只要满足json格式，就可以json.loads出来,不一定非要dumps的数据才能loads

注意点

pickle　

##----------------------------序列化
import pickle
 
dic={'name':'alvin','age':23,'sex':'male'}
 
print(type(dic))#<class 'dict'>
 
j=pickle.dumps(dic)
print(type(j))#<class 'bytes'>
 
 
f=open('序列化对象_pickle','wb')#注意是w是写入str,wb是写入bytes,j是'bytes'
f.write(j)  #-------------------等价于pickle.dump(dic,f)
 
f.close()
#-------------------------反序列化
import pickle
f=open('序列化对象_pickle','rb')
 
data=pickle.loads(f.read())#  等价于data=pickle.load(f)
 
 
print(data['age'])    

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

七、shelve模块(* * *)

shelve模块比pickle模块简单，只有一个open函数，返回类似字典的对象，可读可写;key必须为字符串，而值可以是python所支持的数据类型

import shelve
 
f = shelve.open(r'shelve.txt')
 
# f['stu1_info']={'name':'alex','age':'18'}
# f['stu2_info']={'name':'alvin','age':'20'}
# f['school_info']={'website':'oldboyedu.com','city':'beijing'}
#
#
# f.close()
 
print(f.get('stu_info')['age'])

八、xml模块(* *)

xml是实现不同语言或程序之间进行数据交换的协议，跟json差不多，但json使用起来更简单，不过，古时候，在json还没诞生的黑暗年代，大家只能选择用xml呀，至今很多传统公司如金融行业的很多系统的接口还主要是xml。

xml的格式如下，就是通过<>节点来区别数据结构的:

 1 <?xml version="1.0"?>
 2 <data>
 3     <country name="Liechtenstein">
 4         <rank updated="yes">2</rank>
 5         <year>2008</year>
 6         <gdppc>141100</gdppc>
 7         <neighbor name="Austria" direction="E"/>
 8         <neighbor name="Switzerland" direction="W"/>
 9     </country>
10     <country name="Singapore">
11         <rank updated="yes">5</rank>
12         <year>2011</year>
13         <gdppc>59900</gdppc>
14         <neighbor name="Malaysia" direction="N"/>
15     </country>
16     <country name="Panama">
17         <rank updated="yes">69</rank>
18         <year>2011</year>
19         <gdppc>13600</gdppc>
20         <neighbor name="Costa Rica" direction="W"/>
21         <neighbor name="Colombia" direction="E"/>
22     </country>
23 </data>

xml数据

xml协议在各个语言里的都是支持的，在python中可以用以下模块操作xml：

 1 import xml.etree.ElementTree as ET
 2  
 3 tree = ET.parse("xmltest.xml")
 4 root = tree.getroot()
 5 print(root.tag)
 6  
 7 #遍历xml文档
 8 for child in root:
 9     print(child.tag, child.attrib)
10     for i in child:
11         print(i.tag,i.text)
12  
13 #只遍历year 节点
14 for node in root.iter('year'):
15     print(node.tag,node.text)
16 #---------------------------------------
17 
18 import xml.etree.ElementTree as ET
19  
20 tree = ET.parse("xmltest.xml")
21 root = tree.getroot()
22  
23 #修改
24 for node in root.iter('year'):
25     new_year = int(node.text) + 1
26     node.text = str(new_year)
27     node.set("updated","yes")
28  
29 tree.write("xmltest.xml")
30  
31  
32 #删除node
33 for country in root.findall('country'):
34    rank = int(country.find('rank').text)
35    if rank > 50:
36      root.remove(country)
37  
38 tree.write('output.xml')

View Code

自己创建xml文档：

 1 import xml.etree.ElementTree as ET
 2  
 3  
 4 new_xml = ET.Element("namelist")
 5 name = ET.SubElement(new_xml,"name",attrib={"enrolled":"yes"})
 6 age = ET.SubElement(name,"age",attrib={"checked":"no"})
 7 sex = ET.SubElement(name,"sex")
 8 sex.text = '33'
 9 name2 = ET.SubElement(new_xml,"name",attrib={"enrolled":"no"})
10 age = ET.SubElement(name2,"age")
11 age.text = '19'
12  
13 et = ET.ElementTree(new_xml) #生成文档对象
14 et.write("test.xml", encoding="utf-8",xml_declaration=True)
15  
16 ET.dump(new_xml) #打印生成的格式

创建xml文档

**九、configparser模块(* *)**

来看一个好多软件的常见文档格式如下：

[DEFAULT]
ServerAliveInterval = 45
Compression = yes
CompressionLevel = 9
ForwardX11 = yes
  
[bitbucket.org]
User = hg
  
[topsecret.server.com]
Port = 50022
ForwardX11 = no

如果想用python生成一个这样的文档怎么做呢？

import configparser
  
config = configparser.ConfigParser()
config["DEFAULT"] = {'ServerAliveInterval': '45',
                      'Compression': 'yes',
                     'CompressionLevel': '9'}
  
config['bitbucket.org'] = {}
config['bitbucket.org']['User'] = 'hg'
config['topsecret.server.com'] = {}
topsecret = config['topsecret.server.com']
topsecret['Host Port'] = '50022'     # mutates the parser
topsecret['ForwardX11'] = 'no'  # same here
config['DEFAULT']['ForwardX11'] = 'yes'<br>
with open('example.ini', 'w') as configfile:
   config.write(configfile)

 1 import configparser
 2 
 3 config = configparser.ConfigParser()
 4 
 5 #---------------------------------------------查
 6 print(config.sections())   #[]
 7 
 8 config.read('example.ini')
 9 
10 print(config.sections())   #['bitbucket.org', 'topsecret.server.com']
11 
12 print('bytebong.com' in config)# False
13 
14 print(config['bitbucket.org']['User']) # hg
15 
16 print(config['DEFAULT']['Compression']) #yes
17 
18 print(config['topsecret.server.com']['ForwardX11'])  #no
19 
20 
21 for key in config['bitbucket.org']:
22     print(key)
23 
24 
25 # user
26 # serveraliveinterval
27 # compression
28 # compressionlevel
29 # forwardx11
30 
31 
32 print(config.options('bitbucket.org'))#['user', 'serveraliveinterval', 'compression', 'compressionlevel', 'forwardx11']
33 print(config.items('bitbucket.org'))  #[('serveraliveinterval', '45'), ('compression', 'yes'), ('compressionlevel', '9'), ('forwardx11', 'yes'), ('user', 'hg')]
34 
35 print(config.get('bitbucket.org','compression'))#yes
36 
37 
38 #---------------------------------------------删,改,增(config.write(open('i.cfg', "w")))
39 
40 
41 config.add_section('yuan')
42 
43 config.remove_section('topsecret.server.com')
44 config.remove_option('bitbucket.org','user')
45 
46 config.set('bitbucket.org','k1','11111')
47 
48 config.write(open('i.cfg', "w"))

增删改查

**十、hashlib模块(* *)**

方式一：

import hashlib

hashlib.md5(b'alex').hexdigest()




方式二：

import hashlib

m = hashlib.md5()
m.update(b'alex')
m.hexdigest()

View Code

用于加密相关的操作，3.x里代替了md5模块和sha模块，主要提供 SHA1, SHA224, SHA256, SHA384, SHA512 ，MD5 算法

import hashlib
 
m=hashlib.md5()# m=hashlib.sha256()
 
m.update('hello'.encode('utf8'))
print(m.hexdigest())  #5d41402abc4b2a76b9719d911017c592
 
m.update('alvin'.encode('utf8'))
 
print(m.hexdigest())  #92a7e713c30abbb0319fa07da2a5c4af
 
m2=hashlib.md5()
m2.update('helloalvin'.encode('utf8'))
print(m2.hexdigest()) #92a7e713c30abbb0319fa07da2a5c4af

以上加密算法虽然依然非常厉害，但时候存在缺陷，即：通过撞库可以反解。所以，有必要对加密算法中添加自定义key再来做加密。

import hashlib
 
# ######## 256 ########
 
hash = hashlib.sha256('898oaFs09f'.encode('utf8'))
hash.update('alvin'.encode('utf8'))
print (hash.hexdigest())#e79e68f070cdedcfe63eaf1a2e92c83b4cfb1b5c6bc452d214c1b7e77cdfd1c7

python 还有一个 hmac 模块，它内部对我们创建 key 和内容再进行处理然后再加密:

import hmac
h = hmac.new('alvin'.encode('utf8'))
h.update('hello'.encode('utf8'))
print (h.hexdigest())#320df9832eab4c038b6c1d7ed73a5940

十一、subprocess模块(* * * *)

当我们需要调用系统的命令的时候，最先考虑的os模块。用os.system()和os.popen()来进行操作。但是这两个命令过于简单，不能完成一些复杂的操作，如给运行的命令提供输入或者读取命令的输出，判断该命令的运行状态，管理多个命令的并行等等。这时subprocess中的Popen命令就能有效的完成我们需要的操作。

subprocess模块允许一个进程创建一个新的子进程，通过管道连接到子进程的stdin/stdout/stderr，获取子进程的返回值等操作。

The subprocess module allows you to spawn new processes, connect to their input/output/error pipes, and obtain their return codes.

This module intends to replace several other, older modules and functions, such as: os.system、os.spawn*、os.popen*、popen2.*、commands.*

这个模块一个类：Popen。

#Popen它的构造函数如下：
 
subprocess.Popen(args, bufsize=0, executable=None, stdin=None, stdout=None,stderr=None, preexec_fn=None, close_fds=False, shell=False,<br>                 cwd=None, env=None, universal_newlines=False, startupinfo=None, creationflags=0)

 1 # 参数args可以是字符串或者序列类型（如：list，元组），用于指定进程的可执行文件及其参数。
 2 # 如果是序列类型，第一个元素通常是可执行文件的路径。我们也可以显式的使用executeable参
 3 # 数来指定可执行文件的路径。在windows操作系统上，Popen通过调用CreateProcess()来创
 4 # 建子进程,CreateProcess接收一个字符串参数，如果args是序列类型，系统将会通过
 5 # list2cmdline()函数将序列类型转换为字符串。
 6 # 
 7 # 
 8 # 参数bufsize：指定缓冲。我到现在还不清楚这个参数的具体含义，望各个大牛指点。
 9 # 
10 # 参数executable用于指定可执行程序。一般情况下我们通过args参数来设置所要运行的程序。如
11 # 果将参数shell设为True，executable将指定程序使用的shell。在windows平台下，默认的
12 # shell由COMSPEC环境变量来指定。
13 # 
14 # 参数stdin, stdout, stderr分别表示程序的标准输入、输出、错误句柄。他们可以是PIPE，
15 # 文件描述符或文件对象，也可以设置为None，表示从父进程继承。
16 # 
17 # 参数preexec_fn只在Unix平台下有效，用于指定一个可执行对象（callable object），它将
18 # 在子进程运行之前被调用。
19 # 
20 # 参数Close_sfs：在windows平台下，如果close_fds被设置为True，则新创建的子进程将不会
21 # 继承父进程的输入、输出、错误管道。我们不能将close_fds设置为True同时重定向子进程的标准
22 # 输入、输出与错误(stdin, stdout, stderr)。
23 # 
24 # 如果参数shell设为true，程序将通过shell来执行。
25 # 
26 # 参数cwd用于设置子进程的当前目录。
27 # 
28 # 参数env是字典类型，用于指定子进程的环境变量。如果env = None，子进程的环境变量将从父
29 # 进程中继承。
30 # 
31 # 参数Universal_newlines:不同操作系统下，文本的换行符是不一样的。如：windows下
32 # 用’/r/n’表示换，而Linux下用’/n’。如果将此参数设置为True，Python统一把这些换行符当
33 # 作’/n’来处理。
34 # 
35 # 参数startupinfo与createionflags只在windows下用效，它们将被传递给底层的
36 # CreateProcess()函数，用于设置子进程的一些属性，如：主窗口的外观，进程的优先级等等。

parameter

简单命令：

import subprocess
 
a=subprocess.Popen('ls')#  创建一个新的进程,与主进程不同步
 
print('>>>>>>>',a)#a是Popen的一个实例对象
 
'''
>>>>>>> <subprocess.Popen object at 0x10185f860>
__init__.py
__pycache__
log.py
main.py
 
'''
 
# subprocess.Popen('ls -l',shell=True)
 
# subprocess.Popen(['ls','-l'])

subprocess.PIPE

在创建Popen对象时，subprocess.PIPE可以初始化stdin, stdout或stderr参数。表示与子进程通信的标准流。

import subprocess
 
# subprocess.Popen('ls')
p=subprocess.Popen('ls',stdout=subprocess.PIPE)#结果跑哪去啦?
 
print(p.stdout.read())#这这呢:b'__pycache__\nhello.py\nok.py\nweb\n'

这是因为subprocess创建了子进程，结果本在子进程中，if 想要执行结果转到主进程中，就得需要一个管道，即： stdout=subprocess.PIPE

subprocess.STDOUT

创建Popen对象时，用于初始化stderr参数，表示将错误通过标准输出流输出。

Popen的方法

 1 Popen.poll() 
 2 用于检查子进程是否已经结束。设置并返回returncode属性。
 3 
 4 Popen.wait() 
 5 等待子进程结束。设置并返回returncode属性。
 6 
 7 Popen.communicate(input=None)
 8 与子进程进行交互。向stdin发送数据，或从stdout和stderr中读取数据。可选参数input指定发送到子进程的参数。 Communicate()返回一个元组：(stdoutdata, stderrdata)。注意：如果希望通过进程的stdin向其发送数据，在创建Popen对象的时候，参数stdin必须被设置为PIPE。同样，如 果希望从stdout和stderr获取数据，必须将stdout和stderr设置为PIPE。
 9 
10 Popen.send_signal(signal) 
11 向子进程发送信号。
12 
13 Popen.terminate()
14 停止(stop)子进程。在windows平台下，该方法将调用Windows API TerminateProcess（）来结束子进程。
15 
16 Popen.kill()
17 杀死子进程。
18 
19 Popen.stdin 
20 如果在创建Popen对象是，参数stdin被设置为PIPE，Popen.stdin将返回一个文件对象用于策子进程发送指令。否则返回None。
21 
22 Popen.stdout 
23 如果在创建Popen对象是，参数stdout被设置为PIPE，Popen.stdout将返回一个文件对象用于策子进程发送指令。否则返回 None。
24 
25 Popen.stderr 
26 如果在创建Popen对象是，参数stdout被设置为PIPE，Popen.stdout将返回一个文件对象用于策子进程发送指令。否则返回 None。
27 
28 Popen.pid 
29 获取子进程的进程ID。
30 
31 Popen.returncode 
32 获取进程的返回值。如果进程还没有结束，返回None。

View Code

supprocess模块的工具函数

supprocess模块提供了一些函数，方便我们用于创建进程来实现一些简单的功能。
 
subprocess.call(*popenargs, **kwargs)
运行命令。该函数将一直等待到子进程运行结束，并返回进程的returncode。如果子进程不需要进行交 互,就可以使用该函数来创建。
 
subprocess.check_call(*popenargs, **kwargs)
与subprocess.call(*popenargs, **kwargs)功能一样，只是如果子进程返回的returncode不为0的话，将触发CalledProcessError异常。在异常对象中，包 括进程的returncode信息。
 
check_output(*popenargs, **kwargs)
与call()方法类似，以byte string的方式返回子进程的输出，如果子进程的返回值不是0，它抛出CalledProcessError异常，这个异常中的returncode包含返回码，output属性包含已有的输出。
 
getstatusoutput(cmd)/getoutput(cmd)
这两个函数仅仅在Unix下可用，它们在shell中执行指定的命令cmd，前者返回(status, output)，后者返回output。其中，这里的output包括子进程的stdout和stderr。

 1 import subprocess
 2 
 3 #1
 4 # subprocess.call('ls',shell=True)
 5 '''
 6 hello.py
 7 ok.py
 8 web
 9 '''
10 # data=subprocess.call('ls',shell=True)
11 # print(data)
12 '''
13 hello.py
14 ok.py
15 web
16 '''
17 
18 #2
19 # subprocess.check_call('ls',shell=True)
20 
21 '''
22 hello.py
23 ok.py
24 web
25 '''
26 # data=subprocess.check_call('ls',shell=True)
27 # print(data)
28 '''
29 hello.py
30 ok.py
31 web
32 '''
33 # 两个函数区别:只是如果子进程返回的returncode不为0的话，将触发CalledProcessError异常
34 
35 
36 
37 #3
38 # subprocess.check_output('ls')#无结果
39 
40 # data=subprocess.check_output('ls')
41 # print(data)  #b'hello.py\nok.py\nweb\n'

演示

交互命令：

终端输入的命令分为两种：

输入即可得到输出，如：ifconfig
输入进行某环境，依赖再输入，如：python

需要交互的命令示例

待续

十二、logging模块(* * * * *)

import logging

# 日志输出的基本配置
logging.basicConfig(filename='lol_logging.log', level=logging.INFO, format='%(asctime)s - %(levelname)s: %(message)s')

logging.info(xxx)

https://www.cnblogs.com/wupeiqi/articles/5501365.html

一 (简单应用)

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

输出：

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

可见，默认情况下Python的logging模块将日志打印到了标准输出中，且只显示了大于等于WARNING级别的日志，这说明默认的日志级别设置为WARNING（日志级别等级CRITICAL > ERROR > WARNING > INFO > DEBUG > NOTSET），默认的日志格式为日志级别：Logger名称：用户输出消息。

二 灵活配置日志级别，日志格式，输出位置

 1 import traceback
 2 
 3 def func():
 4     try:
 5         a = a +1
 6     except Exception as e:
 7         # 获取当前错误的堆栈信息
 8         msg = traceback.format_exc()
 9         logging.error(msg)
10 func()

捕获精准错误信息

import logging  
logging.basicConfig(level=logging.DEBUG,  
                    format='%(asctime)s %(name)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')

查看输出：
cat /tmp/test.log
Mon, 05 May 2014 16:29:53 test_logging.py[line:9] DEBUG debug message
Mon, 05 May 2014 16:29:53 test_logging.py[line:10] INFO info message
Mon, 05 May 2014 16:29:53 test_logging.py[line:11] WARNING warning message
Mon, 05 May 2014 16:29:53 test_logging.py[line:12] ERROR error message
Mon, 05 May 2014 16:29:53 test_logging.py[line:13] CRITICAL critical message

可见在logging.basicConfig()函数中可通过具体参数来更改logging模块默认行为，可用参数有
filename：用指定的文件名创建FiledHandler（后边会具体讲解handler的概念），这样日志会被存储在指定的文件中。
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对象

 1 import logging
 2 logger = logging.getLogger('s')
 3 fh = logging.FileHandler('test.log')# 创建一个handler，用于写入日志文件
 4 ch = logging.StreamHandler()# 再创建一个handler，用于输出到控制台
 5 formatter = logging.Formatter('%(asctime)s - %(name)s - %(levelname)s - %(message)s')
 6 fh.setFormatter(formatter)
 7 ch.setFormatter(formatter)
 8 logger.addHandler(fh) #logger对象可以添加多个fh和ch对象
 9 logger.addHandler(ch)
10 logger.setLevel(logging.ERROR)
11 logger.debug('logger debug message')
12 logger.info('logger info message')
13 logger.warning('logger warning message')
14 logger.error('logger error message')
15 logger.critical('logger critical message')
16 def f():
17     try:
18         a = a + 1
19     except Exception as e:
20         logger.error(str(e))
21 
22 f()

logger示例

 1 import traceback
 2 
 3 def func():
 4     try:
 5         a = a +1
 6     except Exception as e:
 7         # 获取当前错误的堆栈信息
 8         msg = traceback.format_exc()
 9         logger.error(msg)
10 func()

捕获精准错误信息

上述几个例子中我们了解到了logging.debug()、logging.info()、logging.warning()、logging.error()、logging.critical()（分别用以记录不同级别的日志信息），logging.basicConfig()（用默认日志格式（Formatter）为日志系统建立一个默认的流处理器（StreamHandler），设置基础配置（如日志级别等）并加到root logger（根Logger）中）这几个logging模块级别的函数，另外还有一个模块级别的函数是logging.getLogger([name])（返回一个logger对象，如果没有指定名字将返回root logger）

先看一个最简单的过程：

import logging

logger = logging.getLogger('s') #也可写为 logger = logging.Logger('s', level=logging.DEBUG)
# 创建一个handler，用于写入日志文件
fh = logging.FileHandler('test.log')

# 再创建一个handler，用于输出到控制台
ch = logging.StreamHandler()

formatter = logging.Formatter('%(asctime)s - %(name)s - %(levelname)s - %(message)s')

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指定日志显示格式。

(1)

Logger是一个树形层级结构，输出信息之前都要获得一个Logger（如果没有显示的获取则自动创建并使用root Logger，如第一个例子所示）。
logger = logging.getLogger()返回一个默认的Logger也即root Logger，并应用默认的日志级别、Handler和Formatter设置。
当然也可以通过Logger.setLevel(lel)指定最低的日志级别，可用的日志级别有logging.DEBUG、logging.INFO、logging.WARNING、logging.ERROR、logging.CRITICAL。
Logger.debug()、Logger.info()、Logger.warning()、Logger.error()、Logger.critical()输出不同级别的日志，只有日志等级大于或等于设置的日志级别的日志才会被输出。

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

只输出了
2014-05-06 12:54:43,222 - root - WARNING - logger warning message
2014-05-06 12:54:43,223 - root - ERROR - logger error message
2014-05-06 12:54:43,224 - root - CRITICAL - logger critical message
从这个输出可以看出logger = logging.getLogger()返回的Logger名为root。这里没有用logger.setLevel(logging.Debug)显示的为logger设置日志级别，所以使用默认的日志级别WARNIING，故结果只输出了大于等于WARNIING级别的信息。

(2) 如果我们再创建两个logger对象：

##################################################
logger1 = logging.getLogger('mylogger') #也可写为 logger1 = logging.Logger('mylogger', level=logging.DEBUG)

logger1.setLevel(logging.DEBUG) 
logger2 = logging.getLogger('mylogger')#也可写为 logger2 = logging.Logger('mylogger', level=logging.INFO)

logger2.setLevel(logging.INFO) 
logger1.addHandler(fh) 
logger1.addHandler(ch) 
logger2.addHandler(fh) 
logger2.addHandler(ch) 
logger1.debug('logger1 debug message') 
logger1.info('logger1 info message') 
logger1.warning('logger1 warning message') 
logger1.error('logger1 error message') 
logger1.critical('logger1 critical message') 
logger2.debug('logger2 debug message') 
logger2.info('logger2 info message') 
logger2.warning('logger2 warning message') 
logger2.error('logger2 error message') 
logger2.critical('logger2 critical message')

结果：

这里有两个个问题：

<1>我们明明通过logger1.setLevel(logging.DEBUG)将logger1的日志级别设置为了DEBUG，为何显示的时候没有显示出DEBUG级别的日志信息，而是从INFO级别的日志开始显示呢？

原来logger1和logger2对应的是同一个Logger实例，只要logging.getLogger（name）中名称参数name相同则返回的Logger实例就是同一个，且仅有一个，也即name与Logger实例一一对应。在logger2实例中通过logger2.setLevel(logging.INFO)设置mylogger的日志级别为logging.INFO，所以最后logger1的输出遵从了后来设置的日志级别。

<2>为什么logger1、logger2对应的每个输出分别显示两次?
这是因为我们通过logger = logging.getLogger()显示的创建了root Logger，而logger1 = logging.getLogger('mylogger')创建了root Logger的孩子(root.)mylogger,logger2同样。而孩子,孙子，重孙……既会将消息分发给他的handler进行处理也会传递给所有的祖先Logger处理。

ok,那么现在我们把

# logger.addHandler(fh)

# logger.addHandler(ch) 注释掉，我们再来看效果：

因为我们注释了logger对象显示的位置，所以才用了默认方式，即标准输出方式。因为它的父级没有设置文件显示方式，所以在这里只打印了一次。

孩子,孙子，重孙……可逐层继承来自祖先的日志级别、Handler、Filter设置，也可以通过Logger.setLevel(lel)、Logger.addHandler(hdlr)、Logger.removeHandler(hdlr)、Logger.addFilter(filt)、Logger.removeFilter(filt)。设置自己特别的日志级别、Handler、Filter。若不设置则使用继承来的值。

<3>Filter
限制只有满足过滤规则的日志才会输出。
比如我们定义了filter = logging.Filter('a.b.c'),并将这个Filter添加到了一个Handler上，则使用该Handler的Logger中只有名字带 a.b.c前缀的Logger才能输出其日志。

filter = logging.Filter('mylogger')

logger.addFilter(filter)

这是只对logger这个对象进行筛选

如果想对所有的对象进行筛选，则：

filter = logging.Filter('mylogger')

fh.addFilter(filter)

ch.addFilter(filter)

这样，所有添加fh或者ch的logger对象都会进行筛选。

完整代码1：

 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 ch.setFormatter(formatter)
14 
15 # 定义一个filter
16 filter = logging.Filter('mylogger')
17 fh.addFilter(filter)
18 ch.addFilter(filter)
19 
20 # logger.addFilter(filter)
21 logger.addHandler(fh)
22 logger.addHandler(ch)
23 
24 
25 
26 
27 logger.setLevel(logging.DEBUG)
28 
29 logger.debug('logger debug message')
30 logger.info('logger info message')
31 logger.warning('logger warning message')
32 logger.error('logger error message')
33 logger.critical('logger critical message')
34 
35 ##################################################
36 logger1 = logging.getLogger('mylogger')
37 logger1.setLevel(logging.DEBUG)
38 
39 logger2 = logging.getLogger('mylogger')
40 logger2.setLevel(logging.INFO)
41 
42 logger1.addHandler(fh)
43 logger1.addHandler(ch)
44 
45 logger2.addHandler(fh)
46 logger2.addHandler(ch)
47 
48 logger1.debug('logger1 debug message')
49 logger1.info('logger1 info message')
50 logger1.warning('logger1 warning message')
51 logger1.error('logger1 error message')
52 logger1.critical('logger1 critical message')
53 
54 logger2.debug('logger2 debug message')
55 logger2.info('logger2 info message')
56 logger2.warning('logger2 warning message')
57 logger2.error('logger2 error message')
58 logger2.critical('logger2 critical message')

View Code

完整代码2：

 1 #coding:utf-8  
 2 import logging  
 3   
 4 # 创建一个logger    
 5 logger = logging.getLogger()  
 6   
 7 logger1 = logging.getLogger('mylogger')  
 8 logger1.setLevel(logging.DEBUG)  
 9   
10 logger2 = logging.getLogger('mylogger')  
11 logger2.setLevel(logging.INFO)  
12   
13 logger3 = logging.getLogger('mylogger.child1')  
14 logger3.setLevel(logging.WARNING)  
15   
16 logger4 = logging.getLogger('mylogger.child1.child2')  
17 logger4.setLevel(logging.DEBUG)  
18   
19 logger5 = logging.getLogger('mylogger.child1.child2.child3')  
20 logger5.setLevel(logging.DEBUG)  
21   
22 # 创建一个handler，用于写入日志文件    
23 fh = logging.FileHandler('/tmp/test.log')  
24   
25 # 再创建一个handler，用于输出到控制台    
26 ch = logging.StreamHandler()  
27   
28 # 定义handler的输出格式formatter    
29 formatter = logging.Formatter('%(asctime)s - %(name)s - %(levelname)s - %(message)s')  
30 fh.setFormatter(formatter)  
31 ch.setFormatter(formatter)  
32   
33 #定义一个filter  
34 #filter = logging.Filter('mylogger.child1.child2')  
35 #fh.addFilter(filter)    
36   
37 # 给logger添加handler    
38 #logger.addFilter(filter)  
39 logger.addHandler(fh)  
40 logger.addHandler(ch)  
41   
42 #logger1.addFilter(filter)  
43 logger1.addHandler(fh)  
44 logger1.addHandler(ch)  
45   
46 logger2.addHandler(fh)  
47 logger2.addHandler(ch)  
48   
49 #logger3.addFilter(filter)  
50 logger3.addHandler(fh)  
51 logger3.addHandler(ch)  
52   
53 #logger4.addFilter(filter)  
54 logger4.addHandler(fh)  
55 logger4.addHandler(ch)  
56   
57 logger5.addHandler(fh)  
58 logger5.addHandler(ch)  
59   
60 # 记录一条日志    
61 logger.debug('logger debug message')  
62 logger.info('logger info message')  
63 logger.warning('logger warning message')  
64 logger.error('logger error message')  
65 logger.critical('logger critical message')  
66   
67 logger1.debug('logger1 debug message')  
68 logger1.info('logger1 info message')  
69 logger1.warning('logger1 warning message')  
70 logger1.error('logger1 error message')  
71 logger1.critical('logger1 critical message')  
72   
73 logger2.debug('logger2 debug message')  
74 logger2.info('logger2 info message')  
75 logger2.warning('logger2 warning message')  
76 logger2.error('logger2 error message')  
77 logger2.critical('logger2 critical message')  
78   
79 logger3.debug('logger3 debug message')  
80 logger3.info('logger3 info message')  
81 logger3.warning('logger3 warning message')  
82 logger3.error('logger3 error message')  
83 logger3.critical('logger3 critical message')  
84   
85 logger4.debug('logger4 debug message')  
86 logger4.info('logger4 info message')  
87 logger4.warning('logger4 warning message')  
88 logger4.error('logger4 error message')  
89 logger4.critical('logger4 critical message')  
90   
91 logger5.debug('logger5 debug message')  
92 logger5.info('logger5 info message')  
93 logger5.warning('logger5 warning message')  
94 logger5.error('logger5 error message')  
95 logger5.critical('logger5 critical message')

View Code

应用：

 1 import os
 2 import time
 3 import logging
 4 from config import settings
 5 
 6 
 7 def get_logger(card_num, struct_time):
 8 
 9     if struct_time.tm_mday < 23:
10         file_name = "%s_%s_%d" %(struct_time.tm_year, struct_time.tm_mon, 22)
11     else:
12         file_name = "%s_%s_%d" %(struct_time.tm_year, struct_time.tm_mon+1, 22)
13 
14     file_handler = logging.FileHandler(
15         os.path.join(settings.USER_DIR_FOLDER, card_num, 'record', file_name),
16         encoding='utf-8'
17     )
18     fmt = logging.Formatter(fmt="%(asctime)s :  %(message)s")
19     file_handler.setFormatter(fmt)
20 
21     logger1 = logging.Logger('user_logger', level=logging.INFO)
22     logger1.addHandler(file_handler)
23     return logger1

View Code

十三、re模块(* * * * *)

就其本质而言，正则表达式（或 RE）是一种小型的、高度专业化的编程语言，（在Python中）它内嵌在Python中，并通过 re 模块实现。正则表达式模式被编译成一系列的字节码，然后由用 C 编写的匹配引擎执行。

常用匹配规则：

匹配整数   \d+
匹配小数   \d+\.\d+
匹配小数或者整数
                        \d+\.\d+|\d+
                        \d+(\.\d+)?
匹配身份证号码 : [1-9]\d{16}[\dx]|[1-9]\d{14}
                       [1-9]\d{14}(\d{2}[\dX])?
爬虫常用：  .*?x   匹配任意非换行符字符任意长度 直到遇到x就停止
# 1、匹配整数或者小数（包括正数和负数）
# -?\d+(\.\d+)?

# 2、匹配年月日日期 格式2018-12-6
# ^[1-9]\d{0,3}-(1[0-2]|0?[1-9])-(3[01]|[12]\d|0?[1-9])$

# 3、匹配qq号
# [1-9]\d{4,11}

# 4、11位的电话号码
# 1[3-9]\d{9}

# 5、长度为8-10位的用户密码 ： 包含数字字母下划线
# \w{8,10}

# 6、匹配验证码：4位数字字母组成的
# [\da-zA-Z]{4}
# [0-9a-zA-Z]{4}

# 7、匹配邮箱地址
# [0-9a-zA-Z][\w\-.]+@[a-zA-Z0-9\-]+(\.[a-zA-Z0-9\-]+)*\.[A-Za-z0-9]{2,6}

# 8、从类似
# <a>wahaha</a>
# <b>banana</b>
# <h1>qqxing</h1>
# 这样的字符串中，
# 1）匹配出wahaha，banana，qqxing内容。
    #  有些时候你要匹配的内容和你不想匹配的内容符合的正则规则是一样的
# \w{6}
# >\w+<

# 2）匹配出a,b,h1这样的内容
# <\w+>

# 9、1-2*((60-30+(-40/5)*(9-2*5/3+7/3*99/4*2998+10*568/14))-(-4*3)/(16-3*2))
# 1）从上面算式中匹配出内层没有其他小括号的表达式
# \([^()]+\)

# 10、从类似9-1000/3+7/3*99/4*2998+10*568/14的表达式中匹配出从左到右第一个乘法或除法
# \d+[*/]\d+

View Code

 1 import re
 2 from urllib.request import urlopen
 3 
 4 def getPage(url):   # 获取网页的字符串
 5     response = urlopen(url)
 6     return response.read().decode('utf-8')
 7 
 8 def parsePage(s):
 9     ret = com.finditer(s)  # 从s这个网页源码中 找到所有符合com正则表达式规则的内容 并且以迭代器的形式返回
10     for i in ret:
11         yield {
12             "id": i.group("id"),
13             "title": i.group("title"),
14             "rating_num": i.group("rating_num"),
15             "comment_num": i.group("comment_num"),
16         }
17 
18 def main(num):  # 0  25 50  # 这个函数执行10次,每次爬取一页的内容
19     url = 'https://movie.douban.com/top250?start=%s&filter=' % num
20     response_html = getPage(url)   # response_html就是这个url对应的html代码 就是 str
21     ret = parsePage(response_html) # ret是一个生成器
22     print(ret)
23     f = open("move_info7", "a", encoding="utf8")
24     for obj in ret:
25         print(obj)
26         data = str(obj)
27         f.write(data + "\n")
28     f.close()
29 
30 com = re.compile(
31         '<div class="item">.*?<div class="pic">.*?<em .*?>(?P<id>\d+).*?<span class="title">(?P<title>.*?)</span>'
32         '.*?<span class="rating_num" .*?>(?P<rating_num>.*?)</span>.*?<span>(?P<comment_num>.*?)评价</span>', re.S)
33 
34 count = 0
35 for i in range(10):
36     main(count)
37     count += 25

爬虫示例

 1 import re
 2 def atom_cal(exp):
 3     if '*' in exp:
 4         a,b = exp.split('*')
 5         return str(float(a) * float(b))
 6     elif '/' in exp:
 7         a, b = exp.split('/')
 8         return str(float(a) / float(b))
 9 
10 def format_exp(exp):
11     exp = exp.replace('--','+')
12     exp = exp.replace('+-','-')
13     exp = exp.replace('-+','-')
14     exp = exp.replace('++','+')
15     return exp
16 
17 def mul_div(exp):
18     while True:
19         ret = re.search('\d+(\.\d+)?[*/]-?\d+(\.\d+)?',exp)
20         if ret:
21             atom_exp = ret.group()
22             res = atom_cal(atom_exp)
23             exp = exp.replace(atom_exp,res)
24         else:return exp
25 
26 def add_sub(exp):
27     ret = re.findall('[+-]?\d+(?:\.\d+)?', exp)
28     exp_sum = 0
29     for i in ret:
30         exp_sum += float(i)
31     return exp_sum
32 
33 def cal(exp):
34     exp = mul_div(exp)
35     exp = format_exp(exp)
36     exp_sum =  add_sub(exp)
37     return exp_sum   # float
38 
39 def main(exp):
40     exp = exp.replace(' ','')
41     while True:
42         ret = re.search('\([^()]+\)',exp)
43         if ret :
44             inner_bracket = ret.group()
45             res = str(cal(inner_bracket))
46             exp = exp.replace(inner_bracket,res)
47             exp = format_exp(exp)
48         else:break
49     return cal(exp)
50 
51 s = '1 - 2 * ( (60-30 +(-40/5) * (9-2*5/3 + 7 /3*99/4*2998 +10 * 568/14 )) - (-4*3)/ (16-3*2) )'
52 ret = main(s)
53 print(ret,type(ret))

计算器示例

字符匹配（普通字符，元字符）：

1 普通字符：大多数字符和字母都会和自身匹配
>>> re.findall('alvin','yuanaleSxalexwupeiqi')
['alvin']

2 元字符：. ^ $ * + ? { } [ ] | ( ) \

元字符之. ^ $ * + ? { }

import re
 
ret=re.findall('a..in','helloalvin')
print(ret)#['alvin']
 
ret=re.findall('^a...n','alvinhelloawwwn')
print(ret)#['alvin']
 
ret=re.findall('a...n$','alvinhelloawwwn')
print(ret)#['awwwn']
 
ret=re.findall('a...n$','alvinhelloawwwn')
print(ret)#['awwwn']
 
ret=re.findall('abc*','abcccc')#贪婪匹配[0,+oo]  
print(ret)#['abcccc']
 
ret=re.findall('abc+','abccc')#[1,+oo]
print(ret)#['abccc']
 
ret=re.findall('abc?','abccc')#[0,1]
print(ret)#['abc']
 
ret=re.findall('abc{1,4}','abccc')
print(ret)#['abccc'] 贪婪匹配

注意：前面的*,+,?等都是贪婪匹配，也就是尽可能匹配，后面加?号使其变成惰性匹配

ret=re.findall('abc*?','abcccccc')
print(ret)#['ab']

元字符之字符集［］：

#--------------------------------------------字符集[]
ret=re.findall('a[bc]d','acd')
print(ret)#['acd']
 
ret=re.findall('[a-z]','acd')
print(ret)#['a', 'c', 'd']
 
ret=re.findall('[.*+]','a.cd+')
print(ret)#['.', '+']
 
#在字符集里有功能的符号: - ^ \
 
ret=re.findall('[1-9]','45dha3')
print(ret)#['4', '5', '3']
 
ret=re.findall('[^ab]','45bdha3')
print(ret)#['4', '5', 'd', 'h', '3']
 
ret=re.findall('[\d]','45bdha3')
print(ret)#['4', '5', '3']

元字符之转义符\

反斜杠后边跟元字符去除特殊功能,比如\.
反斜杠后边跟普通字符实现特殊功能,比如\d

\d 匹配任何十进制数；它相当于类 [0-9]。
\D 匹配任何非数字字符；它相当于类 [^0-9]。
\s 匹配任何空白字符；它相当于类 [ \t\n\r\f\v]。
\S 匹配任何非空白字符；它相当于类 [^ \t\n\r\f\v]。
\w 匹配任何字母数字字符；它相当于类 [a-zA-Z0-9_]。
\W 匹配任何非字母数字字符；它相当于类 [^a-zA-Z0-9_]
\b 匹配一个特殊字符边界，比如空格，&，＃等

ret=re.findall('I\b','I am LIST')
print(ret)#[]
ret=re.findall(r'I\b','I am LIST')
print(ret)#['I']

现在我们聊一聊\,先看下面两个匹配：

#-----------------------------eg1:
import re
ret=re.findall('c\l','abc\le')
print(ret)#[]
ret=re.findall('c\\l','abc\le')
print(ret)#[]
ret=re.findall('c\\\\l','abc\le')
print(ret)#['c\\l']
ret=re.findall(r'c\\l','abc\le')
print(ret)#['c\\l']
 
#-----------------------------eg2:
#之所以选择\b是因为\b在ASCII表中是有意义的
m = re.findall('\bblow', 'blow')
print(m)
m = re.findall(r'\bblow', 'blow')
print(m)

元字符之分组()

 1 # 分组命名 (?P<这个组的名字>正则表达式)
 2 # s = '<a>wahaha</a>'
 3 # ret = re.search('>(?P<con>\w+)<',s)
 4 # print(ret.group(1))
 5 # print(ret.group('con'))
 6 
 7 # s = '<a>wahaha</a>'
 8 # pattern = '<(\w+)>(\w+)</(\w+)>'
 9 # ret = re.search(pattern,s)
10 # print(ret.group(1) == ret.group(3))
11 
12 # 使用前面的分组 要求使用这个名字的分组和前面同名分组中的内容匹配的必须一致
13 # pattern = '<(?P<tab>\w+)>(\w+)</(?P=tab)>'
14 # ret = re.search(pattern,s)
15 # print(ret)

m = re.findall(r'(ad)+', 'add')
print(m)
 
ret=re.search('(?P<id>\d{2})/(?P<name>\w{3})','23/com')
print(ret.group())#23/com
print(ret.group('id'))#23

元字符之｜

ret=re.search('(ab)|\d','rabhdg8sd')
print(ret.group())#ab

re模块下的常用方法

import re
#1
re.findall('a','alvin yuan')    #返回所有满足匹配条件的结果,放在列表里
# 为了findall也可以顺利取到分组中的内容,有一个特殊的语法,就是优先显示分组中的内容
# ret = re.findall('\d+(\.\d+)?','1.234*4')
# print(ret)     #['.234','']
# 取消分组优先(?:正则表达式)
# ret = re.findall('\d+(?:\.\d+)?','1.234*4')
# print(ret)      #['1.234','4']
 
#2
re.search('a','alvin yuan').group()  #函数会在字符串内查找模式匹配,只到找到第一个匹配然后返回一个包含匹配信息的对象,该对象可以
                                     # 通过调用group()方法得到匹配的字符串,如果字符串没有匹配，则返回None。匹配不到结果时调用group会报错，
       常规用法：        # if ret : # 内存地址,这是一个正则匹配的结果
                                       #     print(ret.group()) # 通过ret.group()获取真正的结果
 
#3
re.match('a','abc').group()     #同search,不过尽在字符串开始处进行匹配
 
#4
ret=re.split('[ab]','abcd')     #先按'a'分割得到''和'bcd',在对''和'bcd'分别按'b'分割
print(ret)#['', '', 'cd']
# ret = re.split('(\d+)','alex83taibai40egon25aa')          分组(分割的刀)会保留刀
# print(ret)  #['alex', '83', 'taibai', '40', 'egon', '25', 'aa']
 
#5
ret=re.sub('\d','abc','alvin5yuan6',1)
print(ret)#alvinabcyuan6
ret=re.subn('\d','abc','alvin5yuan6')
print(ret)#('alvinabcyuanabc', 2)
 
#6 compile  编译一个正则表达式,用这个结果去search match findall finditer 能够节省时间
obj=re.compile('\d{3}')
ret=obj.search('abc123eeee')
print(ret.group())#123

finditer 返回一个迭代器,所有的结果都在这个迭代器中,需要通过循环+group的形式取值 能够节省内存
import re
ret=re.finditer('\d','ds3sy4784a')
print(ret)        #<callable_iterator object at 0x10195f940>
 
print(next(ret).group())
print(next(ret).group())

注意：

import re
 
ret=re.findall('www.(baidu|oldboy).com','www.oldboy.com')
print(ret)#['oldboy']     这是因为findall会优先把匹配结果组里内容返回,如果想要匹配结果,取消权限即可
 
ret=re.findall('www.(?:baidu|oldboy).com','www.oldboy.com')
print(ret)#['www.oldboy.com']

补充：

1 import re
2 
3 print(re.findall("<(?P<tag_name>\w+)>\w+</(?P=tag_name)>","<h1>hello</h1>"))
4 print(re.search("<(?P<tag_name>\w+)>\w+</(?P=tag_name)>","<h1>hello</h1>"))
5 print(re.search(r"<(\w+)>\w+</\1>","<h1>hello</h1>"))

View Code

补充2

1 #匹配出所有的整数
2 import re
3 
4 #ret=re.findall(r"\d+{0}]","1-2*(60+(-40.35/5)-(-4*3))")
5 ret=re.findall(r"-?\d+\.\d*|(-?\d+)","1-2*(60+(-40.35/5)-(-4*3))")
6 ret.remove("")
7 
8 print(ret)

View Code

十四、collections模块

　　参考：https://www.cnblogs.com/Eva-J/articles/7228075.html

十五、struct模块

　　参考：https://www.cnblogs.com/1832921tongjieducn/p/11352380.html

返回顶部

posted on 2019-04-14 17:22 始终不够啊阅读(160) 评论(0) 编辑收藏举报

刷新页面返回顶部

模块

一、模块&包(* * * * *)

模块(modue)的概念：

模块导入方法

包(package)

注意点（important）

二、time模块(* * * *)

三种时间表示

calendar模块

三、random模块(* *)

四、os模块(* * * *)

五、sys模块(* * *) sys模块是与python解释器交互的一个接口

六、json & pickle(* * * *)

什么是序列化？

json

pickle

七、shelve模块(* * *)

八、xml模块(* *)

九、configparser模块(* *)

十、hashlib模块(* *)

十一、subprocess模块(* * * *)

简单命令：

subprocess.PIPE

subprocess.STDOUT

Popen的方法

supprocess模块的工具函数

交互命令：

十二、logging模块(* * * * *)

十三、re模块(* * * * *)

元字符之. ^ $ * + ? { }

元字符之字符集［］：

元字符之转义符\

元字符之分组()

元字符之｜

re模块下的常用方法

公告

pickle　

**九、configparser模块(* *)**

**十、hashlib模块(* *)**