软件开发规范,常用模块

By admin in 4858.com on 2019年4月1日

Python 学习之路(叁)

以下所用的是Python 三.六

Python 学习之路(三),python学习之路

Python 学习之路(三)

以下所用的是Python 三.陆

一、集合部分

聚拢是3个无序的,不重复的多少集合,重要用来去重,以及关系测试:交集,差集,并集等

一.一 关系操作

1.壹.壹 列表去重

能够给列表去重,例如:

1 set_demo = [1,2,3,4,5,3,2,1] # 列表
2 set_demo = set(set_demo) # 转换成集合,来去重
3 print(set_demo)

1.1.2 取交集 intersection()方法

能够博得四个聚众的搅和部分,例如:

1 set_demo_1 = set([2,3,4,5,4])
2 set_demo_2 = set([2,22,33,44,11])
3 print(set_demo_1.intersection(set_demo_2))

1.1.3 取并集 union()方法

能够收获八个汇聚的并集,例如:

1 set_demo_1 = set([2,3,4,5,4])
2 set_demo_2 = set([2,22,33,44,11])
3 print(set_demo_1.union(set_demo_2))

1.1.4 差集 difference()方法

删除调用对象中的与参数共有的有的,即差集,例如:

1 set_demo_1 = set([1,2,3,4,5])
2 set_demo_2 = set([1,2,3])
3 print(set_demo_1.issuperset(set_demo_2))#set_demo_1是set_demo_2的父集 返回true
4 print(set_demo_2.issubset(set_demo_1))#set_demo_2是set_demo_1的子集 返回true

1.1.5 子集、父集

能够行使issubset,issuperset方法,例如:

1 set_demo_1 = set([1,2,3,4,5])
2 set_demo_2 = set([1,2,3])
3 print(set_demo_1.issuperset(set_demo_2))#set_demo_1是set_demo_2的父集 返回true
4 print(set_demo_2.issubset(set_demo_1))#set_demo_2是set_demo_1的子集 返回true

一.一.陆 对称差集

集合A与集合B中保有不属于A∩B的元素的集结,例如:

1 set_demo_1 = set([2,3,4,5,4])
2 set_demo_2 = set([2,22,33,44,11])
3 print(set_demo_1.symmetric_difference(set_demo_2)) #返回去掉两者交集的部分

一.壹.7 不相交的

五个聚众倘诺未有交集就再次来到true,例如:

1 set_demo_1 = set([1,2,3,4,5])
2 set_demo_2 = set([11,22,33])
3 print(set_demo_1.isdisjoint(set_demo_2))#没有交集返回true

1.一.八 使用运算符来代替方法调用

1 A = B | C #取并集
2 A = B & C #取交集
3 A = B - C #取差集,在B中去掉C中的部分
4 A = B ^ C #取对称差集

一.贰 基本操作

 1 set_demo = set([1,2,3,4,5])
 2 set_demo.add(66) #添加操作,添加一项
 3 set_demo.update([11,22]) #添加操作,添加多项
 4 
 5 set_demo.remove(66) #删除操作,删除指定一项,若没有则报错
 6 len(set_demo) # 集合长度
 7 
 8 set_demo.pop() #删除操作,随机删除一个,并且返回该值
 9 set_demo.discard(666) #删除操作,删除指定一个,若没有则什么都不做
10 print(set_demo)

二、文件部分

主干的流水线:打开文件->操作文件->关闭文件

二.一 文件打开方式

模式 含义
r 打开只读文件,该文件必须存在。
r+ 打开可读写的文件,该文件必须存在。
w 打开只写文件,若文件存在则文件长度清为0,即该文件内容会消失。若文件不存在则建立该文件。
w+ 打开可读写文件,若文件存在则文件长度清为零,即该文件内容会消失。若文件不存在则建立该文件。
a 以附加的方式打开只写文件。若文件不存在,则会建立该文件,如果文件存在,写入的数据会被加到文件尾,即文件原先的内容会被保留。
a+ 以附加方式打开可读写的文件。若文件不存在,则会建立该文件,如果文件存在,写入的数据会被加到文件尾后,即文件原先的内容会被保留。

注:上述的形态字符串都足以再加三个b字符,如rb、w+b或ab+等组合,加入b
字符用来报告函数库打开的文书为二进制文件,而非纯文字文件。不过在POSIX系统,包括Linux都会忽略该字符。

二.二 文件的读写操作

读文件操作,read(size)方法,参数能够输入读取长度,不填默许读取全体

1 f = open("file_demo",mode="r",encoding='utf-8') #创建文件句柄引用
2 print(f.read())
3 f.close()

写文件操作

1 f = open("file_demo",mode="w",encoding='utf-8') #创建文件句柄引用
2 f.write("测试用例\n")
3 f.close()

读一行、多行

1 f = open("file_demo",mode="r",encoding='utf-8') #创建文件句柄引用
2 print(f.readline()) #单行读取
3 f.close()
4 
5 f = open("file_demo",mode="r",encoding='utf-8') #创建文件句柄引用
6 for line in f.readlines(): #读取全部文件的全部行,存放着文件中,如果文件较大则速度会非常慢,一般不推荐readlines
7     print(line.strip())
8 f.close()

二.3 文件的光标(地方操作)

文本地方操作有以下多少个点子:tell,seek tell()能够回到当前岗位
seek(offset[,
whence]),offset参数是从头的偏移量,表示偏移多少个字节,whence默许为0,表示要从哪些岗位上马晃动:0代表从文件初叶初始算起,一象征从当前任务上马算起,二代表从文件末尾算起。

2.4 文件的flush()操作

flush()方法刷新文件之中缓冲,直接把在那之中缓冲区的数目立马写入文件,而不是被动的等候输出缓冲区写入。可以预防断电等意况使数据尚未写入文件。

1 f = open("file_demo",mode="a",encoding='utf-8') #创建文件句柄引用
2 f.write("这是追加数据")
3 f.flush()#将缓存区的数据写入到文件
4 f.close()

2.5 文件的truncate()方法

truncate( [ size ]):用于从文件的首行首字符开首截断,截断文件为 size
个字符,无 size 表示从此时此刻职分截断;截断之后,前面的具备字符被删去。

二.陆 别的操作

fileno()再次来到二个整形的文书讲述符 encoding()重返打开文件的编码方式isatty()假诺文件再三再四到二个终极设备再次回到 True,不然重回 False
readable()要是文件可读,则赶回True,不然重临 False
writeable()倘若文件可写,则赶回True,不然重返 False

2.7 with操作

with能够自动支持关闭文件,释放资源

1 with open("file_demo",mode="r",encoding="utf-8" ) as f:
2     for line in f:
3         print(line.strip()) #strip用来去除换行

三、JSON 类别化与反种类化

种类化能够简不难单的知道为将对象存款和储蓄到文件中,反类别化能够省略明了为将文件数量读取用对象来储存
连串化进程

1 import json #导入json包
2 
3 # 序列化过程
4 # 字典类型转换为 JSON 对象
5 info = { "name":"CodeHu",
6          "age": 25}
7 with open("json.text","w") as f:
8     f.write( json.dumps(info) )
9     #json.dump(info,f) #或者使用dump

反连串进程

1 import json
2 # 反序列化
3 with open("json.text","r") as f:
4     print(json.loads(f.read())["age"])
5     #print(json.load(f)["age"])#可以采用load方法读取

肆、工程目录规范

摘自

四.一 一般目录结构

比方你的项目名字为foo, 最方便神速目录结构:

Foo/
|-- bin/
|   |-- foo
|
|-- foo/
|   |-- tests/
|   |   |-- __init__.py
|   |   |-- test_main.py
|   |
|   |-- __init__.py
|   |-- main.py
|
|-- docs/
|   |-- conf.py
|   |-- abc.rst
|
|-- setup.py
|-- requirements.txt
|-- README

简易解释一下:

  • bin/:
    存放项目标1些可执行文件,当然你能够起名script/之类的也行。
  • foo/: 存放项指标拥有源代码。(壹)
    源代码中的全体模块、包都应该放在此目录。不要置于顶层目录。(2)
    其子目录tests/存放单元测试代码;
    (叁)程序的输入最佳命名字为 main.py。
  • docs/: 存放壹些文书档案。
  • setup.py: 安装、安顿、打包的台本。
  • requirements.txt: 存放软件依赖的外部Python包列表。
  • README: 项目表明文件。

4.2 README文件

那一个是各样连串都应有有的一个文本,指标是能不难描述该类型的音讯,让读者很快领悟这么些项目。

它供给声明以下多少个事项:

  • 软件定位,软件的基本成效。
  • 运营代码的法子: 安装环境、运行命令等。
  • 简不难单的应用表明。
  • 代码目录结构表明,更详细点能够证实软件的基本原理。
  • 科学普及难题求证。

4.3 setup.py

相似的话,用setup.py来管理代码的卷入、安装、计划难题。产业界规范的写法是用Python流行的包裹工具setuptools来管理那些业务。那种方法广泛利用于开源项目中。但是这里的主题绪想不是用规范的工具来消除这个题目,而是说,2个档次必将要有三个安装配备工具,能飞快方便的在1台新机器准将环境装好、代码安插好和将程序运营起来。

4.4 requirements.txt

本条文件存在的指标是:
方便开发者维护软件的包注重。将支付过程中新增的包添加进这几个列表中,防止在setup.py安装依赖时漏掉软件包。
方便读者分明项目选拔了怎么Python包。
这个文件的格式是每一行包罗一个包正视的注解,通常是flask>=0.拾那种格式,要求是以此格式能被pip识别,那样就可以差不离的经过
pip install -r requirements.txt来把持有Python包依赖都装好。

itemprop=”url”> > id=”indexUrl” itemprop=”indexUrl”>www.bkjia.com > id=”isOriginal” itemprop=”isOriginal”>true > id=”isBasedOnUrl”
itemprop=”isBasedOnUrl”> > id=”genre” itemprop=”genre”>TechArticle > itemprop=”description”>Python 学习之路(三),python学习之路 Python
学习之路(3) 以下所用的是Python 三.陆 1、集合部分
集合是多少个无序的,不另行的数码集合,主…

1.装饰器

软件开发规范,常用模块。概念:本质是函数,正是为其它函数添加附加成效

原则:一.不可能改改被点缀的函数的源代码

   二.不可能修改被点缀的函数的调用方式

例子:

import time

def timer(func):
    def wrapper(*args,**kwargs):
        start_time = time.time()
        func()
        stop_time = time.time()
        print("the func run time is %s" % (stop_time-start_time))
    return wrapper

@timer #实际功能相当于func1 = timer(func1)
def func1():
    time.sleep(3)
    print("in the test1")

func1()

#结果
#in the test1
#the func run time is 3.0005111694335938

该函数满意装饰器的有所要求

装饰器=高阶函数+嵌套函数

高阶函数:

把2个函数名当狠抓参传给别的2个函数;再次来到值中包罗函数名

def func1(func):
    print(func)


def func2():
    print(1)


func1(func2)

嵌套函数:

在三个函数的函数体钦点义另三个函数

def func1():
    print("in the func1")

    def func2():
        print("in the func2")

    func2()


func1()

自己的驾驭:

装饰器的兑现方式,本质正是改变原函数的内部存储器地址。通过高阶函数的重返值,将嵌套函数的内部存款和储蓄器地址赋给了原函数,而原函数的作用被记录在了嵌套函数中,通过嵌套函数添加了新功效,而且不改动力源代码及原函数的调用格局。func一函数实际已经济体改为了warpper函数,warpper函数的功力=func一本来的遵从+添加的效力。不过func1的效果将会被永久改变,不可能再单独完毕func一的成效。

那借使函数要传参数进去如何做吧?

简短!加个非固定参数就解决了!

import time


def timer(func):
    def wrapper(*args, **kwargs):
        start_time = time.time()
        func(*args, **kwargs)
        stop_time = time.time()
        print("the func run time is %s" % (stop_time - start_time))

    return wrapper


@timer
def func1():
    time.sleep(1)
    print("in the test1")


@timer
def func2(*args, **kwargs):
    print(args, kwargs)


func1()
func2("Nick", daizhi="22", sex="male")

 那假诺想要差别的函数达成不一样的装饰器功用,就在装饰器里再嵌套一层函数:

_username, _password = "Nick", "123456"


def auth(auth_type):
    print(auth_type)
    def outer_wrapper(func):
        def wrapper(*args,**kwargs):
            if auth_type == 'local':
                username = input('username:').strip()
                password = input('password:').strip()
                if username == _username and password == _password:
                    print('Welcome!')
                    func()
                else:
                    exit('\033[31;1mInvalid username or password!\033[0m')
            elif auth_type == '1dap':
                print('testing')
        return wrapper
    return outer_wrapper


@auth(auth_type = "local")
def index():
    print('Welcome to index page')

@auth(auth_type = "1dap")
def home():
    print('Welcome to home page')

index()
home()

1. 模块介绍

1、集合部分

聚集是1个冬季的,不重复的数目集合,首要用来去重,以及涉及测试:交集,差集,并集等

2.列表生成式,迭代器与生成器

a = [i+1 for i in range(0,10,2)]
print(a)
>>>[1, 3, 5, 7, 9]

这正是列表生成式

生成器

透过列表生成式,大家得以从来开立三个列表。可是,受到内部存款和储蓄器限制,列表容积肯定是简单的。而且,创设1个包蕴十0万个因素的列表,不仅占用一点都不小的贮存空间,若是大家只有需求拜访前面多少个因素,那前面绝半数以上因素占用的长空都白白浪费了

所以,如若列表成分得以根据某种算法推算出来,那大家是还是不是能够在循环的进程中连连推算出后续的因素呢?那样就不要创制完整的list,从而节省多量的半空中。在Python中,那种单方面循环一边盘算的体制,称为生成器:generator

要成立八个generator,有很二种格局。第二种办法非常粗略,只要把三个列表生成式的[]改成(),就创设了三个generator:

a = (i*i for i in range(10))
print(a)
>>><generator object <genexpr> at 0x00000232FF1F92B0>

