python的学习之路day4

大纲

1、一些常用的内置函数

callable()

chr() & ord()

随机生成验证码

map()

全局变量，局部变量

hash() & round()

max() min() sum()

zip()

2、装饰器

 

一些常用的内置函数：

内置函数一：

# callable()#检查函数是否能被调用，返回True、False
def f1():
    pass


# f1()#能被调用
f2 = 123
# f2()# 这个不能被调用

print(callable(f1))  # 能被调用
print(callable(f2))  # 不能被调用


True
False

# 查看对应的ascii码
# ord()把ASCII转换成数字
# chr()则相反，把数字转换成ASCII
r = chr(65)
print(r)  # A
n = ord("a")
print(n)  # 97

A
97

#随机验证码
import random  # 加入随机验证码模块

li = []
for i in range(6):  # 循环
    temp = random.randrange(65, 91)  # 方法返回指定递增基数集合中的一个随机数
    c = chr(temp)  # 把数字转换成ASCII,原来为数字，所以转换为了大写字母，因为65-91对应的ASCII为大写字母
    li.append(c)  # 将每次转换的ascii加入到列表中
result = "".join(li)  # 用join方法把列表转换为字符
print(result)  # 每次随机输出
# input_li = input("input li:")
# if input_li == result:
#     print("登录成功")


# 以下是修改版
# v2，这个修改版可以随机出现数字
import random

li = []
for i in range(6):
    r = random.randrange(0, 4)  # 返回一个随机数
    if r == 2 or r == 4:  # 如果返回的随机数等于2或者等于4的时候，让他继续下一步操作
        num = random.randrange(0, 10)
        li.append(str(num))  # 用字符串的方式将随机生成的值添加到li列表中
    else:
        temp = random.randrange(65, 91)
        c = chr(temp)
        li.append(c)
result = "".join(li)
print(result)


DYHVPI
2QMTCM

内置函数二：

# map
li = [11, 22, 33, 44, 55]


# map #将函数返回值添加到结果中
# map(函数，可迭代的对象（可以for循环的东西）)
def f2():
    return a + 100


# result = map(f2, li)
result = map(lambda a: a + 100, li)  # 又用到了lambda表达式
print(list(result))


# 没用map函数
li = [11, 22, 33, 44, 55]


def f1(args):
    result = []
    for i in args:
        result.append(100 + i)
    return result  # 返回result


r = f1(li)
print(r)

[111, 122, 133, 144, 155]
[111, 122, 133, 144, 155]

# 全局变量 globals()、局部变量 locals()
aa = "qwe"

def f1():
    a = 123
    print(globals())
    print(locals())

f1()

{'__name__': '__main__', '__doc__': None, '__package__': None, '__loader__': <_frozen_importlib_external.SourceFileLoader object at 0x02EEA350>, '__spec__': None, '__annotations__': {}, '__builtins__': <module 'builtins' (built-in)>, '__file__': 'D:/资料/常用/python/python/day4/Built-in_function6.py', '__cached__': None, 'aa': 'qwe', 'f1': <function f1 at 0x02EAD660>}
{'a': 123}

# hash()#传入一个对象，他会帮我转换为hash值
s = "qwe"
print(hash(s))

-1262142889


# round() #四舍五入
s = round(5.1125,1)
print(s)

5.1

# max、min、sum
s = sum([11, 22, 33])#求和
print(s)

s = max([11, 22, 33])#最大值
print(s)

s = min([11, 22, 33])#最小值
print(s)

66
33
11

# zip()函数用于将可迭代的对象作为参数，将对象中对应的元素打包成一个个元组，然后返回由这些元组组成的列表。
l1 = ["ha", 11, 22, 33]
l2 = ["ha", 11, 22, 33]
l3 = ["ha", 11, 22, 33]
r = zip(l1, l2, l3) # 将每一列元素打包成为一个元组，然后在由一个大的列表包括起来
temp = list(r)[0]#显示第0个元素
ret = ' '.join(temp)
print(ret)

ha ha ha

装饰器

什么是装饰器：

装饰器本质上是一个Python函数，它可以让其他函数在不需要做任何代码变动的前提下增加额外功能，装饰器的返回值也是一个函数对象。装饰器本质上是一个Python函数，它可以让其他函数在不需要做任何代码变动的前提下增加额外功能，装饰器的返回值也是一个函数对象。

装饰器的写法：

def outer(func):
    def inner():
        print('log')
        return func()

    return inner  # 注意这里返回的inner没有()，因为这只是返回一个函数体


# 可以看到我们并没有在f函数里面加入log，但是当我们调用这个函数时，就出现了log
@outer
def f1():
    print("F1")


@outer
def f2():
    print("F2")


@outer
def f100():
    print("F100")


调用装饰器：
f1()

log
F1

装饰器必备的小知识：

def f1():
    print(123)


def f1():
    print(456)


f1()  # 很明显，这个地方会调用第二个f1,他会输出456


def f1():
    print('123')


def f2(xx):
    xx()


f2(f1)#在这个地方，f1表示f1函数的整体，相当于我在f2里面调用了f1函数，所以xx是f1，所以输出内容就是123

装饰器的流程分析：

# def outer(func):
#     print(123, func)

# def outer(func):
#     return "111"

def outer(func):
    def inner():
        print("before")
        func()#func是传入的f1，所以这里执行f1函数
        print("after")

    return inner  # 返回inner相当于返回了这个函数体（整个函数），然后又开始执行inner函数，如果不调用inner,inner将一直放到内存，不会执行



# @ + 函数名
# 功能
#   1、自动执行outer函数并且将下面的函数名f1当作参数传递
#   2、将outer函数的返回值，重复赋值给f1
@outer
def f1():
    print("F1")


# 新建一个文件用来调用这个业务
import process_analysis1

process_analysis1.f1()

返回结果：
before
F1
after

 装饰器修改后（一些比较常用的功能）：

def outer(func):  # 所以我们可以用到万能参数，无论客户需要传入多少参数，我们就可以响应多少参数
    def inner(*args, **kwargs):  # 如果原函数里面带了参数，我们这里也需要参数
        print("before")
        r = func(*args, **kwargs)  # 这个地方也需要放入万能参数
        print("after")
        return r  # 返回f1函数原有的返回值

    return inner  # 返回inner相当于又开始执行inner函数，


# @ + 函数名
# 功能
#   1、自动执行outer函数并且将下面的函数名f1当作参数传递
#   2、将outer函数的返回值，重复赋值给f1
@outer
def f1(arg):
    print(arg)
    return "哈哈"


@outer
def f2(a1, a2):  # 传入两个参数
    print(a1, a2)
    return "哈哈"


#新建一个文件用于调用此文件
import process_analysis3

ret = process_analysis3.f1("11")
print(ret)  # 将返回值也跟着输出

process_analysis3.f2(111, 22)

before
11
after
哈哈
before
111 22
after

最后更新时间：2017-12-09-31:30:02