# 教程 | 十分钟学会函数式 Python

```a = 3
def some_func():
global a
a = 5

some_func()
print(a)```

```def factorial_recursive(n):
# Base case: 1! = 1
if n == 1:
return 1

# Recursive case: n! = n * (n-1)!
else:
return n * factorial_recursive(n-1)```

```class Counter:
def __init__(self, low, high):
# set class attributes inside the magic method __init__
# for "inistalise"
self.current = low
self.high = high

def __iter__(self):
# first magic method to make this object iterable
return self

def __next__(self):
# second magic method
if self.current > self.high:
raise StopIteration
else:
self.current += 1
return self.current - 1```

```for c in Counter(3, 8):
print(c)```

```3
4
5
6
7
8```

`map(function, iterable)`

`[1, 2, 3, 4, 5]`

```x = [1, 2, 3, 4, 5]
def square(num):
return num*num

print(list(map(square, x)))```

Python中的函数式函数是懒惰的。如果我们不加“list()”，那么函数只会将可迭代对象保存下来，而不会保存结果的列表。我们需要明确地告诉Python“把它转换成列表”才能得到结果。

Lambda 表达式

Lambda表达式就是只有一行的函数。比如下面这个lambda表达式可以求出给定数字的平方：

`square = lambda x: x * x`

```>>> square(3)
9```

`lambda x:`

```x = [1, 2, 3, 4, 5]
print(list(map(lambda num: num * num, x)))```

`reduce(function, list)`

```product = 1
x = [1, 2, 3, 4]
for num in x:
product = product * num```

```from functools import reduce

product = reduce((lambda x, y: x * y),[1, 2, 3, 4])```

`filter(function, list)`

```x = range(-5, 5)
new_list = []

for num in x:
if num < 0:
new_list.append(num)```

```x = range(-5, 5)
all_less_than_zero = list(filter(lambda num: num < 0, x))```

```def summation(nums):
return sum(nums)

def action(func, numbers):
return func(numbers)

print(action(summation, [1, 2, 3]))

# Output is 6```

```def rtnBrandon():
return "brandon"
def rtnJohn():
return "john"

def rtnPerson():

if age == 21:
return rtnBrandon()
else:
return rtnJohn()```

Python 中的所有函数都是顶级对象。顶级对象是拥有一个或多个以下特征的对象：

• 在运行时生成
• 赋值给某个数据结构中的变量或元素
• 作为参数传递给函数
• 作为函数的结果返回

```def power(base, exponent):
return base ** exponent```

```def square(base):
return power(base, 2)```

```from functools import partial

square = partial(power, exponent=2)
print(square(2))

# output is 4```

```from functools import partial

powers = []
for x in range(2, 1001):
powers.append(partial(power, exponent = x))

print(powers[0](3))
# output is 9```

```>>> import this
The Zen of Python, by Tim Peters
Beautiful is better than ugly.
Explicit is better than implicit.
Simple is better than complex.
Complex is better than complicated.
Flat is better than nested.
Sparse is better than dense.
Special cases aren’t special enough to break the rules.
Although practicality beats purity.
Errors should never pass silently.
Unless explicitly silenced.
In the face of ambiguity, refuse the temptation to guess.
There should be one — and preferably only one — obvious way to do it.
Although that way may not be obvious at first unless you’re Dutch.
Now is better than never.
Although never is often better than *right* now.
If the implementation is hard to explain, it’s a bad idea.
If the implementation is easy to explain, it may be a good idea.
Namespaces are one honking great idea — let’s do more of those!```

There should be one — and preferably only one — obvious way to do it. （任何事情应该有一个且只有一个方法解决。）

```foo = lambda a: 2

def foo(a):
return 2```

`[function for item in iterable]`

`print([x * x for x in [1, 2, 3, 4]])`

```x = range(-5, 5)

all_less_than_zero = list(filter(lambda num: num < 0, x))
print(all_less_than_zero)```

