【Python 递归哈数&内置函数 07】

一、 递归函数 -->自己调用自己

def wahaha():
    print('wahaha')
    wahaha()
wahaha()
# 官网规定的递归的最大次数是1000次

#案例

# l=[1,2,3,4,[5,6,7,8[9,10,11,12]]]  求这个列表中所有元素的和
l=[1,2,3,4,[5,6,7,8,[9,10,11,12]]]
sum_n=0
def sum_clac(lst):
    global sum_n
    for i in lst:
        if type(i) is list:
            sum_clac(i)
        elif type(i) is int or type(i) is float:
            sum_n += i
    return sum_n
ret=sum_clac(l)
print(ret)  #78

二、内置函数

1、eval函数 -->把字符串的组成的内容当做Python的代码来执行，并返回值

2、exec函数 -->把字符串的组成的内容当做Python的代码来执行，没有返回值

a = input('>>>>') #输入：1+2
print(a) #1+2
print(eval(a)) #3
print(exec(a)) #None

3、callable 名字后面可以加()才可以被调用

   --->dir查看一个函数可以调用那些方法

a =1
print(callable(a)) #False

b = lambda :1
print(callable(b)) #True

4、print

print(1,2) #1 2 #默认已空格进行的分隔
print(1,2,end='*') #1 2*  -->end是已什么结尾的,默认已换行符（\n）进行的换行，可以用end自定义自己所需要的结尾方式
print(1,2,sep=',') #1,2 -->sep已什么分隔的

5、99乘法表

#99乘法表
for i in range(1,10):
    for j in range(1,i+1):
        print('%d*%d=%d'%(i,j,i*j),end=' ')

    print('')

6、和数字相关的函数

ret = divmod(10,3) #divmod返回（除，余）
print(ret) #(3, 1)

ret1 = round(1.2345,2) #round小数取几位
print(ret1) #1.23

ret2 = pow(2,3) #2的3次方，叫幂
print(ret2) #8
#2的3次方还可以这么写
print(2**3)

# 字典里面的数求和
dic = {'a':50,'b':100}
ret3=sum(dic[k] for k in dic) #这里面用到了生成器函数
print(ret3) #150

7、字符相关的内置函数

 常用ord,chr,repr

1）ord把十进制的转换成16进制，chr刚好相反把16进制转换成10进制

print(ord('a')) #97
print(chr(97)) #a

有什么用 --验证码收到的随机数（数字能随机，但是字符是不能随机的，想要字符随机怎么办？把数字组合后然后用chr转换）

2）repr 打印某个变量值的时候更便于区分类型

print(repr('123'))
print(repr(123))
print(123)
print('123')

执行结果：
'123'
123
123
123
常规打印的时候是区分不出来字符串还是int类型的数字，为了区分可以用repr修饰

3）reverse()  反转，类似于[::-1] 专门给list用的

　 reversed() 是一个内置函数，也是反转，但是不会改变list，返回的是一个迭代器

l = [1,3,6,2]
l.reverse()
print(l) #[2, 6, 3, 1]

ret = reversed(l)
print(ret) #<list_reverseiterator object at 0x103ce8f70>
print(l) #[1, 3, 6, 2] 不会改变list
for i in ret:
    print(i,end=' ') #2 6 3 1

从上面两个执行的结果可以看出来，reversed()确实不会改变list本身，他的返回结果是一个迭代器，而reverse()的确是会改变list列表本身的

8、filter、map都是一个返回值为迭代器的函数   --》filter和map的意思就是循环迭代里面的每一个值（比如下面的题：循环迭代lst里面的每一个值 ）

lst = [1,2,3,4,5,6,7,8,9,10]
ret1 = filter(lambda n:n%3==0,lst)
print(ret1) #<filter object at 0x100adefa0>
print(ret1.__next__()) #3

ret2 = map(lambda n:n*2,lst)
print(ret2) #<map object at 0x100adee80>
print(ret2.__next__()) #2

9、zip拉链

a = [1,2,3,4,5]
b = ['a','b','c','d']
ret = zip(a,b)
for i in ret:
    print(i)

#执行结果：
(1, 'a')
(2, 'b')
(3, 'c')
(4, 'd')

把两个列表组合在一起，组合的元素的个数必须是相同的

a = [1,2,3,4,5]
b = ['a','b','c','d']
c= ['换手率','涨跌幅']
ret = zip(a,b,c)
for i in ret:
    print(i)

#执行结果：
(1, 'a', '换手率')
(2, 'b', '涨跌幅')

从上面两个例子可以看出来，zip是可以组合列表的，但是组合时被组合的列表都是需要相同的元素

# 练习题
现有两个元组(('a'),('b')),(('c'),('d'))，
请使用python中匿名函数生成列表[{'a':'c'},{'b':'d'}]

tup1 = (('a'),('b'))
tup2 = (('c'),('d'))
tup3 = zip(tup1,tup2)
iter = map(lambda tu:{tu[0]:tu[1]},tup3)
iter = map(lambda tu:tu,tup3) #[('a', 'c'), ('b', 'd')]  -->得到一个tu,返回一个tu
print(list(iter))
''' map循环ret里面每一个值，每一个值都是一个k,v
得到一个tu，返回一个字典{tu[0]:tu[1]},这样会生成一个iterator  '''

匿名函数lambda 常和map、filter、sorted、min、max拼接使用

10、min，max

ret1 = min(1,2,3,4,5)
print(ret1) #1
ret2 = min([1,2,3,-4,5],key=abs)
# abs是取绝对值的意思
print(ret2) #1
ret3 = min([1,2,3,-4,5],key=lambda n:n%2)
# lambda n:n%2 ==> 得到一个n，然后返回n除以2取余的数
# min([1,2,3,-4,5],key=lambda n:n%2) 取余最小的数
print(ret3) #2

max和min一样的用法

11、排序 sorted  -->从小到大排序

l = [23,-45,43,-66,11,-22]
ret = sorted(l)
print(ret) #[-66, -45, -22, 11, 23, 43]
ret1 = sorted(l,reverse=True,key=lambda n:n%10)
print(ret1) #[-22, -45, -66, 23, 43, 11]

#reverse 列表反转