generator保存的是算法, 能够用for循环调用,也能够用next()函数调用下二个

generator非凡强大。假设推算的算法比较复杂,用接近列表生成式的for循环不可能达成的时候,还足以用函数来促成

例子:

def fib(max):
    n, a, b = 0, 0, 1
    while n < max:
        # print(b)
        yield b
        a, b = b, a + b
        n = n + 1
    return 'done'

for i in fib(10):
    print(i)

 generator的函数,在历次调用next()的时候实施,境遇yield语句再次来到,再一次实施时从上次归来的yield语句处继续执行

然则用for循环调用generator时,发现拿不到generator的return语句的再次来到值。若是想要获得重返值,必须捕获StopIteration错误,重返值包含在StopIteration的value中:

g = fib(6)
while True:
    try:
        x = next(g)
        print('g:', x)
    except StopIteration as e:
        print('Generator return value:', e.value)
        break

还可透过yield达成在单线程的境况下促成并发运算的效益:

import time
def consumer(name):
    print("%s 准备吃包子啦!" %name)
    while True:
       baozi = yield
       print("包子%s来了,被%s吃了!" %(baozi, name))


def producer(name):
    c = consumer('A')
    c2 = consumer('B')
    c.__next__()
    c2.__next__()
    print("我开始准备做包子啦!")
    for i in range(10):
        time.sleep(1)
        print("做了2个包子!")
        c.send(i)
        c2.send(i)

producer("戴老板")

那就贯彻了单线程下的面世运算

所以,_next_()函数只举行生成器,而send()函数不但实行生成器,还对yield进行传值

迭代器

能够直接功效于for循环的数据类型有以下两种:

壹类是会见数据类型,如list、tuple、dict、set、str等;

1类是generator,包罗生成器和带yield的generator function。

那么些足以平素效果于for循环的指标统称为可迭代对象:Iterable。

能够采纳isinstance()判断三个对象是还是不是是Iterable对象:

>>> from collections import Iterable
>>> isinstance([], Iterable)
True
>>> isinstance({}, Iterable)
True
>>> isinstance('abc', Iterable)
True
>>> isinstance((x for x in range(10)), Iterable)
True
>>> isinstance(100, Iterable)
False

而生成器不但能够效率于for循环,还足以被next()函数不断调用并赶回下二个值,直到最后抛出StopIteration错误表表示情爱莫能助持续回到下3个值了

*能够被next()函数调用并频频再次来到下一个值的目的称为迭代器:Iterator“

能够选取isinstance()判断二个目的是否是Iterator对象:

>>> from collections import Iterator
>>> isinstance((x for x in range(10)), Iterator)
True
>>> isinstance([], Iterator)
False
>>> isinstance({}, Iterator)
False
>>> isinstance('abc', Iterator)
False

生成器都以Iterator对象,但list、dict、str即使是Iterable,却不是Iterator。

把list、dict、str等Iterable变成Iterator可以选取iter()函数:

>>> isinstance(iter([]), Iterator)
True
>>> isinstance(iter('abc'), Iterator)
True

为什么list、dictstr不是Iterator

那是因为Python的Iterator对象表示的是一个数据流,Iterator对象足以被next()函数调用并不断再次来到下3个数量,直到未有多少时抛出StopIteration错误。能够把这些数据流看做是二个依样葫芦种类,但大家却无法超前精通类别的长度,只好不断通过next()函数达成按需总计下多少个数据,所以Iterator的乘除是惰性的,唯有在需求重回下三个数目时它才会一个钱打二17个结

Iterator甚至能够表示四个最佳大的数据流,例如全部自然数。而利用list是世代不容许存款和储蓄全部自然数的

小结

举凡可效果于for循环的靶子都以Iterable类型

举凡可职能于next()函数的对象都以Iterator类型,它们表示四个惰性总结的队列

晤面数据类型如list、dict、str等是Iterable但不是Iterator,可是能够透过iter()函数获得二个Iterator对象

Python的for循环本质上正是通过不断调用next()函数达成的,例如:

for x in [1, 2, 3, 4, 5]:
    pass

实则完全等价于:

# 首先获得Iterator对象:
it = iter([1, 2, 3, 4, 5])
# 循环:
while True:
    try:
        # 获得下一个值:
        x = next(it)
    except StopIteration:
        # 遇到StopIteration就退出循环
        break

一. 什么样是模块

在前头的几个章节中大家大多是用 python 解释器来编制程序,如若您从 Python
解释器退出再进入,那么你定义的富有的方法和变量就都冰释了。

为此 Python
提供了2个艺术,把那几个概念存放在文书中,为一些剧本恐怕交互式的解释器实例使用,这一个文件被誉为模块。

模块是二个包罗全体你定义的函数和变量的公文,其后缀名是.py。模块能够被别的程序引入,以利用该模块中的函数等职能。那也是应用
python 标准库的章程。

如:os 是系统相关的模块;file是文件操作相关的模块

模块分为两种:

  • 自定义模块
  • 其3方模块
  • 嵌入模块

自定义模块 和
开源模块的应用参考:  http://www.cnblogs.com/wupeiqi/articles/4963027.html**

一.一 关系操作

 3.json & pickle 数据种类化

用于连串化的七个模块

  • json,用于字符串 和 python数据类型间举办更换

  • pickle,用于python特有的类型 和 python的数据类型间举行转换

Json模块提供了多少个效益:dumps、dump、loads、load

pickle模块提供了三个职能:dumps、dump、loads、load


json.dumps 将数据经过非正规的款型转换为持有程序语言都认识的字符串

json.dump
将数据经过特有的款式转换为保有程序语言都认识的字符串,并写入文件

import json

info = {
    'name': 'daizhi',
    'age': 23,
    'sex': 'male'
}

json_str = json.dumps(info)
print(json_str)

with open('test.text', 'w') as f:
    json.dump(info, f)

鉴于json是更换为具备程序语言都通用的字符串,故不能处理太过复杂的数据类型,所以就要选择pickle:

import pickle

info = {
    'name': 'daizhi',
    'age': 23,
    'sex': 'male'
}

pickle_str = pickle.dumps(info)
print(pickle_str)

with open('test.text', 'wb') as f:
    pickle.dump(info, f)

pickle的用法和json壹模一样 

二、导入模块

Python之所以采纳尤其广阔,在一定水平上也依靠于其为程序员提供了大气的模块以供役使,如若想要使用模块,则供给导入。导入模块有弹指间二种艺术:

import module
from module.xx.xx import xx
from module.xx.xx import xx as rename 
from module.xx.xx import *

导入模块其实正是报告Python解释器去解释那些py文件

  • 导入3个py文件,解释器解释该py文件
  • 导入3个包,解释器解释该包下的 __init__.py 文件 【py2.7】

那么难题来了,导入模块时是基于那二个路径作为规范来开始展览的吧?即:sys.path

import sys
print(sys.path)

要是sys.path路径列表未有您想要的门径,能够透过 sys.path.append(‘路径’)
添加。

import sys
import os
project_path = os.path.dirname(os.path.dirname(os.path.abspath(__file__)))
sys.path.append(project_path)

1.一.一 列表去重

能够给列表去重,例如:

1 set_demo = [1,2,3,4,5,3,2,1] # 列表
2 set_demo = set(set_demo) # 转换成集合,来去重
3 print(set_demo)

 肆.软件目录结构正式

为啥要统一筹划好目录结构?

“设计项目目录结构”,就和”代码编码风格”1样,属于个人风格难点。对于那种风格上的标准,一贯都留存三种态度:

  1. 1类同学觉得,那种个人风格难题”非亲非故重要”。理由是能让程序work就好,风格难题从来不是题材

  2. 另一类同学觉得,规范化能更好的决定程序结构,让程序有所更高的可读性

本身是比较偏向于子孙后代的,因为自己是前1类同学思想表现下的直接受害者。笔者曾经维护过2个非凡不佳读的花色,其落到实处的逻辑并不复杂,不过却消耗了作者可怜长的年华去了然它想表明的情致。从此小编个人对于增强项目可读性、可维护性的供给就很高了。”项目目录结构”其实也是属于”可读性和可维护性”的局面,大家陈设3个层次明显的目录结构,正是为了完毕以下两点:

  1. 可读性高::不纯熟这几个类型的代码的人,一眼就能看懂目录结构,知道程序运行脚本是哪个,测试目录在何方,配置文件在哪儿之类。从而丰硕高效的刺探这一个项目

  2. 可维护性高::定义好共青团和少先队规则后,维护者就能很领悟地领悟,新增的哪位文件和代码应该放在如何目录之下。这么些利益是,随着岁月的推移,代码/配置的局面扩展,项目协会不会混杂,仍旧能够组织特出

于是,作者觉得,保持1个层次显然的目录结构是有须要的。更何况社团贰个特出的工程目录,其实是1件相当的粗略的事务

目录组织措施

关于如何协会1个较好的Python工程目录结构,已经有部分到手了共识的目录结构。在Stackoverflow的这一个题材上,能观望咱们对Python目录结构的切磋

那边面说的已经很好了,笔者也不打算重新造轮子列举各个不相同的诀窍,那在那之中笔者说一下自家的知情和认知

一旦你的项目名称叫foo,
笔者比较提出的最方便火速目录结构那样就丰富了:

Foo/
|-- bin/
|   |-- foo
|
|-- foo/
|   |-- tests/
|   |   |-- __init__.py
|   |   |-- test_main.py
|   |
|   |-- __init__.py
|   |-- main.py
|
|-- docs/
|   |-- conf.py
|   |-- abc.rst
|
|-- setup.py
|-- requirements.txt
|-- README

简简单单解释一下:

  1. bin/:
    存放项指标部分可执行文件,当然你能够起名script/等等的也行

  2. foo/: 存放项指标有着源代码。(壹)
    源代码中的全部模块、包都应该放在此目录。不要置于顶层目录。(2)
    其子目录tests/存放单元测试代码; (3)
    程序的输入最棒命名称叫main.py

  1. docs/: 存放一些文书档案

  2. setup.py:
    安装、安顿、打包的剧本

  3. requirements.txt:
    存放软件依赖的外表Python包列表

  4. README: 项目表达文件

除去,有部分方案提交了更进一步多的内容。比如LICENSE.txt,ChangeLog.txt文件等,作者从不列在那里,因为那么些东西根本是类别开源的时候必要用到。假设您想写多少个开源软件,目录该怎么组织,能够参照那篇小说

上面,再简单讲一下自个儿对那些目录的明白和私家须求啊

三. 施用规则

4858.com,嵌入模块是Python自带的成效,在利用内置模块相应的效应时,需求服从【开首入】再【使用】的口径

 

1.1.2 取交集 intersection()方法

能够收获多少个聚众的滥竽充数部分,例如:

1 set_demo_1 = set([2,3,4,5,4])
2 set_demo_2 = set([2,22,33,44,11])
3 print(set_demo_1.intersection(set_demo_2))

关于README的内容

其1是各样项目都应该有个别二个文书,指标是能不难描述该项指标音信,让读者一点也不慢精晓这么些项目

它要求验证以下多少个事项:

  1. 软件定位,软件的基本作用

  2. 运行代码的方法:
    安装环境、运行命令等

  3. 粗略的应用表明

  4. 代码目录结构表明,更详细点可以证实软件的基本原理

  5. 大面积难点求证

自己以为有上述几点是比较好的1个README。在软件开发初期,由于开发进程中上述内容也许不明了或许产生变化,并不是顺其自然要在1上马就将有所音信都补全。不过在类型收尾的时候,是内需写作这样的贰个文书档案的

能够参考Redis源码中Readme的写法,那中间简洁可是清晰的叙述了Redis作用和源码结构

2. 常用模块

1.1.3 取并集 union()方法

能够赢得多少个集聚的并集,例如:

1 set_demo_1 = set([2,3,4,5,4])
2 set_demo_2 = set([2,22,33,44,11])
3 print(set_demo_1.union(set_demo_2))

关于requirements.txt和setup.py

time模块

在Python中,经常有那两种方式来表示时间:

  • 时刻戳(timestamp):平日来说,时间戳表示的是从一九七零年1十二月31日00:00:00上马按秒总括的偏移量。大家运转“type(time.time())”,再次来到的是float类型。
  • 格式化的时辰字符串(Format String)
  • 结构化的时刻(struct_time):struct_time元组共有捌个因素共多少个要素:(年,月,日,时,分,秒,一年中第几周,一年中第几天,夏令时)

    import time

    print(time.time()) # 时间戳:14962383四5.3捌print(time.strftime(“%Y-%m-%d %X”)) # 格式化的时刻字符串:’2017-0伍-31 二1:四伍:45′

    print(time.localtime()) # 本地时区的struct_time
    ”’
    time.struct_time(tm_year=2017, tm_mon=5, tm_mday=31, tm_hour=21, tm_min=46, tm_sec=1, tm_wday=2, tm_yday=151, tm_isdst=0) #
    ”’
    print(time.gmtime()) # UTC时区的struct_time
    ”’
    time.struct_time(tm_year=2017, tm_mon=5, tm_mday=31, tm_hour=13, tm_min=46, tm_sec=1, tm_wday=2, tm_yday=151, tm_isdst=0)
    ”’

个中总结机认识的岁月只可以是’时间戳’格式,而程序员可处理的恐怕说人类能看懂的小时有:
‘格式化的小时字符串’,’结构化的时间’ ,于是有了下图的变换关系

4858.com 1

# --------------------------按图1转换时间
# localtime([secs])
# 将一个时间戳转换为当前时区的struct_time。secs参数未提供,则以当前时间为准。
print(time.time())
print(time.localtime())
print(time.localtime(1496238894.0))

# gmtime([secs]) 和localtime()方法类似,gmtime()方法是将一个时间戳转换为UTC时区(0时区)的struct_time。

# mktime(t) : 将一个struct_time转化为时间戳。
print(time.mktime(time.localtime()))    # 1496238894.0


