11个编程小技巧，使用起来更省心

正在学 Python 的你并不孤单，有我在这里陪着你每天学习一个 Python 小技术。今天我为初学者整理了 11 个编程小技巧，使用起来非常省心，相信你看完定会有所收获。

公司主营业务：成都网站设计、网站建设、移动网站开发等业务。帮助企业客户真正实现互联网宣传，提高企业的竞争能力。成都创新互联是一支青春激扬、勤奋敬业、活力青春激扬、勤奋敬业、活力澎湃、和谐高效的团队。公司秉承以“开放、自由、严谨、自律”为核心的企业文化，感谢他们对我们的高要求，感谢他们从不同领域给我们带来的挑战，让我们激情的团队有机会用头脑与智慧不断的给客户带来惊喜。成都创新互联推出仓山免费做网站回馈大家。

1、合并(Merge)两个字典

有两个字典，dict1、dict2，想把 dict2 的内容合并(Merge)到 dict1 中，可以使用 dict1.update(dict2)

 
 
 
 
    
  
  
  
  
  1. In [1]: dict1 = { 'a': 1, 'b': 2}
    2. 
  
  
  
  
  2. 
  
  
  
  
  3. In [2]: dict2 = { 'b': 3, 'd': 4}
    4. 
  
  
  
  
  4. 
  
  
  
  
  5. In [3]: dict1.update(dict2)
    6. 
  
  
  
  
  6. 
  
  
  
  
  7. In [4]: dict1
    8. 
  
  
  
  
  8. Out[4]: {'a': 1, 'b': 3, 'd': 4}
    9. 
  
  
  
  
  9. 
  
  
  
  
  10. In [5]: 
    11.

2、合并(Merge)两个字典，但不能改变原始字典

有两个字典，dict1、dict2，现在要把 dict1、dict2 的内容合并(Merge)到 dict3 中，有两种方法：

方法一

 
 
 
 
    
  
  
  
  
  1. dict3 = {}
    2. 
  
  
  
  
  2. dict3.update(dict1)
    3. 
  
  
  
  
  3. dict3.update(dict2)
    4.

方法二

 
 
 
 
    
  
  
  
  
  1. dict3 = {**dict1, **dict2}
    2.

方法二使用了 ** 来解包字典，非常简洁和优雅，推荐使用。

3、对包含字典的列表进行排序

假如有这样的列表：

[{"name": "张三", "age": 30 },{"name": "李四", "age": 10 },{"name": "王武", "age": 15 }]

其内部元素是一个字典，如何进行自定义排序呢?比如按照 age 进行排序：

 
 
 
 
    
  
  
  
  
  1. list1 = [{"name": "张三", "age": 30 },{"name": "李四", "age": 10 },{"name": "王武", "age": 15 }]
    2. 
  
  
  
  
  2. list1.sort(key = lambda x: x["age"])
    3. 
  
  
  
  
  3. print(list1)
    4. 
  
  
  
  
  4. 
  
  
  
  
  5. [{'name': '李四', 'age': 10},
    6. 
  
  
  
  
  6.  {'name': '王武', 'age': 15},
    7. 
  
  
  
  
  7.  {'name': '张三', 'age': 30}]
    8.

如果不能改变 list1 原有的次序，可以使用内建函数 sorted，sorted 返回排序后的结果，并不改变原始顺序：

 
 
 
 
    
  
  
  
  
  1. list1 = [{"name": "张三", "age": 30 },{"name": "李四", "age": 10 },{"name": "王武", "age": 15 }]
    2. 
  
  
  
  
  2. sorted_list = sorted(list1, key = lambda x: x["age"])
    3. 
  
  
  
  
  3. print(sorted_list)
    4. 
  
  
  
  
  4. 
  
  
  
  
  5. [{'name': '李四', 'age': 10},
    6. 
  
  
  
  
  6.  {'name': '王武', 'age': 15},
    7. 
  
  
  
  
  7.  {'name': '张三', 'age': 30}]
    8.

4、检查文件是否存在

方法一，使用 os.path 模块

 
 
 
 
    
  
  
  
  
  1. In [2]: import os
    2. 
  
  
  
  
  2. 
  
  
  
  
  3. In [3]: if os.path.exists("/usr/bin/passwd"):
    4. 
  
  
  
  
  4.    ...:     print("存在")
    5. 
  
  
  
  
  5.    ...:
    6. 
  
  
  
  
  6. 存在
    7.

方法二、使用 pathlib(推荐使用)

 
 
 
 
    
  
  
  
  
  1. In [4]: from pathlib import Path
    2. 
  
  
  
  
  2. 
  
  
  
  
  3. In [5]: if Path("/usr/bin/passwd").exists():
    4. 
  
  
  
  
  4.    ...:     print("存在")
    5. 
  
  
  
  
  5.    ...:
    6. 
  
  
  
  
  6. 存在
    7.

