Python编程进阶1

从网上找的Python编程的小技巧，旨在培养Python编程的思想，记录如下：

from random import  randint

#解析是个运算符号，可以进行简单的运算，实现功能快速
###################################################
data = [randint(-10,101) for _  in range(10) ]
print(data)
#pythhon3中，filter返回的是个迭代器，要对其使用list序列化
out = list(filter(lambda x: x>0,data))
print(out)
#####################################################
#####################################################
#列表解析
out = [x for x in data if x>0]
print(out)

#####################################################
data = {x:randint(60,100) for x in range(1,6)}
print(data)
#字典解析，解析生成的是 一个迭代器，外加list或字典，则
#返回相应的list和字典。解析以for为分界线，左为结果，右为条件
#解析两个关键：结果输出形式和条件表达
out = {k:v for k,v in data.items() if v>90}
print(out)

#输出结果形式可以进行简单的运算，简化代码编写
#同样条件也可以更加复杂点
out={k:v+10 for k,v in data.items() if v>19}
print(out)
#####################################################
#集合解析
data = [randint(-10,101) for _  in range(10) ]
data = set(data)
print(data)
out = {x for x in data if x%3==0}
print(out)


#####################################################
#命名元素，这个有点类似于C中的技巧
student = ('jim',10, 'male','adc@qq.com')
print(student[0])

#将索引值定义为常量，相当于宏
NAME=1
AGE=2
SEX=3
print(student[NAME])

#也可以集中定义，
NAME,AGE,SEX=range(3)
print(student[NAME])


#使用标准库下的命名元组，相当于定义一个类，操作方便
from collections import namedtuple
Student =namedtuple('Student',['name','age','sex'])
s1 = Student(name = 'jjj',age = 10, sex = 'male')
print(s1)
s1 = Student( 'aaaaa',  120,   'dddd')
print(s1)
# 可以按照类方式访问
print(s1.name)

#这里返回真，表示是元组的子类
print(isinstance(s1,tuple))
#####################################################
#如何出现序列中元素的出现频率
data = [randint(0,10) for _ in range(16)]
print(data)

#统计结果是个字典，以列表的值为key，以其出现次数为值
#可以先建立一个字典，其值为空，key来源于列表

#dict提供了从key建立字典的方式
#其值设置为0，也可设置为其它
#以列表为输入作为key，从key建立字典，这招不错
c = dict.fromkeys(data,0)
print(c)

#开始对每个元素迭代
#针对特殊元素，可以考虑特殊处理，这样可以得到更多的功能
for each in data:
    c[each] += 1
print(c)


#如果统计最高的频率
from collections import Counter
c2 = Counter(data)
#这里得到的couter结果和上面我们自己遍历统计的结果是完全一样的
print(c2)

#w但是其中有个most_common方法可以统计最高频率的数据
print(c2.most_common(3))


import re
#统计单词频率
text = 'this is a test ,and this is a good example, so you can learn a lot'
words = re.split('\W+',text)
print(words)
c3 = Counter(words)
print(c3)
print(c3.most_common(4))
#####################################################
#根据字典值的大小，进行排序
#优先使用内置函数sorted
print(sorted([9,2,10,22,1,5]))

data = {x:randint(60,90) for x in "abcxyz"}
print(data)

#默认只排序key，但不是按照value排序的
print(sorted(data))
#可以考虑将字典变成tuple，使用zip函数.
#sorted可以对元组进行排序进行排序
print(sorted([(10,'a'),(1,'dd'),(31,'dddd')]))
z = zip(data.values(),data.keys())
#这里返回的也是一个可迭代对象了
#print(list(z))
print(list(sorted(z)))
#也可以使用返回迭代值，而不是一次性全部返回
#p3已经不支持这个方法了
#z=zip(data.itervalues(), data.iterkeys())
#print(list(z))

#也可以自己定义排序函数
print(list(sorted(data.items(),key=lambda x:x[1])))

######################################################
#如何得到多个字典中的公共key
#取样函数
from random import sample
data = sample('abcdefgh',randint(3,7))
print(data)

s1 = {x:randint(1,4) for x in sample('abcdefg',randint(3,6))}
print(s1)
s2 = {x:randint(1,4) for x in sample('abcdefg',randint(3,6))}
print(s2)
s3 = {x:randint(1,4) for x in sample('abcdefg',randint(3,6))}
print(s3)

#可以使用集合运算操作，也就是集合的交集操作
#s.viewkeys可以得以一个类似于集合的对象
#但是P3好像不支持了
#print(s1.viewkeys())
#可以这样做：将key转化为集合
s1Set = set(s1.keys())
s2Set= set(s2.keys())
s3Set = set(s3.keys())
print(s1Set,s2Set,s3Set)
#从key得到集合，得到list都可以
print(list(s1.keys()))

