Python技巧:List,Tuple,Dict,Set

自己最近主要是用Python,还不是很扎实,学习了程序员硕的Python高效编程技巧实战,讲得很好,感觉受益匪浅,故分享一下心得

在列表List,字典Dict,集合Set中根据条件筛选数据

使用各自的生成式即可
产生相同的列表,列表表达式速度比过滤函数快!!将近一倍. 这两种方法都远远快于for循环
过滤函数定义: filter(function or None, sequence) -> list, tuple, or string
21.jpg

为每个元组Tuple中的元素命名,提高程序可读性

  1. 定义类似于其它语言的枚举类型,也就是定义一系列数值常量

    1
    2
    3
    NAME = 0  
    AGE = 1
    EMAL = 2

    或者

    1
    NAME,AGE,EMAIL = range(3)

    具体使用

    1
    2
    s1 = ('haes',16,'5065@qq.com')
    print s1[AGE]

    这么使用得提前设计好数据结构

  2. 使用collections.namedtuple替代内置tuple
    先实例化一个namedtuple对象,这个对象和tuple的地位一样,只不过带名字(名字就是这个对象的各个属性)
    1
    2
    3
    4
    5
    from collections import namedtuple  
    student = namedtuple('s1',['NAME','AGE','EMAIL'])
    s = student('haes',16,'5065@qq.com')
    print s.NAME
    print isinstance(s,tuple) #Ture

统计序列sequence中元素的出现次数

  1. 使用sorted函数

    1
    2
    #比如:按字典的值排序
    new_c = sorted(c.items(),key=lambda x :x[1])
  2. 使用collections.Counter对象
    将序列sequence传入Counter的构造函数,得到Counter对象是元素出现次数的字典
    Counter.most_common(n)方法得到出现次数最多的前n个元素的列表

    1
    2
    3
    4
    from collections import Counter
    new_c = Counter(data)
    print new_c[3] #data中索引为3的元素出现的次数
    print new_c.most_common(4) #[(10, 4)说明10出现了4次

根据字典值的大小,对字典的项排序

  1. 使用sorted函数

    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
    12
    13
    14
    15
    16
    17
    18
    from random import randint
    d = {x:randint(60,100) for x in 'xyzabc' }
    #直接排序是对字典的键排序,因为默认是对各项的第一个元素排序,元组也是
    print sorted(d )
    #<dictionary-keyiterator object at 0x00000000066742C8>
    print iter(d)
    #可以通过list看看具体的迭代对象是什么
    print list(iter(d))

    #使用sorted函数的key参数
    b = {x:randint(60,100) for x in range(10)}
    #根据value排序和对value排序是两个不同的概念!!!!
    new_b1 = sorted(b.items(),key=lambda x:x[1])
    new_b2 = sorted(b.values())
    new_b3 = sorted(b)
    print new_b1
    print new_b2
    print new_b3
  2. 使用zip函数将字典数据转化元组
    根据value排序和对value排序是两个不同的概念
    zip(seq1, seq2, *more_seqs) 返回的是元组

    1
    2
    3
    4
    5
    6
    7
    #zip的使用
    new_d = zip(d.values(),d.keys())
    #使用迭代版本的key和value节约空间!!!!
    new_D = zip(d.itervalues(),d.iterkeys())
    print new_D
    #将value放在第一个位置,这样就可以按照value排序了
    print sorted(new_D)

查找多个字典的公共键

step1. 使用字典的viewkeys()方法,得到一个字典keys的集合set
step2. 使用map函数,得到所有字典的keys的集合
step3. 使用reduce函数,得到所有字典的集合的交集set

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
from random import randint,sample
#先随机生成4个字典
#def sample(self, population, k):
#Chooses k unique random elements from a population sequence.
#sample:从population序列里面随机选取k个
print sample('abcdefg',randint(3,6))
s1 = {k:randint(0,5) for k in sample('abcdefg',randint(3,6)) }
s2 = {k:randint(0,5) for k in sample('abcdefg',randint(3,6)) }
s3 = {k:randint(0,5) for k in sample('abcdefg',randint(3,6)) }
s4 = {k:randint(0,5) for k in sample('abcdef',randint(3,6))}

# print s1.viewkeys() & s2.viewkeys() & s3.viewkeys()
#map对每个元素执行相同的操作
s = map(dict.viewkeys,[s1,s2,s3])
#def reduce(function, sequence, initial=None)
print reduce(lambda a,b:a & b,s)

#用lambda也行
# s = map(lambda x : x.viewkeys(),[s1,s2,s3])
# print reduce(lambda a,b:a & b,s)

让字典保持有序

使用collections中的有序字典OrderedDict

1
2
3
4
5
6
7
8
9
#实例化一个OrderedDict对象,然后赋值即可
#先插入的值排在前面
from collections import OrderedDict
d = OrderedDict()
d['Bob'] = 1
d['Jim'] = 21
d['Leo'] = -100
for k in d:
print k

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
#模拟跑步排名,先记录的说明成绩靠前
from time import time
from random import randint
from collections import OrderedDict
players = list('ABCDEFGH')
start = time()
d = OrderedDict()
for i in range(8):
raw_input()
#pop还能这么用
p = players.pop(randint(0,7-i))
end = time()
print i+1,p,end-start
d[p] = (i+1,end-start)
print "------------------------------------------"
for k in d: print k,d[k]

实现用户的历史记录功能

使用collections中的deque,它是一个双端循环队列
程序退出前可以使用pickle将队列对象存入文件,再次运行程序时将其导入

1
2
3
4
5
6
7
8
9
10
11
12
from collections import deque
# deque 双端队列
#def __init__(self, iterable=(), maxlen=None)
#最多存5条,超过5条会把最开始的删掉,从而保持deque的容量为5
q = deque([],5)
q.append(1)
q.append(2)
q.append(3)
q.append(4)
q.append(5)
q.append(6)
print q

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
#模拟猜数
from random import randint
from collections import deque
import pickle

N = randint(0,100)
history = deque([],5)
def guess(k):
if k==N:
print 'right'
return True
if k<N:
print '%s is less than N'%k
return False
else:
print '%s is greater than N'%k
return False

while(True):
line = raw_input('plz input a number: ')
if line.isdigit():
k = int(line)
history.append(k)
if guess(k):
break;
elif line == 'check':
print list(history)

pickle.dump(history,open('test.txt','wb'))
p = pickle.load(open('test.txt','rb'))
print p
print list(p)