# strftime(format[, t]) : 把一个代表时间的元组或者struct_time(如由time.localtime()和
# time.gmtime()返回)转化为格式化的时间字符串。如果t未指定,将传入time.localtime()。如果元组中任何一个元素越界,ValueError的错误将会被抛出。
print(time.strftime("%Y-%m-%d %X", time.localtime()))   # 2017-05-31 21:52:58

# time.strptime(string[, format])
# 把一个格式化时间字符串转化为struct_time。实际上它和strftime()是逆操作。
print(time.strptime('2017-05-31 21:52:58', '%Y-%m-%d %X'))
# time.struct_time(tm_year=2017, tm_mon=5, tm_mday=31, tm_hour=21, tm_min=52, tm_sec=58,
# 在这个函数中,format默认为:"%a %b %d %H:%M:%S %Y"。

'''
1496238989.034
time.struct_time(tm_year=2017, tm_mon=5, tm_mday=31, tm_hour=21, tm_min=56, tm_sec=29, tm_wday=2, tm_yday=151, tm_isdst=0)
time.struct_time(tm_year=2017, tm_mon=5, tm_mday=31, tm_hour=21, tm_min=54, tm_sec=54, tm_wday=2, tm_yday=151, tm_isdst=0)
1496238989.0
2017-05-31 21:56:29
time.struct_time(tm_year=2017, tm_mon=5, tm_mday=31, tm_hour=21, tm_min=52, tm_sec=58, tm_wday=2, tm_yday=151, tm_isdst=-1)
'''

1.1.4 差集 difference()方法

删去调用对象中的与参数共有的片段,即差集,例如:

1 set_demo_1 = set([1,2,3,4,5])
2 set_demo_2 = set([1,2,3])
3 print(set_demo_1.issuperset(set_demo_2))#set_demo_1是set_demo_2的父集 返回true
4 print(set_demo_2.issubset(set_demo_1))#set_demo_2是set_demo_1的子集 返回true

setup.py

诚如的话,用setup.py来治本代码的卷入、安装、铺排难题。业界规范的写法是用Python流行的包装工具setuptools来管理这一个业务。那种方式广泛利用于开源项目中。可是那里的核情绪想不是用口径的工具来化解那几个标题,而是说,一个品类必将要有四个装置配备工具,能便捷方便的在1台新机器上将环境装好、代码陈设好和将程序运维起来

其一自家是踩过坑的。

本身刚起初接触Python写项指标时候,安装环境、陈设代码、运营程序那一个进程全是手动完结,遇到过以下难点:

  1. 设置环境时常常忘了近期又添加了三个新的Python包,结果一到线上运维,程序就出错了

  2. Python包的本子信赖难点,有时候大家先后中使用的是1个本子的Python包,可是官方的早已是风靡的包了,通过手动安装就恐怕装错了

  3. 借使依靠的包很多来说,一个1个设置这几个重视是很吃力的工作

  4. 新校友初步写项指标时候,将次第跑起来十三分麻烦,因为恐怕时时忘了要怎么设置各类正视

能够将那个工作自动化起来,升高成效、减弱失误的可能率。”复杂的事物自动化,能自动化的事物一定要自动化。”是1个十分好的习惯

setuptools的文档比较庞大,刚接触的话,可能不太好找到切入点。学习技能的情势正是看旁人是怎么用的,能够参见一下Python的1个Web框架,flask是哪些写的: setup.py

理所当然,不难点本身写个安装脚本(deploy.sh)替代setup.py也未尝不可

asctime及ctime用法

4858.com 2

# --------------------------按图2转换时间
# asctime([t]) : 把一个表示时间的元组或者struct_time表示为这种形式:'Sun Jun 20 23:21:05 1993'。
# 如果没有参数,将会将time.localtime()作为参数传入。
print(time.asctime())# Wed May 31 22:00:10 2017

# ctime([secs]) : 把一个时间戳(按秒计算的浮点数)转化为time.asctime()的形式。如果参数未给或者为
# None的时候,将会默认time.time()为参数。它的作用相当于time.asctime(time.localtime(secs))。
print(time.ctime())  # Wed May 31 22:00:10 2017
print(time.ctime(time.time()))  # Wed May 31 22:00:10 2017

'''
Wed May 31 22:00:10 2017
Wed May 31 22:00:10 2017
Wed May 31 22:00:10 2017
'''

其它用法(sleep)

# 脚本或线程推迟指定的时间运行,单位为秒。
time.sleep(5)

 

1.1.5 子集、父集

能够行使issubset,issuperset方法,例如:

1 set_demo_1 = set([1,2,3,4,5])
2 set_demo_2 = set([1,2,3])
3 print(set_demo_1.issuperset(set_demo_2))#set_demo_1是set_demo_2的父集 返回true
4 print(set_demo_2.issubset(set_demo_1))#set_demo_2是set_demo_1的子集 返回true

requirements.txt

本条文件存在的目标是:

  1. 便利开发者维护软件的包重视。将开发进度中新增的包添加进那么些列表中,防止在setup.py安装正视时漏掉软件包

  2. 有利读者分明项目应用了什么样Python包

这一个文件的格式是每壹行李包裹蕴八个包重视的辨证,经常是flask>=0.10这种格式,须要是其1格式能被pip识别,那样就足以省略的通过pip
install -r
requirements.txt来把拥有Python包重视都装好了。具体格式表明:点这里

random模块

import random

print(random.random())#(0,1)----float    大于0且小于1之间的小数

print(random.randint(1,3))  #[1,3]    大于等于1且小于等于3之间的整数

print(random.randrange(1,3)) #[1,3)    大于等于1且小于3之间的整数

print(random.choice([1,'23',[4,5]]))#1或者23或者[4,5]

print(random.sample([1,'23',[4,5]],2))#列表元素任意2个组合

print(random.uniform(1,3))#大于1小于3的小数,如1.927109612082716 


item=[1,3,5,7,9]
random.shuffle(item) #打乱item的顺序,相当于"洗牌"
print(item)

4858.com 34858.com 4

#!/usr/bin/env python
#-*- coding:utf-8 -*-

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 += str(add)
    return code

print(v_code())

变更随机验证码

 

1.1.陆 对称差集

集合A与集合B中持有不属于A∩B的成分的聚集,例如:

1 set_demo_1 = set([2,3,4,5,4])
2 set_demo_2 = set([2,22,33,44,11])
3 print(set_demo_1.symmetric_difference(set_demo_2)) #返回去掉两者交集的部分

有关配置文件的选择形式

OS模块

提供对操作系统实行调用的接口

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

4858.com 54858.com 6

#!/usr/bin/env python
#-*- coding:utf-8 -*-

import os
# 在Linux和Mac平台上,该函数会原样返回path,在windows平台上会将路径中所有字符转换为小写,并将所有斜杠转换为反斜杠。
print(os.path.normcase('c:/windows\\system32\\'))
'''
os.path.normcase('c:/windows\\system32\\')
'''

# 规范化路径,如..和 /
print(os.path.normpath('c://windows\\System32\\../Temp/'))
'''
c:\windows\Temp
'''

