第1章 模块
1.1 概述
1.2 模块的分类
1.2.1 内置模块
1.2.2 扩展模块
1.2.3 模块安装
1.2.4 自定义模块
第2章 模块之内置模块
2.1 collections模块
2.1.1 collections数据类型
2.1.2 nametuple
2.1.3 可命名元组
2.1.4 queue 模块
2.1.5 Ordereddict有序字典
2.1.6 defaultfict 默认字典
2.2 time模块
2.2.1 sleep
2.3 时间的表示格式
2.3.1 时间戳(timestamp)
2.3.2 格式化时间(Format String)
2.3.3 元组(struct_time)
2.3.4 时间戳的转化
2.3.5 字符串时间的转化方法
2.4 random
2.4.1 随机小数
2.4.2 随机整数
2.4.3 打乱列表顺序
2.4.4 随机练习：验证
2.4.5 练习题:抢红包
2.5 sys模块
2.5.1 定义
2.5.2 调用方法
2.5.3 ****sys.path
2.5.4 sys.platform
2.5.5 sys.version
2.5.6 sys.modules
2.5.7 sys.exit()
2.5.8 sys.argv
2.6 os模块
2.6.1 os参数整理
2.6.2 os.getcwd
2.6.3 __file__
2.6.4 os.chdir
2.6.5 os.stat(‘path/filename‘)
2.6.6 os.path.getsize
2.6.7 目录大小统计练习
2.7 re模块
2.7.1 解释：
2.7.2 规则：
2.7.3 字符组
2.7.4 字符：
2.7.5 量词：
2.7.6 . ^ $
2.7.7 * + ? { }
2.7.8 字符集[][^]
2.7.9 分组 ()与 或 ｜［^］
2.7.10 转义符 \
2.7.11 贪婪匹配
2.7.12 常用的非贪婪匹配Pattern
2.7.13 +?
2.7.14 .*?的用法
2.7.15 re模块应用
2.7.16 正则应用
2.7.17 惰性匹配
2.7.18 search找一个
2.7.19 分组优先
2.7.20 search中没有分组优先
2.7.21 ？的用法
第3章 拾遗
3.1 进度条

第1章 模块

1.1 概述

n  解释：python有很多现成的函数方法，但这些函数不能都放在内存里，为用户节省很多不必要的内存消耗，用不到的内容就不用导入内存中。

n  定义：一组python或c语言的代码；一堆写好的函数或者类

n  以功能来分类

1.2 模块的分类

1.2.1 内置模块

解释：随着Python解释器的安装运行直接可以使用

1.2.2 扩展模块

解释：需要自己安装才能使用如：Django itchat

1.2.3 模块安装

pip3 install diango

1.2.4 自定义模块

解释：用户根据自己的?完成的一组功能

第2章 模块之内置模块

2.1 collections模块

解释：使用前必须先导入，已知的所有模块名都不可以作为python文件名

导入模块

import collections

每一个类都是一个数据类型

例：

a = ‘a‘

实际上是对象的实例化：

a = str(‘a‘)

2.1.1 collections数据类型

collections模块在内置数据类型基础上还提供了额外的几个数据类型：Counter、deque、deque、defaultdicr、namedtupe 和OrderedDictd等

l  namedtuple: 生成可以使用名字来访问元素内容的tuple

l  deque: 双端队列，可以快速的从另外一侧追加和推出对象

l  Counter: 计数器，主要用来计数

l  OrderedDict: 有序字典

l  defaultdict: 带有默认值的字典

2.1.2 nametuple

解释：生成可以使用名字来访问元素的tuple

实例1）求根号

from math import sqrt

p = (1,2)

print(sqrt(p[0]**2 + p[1]**2))

这样写的可读性非常差，如下:可命名元组来解决

import collections

Point = collections.namedtuple(‘point‘,[‘x‘,‘y‘]) #相当创造了一个类，这个类的对象没有方法只有属性

p = Point(1,2) #实例化

from math import sqrt

sqrt(p.x**2 + p.y**2)

