python学习之路-4 内置函数和装饰器

Posted 奋斗中的码农

tags:

篇首语：本文由小常识网(cha138.com)小编为大家整理，主要介绍了python学习之路-4 内置函数和装饰器相关的知识，希望对你有一定的参考价值。

本篇涉及内容

内置函数

装饰器




内置函数

  • 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)
    以上是关于python学习之路-4 内置函数和装饰器的主要内容，如果未能解决你的问题，请参考以下文章

    Python学习之路6 - 装饰器

    python之路基础-内置函数函数装饰器

    Python学习之路：装饰器前奏

    python学习--装饰器生成器内置函数json

    python之路 内置函数，装饰器

    python学习笔记:装饰器生成器内置函数json

    (c)2006-2024 SYSTEM All Rights Reserved IT常识