Python小白的进阶之路---序列、lambda、递归

参考链接：
https://study.163.com/course/courseLearn.htm?courseId=378003#/learn/video?lessonId=658090&courseId=378003

1. 序列

1.1 序列的定义

  在之前的学习中，列表、元祖和字符串是在一起学习的，因为他们有很多共同点：

• 都可以根据索引得到每一个元素
• 默认索引值总是从0开始
• 可以通过分片的方法的得到一个范围内的元素的集合
• 有很多共同的操作符（重复操作符、拼接操作符、成员关系操作符）

我们把它们统称为序列！

1.2 序列的常用BIF

（1）list()：把一个可迭代对象转换为列表

>>> a=list()
>>> a
[]
>>>
>>> b=('YOU ARE THE BEST')
>>> b=list('YOU ARE THE BEST')
>>> b
['Y', 'O', 'U', ' ', 'A', 'R', 'E', ' ', 'T', 'H', 'E', ' ', 'B', 'E', 'S', 'T']
>>> 
>>> c=list((1,2,3,4,5)) #把元祖里的每个元素放入列表中
>>> c
[1, 2, 3, 4, 5]
>>> 
>>> d=list([1,2,3,4,5])
>>> d
[1, 2, 3, 4, 5]

（2）tuple() ：把一个可迭代的对象转换为元祖

（3）str(obj)： 把obj对象转换为字符串

（4）len(sub)：返回sub参数的长度

>>> str1='you are the best'
>>> len(str1)
16

（5）max()：返回序列或者参数集合中的最大值，也就是说，max()的参数可以是一个序列，返回值是该序列的最大值;也可以是多个参数，那么返回的将是这些参数中最大的一个。

>>> str1='you are the best'
>>> len(str1)
16
>>> max(str1)
'y'
>>> str2='a'
>>> max(str1,str2)
'you are the best'

（6）min()：用法和max()一样，但效果相反，返回序列或参数集合的最小值。使用max()和min()方法都要保证序列或参数的数据类型统一，否则会出错。

（7）sum(iterable[,start])：用于返回序列iterable的总和，另外sum有一个可选参数，如果设置该参数，表示从该参数开始加起，默认值是0。

>>> tuple1=1,2,3,4,5
>>> sum(tuple1,20)
35

（8）sorted()：列表的内建方法sort()是实现列表原地排序；而sorted()是返回一个排序后的新列表。

>>> list1=(1,5,-3,0,8,6)
>>> list2=list1
>>> sorted(list2)
[-3, 0, 1, 5, 6, 8]
>>> list1
(1, 5, -3, 0, 8, 6)
>>> list2
(1, 5, -3, 0, 8, 6)

（9）reversed()：返回一个翻转后的迭代器对象。它不是返回一个列表，是返回一个迭代器对象。

>>> list1=(1,5,-3,0,8,6)
>>> reversed(list1)

>>> for each in reversed(list1):
	print(each,end=',')

6,8,0,-3,5,1,

（10）enumerate()：生成由二元组（二元组就是元素数量为二的元祖）构成的一个迭代对象，每个二元组是由可迭代参数的索引号及其对应的元素组成的。

>>> str1='persistance'
>>> for each in enumerate(str1):
	print(each)

	
(0, 'p')
(1, 'e')
(2, 'r')
(3, 's')
(4, 'i')
(5, 's')
(6, 't')
(7, 'a')
(8, 'n')
(9, 'c')
(10, 'e')
>>> 

（11）zip()：用于返回由各个可迭代参数共同组成的元祖。

>>> list1=[1,3,4,7,8]
>>> str1='lovej'
>>> tuple1=(2,3,4,5,6)
>>> for each in zip(list1,str1,tuple1):
	print(each)

	
(1, 'l', 2)
(3, 'o', 3)
(4, 'v', 4)
(7, 'e', 5)
(8, 'j', 6)

2.lambda 表达式

2.1lambda表达式简介

>>> def un(x):
	return 2*x+1

>>> un(10)
21
>>> g=lambda x:2*x+1
>>> g(10)
21
>>> g=lambda x,y:x*y
>>> g(4,5)
20

  lambda表达式基本语法是在冒号（:）左边放原函数的参数，可以有多个参数。用逗号隔开即可；冒号右边是返回值。lambda语句实际上是返回一个函数对象，如果要对它进行使用，只需要进行简单的赋值操作即可。

2.2两个BIF：filter()和map()

（1）filter()
  这个内建函数是一个过滤器。filter有两个参数。如果第一个参数是函数的话，则将第二个可迭代数据里的每一个元素作为函数的参数进行计算，并把返回True的值筛选出来；如果第一个参数是None，则直接将第二个参数中为True的值筛选出来。

>>> a=list(filter(None,[1,0,False,True]))
>>>> a
[1, True]

>>> def odd(x):
	return x%2      #%求余数，偶数余2全为0，奇数余2全为1

>>> b=list(filter(odd,range(10)))
>>> b
[1, 3, 5, 7, 9]

>>> list(filter(lambda x:x%2,range(10)))
[1, 3, 5, 7, 9]

（2）map()
  在编程领域，map一般作为“映射”来解释。map也有两个参数，仍是一个可迭代序列，将序列的每一个元素作为函数的参数进行运算加工，直到可迭代序列每个元素都加工完毕。

>>> list(map(lambda x:x+2,range(10)))
[2, 3, 4, 5, 6, 7, 8, 9, 10, 11]

3.递归

普通函数求阶层：

nmu=int(input('请输入一个数字: '))
def abc(x):
    b=x
    for n in range(1,x): #1到x-1，也就是不包括x本身
        b=b*n
    return b

result=abc(nmu)
print('%d 的阶层是：%d'%(nmu,result))

用递归求阶层：

nmu=int(input('请输入一个数字: '))
def abc(x):
    if x==1:
        return 1
    else:
        return x*abc(x-1)

result=abc(nmu)
print('%d 的阶层是：%d'%(nmu,result))

递归的两个条件：
（1）调用函数本身
（2）设置了正确的返回条件