关于 pathlib 为什么比 os.path 好用，可以阅读求求你，别用 os.path 了。

5、获取某个目录最新的文件或目录

 
 
 
 
    
  
  
  
  
  1. In [7]: import glob
    2. 
  
  
  
  
  2.    ...: import os
    3. 
  
  
  
  
  3.    ...:
    4. 
  
  
  
  
  4.    ...: list_of_files = glob.glob('/Users/aaron/*') # * means all if need specific format
    5. 
  
  
  
  
  5.    ...:  then *.csv
    6. 
  
  
  
  
  6.    ...: latest_file = max(list_of_files, key=os.path.getctime)
    7. 
  
  
  
  
  7.    ...: print(latest_file)
    8. 
  
  
  
  
  8.    ...:
    9. 
  
  
  
  
  9. /Users/aaron/web-service-gin
    10.

更推荐你使用 pathlib

 
 
 
 
    
  
  
  
  
  1. from pathlib import Path
    2. 
  
  
  
  
  2. folder_path = Path('/Users/aaron')
    3. 
  
  
  
  
  3. list_of_paths = folder_path.glob('*')
    4. 
  
  
  
  
  4. latest_path = max(list_of_paths, key = lambda p: p.stat().st_ctime)
    5.

6、随机密码生成器

将以下内容保存为 generate_random_password.py：

 
 
 
 
    
  
  
  
  
  1. import string
    2. 
  
  
  
  
  2. import random
    3. 
  
  
  
  
  3. 
  
  
  
  
  4. def generate_random_password():
    5. 
  
  
  
  
  5.     ## 输入密码长度
    6. 
  
  
  
  
  6.     length = int(input("请输入密码长度："))
    7. 
  
  
  
  
  7.     
    8. 
  
  
  
  
  8.     ## 密码字符范围
    9. 
  
  
  
  
  9.     characters = list(string.ascii_letters + string.digits + "!@#$%^&*()")
    10. 
  
  
  
  
  10.     random.shuffle(characters)
    11. 
  
  
  
  
  11.     
    12. 
  
  
  
  
  12.     ## 随机选择字符
    13. 
  
  
  
  
  13.     password = []
    14. 
  
  
  
  
  14.     for i in range(length):
    15. 
  
  
  
  
  15.         password.append(random.choice(characters))
    16. 
  
  
  
  
  16. 
  
  
  
  
  17.     random.shuffle(password)
    18. 
  
  
  
  
  18. 
  
  
  
  
  19.     ## 现实生成的密码
    20. 
  
  
  
  
  20.     print("".join(password))
    21. 
  
  
  
  
  21. 
  
  
  
  
  22. if __name__ == "__main__":
    23. 
  
  
  
  
  23. 
  
  
  
  
  24.     generate_random_password()
    25.