```x = range(-5, 5)

all_less_than_zero = [num for num in x if num < 0]```

```x = range(-5, 5)

all_less_than_zero = list(map(lambda num: num * num, list(filter(lambda num: num < 0, x))))```

```x = range(-5, 5)

all_less_than_zero = [num * num for num in x if num < 0]```

```# Taken from page 70 chapter 3 of Fluent Python by Luciano Ramalho

DIAL_CODES = [
(86, 'China'),
(91, 'India'),
(1, 'United States'),
(62, 'Indonesia'),
(55, 'Brazil'),
(92, 'Pakistan'),
(234, 'Nigeria'),
(7, 'Russia'),
(81, 'Japan'),
]

>>> country_code = {country: code for code, country in DIAL_CODES}
>>> country_code
{'Brazil': 55, 'Indonesia': 62, 'Pakistan': 92, 'Russia': 7, 'China': 86, 'United States': 1, 'Japan': 81, 'India': 91, 'Nigeria': 234, 'Bangladesh': 880}
>>> {code: country.upper() for country, code in country_code.items() if code < 66}
{1: 'UNITED STATES', 7: 'RUSSIA', 62: 'INDONESIA', 55: 'BRAZIL'}```

• 集合是元素的列表，但列表中没有重复的元素
• 元素的顺序不重要
```# taken from page 87, chapter 3 of Fluent Python by Luciano Ramalho

>>> from unicodedata import name
>>> {chr(i) for i in range(32, 256) if 'SIGN' in name(chr(i), '')}
{'×', '¥', '°', '£', '©', '#', '¬', '%', 'µ', '>', '¤', '±', '¶', '§', '<', '=', '®', '\$', '÷', '¢', '+'}```

0 条评论

• ### 码如其人，同学你能写一手漂亮的Python函数吗

在机器学习中，我们经常需要使用类和函数定义模型的各个部分，例如定义读取数据的函数、预处理数据的函数、模型架构和训练过程的函数等等。那么什么样的函数才是漂亮的、赏...

• ### 如何在一场面试中展现你对Python的coding能力？

如果你已经通过了招聘人员的电话面试，那么下面正是该展现你代码能力的时候了。无论是练习，作业，还是现场白板面试，这都是你证明自己的代码技巧的时刻。

• ### 总结100个Pandas中序列的实用函数

经过一段时间的整理，本期将分享我认为比较常规的100个实用函数，这些函数大致可以分为六类，分别是统计汇总函数、数据清洗函数、数据筛选、绘图与元素级运算函数、时间...

• ### 教程 | 十分钟学会函数式 Python

函数式编程到底是什么？本文将详解其概念，同时分享怎样在 Python 中使用函数式编程。主要内容包括列表解析式和其他形式的解析式。

• ### 教程 | 十分钟学会函数式 Python

导读：函数式编程到底是什么？本文将详解其概念，同时分享怎样在 Python 中使用函数式编程。主要内容包括列表解析式和其他形式的解析式。

• ### 第5章 函数与函数式编程第5章 函数与函数式编程

函数式编程语言最重要的基础是λ演算（lambda calculus），而且λ演算的函数可以传入函数参数，也可以返回一个函数。函数式编程 (简称FP) 是一种编程...

• ### 10分钟快速入门Python函数式编程

本文，你会了解到什么是函数式编程，以及如何用 Python 进行函数式编程。你还会了解到列表解析和其他形式的解析。

• ### JavaScript-立即调用函数表达式（IIFE）

（2）【注意】JavaScript引擎规定，如果function关键字出现在行首，一律解释成函数声明语句

• ### 带你了解python 匿名函数 lambda

打印看一下，显示都是函数，一个是叫sum的函数，另外一个就是lambda的匿名函数。

• ### 关于函数式编程

函数是Python内建支持的一种封装，通过把大段代码拆成函数，再一层一层的调用函数，就可把复杂任务分解成简单的任务 这种分解可以称之为面向过程的程序设计 函数就...