2.1.3 可命名元组

例：

point=collections.namedtuple(‘point‘,[‘x‘,‘y‘]) #相当创造了一个类，这个类的对象没有方法只有属性

p = point(1,2) #实例化

print(p)

print(p.x)

print(p.y)

缺点：是不能修改的

2.1.4 queue 模块

定义：队列

l  队列：先进来的先出去-——售票

l  栈：先进来的后出去——计算机的算法

区别：在存储数据的基础上，严格的维持了一个秩序

例1）：队列

import  queue

q = queue.Queue()

l = list()

q.put(1)

q.put(2)

print(q.get())

输出：

C:\python3\python.exe D:/python/untitled2/python_8/lession.py

1

例2）：双端队列：

解释：维持一个左侧右侧取放的规则

import collections

dq = collections.deque()

dq.append(1)

dq.append(2)

print(dq)

print(dq.pop())

输出：

C:\python3\python.exe D:/python/untitled2/python_8/lession.py

deque([1, 2])

2

例3）：双端队列

import collections

dq = collections.deque()

dq.append(1)

dq.append(2)

print(dq)

print(dq.pop())

print(dq)

dq.appendleft(5)

print(dq.popleft())

print(dq)

输出

C:\python3\python.exe D:/python/untitled2/python_8/lession.py

deque([1, 2])

2

deque([1])

5

deque([1])

2.1.5 Ordereddict有序字典

l  规范创建字典

d = dict([(‘a‘,1),(‘b‘,2),(‘c‘,3)])

print(d)

输出

C:\python3\python.exe D:/python/untitled2/python_8/lession.py

{‘a‘: 1, ‘b‘: 2, ‘c‘: 3}

l  有序取值

from collections import OrderedDict

from collections import OrderedDict

d = OrderedDict([(‘a‘,1),(‘b‘,2),(‘c‘,3)])

print(d)

输出

C:\python3\python.exe D:/python/untitled2/python_8/lession.py

OrderedDict([(‘a‘, 1), (‘b‘, 2), (‘c‘, 3)])

注意：OrderedDict的key会按照插入的顺序排列，不是key本身排序

2.1.6 defaultfict
默认字典

解释：不管key 在不在都不影响value

例1）：

from collections import defaultdict

dd = defaultdict(list)

print(dd)

dd[‘‘].append(1)

dd[‘skfdsjfk‘].append(2)

print(dd)

输出

C:\python3\python.exe
D:/python/untitled2/python_8/lession.py

defaultdict(<class ‘list‘>, {})

defaultdict(<class ‘list‘>, {‘‘: [1],
‘skfdsjfk‘: [2]})

l 
list 为一个callable可调用对象

例：

from collections import defaultdict

def func():return 5

dd = defaultdict(5)

print(dd[‘dafdfsdfsadf‘])

print(dd)

输出

C:\python3\python.exe
D:/python/untitled2/python_8/lession.py

Traceback (most recent call last):

File
"D:/python/untitled2/python_8/lession.py", line 56, in <module>

dd =
defaultdict(5)

TypeError: first argument must be callable or None

正确的

from collections import defaultdict

def func():return 5

dd = defaultdict(lambda : 5)

print(dd[‘dafdfsdfsadf‘])

print(dd)

输出

C:\python3\python.exe
D:/python/untitled2/python_8/lession.py

5

defaultdict(<function <lambda> at 0x00000000027E9BF8>,
{‘dafdfsdfsadf‘: 5})

l 
默认值可以修改

例：

from collections import defaultdict

def func():return 5

dd = defaultdict(lambda : 5)

print(dd[‘dafdfsdfsadf‘])

print(dd)

dd[‘dafdfsdfsadf‘] = 20

print(dd)

输出

C:\python3\python.exe D:/python/untitled2/python_8/lession.py

5

defaultdict(<function <lambda> at
0x0000000001E29BF8>, {‘dafdfsdfsadf‘: 5})

defaultdict(<function <lambda> at
0x0000000001E29BF8>, {‘dafdfsdfsadf‘: 20})

