本篇涉及内容

内置函数

装饰器

内置函数

  • callable()   判断对象是否可以被调用,返回一个布尔值

    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
    num = 10
    print(callable(num))   # num不能够被调用，返回False
                 
    def f1():
        print("name")
                 
    print(callable(f1))     # f1可以被调用,返回True
                 
    # 输出
    False
    True

  • chr()   将十进制整数转换为ascii编码中对应的字符

    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
    12
    13
    14
    15
    16
    17
    18
    19
    20
    21
    22
    23
    24
    25
    26
    27
    28
    29
    30
    31
    num = chr(69)  # 整数69在ascii编码表中对应的是字母E
    print(num)
                  
    # 输出
    E
                 
                 
    # 练习
    # 利用ascii编码随机生成6位验证码
    import random
    li = []
    for i in range(6):
        r = random.randrange(0, 3)   # 生成随机数用来选择数字，小写字母或大写字母
                 
        if r == 0:  # 随机数字
            num = random.randrange(0, 10)
            li.append(str(num))
        elif r == 1:    # 随机大写字母
            temp = random.randrange(65, 91)    # 65-91在ascii表中对应的字符是A-Z
            c = chr(temp)       # 将十进制整数转换成为ascii表中对应的字符
            li.append(str(c))
        elif r == 2:    # 随机小写字母
            temp = random.randrange(97, 123)   # 97-123在ascii表中对应的字符是a-z
            c = chr(temp)   # 将十进制整数转换成为ascii表中对应的字符
            li.append(str(c))
                 
    result = "".join(li)
    print(result)
                 
    # 输出
    814P8i

  • ord()   将字符转换成ascii编码表中对应的十进制整数

    1
    2
    3
    4
    5
    st = ord("E")   # 字符E在ascii编码表中对应的十进制整数是69
    print(st)
                 
    # 输出
    69

  • dir()  # 查看一个对象有哪些功能

    1
    2
    3
    4
    print(dir(dict))
                 
    # 输出
    ['__class__', '__contains__', '__delattr__', '__delitem__', '__dir__', '__doc__', '__eq__', '__format__', '__ge__', '__getattribute__', '__getitem__', '__gt__', '__hash__', '__init__', '__iter__', '__le__', '__len__', '__lt__', '__ne__', '__new__', '__reduce__', '__reduce_ex__', '__repr__', '__setattr__', '__setitem__', '__sizeof__', '__str__', '__subclasshook__', 'clear', 'copy', 'fromkeys', 'get', 'items', 'keys', 'pop', 'popitem', 'setdefault', 'update', 'values']

  • help() 查看对象的使用方法

    1
    2
    3
    4
    print(help(list))
                 
    # 输出
    输出内容太长，自己去试

  • divmod()   # 通过除数和被除数返回一个元组(商, 余数)  做分页比较有用

    1
    2
    3
    4
    5
    n = divmod(100, 9)
    print(n)
                 
    # 输出
    (11, 1)

  • isinstance() 判断对象是否是一个类的实例, 返回一个布尔值

    1
    2
    3
    4
    5
    6
    7
    8
    r = isinstance("abc", str)
    print(r)
    r = isinstance("abc", dict)
    print(r)
                 
    # 输出
    True
    False

  • enumerate()   用于遍历序列中的元素以及它们的下标

    1
    2
    3
    4
    5
    6
    7
    for i,j in enumerate(('a','b','c')):
        print(i,j)
                 
    # 输出
    0 a
    1 b
    2 c

  • filter(函数名, 可迭代对象)      调用函数，将可迭代对象中的每一个元素传给函数去执行，返回的结果为True则保留该元素，将保留的元素组成一个列表，将该列表作为返回值

    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
    12
    13
    14
    15
    16
    17
    18
    19
    20
    def f2(a):
        if a > 22:
            return True
    li = [11, 22, 33, 44, 55, 66]
    ret = filter(f2, li)
    print(list(ret))
                 
    # 输出
    [33, 44, 55, 66]
                 
                 
                 
    ## 使用lambda表达式
    f1 = lambda a: a > 30
    li = [11, 22, 33, 44, 55, 66]
    ret = filter(f1, li)
    print(list(ret))
                 
    # 输出
    [33, 44, 55, 66]

  • map(函数，可迭代对象)  调用函数，将可迭代对象中的每一个元素传给函数去执行，返回的结果组成一个列表，将该列表作为返回值

    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
    12
    13
    14
    15
    16
    17
    def f2(a):
        return a + 100
    li = [11, 22, 33, 44, 55, 66]
    ret = map(f2, li)
    print(list(ret))
                 
    # 输出
    [111, 122, 133, 144, 155, 166]
                 
                 
    ## 使用lambda表达式
    f2 = lambda a: a + 100
    li = [11, 22, 33, 44, 55, 66]
    ret = map(f2, li)
    print(list(ret))
    # 输出
    [111, 122, 133, 144, 155, 166]

  • globals()  # 全局变量     locals()   # 局部变量

    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    NAME = "aaa"
    def show():
        a = 123
        print(globals())
        print(locals())
    show()
                 
    # 输出
    {'__file__': 'D:/SVN/learning/s13/day4/class_code/2、内置函数.py', 'show': <function show at 0x00000000004BCBF8>, '__builtins__': <module 'builtins' (built-in)>, '__spec__': None, 'NAME': 'aaa', '__cached__': None, '__package__': None, '__loader__': <_frozen_importlib.SourceFileLoader object at 0x000000000276E7B8>, '__doc__': None, '__name__': '__main__'}
    {'a': 123}

  • hash()   通过hash计算出一个全数字的值

    1
    2
    3
    4
    5
    6
    s = "123"
    ret = hash(s)
    print(ret)
                 
    # 输出   pycharm执行有问题,这个值会变,在python命令提示符下执行没问题
    -5981999319787686991

  • len()   python2.7 字节长度  python3 字符长度

    1
    2
    3
    4
    5
    name = "张三"
    print(len(name))
                 
    # 输出
    2

  • bytes()  将字符转成字节

    1
    2
    3
    4
    5
    6
    name = "张聪"
    ret = bytes(name, encoding="utf-8")
    print(ret)
                 
    # 输出
    b'\xe5\xbc\xa0\xe8\x81\xaa'

  • max() 求最大值

    1
    2
    3
    4
    5
    r = max([11, 22, 33, 1])
    print(r)
                 
    # 输出
    33

  • min()  求最小值

    1
    2
    3
    4
    5
    r = min([11, 22, 33, 1])
    print(r)
                 
    # 输出
    1

  • sum()  求和

    1
    2
    3
    4
    5
    r = sum([11, 22, 33, 1])
    print(r)
                 
    # 输出
    67

  • pow()   求幂次方

    1
    2
    3
    4
    5
    r = pow(2, 10)  # 2的10次方
    print(r)
                 
    # 输出
    1024

  • reversed() 反转  和list的reversed()方法一样

    1
    2
    3
    4
    5
    6
    li = [1, 3, 4, 1, 53, 3, 5]
    ret = reversed(li)
    print(list(ret))
                 
    # 输出
    [5, 3, 53, 1, 4, 3, 1]

  • round()  四舍五入

    1
    2
    3
    4
    5
    6
    7
    8
    ret = round(1.8)
    ret2 = round(3.3)
    print(ret)
    print(ret2)
                 
    # 输出
    2
    3

  • slice()   跟切片的方法一样 没什么卵用，比切片还麻烦

    1
    2
    3
    4
    5
    6
    7
    8
    9
    myslice = slice(0,5,2)
    print(myslice)
                 
    l = list(range(10))
    print(l[myslice])
                 
    # 输出
    slice(0, 5, 2)
    [0, 2, 4]

  • sorted() 排序

    1
    2
    3
    4
    5
    6
    li = [1, 3, 4, 1, 53, 3, 5]
    ret = sorted(li)
    print(ret)
                 
    # 输出
    [1, 1, 3, 3, 4, 5, 53]

  • type() 查看对象类型

    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
    a = "abc"
    b = [1, 2, 3]
    c = {1: "a", 2: "b"}
    print(type(a))
    print(type(b))
    print(type(c))
                 
    # 输出
    <class 'str'>
    <class 'list'>
    <class 'dict'>

  • zip()  将多个列表的相对应的位置进行组合成一个元组，元组作为元素产生新的列表

    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    l1 = [11, 12, 13, 14]
    l2 = [21, 22, 23, 24]
    l3 = [31, 32, 33, 34]
                 
    ret = zip(l1, l2, l3)
    print(list(ret))
                 
                 
    # 输出
    [(11, 21, 31), (12, 22, 32), (13, 23, 33), (14, 24, 34)]

