九 函数

什么是函数？
为什么要用函数？
函数的分类：内置函数与自定义函数
如何自定义函数
  语法
  定义有参数函数，及有参函数的应用场景
  定义无参数函数，及无参函数的应用场景
  定义空函数，及空函数的应用场景
调用函数
    如何调用函数
    函数的返回值
    函数参数的应用：形参和实参，位置参数，关键字参数，默认参数，*args，**kwargs
高阶函数（函数对象）
函数嵌套
作用域与名称空间
装饰器
迭代器与生成器及协程函数
三元运算，列表解析、生成器表达式
函数的递归调用
内置函数
面向过程编程与函数式编程

#题目一
def modify_file(filename,old,new):
    import os
    with open(filename,‘r‘,encoding=‘utf-8‘) as read_f,        open(‘.bak.swap‘,‘w‘,encoding=‘utf-8‘) as write_f:
        for line in read_f:
            if old in line:
                line=line.replace(old,new)
            write_f.write(line)
    os.remove(filename)
    os.rename(‘.bak.swap‘,filename)

modify_file(‘/Users/jieli/PycharmProjects/爬虫/a.txt‘,‘alex‘,‘SB‘)

#题目二
def check_str(msg):
    res={
        ‘num‘:0,
        ‘string‘:0,
        ‘space‘:0,
        ‘other‘:0,
    }
    for s in msg:
        if s.isdigit():
            res[‘num‘]+=1
        elif s.isalpha():
            res[‘string‘]+=1
        elif s.isspace():
            res[‘space‘]+=1
        else:
            res[‘other‘]+=1
    return res

res=check_str(‘hello name:aSB passowrd:alex3714‘)
print(res)


#题目三：略

#题目四
def func1(seq):
    if len(seq) > 2:
        seq=seq[0:2]
    return seq
print(func1([1,2,3,4]))


#题目五
def func2(seq):
    return seq[::2]
print(func2([1,2,3,4,5,6,7]))


#题目六
def func3(dic):
    d={}
    for k,v in dic.items():
        if len(v) > 2:
            d[k]=v[0:2]
    return d
print(func3({‘k1‘:‘abcdef‘,‘k2‘:[1,2,3,4],‘k3‘:(‘a‘,‘b‘,‘c‘)}))

#注意：target.send(...)在拿到target的返回值后才算执行结束
import os

def init(func):
    def wrapper(*args,**kwargs):
        g=func(*args,**kwargs)
        next(g)
        return g
    return wrapper
@init
def search(target):
    while True:
        search_dir=yield
        for par_dir,_,files in os.walk(search_dir):
            for file in files:
                file_abs_path=r‘%s\%s‘ %(par_dir,file)
                # print(file_abs_path)
                target.send(file_abs_path)
@init
def opener(target):
    while True:
        file_abs_path=yield
        with open(file_abs_path,encoding=‘utf-8‘) as f:
            target.send((file_abs_path,f))
@init
def cat(target):
    while True:
        file_abs_path,f=yield
        print(‘检索文件‘,file_abs_path)
        for line in f:
            tag=target.send((file_abs_path,line))
            print(‘检索文件的行： %s‘ %line)
            if tag:
                break

@init
def grep(pattern,target):
    tag=False
    while True:
        file_abs_path,line=yield tag
        tag=False
        if pattern in line:
            tag=True
            target.send(file_abs_path)
@init
def printer():
    while True:
        file_abs_path=yield
        print(‘过滤出的结果=========>‘,file_abs_path)



search_dir=r‘C:\Users\Administrator\PycharmProjects\test\函数备课\a‘
e=search(opener(cat(grep(‘python‘,printer()))))
e.send(search_dir)

#字符串可以提供的参数 ‘s‘ None
>>> format(‘some string‘,‘s‘)
‘some string‘
>>> format(‘some string‘)
‘some string‘

