标签：index 递归函数 res 生成式 list 二分法 l1 print ly

递归函数

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

#在调用函数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)

标签：index,递归函数,res,生成式,list,二分法,l1,print,ly
来源： https://www.cnblogs.com/blog-tc/p/15789265.html

本站声明： 1. iCode9 技术分享网（下文简称本站）提供的所有内容，仅供技术学习、探讨和分享；
2. 关于本站的所有留言、评论、转载及引用，纯属内容发起人的个人观点，与本站观点和立场无关；
3. 关于本站的所有言论和文字，纯属内容发起人的个人观点，与本站观点和立场无关；
4. 本站文章均是网友提供，不完全保证技术分享内容的完整性、准确性、时效性、风险性和版权归属；如您发现该文章侵犯了您的权益，可联系我们第一时间进行删除；
5. 本站为非盈利性的个人网站，所有内容不会用来进行牟利，也不会利用任何形式的广告来间接获益，纯粹是为了广大技术爱好者提供技术内容和技术思想的分享性交流网站。