一、回调函数
- 把一个函数作为参数传给另一个函数，第一个函数称为回调函数
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 数学相关
abs(obj: [int, float, complex]): int float类型的数据返回绝对值, complex类型数据返回模长
>>> abs(-3.2)
3.2
>>> abs(-4)
4
>>> abs(3+4j) # 复数返回复数的模长
5.0
max(iter) min(iter): 返回可迭代对象中的最大值或最小值
>>> li = [3, 4, 5, -8, 9, 8]
>>> max(li)
9
>>> min(li)
-8
sum(iter)求取iter元素的和
>>> sum(range(1,11))
55
- sorted(obj: [list tuple set dict]) : 排序，返回排序后的对象, 返回值是一个列表
dict对象作为参数时, 按key进行排序
>>> sorted({1: 1, 2: 2, 3: 1})
[1, 2, 3]
len(obj): 返回对象的长度, 元素的个数
>>> li = [2, 1, 4, 3, 9]
>>> len(li)
5
>>> len({2,2,3,4,4})
3
divmod(a,b): 获取商和余数 返回值: (a//b, a%b)
>>> divmod(9, 2)
(4, 1)
pow(a,b): 返回a ** b
>>> pow(2, 3)
8
round(a,b): 获取指定位数的小数(四舍五入)。a代表浮点数，b代表要保留的位数
>>> round(3.141592657535, 3) # 保留三位小数
3.142
>>> round(3.141592657535, 2) # 保留两位小数
3.14
3.2 类型转换
int(x: [float, str]): 将浮点数或整数形式字符串转为整数- float: 通过截断小数部分转为整数
- str: 将字符串转为整数
>>> int(3.12)
3
>>> int("23")
23
float(x:[int, str]): 将整数或浮点数形式的字符串转为浮点数
In [1]: float(2)
Out[1]: 2.0
In [2]: float("2.3")
Out[2]: 2.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)'
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
bytes(str,code): 接收一个字符串，与所要编码的格式，返回一个字节流类型
In [19]: bytes("hello", "utf-8")
Out[19]: b'hello'
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']
- 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')
- 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'}
- 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}
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
hex(x:int): 转换为16进制
In [40]: hex(1024)
Out[40]: '0x400'
oct(int): 转换为8进制
In [41]: oct(98)
Out[41]: '0o142'
bin(int): 转换为2进制
In [42]: bin(10)
Out[42]: '0b1010'
chr(int): 转换数字为相应ASCI码字符
In [43]: chr(67)
Out[43]: 'C'
ord(str): 转换ASCI字符为相应的数字
In [44]: ord("C")
Out[44]: 67
3.3 功能函数
- eval(str): 将str当python表达式执行
In [49]: eval("print('hello world')")
hello world
exec(): 执行python语句
In [52]: exec("print(1+1)")
2
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]
zip(*iterable): 将iterable分组合并。返回一个zip对象
In [56]: dict(zip(["one", "two", "three"], [1, 2, 3]))
Out[56]: {'one': 1, 'two': 2, 'three': 3}