本篇涉及内容

内置函数

装饰器

内置函数

  • 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. 关于ionic传值

    今天,也是偶然发现有的初学者对ionic的传值还不太清除,这里我说明一下 例如你想在这个页面传递参数a.b过去,传递到"tab.wait"页面 $state.go("ta ...

  2. Could not load the Tomcat server configuration at /Servers/Tomcat v7.0 Server at localhost-config.

    [问题] Eclipse[Ubuntu14.04]中启动Tomcat Server[7.0.55]的时候出现错误例如以下: [解决方法] 1.将下边的Servers中的server[Tomcat v7 ...

  3. [RxJS] Refactoring Composable Streams in RxJS, switchMap()

    Refactoring streams in RxJS is mostly moving pieces of smaller streams around. This lessons demonstr ...

  4. Android ActionBar完全解析，使用官方推荐的最佳导航栏(下) .

    转载请注明出处:http://blog.csdn.net/guolin_blog/article/details/25466665 本篇文章主要内容来自于Android Doc,我翻译之后又做了些加工 ...

  5. OpenWrt sscanf问题之于MT7620N与AR9341

    在MT7620N平台做好了wifidog的相关调试工作,除了eth驱动.wireless性能问题,其余的都能够基本正常. 依据实际须要要对已完毕的工作在AR9341平台上实现. 事实上也简单.基本功能 ...

  6. Java学习笔记——JDBC之与数据库MySQL的连接以及增删改查等操作

    必须的准备工作 一.MySQL的安装.可以参考博文: http://blog.csdn.net/jueblog/article/details/9499245 二.下载 jdbc 驱动.可以从在官网上 ...

  7. Android开源代码解读-基于SackOfViewAdapter类实现类似状态通知栏的布局

    一般来说,ListView的列表项都会采用相同的布局,只是填充的内容不同而已,这种情况下,Android提供了convertView帮我们缓存列表项,达到循环利用的目的,开发者也会使用ViewHold ...

  8. Android-IM架构设计

    ###1. 架构总览 ###2. 模块介绍 ####2.1 协议封装与任务流程 #####1) 协议与任务的封装 a. 协议有协议头(协议头因为格式相同,被抽象出来)和协议体组成,协议有两类:请求协议 ...

  9. c#转码解码

    ///反转码                          mdata[k].MNAME = unescape(mdata[k].MNAME);程家楠 13:51:00 Microsoft.JSc ...

  10. IIS 7 支持10万并发请求

    原文链接:http://www.cnblogs.com/dudu/archive/2009/11/10/1600062.html 今天下午17点左右,博客园博客站点出现这样的错误信息: Error S ...