l 
默认字典练习题

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

即： {‘k1‘: 大于66 , ‘k2‘: 小于66}

方法1）

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

my_dict = {}

for value in 
values:

if
value>66:

if
‘k1‘ in  my_dict:

my_dict[‘k1‘].append(value)

else:

my_dict[‘k1‘] = [value]

else:

if
‘k2‘ in my_dict:

my_dict[‘k2‘].append(value)

else:

my_dict[‘k2‘] = [value]

print(my_dict)

输出

C:\python3\python.exe
D:/python/untitled2/python_8/lession.py

{‘k2‘: [11, 22, 33, 44, 55, 66], ‘k1‘: [77, 88,
99, 90]}

方法2）

from collections import defaultdict

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

my_dict = defaultdict(lambda : ‘N/A‘)

my_dict = defaultdict(list)

for value in values:

if value
> 66:

my_dict[‘k1‘].append(value)

else:

my_dict[‘k2‘].append(value)

print(my_dict)

输出：

C:\python3\python.exe
D:/python/untitled2/python_8/lession.py

defaultdict(<class ‘list‘>, {‘k2‘: [11, 22,
33, 44, 55, 66], ‘k1‘: [77, 88, 99, 90]

使用dict时，如果引用的Key不存在，就会抛出KeyError。如果希望key不存在时，返回一个默认值，就可以用defaultdict：

>>> from collections import defaultdict

>>> dd = defaultdict(lambda: ‘N/A‘)

>>> dd[‘key1‘] = ‘abc‘

>>> dd[‘key1‘] # key1存在

‘abc‘

>>> dd[‘key2‘] # key2不存在，返回默认值

‘N/A‘

2.2 time模块

引用方法

import time

time.time

2.2.1 sleep

time.sleep(1) #让你当前的程序阻塞一秒

2.3 时间的表示格式

2.3.1 时间戳(timestamp)

为什么要用时间戳——计算机用的

import  time

print(time.time())

输出

C:\python3\python.exe
D:/python/untitled2/python_8/lession.py

1530523030.2910078 #linux时间戳时间

2.3.2 格式化时间(Format String)

解释：人类时间

import  time

print(time.strftime(‘%Y-%m-%d %H:%M:%S‘))

输出

C:\python3\python.exe
D:/python/untitled2/python_8/lession.py

2018-07-02 17:20:46

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

%y 两位数的年份表示（00-99）

%Y 四位数的年份表示（000-9999）

%m 月份（01-12）

%d 月内中的一天（0-31）

%H 24小时制小时数（0-23）

%I 12小时制小时数（01-12）

%M 分钟数（00=59）

%S 秒（00-59）

%a 本地简化星期名称

%A 本地完整星期名称

%b 本地简化的月份名称

%B 本地完整的月份名称

%c 本地相应的日期表示和时间表示

%j 年内的一天（001-366）

%p 本地A.M.或P.M.的等价符

%U 一年中的星期数（00-53）星期天为星期的开始

%w 星期（0-6），星期天为星期的开始

%W 一年中的星期数（00-53）星期一为星期的开始

%x 本地相应的日期表示

%X 本地相应的时间表示

%Z 当前时区的名称

%% %号本身

2.3.3 元组(struct_time)

解释：struct_time元组共有9个元素:(年，月，日，时，分，秒，一年中第几周，一年中第几天等）

例：

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)

小结：时间戳是计算机能够识别的时间；时间字符串是人能够看懂的时间；元组则是用来操作时间的

2.3.4 时间戳的转化

l 
时间戳-->结构化时间

#time.gmtime(时间戳)    #UTC时间，与英国伦敦当地时间一致

#time.localtime(时间戳) #当地时间。例如我们现在在北京执行这个方法：与UTC时间相差8小时，UTC时间+8小时 = 北京时间

>>>time.gmtime(1500000000)

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.localtime(1500000000)

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)

l 
结构化时间-->时间戳　

#time.mktime(结构化时间)

>>>time_tuple =
time.localtime(1500000000)

>>>time.mktime(time_tuple)

1500000000.0

l 
结构化时间-->字符串时间

#time.strftime("格式定义","结构化时间")  结构化时间参数若不传，则现实当前时间

>>>time.strftime("%Y-%m-%d %X")

‘2017-07-24 14:55:36‘

>>>time.strftime("%Y-%m-%d",time.localtime(1500000000))

‘2017-07-14‘

l 
字符串时间-->结构化时间

#time.strptime(时间字符串,字符串对应格式)

>>>time.strptime("2017-03-16","%Y-%m-%d")

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)

