python笔记day4

5544992

　　冒泡算法
　　方法一：
　　循环次数+一次循环比较的次数=列表长度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 > li[i+1]:　　tmp = li
　　li = 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']
　　分析：

• 　　黄色部分的line.strip()是为了去掉backend最后一行的空行
  
• 　　黄色部分的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()
　　
result
　　

　　
func2 = 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']