装饰器

装饰器可以在不改变函数体和函数调用的情况下在该函数执行之前，或者执行之后进行额外的操作

装饰器的功能

  • 自动执行装饰器函数，并将被装饰函数的函数名当做参数传递给装饰器函数

  • 将装饰器函数的返回值，重新赋值给被装饰函数

装饰器之案例演变

  • 创建一个简单的函数，该函数的内容为输出nginx告警信息，该函数同时被A部门调用

    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
    def print_nginx_log():
        """
        nginx服务器告警
        :return:
        """
        print("nginx server is down")
              
    print_nginx_log()
              
    # 输出
    nginx server is down

  • 新的需求来了，A部门说需要在输出告警之前和输出告警之后分别输出"即将告警"和"告警结束"，然后我们对上面的代码做如下修改：

    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
    12
    13
    14
    15
    16
    17
    def print_nginx_log():    # 直接在该代码中告警的前后添加代码
        """
        nginx服务器告警
        :return:
        """
        print("nginx即将告警")
        print("nginx server is down")
        print("nginx告警结束")
              
    print_nginx_log()
              
    # 输出
    nginx即将告警
    nginx server is down
    nginx告警结束
              
    ### 这个时候完成了A部门的需求，A部门老大很高兴，请我出去happy了一下

  • 新的问题出现了，A部门老大说你这个修改了原来函数的代码，有没有办法在不修改函数代码的基础上完成这个功能啊，思考半天，灵机一动，想到一个办法，代码如下：

    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
    12
    13
    14
    15
    16
    17
    18
    19
    20
    21
    def new_func(func):   # 新添加一个函数，在该函数内去调用nginx告警函数，并在告警前后完成A部门的需求
        print("nginx即将告警")
        func()
        print("nginx告警结束")
              
              
    def print_nginx_log():
        """
        nginx服务器告警
        :return: None
        """
        print("nginx server is down")
              
    new_func(print_nginx_log)
              
    # 输出
    nginx即将告警
    nginx server is down
    nginx告警结束
              
    ## 代码改完，告诉他新的函数的名称，让他去修改代码调用的函数，使用new_func(print_nginx_log)进行调用就可以实现他说的那个功能，A思考了1秒钟，回答说:"fuck，你知道这样我需要改多少个地方么，我有n个位置调用了这个nginx告警函数，让我改不现实，赶紧想办法解决吧"，然后我就开始各种百度，谷歌一顿狂搜，然后发现了装饰器这么个玩意

  • 总结了一下A部门老大的需求就是要想不改变函数调用方式的情况下去对原函数做扩展，然后就有了下面的装饰器：

    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
    12
    13
    14
    15
    16
    17
    18
    19
    20
    21
    22
    23
    24
    25
    def new_func(func):
        """
        装饰函数
        :param func: 被装饰函数的函数名
        :return: func
        """
        print("nginx即将告警")
        func()
        print("nginx告警结束")
        return func
              
              
    @new_func
    def print_nginx_log():
        """
        nginx服务器告警
        :return: None
        """
        print("nginx server is down")
              
              
    # 输出
    nginx即将告警
    nginx server is down
    nginx告警结束

    上面代码流程详解：

  • 使用了装饰器之后执行发现，我并没有调用函数，但是自己就执行了，这肯定不是我想要得结果，然后继续百度、谷歌。。。各种FQ各种搜最后，代码修改如下：

    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
    12
    13
    14
    15
    16
    17
    18
    19
    20
    21
    22
    23
    24
    25
    26
    27
    28
    def new_func(func):
        """
        装饰函数
        :param func: 被装饰函数的函数名
        :return: func
        """
        def inner():
            print("nginx即将告警")
            func()
            print("nginx告警结束")
        return inner
              
    @new_func
    def print_nginx_log():
        """
        nginx服务器告警
        :return:
        """
        print("nginx server is down")
              
    print_nginx_log()
              
    # 输出
    nginx即将告警
    nginx server is down
    nginx告警结束
              
    ### 从结果中看出，当调用nginx告警函数的时候，才会进行输出，完成了A部门老大的需求，于是他猛夸了我一番

    上面代码流程详解：

  • 过了几天，A部门老大跑过来对我说："你看能不能这样，这个只能够对nginx做告警，我现在需要对mysql也要做告警，你能不能在底层函数上面加一个参数，然后我把告警的信息当做参数给传进去"，然后我又一顿狂搜，搞出来的代码如下：

    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
    12
    13
    14
    15
    16
    17
    18
    19
    20
    21
    22
    23
    24
    25
    26
    27
    28
    29
    30
    def new_func(func):
        """
        装饰函数
        :param func: 被装饰函数的函数名
        :return: func
        """
        def inner(value):
            print("nginx即将告警")
            func(value)
            print("nginx告警结束")
        return inner
              
    @new_func
    def print_nginx_log(value):
        """
        nginx服务器告警
        :return:
        """
        print(value)
              
              
    value = "mysql is down"
    print_nginx_log(value)
              
    # 输出
    nginx即将告警
    mysql is down
    nginx告警结束
              
    ### 这样就解决了A部门老大的需求了

  • 过了没几天，他又跑过来，说mysql告警的时候需要传多个参数，nginx告警只需要传一个参数，你看能否搞下，然后我又进入到狂搜的状态，最后搞出来代码如下

    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
    12
    13
    14
    15
    16
    17
    18
    19
    20
    21
    22
    23
    24
    25
    26
    27
    28
    29
    30
    31
    def new_func(func):
        """
        装饰函数
        :param func: 被装饰函数的函数名
        :return: func
        """
        def inner(*args, **kwargs):
            print("nginx即将告警")
            func(*args, **kwargs)
            print("nginx告警结束")
        return inner
              
    @new_func
    def print_nginx_log(*args, **kwargs):
        """
        nginx服务器告警
        :return:
        """
        print(*args, **kwargs)
              
              
    value = "mysql is down"
    k_value = {"time": 100}
    print_nginx_log(value, k_value)
              
    # 输出
    nginx即将告警
    mysql is down {'time': 100}
    nginx告警结束
              
    ### 这样就解决了A部门老大的需求，于是他又请我出去happy了一下^.^

  • 过了没两天又跑来找我，说底层函数没有返回值，我需要一个返回值，然后经过一顿的狂搜，搞到下面的代码

    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
    12
    13
    14
    15
    16
    17
    18
    19
    20
    21
    22
    23
    24
    25
    26
    27
    28
    29
    30
    31
    32
    33
    34
    35
    def new_func(func):
        """
        装饰函数
        :param func: 被装饰函数的函数名
        :return: func
        """
        def inner(*args, **kwargs):
            print("nginx即将告警")
            res = func(*args, **kwargs)
            print("nginx告警结束")
            return res
        return inner
              
    @new_func
    def print_nginx_log(*args, **kwargs):
        """
        nginx服务器告警
        :return:
        """
        print(*args, **kwargs)
        res = "ok"
        return res
              
              
              
    value = "mysql is down"
    k_value = {"time": 100}
    res = print_nginx_log(value, k_value)
    print(res)
              
    ### 输出
    nginx即将告警
    mysql is down {'time': 100}
    nginx告警结束
    ok

