**========================================================================**
**Bubble Algorithm (personal understanding is similar to the IP interchange scheme, or the teacher becomes a small fish bubble bubble**
**)**
**How do I sort the numbers in a list? **
**Method 1 (recursion required)**Li =[5,4,3,2,6] #定义一个列表Print Li #调试打印出列表For m in range (4): #通过循环的方式获得一个从0开始的序列, a few numbers will be written a few times, and

**here the numbers are all over again** .NUM1 = li[m] #开始定义数值对比, starting from After, Li[m] that's the No. 0 value, 5 .num2 = li[m+1] #第一个数字和谁进行对比呢? And the second one, because it's a cycle so long li[m+1], this value is 4if NUM1 > num2: #开始进行判断了, first number 5, greater than the second number 4 ?temp = li[m] #5大于4 need to change position more than 4 of this 5 save to temp variable temp = 5 Li[m] = num2 #第一个数原来是5, but after judging it to redefine it is 4, this step is in the order of Exchangeli[m+1] = temp #

**First redefined in order to 4, where is the second position replaced by 5,5? In a temporary variable, but don't go around, we're going to loop it 5 times, so the number behind will be a little bit more** .Print Li #再重新看一下列表, the nearest two numbers for a change

**results obtained [4, 3, 2, 5, 6] **#这个结果就是,

**but this is obviously not the end of the job, need recursion, that is, the range will need to subtract 1 per 1** .

** **
**Method 2**Li = [66,55,33,44,11,77]for N in Range (1,len (LI)):

**#制造出一个循环, starting from 1, Len total length of the example is read from 1 to 5 exactly, meaning to not read the first number 0 bits**For M in range (Len (LI)-N):

**#循环每次都让它减少一次变成造数5次, build several 4 times, build number 3, recursion ...**NUM1 = Li[m] #第一个被定义的数字就是0位, 66 cycles away num2 = li[m+1] #第二个被定义的每次加1, that is, starting from 1 bits, 55 down. If NUM1 > num2: #开始进行判断了必须条件, first number 66, greater than the second number 55? temp = Li[m] #66大于55 need to change position more than 55 of this 66 save to temp variable temp = li[m] = num2 #第一个数原来是66, but after judging It's going to have to be redefined. It is 55, this step is in the Exchange order li[m+1] = temp #

**The ****first number 66, change the second position to 66,66 where? In a temporary variable, but don't go around, we're going to loop it 5 times, so the number behind will be a little bit more** .
**results obtained [one, ** one, one, one, one, one, one, one]
**Method 3 This is similar to Method 2**li = [66,55,22,11,33]For m in range (Len (LI)-1): #定义一个循环减去1, that is, 0123 4 numbers are cycledFor N in range (M+1,len (LI)): #循环长度m每次加1到列表长度5NUM1 = li[m] #第一个数等于0123 Each value but decreases one number at a timenum2 = li[n] #第二个数等于1234 value each time remember to reduce a number each time

if NUM1 > num2: #开始进行判断了必须条件, first number 66, greater than the second number 55 ?temp = li[n]

**#66大于55 need to change position more than 55 of this 66 save to temp variable temp =** Li[n] = li[m]

**#再次赋值, is directly the second number 55 equals the first value** Li[m] = temp #

**First number 66, change the second position to 66,66 where? In the temporary variable, we have a For loop 5 times, so the number behind will be a bit more** Print Li

**results obtained [one, ** one, one, one, and one]
** ****===============================================================**
**lambda expression** When learning the condition operation, for the seen if Else statement, you can use what we call a tri-wood operation or ternary operation to represent:

**#1. General examples**if = =:name = ' Leyno 'Else:name = ' leyno100 '

**#2. Ternary operations**name = ' Leyno ' if + = ' leyno100 'Print name

**for simple functions, there is also a simple representation of the lambda expression**
**#1. General normal way to define functions**def func (leyno):return Leyno + 1

**#执行函数使用的是return return is the meaning of the returned value, when a return appears representing the end of the function life cycle** result = Func (+)

** **
**#2. How lambda expressions are defined**#处理简单逻辑 Auto ReturnMy_lambda = lambda Arg:arg + 1 #定义lambda表达式result = MY_LAMBDA (123)Print ResultWhat is the point of lambda existence? is the concise representation of the function.

**use built-in functions to demonstrate lambda**
**1.map**Iterates through the sequence, operates on each element of the sequence, and finally obtains a new sequence.#需求给列表内每个数值加10Li = [11,22,33]new_list = map (lambda a:a+100, li) print new_list

**results obtained [111, 122, 133] **
** **#需求两个列表内的值相加Li = [11,22,33]S1 = [1,2,3]new_list = map (lambda a,b:a + B, Li, s1) print New_list

**results obtained [[in] **
** **#lambda加函数需求方式The #复杂格式 operates on each element of the sequence and eventually obtains a new sequence. Li = [11,22,33,44]S1 = [1,2,3,4]def func3 (A, B): return a + bnew_list = map (func3,li,s1) Print new_list

**results obtained [[in] **
** **#简单格式can simplify the steps to a single line and return automatically Li = [11,22,33,44]S1 = [1,2,3,4]print map (Lambda a,b:a + B, Li, S1)

**results obtained [[in] **
** **
**2.filter**Filter the elements in a sequence, and finally get a sequence that matches the criteria#需求filter Filter The elements in the sequence, and finally get the qualifying sequence filter gets the specified element collection operation#多一步操作实现方式Li = [11,22,33,44,55]new_list = filter (lambda abc:abc>22, li) print new_list

**results obtained [from] **
** **#简便一步的实现方式Li = [11,22,33,44,55]print filter (Lambda abc:abc>22, Li)

**results obtained [from] **
** **
**3.reduce**To accumulate all elements within a sequence #reduce对于序列内所有元素进行累计操作 cumulative action # The first parameter of reduce, the function must have two parameters is a precondition # reduce the second argument, the sequence to loop is 2,3,4,5,5,6,7,8# The third parameter of reduce, the initial value is the small plus sign#需求要求列表内数值相加#多一步操作实现方式Li = [11,22,33,44]result = reduce (lambda arge1,arge2:arge1 + arge2,li) Print result

**the results obtained **#简便一步的实现方式Li = [11,22,33,44]print reduce (lambda arge1,arge2:arge1 + arge2,li)

**the results obtained **
Python bubbling algorithm, lambda expression