>>>time.strptime("07/24/2017","%m/%d/%Y")

time.struct_time(tm_year=2017, tm_mon=7, tm_mday=24,
tm_hour=0, tm_min=0, tm_sec=0, tm_wday=0, tm_yday=205, tm_isdst=-1)

2.3.5 字符串时间的转化方法

l 
结构化时间 --> %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‘

l 
时间戳 --> %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‘

例）计算时间差

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

2.4 random

定义：随机

2.4.1 随机小数

l 
大于零且小于1的小数

import random

print(random.random())

输出

C:\python3\python.exe D:/python/untitled2/python_8/lession.py

0.6933507043242297

l 
大于1且小于3的小数

import random

print(random.uniform(1,3))

输出

C:\python3\python.exe
D:/python/untitled2/python_8/lession.py

1.3289565836680464

2.4.2 随机整数

l 
大于等于1且小于等于5之间的整数

import random

print(random.randint(1,5))

输出

C:\python3\python.exe
D:/python/untitled2/python_8/lession.py

2

l 
大于等于1且小于10之间的奇数

import random

print(random.randrange(1,10,2))

l 
随机选择一个返回值

import random

print(random.choice([1,‘23‘,[4,5]]))

输出

C:\python3\python.exe
D:/python/untitled2/python_8/lession.py

[4, 5]

列表中任意两个组合

import random

print(random.sample([1,‘23‘,[4,5]],2))

输出

C:\python3\python.exe
D:/python/untitled2/python_8/lession.py

[[4, 5], 1]

2.4.3 打乱列表顺序

import random

l 
打乱次序

item=[1,3,5,7,9]

random.shuffle(item)

print(item)

输出

C:\python3\python.exe D:/python/untitled2/python_8/lession.py

[7, 3, 9, 1, 5]

2.4.4 随机练习：验证码

从数字大小写子母中随机选取

import 
random

def random_code(num,alpha=True):

import
random

code =
‘‘

for i in
range(num):

choice = str(random.randint(0,9))

if
alpha:

alpha_lower = chr(random.randint(65,90))

alpha_upper = chr(random.randint(97,122))

choice = random.choice([choice,alpha_lower,alpha_upper])

code
+= choice

return
code

print(random_code(4,True))

输出

C:\python3\python.exe D:/python/untitled2/python_8/lession.py

b49b

2.4.5 练习题:抢红包

例：

import random

import sys

def calRandomValue(total, num):

total =
float(total)

num =
int(num)

min =
0.01  # 基数

if (num
< 1):

return

if num
== 1:

print("第%d个人拿到红包数为：%.2f"
% (num, total))

return

i = 1

while (i
< num):

max
= total - min * (num - i)

k =
int((num - i) / 2)

if
num - i <= 2:

k = num - i

max
= max / k

monney = random.randint(int(min * 100), int(max * 100))

monney = float(monney) / 100

total = total - monney

