• python (九)函数


    一、内置函数

      1、作用域相关函数  locals  globals  

      locals:  会以字典类型返回当前位置的全部局部变量
        globals: 以字典类型返回当前位置的全部全局变量,包括所有导入的变量

    # 两个全局变量 name,age
    name = '太白'
    age = 25
    
    
    def func1():  # 两个局部变量:a, b
        a = 'Ws'
        b = {'name': '二狗'}
        print(globals())  # 返回一个全局变量的字典,如下注释部分
            # {'__name__': '__main__', '__doc__': None, '__package__': None,
            #  '__loader__': <_frozen_importlib_external.SourceFileLoader object at 0x108e02208>,
            # '__spec__': None, '__annotations__': {}, '__builtins__': <module 'builtins' (built-in)>,
            # '__file__': '/Users/chensihan/Documents/shanshan/上课练习/000博客.py', '__cached__': None,
            # 'name': '太白', 'age': 25, 'func1': <function func1 at 0x108d981e0>}
        
        print(locals())  # 返回一个局部变量的字典  {'a': 'Ws', 'b': {'name': '二狗'}}
    
    
    func1()
    
    # 下边两个globals和locals执行结果一样, 因为是在全局执行的
    print(globals())  # 此时的全局变量是name,age
        # {'__name__': '__main__', '__doc__': None, '__package__': None,
        #  '__loader__': <_frozen_importlib_external.SourceFileLoader object at 0x10f66e208>,
        # '__spec__': None, '__annotations__': {}, '__builtins__': <module 'builtins' (built-in)>,
        # '__file__': '/Users/chensihan/Documents/shanshan/上课练习/000博客.py', '__cached__': None,
        # 'name': '太白', 'age': 25, 'func1': <function func1 at 0x10f6041e0>}
    
    print(locals())  # 此时的局部变量应该是name,age
        # {'__name__': '__main__', '__doc__': None, '__package__': None,
        #  '__loader__': <_frozen_importlib_external.SourceFileLoader object at 0x1057cb208>,
        # '__spec__': None, '__annotations__': {}, '__builtins__': <module 'builtins' (built-in)>,
        # '__file__': '/Users/chensihan/Documents/shanshan/上课练习/000博客.py', '__cached__': None,
        # 'name': '太白', 'age': 25, 'func1': <function func1 at 0x1057611e0>}

      2、其余相关函数 eval  exec  

      eval : 执行字符串中的代码并将结果返回给执行者。  慎用

    eval('2 + 2')  # 4
    
    n = 1
    eval("n + 4")  # 5
    
    eval('print(666)')  # 666
    
    s3 = 'print(666)'  # 这是个字符串,第一步不执行这里
    print(eval(s3))  # 执行字符串s3中的代码,接收到S3的结果666,再次print的结果是 None

    exec :  执行字符串中的代码 往往执行代码流。   慎用。

    r1 = '''
    for i in range(3):
        print(i)
    '''
    
    exec(r1)  # 0 1 3

      3、内存相关  hash id  

       hash:获取一个对象的哈希值(可哈希对象:int,str,Bool,tuple)

    print(hash(12322))  # int类型 ,结果是 12322
    print(hash('123'))  # str类型,每次结果不同
    print(hash('arg'))  # str类型,每次结果不同
    print(hash(True))  # bool类型,结果 1
    print(hash(False))  # bool类型,结果 0
    print(hash((1, 2, 3)))  # 元祖类型,结果为固定值 2528502973977326415

    id:返回对象的内存地址

    # 以下类型的数据,返回的都是内存地址,每次结果都会变,
    print(id(12322)) 
    print(id('123'))
    print(id('arg'))
    print(id(True))
    print(id(False))
    print(id((1, 2, 3)))

      4、文件操作相关 open  

    f = open('log', 'w', encoding='utf-8')  # # 新建一个log文件
    print('王大锤', file=f)  # 写入内容:王大锤

      5、帮助信息相关 help  

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

    print(help(str))  # 显示class str的帮助信息
    help('sys')  # 显示sys 模块的帮助
    help([1, 2, 3])  # 显示列表 list 帮助信息
    
    a = [1, 2, 3]
    help(a.append)  # 显示list的append方法的帮助信息

      6、调用相关:callable  

        callable:检查一个对象是否是可调用的。如果返回True,object仍然可能调用失败;但如果返回False,调用对象ojbect绝对不会成功。

    a = '大锤'
    
    def func():
        print(666)
        
    print(callable(a))  # False  证明字符串a绝对不会被调用成功
    print(callable(func))  # True 证明func可以被调用,但是不确定每次都能被调用成功
    
    a()

      7、查看内置属性 dir  

        dir:函数不带参数时,返回当前范围内的变量、方法和定义的类型列表;

        带参数时,返回参数的属性、方法列表。如果参数包含方法__dir__(),该方法将被调用。如果参数不包含__dir__(),该方法将最大限度地收集参数信息。

    # 不带参数
    
    print(dir())   # 查看当前模块的属性方法
    # ['__annotations__', '__builtins__', '__cached__', '__doc__',
    # '__file__', '__loader__', '__name__', '__package__', '__spec__']
    
    
    print(dir([]))  # 查看列表的方法
    # ['__add__', '__class__', '__contains__', '__delattr__', '__delitem__',
    #  '__dir__', '__doc__', '__eq__', '__format__', '__ge__', '__getattribute__',
    #  '__getitem__', '__gt__', '__hash__', '__iadd__', '__imul__', '__init__',
    # '__init_subclass__', '__iter__', '__le__', '__len__', '__lt__', '__mul__',
    #  '__ne__', '__new__', '__reduce__', '__reduce_ex__', '__repr__',
    # '__reversed__', '__rmul__', '__setattr__', '__setitem__', '__sizeof__',
    #  '__str__', '__subclasshook__', 'append', 'clear', 'copy', 'count',
    # 'extend', 'index', 'insert', 'pop', 'remove', 'reverse', 'sort']
    
    
    
    
    
    # 带参数
    
    print(dir('大锤'))  # 查看此字符串的方法
    # ['__add__', '__class__', '__contains__', '__delattr__', '__dir__', '__doc__',
    #  '__eq__', '__format__', '__ge__', '__getattribute__', '__getitem__',
    # '__getnewargs__', '__gt__', '__hash__', '__init__', '__init_subclass__',
    # '__iter__', '__le__', '__len__', '__lt__', '__mod__', '__mul__', '__ne__',
    #  '__new__', '__reduce__', '__reduce_ex__', '__repr__', '__rmod__', '__rmul__',
    # '__setattr__', '__sizeof__', '__str__', '__subclasshook__', 'capitalize',
    # 'casefold', 'center', 'count', 'encode', 'endswith', 'expandtabs', 'find',
    # 'format', 'format_map', 'index', 'isalnum', 'isalpha', 'isascii', 'isdecimal',
    #  'isdigit', 'isidentifier', 'islower', 'isnumeric', 'isprintable', 'isspace',
    #  'istitle', 'isupper', 'join', 'ljust', 'lower', 'lstrip', 'maketrans', 'partition',
    #  'replace', 'rfind', 'rindex', 'rjust', 'rpartition', 'rsplit', 'rstrip', 'split',
    #  'splitlines', 'startswith', 'strip', 'swapcase', 'title', 'translate', 'upper', 'zfill']
    
    
    
    print(dir([1, 2, 3]))  # 查看此列表的方法
    # ['__add__', '__class__', '__contains__', '__delattr__', '__delitem__', '__dir__', 
    # '__doc__', '__eq__', '__format__', '__ge__', '__getattribute__', '__getitem__', 
    # '__gt__', '__hash__', '__iadd__', '__imul__', '__init__', '__init_subclass__',
    #  '__iter__', '__le__', '__len__', '__lt__', '__mul__', '__ne__', '__new__', 
    # '__reduce__', '__reduce_ex__', '__repr__', '__reversed__', '__rmul__', '__setattr__', 
    # '__setitem__', '__sizeof__', '__str__', '__subclasshook__', 'append', 'clear', 'copy',
    #  'count', 'extend', 'index', 'insert', 'pop', 'remove', 'reverse', 'sort']
    查看内置属性--dir

      8、基础数据类型相关    

        数据类型:  bool int float complex  bytes

    # int 函数用于将一个字符串或数字转换为整型
    print(int())  # 0
    print(int('12'))  # 12
    print(int(3.6))  # 3
    print(int('0100', base=2))  # 将2进制的 0100 转化成十进制。结果为 4
    
    
    # bool  用于将给定参数转换为布尔类型,如果没有参数,返回 False
    print(bool())  # False
    print(bool(0))  # False
    print(bool(1))  # True (非0即true)
    print(bool(2))  # True
    
    
    # float   用于将整数和字符串转换成浮点数
    print(float(1))  # 1.0
    print(float(112))  # 112.0
    print(float(-123.6)) # -123.6
    print(float('123'))  # 123.0  字符串也会转春成相应的数据
    
    
    # complex  创建一个值为 real + imag * j 的复数或者转化一个字符串或数为复数。如果第一个参数为字符串,则不需要指定第二个参数
    print(complex(1, 2))  # (1+2j)
    print(complex(1))  # 数字 (1+0j)
    print(complex("1"))  # 当做字符串处理(1+0j)
    # 注意:这个地方在"+"号两边不能有空格,也就是不能写成"1 + 2j",应该是"1+2j",否则会报错
    print(complex("1+2j"))  # (1+2j)

    进制转换:   bin oct hex

    # bin:将十进制转换成二进制并返回。
    print(bin(10), type(bin(10)))  # 0b1010 <class 'str'>
    
    
    # oct:将十进制转化成八进制字符串并返回。
    print(oct(10), type(oct(10)))  # 0o12 <class 'str'>
    
    
    # hex:将十进制转化成十六进制字符串并返回。
    print(hex(10), type(hex(10)))  # 0xa <class 'str'>

    数学运算: abs divmod round pow sum min max  divmod

    # abs:返回数字的绝对值。
    print(abs(-5))  # 5
    
    
    # divmod:计算除数与被除数的结果,返回一个包含商和余数的元组(a // b, a % b)
    print(divmod(7, 2))  # (3, 1)
    
    
    # round:保留浮点数的小数位数,默认保留整数
    print(round(7/3, 2))  # 2.33
    print(round(7/3))  # 2
    print(round(3.32567, 3))  # 3.326
    
    
    # pow:求x**y次幂。(三个参数为x**y的结果对z取余)
    # pow(x,y) 等价于 x**y
    # pow(x,y,z) 等价于 x**y%z
    print(pow(2, 3))  # 两个参数为2**3次幂 结果为 8
    print(pow(2.0, 3.0))  # 8.0
    print(pow(2, 4, 3))  # 三个参数为2**4次幂,对3取余。  结果为1
    
    
    # sum:对可迭代对象进行求和计算(可设置初始值)
    print(sum([1, 2, 3]))  # 6
    print(sum((1, 2, 3), 100))  # 106
    print(sum([i for i in range(10)]))  # 45
    print(sum([i for i in range(10)], 100))  # 145
    
    
    # min:返回可迭代对象的最小值(可加key,key为函数名,通过函数的规则,返回最小值)
    print(min([1, 2, 3]))  # 返回此序列最小值 1
    
    ret = min([1, 2, -5], key=abs)  # 按照绝对值的大小,返回此序列最小值
    print(ret)  # 1
    
    dic = {'a': 3, 'b': 2, 'c': 1}
    print(min(dic, key=lambda x: dic[x]))  # c 输出最小值对应的键
    # x为dic的key,lambda的返回值(即dic的值进行比较)返回最小的值对应的键
    
    l1 = [('alex', 3), ('太白', 1), ('wS', 2)]
    # min 默认将可迭代对象中的每个元素依次传入函数中,按照函数的返回值去取最小元素。
    def func(x):
        return x[1]
    print(min(l1, key=func))  # 输出最小的元素 ('太白', 1)
    
    
    # max:返回可迭代对象的最大值(可加key,key为函数名,通过函数的规则,返回最大值)
    print(max([1, 2, 3]))  # 返回此序列最大值 3
    
    ret = max([1, 2, -5], key=abs)  # 按照绝对值的大小,返回此序列最大值
    print(ret)  # -5
    
    dic = {'a': 3, 'b': 2, 'c': 1}
    print(max(dic, key=lambda x: dic[x]))  # a
    # x为dic的key,lambda的返回值(即dic的值进行比较)返回最大的值对应的键
    
    
    # divmod 把除数和余数运算结果结合起来,返回一个包含商和余数的元组(a // b, a % b)
    # 分页会用到。
    print(divmod(7, 3))  # (2, 1)  2为商,1为余数

    列表和元祖:list  tuple

    # list:将一个可迭代对象转化成列表(如果是字典,默认将key作为列表的元素)
    l = list((1, 2, 3))
    print(l)
    
    l = list({1, 2, 3})
    print(l)
    
    l = list({'k1': 1, 'k2': 2})
    print(l)
    
    
    
    # tuple:将一个可迭代对象转化成元祖(如果是字典,默认将key作为元祖的元素)
    tu = tuple((1, 2, 3))
    print(tu)
    
    tu = tuple([1, 2, 3])
    print(tu)
    
    tu = tuple({'k1': 1, 'k2': 2})
    print(tu)

    相关内置函数:   reversed  slice  len  enumerate  all   any  filter  map  

    # reversed:将一个序列翻转,并返回此翻转序列的迭代器
    l1 = [1, 2, 3, 4]
    l1.reverse()
    print(l1)  # [4, 3, 2, 1]
    l2 = reversed(l1)
    print(list(l2))  # [1, 2, 3, 4]
    
    ite = reversed(['a', 2, 3, 'c', 4, 2])
    for i in ite:
        print(i)  # 依次返回2 4 c 3 2 a
    

    # slice:构造一个切片对象,用于列表的切片 li = ['a', 'b', 'c', 'd', 'e', 'f', 'g'] obj = slice(3) print(li[obj]) # ['a', 'b', 'c'] li = ['a', 'b', 'c', 'd', 'e', 'f', 'g'] obj2 = slice(0, 7, 2) # 从0号元素到6号元素, 步长为2取值 print(li[obj2]) # ['a', 'c', 'e', 'g'] # len:返回一个对象中元素的个数。 a = [1, 2, 3, 4] b = {'name': '大锤', 'age': 20} print(len(a)) # 4 print(len(b)) # 2 # sorted:对所有可迭代的对象进行排序操作。 L = [('a', 1), ('c', 3), ('d', 4), ('b', 2), ] print(sorted(L, key=lambda x: x[1])) # 利用key排序 [('a', 1), ('b', 2), ('c', 3), ('d', 4)] students = [('大锤', 'A', 15), ('大脸', 'B', 12), ('小娟', 'B', 10)] print(sorted(students, key=lambda s: s[2])) # 按年龄排序 [('小娟', 'B', 10), ('大脸', 'B', 12), ('大锤', 'A', 15)] print(sorted(students, key=lambda s: s[2], reverse=True)) # 按降序 [('大锤', 'A', 15), ('大脸', 'B', 12), ('小娟', 'B', 10)] l1 = [1, 2, 7, 6, 5, 4] print(sorted(l1)) # [1, 2, 4, 5, 6, 7] # enumerate:枚举,返回一个枚举对象 print(enumerate([1, 2, 3])) # <enumerate object at 0x10e2e0750> for i in enumerate([1, 2, 3]): print(i) # (0, 1) (1, 2) (2, 3) for i in enumerate([1, 2, 3], 100): print(i) # (100, 1) (101, 2) (102, 3) # all:可迭代对象中,全都是True才是True print(all([1, 2, True, 0])) # False # any:可迭代对象中,有一个True 就是True print(any([1, '', 0])) # True # zip:函数用于将可迭代的对象作为参数,将对象中位置对应的元素打包成一个个元组,然后返回由这些元组组成的列表。 # 如果各个迭代器的元素个数不一致,则返回列表长度与最短的对象相同。 l1 = [1, 2, 3] l2 = ['a', 'b', 'c', 5] l3 = ('*', '**', (1, 2, 3)) for i in zip(l1, l2, l3): print(i) # 依次输出(1, 'a', '*') (2, 'b', '**') (3, 'c', (1, 2, 3)) # filter 过滤 通过函数过滤一个可迭代对象,返回的是True # 类似于[i for i in range(10) if i > 3] def func(x): return x % 2 == 0 ret = filter(func, [1, 2, 3, 4, 5, 6, 7]) print(ret) # <filter object at 0x10712d1d0> for i in ret: print(i) # 依次输出 2 4 6 # map: 返回一个迭代器 类比成列表推导式:循环模式 def square(x): # 计算平方数 return x ** 2 print(list(map(square, [1, 2, 3, 4, 5]))) # 计算列表各个元素的平方 [1, 4, 9, 16, 25] print(list(map(lambda x: x ** 2, [1, 2, 3, 4, 5]))) # 使用 lambda 匿名函数 [1, 4, 9, 16, 25] # 提供了两个列表,对相同位置的列表数据进行相加 print(list(map(lambda x, y: x + y, [1, 3, 5, 7, 9], [2, 4, 6, 8, 10]))) # [3, 7, 11, 15, 19] l1 = [1, 2, 3, 4, 5, 6] def func(x): return x ** 2 print(list(map(func, l1))) # [1, 4, 9, 16, 25, 36]

    字符串相关 :str  format  bytes bytearry  memoryview  ord  chr  ascii  %r  repr

    # str:将数据转化成字符串
    s = 'RUNOOB'
    print(str(s))  # 'RUNOOB'
    dict = {'runoob': 'runoob.com', 'google': 'google.com'};
    print(str(dict))  # "{'google': 'google.com', 'runoob': 'runoob.com'}"
    
    
    
    # format:与具体数据相关,用于计算各种小数,精算等
    
    # 对齐方式:字符串可以提供的参数,指定对齐方式,<是左对齐, >是右对齐,^是居中对齐
    print(format('文字在左,包含文字在内共30个字符的位置', '<30'))
    print(format('文字在右,包含文字在内共30个字符的位置', '>30'))
    print(format('文字居中,包含文字在内共30个字符的位置', '^30'))
    
    
    # 整形数值可以提供的参数有 'b' 'c' 'd' 'o' 'x' 'X' 'n' None
    print(format(3, 'b'))  # 转换成二进制  '11'
    print(format(97, 'c'))  # 转换unicode成字符 'a'
    print(format(11, 'd'))  # 转换成10进制
    print(format(11, 'o'))  # 转换成8进制  '13'
    print(format(11, 'x'))  # 转换成16进制 小写字母表示  'b'
    print(format(11, 'X'))  # 转换成16进制 大写字母表示  'B'
    print(format(11, 'n'))  # 和d一样  '11'
    print(format(11))  # 默认和d一样  '11'
    
    
    # 浮点数可以提供的参数有 'e' 'E' 'f' 'F' 'g' 'G' 'n' '%' None
    print(format(314159267, 'e'))  # 科学计数法,默认保留6位小数   '3.141593e+08'
    print(format(314159267, '0.2e'))  # 科学计数法,指定保留2位小数   '3.14e+08'
    print(format(314159267, '0.2E'))  # 科学计数法,指定保留2位小数,采用大写E表示   '3.14E+08'
    print(format(314159267, 'f'))  # 小数点计数法,默认保留6位小数   '314159267.000000'
    print(format(3.14159267000, 'f'))  # 小数点计数法,默认保留6位小数  '3.141593'
    print(format(3.14159267000, '0.8f'))  # 小数点计数法,指定保留8位小数  '3.14159267'
    print(format(3.14159267000, '0.10f'))  # 小数点计数法,指定保留10位小数  '3.1415926700'
    print(format(3.14e+1000000, 'F'))  # 小数点计数法,无穷大转换成大小字母  'INF'
    
    
    # g的格式化比较特殊,假设p为格式中指定的保留小数位数,先尝试采用科学计数法格式化,得到幂指数exp,
        # 如果-4<=exp<p,则采用小数计数法,并保留p-1-exp位小数,否则按小数计数法计数,并按p-1保留小数位数
    print(format(0.00003141566,'.1g'))  # p=1,exp=-5 ==》 -4<=exp<p不成立,按科学计数法计数,保留0位小数点
                                        # 结果为 '3e-05'
    print(format(0.00003141566,'.2g'))  # p=1,exp=-5 ==》 -4<=exp<p不成立,按科学计数法计数,保留1位小数点
                                        # 结果为 '3.1e-05'
    print(format(0.00003141566,'.3g'))  # p=1,exp=-5 ==》 -4<=exp<p不成立,按科学计数法计数,保留2位小数点
                                        # 结果为 '3.14e-05'
    print(format(0.00003141566,'.3G'))  # p=1,exp=-5 ==》 -4<=exp<p不成立,按科学计数法计数,保留0位小数点,E使用大写
                                        # 结果为 '3.14E-05'
    print(format(3.1415926777,'.1g'))   # p=1,exp=0 ==》 -4<=exp<p成立,按小数计数法计数,保留0位小数点
                                        # 结果为 '3'
    print(format(3.1415926777,'.2g'))   # p=1,exp=0 ==》 -4<=exp<p成立,按小数计数法计数,保留1位小数点
                                        # 结果为 '3.1'
    print(format(3.1415926777,'.3g'))   # p=1,exp=0 ==》 -4<=exp<p成立,按小数计数法计数,保留2位小数点
                                        # 结果为 '3.14'
    print(format(0.00003141566,'.1n'))  #   和g相同
                                        # 结果为 '3e-05'
    print(format(0.00003141566,'.3n'))  # 和g相同
                                        # 结果为 '3.14e-05'
    print(format(0.00003141566))    # 和g相同
                                    # 结果为 3.141566e-05'
    
    
    
    
    # bytes:用于不同编码之间的转化
    # 之前学过转码的方式
    s1 = '大锤'
    # unicode ---> utf-8 bytes
    b1 = s1.encode('utf-8')
    print(b1)  # b'xe5xa4xa7xe9x94xa4'
    # utf-8 bytes ---> unicode
    s2 = b1.decode('utf-8')
    print(s2)  # 大锤
    
    # 用bytes实现
    s1 = '大锤'
    # unicode ---> utf-8 bytes
    b1 = bytes(s1, encoding='utf-8')
    print(b1)  # b'xe5xa4xa7xe9x94xa4'
    
    
    
    # bytearry:返回一个新字节数组。这个数组里的元素是可变的,并且每个元素的值范围: 0 <= x < 256。
    ret = bytearray('alex', encoding='utf-8')
    print(ret)  # bytearray(b'alex')  这是个字节数组
    
    print(ret[0])  # 这个数组中0号元素是字母a,这里输入出的是他的ascii码 108
    ret[0] = 65  # 将0号元素重新规定ascii码,65都应的字母是A
    print(ret)  # bytearray(b'Alex') 此时原来字节数组中的第一个字母a已经被替换成A
    
    
    
    # memoryview  返回给定参数的内存查看对象
    v = memoryview(bytearray("abcefg", 'utf-8'))
    print(v[1])  # 98
    print(v[-1])  # 103
    print(v[1:4])  # <memory at 0x10f543a08>
    print(v[1:4].tobytes())  # b'bce'
    
    
    
    # ord:输入字符找该字符编码的位置
    print(ord('a'))  # 97
    print(ord(''))  # 20013
    
    
    
    # chr:输入位置数字找出其对应的字符
    print(chr(97))  # a
    print(chr(20013))  #
    
    
    
    # ascii:是ascii码中的返回该值,不是就返回/u....
    print(ascii('a'))  # 'a' ,是ascii码
    print(ascii(''))  # 'u4e2d' , 不是ascii码
    
    
    
    # %r  原封不动的写出来
    name = '大锤'
    print('我叫%r' % name)  # 我叫'大锤'
    
    # repr  返回一个对象的string形式(原形毕露)。
    print(repr('{"name":"大锤"}'))  # '{"name":"大锤"}'
    print('{"name":"大锤"}')  # {"name":"大锤"}
    字符串相关函数

    数据集合: frozenset

    # frozenset: 返回一个冻结的集合,冻结后集合不能再添加或删除任何元素。
    a = frozenset(range(10))  # 生成一个新的不可变集合 a
    print(a)  # frozenset({0, 1, 2, 3, 4, 5, 6, 7, 8, 9})
    b = frozenset('runoob')
    print(b)  # frozenset(['b', 'r', 'u', 'o', 'n'])

    二、匿名函数

      1、什么是匿名函数?   

        匿名函数: 一句话函数,一行代码实现的函数。

    # 这段代码
    def func(n):
        return n ** n
    
    print(func(10))
    
    # 换成匿名函数
    func = lambda n: n ** n
    print(func(10))

      2、匿名函数的格式  

    函数名 = lambda 参数 :返回值
    
    #参数可以有多个,用逗号隔开
    #匿名函数不管逻辑多复杂,只能写一行,且逻辑执行结束后的内容就是返回值
    #返回值和正常的函数一样可以是任意数据类型

      3、匿名函数与内置函数结合使用  

    # 匿名函数与内置函数相结合使用。
    # 例1
    l1 = [1, 2, 3, 4, 5, 6]
    
    def func(x):
        return x % 2 == 0
    
    obj1 = filter(lambda x: x % 2 == 0, l1)
    print(list(obj1))  # [2, 4, 6]
    
    
    # 例2
    l = [3, 2, 100, 999, 213, 1111, 31121, 333]
    dic = {'k1': 10, 'k2': 100, 'k3': 30}
    
    def func(x):
        return dic[x]
    
    ret = dic[max(dic, key=lambda x: dic[x])]
    print(ret)  # 100

    三、递归函数

      1、什么是递归函数  

        递归函数:在一个函数里,自己调用自己

        递归的最大深度:997(防止不受外界阻力一直递归下去耗费耗费内存)

    # 验证997深度
    def foo(n):
        print(n)
        n += 1
        foo(n)
    foo(1)

      2、什么时候回用到递归呢?  

      举个例子: 

      问a多大了?

      a说,我比 b 大两岁。   n = 4

      b说,我比 c 大两岁。   n = 3

      c说,我比 d 大两岁。   n = 2

      d说,我18了。             n = 1 

      这个时候怎么计算a多大?

    先来分析一下
    
    age(d) = 18
    age(c) = age(d) + 2
    age(b) = age(c) + 2
    age(a) = age(b) + 2

    这种情况用函数写出来:

    def age(n): 
    if n == 1: return 18 elif n > 1: return age(n-1) + 2 print(age(4))

     具体步骤我们来分析一下

    def age(4):
        if n == 1:
            return 30
        elif n > 1:
            return age(3) + 2
    
    
    def age(3):
        if n == 1:
            return 30
        elif n > 1:
            return age(2) + 2
    
    
    def age(2):
        if n == 1:
            return 30
        elif n > 1:
            return age(1) + 2
    
    
    def age(1):
        if n == 1:
            return 30
        elif n > 1:
            return age(1) + 2

    总结一下: 

      递归: 一定要返回值(返回值基本都是函数调用自己)

      3、递归的具体应用  

    # 斐波那契数列
    # 1 1 2 3 5 8 13 21 34.....
    # 第一种  用之前学过的老方法实现,这种方法会循环输出,一行显示一个数字
    a = 0
    b = 1
    while b < 50:
        print(b)  # 循环换行输出  1 2 3 5 8 13 21 34
        a, b = b, a + b  # 右边的表达式会在赋值变动之前执行,
                         # 即先执行右边,比如第一次循环得到b-->1,a+b --> 0+1 然后再执行赋值 a,b =1,0+1,所以执行完这条后a=1,b=1
    
    
    
    # 第二种 同一行输出所有数字
    a = 0
    b = 1
    while b < 50:
        print(b, end=',')  # end 可以将print输出到同一行并以 ,号结尾
                           # 结果为:1,1,2,3,5,8,13,21,34,
        a, b = b, a + b
    
    
    # 第三种 递归实现 循环输出前9项
    def func(n):
        if n <= 1:
            return n
        else:
            return (func(n - 1) + func(n - 2))
    
    
    for i in range(9):
        print(func(i))
    
    
    # 第四种  递归方式实现 生成前9项的一个列表
    lis = []
    for i in range(9):
        if i == 0 or i == 1:  # 第1,2项 都为1
            lis.append(1)
        else:
            lis.append(lis[i-2]+lis[i-1])  # 从第3项开始每项值为前两项值之和
    print(lis)  # [1, 1, 2, 3, 5, 8, 13, 21, 34]
    
    
    
    # 递归顺序输出整数 1 2 3 4 5 6 7 8 9...
    
    def func(n):
        if n > 0 and n < 10:
            print(n)
            func(n+1)
    func(1)
    
    
    # 递归倒序输出整数 9 8 7 6 5 4 3 2 1...
    
    def func(n):
       if n < 10 and n > 0:
           print(n)
           func(n-1)
        
    func(9)
    
    
    
    # 求1~100的和
    def sum(n):
        if n > 0 and n < 101:
            return n + sum(n + 1)
        else:
            return 0
    print(sum(1))  #  5050
  • 相关阅读:
    virtualenv与virtualenvwrapper
    数据类型、变量定义、数据类型转换
    计算机存储单元、标识符
    html单页面中用angular js
    svn客户端访问失败,错误“请求的名称有效,但是找不到请求的类型”的解决
    php 获取某数组中出现次数最多的值(重复最多的值)与出现的次数
    数据库导入时出现“2006
    phpstorm 激活
    取消本地SVN文件夹与服务器的关联
    js实现倒计时函数
  • 原文地址:https://www.cnblogs.com/caoyinshan/p/10142129.html
Copyright © 2020-2023  润新知