python语法技巧

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))  #

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)) #

def f_reduce(x,y):

    return 2*x+y

print(reduce(f_reduce,data_list))  #

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]) #

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]))  #

def prod(L):

    return reduce(lambda x,y:x*y,L)

print(prod([3, 5, 7, 9]))  #

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函数：

def download_many(POP20_CC):

    for cc in sorted(POP20_CC):

        image=get_flag(cc)

        show(cc)

        save_flag(image,cc.lower()+'.gif')

    return len(POP20_CC)

如果我们修改主函数，下载10个国家国旗图片

POP10_CC=('CN IN US ID BR PK NG BD RU JP').split()

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国国旗为参数，看起来比较别扭。

自己以后写代码要学习这种写法！

5、python中实现switch语法结构

https://www.zhihu.com/question/21123544

def case1(somearg):

    pass

def case2(somearg):

    pass

def case3(somearg):

    pass

switch={

1: case1,

2: case2,

3: case3

}

switch[case](arg)

5、enum库用法

from enum import Enum

EventType=Enum('EventType','tick bar signal')

EventType.tick

Out[29]: <EventType.tick: 1>

dir(EventType)

Out[30]: ['__class__', '__doc__', '__members__', '__module__', 'bar', 'signal', 'tick']

dic ={'a': 1, 'b': 2, 'c': 3}

for n,buf in enumerate(dic):

    print(n,buf)

# 0 a

# 1 b

# 2 c

6、python直接赋值和for循环执行效率比较

结论：直接赋值比for循环要快

# 下面代码为将一个对象所有属性给另一个对象，注意test1不行。

from datetime import datetime

class A():

    name = "runoob"

def test(a, b):

    for k, v in a.__dict__.items():

        setattr(b, k, v)

def test1(a, b):

    for k, v in a.__dict__.items():

        b.k = v

def test2(a, b):

    b.a = a.a

    b.b = a.b

    b.c = a.c

    b.d = a.d

    b.e = a.e

    b.f = a.f

def run(f, a, b):

    start = datetime.now()

    for i in range(10000):  #

        f(a, b)

    end = datetime.now()

    print(end - start)

dic = {'a': 1, 'b': 2, 'c': 3, 'd': 4, 'e': 5, 'f': 6, 'aa': 1, 'ba': 2, 'ca': 3, 'da': 4, 'ea': 5, 'fa': 6}

a = A()

for k, v in dic.items():

    setattr(a, k, v)

print(a.__dict__)

b = A()

run(test, a, b)

print(b.__dict__)

# test

# {'a': 1, 'b': 2, 'c': 3, 'd': 4, 'e': 5, 'f': 6}

# 0:00:09.460686

# {'a': 1, 'b': 2, 'c': 3, 'd': 4, 'e': 5, 'f': 6}

# test1

# {'a': 1, 'b': 2, 'c': 3, 'd': 4, 'e': 5, 'f': 6}

# 0:00:05.086406

# {'k': 6}

# test2

# {'a': 1, 'b': 2, 'c': 3, 'd': 4, 'e': 5, 'f': 6}

# 0:00:03.672156

# {'a': 1, 'b': 2, 'c': 3, 'd': 4, 'e': 5, 'f': 6}

# 下面代码为将一个字典所有键值对作为一个对象的属性

print('ok')

from datetime import datetime

class A():

    name = "runoob"

def test(a, b):

    for k, v in a.items():

        setattr(b, k, v)

def test1(a,b):

    for k,v in a.items():

        b.__setattr__(k,v)

def test2(a, b):

    b.a = a['a']

    b.b = a['b']

    b.c = a['c']

    b.d = a['d']

    b.e = a['e']

    b.f = a['f']

    b.aa = a['aa']

    b.ba = a['ba']

    b.ca = a['ca']

    b.da = a['da']

    b.ea = a['ea']

    b.fa = a['fa']

def run(f, a, b):

    start = datetime.now()

    for i in range(10000):  #

        f(a, b)

    end = datetime.now()

    print(end - start)

a = {'a': 1, 'b': 2, 'c': 3, 'd': 4, 'e': 5, 'f': 6, 'aa': 1, 'ba': 2, 'ca': 3, 'da': 4, 'ea': 5, 'fa': 6}

b = A()

run(test1, a, b)

print(b.__dict__)

# 结果：赋值比for循环快