【Python基础】函数的高级用法（内置函数、形参和实参、匿名函数、高阶函数、递归函数、函数的作用域、闭包与global及nonlocal、装饰器）

内置函数

认识Python自带的, 可全局调用的函数, 避免我们命名冲突导致了函数性状发生改变

• 查看Python携带的内置函数

from pprint import pprint
# 格式化输出的库
pprint(dir(__builtins__))

• 常见的内置函数 

str

>>> str(1.0)
'1.0'

int

>>> int(1.0)
1
>>> int("1.0")
Traceback (most recent call last):
  File "<stdin>", line 1, in <module>
ValueError: invalid literal for int() with base 10: '1.0'
>>> int("1")
1

float

>>> float("1.0")
1.0
>>> float(1)
1.0
>>> float('1')
1.0

bytes

>>> bytes('a'.encode("utf-8"))
b'a'

bool

>>> bool(0)
False
>>> bool(1)
True
>>> bool(2)
True
>>> bool('0')
True
>>> bool(0.0)
False

list

只要是序列都可以转换成list

>>> list("qwe")
['q', 'w', 'e']

tuple

>>> tuple("qwe")
('q', 'w', 'e')
>>> tuple([1,2])
(1, 2)

dict

>>> dict(a=1)
{'a': 1}

set

>>> set([1,2,2])
{1, 2}
>>> set("qweqweqwe")
{'q', 'w', 'e'}

id

查看当前对象的内存地址

>>> a = "1"
>>> id(a)
26114944

dir

• 当前对象下的所有方法和属性

• 在Python中一切皆为对象

dir(__builtins__)

max

返回一个序列中的最大值

>>> max([2, 4,67,1])
67

min

返回一个序列中的最小值

>>> min([2, 4,67,1])
1

range

返回一组数字区间的可迭代对象

>>> r = range(100)
>>> r
range(0, 100)

>>> for i in range(10):
...     print(i)

---

函数的形参和实参

形参

形式参数, 简单地说就是还没接受到实际值的参数. 函数未调用时就是形参

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

实参

实际传入的参数, 函数调用时传入的值就叫实参

print(my_power(2, 3))

---

匿名函数

顾名思义匿名函数就是没有名字的函数, 一般都是提供给高阶函数调用。

• 通过lambda关键字来声明匿名函数

>>> lambda x: x **2
# 返回的是一个匿名函数对象
<function <lambda> at 0x018BB660>

函数体是纯表达式

• 不能有复杂的逻辑判断语句

  • 唯一例外的例子:

lambda x: 返回值 if 纯表达式 else 返回值

lambda x: True if  x % 2==0 else False

• 不能有循环语句

• 不能有异常捕获

• 不能有赋值语句

• 不能有return

  • 默认表达式运行的结果就是返回值

>>> lambda x: x **2
#返回值就是 x**2

 例子

l = [[1,2], [2,1], [6,4], [3,5]]
l.sort(key=lambda x: x[1])
print(l)

---

高阶函数

接受函数作为参数, 或者把函数作为结果返回

map(映射)

对一个序列每个元素进行相同的操作, 这个过程就叫映射

>>> l = [1,2,3]
>>> m = map(lambda x: x**2, [1,2,3])

# 获得返回结果是一个map对象
>>> m
<map object at 0x03545C10>
>>> l
[1, 2, 3]

# map对象是一个可迭代对象, 需要驱动可迭代对象返回值, list就有这样的功能. 暂时不要太纠结
>>> list(m)
[1, 4, 9]
>>> l
[1, 2, 3]

等同于以下:

def my_powser_2(a):
	return a ** 2

# 匿名函数只是图方便, 所有的匿名都可以通过正常函数替换
>>> m = map(my_powser_2, [1,2,3])
>>> list(m)
[1, 4, 9]

多用于和math库进行运算操作

>>> m = map(math.sqrt, [1, 4, 9, 16, 25])
>>> list(m)
[1.0, 2.0, 3.0, 4.0, 5.0]

filter(过滤)

filter(函数, 可迭代对象)
函数中的表达式返回结果为False, 就会被过滤

[0, 1, 2, 3, 4, 5, 6, 7, 8, 9]
# 过滤偶数
>>> f = filter(lambda x: x%2, l)
>>> list(f)
[1, 3, 5, 7, 9]

# 过滤奇数
>>> f = filter(lambda x: False if x%2 == 1 else True, l)
>>> list(f)
[0, 2, 4, 6, 8]

---

递归函数

在函数中调用自身的函数就叫递归函数

核心思想

将大的任务拆分为子任务来解决复杂问题, 只要大任务能拆分成子任务, 就可以使用递归

F(n) = F(F(n-1))

声明一个递归函数(阶乘)

• 一定要有退出机制

F(n) = n * F(n-1)

def fact(n):
    if n == 1:
        return 1
    return n * fact(n-1)

---

Everything is going smoothly.