递归函数

定义：在调用一个函数的过程中，又直接或间接地调用了该函数本身。

#在调用函数index过程中又调用了index，这就是直接调用函数index本身
	count = 1
	def index():
	    print('from index')
	    global count
	    print(count)
	    count += 1
	    index()
	index()
    
#在调用函数f1的过程中调用了函数f2，而在调用函数f2的过程中又调用了函数f1，这就是间接调用了函数f1本身
	def f1():
	    print('f1')
	    f2()
	def f2():
	    print('f2')
	    f1()
	f1()
	从以上两种情况可以看出，两种情况下的递归调用都是一个无限循环的过程，但python对函数的递归调用的深度做了限制，因次并不会进入无限循环，但会抛出异常，要避免出现这种情况，就必须让递归调用在满足某个特定条件下终止。
     递归深度默认是1000次,递归深度是可以查看和更改的
		import sys
		print(sys.getrecursionlimit())  查看递归深度的次数，默认是1000次
		sys.setrecursionlimit(4)		更改递归深度的次数，括号内数字是几就是几次(不能小于4次)
		print(sys.getrecursionlimit())
练习：
打印出所有的数字
list = [1, [2, [3, [4, [5, [6, [7, [8, [9, [10, ]]]]]]]]]]
def get_num(list):
    for i in list:
        if type(i) is int:
            print(i)
        else:
            get_num(i)
get_num(list)

三元表达式

三元表达式：python提供的一种简化代码的解决方案。
语法：res = 条件成立时返回的值 if 条件 else 条件不成立时返回的值   
	def my_max(a, b):
	    if a > b:
	        return a
	    else:
	        return b
	print(my_max(1, 2))
针对上述只有两种情况的判断，我们可以使用三元表达式
	a = 1
	b = 2
	res = a if a > b else b
	print(res)

#让用户输入：
	name = input('username>>>').strip()
	if name == 'ly':
	     print('帅哥')
	 else:
	     print('dsb')
        
使用三元表达式是：
	res = '帅哥' if name == 'ly' else 'dsb'
	print(res)

算法之二分法

# 什么是算法
	就是解决问题的高效方法
#常见的算法：冒泡算法、二分法、选择排序

二分法
	必须要有序
  

l = [1, 2, 3, 4, 5, 6, 11, 22, 34, 44, 55, 66, 67, 333, 444]
def my_half(target_num, l):
    # 1. 从列表中去一个中间值
    middle_index = len(l) // 2
    # 2. 比较
    if target_num > l[middle_index]:
        # 要找的元素在右边
        l_right = l[middle_index + 1:]
        my_half(target_num, l_right)
        print(l_right)
    elif target_num < l[middle_index]:
        # 要找的元素一定在左边
        l_left = l[:middle_index]
        my_half(target_num, l_left)
        print(l_left)
    else:
        print('找到了，哈哈哈哈')
my_half(34, l)

列表生成式

列表生成式：python提供的一种简化代码的解决方案，用来快速生成列表.
1.给列表的每一个元素后面都加上dsb,l = ['ly', 'jason', 'tom']
	第一种方式：
		l = ['ly', 'jason', 'tom']
		new_list = []
		for i in l:
		    new_list.append(i + 'dsb')
		print(new_list)
	第二种方式：
		l = ['ly', 'jason', 'tom']
		res = [i + 'dsb' for i in l]
		print(res)
2.给列表的每一个元素(jason除外)后面都加上dsb,l = ['ly', 'jason', 'tom']
	第一种方式：
		l = ['ly', 'jason', 'tom']
		new_list = []
		for i in l:
		    if i != 'jason':
		        new_list.append(i + 'dsb')
		    else:
		        new_list.append(i)
		print(new_list)
	第二种方式：
		l = ['ly', 'jason', 'tom']
		res = [i + 'dsb' if i != 'jason' else i for i in l]
		print(res)

字典生成式

1.把列表l1的每一个元素当成字典的k，把列表l2的每一个元素当成字典的value
l1 = ['name', 'age', 'hobby']
l2 = ['ly', 18, 'music']
第一种方式：
	l1 = ['name', 'age', 'hobby']
	l2 = ['ly', 18, 'music']
	new_dict = {}
	for i in range(len(l1)):
	    new_dict[l1[i]] = l2[i]
	print(new_dict)
第二种方式：
	l1 = ['name', 'age', 'hobby']
	l2 = ['ly', 18, 'music']
	res = {l1[i]: l2[i] for i, j in enumerate(l1)}
	print(res)
PS：enumerate的作用是取列表的索引和值
	l1 = ['name', 'age', 'hobby']
	for i, j in enumerate(l1):
		print(i, j)
	结果：
	0 name
	1 age
	2 hobby
    还可以加start参数：
    for i, j in enumerate(l1， start=1): 表示索引从1开始

集合生成式
	res = {l1[i] for i, j in enumerate(l1)}
	print(res)

生成器
	res = (l1[i] for i, j in enumerate(l1))
	print(res)

匿名函数

# 没有名字的函数
'''
	语法格式：
		lambda 参数：返回值
'''
print(lambda x: x ** 2) 	==> 打印出的是匿名函数的内存地址
print((lambda x: x ** 2)(2))  ==> 打印出的是匿名函数的返回值

不会单独使用，结合一些内置函数使用
l = [1, 2, 3, 4, 5, 6]
res=list(map(lambda x:x**3, l))
print(res)