zoukankan html css js c++ java

Python入门基础知识点（装饰器，推导式和内置函数）

装饰器

现在让你统计每个函数的执行时间，你怎么做？

import time        #引入时间函数
def func1():
    start = time.time()          #定于开始的时间
    print('in func1')                #执行函数里的内容
    print(time.time() - start)      #让现在的时间减去开始的时间，求出效率

func1()

现在让你写一个函数，来测试另一个函数的执行效率，如果测试500个函数的执行效率呢？

import time

def func1():      #定义一个函数
    print('in func1')

def timer(func):        # 定义一个函数，在嵌套一个函数
    def inner():
        start = time.time()    #定义开始的时间
        func()                 #执行func1函数
        print(time.time() - start)  #定义效率
    return inner          #返回值返回inner给func1,func1=inner

func1 = timer(func1)      #func1实参传递给timer函数
func1()         #此时的func1（）=inner()

但是Python认为你这个还是不简单，所以Python给你提供了一个更见的方式就是语法糖。

import time
def timer(func):
    def inner():
        start = time.time()
        func()
        print(time.time() - start)
    return inner

@timer   #==> func1 = timer(func1)   #语法糖
def func1():
    print('in func1')


func1()

到这里，我们可以简单的总结一下：

　　装饰器的本质：一个闭包函数

　　装饰器的功能：在不修改原函数及其调用方式的情况下对原函数功能进行扩展

还有最后一个问题要解决，刚刚我们讨论的装饰器都是装饰不带参数的函数，现在要装饰一个带参数的函数怎么办呢？

def timer(func):
    def inner(a):
        start = time.time()
        func(a)
        print(time.time() - start)
    return inner

@timer      #func1=timer(func1)
def func1(a):
    print(a)

func1(1)

其实装饰带参的函数并不是什么难事，但假如你有两个函数，需要传递的参数不一样呢？

import time
def timer(func):
    def inner(*args,**kwargs):
        start = time.time()
        re = func(*args,**kwargs)
        print(time.time() - start)
        return re
    return inner

@timer   #==> func1 = timer(func1)
def func1(a,b):
    print('in func1')

@timer   #==> func2 = timer(func2)
def func2(a):
    print('in func2 and get a:%s'%(a))
    return 'fun2 over'

func1('aaaaaa','bbbbbb')
print(func2('aaaaaa'))

现在参数的问题已经完美的解决了，可是如果你的函数是有返回值的呢？

import time
def timer(func):
    def inner(*args,**kwargs):
        start = time.time()
        re = func(*args,**kwargs)
        print(time.time() - start)
        return re
    return inner

@timer   #==> func2 = timer(func2)
def func2(a):
    print('in func2 and get a:%s'%(a))
    return 'fun2 over'

func2('aaaaaa')
print(func2('aaaaaa'))

刚刚那个装饰器已经非常完美了，但是正常我们情况下查看函数的一些信息的方法在此处都会失效

def index():
    '''这是一个主页信息'''
    print('from index')

print(index.__doc__)    #查看函数注释的方法
print(index.__name__)   #查看函数名的方法

为了不让他们失效，我们还要在装饰器上加上一点来完善它：

from functools import wraps

def deco(func):
    @wraps(func) #加在最内层函数正上方
    def wrapper(*args,**kwargs):
        return func(*args,**kwargs)
    return wrapper

@deco
def index():
    '''哈哈哈哈'''
    print('from index')

print(index.__doc__)
print(index.__name__)

开放封闭原则:

　　1.对扩展是开放的

　　　　为什么要对扩展开放呢？

　　　　我们说，任何一个程序，不可能在设计之初就已经想好了所有的功能并且未来不做任何更新和修改。所以我们必须允许代码扩展、添加新功能。

　　2.对修改是封闭的

　　　　为什么要对修改封闭呢？

　　　　就像我们刚刚提到的，因为我们写的一个函数，很有可能已经交付给其他人使用了，如果这个时候我们对其进行了修改，很有可能影响其他已经在使用该函数的用户。

装饰器完美的遵循了这个开放封闭原则。

装饰器的主要功能：

在不改变函数调用方式的基础上在函数的前、后添加功能。

装饰器的固定格式：