python学习之路-4 内置函数和装饰器的更多相关文章

  1. Python之函数（自定义函数，内置函数，装饰器，迭代器，生成器）

    Python之函数(自定义函数,内置函数,装饰器,迭代器,生成器) 1.初始函数 2.函数嵌套及作用域 3.装饰器 4.迭代器和生成器 6.内置函数 7.递归函数 8.匿名函数

  2. Python学习（八） —— 内置函数和匿名函数

    一.递归函数 定义:在一个函数里调用这个函数本身 递归的最大深度:997 def func(n): print(n) n += 1 func(n) func(1) 测试递归最大深度 import sy ...

  3. python学习 day013打卡 内置函数

    本节主要内容: 内置函数: 内置函数就是python给你提供的.拿来直接用的函数,比如print,input等等.截止到python版本3.6.2 python一共提供了68个内置函数.他们就是pyt ...

  4. python成长之路八 -- 内置函数

    1,python内置函数     内置函数     abs() dict() help() min() setattr() all()  dir()  hex() next()  slice()  a ...

  5. Python学习笔记——常用的内置函数

    一.yield def EricReadlines(): seek = 0 while True: with open('D:/temp.txt','r') as f: f.seek(seek) da ...

  6. python之路 内置函数，装饰器

    一.内置函数 #绝对值 abs() #所有值都为真才为真 all() #只要有一个值为真就为真 any() #10进制转成二进制 bin() #10进制转成八进制 oct() #10进制转成十六进制 ...

  7. Python学习【第5篇】：Python之函数（自定义函数，内置函数，装饰器，迭代器，生成器、模块）

    一.为什么要使用函数? 1.避免代码重用 2.提高代码的可读性 二.函数的定义与调用 1. def  函数名(参数1,参数2): ''' 函数注释''' print('函数体') return 返回值 ...

  8. python学习三十八天常用内置函数分类汇总

    python给我们提供丰富的内置函数,不用去写函数体,直接调用就可以运行,很方便快速给我提供开发所需要的函数. 1,查内存地址 id() 变量的内存地址 id() 2,输入输出 input()  pr ...

  9. python学习笔记-day4笔记 常用内置函数与装饰器

    1.常用的python函数 abs             求绝对值 all               判断迭代器中所有的数据是否为真或者可迭代数据为空,返回真,否则返回假 any          ...