#整形数值可以提供的参数有 ‘b‘ ‘c‘ ‘d‘ ‘o‘ ‘x‘ ‘X‘ ‘n‘ None
>>> format(3,‘b‘) #转换成二进制
‘11‘
>>> format(97,‘c‘) #转换unicode成字符
‘a‘
>>> format(11,‘d‘) #转换成10进制
‘11‘
>>> format(11,‘o‘) #转换成8进制
‘13‘
>>> format(11,‘x‘) #转换成16进制 小写字母表示
‘b‘
>>> format(11,‘X‘) #转换成16进制 大写字母表示
‘B‘
>>> format(11,‘n‘) #和d一样
‘11‘
>>> format(11) #默认和d一样
‘11‘

#浮点数可以提供的参数有 ‘e‘ ‘E‘ ‘f‘ ‘F‘ ‘g‘ ‘G‘ ‘n‘ ‘%‘ None
>>> format(314159267,‘e‘) #科学计数法，默认保留6位小数
‘3.141593e+08‘
>>> format(314159267,‘0.2e‘) #科学计数法，指定保留2位小数
‘3.14e+08‘
>>> format(314159267,‘0.2E‘) #科学计数法，指定保留2位小数，采用大写E表示
‘3.14E+08‘
>>> format(314159267,‘f‘) #小数点计数法，默认保留6位小数
‘314159267.000000‘
>>> format(3.14159267000,‘f‘) #小数点计数法，默认保留6位小数
‘3.141593‘
>>> format(3.14159267000,‘0.8f‘) #小数点计数法，指定保留8位小数
‘3.14159267‘
>>> format(3.14159267000,‘0.10f‘) #小数点计数法，指定保留10位小数
‘3.1415926700‘
>>> format(3.14e+1000000,‘F‘)  #小数点计数法，无穷大转换成大小字母
‘INF‘

#g的格式化比较特殊，假设p为格式中指定的保留小数位数，先尝试采用科学计数法格式化，得到幂指数exp，如果-4<=exp<p，则采用小数计数法，并保留p-1-exp位小数，否则按小数计数法计数，并按p-1保留小数位数
>>> format(0.00003141566,‘.1g‘) #p=1,exp=-5 ==》 -4<=exp<p不成立，按科学计数法计数，保留0位小数点
‘3e-05‘
>>> format(0.00003141566,‘.2g‘) #p=1,exp=-5 ==》 -4<=exp<p不成立，按科学计数法计数，保留1位小数点
‘3.1e-05‘
>>> format(0.00003141566,‘.3g‘) #p=1,exp=-5 ==》 -4<=exp<p不成立，按科学计数法计数，保留2位小数点
‘3.14e-05‘
>>> format(0.00003141566,‘.3G‘) #p=1,exp=-5 ==》 -4<=exp<p不成立，按科学计数法计数，保留0位小数点，E使用大写
‘3.14E-05‘
>>> format(3.1415926777,‘.1g‘) #p=1,exp=0 ==》 -4<=exp<p成立，按小数计数法计数，保留0位小数点
‘3‘
>>> format(3.1415926777,‘.2g‘) #p=1,exp=0 ==》 -4<=exp<p成立，按小数计数法计数，保留1位小数点
‘3.1‘
>>> format(3.1415926777,‘.3g‘) #p=1,exp=0 ==》 -4<=exp<p成立，按小数计数法计数，保留2位小数点
‘3.14‘
>>> format(0.00003141566,‘.1n‘) #和g相同
‘3e-05‘
>>> format(0.00003141566,‘.3n‘) #和g相同
‘3.14e-05‘
>>> format(0.00003141566) #和g相同
‘3.141566e-05‘

array=[1,3,4,71,2]

ret=[]
for i in array:
ret.append(i**2)
print(ret)

#如果我们有一万个列表,那么你只能把上面的逻辑定义成函数
def map_test(array):
ret=[]
for i in array:
ret.append(i**2)
return ret

print(map_test(array))

#如果我们的需求变了,不是把列表中每个元素都平方,还有加1,减一,那么可以这样
def add_num(x):
return x+1
def map_test(func,array):
ret=[]
for i in array:
ret.append(func(i))
return ret

print(map_test(add_num,array))
#可以使用匿名函数
print(map_test(lambda x:x-1,array))


#上面就是map函数的功能,map得到的结果是可迭代对象
print(map(lambda x:x-1,range(5)))

 

from functools import reduce
#合并,得一个合并的结果
array_test=[1,2,3,4,5,6,7]
array=range(100)

