1.python基础要点（三）_x,y in ((1,2),(2,3),(0,-1))-优快云博客

注：本文主要转载自廖雪峰的python教程,部分内容由自己编写。

一、函数

（1）递归函数

定义：如果一个函数在内部调用自身本身，这个函数就是递归函数。

在函数内部，可以调用其他函数。如果一个函数在内部调用自身本身，这个函数就是递归函数。

举个例子，我们来计算阶乘n! = 1 x 2 x 3 x ... x n，用函数fact(n)表示，可以看出：

fact(n) = n! = 1 x 2 x 3 x ... x (n-1) x n = (n-1)! x n = fact(n-1) x n

所以，fact(n)可以表示为n x fact(n-1)，只有n=1时需要特殊处理。

于是，fact(n)用递归的方式写出来就是：

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

递归函数的优点是定义简单，逻辑清晰。理论上，所有的递归函数都可以写成循环的方式，但循环的逻辑不如递归清晰。

使用递归函数需要注意防止栈溢出。在计算机中，函数调用是通过栈（stack）这种数据结构实现的，每当进入一个函数调用，栈就会加一层栈帧，每当函数返回，栈就会减一层栈帧。由于栈的大小不是无限的，所以，递归调用的次数过多，会导致栈溢出。

二、高级特性

1、切片

L[1:3]

L[:3]

L[-2:-1]

以上均不取最后的索引值。

L[-2:]

以上取最后的索引值。

实操：

切片操作十分有用。我们先创建一个0-99的数列：

>>> L = list(range(100))
>>> L
[0, 1, 2, 3, ..., 99]

可以通过切片轻松取出某一段数列。比如前10个数：

>>> L[:10]
[0, 1, 2, 3, 4, 5, 6, 7, 8, 9]

后10个数：

>>> L[-10:]
[90, 91, 92, 93, 94, 95, 96, 97, 98, 99]

前11-20个数：

>>> L[10:20]
[10, 11, 12, 13, 14, 15, 16, 17, 18, 19]

后第2-第11个数：L[-11:-1]

前10个数，每两个取一个：

>>> L[:10:2]
[0, 2, 4, 6, 8]

所有数，每5个取一个：

>>> L[::5]
[0, 5, 10, 15, 20, 25, 30, 35, 40, 45, 50, 55, 60, 65, 70, 75, 80, 85, 90, 95]

甚至什么都不写，只写[:]就可以原样复制一个list：

>>> L[:]
[0, 1, 2, 3, ..., 99]

tuple也是一种list，唯一区别是tuple不可变。因此，tuple也可以用切片操作，只是操作的结果仍是tuple：

>>> (0, 1, 2, 3, 4, 5)[:3]
(0, 1, 2)

字符串'xxx'也可以看成是一种list，每个元素就是一个字符。因此，字符串也可以用切片操作，只是操作结果仍是字符串：

>>> 'ABCDEFG'[:3]
'ABC'
>>> 'ABCDEFG'[::2]
'ACEG'

2、迭代

只要作用于一个可迭代对象，for循环就可以正常运行，而我们不太关心该对象究竟是list还是其他数据类型。

迭代：for ... in ...

可迭代对象（不一定要有下标）：list、turple、dict、字符串

对于dict来说，默认情况下迭代的是key值。如果想迭代的是value值，可以使用【for value in d.values():】。如果要同时迭代key和value值，则要【for key,value in d.items():】

>>> d = {'a': 1, 'b': 2, 'c': 3}
>>> for key in d:
...     print(key)
...
a
c
b

由于字符串也是可迭代对象，因此，也可以作用于for循环：

>>> for ch in 'ABC':
...     print(ch)
...
A
B
C

检测对象是否可迭代的办法：

 from collections import Iterable
>>> isinstance('abc', Iterable) # str是否可迭代
True
>>> isinstance([1,2,3], Iterable) # list是否可迭代，还可检验元组：isinstance((1,2,3),Iterable)---True
True
>>> isinstance(123, Iterable) # 整数是否可迭代
False

用 enumerate函数来迭代list的i和value值

>>> for i, value in enumerate(['A', 'B', 'C']):
...     print(i, value)
...
0 A
1 B
2 C

上面的for循环里，同时引用了两个变量，在Python里是很常见的。

如：

 for x, y in [(1, 1), (2, 4), (3, 9)]:
...     print(x, y)
...
1 1
2 4
3 9

3、列表生成式

列表生成式：单层循环，双层循环，条件过滤

L1 = ['Hello','World',18,'Apple',None]L2 = ???

期待输出: ['hello','world','apple']

代码：

In [46]:L1 = ['Hello','World',18,'Apple',None]

In [47]:L2 = [s for s in L1 if isinstance(s,str)]

In [48]: print (L2)['Hello','World','Apple']

疑惑：

字典是否可以有生成式？

4、生成器（generator）

一边循环一边计算的叫生成器。

类型：list生成器【用（）代替[]的列表生成式格式便可生成】、yield函数形式

5、迭代器

可用于for循环（list，turple，dict，s，生成器等）的都是Iterable

可用于next（）函数并不断返回下一个值的是Iterator

但Iterable可通过调用Iter（）函数来获得一个Iterator

6、高阶函数（函数式编程）

（1）lambda：

格式：

lambda 参数：返回值

eg：f=lambda x:x+2

适用场景：可用于定义简单函数，提高效率

（2）map/reduce

map示例：

>>> list(map(str, [1, 2, 3, 4, 5, 6, 7, 8, 9]))
['1', '2', '3', '4', '5', '6', '7', '8', '9']

>>> b=list(map(lambda x:x+2,a))  #其中，a=[1,2,3]

reduce ：用于递归计算。（适用reduce函数须从functools库中调用）

PS:最后的调用是

再看reduce的用法。reduce把一个函数作用在一个序列[x1, x2, x3, ...]上，这个函数必须接收两个参数，reduce把结果继续和序列的下一个元素做累积计算，其效果就是：

reduce(f, [x1, x2, x3, x4]) = f(f(f(x1, x2), x3), x4)

示例 1/2：比方说对一个序列求和，就可以用reduce实现：

>>> from functools import reduce
>>> def add(x, y):
...     return x + y
...
>>> reduce(add, [1, 3, 5, 7, 9])
25

from functools import reduce

def char2num(s):
    return {'0': 0, '1': 1, '2': 2, '3': 3, '4': 4, '5': 5, '6': 6, '7': 7, '8': 8, '9': 9}[s]

def str2int(s):
    return reduce(lambda x, y: x * 10 + y, map(char2num, s))     #将字符串形式变为整数形式