#下面可以进行集合的运算
print(s1Set & s2Set)

#可以使用map函数，对每个成员都进行运算
#这样可以得到三个列表，其内容都是各个key
#map函数是集中对大量元素统一处理，处理过程
#是个函数，可以复杂，也可以简单
'''这里体现了函数式编程，以函数为中心，有输入，有输出

print(list(map(lambda x :x*2,[1,2,3,4])))

[2, 4, 6, 8]
print(list(map(lambda x :x*2,[1,2,3,4,[1,2]])))
[2, 4, 6, 8, [1, 2, 1, 2]]
'''
print(list(map(dict.keys,[s1,s2,s3])))
from functools import reduce
#再使用reduce函数进行处理,reduce是将前一个结果和下一个元素进行运算，这个比较符合思想
#也就是连续执行相同的动作
print(reduce(lambda a,b:a&b, list(map(dict.keys,[s1,s2,s3]))))


#普通的字典是无序的，
d={}
d['a'] = (1,19)
d['b'] = (2,11)
d['c'] = (3,22)
print(d)
for k in d:print(k)
for k,v in d.items(): print(k,v)


#可以使用有序字典,它是按照进入字典的次序迭代的
from collections import OrderedDict
d=OrderedDict()
d['a'] = (1,19)
d['b'] = (2,11)
d['c'] = (3,22)
for k in d:print(k)
for k,v in d.items(): print(k,v)


其对应结果：

[-1, 87, 52, 74, -3, 1, 70, 51, 85, 5]
[87, 52, 74, 1, 70, 51, 85, 5]
[87, 52, 74, 1, 70, 51, 85, 5]
{1: 73, 2: 75, 3: 67, 4: 90, 5: 82}
{}
{1: 83, 2: 85, 3: 77, 4: 100, 5: 92}
{39, 72, 77, 15, 83, 89, -6, -3, 95}
{72, -6, 15, -3, 39}
jim
10
jim
Student(name='jjj', age=10, sex='male')
Student(name='aaaaa', age=120, sex='dddd')
aaaaa
True
[5, 3, 5, 1, 8, 0, 10, 9, 3, 4, 2, 5, 0, 9, 10, 1]
{0: 0, 1: 0, 2: 0, 3: 0, 4: 0, 5: 0, 8: 0, 9: 0, 10: 0}
{0: 2, 1: 2, 2: 1, 3: 2, 4: 1, 5: 3, 8: 1, 9: 2, 10: 2}
Counter({5: 3, 0: 2, 1: 2, 3: 2, 9: 2, 10: 2, 2: 1, 4: 1, 8: 1})
[(5, 3), (0, 2), (1, 2)]
['this', 'is', 'a', 'test', 'and', 'this', 'is', 'a', 'good', 'example', 'so', 'you', 'can', 'learn', 'a', 'lot']
Counter({'a': 3, 'is': 2, 'this': 2, 'you': 1, 'lot': 1, 'and': 1, 'so': 1, 'example': 1, 'learn': 1, 'test': 1, 'can': 1, 'good': 1})
[('a', 3), ('is', 2), ('this', 2), ('you', 1)]
[1, 2, 5, 9, 10, 22]
{'x': 80, 'z': 67, 'b': 74, 'a': 75, 'y': 63, 'c': 90}
['a', 'b', 'c', 'x', 'y', 'z']
[(1, 'dd'), (10, 'a'), (31, 'dddd')]
[(63, 'y'), (67, 'z'), (74, 'b'), (75, 'a'), (80, 'x'), (90, 'c')]
[('y', 63), ('z', 67), ('b', 74), ('a', 75), ('x', 80), ('c', 90)]
['f', 'a', 'e', 'b', 'c', 'h', 'g']
{'b': 3, 'a': 2, 'c': 2, 'g': 4, 'f': 1, 'd': 4}
{'b': 4, 'f': 1, 'g': 4}
{'e': 1, 'b': 1, 'f': 4, 'g': 1, 'c': 3}
{'a', 'g', 'c', 'f', 'b', 'd'} {'b', 'f', 'g'} {'e', 'b', 'f', 'g', 'c'}
['b', 'a', 'c', 'g', 'f', 'd']
{'b', 'f', 'g'}
[dict_keys(['b', 'a', 'c', 'g', 'f', 'd']), dict_keys(['b', 'f', 'g']), dict_keys(['e', 'b', 'f', 'g', 'c'])]
{'b', 'f', 'g'}
{'b': (2, 11), 'a': (1, 19), 'c': (3, 22)}
b
a
c
b (2, 11)
a (1, 19)
c (3, 22)
a
b
c
a (1, 19)
b (2, 11)
c (3, 22)