#报错啊,res没有指定初始值
def reduce_test(func,array):
l=list(array)
for i in l:
res=func(res,i)
return res

# print(reduce_test(lambda x,y:x+y,array))

#可以从列表左边弹出第一个值
def reduce_test(func,array):
l=list(array)
res=l.pop(0)
for i in l:
res=func(res,i)
return res

print(reduce_test(lambda x,y:x+y,array))

#我们应该支持用户自己传入初始值
def reduce_test(func,array,init=None):
l=list(array)
if init is None:
res=l.pop(0)
else:
res=init
for i in l:
res=func(res,i)
return res

print(reduce_test(lambda x,y:x+y,array))
print(reduce_test(lambda x,y:x+y,array,50))



 

movie_people=[‘alex‘,‘wupeiqi‘,‘yuanhao‘,‘sb_alex‘,‘sb_wupeiqi‘,‘sb_yuanhao‘]

def tell_sb(x):
return x.startswith(‘sb‘)


def filter_test(func,array):
ret=[]
for i in array:
if func(i):
ret.append(i)
return ret

print(filter_test(tell_sb,movie_people))


#函数filter,返回可迭代对象
print(filter(lambda x:x.startswith(‘sb‘),movie_people))

 

#当然了,map,filter,reduce,可以处理所有数据类型

name_dic=[
{‘name‘:‘alex‘,‘age‘:1000},
{‘name‘:‘wupeiqi‘,‘age‘:10000},
{‘name‘:‘yuanhao‘,‘age‘:9000},
{‘name‘:‘linhaifeng‘,‘age‘:18},
]
#利用filter过滤掉千年王八,万年龟,还有一个九千岁
def func(x):
age_list=[1000,10000,9000]
return x[‘age‘] not in age_list


res=filter(func,name_dic)
for i in res:
print(i)

res=filter(lambda x:x[‘age‘] == 18,name_dic)
for i in res:
print(i)


#reduce用来计算1到100的和
from functools import reduce
print(reduce(lambda x,y:x+y,range(100),100))
print(reduce(lambda x,y:x+y,range(1,101)))

#用map来处理字符串列表啊,把列表中所有人都变成sb,比方alex_sb
name=[‘alex‘,‘wupeiqi‘,‘yuanhao‘]

res=map(lambda x:x+‘_sb‘,name)
for i in res:
print(i)

 

‘‘‘
不可变:数字,字符串,元组
可变:列表,字典

原子:数字,字符串
容器:列表,元组,字典

直接访问:数字
顺序:字符串,列表,元组
映射访问:字典

‘‘‘

#一一对应
a,b,c,d,e=‘hello‘
print(e,d)

#少一个报错
# a,b,c=‘hello‘

#*号的使用
a,*_,e=‘hello‘
print(a,e)

#列表中的元素解压也是一一对应的关系
data=[‘mac‘,10000,[2016,10,12]]
name,price,date=data
print(name,price,date)

#截取子元素
name,price,[year,month,day]=data
print(name,price,year,month,day)

#无用的元素用_代替
data=[‘mac‘,10000,[2016,10,12]]
_,price,_=data
print(price)

#头截取,尾截取
record=[‘lhf‘,‘male‘,18,‘12345@qq.com‘,‘1861131211‘]
*_,phone=record
name,*_=record
print(phone)
print(name)

#解压可迭代对象赋值给多个值
#一个八个月的业绩与前七个月的平均值比较

sales_record=[11,12,3,7,9,6,3,5]
*head,tail=sales_record
print(head,tail)
print(sum(head)/len(head))
if tail > sum(head)/len(head):
    print(‘第八个月业绩高于前七个月平均值‘)
elif tail == sum(head)/len(head):
    print(‘第八个月业绩等于前七个月平均值‘)
else:
    print(‘第八个月业绩小于前七个月平均值‘)



#解压元素在函数中的应用

records=[
    (‘say_hi‘,‘hello‘),
    (‘calculate‘,10,20,30,40),
    (‘dic_handle‘,‘name‘,‘lhf‘)
]

def say_hi(msg):
    print(msg)

def calculate(l):
    res=0
    for i in l:
        res+=i
    print(res)

def dic_handle(l):
    key,val=l
    dic={key:val}
    print(dic)