执行结果

 
 
 
 
    
  
  
  
  
  1. python generate_random_password.py
    2. 
  
  
  
  
  2. 请输入密码长度：6
    3. 
  
  
  
  
  3. i3o!(o
    4.

7、将两个列表转换为一个字典

 
 
 
 
    
  
  
  
  
  1. list1 = ['a', 'b', 'c']
    2. 
  
  
  
  
  2. list2 = [1, 2, 3]
    3. 
  
  
  
  
  3. dictionary = dict(zip(list1, list2))
    4. 
  
  
  
  
  4. print(dictionary) # {'a': 1, 'b': 2, 'c': 3}
    5.

8、测量小代码片段的执行时间

 
 
 
 
    
  
  
  
  
  1. import timeit
    2. 
  
  
  
  
  2. start = timeit.default_timer()
    3. 
  
  
  
  
  3. [i for i in range(100000)]
    4. 
  
  
  
  
  4. stop = timeit.default_timer()
    5. 
  
  
  
  
  5. print(stop - start)
    6.

timeit 是标准库提供的计时工具，还可以在命令行这样使用：

示例 1：命令行界面来比较三个不同的表达式。

 
 
 
 
    
  
  
  
  
  1. $ python3 -m timeit '"-".join(str(n) for n in range(100))'
    2. 
  
  
  
  
  2. 10000 loops, best of 5: 30.2 usec per loop
    3. 
  
  
  
  
  3. $ python3 -m timeit '"-".join([str(n) for n in range(100)])'
    4. 
  
  
  
  
  4. 10000 loops, best of 5: 27.5 usec per loop
    5. 
  
  
  
  
  5. $ python3 -m timeit '"-".join(map(str, range(100)))'
    6. 
  
  
  
  
  6. 10000 loops, best of 5: 23.2 usec per loop
    7.

示例 2：通过代码中比较三个不同的表达式。

 
 
 
 
    
  
  
  
  
  1. >>>
    2. 
  
  
  
  
  2. >>> import timeit
    3. 
  
  
  
  
  3. >>> timeit.timeit('"-".join(str(n) for n in range(100))', number=10000)
    4. 
  
  
  
  
  4. 0.3018611848820001
    5. 
  
  
  
  
  5. >>> timeit.timeit('"-".join([str(n) for n in range(100)])', number=10000)
    6. 
  
  
  
  
  6. 0.2727368790656328
    7. 
  
  
  
  
  7. >>> timeit.timeit('"-".join(map(str, range(100)))', number=10000)
    8. 
  
  
  
  
  8. 0.23702679807320237
    9.

timeit 内部还可以传入一个可调用对象:

 
 
 
 
    
  
  
  
  
  1. >>> def fun():
    2. 
  
  
  
  
  2. ...     return "-".join(map(str, range(100)))
    3. 
  
  
  
  
  3. ... 
    4. 
  
  
  
  
  4. >>> import timeit
    5. 
  
  
  
  
  5. >>> timeit.timeit(fun, number=10000)
    6. 
  
  
  
  
  6. 0.16171755199999893
    7. 
  
  
  
  
  7. >>> 
    8.

9、统计列表中频率最高的元素

 
 
 
 
    
  
  
  
  
  1. def most_frequent(list):
    2. 
  
  
  
  
  2.   return max(set(list), key=list.count)
    3. 
  
  
  
  
  3. 
  
  
  
  
  4. mylist = [1,1,2,3,4,5,5,1,2,1,]
    5. 
  
  
  
  
  5. print("频率最高的元素: ", most_frequent(mylist))
    6.

10、如何避免冗长的 if else 分支

简单来说，就是借助于字典，把策略写在字典里面，比如设计一个函数，计算两个数的加、减、乘、除、n 次方

 
 
 
 
    
  
  
  
  
  1. def calculate(action_des: str, a:int,b:int) -> int:
    2. 
  
  
  
  
  2.  if action_des == '+':
    3. 
  
  
  
  
  3.   return a+b
    4. 
  
  
  
  
  4.  elif action_dex == '-':
    5. 
  
  
  
  
  5.   return a-b
    6. 
  
  
  
  
  6.  elif action_dex == '*':
    7. 
  
  
  
  
  7.   return a*b
    8. 
  
  
  
  
  8.  elif action_dex == '/':
    9. 
  
  
  
  
  9.   return a/b
    10. 
  
  
  
  
  10.  elif action_dex == '**':
    11. 
  
  
  
  
  11.   return a**b
    12.

借助于字典，可以不需要使用 if else：

 
 
 
 
    
  
  
  
  
  1. import operator
    2. 
  
  
  
  
  2. 
  
  
  
  
  3. def calculate(action_des: str, a:int,b:int) -> int:
    4. 
  
  
  
  
  4.  action = {
    5. 
  
  
  
  
  5.   "+": operator.add,
    6. 
  
  
  
  
  6.   "-": operator.sub,
    7. 
  
  
  
  
  7.   "/": operator.truediv,
    8. 
  
  
  
  
  8.   "*": operator.mul,
    9. 
  
  
  
  
  9.   "**": pow
    10. 
  
  
  
  
  10.     }
    11. 
  
  
  
  
  11.  return action[action_des](a, b)
    12.

这也是设计模式中的策略模式的最小示例。

11、让列表内的元素随机排列一下

 
 
 
 
    
  
  
  
  
  1. import random
    2. 
  
  
  
  
  2. 
  
  
  
  
  3. MyList = [1, 2, 3, 4]
    4. 
  
  
  
  
  4. random.shuffle(MyList)
    5. 
  
  
  
  
  5. print(MyList) # [3, 4, 2, 1]
    6.

最后

以上 11 个编程小技巧，如果有帮助，点个赞再滑走吧。

本文转载自微信公众号「 Python七号」，可以通过以下二维码关注。转载本文请联系 Python七号公众号。

网页标题：11个编程小技巧，使用起来更省心
网页网址：http://www.shufengxianlan.com/qtweb/news46/4896.html

网站建设、网络推广公司-创新互联，是专注品牌与效果的网站制作，网络营销seo公司；服务项目有等

广告

声明：本网站发布的内容（图片、视频和文字）以用户投稿、用户转载内容为主，如果涉及侵权请尽快告知，我们将会在第一时间删除。文章观点不代表本网站立场，如需处理请联系客服。电话：028-86922220；邮箱：631063699@qq.com。内容未经允许不得转载，或转载时需注明来源： 创新互联

猜你还喜欢下面的内容

网站设计公司知识

行业网站建设

兴发搬家　　 　成都网站制作　　 　成都网站设计　　 　广安网站建设　　 　营销型网站建设　　 　成都网站设计公司　　 　网站服务器租用　　 　定制网站建设　　 　普能电气　　 　娃娃鱼鱼苗　　 　成都移动服务器托管　　 　雅安托管服务器　　 　成都租用服务器　　 　四川成都网站建设　　 　SSL证书　　 　盐亭网站建设　　 　教育网站设计方案　　 　网络营销　　 　重庆APP开发　　 　网站ssl证书