冒泡算法

方法一：

循环次数+一次循环比较的次数=列表长度len(L)-1

使用两层for循环，第一层循环控制循环次数，第二层循环控制比较次数，两次循环之间有关联

#!/usr/bin/env python# -*- coding:utf-8 -*-li = [99,22,11,6,3]for n in range(1,len(li)-1):  --->循环次数    for i in range(len(li)-n):   --->一次循环中比较次数        if li[i] > li[i+1]:            tmp = li[i]            li[i] = li[i+1]            li[i+1] = tmpprint li

方法二：

逻辑上分成两个列表，一个从第一个元素到倒数第二个元素，一个从第二个元素到最后一个元素

两个列表相同索引的两个元素比较，比较到最后也能排序成功

L = [88,33,99,66,22,33,77]L1 = [88,33,99,66,22,33] L2 = [33,99,66,22,33,77]

#!/usr/bin/env python
# -*- coding:utf-8 -*-L = [,,,,,,]m ((L)-):n (m+,(L)):L[m] > L[n]:tmp = L[m]L[m] = L[n]L[n] = tmp
L

排序在开发中用的很多，主要用在按照时间排序，按照字母排序等场合。

但是冒泡排序的效率不高，因为用到了两次for循环和若干次值的替换。

haproxy配置文件查询函数，将对应的backend后的内容取出

haproxy.txt配置文件：

frontend carrick.org

bind 0.0.0.0:80

option httplog

option httpclose

option forwardfor

log global

acl www hdr_reg(host) -i www.carrick.org

use_backend www.carrick.org if www

backend www.carrick.org

server 100.1.7.9 100.1.7.9 weight 20 maxconn 3000

server 100.1.7.10 100.1.7.10 weight 20 maxconn 3000

# backend buy.carrick.org

server 100.1.7.9 100.1.7.9 weight 20 maxconn 3001

server 100.1.7.9 100.1.7.9 weight 20 maxconn 3001

backend buy.carrick.org

server 100.1.7.9 100.1.7.9 weight 20 maxconn 3002

server 100.1.7.9 100.1.7.9 weight 20 maxconn 3002

# backend buy.carrick.org

server 100.1.7.9 100.1.7.9 weight 20 maxconn 3003

server 100.1.7.9 100.1.7.9 weight 20 maxconn 3003

backend show carrick.org

server 100.1.7.9 100.1.7.9 weight 20 maxconn 3000

代码：

fetch.py

fetch(backend):flag = fetch_list = [](,) obj:line obj:line.strip().startswith(% backend):flag = flag :fetch_list.append(line.strip())flag line.strip().strip().strip().startswith():= (fetch_list)
result = fetch()
result

运行结果：

['server 100.1.7.9 100.1.7.9 weight 20 maxconn 3002', 'server 100.1.7.9 100.1.7.9 weight 20 maxconn 3002']

分析：

1. ×××部分的line.strip()是为了去掉backend最后一行的空行

2. ×××部分的not line.strip().startswith("#")是为了不将第二个# backend的内容追加进来

如果第二个if和第三个if换顺序，就不需要加×××部分的not line.strip().startswith("#")，因为这样会在插入第二个# backend之前将整个循环结束掉

3. 学会使用单if语句，学会使用flag加标志位，学会使用continue跳出本次for循环，也就是跳到了下一行，学会使用break跳出整个for循环

4. strip()可以去掉行结尾的空格，可以去掉空行，也可以去掉回车\n，如果写成strip('#')，也可以去掉开头的#，但是无法去掉开头的空格，也无法去掉两个字符串中间的空格

5. flag是为了判断行是否可以取到fetch_list列表中

haproxy配置文件添加函数，添加配置文件

流程图：

代码：

注意：

python必须先定义函数，然后在调用函数。如果调用函数在定义函数之前，就会报错。

JAVA和C#可以先调用函数，再定义函数

简化的if else ==>三元运算

简化的函数定义 ==> lambda表达式

def func(arg):

return arg + 1

等价于

func = lambda arg: arg + 1

func1(arg):arg + result = func1()
resultfunc2 = a : a + result = func2()
result

执行结果：

101

1001

lambda函数只用于处理简单的函数，会自动执行return

lambda表达式也可以接动态参数

func3 = lambda a,**kwargs : xxx

map函数

用于对序列（元组，列表）统一进行操作

两个参数的情况：

li = [33,55,77]
def func(a):
    return a + 10
new_li = map(func,li)
print new_li

执行结果：

[43, 65, 87]

多个参数的情况：

li1 = [33,55,77]
li2 = [4,5,6]
def func(a1,a2):
    return a1 + a2
new_li = map(func,li1,li2)
print new_li

执行结果：

[37, 60, 83]

列表个数不一致的情况：

li1 = [33,55,77]
li2 = [4,5,6]
li3 = [1,2]
def func(a1,a2,a3):
    ifnot a3:   --->a3默认为none，在函数体内给a3做个判断，如果a3为none，给a3复制为123，这样就可以不报错的执行了
        a3 = 123
    return a1 +a2 + a3
new_li = map(func,li1,li2,li3)
print new_li

执行结果：

[38, 62, 206]

用lambda表达式的写法：

li1 = [33,55,77]
li2 = [4,5,6]
li3 = [1,2,3]
def func(a1,a2,a3):
    return a1 +a2 + a3
print map(lambda a1,a2,a3:a1 + a2 + a3,li1,li2,li3)

执行结果：

[38, 62, 86]

filter函数

filter函数会对序列（元组，列表）进行处理，只有返回值为True的才会放到新列表中

filter(None,)  --->只过滤出bool值为真的元素

代码：

li = [33,55,'','Carrick',0,False] --->空字符串，0，False的布尔值都为假，因此被过滤掉了
print filter(None,li)

执行结果：

[33, 55, 'Carrick']

filter(func,)  --->通过函数来判断哪些会被过滤掉

li = [33,55,44,'Carrick',0,False]
print filter(lambda a:a > 33,li)

执行结果:

[55, 44, 'Carrick']

返回值为真的，才会被过滤出来。44,55都大于33，因此返回值为真，非空字符串Carrick也大于33，因此都被过滤出来

相当于如下的代码：

li = [33,44,55,'Carrick',0,False]
def func(a):
    if a >33:
        return a
result = filter(func,li)
print result

执行结果:

[55, 44, 'Carrick']