1、三元表达式：
value= true-expr if condition else false-expr
例如：a=‘positive‘ if 3>0 else ‘negative‘
2、用列表推导式来取代map和filter
a=[1,2,3,4,5] squares=list(map(lambda x:x**2,a)) print(squares) #[1, 4, 9, 16, 25] squares=[x**2 for x in a] print(squares) #[1, 4, 9, 16, 25] data=list(map(lambda x:x**2 ,filter(lambda x:x%2==0,a))) print(data) #[4, 16] data_one=[x**2 for x in a if x%2==0] 等价于data_one=[x**2 for x in a and x%2==0]
print(data_one) #[4, 16] #字典与集合也有类似的推导机制 chile_ranks={‘ghost‘:1,‘habanero‘:2,‘cayenne‘:3} rank_dict={rank:name for name,rank in chile_ranks.items()} chile_len_set={len(name) for name in rank_dict.values()} print(rank_dict) #{1: ‘ghost‘, 2: ‘habanero‘, 3: ‘cayenne‘} print(chile_len_set) #{8, 5, 7}
3、函数式编程
能接收其他函数作为参数的函数，被称为高阶函数(high-order function)
代表性高阶函数：map() filter() 和 reduce()
map()函数接收两个参数，一个是函数，一个是Iterable，map将传入的函数依次作用到序列的每个元素，
并把结果作为新的Iterable返回。
lambda_sum=lambda x,y:x+y
print(lambda_sum(3,4)) #7
data_list=[1,3,5,6]
result=map(lambda x:x+3,data_list)
print(list(result)) #[4, 6, 8, 9]
def f(x):
return x+3
result_one=list(map(f,data_list))
print(result_one) #[4, 6, 8, 9]
reduce():把一个函数作用在一个序列[x1,x2,x3,...]上，这个函数必须接收两个参数，reduce把结果
继续和序列的下一个元素做累积计算。感觉用处不大！自己也能写，会麻烦一些，如果需要，还是可用。
from functools import reduce
data_list=[1,3,5]
print(reduce(lambda x,y:2*x+y,data_list)) #15
def f_reduce(x,y):
return 2*x+y
print(reduce(f_reduce,data_list)) #15
new_list=data_list[:1]
for i in range(1,len(data_list)):
new_list.append(2*new_list[i-1]+data_list[i])
print(new_list) #[1, 5, 15]
print(new_list[-1]) #15
def prod(L):
new_list=L[:1]
for i in range(1,len(L)):
new_list.append(new_list[i-1]*L[i])
return new_list[-1]
print(prod([3, 5, 7, 9])) #945
def prod(L):
return reduce(lambda x,y:x*y,L)
print(prod([3, 5, 7, 9])) #945
3、filter() ，和map()类似，也接收一个函数和一个序列。和map()不同的是，filter()把传入的函数依次作用于每个元素，
然后根据返回值是True还是False决定保留还是丢弃该元素
list(filter(lambda x:x%2==0,[3,4,5])) #[4]
list(filter(lambda x:x%2==1,[3,4,5])) #[3,5]
lst=[x**2 for x in range(10)] #[0, 1, 4, 9, 16, 25, 36, 49, 64, 81]
x1=[1,3,5]
y1=[9,12,13]
lst1=[x**2 for (x,y) in zip(x1,y1) if y>10]
print(lst1) #[9, 25]
dict={k:v for k,v in enumerate(‘vamei‘) if v not in ‘vi‘}
print(dict) #{1: ‘a‘, 2: ‘m‘, 3: ‘e‘}
4、fluent python 阅读笔记
import os,time,sys,requests
POP20_CC=(‘CN IN US ID BR PK NG BD RU JP ‘
‘MX PH VN ET EG DE IR TR CD FR‘).split()
BASE_URL=‘http://flupy.org/data/flags‘
DEST_DIR=‘E://‘
def save_flag(img,filename):
path=os.path.join(DEST_DIR,filename)
with open(path,‘wb‘) as fp:
fp.write(img)
def get_flag(cc):
url=‘{}/{cc}/{cc}.gif‘.format(BASE_URL, cc=cc.lower())
resp=requests.get(url)
return resp.content
def show(text):
print(text,end=‘ ‘)
sys.stdout.flush()
def download_many(cc_list):
for cc in sorted(cc_list):
image=get_flag(cc)
show(cc)
save_flag(image,cc.lower()+‘.gif‘)
return len(cc_list)
def main(download_many):
t0=time.time()
count=download_many(POP20_CC)
elapsed=time.time()-t0
msg=‘\n{} flags downloaded in {:.2f}‘
print(msg.format(count,elapsed))
if __name__==‘__main__‘:
main(download_many)
简单的一个代码，写的比较好！将一个脚本任务按照实现流程分为几个动作，每个动作写一个函数，有如下优点：
1、代码清晰
思路清晰，而非胡子眉毛一把抓，整体任务分为若干个小动作，一个动作用一个函数来实现。
2、易于扩展
如果代码某一块需要修改，可以仅修改部分函数即可，对其他函数无影响，也可以增加其他功能。
3、写主函数
代码中包含有主函数，从主函数开始，便于程序的阅读，一看到main()，知道从这里开始阅读起。
4、不同函数之间变量名称
写函数的时候可以以变量名称、类型方式写，注意函数内变量一致即可，调用时则使用全局变量中名称，两者要不一样吗？为什么呢？？
比如这样改写download_many函数：
for cc in sorted(POP20_CC):
image=get_flag(cc)
show(cc)
save_flag(image,cc.lower()+‘.gif‘)
return len(POP20_CC)
如果我们修改主函数，下载10个国家国旗图片
def main(download_many):
t0=time.time()
count=download_many(POP10_CC)
elapsed=time.time()-t0
msg=‘\n{} flags downloaded in {:.2f}‘
print(msg.format(count,elapsed))
结果是主函数的修改对download_many函数还是起作用，因为download_many函数中变量只是相当于x，真正起作用还是调用时主函数中输入的参数值，所以你这样写也没有问题。不过用变量cc_list好，阅读起来不会引起混淆，不管你是下10国国旗还是20国国旗。如果你download_many中是20国国旗作为变量，调用时输入10国国旗为参数，看起来比较别扭。
自己以后写代码要学习这种写法！