for func,*args in records:
    if func == ‘say_hi‘:
        say_hi(args)
    elif func == ‘calculate‘:
        calculate(args)
    elif func == ‘dic_handle‘:
        dic_handle(args)

#linux系统中用户记录
record=‘root:x:0:0:super user:/root:/bin/bash‘
*head,home_dir,_=record.split(‘:‘)
print(‘家目录‘,home_dir)

#_*_coding:utf-8_*_
__author__ = ‘Linhaifeng‘
from collections import deque

# #实现队列,不指定大小则无限添加
# d=deque(maxlen=3)
# d.append(1)
# d.append(2)
# d.append(3)
# print(d)
# d.append(4)
# print(d)
# d.appendleft(5)
# print(d)
# print(d.pop())
# print(d.popleft())

def search(file,pattern,max_len=5):
    pre_lines=deque(maxlen=max_len)
    for line in file:
        if pattern in line:
            yield pre_lines,line
        pre_lines.append(line)

if __name__ == ‘__main__‘:
    with open(‘测试文件‘) as file:
        for pre_l,line in search(file,‘Exchange‘):
            print(‘-‘*60)
            for i in pre_l:
                print(i)
            print(‘匹配行----->‘,line)

#_*_coding:utf-8_*_
__author__ = ‘Linhaifeng‘

import heapq

nums=[1,2,3,-10,100,30,200,21,9,7]
print(heapq.nlargest(3,nums))
print(heapq.nsmallest(3,nums))



portfolio=[
    {‘name‘:‘IBM‘,‘shares‘:100,‘price‘:91.1},
    {‘name‘:‘AAPL‘,‘shares‘:50,‘price‘:532.1},
    {‘name‘:‘FB‘,‘shares‘:200,‘price‘:21.01},
    {‘name‘:‘HPQ‘,‘shares‘:35,‘price‘:32.75},
    {‘name‘:‘YHOO‘,‘shares‘:45,‘price‘:16.35},
    {‘name‘:‘ACME‘,‘shares‘:75,‘price‘:115.65}
]

cheap=heapq.nsmallest(3,portfolio,key=lambda x:x[‘price‘])
print(cheap)

‘‘‘
如果你想在一个集合中查找最小或最大的N个元素,
并且N小于集合元素数量, 那么这些函数提供了很好的性能。
因为在底层实现里面,首先会先将集合数据进行堆
排序后放入一个列表中
‘‘‘

heapq.heapify(nums)
print(nums)
‘‘‘
堆数据结构最重要的特征是heap[0]永远是最小的元素。
并且剩余的元素可以很 容易的通过调用heap.heappop()方法得到,
该方法会先将第一个元素弹出来,然后 用下一个最小的元素来取代被弹出元素
(这种操作时间复杂度仅仅是O(log N),N是堆大小。)比如,如果想要查找最小的3个元素,
你可以这样做:
‘‘‘
print(heapq.heappop(nums))
print(heapq.heappop(nums))
print(heapq.heappop(nums))

‘‘‘
nlarges(),nsmallest():当要查找的元素个数相对较小时使用
min(),max():就是要找唯一一个最大的或者最小的值时使用
sort[items][n:m]:当要查找的元素个数相接近items长度时使用
‘‘‘

#_*_coding:utf-8_*_
__author__ = ‘Linhaifeng‘
import heapq

class PriotryQueue:
    def __init__(self):
        self._queue=[]
        self._index=0

    def push(self,item,priotry):
        heapq.heappush(self._queue,(-priotry,self._index,item))
        self._index+=1

    def pop(self):
        return heapq.heappop(self._queue)[-1]

class Item:
    def __init__(self,name):
        self.name=name

    def __str__(self):
        return self.name

    def __repr__(self):
        # return self.name
        return ‘Item({!r})‘.format(self.name)
q=PriotryQueue()
q.push(Item(‘镇长‘),1)
q.push(Item(‘省长‘),4)
q.push(Item(‘主席‘),5)
q.push(Item(‘市长‘),3)
q.push(Item(‘县长‘),2)

print(q._queue)

print(q.pop())
print(q.pop())
print(q.pop())
print(q.pop())
print(q.pop())