path = '/Users/shuke/data/\\file/\\\\update.py/../..'
print(os.path.normpath(path))
'''
\Users\shuke\data

规范化路径

4858.com 74858.com 8

#方式一:推荐使用
import os
#具体应用
import os,sys
possible_topdir = os.path.normpath(os.path.join(
    os.path.abspath(__file__),
    os.pardir, #上一级
    os.pardir,
    os.pardir
))
sys.path.insert(0,possible_topdir)


#方式二:不推荐使用
os.path.dirname(os.path.dirname(os.path.dirname(os.path.abspath(__file__))))

os路径处理

 

一.一.柒 不相交的

五个聚众假如未有交集就回去true,例如:

1 set_demo_1 = set([1,2,3,4,5])
2 set_demo_2 = set([11,22,33])
3 print(set_demo_1.isdisjoint(set_demo_2))#没有交集返回true

只顾,在地点的目录结构中,没有将conf.py放在源码目录下,而是位于docs/目录下

多多类型对铺排文件的接纳做法是:

  1. 布署文件写在二个或多少个python文件中,比如此处的conf.py

  2. 品种中哪些模块用到那么些布局文件就一向通过import
    conf那种格局来在代码中运用安顿

那种做法作者不太援救:

  1. 这让单元测试变得紧Baba(因为模块内部注重了表面配置)

  2. 三只配置文件作为用户控制造进程序的接口,应当能够由用户私自钦点该公文的途径

  3. 先后组件可复用性太差,因为这种贯穿全数模块的代码硬编码格局,使得超越四分之2模块都重视conf.py这些文件

之所以,作者认为配置的使用,更好的方式是:

  1. 模块的布置都以足以灵活配置的,不受外部配置文件的影响

  2. 先后的安排也是足以灵活决定的

可知佐证那么些思想的是,用过nginx和mysql的同桌都知晓,nginx、mysql那么些程序都足以轻易的内定用户配置

从而,不应有在代码中一贯import
conf来接纳布署文件。下面目录结构中的conf.py,是付出的一个配备样例,不是在写死在先后中一贯引用的安排文件。能够透过给main.py运营参数指虞诩顿路径的情势来让程序读取配置内容。当然,那里的conf.py你可以换个类似的名字,比如settings.py。也许你也得以利用此外格式的始末来编排配置文件,比如settings.yaml之类的

 sys模块

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

4858.com 94858.com 10

import sys,time

for i in range(50):
    sys.stdout.write('%s\r' %('#'*i))
    sys.stdout.flush()
    time.sleep(0.1)

'''
注意:在pycharm中执行无效,请到命令行中以脚本的方式执行
'''

进度条

进程条完结

 

一.1.八 使用运算符来代替方法调用

1 A = B | C #取并集
2 A = B & C #取交集
3 A = B - C #取差集,在B中去掉C中的部分
4 A = B ^ C #取对称差集

5.调用任何目录下的py文件

先采取os模块下的os.path.dirname()命令获取上级目录路径,再选用sys模块下的sys.path.append()命令将引得路径添加到环境路径里

shutil模块

模块效能:  3个相比较高级的 文件、文件夹、压缩包 处理模块

4858.com 114858.com 12

#!/usr/bin/env python
#-*- coding:utf-8 -*-

import shutil

# 1.shutil.copyfileobj(fsrc, fdst[, length])
# 将文件内容拷贝到另一个文件中,可以copy指定大小的内容
shutil.copyfileobj(open('Readme','r'),open('Readme_bak','w'))

# 2.shutil.copyfile(src, dst)
# 拷贝文件
shutil.copyfile('login.log','login_2017-06-05')

# 3.shutil.copymode(src, dst)
# 仅拷贝权限。内容、组、用户均不变
shutil.copymode('login.log','login_2017-06-05')     # 文件必须存在

# 4.shutil.copystat(src, dst)
# 仅拷贝状态的信息,包括:mode bits, atime, mtime, flags
shutil.copystat('Readme','Readme_bak')

# 5.shutil.copy(src, dst)
# 拷贝文件和权限
shutil.copy('Readme','Readme_bk')

# 6.shutil.copy2(src, dst)
# 拷贝文件和状态信息
shutil.copy2('Readme','Readme_bk')

# 7.shutil.ignore_patterns(*patterns)
# shutil.copytree(src, dst, symlinks=False, ignore=None)
# 递归的去拷贝目录,以及软连接的处理方式
shutil.copytree('E:\YQLFC\study\day06\study','E:\YQLFC\study\day06\study01',ignore=shutil.ignore_patterns('*.log'))
'''
注意: 目标目录不能存在,注意对folder2目录父级目录要有可写权限,ignore的意思是排除
'''
shutil.copytree('E:\YQLFC\study\day06\study','E:\YQLFC\study\day06\study01',symlinks=True,ignore=shutil.ignore_patterns('*.log'))
'''
注意: 通常的拷贝都把软连接拷贝成硬链接,即对待软连接来说,创建新的文件
'''

# 8.shutil.rmtree(path[, ignore_errors[, onerror]])
# 递归的去删除文件
shutil.rmtree(r'E:\YQLFC\study\day06\study01')


# 9.shutil.move(src, dst)
# 递归的去移动文件,它类似mv命令,其实就是重命名。
shutil.move(r'E:\YQLFC\study\day06\study01',r'E:\YQLFC\study\day06\study02')

文件.权限.目录操作

1.2 基本操作

 1 set_demo = set([1,2,3,4,5])
 2 set_demo.add(66) #添加操作,添加一项
 3 set_demo.update([11,22]) #添加操作,添加多项
 4 
 5 set_demo.remove(66) #删除操作,删除指定一项,若没有则报错
 6 len(set_demo) # 集合长度
 7 
 8 set_demo.pop() #删除操作,随机删除一个,并且返回该值
 9 set_demo.discard(666) #删除操作,删除指定一个,若没有则什么都不做
10 print(set_demo)

6.作业:ATM程序

次第须要:

一成不变完结3个ATM + 购物商城先后

  1. 额度 16000或自定义

  2. 福寿双全购物商城,买东西参加 购物车,调用信用卡接口结账

  3. 能够提现,手续费5%

  4. 每月2二号出账单,每月10号为还款日,过期未还,按欠款总额
    拾叁分之5 每一日计算利息

  5. 援救多账户登录

  6. 支撑账户间转账

  7. 笔录每月一般消费流水

  8. 提供还款接口

  9. ATM记录操作日志 

  10. 提供管理接口,包括丰硕账户、用户额度,冻结账户等。。。

  11. 用户认证用装饰器

 

shutil.make_archive(base_name, format,…)

始建压缩包并赶回文件路径,例如:zip、tar

创制压缩包并回到文件路径,例如:zip、tar

  • base_name:
    压缩包的公文名,也能够是压缩包的门路。只是文件名时,则保留至当前目录,不然保存至钦定路线,
  • 如 data_bak                       =>保存至如今路线
  • 如:/tmp/data_bak =>保存至/tmp/
  • format: 压缩包种类,“zip”, “tar”, “bztar”,“gztar”
  • root_dir: 要削减的文书夹路径(暗许当前目录)
  • owner: 用户,暗中同意当前用户
  • group: 组,暗许当前组
  • logger: 用于记录日志,常常是logging.Logger对象

    # 将 /data 下的文件打包放置当前先后目录
    import shutil
    ret = shutil.make_archive(“data_bak”, ‘gztar’, root_dir=’/data’)

    # 将 /data下的文件打包放置 /tmp/目录
    import shutil
    ret = shutil.make_archive(“/tmp/data_bak”, ‘gztar’, root_dir=’/data’)

shutil 对压缩包的拍卖是调用 ZipFile 和 TarFile 八个模块来落实的,详细:

4858.com 134858.com 14

import zipfile

# 压缩
z = zipfile.ZipFile('study.zip', 'w')       # 包名
z.write('login.log')                        # 将指定文件压缩至压缩包中
z.write('Readme')
z.close()

# 解压
z = zipfile.ZipFile('study.zip', 'r')
z.extractall(path='.')                    # 解压路径,可以指定,默认当前    
z.close()

zipfile压缩解压缩

4858.com 154858.com 16

import tarfile

# 压缩
t=tarfile.open('/tmp/study.tar','w')
t.add('/data/study/Readme',arcname='Readme_bk')
t.add('/data/study/login.log',arcname='login.log_bk')
t.close()


# 解压
t=tarfile.open('/tmp/study.tar','r')
t.extractall('/data/tmp')
t.close()

tarfile压缩解压缩

 

 

2、文件部分

着力的流水生产线:打开文件->操作文件->关闭文件

json和pickle模块

事先大家学习过用eval内置方法能够将一个字符串转成python对象,但是,eval方法是有局限性的,对于常见的数据类型,json.loads和eval都能用,但蒙受特别类型的时候,eval就随便用了,所以eval的要紧照旧普通用来施行1个字符串表明式,并赶回表明式的值。

import json
x="[null,true,false,1]"
print(eval(x)) #报错,无法解析null类型,而json就可以
print(json.loads(x)) 

何以是系列化?

大家把目的(变量)从内部存款和储蓄器中变为可存款和储蓄或传输的经过称之为系列化,在Python中叫pickling,在其余语言中也被称之为serialization,marshalling,flattening等等,都以一个趣味。

缘何要系列化?

1:持久保存意况

需知3个软件/程序的施行就在拍卖一文山会海情景的变型,在编制程序语言中,’状态’会以各类各个有结构的数据类型(也可归纳的敞亮为变量)的花样被保存在内部存储器中。

内部存款和储蓄器是无能为力永久保存数据的,当程序运转了1段时间,大家断电大概重启程序,内部存款和储蓄器中关于那一个顺序的先头壹段时间的数码(有结构)都被清空了。

在断电或重启程序在此以前将次第当前内部存款和储蓄器中全体的数码都封存下来(保存到文件中),以便于下次程序执行能够从文件中载入以前的多寡,然后继续执行,那就是种类化。

现实的来说,你玩任务召唤闯到了第23关,你保存游戏景况,关机走人,下次再玩,还是能够从上次的岗位上马持续闯关。或如,虚拟机状态的挂起等。

贰:跨平台数据交互

体系化之后,不仅能够把类别化后的内容写入磁盘,还足以经过网络传输到其余机器上,假使收发的四头约定好实用一种种类化的格式,那么便打破了阳台/语言差别化带来的限量,达成了跨平台数据交互。

反过来,把变量内容从类别化的靶子重新读到内部存款和储蓄器里称之为反体系化,即unpickling。

二.1 文件打开情势

模式 含义
r 打开只读文件,该文件必须存在。
r+ 打开可读写的文件,该文件必须存在。
w 打开只写文件,若文件存在则文件长度清为0,即该文件内容会消失。若文件不存在则建立该文件。
w+ 打开可读写文件,若文件存在则文件长度清为零,即该文件内容会消失。若文件不存在则建立该文件。
a 以附加的方式打开只写文件。若文件不存在,则会建立该文件,如果文件存在,写入的数据会被加到文件尾,即文件原先的内容会被保留。
a+ 以附加方式打开可读写的文件。若文件不存在,则会建立该文件,如果文件存在,写入的数据会被加到文件尾后,即文件原先的内容会被保留。

注:上述的形象字符串都得以再加多少个b字符,如rb、w+b或ab+等组合,参加b
字符用来报告函数库打开的文书为二进制文件,而非纯文字文件。然而在POSIX系统,包涵Linux都会忽略该字符。

json种类化应用

1旦大家要在差异的编制程序语言之间传递对象,就务须把指标类别化为正规格式,比如XML,但更好的方法是种类化为JSON,因为JSON代表出来正是三个字符串,能够被抱有语言读取,也能够方便地蕴藏到磁盘或许通过网络传输。JSON不仅是明媒正娶格式,并且比XML更快,而且能够直接在Web页面中读取,卓殊便于。

JSON代表的靶子正是专业的JavaScript语言的对象,JSON和Python内置的数据类型对应如下:

4858.com 17

4858.com 18

示例:

4858.com 194858.com 20

import json

# ********dumps&&loads搭配使用***********
# 1. 序列化
dic = {'name': 'alvin', 'age': 23, 'sex': 'male'}
j = json.dumps(dic)
print(type(j))  # <class 'str'>

# 将dumps后的str类型的数据写入文件
f = open('info.json', 'w')
f.write(j)                          # 等价于json.dump(dic,f)
f.close()


# 2.反序列化(读取数据加载到内存中)
f = open('info.json')
data = json.loads(f.read())  # 等价于data=json.load(f)

json.dumps和json.loads

4858.com 214858.com 22

# ********dump&&load搭配使用***********
# (大多应用于将内存中的数据保存至本地存储进行读写操作时)
# 1. 序列化
dic = {'name': 'alvin', 'age': 23, 'sex': 'male'}
json.dump(dic,open('info1.json','w'))

# 2. 反序列化
data=json.load(open('info1.json','r'))
print(data,type(data))
'''
执行结果:
{'age': 23, 'sex': 'male', 'name': 'alvin'} <class 'dict'>
'''

json.dump和json.load

 注意的题材:

import json
# dct="{'1':111}"                 #json 不认单引号
# dct=str({"1":111})              # 报错,因为生成的数据还是单引号:{'one': 1}
# print(dct)                      # 转换后还是单引号

dct='{"1":"111"}'
print(json.loads(dct))

'''
执行结果:
{'1': '111'}
'''

注:  无论数额是何等创设的,只要满意json格式,就能够json.loads出来,不自然非要dumps的多少才能loads

二.二 文件的读写操作

读文件操作,read(size)方法,参数能够输入读取长度,不填暗中认可读取全部

1 f = open("file_demo",mode="r",encoding='utf-8') #创建文件句柄引用
2 print(f.read())
3 f.close()

写文件操作

1 f = open("file_demo",mode="w",encoding='utf-8') #创建文件句柄引用
2 f.write("测试用例\n")
3 f.close()

读一行、多行

1 f = open("file_demo",mode="r",encoding='utf-8') #创建文件句柄引用
2 print(f.readline()) #单行读取
3 f.close()
4 
5 f = open("file_demo",mode="r",encoding='utf-8') #创建文件句柄引用
6 for line in f.readlines(): #读取全部文件的全部行,存放着文件中,如果文件较大则速度会非常慢,一般不推荐readlines
7     print(line.strip())
8 f.close()

pickle系列化应用

 4858.com 23

4858.com 244858.com 25

import pickle


dic = {'name': 'alvin', 'age': 23, 'sex': 'male'}

# 1. 序列化
p = pickle.dumps(dic)
print(type(p))          # <class 'bytes'>
f = open('info.pkl', 'wb')          # 注意是w是写入str,wb是写入bytes,p是'bytes'类型
f.write(p)                          # 等价于pickle.dump(dic,f)
f.close()

# 2.反序列化
import pickle
f = open('info.pkl', 'rb')
data = pickle.loads(f.read())       # 等价于data=pickle.load(f)
print(data,type(data),data['age'])
'''
{'age': 23, 'sex': 'male', 'name': 'alvin'} <class 'dict'> 23
'''

pickle.dumps和pickle.loads

4858.com 264858.com 27

import pickle

dic = {'name': 'shuke', 'age': 23, 'sex': 'male'}
# 1. 序列化
pickle.dump(dic,open('info.pkl','wb'))

# 反序列化
data=pickle.load(open('info.pkl','rb'))
print(data,data['name'])
'''
{'sex': 'male', 'age': 23, 'name': 'shuke'} shuke
'''

pickle.dump和pickle.load

注:
Pickle的难点和拥有别的编制程序语言特有的类别化难点壹样,正是它只好用于Python,并且只怕两样版本的Python互相都不般配,由此,只好用Pickle保存这么些不重要的数目,无法学有所成地反系列化也没涉及。 

 

2.3 文件的光标(地点操作)

文件地方操作有以下多少个点子:tell,seek tell()可以回来当前岗位
seek(offset[,
whence]),offset参数是发端的偏移量,表示偏移多少个字节,whence暗许为0,表示要从哪些岗位上马晃动:0代表从文件开首初始算起,壹意味着从脚下职分上马算起,贰意味从文件末尾算起。

shelve模块

shelve模块比pickle模块简单,只有三个open函数,再次来到类似字典的靶子,可读可写;key必须为字符串,而值能够是python所扶助的数据类型

import shelve

f=shelve.open(r'sheve.txt')
f['stu1_info']={'name':'egon','age':18,'hobby':['piao','smoking','drinking']}
f['stu2_info']={'name':'gangdan','age':53}
f['school_info']={'website':'http://www.pypy.org','city':'beijing'}

print(f['stu1_info']['hobby'])
f.close()
'''
执行结果:
['piao', 'smoking', 'drinking']
'''

 

2.4 文件的flush()操作

flush()方法刷新文件之中缓冲,直接把在那之中缓冲区的数码及时写入文件,而不是被动的等待输出缓冲区写入。可以预防断电等意况使数码未有写入文件。

1 f = open("file_demo",mode="a",encoding='utf-8') #创建文件句柄引用
2 f.write("这是追加数据")
3 f.flush()#将缓存区的数据写入到文件
4 f.close()

xml模块

xml是兑现差异语言或程序之间进行数据交换的说道,跟json大约,但json使用起来更简便易行,不过,北宋,在json还没出生的深紫灰时代,大家只可以选拔用xml呀,到现在很多价值观专营商如金融行业的许多系统的接口还第二是xml。

xml的格式如下,便是经过<>节点来分别数据结构的:

4858.com 284858.com 29

<?xml version="1.0"?>
<data>
    <country name="Liechtenstein">
        <rank updated="yes">2</rank>
        <year>2008</year>
        <gdppc>141100</gdppc>
        <neighbor name="Austria" direction="E"/>
        <neighbor name="Switzerland" direction="W"/>
    </country>
    <country name="Singapore">
        <rank updated="yes">5</rank>
        <year>2011</year>
        <gdppc>59900</gdppc>
        <neighbor name="Malaysia" direction="N"/>
    </country>
    <country name="Panama">
        <rank updated="yes">69</rank>
        <year>2011</year>
        <gdppc>13600</gdppc>
        <neighbor name="Costa Rica" direction="W"/>
        <neighbor name="Colombia" direction="E"/>
    </country>
</data>

xml数据

xml数据

xml协议在每个语言里的都 是扶助的,在python中常用以下格局操作xml:

# print(root.iter('year'))             #全文搜索
# print(root.find('country'))          #在root的子节点找,只找一个
# print(root.findall('country'))       #在root的子节点找,查找所有

4858.com 304858.com 31

import xml.etree.ElementTree as ET

tree = ET.parse("xmltest.xml")
root = tree.getroot()
print(root.tag)

#遍历xml文档
for child in root:
    print('========>',child.tag,child.attrib,child.attrib['name'])
    for i in child:
        print(i.tag,i.attrib,i.text)

#只遍历year 节点
for node in root.iter('year'):
    print(node.tag,node.text)
#---------------------------------------

import xml.etree.ElementTree as ET

tree = ET.parse("xmltest.xml")
root = tree.getroot()

#修改
for node in root.iter('year'):
    new_year=int(node.text)+1
    node.text=str(new_year)
    node.set('updated','yes')
    node.set('version','1.0')
tree.write('test.xml')


#删除node
for country in root.findall('country'):
   rank = int(country.find('rank').text)
   if rank > 50:
     root.remove(country)

tree.write('output.xml')

示例

4858.com 324858.com 33

#在country内添加(append)节点year2
import xml.etree.ElementTree as ET
tree = ET.parse("a.xml")
root=tree.getroot()
for country in root.findall('country'):
    for year in country.findall('year'):
        if int(year.text) > 2000:
            year2=ET.Element('year2')
            year2.text='新年'
            year2.attrib={'update':'yes'}
            country.append(year2) #往country节点下添加子节点

tree.write('a.xml.swap')

添加子节点

创建xml文档:

4858.com 344858.com 35

import xml.etree.ElementTree as ET


new_xml = ET.Element("namelist")
name = ET.SubElement(new_xml,"name",attrib={"enrolled":"yes"})
age = ET.SubElement(name,"age",attrib={"checked":"no"})
sex = ET.SubElement(name,"sex")
sex.text = '33'
name2 = ET.SubElement(new_xml,"name",attrib={"enrolled":"no"})
age = ET.SubElement(name2,"age")
age.text = '19'

et = ET.ElementTree(new_xml) #生成文档对象
et.write("test.xml", encoding="utf-8",xml_declaration=True)

ET.dump(new_xml) #打印生成的格式

示例

 

2.5 文件的truncate()方法

truncate( [ size ]):用于从文件的首行首字符开头截断,截断文件为 size
个字符,无 size 表示从当前职责截断;截断之后,前边的具有字符被删去。

configparser模块

针对key/value方式的布署文件进行增加和删除改查操作

4858.com 364858.com 37

# 注释1
; 注释2


[Block]
zoneid = 4000
opendatasys = True

[db]
dbhost = 192.168.1.100
dbuser = root
dbpassword = 123456
dbadmin = admin

[center]
centerhost = 127.0.0.1
centerport = 42000

[gateway]
host = 192.168.1.101
transferport = 40001

settings.ini

注:
当中的key/value也能够形如k壹:v1的格式

常用操作

4858.com 384858.com 39

#!/usr/bin/env python
#-*- coding:utf-8 -*-

import configparser

config=configparser.ConfigParser()
config.read('settings.ini')

# 查看所有的标题
res=config.sections()
print(res)              # ['Block', 'log', 'db', 'center']

#查看标题Block下所有key=value的key
options=config.options('Block')
print(options)              # ['zoneid', 'opendatasys']

# 查看标题db下所有key=value的(key,value)格式
item_list=config.items('db')
print(item_list)             # [('dbhost', '192.168.1.100'), ('dbuser', 'root'), ('dbpassword', '123456'), ('dbadmin', 'admin')]

#查看标题log下BEBUG的值=>字符串格式
val=config.get('log','DEBUG')
print(val)              # 0; 字符串格式

#查看标题Block下ZONEID的值=>整数格式
val1=config.getint('Block','ZONEID')
print(val1)                         # 40002; 整数

#查看标题Block下的opendatasys值=>布尔值格式
val2=config.getboolean('Block','opendatasys')
print(val2)                         # True; 布尔值True

#查看标题center下CENTERPORT的值=>浮点型格式
val3=config.getfloat('center','CENTERPORT')
print(val3)                         # 42000.0; 浮点数

读取

4858.com 404858.com 41

import configparser

config=configparser.ConfigParser()
config.read('settings.ini',encoding='utf-8')


# 删除整个标题Block
config.remove_section('log')

# 删除标题center下的某个CENTERHOST和CENTERPORT
config.remove_option('center','CENTERHOST')
config.remove_option('center','CENTERPORT')

# 判断是否存在某个标题
print(config.has_section('log'))

#判断标题Block下是否有GAMEID
print(config.has_option('Block','GAMEID'))

#添加一个标题
# config.add_section('gateway')

# 在标题gateway下添加HOST=192.168.1.101,TRANSFERPORT=40001的配置
config.set('gateway','HOST','192.168.1.101')
config.set('gateway','TRANSFERPORT','40001')            # 正确
config.set('gateway','TRANSFERPORT',40001)              # 报错,必须是字符串数据类型

#最后将修改的内容写入文件,完成最终的修改
config.write(open('settings.ini','w'))

修改或充实

次第中采纳的配备文件key/value格式绝相比较较广泛,如php.ini文件就遵照那种格式。

演示文件的格式如下,文件名称为settings.ini:

[Block]
zoneid = 40002
opendatasys = True

[db]
dbhost = 192.168.1.100
dbuser = root
dbpassword = 123456
dbadmin = admin

[center]
CENTERHOST=127.0.0.1
CENTERPORT=42000

[gateway]
host = 192.168.1.101
transferport = 40001

获取具有节点

import configparser
config=configparser.ConfigParser()
config.read('settings.ini',encoding='utf-8')
res=config.sections()
print(res)

'''
打印结果:
['Block', 'db', 'center', 'gateway']
'''

 获取钦赐节点下全部的键值对

import configparser
config=configparser.ConfigParser()
config.read('settings.ini',encoding='utf-8')
res=config.items('Block')
print(res)

'''
打印结果:
[('zoneid', '40002'), ('opendatasys', 'True')]
'''

赢得内定节点下拥有的键

import configparser
config=configparser.ConfigParser()
config.read('settings.ini',encoding='utf-8')
res=config.options('Block')
print(res)

'''
打印结果:
['zoneid', 'opendatasys']
'''

取得钦定节点下钦点key的值

import configparser
config=configparser.ConfigParser()
config.read('settings.ini',encoding='utf-8')

res1=config.get('center','CENTERHOST')
res2=config.getint('center','CENTERPORT')
print(res1)
print(res2)

'''
打印结果:
127.0.0.1
42000
'''

增加和删除改查

4858.com 424858.com 43

import configparser
config=configparser.ConfigParser()
config.read('settings.ini',encoding='utf-8')

#添加节点
config.add_section('global')                    # 已经存在则报错
config['global']['username']='shuke'
config['global']['passwd']='123456'
config.write(open('settings.ini','w'))          # 将修改写入文件保存

#删除节点
config.remove_section('global')                 # 删除节点section
config.remove_option('global','host')           # 删除节点section下的某一个option(key)
config.write(open('settings.ini','w'))

# 修改
config.set('Block','zoneid','4000')
config.write(open('settings.ini','w'))

#检查
has_sec=config.has_section('Block')
print(has_sec)                                  # True
has_sec=config.has_option('Block','zoneid')     # Block下是否有一个键zoneid
print(has_sec)                                  # True

增加和删除改查

依据上述的法子新建1个布局文件

import configparser

config = configparser.ConfigParser()
# 默认的section
config["DEFAULT"] = {'ServerAliveInterval': '45',
                     'Compression': 'yes',
                     'CompressionLevel': '9'}
# 新建一个section,方法1
config['bitbucket.org'] = {}
config['bitbucket.org']['User'] = 'hg'      # key/value

# 新建一个section,方法2
config['topsecret.server.com'] = {}
topsecret = config['topsecret.server.com']
topsecret['Host_Port'] = '50022'        # mutates the parser
topsecret['ForwardX11'] = 'no'          # same here

# 在默认的section中增加一个新的option
config['DEFAULT']['ForwardX11'] = 'yes'
with open('example.ini', 'w') as configfile:
    config.write(configfile)

贰.陆 别的操作

fileno()重返2个整形的文件讲述符 encoding()重临打开文件的编码形式isatty()假如文件再三再四到贰个巅峰设备重临 True,不然重返 False
readable()即便文件可读,则赶回True,不然重回 False
writeable()即使文件可写,则赶回True,不然再次来到 False

DEFAULT section

比方安顿文件中设有二个名称叫 DEFAULT 的 section,那么任何 section
会扩大它的 option 并且可以覆盖它的 option。

4858.com 444858.com 45

[DEFAULT]
host = 127.0.0.1
port = 3306

[db_root]
user = root
pass = root

[db_huey]
host = 192.168.1.101
user = huey
pass = huey

db.conf

4858.com 464858.com 47

import configparser

cp = configparser.ConfigParser()
cp.read('db.conf')

print(cp.get('db_root', 'host'))    # 127.0.0.1
print(cp.get('db_huey', 'host'))   # 192.168.1.101

default_section.py

2.7 with操作

with能够自动匡助关闭文件,释放财富

1 with open("file_demo",mode="r",encoding="utf-8" ) as f:
2     for line in f:
3         print(line.strip()) #strip用来去除换行

插值 Interpolation

SafeConfigParser 提供了插值的性子来构成数据。

4858.com 484858.com 49

[DEFAULT]
url = %(protocol)s://%(server)s:%(port)s/

[http]
protocol = http
server = localhost
port = 8080

[ftp]
url = %(protocol)s://%(server)s/
protocol = ftp
server = 192.168.1.102

url.conf

4858.com 504858.com 51

import configparser

cp = configparser.ConfigParser()
cp.read('url.conf')

print(cp.get('http', 'url'))    # http://localhost:8080/
print(cp.get('ftp', 'url'))    # ftp://192.168.1.102/

interpolation_demo.py

 

 

三、JSON 系列化与反种类化

种类化能够简单的知情为将指标存款和储蓄到文件中,反连串化能够省略掌握为将文件数量读取用对象来储存
类别化进度

1 import json #导入json包
2 
3 # 序列化过程
4 # 字典类型转换为 JSON 对象
5 info = { "name":"CodeHu",
6          "age": 25}
7 with open("json.text","w") as f:
8     f.write( json.dumps(info) )
9     #json.dump(info,f) #或者使用dump

反类别进程

1 import json
2 # 反序列化
3 with open("json.text","r") as f:
4     print(json.loads(f.read())["age"])
5     #print(json.load(f)["age"])#可以采用load方法读取

hashlib模块

 hash:一种算法 ,3.x里代替了md伍模块和sha模块,主要提供 SHA1, SHA2②4,
SHA25陆, SHA3八肆, SHA51贰 ,MD5 算法
八本性状:

  1. 情节同样则hash运算结果一致,内容有点改变则hash值则变
  2. 不可逆推
  3. 1如既往算法:无论校验多少长度的数码,获得的哈希值长度固定。

4858.com 524858.com 53

#!/usr/bin/env python
#-*- coding:utf-8 -*-

import hashlib

string = "HelloWorld"
# ######## md5 ########
md5 = hashlib.md5()
md5.update(string.encode('utf-8'))     # 注意转码
res = md5.hexdigest()
print("md5加密结果:",res)

# ######## sha1 ########
sha1 = hashlib.sha1()
sha1.update(string.encode('utf-8'))
res = sha1.hexdigest()
print("sha1加密结果:",res)

# ######## sha256 ########
sha256 = hashlib.sha256()
sha256.update(string.encode('utf-8'))
res = sha256.hexdigest()
print("sha256加密结果:",res)

# ######## sha384 ########
sha384 = hashlib.sha384()
sha384.update(string.encode('utf-8'))
res = sha384.hexdigest()
print("sha384加密结果:",res)

# ######## sha512 ########
sha512= hashlib.sha512()
sha512.update(string.encode('utf-8'))
res = sha512.hexdigest()
print("sha512加密结果:",res)

# ######## 注意 ########
m = hashlib.md5()
m.update('Hello'.encode('utf8'))
print('Hello的md5值: ',m.hexdigest())         # Hello字符串的md5值

m.update('World'.encode('utf8'))
print('World的md5值: ',m.hexdigest())         # World字符串的md5值

m2 = hashlib.md5()
m2.update('HelloWorld'.encode('utf8'))      
print('HelloWorld的md5值: ',m2.hexdigest())   # HelloWorld字符串的md5值

'''
md5加密结果: 68e109f0f40ca72a15e05cc22786f8e6
sha1加密结果: db8ac1c259eb89d4a131b253bacfca5f319d54f2
sha256加密结果: 872e4e50ce9990d8b041330c47c9ddd11bec6b503ae9386a99da8584e9bb12c4
sha384加密结果: 293cd96eb25228a6fb09bfa86b9148ab69940e68903cbc0527a4fb150eec1ebe0f1ffce0bc5e3df312377e0a68f1950a
sha512加密结果: 8ae6ae71a75d3fb2e0225deeb004faf95d816a0a58093eb4cb5a3aa0f197050d7a4dc0a2d5c6fbae5fb5b0d536a0a9e6b686369fa57a027687c3630321547596
Hello的md5值:  8b1a9953c4611296a827abf8c47804d7
World的md5值:  68e109f0f40ca72a15e05cc22786f8e6
HelloWorld的md5值:  68e109f0f40ca72a15e05cc22786f8e6
'''

示例

 注: 把一段十分长的数量update数次,与一遍update那段长数据,得到的结果壹致,可是update数次为校验大文件提供了或许。

 以上加密算法固然依然非常厉害,但时候存在瑕疵,即:通过撞库能够反解。所以,有要求对加密算法中添加自定义key再来做加密。

low = hashlib.md5()
low.update('HelloWorld'.encode('utf-8'))
res = low.hexdigest()
print("普通加密:",res)

high = hashlib.md5(b'e1b8klemn3L')              # 默认自定义一个key值
high.update('HelloWorld'.encode('utf-8'))
res = high.hexdigest()
print("采用key加密:",res)

'''
普通加密: 68e109f0f40ca72a15e05cc22786f8e6
采用key加密: 94774db9f7276dbcb9b75cf690c568ac
'''

4858.com 544858.com 55

import hashlib
passwds=[
    'alex3714',
    'alex1313',
    'alex94139413',
    'alex123456',
    '123456alex',
    'a123lex',
    ]
def make_passwd_dic(passwds):
    dic={}
    for passwd in passwds:
        m=hashlib.md5()
        m.update(passwd.encode('utf-8'))
        dic[passwd]=m.hexdigest()
    return dic

def break_code(cryptograph,passwd_dic):
    for k,v in passwd_dic.items():
        if v == cryptograph:
            print('密码是===>\033[46m%s\033[0m' %k)

cryptograph='aee949757a2e698417463d47acac93df'
break_code(cryptograph,make_passwd_dic(passwds))

模拟撞库破解密码

暴力破解:模拟撞库

 python 还有3个 hmac 模块,它在那之中对我们创设 key 和 内容
实行进一步的处理然后再加密:

1 import hmac
2 h = hmac.new('Hello'.encode('utf8'))
3 h.update('World'.encode('utf8'))
4 print (h.hexdigest())           # c71c0cd0dc2449bdd89d28eb03bef204

 

肆、工程目录规范

摘自

 subprocess模块

4858.com 564858.com 57

subprocess.Popen(
      args, 
      bufsize=0, 
      executable=None,
      stdin=None,
      stdout=None, 
      stderr=None, 
      preexec_fn=None, 
      close_fds=False, 
      shell=False, 
      cwd=None, 
      env=None, 
      universal_newlines=False, 
      startupinfo=None, 
      creationflags=0)

1)、args可以是字符串或者序列类型(如:list,元组),用于指定进程的可执行文件及其参数。如果是序列类型,第一个元素通常是可执行文件的路径。我们也可以显式的使用executeable参数来指定可执行文件的路径。
2)、bufsize:指定缓冲。0 无缓冲,1 行缓冲,其他 缓冲区大小,负值 系统缓冲(全缓冲)
3)、stdin, stdout, stderr分别表示程序的标准输入、输出、错误句柄。他们可以是PIPE,文件描述符或文件对象,也可以设置为None,表示从父进程继承。
4)、preexec_fn只在Unix平台下有效,用于指定一个可执行对象(callable object),它将在子进程运行之前被调用。
5)、Close_sfs:在windows平台下,如果close_fds被设置为True,则新创建的子进程将不会继承父进程的输入、输出、错误管道。我们不能将close_fds设置为True同时重定向子进程的标准输入、输出与错误(stdin, stdout, stderr)。
6)、shell设为true,程序将通过shell来执行。
7)、cwd用于设置子进程的当前目录
8)、env是字典类型,用于指定子进程的环境变量。如果env = None,子进程的环境变量将从父进程中继承。
Universal_newlines:不同操作系统下,文本的换行符是不一样的。如:windows下用'/r/n'表示换,而Linux下用'/n'。如果将此参数设置为True,Python统一把这些换行符当作'/n'来处理。startupinfo与createionflags只在windows下用效,它们将被传递给底层的CreateProcess()函数,用于设置子进程的一些属性,如:主窗口的外观,进程的优先级等等。
9)、startupinfo与createionflags只在windows下有效,它们将被传递给底层的CreateProcess()函数,用于设置子进程的一些属性,如:主窗口的外观,进程的优先级等等。
Popen方法
1)、Popen.poll():用于检查子进程是否已经结束。设置并返回returncode属性。
2)、Popen.wait():等待子进程结束。设置并返回returncode属性。
3)、Popen.communicate(input=None):与子进程进行交互。向stdin发送数据,或从stdout和stderr中读取数据。可选参数input指定发送到子进程的参数。Communicate()返回一个元组:(stdoutdata, stderrdata)。注意:如果希望通过进程的stdin向其发送数据,在创建Popen对象的时候,参数stdin必须被设置为PIPE。同样,如果希望从stdout和stderr获取数据,必须将stdout和stderr设置为PIPE。
4)、Popen.send_signal(signal):向子进程发送信号。
5)、Popen.terminate():停止(stop)子进程。在windows平台下,该方法将调用Windows API TerminateProcess()来结束子进程。
6)、Popen.kill():杀死子进程。
7)、Popen.stdin:如果在创建Popen对象是,参数stdin被设置为PIPE,Popen.stdin将返回一个文件对象用于策子进程发送指令。否则返回None。
8)、Popen.stdout:如果在创建Popen对象是,参数stdout被设置为PIPE,Popen.stdout将返回一个文件对象用于策子进程发送指令。否则返回None。
9)、Popen.stderr:如果在创建Popen对象是,参数stdout被设置为PIPE,Popen.stdout将返回一个文件对象用于策子进程发送指令。否则返回None。
10)、Popen.pid:获取子进程的进程ID。
11)、Popen.returncode:获取进程的返回值。如果进程还没有结束,返回None。
12)、subprocess.call(*popenargs, **kwargs):运行命令。该函数将一直等待到子进程运行结束,并返回进程的returncode。文章一开始的例子就演示了call函数。如果子进程不需要进行交互,就可以使用该函数来创建。
13)、subprocess.check_call(*popenargs, **kwargs):与subprocess.call(*popenargs, **kwargs)功能一样,只是如果子进程返回的returncode不为0的话,将触发CalledProcessError异常。在异常对象中,包括进程的returncode信息。

subprocess.波普n参数介绍

常用操作:

4858.com 584858.com 59

#!/usr/bin/env python
#-*- coding:utf-8 -*-

import  subprocess

'''
sh-3.2# ls /Users/egon/Desktop |grep txt$
mysql.txt
tt.txt
事物.txt
'''

# 模拟管道操作
res1=subprocess.Popen('ls /Users/jieli/Desktop',shell=True,stderr=subprocess.PIPE,stdout=subprocess.PIPE)      # stderr为标准错误输出,stdout为标准输出
res=subprocess.Popen('grep txt$',shell=True,stdin=res1.stdout,                                                 # 将res1的stdout作为res的stdin
                 stdout=subprocess.PIPE)
print(res.stdout.read().decode('utf-8'))        # 读取标准输出管道中的内容,读取后管道内容会被置为空

# 等同于上面,但是上面的优势在于,一个数据流可以和另外一个数据流交互,可以通过爬虫得到结果然后交给grep
res1=subprocess.Popen('ls /Users/jieli/Desktop |grep txt$',shell=True,stdout=subprocess.PIPE)       # 执行命令
print(res1.stdout.read().decode('utf-8'))


#windows下:
# dir | findstr 'test*'
# dir | findstr 'txt$'
import subprocess
res1=subprocess.Popen(r'dir E:\YQLFC\study\day06',shell=True,stdout=subprocess.PIPE)
res=subprocess.Popen('findstr test*',shell=True,stdin=res1.stdout,
                 stdout=subprocess.PIPE)
print(res.stdout.read().decode('gbk')) # subprocess使用当前系统默认编码,得到结果为bytes类型,在windows下需要用gbk解码

示例

参考链接: 

 

四.一 一般目录结构

只要你的体系名称叫foo, 最方便急忙目录结构:

Foo/
|-- bin/
|   |-- foo
|
|-- foo/
|   |-- tests/
|   |   |-- __init__.py
|   |   |-- test_main.py
|   |
|   |-- __init__.py
|   |-- main.py
|
|-- docs/
|   |-- conf.py
|   |-- abc.rst
|
|-- setup.py
|-- requirements.txt
|-- README

简不难单解释一下:

  • bin/: 存放项目的1些可执行文件,当然你能够起名script/之类的也行。
  • foo/: 存放项指标具备源代码。(一)
    源代码中的全数模块、包都应该放在此目录。不要置于顶层目录。(二)
    其子目录tests/存放单元测试代码;
    (三)程序的输入最棒命名字为 main.py。
  • docs/: 存放1些文书档案。
  • setup.py: 安装、布置、打包的本子。
  • requirements.txt: 存放软件重视的表面Python包列表。
  • README: 项目表明文件。

logging模块

4.2 README文件

这一个是各种连串都应该有的3个文书,目标是能大约描述该品种的信息,让读者极快明白这一个连串。

它要求证实以下多少个事项:

  • 软件定位,软件的基本成效。
  • 运行代码的不2秘籍: 安装环境、运转命令等。
  • 简单易行的运用验证。
  • 代码目录结构表明,更详细点能够证实软件的基本原理。
  • 周边难题求证。

1. 总括:用于便捷记录日志且线程安全的模块

  • 假若不点名filename,则私下认可打字与印刷到终点
  • 钦点日志级别:

钦点格局:
1:level=10
2:level=logging.ERROR

日志级别项目:
CRITICAL = 50
FATAL = CRITICAL
ERROR = 40
WARNING = 30
WARN = WARNING
INFO = 20
DEBUG = 10
NOTSET = 0

  • 钦定日志级别为EWranglerRO奥迪Q5,则唯有E卡宴RO安德拉及其以上级其余日志会被打字与印刷

4858.com 604858.com 61

#!/usr/bin/env python
#-*- coding:utf-8 -*-

import logging

logging.basicConfig(filename='access.log',
                    format='%(asctime)s - %(name)s - %(levelname)s -%(module)s:  %(message)s',
                    datefmt='%Y-%m-%d %H:%M:%S %p',
                    level=10)

logging.debug('debug')
logging.info('info')
logging.warning('warning')
logging.error('error')
logging.critical('critical')
logging.log(10,'log')       # 如果level=40,则只有logging.critical和loggin.error的日志会被打印

示例

4.3 setup.py

1般的话,用setup.py来保管代码的包裹、安装、安插难题。产业界规范的写法是用Python流行的卷入工具setuptools来治本这么些工作。那种艺术广泛使用于开源项目中。然则那里的核心思想不是用口径的工具来缓解这几个难题,而是说,多少个体系必将要有三个装置配置工具,能非常的慢便捷的在1台新机器大校环境装好、代码安排好和将程序运营起来。

2. 可在logging.basicConfig()函数中经过切实参数来改变logging模块暗中认可行为,可用参数有:

  1. filename:用钦赐的公文名创制FiledHandler,那样日志会被储存在钦定的文件中。
  2. filemode:文件打开药方式,在钦赐了filename时使用这么些参数,暗中同意值为“a”还可内定为“w”。
  3. format:钦赐handler使用的日记彰显格式。 
  4. datefmt:钦赐日期时间格式。 
  5. level:设置rootlogger(前面会讲解具体概念)的日志级别 
  6. stream:用钦定的stream创设StreamHandler。能够钦点输出到sys.stderr,sys.stdout或然文件,暗中同意为sys.stderr。若同时列出了filename和stream七个参数,则stream参数会被忽略。
  7. 点击查阅更详实

4.4 requirements.txt

本条文件存在的指标是:
方便开发者维护软件的包依赖。将付出进度中新增的包添加进那么些列表中,制止在setup.py安装注重时漏掉软件包。
方便读者明确项目采用了什么样Python包。
那么些文件的格式是每壹行包涵多少个包重视的证实,常常是flask>=0.十那种格式,要求是这一个格式能被pip识别,那样就足以简简单单的通过
pip install -r requirements.txt来把富有Python包信赖都装好。

3. 日志格式

%(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

用户输出的消息

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

paramiko模块

paramiko是三个用来做长途控制的模块,使用该模块可以对长距离服务器进行命令或文件操作,值得1说的是,fabric和ansible内部的远程管理正是使用的paramiko来现实。

安装

pycrypto,由于 paramiko 模块内部依赖pycrypto,所以先下载安装pycrypto
pip3 install pycrypto
pip3 install paramiko

注:如果在安装pycrypto2.0.1时发生如下错误
        command 'gcc' failed with exit status 1...
可能是缺少python-dev安装包导致
如果gcc没有安装,请事先安装gcc

应用:

SSHClient

用以连接远程服务器并实施基本命令

依照用户名密码连接:

import paramiko

# 创建SSH对象
ssh = paramiko.SSHClient()
# 允许连接不在know_hosts文件中的主机
ssh.set_missing_host_key_policy(paramiko.AutoAddPolicy())
# 连接服务器
ssh.connect(hostname='c1.salt.com', port=22, username='shuke', password='123')

# 执行命令
stdin, stdout, stderr = ssh.exec_command('df')
# 获取命令结果
result = stdout.read()

# 关闭连接
ssh.close()

4858.com 624858.com 63

import paramiko

transport = paramiko.Transport(('hostname', 22))
transport.connect(username='shuke', password='123')

ssh = paramiko.SSHClient()
ssh._transport = transport

stdin, stdout, stderr = ssh.exec_command('df')
print stdout.read()

transport.close()

SSHClient 封装 Transport

听闻公钥密钥连接:

4858.com 644858.com 65

import paramiko

private_key = paramiko.RSAKey.from_private_key_file('/home/auto/.ssh/id_rsa')

# 创建SSH对象
ssh = paramiko.SSHClient()
# 允许连接不在know_hosts文件中的主机
ssh.set_missing_host_key_policy(paramiko.AutoAddPolicy())
# 连接服务器
ssh.connect(hostname='c1.salt.com', port=22, username='shuke', key=private_key)

# 执行命令
stdin, stdout, stderr = ssh.exec_command('df')
# 获取命令结果
result = stdout.read()

# 关闭连接
ssh.close()

示例

4858.com 664858.com 67

import paramiko

private_key = paramiko.RSAKey.from_private_key_file('/home/auto/.ssh/id_rsa')

transport = paramiko.Transport(('hostname', 22))
transport.connect(username='shuke', pkey=private_key)

ssh = paramiko.SSHClient()
ssh._transport = transport

stdin, stdout, stderr = ssh.exec_command('df')

transport.close()

SSHClient封装Transport

4858.com 684858.com 69

import paramiko
from io import StringIO

key_str = """-----BEGIN RSA PRIVATE KEY-----
MIIEpQIBAAKCAQEAq7gLsqYArAFco02/55IgNg0r7NXOtEM3qXpb/dabJ5Uyky/8
NEHhFiQ7deHIRIuTW5Zb0kD6h6EBbVlUMBmwJrC2oSzySLU1w+ZNfH0PE6W6fans
H80whhuc/YgP+fjiO+VR/gFcqib8Rll5UfYzf5H8uuOnDeIXGCVgyHQSmt8if1+e
7hn1MVO1Lrm9Fco8ABI7dyv8/ZEwoSfh2C9rGYgA58LT1FkBRkOePbHD43xNfAYC
tfLvz6LErMnwdOW4sNMEWWAWv1fsTB35PAm5CazfKzmam9n5IQXhmUNcNvmaZtvP
c4f4g59mdsaWNtNaY96UjOfx83Om86gmdkKcnwIDAQABAoIBAQCnDBGFJuv8aA7A
ZkBLe+GN815JtOyye7lIS1n2I7En3oImoUWNaJEYwwJ8+LmjxMwDCtAkR0XwbvY+
c+nsKPEtkjb3sAu6I148RmwWsGncSRqUaJrljOypaW9dS+GO4Ujjz3/lw1lrxSUh
IqVc0E7kyRW8kP3QCaNBwArYteHreZFFp6XmtKMtXaEA3saJYILxaaXlYkoRi4k8
S2/K8aw3ZMR4tDCOfB4o47JaeiA/e185RK3A+mLn9xTDhTdZqTQpv17/YRPcgmwz
zu30fhVXQT/SuI0sO+bzCO4YGoEwoBX718AWhdLJFoFq1B7k2ZEzXTAtjEXQEWm6
01ndU/jhAasdfasdasdfasdfa3eraszxqwefasdfadasdffsFIfAsjQb4HdkmHuC
OeJrJOd+CYvdEeqJJNnF6AbHyYHIECkj0Qq1kEfLOEsqzd5nDbtkKBte6M1trbjl
HtJ2Yb8w6o/q/6Sbj7wf/cW3LIYEdeVCjScozVcQ9R83ea05J+QOAr4nAoGBAMaq
UzLJfLNWZ5Qosmir2oHStFlZpxspax/ln7DlWLW4wPB4YJalSVovF2Buo8hr8X65
lnPiE41M+G0Z7icEXiFyDBFDCtzx0x/RmaBokLathrFtI81UCx4gQPLaSVNMlvQA
539GsubSrO4LpHRNGg/weZ6EqQOXvHvkUkm2bDDJAoGATytFNxen6GtC0ZT3SRQM
WYfasdf3xbtuykmnluiofasd2sfmjnljkt7khghmghdasSDFGQfgaFoKfaawoYeH
C2XasVUsVviBn8kPSLSVBPX4JUfQmA6h8HsajeVahxN1U9e0nYJ0sYDQFUMTS2t8
RT57+WK/0ONwTWHdu+KnaJECgYEAid/ta8LQC3p82iNAZkpWlGDSD2yb/8rH8NQg
9tjEryFwrbMtfX9qn+8srx06B796U3OjifstjJQNmVI0qNlsJpQK8fPwVxRxbJS/
pMbNICrf3sUa4sZgDOFfkeuSlgACh4cVIozDXlR59Z8Y3CoiW0uObEgvMDIfenAj
98pl3ZkCgYEAj/UCSni0dwX4pnKNPm6LUgiS7QvIgM3H9piyt8aipQuzBi5LUKWw
DlQC4Zb73nHgdREtQYYXTu7p27Bl0Gizz1sW2eSgxFU8eTh+ucfVwOXKAXKU5SeI
+MbuBfUYQ4if2N/BXn47+/ecf3A4KgB37Le5SbLDddwCNxGlBzbpBa0=
-----END RSA PRIVATE KEY-----"""

private_key = paramiko.RSAKey(file_obj=StringIO(key_str))
transport = paramiko.Transport(('10.0.1.40', 22))
transport.connect(username='shuke', pkey=private_key)

ssh = paramiko.SSHClient()
ssh._transport = transport

stdin, stdout, stderr = ssh.exec_command('df')
result = stdout.read()

transport.close()

print(result)

依照私钥字符串举行三番五次

SFTPClient

用来连接远程服务器并履行上传下载

依据用户名密码上传下载

import paramiko

transport = paramiko.Transport(('hostname',22))
transport.connect(username='shuke',password='123')

sftp = paramiko.SFTPClient.from_transport(transport)
# 将location.py 上传至服务器 /tmp/test.py
sftp.put('/tmp/location.py', '/tmp/test.py')
# 将remove_path 下载到本地 local_path
sftp.get('remove_path', 'local_path')

transport.close()

听大人讲公钥密钥上传下载

import paramiko

private_key = paramiko.RSAKey.from_private_key_file('/home/auto/.ssh/id_rsa')

transport = paramiko.Transport(('hostname', 22))
transport.connect(username='shuke', pkey=private_key )

sftp = paramiko.SFTPClient.from_transport(transport)
# 将location.py 上传至服务器 /tmp/test.py
sftp.put('/tmp/location.py', '/tmp/test.py')
# 将remove_path 下载到本地 local_path
sftp.get('remove_path', 'local_path')

transport.close()

4858.com 704858.com 71

#!/usr/bin/env python
# -*- coding:utf-8 -*-
import paramiko
import uuid

class Haproxy(object):

    def __init__(self):
        self.host = '172.16.103.191'
        self.port = 22
        self.username = 'shuke'
        self.pwd = '123'
        self.__k = None

    def create_file(self):
        file_name = str(uuid.uuid4())
        with open(file_name,'w') as f:
            f.write('sb')
        return file_name

    def run(self):
        self.connect()
        self.upload()
        self.rename()
        self.close()

    def connect(self):
        transport = paramiko.Transport((self.host,self.port))
        transport.connect(username=self.username,password=self.pwd)
        self.__transport = transport

    def close(self):

        self.__transport.close()

    def upload(self):
        # 连接,上传
        file_name = self.create_file()

        sftp = paramiko.SFTPClient.from_transport(self.__transport)
        # 将location.py 上传至服务器 /tmp/test.py
        sftp.put(file_name, '/home/wupeiqi/tttttttttttt.py')

    def rename(self):

        ssh = paramiko.SSHClient()
        ssh._transport = self.__transport
        # 执行命令
        stdin, stdout, stderr = ssh.exec_command('mv /home/wupeiqi/tttttttttttt.py /home/shuke/ooooooooo.py')
        # 获取命令结果
        result = stdout.read()


ha = Haproxy()
ha.run()

Demo

Demo

 

re模块

壹.如何是正则?

正则就是用部分存有特种含义的记号组合到1同(称为正则表达式)来描述字符可能字符串的艺术。或然说:正则正是用来叙述1类东西的规则。(在Python中)它内嵌在Python中,并透过
re 模块实现。正则表明式情势被编写翻译成1多元的字节码,然后由用 C
编写的匹配引擎执行。

二.常用分外格局(元字符)

4858.com 72

4858.com 734858.com 74

#!/usr/bin/env python
#-*- coding:utf-8 -*-

import re

# =================================匹配模式=================================
# 一对一的匹配
print('hello'.replace('ll','gg'))   # heggo  用new字符串替换掉old字符串
print('hello'.find('ll'))   # 2  匹配到的索引位置

# ******正则匹配******
str = "Hello shuke, 123"
# \w与\W
print(re.findall('\w',str))     # ['H', 'e', 'l', 'l', 'o', 's', 'h', 'u', 'k', 'e', '1', '2', '3']
print(re.findall('\W',str))     # [' ', ',', ' ']

# \s与\S
print(re.findall('\s',str)) # [' ', ' ']
print(re.findall('\S',str)) # ['H', 'e', 'l', 'l', 'o', 's', 'h', 'u', 'k', 'e', ',', '1', '2', '3']

# \d与\D
print(re.findall('\d',str)) # ['1', '2', '3']
print(re.findall('\D',str)) # ['H', 'e', 'l', 'l', 'o', ' ', 's', 'h', 'u', 'k', 'e', ',', ' ']

#\A与\Z
print(re.findall('\AHe',str)) # ['He']
print(re.findall('123\Z',str)) # ['123']

#\n与\t
print(re.findall(r'\n','Hello shuke \n123')) # ['\n']
print(re.findall(r'\t','Hello shuke\t123')) # ['\t']

#^与$
print(re.findall('^H',str)) #['H']
print(re.findall('3$',str)) #['3']

# 重复匹配:| . | * | ? | .* | .*? | + | {n,m} |
#.
print(re.findall('a.b','a1b abc a*b a$b')) # ['a1b', 'a*b', 'a$b']
print(re.findall('a.b','a\nb'))     # []   .不能匹配到\n符
print(re.findall('a.b','a\nb',re.S))    # ['a\nb']
print(re.findall('a.b','a\nb',re.DOTALL))   # ['a\nb']同上一条意思一样

#*
print(re.findall('He*','hello '))   # []
print(re.findall('He*',str))    # ['He']
print(re.findall('ab*','b ab abbbb'))   # ['ab', 'abbbb']

#?
print(re.findall('He?',str))    # ['He']
print(re.findall('ab?','abbb'))     # ['ab']

#匹配所有包含小数在内的数字
print(re.findall('\d+\.?\d*',"asd123fd1.23asdls12dkk3.4esf5"))      # ['123', '1.23', '12', '3.4', '5']

#.* 默认为贪婪匹配
print(re.findall('a.*b','a1b222ahjhsk22222b'))  # ['a1b222ahjhsk22222b']

#.*?为非贪婪匹配:推荐使用
print(re.findall('a.*?b','a1b222ahjhsk22222b'))     # ['a1b', 'ahjhsk22222b']

#+
print(re.findall('ab+','a accc'))   # []
print(re.findall('ab+','abbb'))     # ['abbb']

#{n,m}
print(re.findall('ab{2}','abbb'))       # ['abb']
print(re.findall('ab{2,4}','abbb'))     # ['abbb']
print(re.findall('ab{1,}','abbb'))      # ['abbb'] 'ab{1,}' == 'ab+'
print(re.findall('ab{0,}','abbb'))      # ['abbb'] 'ab{0,}' == 'ab*'

#[]
#[]内的都为普通字符了,且如果-没有被转意的话,应该放到[]的开头或结尾
print(re.findall('a[1*-]b','a1b a*b a-b'))  # ['a1b', 'a*b', 'a-b']
#[]内的^代表的意思是取反,所以结果为['a=b']
print(re.findall('a[^1*-]b','a1b a*b a-b a=b'))     # ['a=b']
#[]内的^代表的意思是取反,所以结果为['a=b']
print(re.findall('a[0-9]b','a1b a*b a-b a=b'))      # ['a1b']
#[]内的^代表的意思是取反,所以结果为['a=b']
print(re.findall('a[a-z]b','a1b a*b a-b a=b aeb'))  # ['aeb']
#[]内的^代表的意思是取反,所以结果为['a=b']
print(re.findall('a[a-zA-Z]b','a1b a*b a-b a=b aeb aEb'))       # ['aeb', 'aEb']

#\# print(re.findall('a\\c','a\c')) #对于正则来说a\\c确实可以匹配到a\c,但是在python解释器读取a\\c时,会发生转义,然后交给re去执行,所以抛出异常
#r代表告诉解释器使用rawstring,即原生字符串,把我们正则内的所有符号都当普通字符处理,不要转义
print(re.findall(r'a\\c','a\c'))        # ['a\\c']
#同上面的意思一样,和上面的结果一样都是['a\\c']
print(re.findall('a\\\\c','a\c'))       # ['a\\c']

#():分组
print(re.findall('ab+','ababab123'))        # ['ab', 'ab', 'ab']
print(re.findall('(ab)+123','ababab123'))   # ['ab'],匹配到末尾的ab123中的ab
#findall的结果不是匹配的全部内容,而是组内的内容,?:可以让结果为匹配的全部内容
print(re.findall('(?:ab)+123','ababab123')) # ['ababab123']

#|
print(re.findall('compan(?:y|ies)','Too many companies have gone bankrupt, and the next one is my company'))  # ['companies', 'company']

re匹配情势

4858.com 754858.com 76

#!/usr/bin/env python
#-*- coding:utf-8 -*-

import re

# ===========================re模块提供的方法介绍===========================
str = 'Hello jack john shuke'
#1
print(re.findall('o',str) )   # ['o', 'o'],返回所有满足匹配条件的结果,放在列表里
#2
print(re.search('o',str).group())  # o,只到找到第一个匹配然后返回一个包含匹配信息的对象,该对象可以通过调用group()方法得到匹配的字符串,如果字符串没有匹配,则返回None。

#3
print(re.match('o',str))    # None,同search,不过在字符串开始处进行匹配,完全可以用search+^代替match
print(re.search('^o',str))  # None,用search+^代替match

#4
print(re.split('[ab]','abcd'))                     # ['', '', 'cd'],先按'a'分割得到''和'bcd',再对''和'bcd'分别按'b'分割
print(re.split('ke','jake shuke echo keke'))    # ['ja', ' shu', ' echo ', '', '']; 不带括号结果不包含分割的字符串
print(re.split('(ke)','jake shuke echo keke'))  # ['ja', 'ke', ' shu', 'ke', ' echo ', 'ke', '', 'ke', ''];带括号结果包含分割的字符串 

#5
print('===>',re.sub('j','J',str))       # ===> Hello Jack John shuke,不指定n,默认替换所有
print('===>',re.sub('j','J',str,1))     # ===> Hello Jack john shuke  替换一次
print('===>',re.sub('j','J',str,2))     # ===> Hello Jack John shuke  替换二次
print('===>',re.sub('^(\w+)(.*?\s)(\w+)(.*?\s)(\w+)(.*?)$',r'\5\2\3\4\1',str))  # ===> john jack Hello
print('===>',re.subn('j','J',str))      # ===> ('Hello Jack John shuke', 2),结果带有总共替换的次数

#6
obj=re.compile('\d{2}')

print(obj.search('abc123eeee').group())     # 12
print(obj.findall('abc123eeee'))            # ['12'],重用了obj

re模块提供的不贰秘籍

从网页源码中格外标签的采纳:

4858.com 774858.com 78

#!/usr/bin/env python
#-*- coding:utf-8 -*-

import re
print(re.findall("<(?P<tag_name>\w+)>\w+</(?P=tag_name)>","<h1>hello</h1>")) # ['h1']
print(re.search("<(?P<tag_name>\w+)>\w+</(?P=tag_name)>","<h1>hello</h1>").group()) # <h1>hello</h1>
print(re.search("<(?P<tag_name>\w+)>\w+</(?P=tag_name)>","<h1>hello</h1>").groupdict()) # {'tag_name': 'h1'}

print(re.search(r"<(\w+)>\w+</(\w+)>","<h1>hello</h1>").group())    # <h1>hello</h1>
print(re.search(r"<(\w+)>\w+</\1>","<h1>hello</h1>").group())       # <h1>hello</h1>

合营标签

4858.com 794858.com 80

#!/usr/bin/env python
#-*- coding:utf-8 -*-
import re

print(re.findall(r'-?\d+\.?\d*',"1-12*(60+(-40.35/5)-(-4*3))")) # ['1', '-12', '60', '-40.35', '5', '-4', '3'] 找出所有数字


#使用|,先匹配的先生效,|左边是匹配小数,而findall最终结果是查看分组,所有即使匹配成功小数也不会存入结果
#而不是小数时,就去匹配(-?\d+),匹配到的自然就是,非小数的数,在此处即整数
print(re.findall(r"-?\d+\.\d*|(-?\d+)","1-2*(60+(-40.35/5)-(-4*3))")) # ['1', '-2', '60', '', '5', '-4', '3'] 找出所有整数

匹配数字

4858.com 814858.com 82

#!/usr/bin/env python
#-*- coding:utf-8 -*-


#在线调试工具:tool.oschina.net/regex/#
import re

# 常规匹配
content='Hello 123 456 World_This is a Regex Demo'
res=re.match('Hello\s\d\d\d\s\d{3}\s\w{10}.*Demo',content)
print(res)
print(res.group())      # Hello 123 456 World_This is a Regex Demo
print(res.span())       # (0, 40)

# 泛匹配
content='Hello 123 456 World_This is a Regex Demo'
res=re.match('^Hello.*Demo',content)
print(res.group())      # Hello 123 456 World_This is a Regex Demo


# 匹配目标,获得指定数据
content='Hello 123 456 World_This is a Regex Demo'
res=re.match('^Hello\s(\d+)\s(\d+)\s.*Demo',content)
print(res.group())      # Hello 123 456 World_This is a Regex Demo; 匹配所有的内容
print(res.group(1))     # 123; 匹配第一个括号内的内容
print(res.group(2))     # 456; 匹配第二个括号内的内容



# 贪婪匹配:.*代表匹配尽可能多的字符
content='Hello 123 456 World_This is a Regex Demo'
res=re.match('^He.*(\d+).*Demo$',content)
print(res.group(1)) # 6; 只打印6,因为.*会尽可能多的匹配,然后后面跟至少一个数字


# 非贪婪匹配.*?匹配尽可能少的字符
content='Hello 123 456 World_This is a Regex Demo'
res=re.match('^He.*?(\d+).*Demo$',content)
print(res.group(1))     # 123; 因为.*?会尽可能少的匹配,至少有一个任意字符


# 匹配模式:.不能匹配换行符
content="Hello 123456 World_This is a Regex Demo"
res=re.match('He.*?(\d+).*?Demo$',content)
print(res)          # 输出None

res=re.match('He.*?(\d+).*?Demo$',content,re.S)             # re.S让.可以匹配换行符
print(res)
print(res.group(1))     # 123456


#转义:\
content='price is $5.00'
res=re.match('price is $5.00',content)
print(res)      # None

res=re.match('price is \$5\.00',content)
# print(res)
print(res.group())      # price is $5.00


# *********总结:尽量精简,详细的如下*********
            # 尽量使用泛匹配模式.*
            # 尽量使用非贪婪模式:.*?
            # 使用括号得到匹配目标:用group(n)去取得结果
            # 有换行符就用re.S:修改模式


# ***********re.search************
# re.search:会扫描整个字符串,不会从头开始,找到第一个匹配的结果就会返回
content='Extra strings Hello 123 456 World_This is a Regex Demo Extra strings'
res=re.match('Hello.*?(\d+).*?Demo',content)
# print(res)      # 输出结果为None

content='Extra strings Hello 123 456 World_This is a Regex Demo Extra strings'
res=re.search('Hello.*?(\d+).*?Demo',content) #
print(res.group(1))         # 123; 扫描整个字符串进行匹配

# re.search:只要一个结果
content='''<tbody><tr id="4766303201494371851675" class="even "><td><div class="hd">1<div class="rk "><a href="/song?id=476630320"><img class="rpic" src="http://www.baidu.com></a></div></div></td><td class="rank"><div class="f-cb"><div class="tt"><a href="/song?id=476630320"><img class="rpic" src="http://p1.music.126.net/Wl7T1LBRhZFg0O26nnR2iQ==/19217264230385030.jpg?param=50y50&amp;quality=100"></a>',content)
print(res.group())      # <a href="/song?id=476630320"><img class="rpic" src="http://www.baidu.com></a>; 匹配成功就立刻返回,失败则返回None

