pathon第五天

进阶、进程和线程
pathon进阶
一.编码规范
1.代码编排
1）缩进四个空格，空格与Tab不能混用
2）行长80，防止单行逻辑复杂
2.import
1).不能用 from xxx import *
2).顺序：标准库、第三方库、自定义库
3）单行不要immport多个库
4）木哦坏内用不到的不要去import
3.空格
1）表i但符号后面跟一个空格，千米那不要空格（行尾分号后无空格）
2）运算符前后各一个空格
3）当 = 用于指示关键字参数或默认值时，两侧无空格
4、适当添加空行
1）函数间：顶级函数间空两行，类的方法之间空一行
2）同意函数内的逻辑块之间空一行
3）文件结尾：留一个空行（Unix\n是文件结束符）
5、注释
1）忌：逐行添加注释、没有一个注释
2）行内注释：单行逻辑过于复杂时添加
3）引入外来算法或者配置时需在注释中添加原链接，标明出处
4）块注释：一段逻辑开始时添加
5）函数和类尽可能添加docstring
6、命名
1）不要用单字母的变量名
2）包名、模块名、函数名、方法名小写、单词间用下划线链接
3）类名、异常名使用CapWords(首字母大写）的方式，异常名结尾加Error或Warning后缀
4）当全局变量尽量使用大写，一组同类型的全局变量要加统一前缀，单词用下划线连接
7.字符串拼接尽量使用join
速度快，内存消耗小yin
8.语义明确、直白
9.程序的构建
1)一个函数只能做一件事，并把这件事做好
2）大的功能用小的函数之间的灵活组合来完成
3）避免编写庞大的程序
10.函数名必须有动词，最好是do_something形式，或somebody_do_something句式
11.自定义的变量名、函数名不要与标准库中的名字冲突
格式化 Alt+Shift+f
二、函数闭包
引用了自由变量的函数即是一个闭包，这个被引用的自由变量和这个函数一同存在。
def foo():
l = []
def bar(i):
l.append(i)
return l
return bar

if name == “main”:
f1 = foo()
print(f1)

#<function foo..bar at 0x000000C17DF41378>
1
2
3
4
5
6
7
8
9
10
11
12
def foo():
l = []
def bar(i):
l.append(i)
return l
return bar

if name == “main”:
f1 = foo()
f2 = foo()
f3 = foo()
print(f1(1))
print(f2(2))
print(f3(3))
“”"
[1]
[2]
[3]
“”"
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
def foo():
l = []
def bar(i):
l.append(i)
return l
return bar

if name == “main”:
f1 = foo()
f2 = foo()
print(f1(1))
print(f2(2))
print(f2(3))
“”"
[1]
[2]
[2, 3]
“”"
三、装饰器
1.最简装饰器
def deco(func):
def warp():
print(‘hahaha’)
return warp

@deco
def A():
print(‘joker’)
A()

#hahaha
1
2
3
4
5
6
7
8
9
10
11
逻辑：A() -->deco --> func:A --> return warp:warp() --> “hahaha”

def deco(func):
def warp():
print(‘hahaha’)
func()
return warp

@deco
def A(): #不带参
return’joker’
print(A()) #被warp捕获

“”"
hahaha
None
“”"
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
def deco(func):
def warp():
print(‘hahaha’)
return func()
return warp

@deco
def A():
print(‘hahaha’)
return’joker’
print(A())
“”"
hahaha
hahaha
joker
“”"
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
2、函数体加参数

def deco(func):
def warp(n):
print(‘hahaha’)
return func(n)
return warp

@deco
def A(name):
print(name)
A(‘joker’)
“”"
hahaha
joker
“”"
1
2
3
4
5
6
7
8
9
10
11
12
13
14
def deco(func):
def warp(n):
print(‘hahaha’)
n = ‘OK’
return func(n)
return warp

@deco
def A(name): (参数等同于作废)
print(name)
A(‘joker’)

“”"
hahaha
OK
“”"
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
def deco(func):
def warp(n,n1):
print(‘hahaha’)
n = ‘OK’
return func(n,n1)
return warp

@deco
def A(name,name2):
print(name)
print(name2)
A(‘joker’,‘faker’)

“”"
OK
faker
“”"
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
练习
1）输入两个数字，装饰器的作用是求这两个数字的和，本函数的作用是打印这两个数字的和

