python笔记-回调函数, 递归函数和常用内置函数

一、回调函数

• 把一个函数作为参数传给另一个函数，第一个函数称为回调函数

def add(a, b):
    return a + b


def multiply(a, b):
    return a * b


def calculate(a, b, f):
    return f(a, b)


def main():
    a = int(input("输入整数a: "))
    b = int(input("输入整数b: "))
    print("a + b", calculate(a, b, add))
    print("a * b", calculate(a, b, multiply))

main()

• 有在调用时才看出来是不是回调函数
• 正常调用就是普通函数
• 作为一个函数的参数在需要的时候分情况调用，就是回调函数。

二、递归函数

在函数内部调用函数本身的函数称为递归函数

递归实现求一个数的阶乘

def factorial(n):
    if n == 0 or n == 1:
        return 1
    return n * factorial(n - 1)


print(factorial(10))

递归实现计算斐波拉且数列的第n项

def fib(n: int):
    if n == 1 or n == 2:
        return 1
    return fib(n - 1) + fib(n - 2)


print(fib(10))

三、常用内置函数

3.1 数学相关

1. abs(obj: [int, float, complex]): int float类型的数据返回绝对值, complex类型数据返回模长

>>> abs(-3.2)
3.2
>>> abs(-4)
4
>>> abs(3+4j)  # 复数返回复数的模长
5.0

2. max(iter) min(iter): 返回可迭代对象中的最大值或最小值

>>> li = [3, 4, 5, -8, 9, 8]
>>> max(li)
9
>>> min(li)
-8

3. sum(iter) 求取iter元素的和

>>> sum(range(1,11))
55

4. sorted(obj: [list tuple set dict]) : 排序，返回排序后的对象, 返回值是一个列表
   • dict对象作为参数时, 按key进行排序

>>> sorted({1: 1, 2: 2, 3: 1})
[1, 2, 3]

5. len(obj): 返回对象的长度, 元素的个数

>>> li = [2, 1, 4, 3, 9]
>>> len(li)
5
>>> len({2,2,3,4,4})
3

