Python3实用编程技巧进阶

Python3实用编程技巧进阶

1.1.如何在列表中根据条件筛选数据

 

# 1.1. 如何在列表中根据条件筛选数据

 

data = [-1, 2, 3, -4, 5]

 

# 筛选出 data 列表中大于等于零的数据

# 第一种方法,不推荐

res1 = []

for x in data:

    if x >= 0:

        res1.append(x)

 

print(res1)

 

# 第二种用列表解析,推荐使用

res2 = [ x for x in data if x >= 0]

print(res2)

 

# 第三种用 filter 函数

res3 = list(filter(lambda x : x>= 0,data))

print(res3)

 

1.2.如何在字典中根据条件筛选数据

 

# 1.2. 如何在字典中根据条件筛选数据

 

from random import randint

 

# 创建学生字典 , 学号为 1~20 ,分数为 50~100 随机

d = {‘student%d’% i: randint(50,100) for i in range(1,21)}

print(d)

 

# 过滤出分数为 90 的学生字典

# 第一种方法

d1 = {k:v for k,v in d.items() if v >= 90}

print(d1)

 

# 第二种方法

d2 = dict(filter(lambda item:item[1] >= 90, d.items()))

print(d2)

 

1.3.如何在集合中根据条件筛选数据

 

# 1.3. 如何在集合中根据条件筛选数据

 

from random import randint

 

s = {randint(0,20) for _ in range(20)}

print(s)

 

# 筛选出能被 3 整除的数

s1 = {x for x in s if x % 3 == 0}

print(s1)

 

1.4.如何为元祖中的每个元素命名,提高程序可读性

 如下元祖,通过函数判断年龄和性别,但是这样代码可读性很差,别人并不知道student[1],student[2]代表什么意思。如何解决呢

 

def func(student):

    if student[1] < 18 :

        pass

 

    if student[2] == ‘male’:

        pass

 

student = (‘derek’,22,’male’,’111@qq.com’)

 

func(student)

 

方案一:定义枚举类型

 

#1.4.. 如何为元祖中的每个元素命名,提高程序可读性

 

def func(student):

    if student[1] < 18 :

        pass

 

    if student[2] == ‘male’:

        pass

 

s1 = (‘derek’,22,’male’,’111@qq.com’)

 

# 第一种:使用枚举

from enum import IntEnum

 

class StudentEnum(IntEnum):

    NAME = 0

    AGE = 1

    SEX = 2

    EMAIL = 3

 

print(s1[StudentEnum.NAME])

print(s1[StudentEnum.AGE])

 

方案二:使用标准库中collections.namedtuple替代内置tuple

 

#1.4.. 如何为元祖中的每个元素命名,提高程序可读性

 

def func(student):

    if student[1] < 18 :

        pass

 

    if student[2] == ‘male’:

        pass

 

s1 = (‘derek’,22,’male’,’111@qq.com’)

 

# 第一种:使用枚举

from enum import IntEnum

 

class StudentEnum(IntEnum):

    NAME = 0

    AGE = 1

    SEX = 2

    EMAIL = 3

 

print(s1[StudentEnum.NAME])

print(s1[StudentEnum.AGE])

 

# 第二种:使用标准库中 collections.namedtuple 替代内置 tuple

from collections import namedtuple

 

Student = namedtuple(‘student’,[‘name’,’age’,’sex’,’email’])

s2 = Student(‘derek’,22,’male’,’222@qq.com’)

print(s2[0])               #derek

# 可以通过 s2.name 获取姓名

print(s2.name)             #derek

 

 

1.5.如何根据字典中值的大小,对字典中的项进行排序

第一种方法:列表解析

 

# 1.5. 如何根据字典中值的大小,对字典中的项进行排序

 

from random import randint

 

d = {k: randint(60, 100) for k in ‘abcdefg’}

print(d)

# 第一种方法:使用列表解析或者 zip() 函数 , 把字典的 keys values 反转过来

list1 = [(v,k) for k,v in d.items()]

# 或者使用 zip() 函数

# list2 = list(zip(d.values(),d.keys()))

print(list1)

list1 = sorted(list1,reverse=True)

print(list1)

 

第二种使用sorted

 

# 1.5. 如何根据字典中值的大小,对字典中的项进行排序

 

from random import randint

 

d = {k: randint(60, 100) for k in ‘abcdefg’}

print(d)

# 第一种方法:使用列表解析或者 zip() 函数 , 把字典的 keys values 反转过来

list1 = [(v,k) for k,v in d.items()]

# 或者使用 zip() 函数

# list2 = list(zip(d.values(),d.keys()))

 