def deco(func):
def warp(n,n1):
sum_ = n + n1
return func(sum_,n1)
return warp

@deco
def A(name,name2):
print(name)
A(10,20)
#30
1
2
3
4
5
6
7
8
9
10
11
2）无敌验证码：无论输入什么都返回错误

import random
def deco(func):
def warp(n1,n2):
n1 = -1
return func(n1,n2)
return warp

@deco
def A(n1,n2):
if n1 == n2:
print(‘验证码输入正确’)
else:
print(‘验证码输入错误’)

num = random.randrange(1000,9999)
print(‘验证码是%d’%num)
num2 = int(input(’>>’))
A(num,num2)

“”"
验证码是9833

9833
验证码输入错误
“”"
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
3、装饰器传参

import random
def deco2(parms):
def deco(func):
def warp(n1,n2):
if parms:
n1 = -1
return func(n1,n2)
return warp
return deco

@deco2(False) (True则走装饰器)
def A(n1,n2):
if n1 == n2:
print(‘验证码输入正确’)
else:
print(‘验证码输入错误’)

num = random.randrange(1000,9999)
print(‘验证码是%d’%num)
num2 = int(input(’>>’))
A(num,num2)
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
4、不定长参数
1）*args

import random
def deco2(parms):
def deco(func):
def warp(*args,**kwargs):
args = list(args)
if parms:
args[0] = -1
return func(*args,**kwargs)
return warp
return deco

@deco2(True)
def A(n1,n2):
if n1 == n2:
print(‘验证码输入正确’)
else:
print(‘验证码输入错误’)

num = random.randrange(1000,9999)
print(‘验证码是%d’%num)
num2 = int(input(’>>’))
A(num,num2)
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
2）**kwargs

import random
def deco2(parms):
def deco(func):
def warp(*args,**kwargs):
if parms:
kwargs[‘n1’] = -1
return func(*args,**kwargs)
return warp
return deco

@deco2(True)
def A(n1,n2):
if n1 == n2:
print(‘验证码输入正确’)
else:
print(‘验证码输入错误’)

num = random.randrange(1000,9999)
print(‘验证码是%d’%num)
num2 = int(input(’>>’))
A(n1 = num,n2 = num2)
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
练习：
检测某个时间段内（5秒）ip访问次数，超过十次则返回404

import time

TIME1 = 0
TIME2 = 0

def check_ip(func):
def warp(*args,**kwargs):
if round(abs(TIME2 - TIME1),3) < 0.5:
print(‘404’)
else:
return func(*args,**kwargs)
return warp

@check_ip
def A(ip):
print(‘进入网页成功’)

#模拟请求
for _ in range(50):
ip = ‘127.0.0.1’
TIME1 = time.time()
A(ip)
TIME2 = time.time
time.sleep(1)
————————————————
进程和线程
一.概念
1.进程：
操作系统中执行一个程序，操作系统以进程为单位分配储存空间，每个进程都有自己的地址空间、数据栈以及其他用于跟踪进程执行的辅助数据，操作系统管理所有进程的执行，为他们合理的分配资源。
2.进程
一个进程可以拥有多个并发的执行线索，简单的说就是拥有多个可以获得CPU调度的执行单元，这就是线程。
二 多进程
1.最简单的进程
import multiprocessing

def A():
print(‘Hello’)

if name == “main”:
#创建进程
p = multiprocessing.Process(target = A, args = ())
p.start() #启动进程
p.join()
print(‘Over’)

#Hello
#Over
二.多进程
import multiprocessing
import os

def A(name):
print(os.getpid())
print(name)

if name == “main”:
#创建进程
p1 = multiprocessing.Process(target = A, args = (‘sdf1’,))
p2 = multiprocessing.Process(target = A, args = (‘sdf2’,))
p1.start()
p2.start() #启动进程
p2.join()
p2.join()
print(‘OK’)

“”"
sdf1
13068
sdf2
OK
“”"
如果程序中的代码只能按顺序一点点的往下执行，那么即使执行两个毫不相干的下载任务，也许先等待一个文件下载完成后才能开始下一个下载任务，在这并不合理，也没有效率。进下来我们使用多进程的方式将两个下载任务放到不同的任务中