def timer(func):
    def inner(*args,**kwargs):
        '''执行函数之前要做的'''
        re = func(*args,**kwargs)
        '''执行函数之后要做的'''
        return re
    return inner


*************************************



from functools import wraps

def deco(func):
    @wraps(func) #加在最内层函数正上方
    def wrapper(*args,**kwargs):
        return func(*args,**kwargs)
    return wrapper

假如你有成千上万个函数使用了一个装饰器，现在你想把这些装饰器都取消掉，你要怎么做？

def outer(flag):
    def timer(func):
        def inner(*args,**kwargs):
            if flag:
                print('''执行函数之前要做的''')
            re = func(*args,**kwargs)
            if flag:
                print('''执行函数之后要做的''')
            return re
        return inner
    return timer

@outer(False)
def func():
    print(111)

func()

多个装饰器装饰同一个函数

def wrapper1(func):
    def inner():
        print('wrapper1 ,before func')
        func()
        print('wrapper1 ,after func')
    return inner

def wrapper2(func):
    def inner():
        print('wrapper2 ,before func')
        func()
        print('wrapper2 ,after func')
    return inner

@wrapper2
@wrapper1
def f():
    print('in f')

f()

内置函数

匿名函数:这个函数真的没有名字
# lambda 关键字  x参数:x是返回值
# 一行函数 用于简单需求
# print((lambda x:x)(5))
# lambda 的返回值只能是一个
sorted() 可迭代对象 key=指定排序方式 可以调整排序方式
filter() 函数,可迭代对象 过滤的规则在函数中写
map() 函数,可迭代对象,将每个元素进行同样的操作
from functools import reduce
# reduce() 函数,可迭代对象  累计算

# 以上4个内置函数,都帮咱们提前实现了for循环

今天我们就认识一下python的内置函数.

# 1.记住怎么用

# print(abs(-98))          # 求绝对值  正的负的 出来后全都是正的  **

# print(all([1,0,3,4]))    # all 判断元素中都为真的才是真  *

# print(any([1,False,0]))  # any 判断元素中只要有一个为真就是真 *

# print(ascii('你'))       #  查看元素对应的内容

# print(bin(10))           # 将10进制转行2进制       **

# print(bool([1]))         # 将内容转换成布尔值

# b = bytearray('meet'.encode('utf-8'))
# # 返回一个新的元组,元组可以切片,切片的内容对应的ascii表
# print(b[3])

# print(bytes('你',encoding='utf-8'))                *
# print('你'.encode('utf-8'))

# def func():
#     pass
#
# print(callable(func))   # 检查这个对象是否可以调用          **

# print(chr(65))  # 输入数字,返回对应的ascii表位上对应的内容   **

# a = compile('input(">>>")','','exec')
# exec(a)

# print(complex(8))  # 复数             *

# print(dict(key=1,name=2))

# print(dir([1,2]))  # 查看对象的所有方法     ***

# print(divmod(5,2))   # 返回一个元组,元组的第一个元素是商,第二个元素是余数  **

# print(enumerate)   # 枚举

# li = [1,2,3,4,5,6,7]
#
# for i,em in enumerate(li,1):  # enumerate不写值默认是0         ****
#     # enumerate  第一个参数是可迭代对象,第二参数是计数
#     print(i,em)


# s = """9+4+3"""    # 将字符串中内容执行
# print(eval(s))     # 上班以后禁止使用

# li = [1,23,4,]
# s = """
# def func():
#     print(1)
# func()
# """
# g = exec(s)
# print(g)
# print(li)         # 公司非常禁止

# print(float(20))

# i = 3.56
# print(int(i))

# python3  6 / 3  2.0
# python2  6 / 3  2

# 's'.format()  # 字符串的方法
# print(format('a','>10'))      # 公用函数  右对齐
# print(format('a','<10'))      # 公用函数  左对齐
# print(format('a','^10'))      # 公用函数  居中

# print(format(3,'b'))

# print(format(3,'08b'))  # 00000011   二进制
# print(format(3,'o'))    # 八进制
# print(format(3,'x'))    # 八进制

# a = 1
# def func():
#     pass

# print(globals())  # 查看全局都哪些内容            **
# print(b)
# print(globals().get('b'))