# re.findall:找到符合条件的所有结果
res=re.findall('<a\shref=.*?\<\/a\>',content)
print(res)      # 返回一个列表
for i in res:
    print(i)
'''
输出结果
['<a href="/song?id=476630320"><img class="rpic" src="http://www.baidu.com></a>', '<a href="/song?id=476630320"><img class="rpic" src="http://p1.music.126.net/Wl7T1LBRhZFg0O26nnR2iQ==/19217264230385030.jpg?param=50y50&amp;quality=100"></a>']
<a href="/song?id=476630320"><img class="rpic" src="http://www.baidu.com></a>
<a href="/song?id=476630320"><img class="rpic" src="http://p1.music.126.net/Wl7T1LBRhZFg0O26nnR2iQ==/19217264230385030.jpg?param=50y50&amp;quality=100"></a>
'''


# *********re.sub:字符串替换********
# re.search函数会在字符串内查找模式匹配,只到找到第一个匹配然后返回,如果字符串没有匹配,则返回None。
content='Extra strings Hello 123 456 World_This is a Regex Demo Extra strings'
content=re.sub('\d+','',content)
print(content)      # Extra strings Hello   World_This is a Regex Demo Extra strings;将数字替换为空

# 用\1取得第一个括号的内容
# 用法:将123与456换位置
content='Extra strings Hello 123 456 World_This is a Regex Demo Extra strings'
content=re.sub('(Extra.*?)(\d+)(\s)(\d+)(.*?strings)',r'\1\4\3\2\5',content)
content=re.sub('(\d+)(\s)(\d+)',r'\3\2\1',content)
print(content)