print("第%d个人拿到红包数为：%.2f,
余额为: %.2f" % (i, monney, total))

i +=
1

print("第%d个人拿到红包数为：%.2f,
余额为: %.2f" % (i, total, 0.0))

if __name__ == "__main__":

total =
input(‘输入红包总金额:‘)

num =
input(‘输入发红包数量:‘)

calRandomValue(total, num)

2.5 sys模块

2.5.1 定义

解释:和python解释器相关的模块

2.5.2 调用方法

import sys

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

sys.argv 命令行参数list,第一个元素是程序本身的路径

sys.exit(n) 退出程序，正常退出时exit(0),错误退出sys.exit(1)

sys.version 获取python解释程序的版本信息

sys.path 返回模块的搜索路径，初始化使用pythonpath环境变量的值

sys.platform  
返回操作系统平台名称

2.5.3 ****sys.path

解释：关系到你的模块是否顺利的被导入，每个代码都要用，

模块能不能顺利被导入，取决于你的模块是不是在sys.path路径中

路径的寻找是依据sys.path列表中的顺序查找的

找到一个符合的条件会停止查找

2.5.4 sys.platform

定义：判断是否为windows平台

2.5.5 sys.version

判断python版本

import  sys

print(sys.version)

print(sys.platform)

# print(sys.modules)

sys.exit()

输出

D:/python/untitled2/python_8/lession.py

3.6.2 (v3.6.2:5fd33b5, Jul  8 2017, 04:57:36) [MSC v.1900 64 bit (AMD64)]

win32

2.5.6 sys.modules

记载我们已经导入的模块名及导入的模块内存地址

import  sys

print(sys.modules)

输出

C:\python3\python.exe
D:/python/untitled2/python_8/lession.py

{‘builtins‘: <module ‘builtins‘ (built-in)>,
‘sys‘: <module ‘sys‘ (built-in)>, ‘_frozen_importlib‘: <module
‘_frozen_importlib‘ (frozen)>, ‘_imp‘: <module ‘_imp‘ (built-in)>,
‘_warnings‘: <module ‘_warnings‘ (built-in)>, ‘_thread‘: <module
‘_thread‘ (built-in)>, ‘_weakref‘

2.5.7 sys.exit()

解释：退出

2.5.8 sys.argv

解释：效率高 直接写入文件，可以节省代码执行时间减少阻塞

import sys

sys.argv

print(sys.srgv)

if sys.srgv[1] == ‘wang‘ and sys.argv[1] ==
‘wang123‘:

print("登录成功")

else:

user =
input(‘username:‘)

pwd =
input(‘pasword: ‘)

if user
== ‘wang‘and pwd == ‘wang123

print(‘登录成功’)‘

终端操作：

2.6 os模块

解释：与操作系统相关的模块

2.6.1 os参数整理

os.walk 返回一个三元组（root，dirs,files）

root指当前正在遍历的这个文件夹的本身的地址

dirs是一个list，内容是该文件夹中所有的目录的名字（不包括子目录）

files同样是list，内容是该文件中所有的文件（不包括子目录）

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  获取系统环境变量

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的大小

2.6.2 os.getcwd

所谓工作目录并不是当前文件所在的位置，而是当前python脚本的工作路径

2.6.3 __file__

显示当前文件所在的绝对路径

print(__file__)

输出

C:\python3\python.exe
D:/python/untitled2/python_8/lession.py

D:/python/untitled2/python_8/lession.py

2.6.4 os.chdir

解释：相当于shell下的cd

例：

import os

print(__file__)#显示当前文件绝对路径

os.chdir(os.path.dirname(__file__))#切换到当前文件下，相当于先cd到文件目录

print(os.getcwd())#返回path的目录

输出

C:\python3\python.exe
D:/python/untitled2/python_8/lession.py

D:/python/untitled2/python_8/lession.py

D:\python\untitled2\python_8

2.6.5 os.stat(‘path/filename‘)

注意：os.stat(‘path/filename‘)  获取文件/目录信息 的结构说明

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）是创建时间（详细信息参见平台的文档）。

2.6.6 os.path.getsize

解释：返回path的大小有可能1024

例：输出字符串只是当前使用的平台

print(os.path.getsize(r‘D:\python\untitled2\python_8\lession.py‘))

print(os.path.getsize(r‘D:\python\untitled2\python_借鉴\员工信息练习.py‘))

print(os.path.getsize(r‘D:\python\untitled2\lianxi\1.py‘))

输出

C:\python3\python.exe
D:/python/untitled2/python_8/lession.py

3989

12861

1388

2.6.7 目录大小统计练习

#!/usr/bin/env python

# -*- coding:utf-8 -*-

import os

f_dir = os.path.abspath(os.path.dirname(__file__))

def get_dir_size(dir):

size = 0

for
root, dirs, files in os.walk(dir):

size
+= sum([os.path.getsize(os.path.join(root, name)) for name in files])

return
size

if __name__ == ‘__main__‘:

size =
get_dir_size(‘../‘)

print(‘Total size is: %.3f Mb‘ % (size / 1024 / 1024))

2.7 re模块

2.7.1 解释：

正则表达式和python语言，是一个独立的语法

2.7.2 规则：

l  字符串的匹配

l  从一个巨大的字符串集合中

l  根据规则来找到想要的内容

l  或者判断是否符合你的规定

2.7.3 字符组

l 
解释：

字符组 ： [字符组]

在同一个位置可能出现的各种字符组成了一个字符组，在正则表达式中用[]表示

字符分为很多类，比如数字、字母、标点等等。

假如你现在要求一个位置"只能出现一个数字",那么这个位置上的字符只能是0、1、2...9这10个数之一。

l  常用范围

数字：[0-9]

字母：[A-Za-z]

2.7.4 字符：

2.7.5 量词：

2.7.6 . ^ $

2.7.7 * + ? {
}

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

2.7.8 字符集[][^]

2.7.9 分组 ()与 或 ｜［^］

身份证号码是一个长度为15或18个字符的字符串，如果是15位则全部???数字组成，首位不能为0；如果是18位，则前17位全部是数字，末位可能是数字或x，下面我们尝试用正则来表示：

2.7.10 转义符 \

在正则表达式中，有很多有特殊意义的是元字符，比如\d和\s等，如果要在正则中匹配正常的"\d"而不是"数字"就需要对"\"进行转义，变成‘\\‘。

在python中，无论是正则表达式，还是待匹配的内容，都是以字符串的形式出现的，在字符串中\也有特殊的含义，本身还需要转义。所以如果匹配一次"\d",字符串中要写成‘\\d‘，那么正则里就要写成"\\\\d",这样就太麻烦了。这个时候我们就用到了r‘\d‘这个概念，此时的正则是r‘\\d‘就可以了。

2.7.11 贪婪匹配

贪婪匹配：在满足匹配时，匹配尽可能长的字符串，默认情况下，采用贪婪匹配

2.7.12 非贪婪匹配

*? 重复任意次，但尽可能少重复

2.7.13 +?

解释： 重复1次或更多次，但尽可能少重复

?? 重复0次或1次，但尽可能少重复

{n,m}? 重复n到m次，但尽可能少重复

{n,}? 重复n次以上，但尽可能少重复

2.7.14 .*?的用法

. 是任意字符

* 是取 0 至 无限长度

? 是非贪婪模式。

何在一起就是 取尽量少的任意字符，一般不会这么单独写，他大多用在：

.*?x

就是取前面任意长度的字符，直到一个x出现

2.7.15 re模块应用

import re

ret = re.findall(‘a‘, ‘eva egon yuan‘)  # 返回所有满足匹配条件的结果,放在列表里

print(ret) #结果 : [‘a‘,
‘a‘]

ret = re.search(‘a‘, ‘eva egon yuan‘).group()

print(ret) #结果 : ‘a‘

# 函数会在字符串内查找模式匹配,只到找到第一个匹配然后返回一个包含匹配信息的对象,该对象可以

# 通过调用group()方法得到匹配的字符串,如果字符串没有匹配，则返回None。

ret = re.match(‘a‘, ‘abc‘).group()  # 同search,不过尽在字符串开始处进行匹配

print(ret)

#结果 : ‘a‘

ret = re.split(‘[ab]‘, ‘abcd‘)  # 先按‘a‘分割得到‘‘和‘bcd‘,在对‘‘和‘bcd‘分别按‘b‘分割

print(ret) 
# [‘‘, ‘‘, ‘cd‘]

ret = re.sub(‘\d‘, ‘H‘, ‘eva3egon4yuan4‘, 1)#将数字替换成‘H‘，参数1表示只替换1个

print(ret) #evaHegon4yuan4

ret = re.subn(‘\d‘, ‘H‘, ‘eva3egon4yuan4‘)#将数字替换成‘H‘，返回元组(替换的结果,替换了多少次)

print(ret)

obj = re.compile(‘\d{3}‘)  #将正则表达式编译成为一个 正则表达式对象，规则要匹配的是3个数字

ret = obj.search(‘abc123eeee‘) #正则表达式对象调用search，参数为待匹配的字符串

print(ret.group()) 
#结果 ： 123

import re

ret = re.finditer(‘\d‘, ‘ds3sy4784a‘)   #finditer返回一个存放匹配结果的迭代器

print(ret) 
# <callable_iterator object at 0x10195f940>

print(next(ret).group())  #查看第一个结果

print(next(ret).group())  #查看第二个结果

print([i.group() for i in ret])  #查看剩余的左右结果

2.7.16 正则应用

\d+\.?|d*

原字符：12.12

12

匹配结果：

12.12

12

2.7.17 惰性匹配

匹配规则：\d*?

import re

ret = re.findall(‘\d‘,‘eva6543 wang  656li‘)

print(ret)

ret1 = re.search(‘a‘,‘eva wang li‘).group()

print(ret1)

输出

C:\python3\python.exe
D:/python/untitled2/python_8/lession.py

[‘6‘, ‘5‘, ‘4‘, ‘3‘, ‘6‘, ‘5‘, ‘6‘]

a

2.7.18 search找一个

ret1 = re.search(‘\d‘,‘eva123 wang345 li128‘)

print(ret1)

print(ret1.group())

输出

C:\python3\python.exe
D:/python/untitled2/python_8/lession.py

<_sre.SRE_Match object; span=(3, 4),
match=‘1‘>

1

2.7.19 分组优先

import re

#findall 特性 匹配的时候按照规则匹配，显示只显示分组内的

ret = re.findall(‘(\d)5‘,‘eva23454 wang 35li15‘)

print(ret)

ret = re.findall(‘\d5‘,‘eva23454 wang 35li15‘)

print(ret)

输出

D:/python/untitled2/python_8/lession.py

[‘4‘, ‘3‘, ‘1‘]

[‘45‘, ‘35‘, ‘15‘]

?的用法

import re

#在分组的开始加上？: 表示取消分组优先

ret = re.findall(‘(?:\d)5‘,‘eva23454 wang 35li15‘)

print(ret)

ret = re.findall(‘\d5‘,‘eva23454 wang 35li15‘)

print(ret)

输出

D:/python/untitled2/python_8/lession.py

[‘45‘, ‘35‘, ‘15‘]

[‘45‘, ‘35‘, ‘15‘]

2.7.20 search中没有分组优先

#在search中没有正则规则的分组优先功能

ret = re.search(‘(\d)5‘,‘eva23454 wang 35li15‘)

print(ret.group())

输出

C:\python3\python.exe
D:/python/untitled2/python_8/lession.py

45

2.7.21 ？的用法

l 
？做量词 表示是0次或1次

l 
？在量词后 表示惰性匹配

l 
？:在分组开头 表示取消分组优先

第3章 拾遗

3.1 进度条

例：

#!/usr/bin/env python

# -*- coding:utf-8 -*-

import  time

for i in range(0,101,2):

time.sleep(0.1)

char_unm
= i//2 #取整除，返回商的整数部分

# print(char_unm)

#\r表示不进行转义 %取模取出余数

per_str
= ‘\r%s%%: %s\n‘ % (i,‘*‘ * char_unm) if i == 100 else ‘\r%s%% : %s‘%(i ,‘*‘*
char_unm)

print(per_str,end=‘‘,flush=True)

原文地址：https://www.cnblogs.com/wang-xd/p/9269728.html