#_*_coding:utf-8_*_
__author__ = ‘Linhaifeng‘

‘‘‘
一个字典就是一个键对应一个单值的映射。
如果你想要一个键映射多个值,那么你就需
要将这多个值放到另外的容器中,比如列表
或者集合里面。比如,你可以像下面 这样构造这样的字典:
‘‘‘

people={
    ‘name‘:[‘alex‘,‘李杰‘],
    ‘hobby‘:[‘play‘,‘coding‘]
}

project={
    ‘company‘:{‘IBM‘:‘CTO‘,‘Lenovo‘:‘CEO‘,‘baidu‘:‘COO‘,‘Alibaba‘:‘UFO‘},
    ‘applicant‘:[‘小白‘,‘lhf‘,‘武藤兰‘]
}

‘‘‘
选择使用列表还是集合取决于你的实际需求。
如果你想保持元素的插入顺序就应该使用列表,
如果想去掉重复元素就使用集合(并且不关心元素的顺序问题)。
你可以很方便的使用collections模块中的defaultdict来构造这样的字典。             的一个特征是它会自动初始化每个     刚开始对应的值,所以你只需要 关注添加元素操作了。比如:
‘‘‘
from collections import defaultdict
d=defaultdict(list)
d[‘teacher‘].append(‘alex‘)
d[‘teacher‘].append(‘wupeiqi‘)
d[‘teacher‘].append(‘wuqiqi‘)
d[‘boss‘].append(‘oldboy‘)
d[‘boss‘].append(‘alex‘)

d_set=defaultdict(set)
d_set[‘a‘].add(1)
d_set[‘a‘].add(2)
d_set[‘a‘].add(3)

print(d,d_set)

#setdefault
d={}

d.setdefault(‘a‘,[]).append(1)
d.setdefault(‘a‘,[]).append(2)
d.setdefault(‘a‘,[]).append(2)
print(d)

#自己实现一个一键多值字典
l=[
    (‘teacher‘,‘alex‘),
    (‘teacher‘,‘lhf‘),
    (‘teacher‘,‘papa‘),
    (‘boss‘,‘alex‘),
    (‘boss‘,‘wupeiqi‘),
]
d={}
for k,v in l:
    if k not in d:
       d[k]=[]
    d[k].append(v)
print(d)

#用defaultdict实现,更优雅
d=defaultdict(list)
for k,v in l:
    d[k].append(v)

print(d)

#_*_coding:utf-8_*_
__author__ = ‘Linhaifeng‘

from collections import OrderedDict
d=OrderedDict()
d[‘dream1‘]=‘先挣他妈一个亿‘
d[‘dream2‘]=‘然后周游全世界‘
d[‘dream3‘]=‘再娶他妈七八个媳妇‘
d[‘dream4‘]=‘洗洗脸,然后梦就醒了‘

for key in d:
    print(key,d[key])

# import json
# print(json.dumps(d))

‘‘‘
OrderedDict内部维护着一个根据键插入顺序排序的双向链表每次当一个新的元素
插入进来的时候,它会被放到链表的尾部对于一个已经存在的键的重复赋值不会改变
键的顺序。需要注意的是,一个OrderedDict的大小是一个普通字典的两倍,因为它
内部维 护着另外一个链表。所以如果你要构建一个需要大量OrderedDict实例的数
据结构的时候,那么你就得仔细 权衡一下是否使用OrderedDict带来的好处要大过
额外内存消耗的影响。
‘‘‘

#_*_coding:utf-8_*_
__author__ = ‘Linhaifeng‘
prices={
    ‘ACME‘:45.23,
    ‘AAPL‘:612.78,
    ‘IBM‘:205.55,
    ‘HPQ‘:37.20,
    ‘FB‘:10.75
}

#zip()创建的是只能访问一次的迭代器,下面的max()会报错
# prices_and_names=zip(prices.values(),prices.keys())
# min_price=min(prices_and_names)
# max_price=max(prices_and_names)

#单纯的min(prices)是按照key来取值


min_price=min(zip(prices.values(),prices.keys()))
max_price=max(zip(prices.values(),prices.keys()))

print(min_price)
print(max_price)