# 带命名的组:\g
content = "hello shuke, nihao shuke";
res = re.sub(r"hello (\w+), nihao \1", "\g<1>", content);
print("replacedStr=",res)       # replacedStr= shuke 明名组的用法: 反斜杠加g以及中括号内一个名字,即:\g<name>,对应着命了名的组,named group

# 带命名的组:named group
content = "hello shuke, nihao shuke";
res = re.sub(r"hello (?P<name>\w+), nihao (?P=name)", "\g<name>", content);
print("replacedStr=",res)       # replacedStr= shuke

# 匹配一次
content='Extra strings Hello 123 456 World_This is a Regex Demo Extra strings'
res=re.search('Extra.*?(\d+).*strings',content)
if res:
    print('res.group(0): ',res.group(0),'res.group(1): ',res.group(1))       # res.group(0):  Extra strings Hello 123 456 World_This is a Regex Demo Extra strings res.group(1):  123
else:
    print('not search')


# 正则在爬虫的应用
import requests,re

respone=requests.get('https://book.douban.com/').text
# print(respone)
print('======'*100)
res=re.findall('<li.*?cover.*?href="(.*?)".*?title="(.*?)">.*?more-meta.*?author">(.*?)(.*?)(.*?)',respone,re.S)
# res=re.findall('<li.*?cover.*?href="(.*?)".*?more-meta.*?author">(.*?)(.*?)(.*?).*?</li>',respone,re.S)