6. divmod(a,b): 获取商和余数 返回值: (a//b, a%b)

>>> divmod(9, 2)
(4, 1)

7. pow(a,b): 返回a ** b

>>> pow(2, 3)
8

8. round(a,b) : 获取指定位数的小数(四舍五入)。a代表浮点数，b代表要保留的位数

>>> round(3.141592657535, 3)  # 保留三位小数
3.142
>>> round(3.141592657535, 2)  # 保留两位小数
3.14

3.2 类型转换

1. int(x: [float, str]): 将浮点数或整数形式字符串转为整数
   • float: 通过截断小数部分转为整数
   • str: 将字符串转为整数

>>> int(3.12)
3
>>> int("23")
23

2. float(x:[int, str]): 将整数或浮点数形式的字符串转为浮点数

In [1]: float(2)                                                                                  
Out[1]: 2.0

In [2]: float("2.3")                                                                              
Out[2]: 2.3

3. str(x:[int, float, tuple, list]): 将其他类型转为字符串类型

In [3]: str(2)                                                                                    
Out[3]: '2'

In [4]: str(2.3)                                                                                  
Out[4]: '2.3'

In [5]: str([1,2,3])  # 列表和元祖会将其标志符号一起转为字符串, 列表:[,] 元祖: (,)                                                                           
Out[5]: '[1, 2, 3]'

In [6]: str((1,2,3))                                                                              
Out[6]: '(1, 2, 3)'

In [7]: str(3+4j)                                                                                 
Out[7]: '(3+4j)'

4. bool(obj:[int, float, str, list, tuple, set, deict,...]): 将其他类型转为布尔类型

In [9]: bool(0)  # 0--> False                                                                                  
Out[9]: False

In [10]: bool(1)  # !0 --> True                                                                                
Out[10]: True

In [11]: bool("")  # 空字符串, "" --> False                                                                  
Out[11]: False

In [12]: bool("x")  # 非空字符串, "x" --> True                                                        
Out[12]: True

In [13]: bool([])  # 空列表, [] --> False                                                                             
Out[13]: False

In [14]: bool([1,2,3])  # 非空列表, [1,2, 3] --> True                                                          
Out[14]: True

In [15]: bool(())     # 空元祖, () --> False                                              
Out[15]: False

In [16]: bool((1,2,3))  # 非空元祖, (1,2,3) --> True                                                       
Out[16]: True

5. bytes(str,code): 接收一个字符串，与所要编码的格式，返回一个字节流类型

In [19]: bytes("hello", "utf-8")                                                                  
Out[19]: b'hello'

6. list(iterable:[str, tuple, set, dict]): 转换为列表(list)

In [23]: list("hello")                                                                            
Out[23]: ['h', 'e', 'l', 'l', 'o']

In [24]: list((1,2,3))                                                                            
Out[24]: [1, 2, 3]

In [25]: list({1,2,3,3,4,2})                                                                      
Out[25]: [1, 2, 3, 4]

In [26]: list({"name": "dyp", "age": 12})   # 字典只会将键 key 转为列表                                                        
Out[26]: ['name', 'age']

7. tuple(iterable:[str, list, set, dict]): 转为元祖(tuple)

In [27]: tuple("hello")                                                                           
Out[27]: ('h', 'e', 'l', 'l', 'o')

In [28]: tuple([1,2,3])                                                                           
Out[28]: (1, 2, 3)

In [29]: tuple({1,2,3,3, 2,1})                                                                    
Out[29]: (1, 2, 3)

In [30]: tuple({"name": "dyp", "age": 13})                                                        
Out[30]: ('name', 'age')

8. set(iterable:[str, list, tuple, dict]): 转为集合(set)

In [31]: set("hello")                                                                             
Out[31]: {'e', 'h', 'l', 'o'}

In [32]: set([1,2,3,3,2,1])                                                                       
Out[32]: {1, 2, 3}

In [33]: set((1,2,3,3,2,1))                                                                       
Out[33]: {1, 2, 3}

In [34]: set({"name": "dyp", "age": 13})                                                          
Out[34]: {'age', 'name'}

9. dict(obj:[key=value, list, tuple, dict]): 转为字典

In [35]: dict(name="dyp", age=21)                                                                 
Out[35]: {'name': 'dyp', 'age': 21}

In [36]: dict([("name", "dyp"), ("age", 21)])                                                     
Out[36]: {'name': 'dyp', 'age': 21}

In [37]: dict({'name': 'dyp', 'age': 21})                                                         
Out[37]: {'name': 'dyp', 'age': 21}

10. enumerate(iterable): 返回一个枚举对象, 由(index, value)组成

In [38]: enumerate([1,2,3])                                                                       
Out[38]: <enumerate at 0x7f05d13044c8>

In [39]: for k, value in enumerate([1,2,3]): 
    ...:         print(k,value) 
    ...:                                                                                          
0 1
1 2
2 3

11. hex(x:int): 转换为16进制

In [40]: hex(1024)                                                                                
Out[40]: '0x400'

12. oct(int): 转换为8进制

In [41]: oct(98)                                                                                  
Out[41]: '0o142'

13. bin(int): 转换为2进制

In [42]: bin(10)                                                                                  
Out[42]: '0b1010'

14. chr(int): 转换数字为相应ASCI码字符

In [43]: chr(67)                                                                                  
Out[43]: 'C'

15. ord(str): 转换ASCI字符为相应的数字

In [44]: ord("C")                                                                                 
Out[44]: 67

3.3 功能函数

1. eval(str): 将str当python表达式执行

In [49]: eval("print('hello world')")                                                             
hello world

2. exec(): 执行python语句

In [52]: exec("print(1+1)")                                                                       
2

3. map(func, *iterable): 将func用于每个iterable对象

In [53]: fun = lambda x:x%2                                                                       

In [54]: map(fun, [1,2,3,4,5,6,7,8,9,10])                                                         
Out[54]: <map at 0x7f05d0ff23c8>

In [55]: list(map(fun, [1,2,3,4,5,6,7,8,9,10]))                                                   
Out[55]: [1, 0, 1, 0, 1, 0, 1, 0, 1, 0]

4. zip(*iterable): 将iterable分组合并。返回一个zip对象

In [56]: dict(zip(["one", "two", "three"], [1, 2, 3]))                                            
Out[56]: {'one': 1, 'two': 2, 'three': 3}