print(min(prices,key=lambda k:prices[k]))
print(max(prices,key=lambda k:prices[k]))

‘‘‘
需要注意的是在计算操作中使用到了(值,键)对。当多个实体
拥有相同的值的时 候,键会决定返回结果。比如,在执行min()
和max()操作的时候,如果恰巧最小或 最大值有重复的,那么拥
有最小或最大键的实体会返回
‘‘‘
prices={‘A‘:45.23,‘Z‘:45.23}

print(min(zip(prices.values(),prices.keys())))

#_*_coding:utf-8_*_
__author__ = ‘Linhaifeng‘
a={
    ‘x‘:1,
    ‘y‘:2,
    ‘z‘:3,
}

b={
    ‘w‘:1,
    ‘x‘:2,
    ‘y‘:3,
}

print(a.keys() & b.keys())
print(a.keys() - b.keys())
print(a.items() - b.keys())


#生成一个新的字典,去掉某些key

c={key:a[key] for key in a.keys() - {‘z‘,‘w‘}}
print(c)

#_*_coding:utf-8_*_
__author__ = ‘Linhaifeng‘

a=[1,5,2,1,9,1,5,10]

#如果想简单去重,可以使用set,但是set是无序的
# print(set(a))

#如果序列的值都是hashable类型,那么可以简单利用集合或者生成器来解决这个问题
def dedupe(items):
    seen=set()
    for i in items:
        if i not in seen:
            yield i
            seen.add(i)
print(list(dedupe(a)))


#如果序列元素是不可hashable类型
a=[
    {‘name‘:‘alex‘,‘age‘:18},
    {‘name‘:‘alex‘,‘age‘:100},
    {‘name‘:‘alex‘,‘age‘:100},
    {‘name‘:‘lhf‘,‘age‘:18},

]

def dedupe(items,key=None):
    seen=set()
    for i in items:
        k=i if not key else key(i)
        if k not in seen:
            yield i
            seen.add(k)
print(list(dedupe(a,key=lambda k:(k[‘name‘],k[‘age‘]))))

#去除文件中相同的内容用第一种方法即可

#_*_coding:utf-8_*_
__author__ = ‘Linhaifeng‘

#普通切片,一堆硬编码
record=‘苍井空‘
record1=‘abcde‘
print(record[1:3])
print(record1[1:3])

#命名切片,减少硬编码
record=‘苍井空 18621452550 沙河汇德商厦‘
phone=slice(4,15)
addr=slice(16,21)
print(record[phone])
print(record[addr])

‘‘‘
一般来讲,代码中如果出现大量的硬编码下标值会使
得可读性和可维护性大大降 低。比如,如果你回过来
看看一年前你写的代码,你会摸着脑袋想那时候自己到
底想 干嘛啊。这里的解决方案是一个很简单的方法让
你更加清晰的表达代码到底要做什么。内置的slice()
函数创建了一个切片对象,可以被用在任何切片允许使用
的地方。
‘‘‘

s=slice(5,50,2)
print(s.start)
print(s.stop)
print(s.step)

#_*_coding:utf-8_*_
__author__ = ‘Linhaifeng‘
from collections import Counter
words=[‘if‘, ‘you‘, ‘were‘, ‘a‘,
       ‘you,I‘, ‘would‘, ‘never‘,‘if‘,
       ‘would‘, ‘if‘]
# d={}
# for word in words:
#     if word not in d:
#         d[word]=1
#     else:
#         d[word]+=1
# print(d)

word_counts=Counter(words)
# print(word_counts)

#统计出现频率最高的3个单词
print(word_counts.most_common(2))

#可以像字典一样取值
print(word_counts[‘if‘])

#新增单词
more_words=[‘if‘,‘if‘]
for word in more_words:
    word_counts[word]+=1

print(word_counts)
#或者直接使用
word_counts.update(more_words)
print(word_counts)


#counter实例可以进行数学运算

a=Counter(words)
b=Counter(more_words)
print(a)
print(b)
print(a-b)
print(b-a)
print(a+b)

文件conf.txt内容
global
        log 127.0.0.1 local2
        daemon
        maxconn 256
        log 127.0.0.1 local2 info
defaults
        log global
        mode http
        timeout connect 5000ms
        timeout client 50000ms
        timeout server 50000ms
        option  dontlognull