# 格式化输出
for i in res:
    print('%s    %s    %s   %s' %(i[0].strip(),i[1].strip(),i[2].strip(),i[3].strip()))

示例

示例

4858.com 834858.com 84

IP:
^(25[0-5]|2[0-4]\d|[0-1]?\d?\d)(\.(25[0-5]|2[0-4]\d|[0-1]?\d?\d)){3}$
手机号:
^1[3|4|5|8][0-9]\d{8}$
邮箱:
[a-zA-Z0-9_-]+@[a-zA-Z0-9_-]+(\.[a-zA-Z0-9_-]+)+

IP|手机号|邮箱

常用匹配语法:

re.match     从头开始匹配
re.search    匹配包含
re.findall    把所有匹配到的字符放到以列表中的元素返回
re.splitall   以匹配到的字符当做列表分隔符
re.sub         匹配字符并替换

 

三. 软件开发目录结构正式

为什么要规划好目录结构?

“设计项目目录结构”,就和”代码编码风格”1样,属于个人风格难点。对于这种风格上的专业,一向都存在二种态度:

  1. 1类同学认为,那种个人风格难题”非亲非故主要”。理由是能让程序work就好,风格难点根本小难题。
  2. 另1类同学认为,规范化能更好的支配程序结构,让程序有所更高的可读性。

