python 第四天
内置函数
装饰器
函数没有返回值，默认返回NONE
参数传递时是引用
li = [11,22,33,44]
def f1(arg):
li.append(55) #没有返回值，所以返回NONE
li = f1(li) #这只是引用
print(li)
#返回结果
None
li = [11,22,33,44]
def f1(arg):
li.append(55) #没有返回值，所以返回NONE
#li = f1(li)
f1(li) #执行函数
print(li)
#返回结果
[11, 22, 33, 44, 55]
f2="fdsfsa"
callable 判断是否被调用
#chr() #把数字转成字母,必须ascii表里有
#ord() #把字母转成数字,必须ascii表里有
r = chr(65) #数字转字母，ascii表里有
print(r)
n=ord("a") #字母输数字，ascii表里有
print(n)
#生成随机数
import random #随机产生数字，randrange给范围
i = random.randrange(1,5) #在1和5的范围内随机生成，但不包括5
print(i)
#数字转字母，随机生成
i = random.randrange(65,91)
c = chr(i)
print(c)
#生成六位字母随机码
import random
li = []
for i in range(6): #循环六次，生成六位
temp = random.randrange(65,91)
c = chr(temp)
li.append(c)
print(li) #
result = "".join(li) #join拼接，合并成字符串输出
print(result)
['E', 'X', 'Q', 'U', 'H', 'K']
EXQUHK
#固定位置生成数字
#只在第2和第4元素位生成随机数字(其实是字符串)
import random
li = []
for i in range(6): #循环六次，生成六位
if i == 2 or i == 4: #固定位置生成数字
num = random.randrange(0,10) #在1到10的范围内随机生成数字
li.append(str(num)) #为什么要转成字符串，因为join合并要求必须是字符串
else:
temp = random.randrange(65,91)
c=chr(temp)
li.append(c)
result = "".join(li) #join拼接，合并成字符串输出(元素必须是字符串)
print(result)
#随机数字和字母验证码
import random
li = []
for i in range(6): #循环六次，生成六位
r = random.randrange(0, 5)
if r ==2 or r == 4:
num = random.randrange(0, 10)
li.append(str(num))
else:
temp = random.randrange(65, 91)
c = chr(temp)
li.append(c)
result = "".join(li) #join拼接，合并成字符串输出(元素必须是字符串),
print(result)
#compile() #把字符串编译成python代码,exec eval 执行
#eval() #只能执行表达式，有返回值，并获取结果
#exec() #接收代码或字符串，没有返回值，拿不到结果。
#exec 用法1
s = 'print(123)'
#编译，single,eval,exec
#把字符串编译成python代码
r = compile(s,'<string>','exec') #编译字符串
#执行python代码
exec(r) #执行
返回结果
123
#exec 用法2
s = 'print(123)' #这里加了print，exec会把123返回，因为exec把s看为整体，执行了print
r = compile(s,'<string>','exec')
k = exec(r)
print(k) #这个操作会返回None，证明exec只接收不返回值
返回结果
123
None
#eval 计算乘法
s = "8*8"
print(s)
ret = eval(s) #字符串转为python代码计算，并返回值，但只接收表达式
print(ret)
#print(eval(s)) #同上
返回结果
64
#exec 和eval 不同之处
print(exec("7+9+8")) #exec 没有返回值，所以返回NONE
ret = eval("7+9+8") #eval 有返回值，并获取结果，但只接收表达式
print(ret)
返回结果
None
24
#dir() #快速查看对像提供那些功能
print(dir(list))
#查帮助
help(list)
#共：97页，每页显示10条，需要多少页
#算商和余数
r = divmod(97,10)
print(r)
(9, 7) #结果是商9，余7
r = divmod(100,10) #整除，商10，余0
print(r)
(10, 0) #整除，商10，余0
#isinstance
#用于判断对象是否是某个类的实例,返回True和False,什么都可以判断
s = [11,11,11]
r = isinstance(s,list) #判断是否为列表，是则返回True
print(r)
s = [11,11,11]
r = isinstance(s,str) #判断是否为字符串，否则返回False
print(r)
#函数默认没有返回值，想要返回值使用return
#函数中的return语句和print语句的区别
#想要有返回值必须使用return
#return是返回数值的意思，比如定义两个函数，一个是有返回值，另一个用print语句，看看结果有什么不同
def func1(x,y):
print(x+y)
result = func1(1,2)
print(result is None) #会返回None(因为有print，也会返回3)
def func2(x, y):
return (x + y)
result = func2(1, 2) #改为return即直接返回值3，只返回我想要的值
print(result) # 会返回None
#filter,map #均为逗号后和逗号前合用
#filter #函数返回True,将元素加到结果中
#map #将函数返回值添加到结果中
#判断大于22的回显
def f1(args):
result = []
for item in args:
if item > 22:
result.append(item)
#print(result) #如果开启这句即将代表大于22的列表回显，但还是会返回None,使用return即只返回值，不回显None
#return result #返回值
li = [11,22,33,44,55]
ret = f1(li) #参数传递时是引用
print(ret) #不会返回值，只返回None,因为函数默认没有返回值，加return才有返回值
返回结果
None #函数默认没有返回值，想要返回值使用return
#filter(函数,可迭代对像),逐个读，内部循环
#filter 迭代循环功能 ，迭代循环模块
#从li列表中循环读，从11开始一个一个迭代读出来
li = [11,22,33,44,55]
ret = filter(None,li)
print(list(ret))
#找出大于22的数字
#filter 内部循环，参数比较
def f2(a):
if a>22:
return True
li = [11,22,33,44,55]
ret = filter(f2,li) #li的每个元素都执行一次f2函数,为True时则大于22,合法添加到结果ret
print(list(ret))
lambda 表达式 #一种特殊函数，真则回True,假则返回False
#自动return
f1 = lambda a:a > 30
ret = f1(90)
print(ret)
返回结果
True
#判断大于33的数返回
#lambda 函数简化函数代码，和filter合用简化for 和代码
li = [11,22,33,44,55]
result = filter(lambda a:a > 33,li) #li内部循环和逗号前面的a函数逐个比较，大于33回显
print(list(result))
返回结果
[44, 55]
#map(函数，可迭代的对像(可以for循环的东西))
#每个元素加100
li = [11,22,33,44,55]
def f1(args):
result = []
for i in args:
result.append(100+i) #每循环一次加100
return result
r = f1(li)
print(r)
#每个元素加100，以列表回显，map + 函数方法
#简化for
li = [11,22,33,44,55]
def f2(a):
return a + 100
result = map(f2,li) #后者li和逗号前者合用逐个计算
print(list(result))
#每个元素加200,map + lambda特殊 方法
#lambda 和 map合用简化函数和for
li = [11,22,33,44,55]
result = map(lambda a:a +200,li) #逗号后和逗号前合用，循环li逐个和逗号前方法计算，每个元素加200
print(list(result))
#locals 函数为本地变量
#globals 函数为全屏变量
NAME = "ALEX"
def show():
a = 123
print(locals())
print(globals())
show()
#转成加密码的hash
s = "hhh"
print(hash(s))
s = "hjfkdsjflksajflkjsadflsfjsajflsa"
print(hash(s))
#len计算长度
#python3以字符个数计算,所以回长度为2
s = "李杰"
print(len(s))
#python2以字节个数计算，所以返回长度为6
s= "李杰"
b = bytes(s,encoding='utf-8')
print(len(b))
--------------------------------------------------------------------------------------------
#判断输入
1.一行一行的读，不要加入内存(不要readlines),要用for line in f #此方法不用全加内存在读，快
f = open(xxx)
for line in f:
print line
#查询
def fetch(backend):
result = []
with open('ha.conf','r',encoding='utf-8') as f:
flag = False
for line in f:
if line.strip().startswith("backend") and line.strip() == "backend " + backend: #判断以backend开头及 backend 和输入
flag = True
continue
if flag and line.strip().startswith("backend"):
flag = False
break
if flag and line.strip(): #拿到对应的信息，去空行
result.append(line.strip())
return result
ret = fetch("www.oldboy.org")
print(ret)
-----json方法
#将一个字符串，转换成python的基本数据类型,打回原形
#将一个字符串或其他转换成我想要的格式
#一个特殊字符的列表
s = "[11,22,33,44,5]"
print(type(s),s)
import json
n = json.loads(s) #将一个字符串，转换成python的基本数据类型
print(type(n),n)
s = '{"k1":"v1"}' #json 能读的格式外面有'单引号'，里面的值必须是"双引号"
import json
n = json.loads(s) #将一个字符串，转换成python的基本数据类型
print(type(n),n)
#!/usr/bin/env python
#-*- coding:utf-8 -*-
# Author:Minghu Wang
def fetch(backend):
result = []
with open('ha.conf','r',encoding='utf-8') as f:
flag = False
for line in f:
if line.strip().startswith("backend") and line.strip() == "backend " + backend: #判断以backend开头及 backend 和输入
flag = True
continue
if flag and line.strip().startswith("backend"): #如果输入信息和文件匹配，到第二个以backend开头的即False结跳出循环
flag = False
break
if flag and line.strip(): #拿到对应的信息，去空行追加到列表
result.append(line.strip())
return result
ret = fetch("www.oldboy.org")
print(ret)
def add(backend,record):
#思路一：
#思路二
#先检查记录存不存在
record_list = fetch(backend) #这句是调用fetch查询函数,什么也没传即为空
#print(record_list)
if not record_list: #fetch为则执行以下
#backend 不存在
with open('ha.conf','r') as old, open("new.conf",'w') as new: #读一个文件写新文件
for line in old: #循环每行
new.write(line) #全写到新
new.write("\nbackend " + backend + "\n") #如果旧的文件里没有写入输入信息到new.conf
new.write(" " * 8 + record + "\n") #同时写入记录(可以不用输入)
else:
#backend 存在
pass
bk = "test.oldboy.org"
rd = "server 100.1.7.90 100.1.7.90 weight 20 maxconn 30"
add(bk,rd) #为add函数传参 bk,rd
-----------------------------------------------------------------------------------------------------
#找最大
r = max([11,22,33,1])
print(r)
#找最小
r = min([11,22,33,1])
print(r)
#求和
r = sum([11,22,33,1])
print(r)
2的10次方
2**10
pow(2,10)
r = pow(2,10)
print(r)
#四舍五入
r = round(1.4)
print(r)
#排序
li = [11,22,11,1]
li.sort()
sorted(li)
#字典排序
li = {"2":22,"1":1,"4":21,"3":234}
print(sorted(li))
返回结果
['1', '2', '3', '4']
#zip 取列值,把元素为同一级的放到一起，横向输出，相当于awk抽列
l1 = ["alex",11,22,33]
l2 = ["is",11,22,33]
l3 = ["sb",11,22,33]
r = zip(l1,l2,l3)
print(list(r))
输出结果
[('alex', 'is', 'sb'), (11, 11, 11), (22, 22, 22), (33, 33, 33)]
#zip 取列值,把元素为同一级的放到一起，横向输出
l1 = ["alex",11,22,33]
l2 = ["is",11,22,33]
l3 = ["sb",11,22,33]
r = zip(l1,l2,l3) #取列值
temp = list(r)[0]
ret = ' '.join(temp) #join拼接，合并，以空格分隔合并
print(ret)
返回结果
alex is sb
#装饰器
#在执行函数前或后执行相关功能
#装饰器老函数前面回显
实例主程序s2
#!/usr/bin/env python
#-*- coding:utf-8 -*-
# Author:Minghu Wang
# 加@outer 自动作了两个操作
#1. 将它下面的函数传参给outer,即f1函数是outer的形参，可以用func()执行，返回f1的结果（旧f1）
#2. 将outer函数的返回值重新赋值给f1，即inner函数体(outer的方法)是新的f1,当f1()执行函数时即返回inner的结果（新f1）
def outer(func):
def inner():
print('log')
return func() #老f1函数,即执行f1,则返回F1,有多个传参依次类推 (老f1)
return inner #返回函数体，即不执行，即只返回内存地址，新的f1,当f1()执行时即返回log, (新f1)
@outer
def f1():
print("F1")
@outer
def f2():
print("F2")
@outer
def f100():
print("F100")
调用程序b1
#!/usr/bin/env python
#-*- coding:utf-8 -*-
# Author:Minghu Wang
import s2
s2.f1()
s2.f2()
s2.f100()
返回结果
log
F1
log
F2
log
F100
def f1():
print(123)
def f1():
print(456)
f1()
def f1():
print('123')
def f2(xxx):
xxx()
f2(f1) #f2(f1)等同于f2(xxx)，xxx()等同于执行f1
结果
123
#装饰器老函数前后回显
主程序s2
#!/usr/bin/env python
#-*- coding:utf-8 -*-
# Author:Minghu Wang
def outer(func):
def inner():
print('before') #f1函数前操作
func() #老f1函数F1
print('after') #f1函数后操作
return inner
#@ + 函数名
#功能：
# 1.自动执行outer函数并且将其下面的函数f1当作参数传递给outer函数
# 2.将outer函数的返回值，重新赋值给f1(修改了f1的值)
@outer
def f1():
print("F1")
调用程序
#!/usr/bin/env python
#-*- coding:utf-8 -*-
# Author:Minghu Wang
import s2
s2.f1()
返回结果
before
F1
after
#装饰器老函数前后回显，并用return单独调
主程序s2
#!/usr/bin/env python
#-*- coding:utf-8 -*-
# Author:Minghu Wang
def outer(func):
def inner():
print('before') #f1函数前操作
r = func()
print('after') #f1函数后操作
return r #新f1()执行时，返回结果是“砍你”，return方法只能return方法调用，所以此处调的是f1里的return “砍你”
return inner #inter 是个函数体，不是执行函数
#@ + 函数名
#功能：
# 1.自动执行outer函数并且将其下面的函数f1当作参数传递给outer函数(老f1，存入内存)
# 2.将outer函数的返回值，重新赋值给f1(修改了f1的值)(把outer函数里的返回值给f1,而不是把outer整个赋值)
@outer
def f1():
print("F1")
return "砍你"
执行程序b1
#!/usr/bin/env python
#-*- coding:utf-8 -*-
# Author:Minghu Wang
import s2
ret = s2.f1()
print("返回值",ret)
#给装饰器传一个参
主程序s2
#!/usr/bin/env python
#-*- coding:utf-8 -*-
# Author:Minghu Wang
def outer(func):
def inner(a): #给函数定义形参
print('before') #f1函数前操作
r = func(a) #给老f1函数定义传参变量
print('after') #f1函数后操作
return r
return inner
#@ + 函数名
#功能：
# 1.自动执行outer函数并且将其下面的函数f1当作参数传递给outer函数(老f1，存入内存)
# 2.将outer函数的返回值，重新赋值给f1(修改了f1的值)(把outer函数里的返回值给f1,而不是把outer整个赋值)
@outer
def f1(arg): #定义传参
print(arg)
return "砍你"
调用程序b1
#!/usr/bin/env python
#-*- coding:utf-8 -*-
# Author:Minghu Wang
import s2
ret = s2.f1('fafafa') #给老f1函数参实参
print("返回值",ret)
返回结果
before
fdskjfsafsa #老f1函数的返回值
after
返回值 砍你
#给装饰器传多参数
主程序s2
#!/usr/bin/env python
#-*- coding:utf-8 -*-
# Author:Minghu Wang
def outer(func):
def inner(*args,**kwargs): #定义万能参数
print('before') #f1函数前操作
r = func(*args,**kwargs) #给老函数定义万能参数
print('after') #f1函数后操作
return r
return inner
#@ + 函数名
#功能：
# 1.自动执行outer函数并且将其下面的函数f1当作参数传递给outer函数(老f1，存入内存)
# 2.将outer函数的返回值，重新赋值给f1(修改了f1的值)(把outer函数里的返回值给f1,而不是把outer整个赋值)
@outer
def f1(arg):
print(arg)
return "砍你"
@outer
def f2(a1,a2): #给装饰器传多个参数
print("F2")
执行程序b1
#!/usr/bin/env python
#-*- coding:utf-8 -*-
# Author:Minghu Wang
import s2
ret = s2.f1('fafafa')
print("返回值",ret)
s2.f2(11,22) #给装饰器传多实参
返回结果
before
fdskjfsafsa
after
返回值 砍你
before
F2 #返回F2的结果
after
#完整的装饰器，在两个函数前后操作功能，在第三个函数不做操作
#!/usr/bin/env python
#-*- coding:utf-8 -*-
# Author:Minghu Wang
def outer(func):
def inner(*args,**kwargs):
print('before') #f1函数前操作
r = func(*args,**kwargs)
print('after') #f1函数后操作
return r
return inner
#@ + 函数名
#功能：
# 1.自动执行outer函数并且将其下面的函数f1当作参数传递给outer函数(老f1，存入内存)
# 2.将outer函数的返回值，重新赋值给f1(修改了f1的值)(把outer函数里的返回值给f1,而不是把outer整个赋值)
@outer
def f1(arg):
print(arg)
return "砍你"
@outer
def f2(a1,a2):
print("F2")
def f3():
print("F3")
#!/usr/bin/env python
#-*- coding:utf-8 -*-
# Author:Minghu Wang
import s2
ret = s2.f1('fafafa')
print("返回值",ret)
s2.f2(11,22)
s2.f3()
返回结果
before
fafafa
after
返回值 砍你
before
F2
after
F3
无装饰器登录程序，代码繁琐，重复性高
#!/usr/bin/env python
#-*- coding:utf-8 -*-
# Author:Minghu Wang
LOGIN_USER = {"is_login":False}
def changepwd():
if LOGIN_USER['is_login']:
print("欢迎%登录" % LOGIN_USER['current_user'])
else:
print("请登录")
def manager():
if LOGIN_USER['is_login']:
print("欢迎%登录" % LOGIN_USER['current_user'])
else:
print("请登录")
def login(user,pwd):
if user == "alex" and pwd == "123":
LOGIN_USER['is_login'] = True
LOGIN_USER['current_user'] = user
manager()
def main():
while True:
inp = input("1,后台管理;2，登录")
if inp == '1':
manager()
elif inp == '2':
username = input("请输入用户名")
pwd = input('请输入密码')
login()
main()
装饰器登录程序 #简化代码，减少反复性
#!/usr/bin/env python
#-*- coding:utf-8 -*-
# Author:Minghu Wang
LOGIN_USER = {"is_login": False }
def outer(func):
def inner(*args, **kwargs):
if LOGIN_USER['is_login']:
r = func()
return r
else:
print("请登录")
return inner
def outer1(func):
def inner(*args, **kwargs):
if LOGIN_USER['is_login'] and LOGIN_USER['user_type'] == 2:
r = func()
return r
else:
print("请登录,或者权限不够")
return inner
@outer1
def order():
print("欢迎%s登录" % LOGIN_USER['current_user'])
@outer
def changepwd():
print("欢迎%s登录" % LOGIN_USER['current_user'])
@outer
def manager():
print("欢迎%s登录" % LOGIN_USER['current_user'])
def login(user, pwd):
if user == "alex" and pwd == "123":
LOGIN_USER['is_login'] = True
LOGIN_USER['current_user'] = user
manager()
def main():
while True:
inp = input("1,后台管理；2,登录")
if inp == '1':
manager()
elif inp == '2':
username = input("请输入用户名")
pwd = input("请输入密码")
login(username, pwd)
main()
#!/usr/bin/env python
#-*- coding:utf-8 -*-
# Author:Minghu Wang
LONGIN_USER = {'is_login':False}
def outer(func):
def inner(*args, **kwargs):
if LONGIN_USER['is_login']: #当登录成功时即为True时执行其老函数
r = func()
return r
else:
print('请登录')
return inner
@outer
def order():
print('欢迎%s登录' % LONGIN_USER['curret_user']) #登录成功时回显其用户
@outer
def chanpepwd():
print('欢迎%s登录' % LONGIN_USER['curret_user']) #执行更改密码时提示用户
@outer
def manager():
print('欢迎%s登录' % LONGIN_USER['curret_user'])
def login(user, pwd):
if user == 'alex' and pwd == '123':
LONGIN_USER['is_login'] = True #登录成功LOGIN_USER的is_login为True
LONGIN_USER['curret_user'] = user #用户列表为alex
manager() #执行管理
else:
print("用户名密码不对，请重新登录 或 注册账号")
def main():
while True:
inp = input('1,后台管理; 2,登录')
if inp == '1':
manager()
elif inp == '2':
username = input('请输入用户名')
pwd = input('请输入密码')
login(username, pwd)
main()