listen stats :8888
        stats enable
        stats uri       /admin
        stats auth      admin:1234

frontend oldboy.org
        bind 0.0.0.0:80
        option httplog
        option httpclose
        option  forwardfor
        log global
        acl www hdr_reg(host) -i www.oldboy.org
        use_backend www.oldboy.org if www

backend www.oldboy.org
        server 100.1.7.9 100.1.7.9 weight 20 maxconn 3000

原配置文件


deque_test.py内容

from collections import deque
import re

def conf_dic(f):
    dic={}
    for line in f:
        if re.match(‘[a-zA-Z]‘,line):
            key=line
        elif re.match(‘^ ‘,line):
            dic.setdefault(key,[]).append(line)

    return dic



if __name__ == ‘__main__‘:
    with open(‘conf.txt‘,encoding=‘utf-8‘) as f:
        dic=conf_dic(f)

    for i in dic:
        print(‘%s‘ %i,end=‘‘)
        for line in dic[i]:
            print(line,end=‘‘)
        print(‘-‘*20)

#_*_coding:utf-8_*_
__author__ = ‘Alex Li‘
from operator import itemgetter

rows=[
    {‘fname‘:‘Brian1‘,‘lname‘:‘Jones1‘,‘uid‘:1003},
    {‘fname‘:‘Brian2‘,‘lname‘:‘Jones2‘,‘uid‘:1002},
    {‘fname‘:‘Brian3‘,‘lname‘:‘Jones3‘,‘uid‘:1001},
    {‘fname‘:‘Brian4‘,‘lname‘:‘Jones4‘,‘uid‘:1004},
]
# rows_by_uid=sorted(rows,key=lambda rows:rows[‘uid‘])
# for i in rows_by_uid:
#     print(i)
#
#
#
# rows_by_uid=sorted(rows,key=itemgetter(‘uid‘))
# for i in rows_by_uid:
#     print(i)


rows_by_lfname=sorted(rows,key=itemgetter(‘lname‘,‘fname‘))
print(rows_by_lfname)
for i in rows_by_lfname:
    print(i)

#_*_coding:utf-8_*_
__author__ = ‘Alex Li‘

#要生成列表
l=[]
for i in range(6):
   i*=2
   l.append(i)
print(l)



y=[i*2 for i in range(6)]
print(y)


def func(n):
    return n+10
z=[func(i) for i in range(6)]
print(z)

l=[1,2,3,-1,-10,4,5]
#过滤掉负数
l_new=[i for i in l if i >= 0]
print(l_new)

#_*_coding:utf-8_*_
__author__ = ‘Alex Li‘


#生成器,取一次生成一个值,只能next不能回退,因为只有一个

l=[i for i in range(10000000)] #机器卡死
g=(i for i in range(1000000)) #一秒生成
g.__next__()
#next到最后报异常


def fib(n1,n2,count=0):
    if count > 10:return
    if count == 0:
        print(‘‘,n1,end=‘‘)

    x=n2
    n2=(n1+n2)
    n1=x
    print(‘ ‘,n2,end=‘‘)
    count+=1
    fib(n1,n2,count)



#
# 0 1 1 2 3 5 8 13 21

# fib(0,1)
#
def fib2(max=10):
    n,a,b=0,0,1
    while n < max:
        # x=b
        # b=b+a
        # a=x
        yield b
        a,b=b,a+b
        # print(‘ ‘,b,end=‘‘)

        n+=1
    return ‘done‘

x=fib2()
x.__next__()
x.__next__()
x.__next__()
x.__next__()
x.__next__()
x.__next__()
x.__next__()
x.__next__()
x.__next__()
x.__next__()
x.__next__()
x.__next__()
x.__next__()
x.__next__()
x.__next__()

# while True:
#     try:
#         print(x.__next__())
#     except Exception as e:
#         print(e)
#         break

#_*_coding:utf-8_*_
__author__ = ‘Alex Li‘
import time

def consumer(name):
    print(‘[%s]准备吃包子啦‘ %name)
    while True:
        baozi=yield

        print(‘包子[%s]来了,被[%s]吃了‘ %(baozi,name))