自家是相比较偏向于后世的,因为笔者是前一类同学思想行为下的直白受害者。小编早已维护过1个百般倒霉读的项目,其完毕的逻辑并不复杂,不过却消耗了自家非常短的时刻去驾驭它想表明的趣味。从此我个人对于拉长项目可读性、可维护性的需要就很高了。”项目目录结构”其实也是属于”可读性和可维护性”的范畴,大家统筹二个层次明显的目录结构,正是为了达成以下两点:

  1. 可读性高:
    素不相识这一个项指标代码的人,一眼就能看懂目录结构,知道程序运营脚本是哪位,测试目录在何处,配置文件在哪里之类。从而丰裕便捷的垂询这一个系列。
  2. 可维护性高:
    定义好组织规则后,维护者就能很醒目地了然,新增的哪些文件和代码应该放在什么目录之下。那个利益是,随着时光的延迟,代码/配置的规模扩大,项目布局不会混杂,照旧能够协会杰出。

据此,小编以为,保持3个层次明显的目录结构是有至关重要的。更何况协会二个优质的工程目录,其实是壹件很简短的事务。

目录组织章程

至于如何组织二个较好的Python工程目录结构,已经有局地到手了共同的认识的目录结构。在Stackoverflow的其一标题上,能看出我们对Python目录结构的座谈。

这边面说的已经很好了,笔者也不打算重新造轮子列举各个分歧的不贰秘籍,那之中小编说一下小编的通晓和体会。

设若你的门类名叫foo, 笔者比较提出的最方便快速目录结构那样就丰盛了:

Foo/
|-- bin/
|   |-- foo
|
|-- foo/
|   |-- tests/
|   |   |-- __init__.py
|   |   |-- test_main.py
|   |
|   |-- __init__.py
|   |-- main.py
|
|-- docs/
|   |-- conf.py
|   |-- abc.rst
|
|-- setup.py
|-- requirements.txt
|-- README

简单的讲解释一下:

  1. bin/:
    存放项目的1对可执行文件,当然你能够起名script/等等的也行。
  2. foo/: 存放项目标享有源代码。(1)
    源代码中的全部模块、包都应该置身此目录。不要置于顶层目录。(二)
    其子目录tests/存放单元测试代码; (三)
    程序的进口最佳命名称为main.py
  3. docs/: 存放一些文书档案。
  4. setup.py: 安装、布置、打包的剧本。
  5. requirements.txt: 存放软件依赖的表面Python包列表。
  6. README: 项目表达文件。

除去,有部分方案提交了更为多的始末。比如LICENSE.txt,ChangeLog.txt文本等,笔者从未列在此处,因为这几个事物主借使种类开源的时候必要用到。若是您想写一个开源软件,目录该怎么协会,能够参见那篇文章。

上面,再简单讲一下本人对这个目录的精通和民用要求呢。

关于README的内容

本条本身觉着是种种品种都应当某个三个文书,目标是能大概描述该项指标消息,让读者不慢掌握这些项目。

它必要验证以下多少个事项:

  1. 软件定位,软件的基本作用。
  2. 运维代码的不二等秘书诀: 安装环境、运营命令等。
  3. 简简单单的行使表明。
  4. 代码目录结构表达,更详细点能够作证软件的基本原理。
  5. 大面积难点求证。

本身以为有以上几点是相比较好的二个README。在软件开发初期,由于开发进度中上述内容也许不醒目恐怕产生变化,并不是必然要在一起来就将具备音信都补全。然则在品种收尾的时候,是急需写作那样的1个文档的。

能够参见Redis源码中Readme的写法,那之中简洁可是清晰的讲述了Redis作用和源码结构。

关于requirements.txt和setup.py

setup.py

相似的话,用setup.py来治本代码的卷入、安装、铺排难点。产业界规范的写法是用Python流行的包装工具setuptools来管理这几个业务。那种方法广泛选用于开源项目中。可是那里的宗旨境想不是用标准化的工具来化解这个标题,而是说,贰个品种必然要有三个装置配置工具,能飞速方便的在1台新机器中校环境装好、代码铺排好和将程序运转起来。

以此自身是踩过坑的。

本身刚初始接触Python写项目标时候,安装环境、陈设代码、运营程序这些历程全是手动完结,碰着过以下难题:

  1. 安装环境时平日忘了近年又添加了多个新的Python包,结果1到线上运维,程序就出错了。
  2. Python包的本子依赖难点,有时候大家先后中利用的是几个版本的Python包,可是官方的早已是新型的包了,通过手动安装就恐怕装错了。
  3. 借使依靠的包很多来说,叁个三个设置这几个依赖是很伤脑筋的政工。
  4. 新校友发轫写项指标时候,将先后跑起来十分麻烦,因为大概时时忘了要怎么设置各样依赖。

setup.py能够将这几个业务自动化起来,升高功用、减少失误的票房价值。”复杂的东西自动化,能自动化的事物必定要自动化。”是两个老大好的习惯。

setuptools的文档正如庞大,刚接触的话,或者不太好找到切入点。学习技能的诀窍就是看别人是怎么用的,能够参照一下Python的一个Web框架,flask是何等写的: setup.py

理所当然,不难点自身写个安装脚本(deploy.sh)替代setup.py也未尝不可。

requirements.txt

本条文件存在的目标是:

  1. 造福开发者维护软件的包依赖。将付出进度中新增的包添加进那些列表中,防止在setup.py设置正视时漏掉软件包。
  2. 惠及读者明显项目选取了什么样Python包。

以此文件的格式是每一行李包裹罗二个包重视的认证,常常是flask>=0.10那种格式,供给是以此格式能被pip辨认,这样就能够大约的通过 pip install -r requirements.txt来把富有Python包注重都装好了。具体格式表明: 点这里。

关于配置文件的利用办法

留神,在下边包车型大巴目录结构中,未有将conf.py放在源码目录下,而是放在docs/目录下。

多多类别对配置文件的应用做法是:

  1. 布局文件写在二个或四个python文件中,比如那里的conf.py。
  2. 花色中哪些模块用到那一个布局文件就间接通过import conf这种样式来在代码中利用安插。

那种做法我不太援救:

  1. 那让单元测试变得紧Baba(因为模块内部注重了表面配置)
  2. 一面配置文件作为用户控制造进度序的接口,应当能够由用户自由钦点该文件的路线。
  3. 次第组件可复用性太差,因为那种贯穿全数模块的代码硬编码方式,使稳妥先半数模块都凭借conf.py本条文件。

据此,笔者以为配置的运用,更好的艺术是,

  1. 模块的陈设都以可以灵活安插的,不受外部配置文件的熏陶。
  2. 次第的配置也是能够灵活决定的。

可见佐证那么些思量的是,用过nginx和mysql的校友都理解,nginx、mysql那一个程序都能够任意的钦点用户配置。

就此,不应有在代码中央直机关接import conf来行使安插文件。上边目录结构中的conf.py,是交由的2个安插样例,不是在写死在程序中央直机关接引用的布局文件。能够由此给main.py运行参数内定布署路径的格局来让程序读取配置内容。当然,这里的conf.py您可以换个类似的名字,比如settings.py。或然你也得以运用其余格式的始末来编排配置文件,比如settings.yaml之类的。

 

 

连锁链接:

  1.  

  2.  

 

发表评论

电子邮件地址不会被公开。 必填项已用*标注

网站地图xml地图
Copyright @ 2010-2019 美高梅手机版4858 版权所有