list1 = sorted(list1,reverse=True)

 

 

# 第二种方法:使用 sorted 排序

p = sorted(d.items(),key=lambda item:item[1],reverse=True)

print(p)     #[(‘a’, 97), (‘b’, 93), (‘d’, 93), (‘e’, 92), (‘f’, 76), (‘c’, 66), (‘g’, 61)]

 

# 对分数添加一个排名

d = {k:(i,v) for i, (k,v) in enumerate(p,1)}

print(d)    #{‘g’: (1, 97), ‘d’: (2, 92), ‘f’: (3, 91), ‘c’: (4, 79), ‘a’: (5, 78), ‘e’: (6, 67), ‘b’: (7, 64)}

 

1.6.如何统计序列中元素的频度

 

# 1.6 如何统计序列中元素的频度

from random import randint

from collections import Counter

 

data = [randint(1,5) for _ in range(1,20)]

print(data)   #[5, 2, 1, 2, 5, 3, 1, 1, 1, 4, 2, 5, 3, 2, 3, 5, 1, 2, 5]

 

# 计算频度最高的是三个数

c = Counter(data)

print(c.most_common(3))    #[(1, 5), (3, 4), (2, 4)]

 

1.7.如何快速找到多个字典中的公共键

 

# 1.7. 如何快速找到多个字典中的公共键

 

from random import randint,sample

from functools import reduce

 

d1 = {k:randint(1,4) for k in sample(‘abcdefgh’,randint(3,6))}

d2 = {k:randint(1,4) for k in sample(‘abcdefgh’,randint(3,6))}

d3 = {k:randint(1,4) for k in sample(‘abcdefgh’,randint(3,6))}

 

#1. 使用字典的 keys() 方法,得到一个字典 keys 的集合

#2. 使用 map 函数,得到每个字典 keys 的集合

#3. 使用 reduce ,取所有字典 keys 集合的交集

 

dl = [d1,d2,d3]

# 找到三个字典中相同的 keys

result = reduce(lambda a,b: a & b, map(dict.keys, dl))

print(result)

 

1.8.如何让字典保持有序

 

# 1.8. 如何让字典保持有序

 

from collections import OrderedDict

from itertools import islice

 

d = OrderedDict()

d[‘e’] = 5

d[‘d’] = 4

d[‘c’] = 3

d[‘b’] = 2

d[‘a’] = 1

 

print(d)    #OrderedDict([(‘e’, 5), (‘d’, 4), (‘c’, 3), (‘b’, 2), (‘a’, 1)])

 

#OrderedDict 字典,在迭代操作时,它会保持元素被插入时的顺序

 

def query_by_order(d, a, b =None):

    if b is None:

        b = a + 1

    return list(islice(d,a,b))

 

# 第五个 key

res1 = query_by_order(d,4)

print(res1)     #[‘a’]

 

# 第二个和第三个 key

res2 = query_by_order(d,1,3)

print(res2)     #[‘d’, ‘c’]

 

1.9.如何实现用户的历史记录功能

使用容量为n的队列存储历史记录

·  使用deque双端循环队列存储历史记录(deque是保存到内存中,下次启动历史记录会消失)

·  如果想保存到硬盘中,使用pickle模块,以便下次启动使用

 

# 1.9 如何实现用户的历史记录功能

 

from random import randint

from collections import deque

import pickle

 

 

def guess(n, k):

    if n == k:

        print(‘ 猜对了,这个数字是 %d’ % k)

        return True

    if n < k:

        print(‘ 猜大了,比 %d ‘ % k)

    elif n > k:

        print(‘ 猜小了,比 %d ‘ % k)

    return False

 

 

def main():

    n = randint(1, 100)

    i = 1

    hq = deque([], 5)

    while True:

        line = input(‘[%d] 请输入一个数字: ‘ % i)

        if line.isdigit():

            k = int(line)

            hq.append(k)

            i += 1

            if guess(n, k):

                break

        elif line == ‘quit’:

            break

        elif line == ‘history’:

            print(hq)

 

 

if __name__ == ‘__main__’:

    main()

 

# 结果

[1] 请输入一个数字: 1

猜小了,比1

[2] 请输入一个数字: 2

猜小了,比2

[3] 请输入一个数字: 3

猜小了,比3

[4] 请输入一个数字: history

deque([1, 2, 3], maxlen=5)

[4] 请输入一个数字:

 

    原文作者:itman_456
    原文地址: http://blog.itpub.net/69949609/viewspace-2660614/
    本文转自网络文章,转载此文章仅为分享知识,如有侵权,请联系博主进行删除。
点赞