python 内置、匿名、高阶、递归等函数(3.1)

友儿

发布于 2022-09-28 13:22:26

3120

发布于 2022-09-28 13:22:26

文章被收录于专栏：友儿

重新认识函数

内置函数

认识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))

函数的返回值

返回值的类型

任意类型, 包括函数本身

如何接受返回值

接收单个值

一个变量接受返回的多个值

实际上返回的是个tuple

>>> def foo(a, b):
...     return a*2, b*2
...
>>> result = foo(1, 2)
>>> result
(2, 4)

多个变量按顺序接收

实现原理是元组解包(unpack)

>>> a,b = foo(1,2)
>>> a
2
>>> b
4
# 等同于
>>> result = foo(1,2)
>>> a, b = result

不定长变量接收

>>> result
(1, 2, 3, 4, 5, 6, 7)
>>> a, *b, c = result
>>> a
1
>>> c
7
>>> b
[2, 3, 4, 5, 6]

匿名函数

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

通过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)

本文参与腾讯云自媒体同步曝光计划，分享自作者个人站点/博客。

如有侵权请联系 cloudcommunity@tencent.com 删除

python

编程算法

本文分享自作者个人站点/博客前往查看

如有侵权，请联系 cloudcommunity@tencent.com 删除。

本文参与腾讯云自媒体同步曝光计划，欢迎热爱写作的你一起参与！

python

编程算法

登录后参与评论

0 条评论

热度