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(" backend " + backend + " ")    #如果旧的文件里没有写入输入信息到new.conf
            new.write(" " * 8 + record + " ")            #同时写入记录(可以不用输入)
    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()