随机推荐

  1. Javascript:重用之道

    近期写了大量的js,愈发觉得自己的代码过于冗余,所以,利用周末的时间研习代码重用之道,有了这篇博文所得: 重用代码: 1.尽量保证 HTML 代码结构一致,可以通过父级选取子元素 2.把核心主程序实现 ...

  2. <Win32_6>程序员求爱的创意程序^_^

    作为程序员,我们时常被外界误认为很闷.不浪漫.没创意……等等这一类人,这让我们实在有些感伤啊,我得为程序员呐喊一声: 我们也能可以欢快.浪漫.有创意…… 朋友,你向女生表白过吗? …… 这个问题有点儿 ...

  3. 安装tcmalloc

    安装google-perftools:#tar zxvf google-perftools-1.6.tar.gz #cd google-perftools-1.6 #./configure#make# ...

  4. 无语的index hint：手工分配哈希区，5小时不出结果，优化后20分钟

    同事说,有个语句5个小时不出结果,叫我帮忙看看,于是叫同事发过来.不看不知道,一看吓一跳,3个表关联,强制使用了2个index hint,当中一个表9g,一个表67g,另一个小表40Mb.开发者,总以 ...

  5. Hacker（18）----了解Windows系统漏洞

    一.WinXP中的漏洞 在WinXP中,常见的漏洞主要有UPNP服务漏洞.帮助与支持中心漏洞.压缩文件夹漏洞.服务拒绝漏洞.RDP漏洞以及热键漏洞. 1.UPNP服务漏洞 漏洞描述:UPNP(Univ ...

  6. 在IIS集成管道中使用OWIN Middleware

    在Katana中启用Windows Authorization OWIN的架构: Host 管理OWIN pipeline上运行的进程 Server 打开一个network socket,,监听请求 ...

  7. JS中的for和for in循环

    1.for循环通常用来遍历数组或类数组对象 模式1:长度缓存 for(var i=0,max=arr.length;i<max;i++){ //your code } 模式2:逐减,与零比较比与 ...

  8. sql server windows账号不能登陆指定的数据库

    问题描述: 1. windows账号登陆后,默认的数据库被删除 2. SA账号密码也忘记了 此时就会导致用windows账号登陆Sql Server的时候,返回4064的错误,按照上面的问题描述,应该 ...

  9. rsync数据同步配置

    环境配置 操作系统:centos6.4_64bit A服务器IP:192.168.6.128 B服务器IP:192.168.6.129 以A服务器为基准,将A服务器文件同步到B服务器. 步骤如下: 开 ...

  10. URI和URL

    URI(uniform resource identifier),统一资源标识符,用来唯一的标识一个资源. URL(uniform resource locator),统一资源定位器,它是一种具体的U ...