# dic = {[1,2,3]:1}
# print(hash([1,2,3]))  #求对象的哈希值             *

# print(help(input))      # 不知道怎么用的时候可以使用help查看一下

# print(hex(33))           #  将10进制转换成16进制  *

# print(id('s'))             # 查看数据的内存地址   ***

# print(input(">>>"))         # 获取用户输入的内容  *****

# print(int())                  # 将数据转换成整型    *****

# print(isinstance([1,2,3],str))   #判断这个数据时什么类型  ***

# iter                             # 判断是不是可迭代对象   ***

# len()                              # 获取数据的长度     *****

# list()                              # 转换成一个列表  ***

# def func():
#     a = 1
#     print(locals())  # 查看局部空间的内容       ***
#
# func()

# print(max(1,2,3,4,5))   # 求最大值              ***

# print(min(1,2,3,4))       # 求最小值            ***

# print(memoryview(b'a'))        # 查看字节的内存地址

# print(next())               # 迭代器中的取下一个值  ***

# print(oct(9))                 # 将10进制转换成8进制  **

# open(文件名,对这个文件要操作的模式,编码)

# '你好'.encode('utf-8')
# coding:utf-8

# print(ord('中'))     # 输入的是unicode编码的内容    **
# print(chr(20013))    # 输入的是unicode的内容        **

# print(pow(2,3))  #两个参数的时候求幂运算
# print(pow(2,3))    #三个参数的时候先求幂运算在取余

# print('你好','我好',sep=' ',end='')
# print('大家好')

# print('你好',file=open('a','w',encoding='utf-8'))

# print('123')         # 是处理后给你显示的    *****
# print(repr('123'))   # 显示的是原数据        ***

# print(list(reversed()))  # 反转 元组,列表,字符串    ****

# print(round(5.472343212,3))   #四舍五入      ***

# li = [1,2,3,4]
# # s = slice(2)   #切片
# print(li[3])


# print(sum({1:4,2:5}))   #求和     ***

# print(type('aasas'))    # 获取数据类型

# print(vars(str))
# print(locals())

# li = [1,2,3,4]
# ls = [5,6,7,4,5,6]
# lst = ['a','b','c','d','e']
# print(list(zip(li,ls,lst)))  #拉链                  ****

# __import__('time')   # 导入的方式 ---- > 反射

Python入门基础知识点（装饰器，推导式和内置函数）

装饰器

内置函数

2.整体函数使用：

2.1 作用域相关

2.1.1 locals() 返回当前作⽤用域中的名字

2.1.2 globals() 返回全局作⽤用域中的名字

2.2 迭代器相关

2.2.1 range() 生成数据

2.2.2.next() 迭代器向下执⾏一次, 内部实际使用了__next__()方法返回迭代器的下一个项目

2.2.3 iter() 获取迭代器, 内部实际使用的是__iter__()方法来获取迭代器

2.3 字符串类型代码的执行

2.3.1 eval() 执行部分字符串类型的代码,并返回最终结果

2.3.2 exec() 执行字符串类型的代码

2.4 输入和输出相关

2.4.1 input() 获取用户输入的内容

2.4.2 print() 打印输出

2.5 内存相关

2.5.1 hash() 获取到对象的哈希值(int, str, bool, tuple)

2.5.2 id() 获取到对象的内存地址

2.6 文件操作相关

2.6.1 open() 用于打开一个文件, 创建一个文件句柄

2.7 帮助

2.7.1 help() 函数用于查看函数或模块用途的详细说明

2.8 调用相关

8.1 callable() 用于检查一个对象是否是可调用的. 如果返回True, object有可能调用失败, 但如果返回False. 那调用绝对不会成功

2.9 查看内置属性

2.9.1 dir()查看对象的内置属性

2.10 基础数据类型相关

2.10.1 数字相关

2.10.2 数学运算

2.10 .3数据结构相关

2.11 数据集合

2.12 其他相关

2.13 lambda

2.14 sorted

2.15 filter

2.16 map

2.17 reduce

2.2.2.next() 迭代器向下执⾏一次, 内部实际使用了next()方法返回迭代器的下一个项目

2.2.3 iter() 获取迭代器, 内部实际使用的是iter()方法来获取迭代器