python冒泡算法，lambda表达式

========================================================================
冒泡算法 （个人理解类似于IP互换方案方式，或者被老师成为小鱼冒泡泡

）
如何将列表内的数字进行排序呢？
方法1(需要递归)

li =[5,4,3,2,6] #定义一个列表
print li #调试打印出列表
for m in range(4): #通过循环的方式获得一个从0开始的序列，几个数字就写循环几次就好了，这里数字会全比一遍
num1 = li[m] #开始定义数值对比，从前往后开始比，li[m]那就第0个数值，5
num2 = li[m+1] #第一个数字和谁进行对比呢？和第二个，因为是循环那么久li[m+1]，这个数值就是4
if num1 > num2: #开始进行判断了，第一个数5，大于第二个数4吗?
temp = li[m] #5大于4 需要换位置了 大于4的这个5存到临时变量 temp = 5
li[m] = num2 #第一个数原来是5，但判断后就得给它重新定义了它就是4，这一步就是在调换顺序
li[m+1] = temp #第一个重新定义为了4，把第二个位置换成5,5在哪呢？在临时变量里呢，但别绕不过来，咱们for循环了5次呢所以后边的数都会比一下的
print li #再重新看一下列表，临近的两个数换了一下
得到的结果[4, 3, 2, 5, 6] #这个结果就是，但是这个明显没有完活儿啊，需要递归，就是range每次都需要减去1，到1就好

方法2
li = [66,55,33,44,11,77]
for n in range (1,len(li)): #制造出一个循环，从1开始，len总长度结束那例子就是读取从1开始到5刚好，意思就是不读第一个数0位
for m in range(len(li)-n): #循环每次都让它减少一次变成造数5次，造数4次，造数3，递归...
num1 = li[m] #第一个被定义的数字就是0位，66循环走
num2 = li[m+1] #第二个被定义的每次加1，那就是从1位开始，55往下走
if num1 > num2: #开始进行判断了必须条件，第一个数66，大于第二个数55吗?
temp = li[m] #66大于55 需要换位置了 大于55的这个66存到临时变量 temp = 66
li[m] = num2 #第一个数原来是66，但判断后就得给它重新定义了它就是55，这一步就是在调换顺序
li[m+1] = temp #第一个数66，把第二个位置换成66,66在哪呢？在临时变量里呢，但别绕不过来，咱们for循环了5次呢所以后边的数都会比一下的
得到的结果[11, 33, 44, 55, 66, 77]

方法3这个和方法2类似
li = [66,55,22,11,33]
for m in range(len(li)-1): #定义一个循环减去1，就是循环了0123 4个数
for n in range(m+1,len(li)): #循环长度m每次加1到列表长度5
num1 = li[m] #第一个数等于0123 每次的值 但每次会减少一个数字
num2 = li
#第二个数等于1234 每次的值 记住每次会减少一个数字

if num1 > num2: #开始进行判断了必须条件，第一个数66，大于第二个数55吗?
temp = li
#66大于55 需要换位置了 大于55的这个66存到临时变量 temp = 66
li
= li[m] #再次赋值，直接就是第二个数55等于了第一个数值55
li[m] = temp #第一个数66，把第二个位置换成66,66在哪呢？在临时变量里呢，咱们for循环了5次呢所以后边的数都会比一下的
print li
得到的结果[11, 22, 33, 55, 66]
[b]===============================================================[/b]
lambda表达式

在学习条件运算的时候，对于见得if else语句，可以使用我们称之为三木运算或者三元运算来表示：
#1.普通例子
if 100 == 100:
name = 'leyno'
else:
name = 'leyno100'
#2.三元运算
name = 'leyno' if 100 == 100 else 'leyno100'
print name

对于简单的函数来说，也存在着一种简便的表示方式，那就是lambda表达式
#1.定义函数常规普通的方式
def func(leyno):
return leyno + 1 #执行函数使用的是return return是返回数值的意思，当出现return代表着函数生命周期结束
result = func(100)

#2.lambda表达式定义方式 #处理简单逻辑 自动 return
my_lambda = lambda arg : arg + 1 #定义lambda表达式
result = my_lambda(123)
print result

lambda存在的意义在于哪里呢？就是对函数的简洁表示


使用内置函数来演示lambda
1.map
遍历序列，对序列中每个元素进行操作，最终获得新的序列。



#需求给列表内每个数值加10
li = [11,22,33]
new_list = map(lambda a: a+100, li)
print new_list
得到的结果[111, 122, 133]

#需求两个列表内的值相加
li = [11,22,33]
s1 = [1,2,3]
new_list = map(lambda a,b: a + b, li, s1)
print new_list
得到的结果[12, 24, 36]

#lambda加函数需求方式
#复杂格式 对序列中每个元素进行操作，最终获得新的序列。
li = [11,22,33,44]
s1 = [1,2,3,4]
def func3(a,b):
return a + b
new_list = map(func3,li,s1)
print new_list
得到的结果[12, 24, 36, 48]

#简单格式 可以简化步骤 为一行 且自动return
li = [11,22,33,44]
s1 = [1,2,3,4]
print map(lambda a,b: a + b, li, s1)
得到的结果[12, 24, 36, 48]

2.filter
对于序列中的元素进行筛选，最终获取符合条件的序列



#需求filter 对于序列中的元素进行筛选，最终获取符合条件的序列 过滤 获取指定元素集合操作
#多一步操作实现方式
li = [11,22,33,44,55]
new_list = filter(lambda abc: abc>22, li)
print new_list
得到的结果[33, 44, 55]

#简便一步的实现方式
li = [11,22,33,44,55]
print filter(lambda abc: abc>22 ,li )
得到的结果[33, 44, 55]

3.reduce
对序列内的所有元素进行累计操作





#reduce对于序列内所有元素进行累计操作 累积操作
# reduce的第一个参数，函数必须要有两个参数是前提条件
# reduce的第二个参数，要循环的序列 就是2,3,4,5,5,6,7,8
# reduce的第三个参数，初始值为小加号

#需求要求列表内数值相加
#多一步操作实现方式
li = [11,22,33,44]
result = reduce(lambda arge1,arge2:arge1 + arge2,li)
print result
得到的结果 110
#简便一步的实现方式
li = [11,22,33,44]
print reduce(lambda arge1,arge2:arge1 + arge2,li)
得到的结果 110