# c=consumer(‘alex‘)
# c.__next__()
# c.send(‘韭菜馅的‘)


def producter():
    c1=consumer(‘alex‘)
    c2=consumer(‘wupeiqi‘)
    c1.__next__()
    c2.__next__()
    print(‘开始做包子啦‘)
    for i in range(10):
        time.sleep(1)
        c1.send(i)
        c2.send(i)

producter()


f=open(‘a.txt‘)
f.__next__()

#_*_coding:utf-8_*_
__author__ = ‘Alex Li‘
name=‘lhf‘
passwd=‘123‘

def auth(auth_type):
    def inner_auth(func):
        def _wrapper(*args,**kwargs):
            username=input(‘username: ‘)
            password=input(‘passwd: ‘)
            if auth_type == ‘local‘:
                if username ==  name and password ==passwd:
                    print(‘user login successfull‘)
                    res=func(*args,**kwargs)

                else:
                    exit(‘log err‘)
            elif auth_type == ‘ldap‘:
                print(‘搞毛线ldap,谁特么会‘)

        return _wrapper
    return inner_auth


def index():
    print(‘welcome to index page‘)

@auth(auth_type=‘local‘)
def home():
    print("welcome to home page")

@auth(auth_type=‘ldap‘)
def bbs():
    print(‘welcome to bbs page‘)

index()
home()
bbs()

#_*_coding:utf-8_*_
__author__ = ‘Linhaifeng‘
prices={
    ‘ACME‘:45.23,
    ‘AAPL‘:612.78,
    ‘IBM‘:205.55,
    ‘HPQ‘:37.20,
    ‘FB‘:10.75
}
prices_new={key:val for key,val in prices.items() if val > 200}
print(prices_new)

#_*_coding:utf-8_*_
__author__ = ‘Linhaifeng‘
from collections import namedtuple
#商品,购买个数,单价
records=[
    (‘mac‘,2,20000),
    (‘lenovo‘,1,3000),
    (‘apple‘,0,10),
    (‘tesla‘,10,1000000)
]
‘‘‘
命名元组的一个主要用途是将你的代码从下标操作中解脱出来。
因此,如果你从数 据库调用中返回了一个很大的元组列表,通
过下标去操作其中的元素,当你在表中添 加了新的列的时候你
的代码可能就会出错了。但是如果你使用了命名元组,那么就不
会有这样的顾虑。
为了说明清楚,下面是使用普通元组的代码:
‘‘‘
cost=0.0
for rec in records:
    cost+=rec[1]*rec[2]
    print(‘商品:%s 购买个数:%s,总价格为:%s‘ %(rec[0],rec[1],cost))


#使用命名元祖后
sk=namedtuple(‘Stock‘,[‘name‘,‘count‘,‘price‘])
for rec in records:
    s=sk(*rec)
    print(s.count*s.price)

p=namedtuple(‘People‘,[‘name‘,‘gender‘,‘age‘])
l=[‘alex‘,‘femal‘,18]
p1=p(*l)
print(p1)
print(p1.name)
print(p1.age)
print(p1.gender)

‘‘‘
命名元组另一个用途就是作为字典的替代,
因为字典存储需要更多的内存空间。如果
你需要构建一个非常大的包含字典的数据结构,
那么使用命名元组会更加高效。但 是需要注意的是,
不像字典那样,一个命名元组是不可更改的。比如:
‘‘‘
p=namedtuple(‘People‘,[‘name‘,‘gender‘,‘age‘])
l=[‘alex‘,‘femal‘,18]
p1=p(*l)
print(p1.name)
# p1.name=‘sb‘#报错,不可修改
p1=p1._replace(name=‘sb‘)#需要重新赋值给p1
print(p1.name)

#可以新建一个函数,弥补必须使用_replace才能修改元素的缺点
p=namedtuple(‘People‘,[‘name‘,‘gender‘,‘age‘])
p1=p(‘‘,‘‘,None)
def dict_to_stock(s):
    return p1._replace(**s)

print(dict_to_stock({‘name‘:‘alex‘,‘gender‘:‘f‘,‘age‘:18}))
print(dict_to_stock({‘name‘:‘sb‘,‘gender‘:‘f‘,‘age‘:18}))