自定义模块

  1. #!/usr/bin/env python3
  2. # author:Alnk(李成果)
  4. # 为什么要有模块？(内置函数不够用)
  5. # 和操作系统打交道
  6. # 和python解释器打交道
  7. # 和时间打交道
  8. # 如何利用python发邮件
  9. # 如何利用python图像识别
  11. # 都是完成好的功能
  12. # 可以被封装成函数
  13. # 可以成为内置的函数
  14. # 占用内存空间
  16. # 整理分类，把相同的功能放在一个文件中
  17. # 我们在开发的过程中，用到哪个功能直接导入使用就可以了
  18. # 不使用的功能不会进入内存占用不必要的空间
  19. # 使用的功能我们可以自由的选择
  21. # 模块的本质
  22. # 就是封装了很多很多函数、功能的一个文件
  24. # 导入模块 就是 import
  26. # 模块的分类
  27. # 内置模块 不需要我们进行额外的安装、随着解释器的安装直接就可以使用的模块
  28. # 扩展模块/第三方模块 我们安装了python解释器之后 如果要使用这些模块还要单独安装
  29.     # https://pypi.org/
  30.     # 豆瓣的 python源
  31. # 自定义模块
  32.     # 自己写的模块
  1. #!/usr/bin/env python3
  2. # author:Alnk(李成果)
  4. # 引用模块相当于执行这个模块
  5. # 重复引用会直接引用内存中已经加载好的模块结果
  6. # import tom
  7. # import tom
  9. # 模块被引用发生了三件事：
  10. # 1，创建一个以被导入模块的名字命名的名称空间
  11. # 2，自动执行模块中的代码（将模块中的所有内容加载到内存）
  12. # 3，要想执行模块中的代码必须通过模块名.的方式执行获取
  14. from tom import change
  15. import tom
  16. print(tom.name)  # 汤姆
  17. tom.read1()  # tom模块： 汤姆
  18. name = '杰瑞'
  19. print(tom.name)  # 汤姆
  20. print(name)  # 杰瑞
  21. print("------------------ 1 ---------------------")
  23. # 模块的改名
  24. # 1,模块名过长，引用不方便，给模块改名，简化引用。
  25. import abcdpythonuser as ab
  26. print(ab.age)  # 18
  27. ab.func()  # 666
  28. print("------------------ 2 ---------------------")
  30. # 2, 优化代码。
  31. # import mysql
  32. # import oracle
  33. # db_sql = input('>>> ')
  34. # if db_sql == 'mysql':
  35. #     mysql.sql_parse()
  36. # elif db_sql == 'orcle':
  37. #     orcle.sql_parse()
  39. # 改版
  40. # db_sql = input('>>> ')
  41. # if db_sql == 'mysql':
  42. #     import mysql as db
  43. # elif db_sql == 'oracle':
  44. #     import orcle as db
  45. # db.sql_parse()
  46. # print("------------------ 3 ---------------------")
  48. # 引用多个模块
  49. # 标准的：
  50. # import mysql
  51. # import time
  52. # import sys
  53. # 不建议：
  54. # import mysql,time,os,sys
  56. # from ..... import .....
  57. # 执行过程:
  58. # 1，执行一遍tom的所有代码，加载到内存。
  59. # 2，将name，read1这些实际引用过来的变量函数在本文件复制一份。
  60. # globals()查看
  61. # 好处：使用简单
  62. # 坏处：容易与本文件的变量，函数名等发生冲突
  63. from tom import change,name,read1
  64. name = '小虎'
  65. def read1():
  66.     print(666)
  67. print(name)  # 小虎
  68. read1()  #666
  69. from tom import change,name,read1
  70. print(name)  # 汤姆
  71. read1()  # tom模块： 汤姆
  72. # print(globals())
  73. print("------------------ 4 ---------------------")
  75. # 起别名：
  76. from tom import read1 as r
  77. r()
  78. print("------------------ 5 ---------------------")
  80. #导入多个：
  81. # 方式一
  82. # from tom import name
  83. # from tom import raed1
  84. # 方式2
  85. # from tom import name,read1,read2
  86. print("------------------ 6 ---------------------")
  88. # 导入所有：一般不用
  89. # from tom import *
  90. # print(globals())
  92. # 如果使用只有两点：
  93. # 1，将导入的模块中的所有的代码全部清楚的前提下，可以使用 *
  94. # from time import time
  95. # 2，只是用一部分
  96. # from tom import *
  97. # read1()
  98. # read2()
  99. # read3()
  100. # change()
  102. # import tom
  103. # 文件有个两个作用：
  104. # 1，作为脚本，直接运行
  105. # 2，作为模块供别人使用。
  106. # 3， __name__ == '__main__' 可以作为一个项目的启动文件用。
  108. # 模块的搜索路径
  109. # 先从内存中寻找  -----> built-in 内置模块 -----> sys.path找
  111. import sys
  112. print(sys.path)  #  返回一个列表 ，列表的第一个参数就当前目录。
  113. print("------------------ 7 ---------------------")

tom.py

  1. # -*- coding: utf-8 -*-
  2. # __all__ = ['read1','read2']  # 控制 * 的范围。 from tom import * 只会导入 read1 read2
  3. print('from the tom.py')
  5. name = '汤姆'
  7. def read1():
  8.     print('tom模块：', name)
  10. def read2():
  11.     print('tom模块')
  12.     read1()
  14. def read3():
  15.     print('read3....')
  17. def read4():
  18.     # dic = dict([('a', 1), ('b', 2), ('c', 3)])
  19.     # print(dic)
  20.     l1 = [1,2,3]
  21.     l2 = ['a','b','c']
  22.     print(dict(zip(l1,l2)))
  24. def change():
  25.     global name
  26.     name = 'tom'
  27.     # print(666)
  28.     # return name
  30. # read4()
  31. # print(__name__)  # 在本文件运行，__name__ == __mian__
  33. if __name__ == '__main__':
  34.     read3()

abcdpythonuser.py

  1. #!/usr/bin/env python3
  2. # author:Alnk(李成果)
  3. age = 18
  5. def func():
  6.     print(666)

mysql.py

  1. #!/usr/bin/env python3
  2. # author:Alnk(李成果)
  4. def sql_parse():
  5.     print('from mysql sql parse')

oracle.py

  1. #!/usr/bin/env python3
  2. # author:Alnk(李成果)
  4. def sql_parse():
  5.     print('from mysql sql parse')

常用内置模块

time模块

  1. #!/usr/bin/env python3
  2. # author:Alnk(李成果)
  4. # time模块 和时间打交道的模块
  5. import time
  7. # 1.时间戳时间 time.time()
  8. print(time.time())  # 1618384314.988371 时间戳格式
  10. # float 小数
  11. # 为什么时间要用这种格式(1618384314.988371)表示？
  12. # 是给计算机看的
  13. # '2019/1/27 11:13'
  14. # 1970 1 1 0:0:0 英国伦敦的时间 0时区
  15. # 1970 1 1 8:0:0 北京的时间 东8区
  16. print("--------------- 1 ---------------------------")
  18. # 2.格式化时间 time.strftime('%Y-%m-%d %H:%M:%S')
  19. t1 = time.strftime('%Y-%m-%d %H:%M:%S')
  20. print(t1)
  21. t1 = time.strftime('%Y+%m+%d %H:%M:%S %a')
  22. print(t1)
  23. t1 = time.strftime('%Y+%m+%d %H:%M:%S %A %b %B')
  24. print(t1)
  25. t1 = time.strftime('%c')
  26. print(t1)
  27. print("--------------- 2 ---------------------------")
  29. # 3.结构化时间（时间元组） time.localtime()
  30. # time.struct_time(tm_year=2021, tm_mon=4, tm_mday=14, tm_hour=15, tm_min=18, tm_sec=52, tm_wday=2, tm_yday=104, tm_isdst=0)
  31. # print(time.localtime())
  32. # tm_year=2019 --- 年
  33. # tm_mon=1     ---月
  34. # tm_mday=28,   ---日
  35. # tm_hour=11,  ---时
  36. # tm_min=33,  ---分
  37. # tm_sec=1,   ---秒
  38. # tm_wday=0,  --- 一周的第几天，星期一为0
  39. # tm_yday=28,  ---  一年的第几天
  40. # tm_isdst=0  --- 是否是夏令时，默认不是
  42. # 转换只能通过结构化时间进行转换
  43. # 时间戳格式 <---> 结构化时间 <---> 格式化时间
  44. # 1548558746.5218766                        '2019/1/27 11:13'
  45. #   计算机能看懂的    (为了进行数据转换)    人能看懂的
  46. #   时间戳时间         结构化时间           格式化时间
  47. #   time.time()       time.localtime()      time.strftime('%Y-%m-%d %H:%M:%S')
  49. # 举例1
  50. # 格式化时间 2018-8-8  ---> 时间戳时间
  51. # 1.1，先把格式化时间 转化成 元组时间
  52. str_time = '2018-8-8'
  53. struct_time = time.strptime(str_time, '%Y-%m-%d')
  54. print(struct_time)
  55. # 1.2，在转化成时间戳
  56. stamp_time = time.mktime(struct_time)
  57. print(stamp_time)
  58. print("--------------- 3.1 ---------------------------")
  60. # 举例2
  61. # 2000000000 转化为格式化时间
  62. # 2.1，先把时间戳时间转化为元组时间
  63. stamp_t = 2000000000
  64. struct_t = time.localtime(stamp_t)
  65. print(struct_t)
  66. # 2.2，再把元组时间转为格式化时间
  67. strftime_t = time.strftime('%Y-%m-%d %H:%M:%S', struct_t)
  68. print(strftime_t)
  69. print("--------------- 3.2 ---------------------------")
  71. # 小练习1
  72. # 拿到本月时间1号的时间戳时间
  73. # 1，拿到本月的格式化时间
  74. strftime_t = time.strftime('%Y-%m')
  75. print(strftime_t)
  76. # 2，转化为结构化元组时间
  77. struct_t = time.strptime(strftime_t, '%Y-%m')
  78. print(struct_t)
  79. # 3，转化为时间戳时间
  80. stamp_t = time.mktime(struct_t)
  81. print(stamp_t)
  82. print("--------------- 4 ---------------------------")
  84. # 小练习2
  85. # '2017-09-11 08:30:00' '2018-09-13 08:30:10' 计算这两个时间段的时间差
  86. # 先把格式化时间--->元组时间--->时间戳时间
  87. t1 = time.mktime(time.strptime('2017-09-11 08:30:00', '%Y-%m-%d %H:%M:%S'))
  88. t2 = time.mktime(time.strptime('2018-09-13 08:30:10', '%Y-%m-%d %H:%M:%S'))
  89. print(t1)
  90. print(t2)
  91. ret = t2 - t1
  92. struct_t = time.gmtime(ret)
  93. print(struct_t)
  94. print('相差%d年%d月%d天%d小时%d分钟%d秒' % (
  95.     struct_t.tm_year - 1970,
  96.     struct_t.tm_mon - 1,
  97.     struct_t.tm_mday - 1,
  98.     struct_t.tm_hour - 0,
  99.     struct_t.tm_min - 0,
  100.     struct_t.tm_sec - 0,
  101. ))

datetime模块

  1. #!/usr/bin/env python3
  2. # author:Alnk(李成果)
  3. import datetime
  5. now_time = datetime.datetime.now()
  6. print(now_time)  # 2021-04-14 15:29:52.021695
  7. print(now_time + datetime.timedelta(weeks=3))
  8. print(now_time + datetime.timedelta(weeks=-3))
  9. print(now_time + datetime.timedelta(days=-3))
  10. print(now_time + datetime.timedelta(days=3))
  11. print(now_time + datetime.timedelta(hours=3))
  12. print("-------- 1 -----------")
  14. # 直接调整
  15. print(now_time.replace(year=2010))
  16. print(now_time.replace(month=10))
  17. print(now_time.replace(year=1989, month=4, day=25))
  18. print(now_time.replace(year=1989, month=4, day=25, hour=14, minute=10, second=10))
  19. print("-------- 2 -----------")
  21. print(datetime.date.fromtimestamp(time.time()))

logging模块

  1. #!/usr/bin/env python3
  2. # author:Alnk(李成果)
  4. # logging
  5. # 什么时候需要打印日志？
  6. # 任何操作？
  7. # 个性化推荐，淘宝，京东，知乎，网易云音乐等等
  8. # 只要给你做记录，都可以当做广义的日志
  10. # 开发中的日志：
  11. # 1,日志帮助你调试代码
  12. # 2,代码的警告，危险提示作用
  13. # 3,你对服务器的操作命令
  14. # 4,重要的节点，需要日志提示
  16. # 低配
  17. # 低配版：不能同时屏幕输出和文件写入
  18. # import logging
  19. # import time
  20. # logging.debug('debug message')  # 调试模式
  21. # logging.info('info message')  # 正常运转模式
  22. # logging.warning('warning message 1')  # 警告模式
  23. # logging.error('error message 2')  # 错误模式
  24. # logging.critical('critical message 3')  # 致命的 崩溃模式
  25. #
  26. # while 1:
  27. #     try:
  28. #         num = input('>>>:')
  29. #         int(num)
  30. #     except ValueError:
  31. #         logging.warning('输入非数字元素，警告！')
  32. #         time.sleep(1)
  33. #         break
  34. # print("-------------- 1 --------------------")
  36. # 制定显示信息格式
  37. # import logging
  38. # logging.basicConfig(
  39. #     # level=logging.DEBUG,
  40. #     level=20,  # 设置级别
  41. #     format='%(asctime)s %(filename)s [line:%(lineno)d] %(levelname)s %(message)s',
  42. #     # datefmt='%a, %d %b %Y %H:%M:%S',  # 显示时间格式
  43. #     # filename='test.log',
  44. #     # filemode='w'
  45. # )
  46. # logging.debug('debug message 1')  # 调试模式  10
  47. # logging.info('info message 2')  # 正常运转模式  20
  48. # logging.warning('warning message 3') # 警告模式  30
  49. # logging.error('error message 4')  # 错误模式  40
  50. # logging.critical('critical message 5')  #致命的 崩溃模式 50
  51. # print("-------------- 2 --------------------")
  53. # # 标配
  54. # # 1.产生logger对象
  55. # import logging
  56. # logger = logging.getLogger()
  57. #
  58. # # 2 产生其他对象(屏幕对象，文件对象)
  59. # sh = logging.StreamHandler()  # 屏幕对象
  60. # fh1 = logging.FileHandler('staff.log', encoding='utf-8')  # 文件对象
  61. # fh2 = logging.FileHandler('boss.log', encoding='utf-8')  # 文件对象
  62. #
  63. # # 3，设置显示格式
  64. # formater = logging.Formatter('%(asctime)s - %(name)s - %(levelname)s - %(message)s')  # 执行设置显示格式
  65. # formater1 = logging.Formatter('%(asctime)s - %(name)s - %(levelname)s - %(message)s')  # 执行设置显示格式
  66. # formater2 = logging.Formatter('%(asctime)s-%(message)s')  # 执行设置显示格式
  67. #
  68. # # 4，给对象绑定格式
  69. # sh.setFormatter(formater)
  70. # fh1.setFormatter(formater1)
  71. # fh2.setFormatter(formater2)
  72. #
  73. # # 5 给logger对象绑定其他对象
  74. # logger.addHandler(sh)
  75. # logger.addHandler(fh1)
  76. # logger.addHandler(fh2)
  77. #
  78. # # 6 设置显示级别
  79. # # 其他对象的级别要高于logger的级别
  80. # logger.setLevel(40)
  81. # sh.setLevel(20)
  82. # fh1.setLevel(30)
  83. # fh2.setLevel(50)
  84. #
  85. #
  86. # logging.debug('debug message 1')  # 调试模式  10
  87. # logging.info('info message 2')  # 正常运转模式  20
  88. # logging.warning('warning message 3') # 警告模式  30
  89. # logging.error('error message 4')  # 错误模式  40
  90. # logging.critical('critical message 5')  #致命的 崩溃模式 50
  91. # print("-------------- 3 --------------------")
  93. # 高配 真正的工作中，是自定制个性化日志
  94. import os
  95. import logging.config
  97. # 定义三种日志输出格式 开始
  99. # 标准版 格式
  100. standard_format = '[%(asctime)s][%(threadName)s:%(thread)d][task_id:%(name)s][%(filename)s:%(lineno)d]' \
  101.                   '[%(levelname)s][%(message)s]' #其中name为getlogger指定的名字
  102. # 简单版 格式
  103. simple_format = '[%(levelname)s][%(asctime)s][%(filename)s:%(lineno)d]%(message)s'
  105. # boss版格式
  106. id_simple_format = '[%(levelname)s][%(asctime)s] %(message)s'
  108. # 定义日志输出格式 结束
  109. logfile_name = r'staff.log'  # log文件名
  111. # log配置字典
  112. LOGGING_DIC = {
  113.     'version': 1,  # 版本
  114.     'disable_existing_loggers': False,  # 可否重复使用之前的logger对象
  115.     'formatters': {
  116.         'standard': {
  117.             'format': standard_format
  118.         },
  119.         'simple': {
  120.             'format': simple_format
  121.         },
  122.         'boss_formatter':{
  123.             'format': id_simple_format
  124.         },
  125.     },
  126.     'filters': {},
  127.     'handlers': {
  128.         # 打印到终端的日志
  129.         'stream': {
  130.             'level': 'DEBUG',
  131.             'class': 'logging.StreamHandler',  # 打印到屏幕
  132.             'formatter': 'simple'
  133.         },
  134.         # 打印到文件的日志,收集info及以上的日志  文件句柄
  135.         'file': {
  136.             'level': 'INFO',
  137.             'class': 'logging.handlers.RotatingFileHandler',  # 保存到文件
  138.             'formatter': 'standard',  #标准
  139.             'filename': logfile_name,  # 日志文件
  140.             'maxBytes': 30000,  # 日志大小 30000 bit
  141.             'backupCount': 5,  # 轮转文件数
  142.             'encoding': 'utf-8',  # 日志文件的编码，再也不用担心中文log乱码了
  143.         },
  144.     },
  145.     'loggers': {
  146.         # logging.getLogger(__name__)拿到的logger配置
  147.         '': {
  148.             'handlers': ['stream', 'file'],  # 这里把上面定义的两个handler都加上，即log数据既写入文件又打印到屏幕
  149.             'level': 'DEBUG',  # 总级别
  150.             'propagate': True,  # 向上（更高level的logger）传递
  151.         },
  152.     },
  153. }
  154. # 字典中第一层的所有key都是固定不可变的
  155. # import logging
  156. # logging.config.dictConfig(LOGGING_DIC)
  157. # logger = logging.getLogger()  # 这个logger对象是通过自己个性化配置的logger对象
  158. # logger.debug('调试模式1')
  159. # logger.info('运转正常2')
  160. # logger.warning("警告 3")
  161. # logger.error("错误 4")
  162. # logger.critical("严重错误 5")
  164. def load_my_logging_cfg():
  165.     logging.config.dictConfig(LOGGING_DIC)  # 导入上面定义的logging配置
  166.     logger = logging.getLogger(__name__)  # 生成一个log实例
  167.     logger.info('It works!')  # 记录该文件的运行状态
  169. if __name__ == '__main__':
  170.     load_my_logging_cfg()

模拟其他模块调用日志模块

logging_test.py

  1. #!/usr/bin/env python3
  2. # author:Alnk(李成果)
  3. import logging
  4. import logging.config
  6. # 1 定义日志格式，分为标准版，简单版，low版，可以自定义
  7. # 标准版
  8. standard_format = '[%(asctime)s][%(threadName)s:%(thread)d][task_id:%(name)s][%(filename)s:%(lineno)d]' \
  9.                   '[%(levelname)s][%(message)s]'  # 其中name为getlogger指定的名字
  11. # 简单版
  12. simple_format = '[%(levelname)s][%(asctime)s][%(filename)s:%(lineno)d]%(message)s'
  14. # low版
  15. id_simple_format = '[%(levelname)s][%(asctime)s] %(message)s'
  17. # 2 定义日志输出文件，也可以只定义一个文件
  18. logfile_name = r'stafftest.log'
  19. logfile_boss = r'bosstest.log'
  21. # 3 logging模块配置字典
  22. # 字典中第一层的所有key都是固定不可变的
  23. LOGGING_DIC = {
  24.     'version': 1,  # 版本
  25.     'disable_existing_loggers': False,  # 可否重复使用之前的logger对象
  26.     'formatters': {  # 日志格式，第一步定义的
  27.             'standard': {
  28.                 'format': standard_format
  29.             },
  30.             'simple': {
  31.                 'format': simple_format
  32.             },
  33.             'boss_formatter': {
  34.                 'format': id_simple_format
  35.             },
  36.     },
  37.     'filters': {},  # 过滤
  38.     'handlers': {
  39.         # 打印到终端的日志
  40.         'stream': {
  41.             'level': 'DEBUG',
  42.             'class': 'logging.StreamHandler',  # 打印到屏幕
  43.             'formatter': 'simple'
  44.         },
  45.         # 打印到文件的日志,收集info及以上的日志 文件句柄
  46.         'file': {
  47.             'level': 20,
  48.             'class': 'logging.handlers.RotatingFileHandler',  # 保存到文件
  49.             'formatter': 'standard',  # 标准
  50.             'filename': logfile_name,  # 日志文件
  51.             'maxBytes': 3000000,  # 日志大小 3000000 bit
  52.             'backupCount': 5,  # 轮转文件数
  53.             'encoding': 'utf-8',  # 日志文件的编码，再也不用担心中文log乱码了
  54.         },
  55.          'boss': {
  56.             'level': 20,
  57.             'class': 'logging.handlers.RotatingFileHandler',  # 保存到文件
  58.             'formatter': 'boss_formatter',  # low版
  59.             'filename': logfile_boss,  # 日志文件
  60.             'maxBytes': 300,  # 日志大小 300 bit
  61.             'backupCount': 5,  # 轮转文件数
  62.             'encoding': 'utf-8',  # 日志文件的编码，再也不用担心中文log乱码了
  63.         },
  64.     },
  65.     'loggers': {
  66.         # logging.getLogger(__name__)拿到的logger配置
  67.         '': {
  68.             'handlers': ['stream', 'file', 'boss'],  # 这里把上面定义的handler都加上，即log数据既写入文件又打印到屏幕
  69.             'level': 'DEBUG',  # 总级别
  70.             'propagate': True,  # 向上（更高level的logger）传递
  71.         },
  72.     },
  73. }
  75. # 4 定义一个函数，供其他模块调用
  76. def get_logger(taskid):
  77.     logging.config.dictConfig(LOGGING_DIC)
  78.     logger = logging.getLogger(taskid)  # 这个logger对象是通过自己个性化配置的logger对象
  79.     return logger  # 返回logger对象供使用者调用
  81. if __name__ == '__main__':
  82.     logger1 = get_logger('测试业务')  # 调用函数，获取返回值logger对象
  83.     logger1.info('打印日志logger1')
  85.     # 其他业务模块调用
  86.     logger2 = get_logger('其他业务')
  87.     logger2.error('错误日志')

test.py

  1. #!/usr/bin/env python3
  2. # author:Alnk(李成果)
  3. from logging_test import get_logger
  5. logger1 = get_logger('模拟其他模块调用日志模块')
  6. logger1.info('日志打印')

random模块

  1. #!/usr/bin/env python3
  2. # author:Alnk(李成果)
  4. # 和随机相关的内容 random模块
  5. import random
  7. # 随机小数
  8. print(random.random())  # (0,1)
  9. print(random.uniform(1, 2))  # (n,m)
  10. print("------ 1 ---------------------------------------------")
  12. # 随机整数
  13. print(random.randint(1, 2))  # [1, 2] 包含了2
  14. print(random.randrange(1, 2))    # [1, 2) 不包含2
  15. print(random.randrange(1, 5, 2))  # 步长为2
  16. print("------ 2 ---------------------------------------------")
  18. # 随机从一个列表中取一个值
  19. ret = random.choice([1, 2, 3, ('k', 'v'), {'name': 'tom'}])
  20. print(ret)
  21. print("------ 3 ---------------------------------------------")
  23. # 随机从一个列表中取2个值
  24. ret2 = random.sample([1, 2, 3, ('k', 'v'), {'name': 'tom'}], 2)
  25. print(ret2)
  26. print("------ 4 ---------------------------------------------")
  28. # 打乱顺序  洗牌
  29. l1 = [1, 2, 3, 4, 5]
  30. random.shuffle(l1)
  31. print(l1)
  32. print("------ 5 ---------------------------------------------")
  34. # 验证码例子
  35. def my_code(n=6, flag=True):
  36.     code = ''
  37.     for i in range(n):
  38.         num = random.randint(0, 9)
  39.         # 注意这里的小技巧
  40.         # 字母和数字混合
  41.         if flag:
  42.             alp = chr(random.randint(65, 90))  # A-Z 字母随机
  43.             num = random.choice([num, alp])  # 字母和数字之中取一个
  44.         code += str(num)
  45.     return code
  47. # ret = my_code(n=4, flag=False)
  48. ret = my_code()
  49. print(ret)
  50. print("------ 6 ---------------------------------------------")
  52. # 红包例子
  53. # 思路：
  54. # 1.需要确定红包个数，红包总金额
  55. # 2.最低金额为0.01元
  56. # 3.每抽中一次，需要用红包当前总金额减去抽中的金额，然后在继续在该区间内随机抽取
  57. def hb(num, money):
  58.     # 定义空列表用来存储抽奖金额
  59.     lst = []
  61.     # 金额乘以100，便于计算，后续加入到列表在除以100
  62.     money = int(money * 100)
  64.     # 判断传递参数的合法性
  65.     if type(num) is int and num >=1 and (type(money) is int or type(money) is float):
  66.         # for循环应该比num少一次,例如2个红包个数，for循环1次就可以
  67.         for i in range(1, num):
  68.             # 保证不出现抽中0元的现象
  69.             p = random.randint(1, money - (num - i))
  70.             lst.append(p / 100)
  71.             # 需要减去已经抽取的红包金额
  72.             money = money - p
  73.         else:
  74.             # 循环结束了，把剩余的红包总金额放入到一个红包内
  75.             lst.append(money / 100)
  76.         return lst
  77.     else:
  78.         print('参数有误!')
  80. ret = hb(3, 0.04)
  81. print(ret)

os模块

  1. #!/usr/bin/env python3
  2. # author:Alnk(李成果)
  4. import os
  5. # os和操作系统打交道的
  7. # 和文件、文件夹相关的
  8. # os.makedirs('dirname1/dirname2')    # 可生成多层递归目录
  9. # os.removedirs('dirname1/dirname2')    # 若目录为空，则删除，并递归到上一级目录，如若也为空，则删除，依此类推
  10. # os.mkdir('dirname')    # 生成单级目录；相当于shell中mkdir dirname
  11. # os.rmdir('dirname')    # 删除单级空目录，若目录不为空则无法删除，报错；相当于shell中rmdir dirname
  12. # ret = os.listdir(r'/tmp')  # 列出指定目录下的所有文件和子目录，包括隐藏文件，并以列表方式打印
  13. # print(ret)
  14. # os.remove('test.py')  # 删除一个文件
  15. # os.rename("test.py", "test2.py")  # 重命名文件/目录
  16. # ret = os.stat(r'test.py')  # 获取文件/目录信息
  17. # print(ret)
  18. # print("------------- 1 ----------------")
  20. # 和执行系统命令相关
  21. # os.system("dir")  # 运行shell命令，直接显示
  22. # ret = os.popen('dir').read()  # 运行shell命令，获取执行结果
  23. # print(ret)
  24. # ret = os.getcwd() # 获取当前工作目录，即当前python脚本工作的目录路径
  25. # print(ret)
  26. # os.chdir(r"/tmp")  # 改变当前脚本工作目录；相当于shell下cd
  27. # ret = os.getcwd()
  28. # print(ret)
  29. # # 所谓工作目录 文件在哪个目录下运行 工作目录就是哪里
  30. # # 和这个文件本身所在的路径没有关系
  31. # # 1.工作目录与文件所在位置无关
  32. # # 2.工作目录和所有程序中用到的相对目录都相关
  33. # print("------------- 2 ----------------")
  35. # 和路径相关的
  36. # os.path
  37. # ret = os.path.abspath(__file__) # 返回path规范化的绝对路径
  38. # print(ret)
  39. # ret = os.path.split(__file__) # 将path分割成目录和文件名二元组返回
  40. # print(ret)
  41. # os.path.dirname(path) # 返回path的目录。其实就是os.path.split(path)的第一个元素
  42. # os.path.basename(path) # 返回path最后的文件名。如何path以／或\结尾，那么就会返回空值。即os.path.split(path)的第二个元素
  43. # ret = os.path.exists(r'E:\python')  # 如果path存在，返回True；如果path不存在，返回False
  44. # print(ret)
  45. # ret = os.path.isabs('E:\python3周末班2期笔记\05 day05\03 笔记整理')  # 如果path是绝对路径，返回True
  46. # print(ret)
  47. # ret = os.path.isfile('E:\python3周末班2期笔记\05 day05\03 笔记整理')  # 如果path是一个存在的文件，返回True。否则返回False
  48. # print(ret)
  49. # ret = os.path.isdir('E:\python3周末班2期笔记')  # 如果path是一个存在的目录，则返回True。否则返回False
  50. # print(ret)
  51. # ret = os.path.join('E:\python3周末班2期笔记', 'abc', 'def')  # 将多个路径组合后返回，第一个绝对路径之前的参数将被忽略
  52. # print(ret)
  53. # os.path.getatime(path)  返回path所指向的文件或者目录的最后访问时间
  54. # os.path.getmtime(path)  返回path所指向的文件或者目录的最后修改时间
  55. # ret = os.path.getsize(r'E:\python3周末班2期笔记\05 day05\03 笔记整理\00 今日课程大纲.py')
  56. #  返回path的大小,文件夹的大小不准确
  57. # print(ret)
  58. # print("------------- 3 ----------------")
  60. # 练习题
  61. # 使用python代码 计算文件夹的大小
  62. # 文件夹里可能还有文件夹
  63. # import os
  64. # total_size=0
  65. # def file_size(path):
  66. #     global total_size
  67. #     path=os.path.abspath(path)
  68. #     print('path',path)
  69. #     file_list=os.listdir(path)
  70. #     print('list',file_list)
  71. #     for i in file_list:
  72. #         i_path = os.path.join(path, i)
  73. #         if os.path.isfile(i_path):
  74. #             total_size += os.path.getsize(i_path)
  75. #         else:
  76. #             try:
  77. #                 file_size(i_path)
  78. #             except RecursionError:
  79. #                 print('递归操作时超出最大界限')
  80. #     return total_size
  81. #
  82. # print(file_size(r'E:\02'))
  83. # print("------------- 4 ----------------")

sys模块

  1. #!/usr/bin/env python3
  2. # author:Alnk(李成果)
  4. import sys
  5. # sys模块是和 python解释器打交道的
  7. # sys.exit()    # 退出
  8. # print(123)
  9. # print(sys.version) # 版本
  10. # print(sys.platform)  # 平台 操作系统
  12. # print(sys.path)  # 模块搜索路径
  13. # 包含的内容
  14. # 1.内置的python安装的时候就规定好的一些内置模块所在的路径
  15. # 内置模块
  16. # 扩展模块
  17. # 2.当前被执行的文件所在的路径
  18. # 自定义的模块
  20. # 需要在CMD执行
  21. # python py文件的目录 参数1 参数2
  22. # print(sys.argv)   # []
  23. # if sys.argv[1] == 'tom' and sys.argv[2] == '123':
  24. #     print('登陆成功')
  25. # else:
  26. #     print('登陆失败')
  27. #     sys.exit()
  28. # print('登陆成功后的所有代码')

json模块

  1. #!/usr/bin/env python3
  2. # author:Alnk(李成果)
  4. # 序列化模块
  5. # 序列化
  6. # 序列 list str tuple bytes
  7. # 可迭代的都是序列？字典？集合？无序的，散列。不是序列
  8. # 狭义的序列 str / bytes
  9. # 序列化？把...变得有序，把...变成str或者是bytes
  10. # 反序列化？把str/bytes 还原回原来的 ...
  12. # 为什么要有序列化？
  13. # 1.存储在文件中 长久保存到硬盘
  14. # 2.在网络上传递，只能用字节
  16. # 序列化模块
  17. import json
  18. # 能够支持所有的计算机高级语言
  19. # 对数据类型的要求非常严格
  20. dic = {"key": "value"}
  21. ret = json.dumps(dic)   # 序列化方法
  22. print(dic, type(dic))  # {'key': 'value'} <class 'dict'>
  23. print(ret, type(ret))  # {"key": "value"} <class 'str'>
  24. with open('json_file', 'w') as f:
  25.     f.write(ret)
  27. with open('json_file') as f:
  28.     content = f.read()
  29. d = json.loads(content)    # 反序列化方法
  30. print(d, type(d))  # {'key': 'value'} <class 'dict'>
  31. print(d['key'])
  32. print("------------ 1 ------------------------------")
  34. # 1：json格式规定所有的key必须是字符串数据类型
  35. dic = {1: 2}
  36. ret = json.dumps(dic)
  37. print(dic[1])  # 2
  38. print(ret)  # {"1": 2}
  39. new_dic = json.loads(ret)
  40. print(new_dic)  # {'1': 2}
  41. print("------------ 2 ------------------------------")
  43. # 2 ： json中的所有tuple都会被当作list处理
  44. dic = {1: (1, 2, 3)}
  45. ret = json.dumps(dic)
  46. print(ret)  # {"1": [1, 2, 3]}
  47. new_dic = json.loads(ret)
  48. print(new_dic)  # {"1": [1, 2, 3]}
  49. print("------------ 3 ------------------------------")
  51. # 3： json能支持的数据类型非常有限，字符串 数字 列表 字典
  53. # dumps loads   字符串 和 其他基础数据类型之间转换
  54. # dump  load    文件   和 其他基础数据类型之间转换
  56. # dump load
  57. dic = {"key": "value"}
  58. with open('json_file2', 'w') as f:
  59.     json.dump(dic, f)
  61. with open('json_file2') as f:
  62.     ret = json.load(f)
  63. print(ret['key'])  # value
  64. print("------------ 4 ------------------------------")
  66. # json不可以dump多次
  67. dic = {"key": "value"}
  68. with open('json_file3', 'w') as f:
  69.     json.dump(dic, f)
  70.     # json.dump(dic, f)  # dump多次会报错
  72. with open('json_file3', 'r') as f:
  73.     ret = json.load(f)
  74.     print(ret)
  75. print("------------ 5 ------------------------------")
  77. # 如果需要dump多次，按照下面的方法
  78. str_dic = {"name": "tom", "sex": None}
  79. ret = json.dumps(str_dic)
  81. with open('json_file4', 'w') as f:
  82.     f.write(ret+'\n')
  83.     f.write(ret+'\n')
  85. with open('json_file4', 'r') as f:
  86.     for line in f:
  87.         print(json.loads(line), type(json.loads(line)))

pickle模块

  1. #!/usr/bin/env python3
  2. # author:Alnk(李成果)
  4. import pickle
  6. # 1.支持几乎所有python中的数据类型
  7. # 2.只在python语言中通用
  8. # 3.pickle适合与bytes类型打交道的
  9. s = {1, 2, 3, 4}
  10. print(type(s))  # <class 'set'>
  11. ret = pickle.dumps(s)
  12. print(ret)
  13. ret2 = pickle.loads(ret)
  14. print(ret2)
  15. print("--------------- 1 -----------------")
  17. # pickle：序列化时候数据是什么类型，反序列化以后数据还是原来的类型，这点和 json 有点不一样
  18. d = {1: 2, 3: 4}
  19. ret = pickle.dumps(d)
  20. print(ret)
  21. new_d = pickle.loads(ret)
  22. print(new_d)
  23. print("--------------- 2 -----------------")
  25. # 写入文件
  26. s = {(1, 2, 3): 2, 3: 4}
  27. result = pickle.dumps(s)
  28. print(result)
  29. with open('pickle_file', 'wb') as f:
  30.     f.write(result)
  32. with open('pickle_file', 'rb') as f:
  33.     content = f.read()
  34. ret = pickle.loads(content)
  35. print(ret, type(ret))
  36. print("--------------- 3 -----------------")
  38. # pickle 可以支持多个对象放入文件
  39. # pickle 可以dump多次，也可以load多次
  40. s1 = {1, 2, 3}
  41. s2 = {1: 2, 3: 4}
  42. s3 = ['k', 'v', (1, 2, 3), 4]
  43. with open('pickle_file2', 'wb') as f:
  44.     pickle.dump(s1, f)
  45.     pickle.dump(s2, f)
  46.     pickle.dump(s3, f)
  48. with open('pickle_file2', 'rb') as f:
  49.     count = 1
  50.     while count <= 3:
  51.         try:
  52.             content = pickle.load(f)
  53.             print(content)
  54.             count += 1
  55.         except EOFError:
  56.             break
  57. print("--------------- 4 -----------------")
  59. # json 实际上使用json更多 优先选择
  60. # 如果你是要跨平台沟通，那么推荐使用json
  61. # key只能是字符串
  62. # 不能多次load和dump
  63. # 支持的数据类型有限
  65. # pickle
  66. # 如果你是只在python程序之间传递消息，并且要传递的消息是比较特殊的数据类型
  67. # 处理文件的时候 rb/wb
  68. # 支持多次dump/load

re模块

正则表达式

  1. #!/usr/bin/env python3
  2. # author:Alnk(李成果)
  4. # 正则表达式
  5. # re模块 是用来在python中操作 正则表达式 的
  6. # 要先知道正则表达式是什么？做什么用的？怎么用
  8. # 正则表达式检测网站
  9. # http://tool.chinaz.com/regex/
  11. # 邮箱地址
  12. # 用户名 密码
  13. # 要检测一个用户输入的内容是否符合我的规则
  15. # 用户输入的内容对于程序员来说都是字符串
  16. # 一个文件是一堆字符串，有很多内容
  18. # 检测某一个字符串是否符合规则            需求一
  19. # 从一大段文字中找到符合规则的字符串       需求二
  21. # 正则表达式  --> 字符串规则匹配的
  22. # 1.判断某一个字符串是否符合规则
  23. # 2.从一段文字中提取出符合规则的内容
  25. # 初识正则表达式
  26. # 字符组的概念
  27. # [ ]表示字符组，一个[ ]表示一个字符组
  28. # [1-9]
  29. # [0-9]
  30. # [1-5]
  31. # [a-z]
  32. # [a-f]
  33. # 1.对字母来说 区分大小写
  34. # 2.a-f可以 f-a不行
  35. # 一个字符位置上可以出现的内容是匹配数字或字母：[0-9a-zA-Z]
  36. # 匹配一个两位数:# [1-9][0-9]
  38. # 元字符
  39. # \d    数字
  40. # \w    数字 字母 下划线
  41. # \s    空格 回车 制表符
  42. # \t    制表符
  43. # \n    回车
  44. # \b    匹配一个单词的边界。例如 hello world  o\b会匹配hello的o
  45. # \D    非数字
  46. # \W    非数字字母下划线
  47. # \S    非空白
  49. # ^      一个字符串的开始
  50. # $      一个字符串的结尾
  51. # ^xxxx$  约束的了整个字符串中的内容必须一一与表达式对应上
  52. # 例如: hello hello hello
  53. # ^hello 只能匹配第一个hello
  54. # hello$ 只能匹配最后一个hello
  55. # hello^  不能匹配任何字符串。因为 ^ 是开头，没有可能在开头在出现字符。
  57. # |       表示或
  58. # 例子：匹配ab或abc  要这样写 abc|ab  把长的表达式写在前面
  60. # ()      分组
  61. # a(b|c)d
  62. # 例子：www.baidu.com www.baide.com  表达式 www.baid(u|e).com
  64. # . 表示除了换行符以外的任意字符
  66. # 非 字符组
  67. # [^ABC] 只要不是ABC都能匹配
  69. # 量词
  70. # {n}   在这个量词前面的一个元字符出现n次
  71. # {n,}  在这个量词前面的一个元字符出现n次或n次以上
  72. # {n,m}  在这个量词前面的一个元字符出现n次到m次以上
  73. #
  74. # ?     在这个量词前面的一个元字符出现0次或者1次
  75. # +     在这个量词前面的一个元字符出现1次或者多次
  76. # *     在这个量词前面的一个元字符出现0次或者多次
  78. # 例子：
  79. # 1.匹配一个整数：\d+
  80. # 2.匹配一个小数：\d+\.\d+
  81. # 3.匹配整数或者小数： 表达式 \d+(\.\d+)?   括号里面的被量词?问号约束，约束了一组字符的出现次数
  83. # 小练习
  84. # 正则表达式默认都是贪婪匹配
  85. # 贪婪匹配：会尽量多的帮我们匹配内容
  86. # 例子 待匹配字符：李杰和李莲英和李二棍子  正则表达式：李.?   匹配结果：李杰  李莲  李二 匹配到这3条
  88. # 回溯算法下的贪婪匹配
  89. # 例子：待匹配字符:<a>bbbb<a> 正则表达式:<.*> 匹配结果:<a>bbbb<a>
  91. # 非贪婪模式，
  92. # 在量词后面加一个问号，开启非贪婪模式
  93. # 惰性匹配：尽量少的匹配
  94. # 例子：待匹配字符:<a>bbbb<a> 正则表达式:<.*?> 匹配结果:<a>    <a>  这两条
  96. # 例子 待匹配字符：李杰和李莲英和李二棍子  正则：李[杰莲英二棍子]*    匹配结果：李杰 李莲英 李二棍子
  97. # 例子 待匹配字符：李杰和李莲英和李二棍子  正则：李[^和]*             匹配结果：李杰 李莲英 李二棍子
  99. # 例子
  100. # 身份证号码是一个长度为15或18个字符的字符串，如果是15位则全部由数字组成，首位不能为0；
  101. # 如果是18位，则前17位全部是数字，末位可能是数字或x
  102. # ^[1-9]\d{14}(\d{2}[x\d])?$
  103. # ^([1-9]\d{16}[\dx]|[1-9]\d{14})$
  105. # 转义符例子
  106. # r'\\n' 匹配 '\n'
  108. # .*?x   ：爬虫常用 ，表示匹配任意字符，直到遇见x停止
  110. # 练习题
  111. # 1、 匹配一段文本中的每行的邮箱
  112. #       http://blog.csdn.net/make164492212/article/details/51656638
  113. #
  114. # 2、 匹配一段文本中的每行的时间字符串，比如：‘1990-07-12’；
  115. #
  116. #    分别取出1年的12个月（^(0?[1-9]|1[0-2])$）、
  117. #    一个月的31天：^((0?[1-9])|((1|2)[0-9])|30|31)$
  118. #
  119. # 3、 匹配qq号。(腾讯QQ号从10000开始)  ［1,9］[0,9]{4,}
  120. #
  121. # 4、 匹配一个浮点数。       ^(-?\d+)(\.\d+)?$   或者  -?\d+\.?\d*
  122. #
  123. # 5、 匹配汉字。             ^[\u4e00-\u9fa5]{0,}$
  124. #
  125. # 6、 匹配出所有整数

re模块

  1. #!/usr/bin/env python3
  2. # author:Alnk(李成果)
  3. import re
  5. # 1 findall() 匹配所有
  6. ret = re.findall("\d+", 'h2b3123')
  7. print(ret, type(ret))  # ['2', '3123'] <class 'list'>
  8. print("------------ 1 --------------------")
  10. # 分组遇到findall，优先显示分组中匹配到的内容
  11. # ( ) 分组匹配
  12. ret = re.findall('www.(baidu|oldboy).com', 'www.oldboy.com')
  13. print(ret)  # ['oldboy']
  15. # 如何取消分组优先？  ?:
  16. ret = re.findall('www.(?:baidu|oldboy).com', 'www.oldboy.com')
  17. print(ret)  # ['www.oldboy.com']
  18. print("------------ 2 --------------------")
  20. # 2 search() 只匹配从左到右的第一个
  21. ret = re.search('\d+','h2b3123')
  22. print(ret)  # <_sre.SRE_Match object; span=(1, 2), match='2'>
  23. print(ret.group())  # 2
  24. print("------------ 3 --------------------")
  26. ret = re.search('\d+','aaaab123a1')
  27. if ret:
  28.     print(ret.group())  # 123
  29. print("------------ 4 --------------------")
  31. # 3 compile() # 节省时间
  32. # compile 节省时间 一条正则表达式用多次
  33. # '\d+'  --> 正则规则 --> python代码 --> 将字符串按照代码执行匹配
  34. ret = re.compile('\d+')  # 先写好正则表达式
  35. r = ret.findall('ahkfgilWIVKJBDKvjgheo')  # 匹配所有
  36. if r:
  37.     print(r)
  38. print("------------ 5 --------------------")
  40. r = ret.search('ahkfgilsk0194750dfjWIVKJBDKvjgheo')  # 只匹配从左到右的第一个
  41. if r:
  42.     print(r.group())  # 0194750
  43. print("------------ 6 --------------------")
  45. # 4 finditer 节省空间 结果的条数很多的时候
  46. ret = re.finditer('\d+','dskh1040dsvk034fj048d3g5h4j')
  47. for r in ret:
  48.     print(r.group())
  49. print("------------ 7 --------------------")
  51. # 练习题
  52. # 匹配标签
  53. s = '<h1>abc</h1>'
  54. ret = re.search('<(\w+)>', s)
  55. print(ret.group())
  56. print("------------ 8 --------------------")
  58. # 分组
  59. s = '<h1>abc</h1>'
  60. ret = re.search('<(\w+)>(.*?)<(/\w+)>', s)
  61. print(ret.group())   # <h1>abc</h1>
  62. print(ret.group(1))  # h1
  63. print(ret.group(2))  # abc
  64. print(ret.group(3))  # /h1
  65. print("------------ 9 --------------------")
  67. # 分组标签
  68. s = '<h1>abc</h1>'
  69. ret = re.search('<(?P<tag>\w+)>(.*?)<(/\w+)>', s)
  70. print(ret.group('tag'))  # h1
  71. print("------------ 10 --------------------")
  73. s = '<h1>abc</h1>'
  74. ret = re.search('<(?P<tag1>\w+)>(.*?)</(?P=tag1)>', s)
  75. print(ret)  # <_sre.SRE_Match object; span=(0, 12), match='<h1>abc</h1>'>
  76. print(ret.group())  # <h1>abc</h1>
  77. print(ret.group('tag1'))  # h1
  78. print("------------ 11 --------------------")
  80. # 还可以在分组中利用?<name>的形式给分组起名字
  81. # 获取的匹配结果可以直接用group('名字')拿到对应的值
  82. ret = re.search("<(?P<tag_name>\w+)>\w+</(?P=tag_name)>", "<h1>hello</h1>")
  83. print(ret.group('tag_name'))  # 结果 ：h1
  84. print(ret.group())  # 结果 ：<h1>hello</h1>
  85. print("------------ 12 --------------------")
  87. # 如果不给组起名字，也可以用\序号来找到对应的组，表示要找的内容和前面的组内容一致
  88. # 获取的匹配结果可以直接用group(序号)拿到对应的值
  89. ret = re.search(r"<(\w+)>\w+</\1>","<h1>hello</h1>")
  90. print(ret.group(1))  # h1
  91. print(ret.group())  # 结果 ：<h1>hello</h1>

hashlib模块

  1. #!/usr/bin/env python3
  2. # author:Alnk(李成果)
  3. import hashlib
  5. # 加密模块 摘要算法 一堆加密算法的集合体
  6. # import hashlib
  7. # 给密码加密
  8. # 文件的校验
  10. # hashlib： 将str类型 通过算法 -----> 一串等长度的数字
  11. # 1，不同的字符串 转化成数字肯定不同
  12. # 2，相同的字符串即使在不同的计算机上只要使用相同的加密方式 转化成的数字一定相同
  13. # 3，hashlib加密不可逆，不能破解
  15. # md5加密
  16. # md5加密效率快，通用，安全性相对差
  17. ret = hashlib.md5()
  18. ret.update('好123'.encode('utf-8'))  # 51cb75f82eceb17b86f019e01618d75e
  19. print(ret.hexdigest())
  20. print("-------------- 1 ----------------------------------------------")
  22. ret = hashlib.md5()
  23. ret.update('aabbccddeeff'.encode('utf-8'))  # d6ce01d2e191f83c4396ee41eed4e076
  24. print(ret.hexdigest())
  25. print("-------------- 2 ----------------------------------------------")
  27. ret = hashlib.md5()
  28. ret.update('1'.encode('utf-8'))  # c4ca4238a0b923820dcc509a6f75849b
  29. print(ret.hexdigest())
  30. print("-------------- 3 ----------------------------------------------")
  32. # 撞库
  33. # 经常设置的 111111 000000 123456 password 等等，做了一个对应表，一一对去寻找
  34. ret = hashlib.md5()
  35. ret.update('123456'.encode('utf-8'))  # e10adc3949ba59abbe56e057f20f883e
  36. print(ret.hexdigest())
  37. print("-------------- 4 ----------------------------------------------")
  39. # 加盐
  40. # 让你的密码更复杂。
  41. ret = hashlib.md5('hello word!'.encode('utf-8'))  # 盐
  42. ret.update('123456'.encode('utf-8'))  # cad5c6823564df20c3fb53848a9b84ef
  43. print(ret.hexdigest())
  44. print("-------------- 5 ----------------------------------------------")
  46. # 动态的盐
  47. # username = input('请输入用户名：')
  48. # ret = hashlib.md5(username[::2].encode('utf-8'))
  49. # ret.update('123456'.encode('utf-8'))  # 765b4e7ed31b8aa07755d1c24c69d48c
  50. # print(ret.hexdigest())
  52. # sha加密
  53. # sha加密，算法更好 安全性高，效率低，耗时长
  54. ret = hashlib.sha1()
  55. ret.update('gjfds;fldg'.encode('utf-8'))
  56. print(ret.hexdigest())  # 40098e7fbc4d85eba01695315e2dd896bd4d8ebb
  57. print("-------------- 6 ----------------------------------------------")
  59. ret = hashlib.sha256()
  60. ret.update('gjfds;fldg'.encode('utf-8'))
  61. print(ret.hexdigest())  # b3a2d0e194c193ecd04a61a2b28863047b27b7b93c28b5fdab578aeab0f96dd9
  62. print("-------------- 7 ----------------------------------------------")
  64. ret = hashlib.sha512()
  65. ret.update('gjfds;fldg'.encode('utf-8'))
  66. # 9a5eea267dc6b7a7e3eb45f1f9345b735a26dea92787de5f356e87fe4efe635a1d7b27c8f321e9ec87ad03a7eab91d7bfbf7a753da01e3e6dda6a06b272485d6
  67. print(ret.hexdigest())
  68. print("-------------- 8 ----------------------------------------------")
  70. # 文件校验
  71. # 文件较小用下面代码
  72. def check_md5(file):
  73.     ret = hashlib.md5()
  74.     with open(file, mode='rb') as f1:
  75.         ret.update(f1.read())
  76.         return ret.hexdigest()
  78. print(check_md5('文件校验1'))
  79. print(check_md5('文件校验2'))
  80. print("-------------- 9 ----------------------------------------------")
  82. # 大文件的校验：
  83. ret1 = hashlib.md5()
  84. ret1.update("a".encode("utf-8"))
  85. print(ret1.hexdigest())  # 0cc175b9c0f1b6a831c399e269772661
  87. ret2 = hashlib.md5()
  88. ret2.update("b".encode("utf-8"))
  89. print(ret2.hexdigest())  # 92eb5ffee6ae2fec3ad71c777531578f
  91. ret3 = hashlib.md5()
  92. ret3.update("a".encode("utf-8"))
  93. ret3.update("b".encode("utf-8"))
  94. print(ret3.hexdigest())  #  187ef4436122d1cc2f40dc2b92f0eba0
  95. print("-------------- 10 ----------------------------------------------")
  97. #
  98. def check_md5(file):
  99.     ret = hashlib.md5()
  100.     with open(file, mode='rb') as f1:
  101.         while 1:
  102.             content = f1.read(1024)
  103.             if content:
  104.                 ret.update(content)
  105.             else:
  106.                 break
  107.         return ret.hexdigest()
  109. print(check_md5('文件校验1'))
  110. print(check_md5('文件校验2'))

collections模块

  1. #!/usr/bin/env python3
  2. # author:Alnk(李成果)
  3. from collections import namedtuple
  4. from collections import deque
  5. from collections import defaultdict
  6. from collections import Counter
  8. # 1 namedtuple 坐标
  9. point_tuple = namedtuple('point', ['x', 'y'])
  10. p = point_tuple(1, 2)
  11. print(p)  # point(x=1, y=2)
  12. print(p[0])  # 1
  13. print(p.x)  # 1
  14. print(p.x + p.y)  # 3
  15. print("----------- 1 -----------------")
  17. # 2 deque 双向队列
  18. q = deque(['a', 'b', 'c'])
  19. print(q, type(q))  # deque(['a', 'b', 'c']) <class 'collections.deque'>
  21. # 从右边增加值
  22. q.append('x')
  23. q.append('y')
  24. print(q, type(q))  # deque(['a', 'b', 'c', 'x', 'y']) <class 'collections.deque'>
  26. # 从右边删除值
  27. q.pop()
  28. q.pop()
  29. print(q, type(q))  # deque(['a', 'b', 'c']) <class 'collections.deque'>
  31. # 从左边增值
  32. q.appendleft('x')
  33. q.appendleft('y')
  34. print(q, type(q))  # deque(['y', 'x', 'a', 'b', 'c']) <class 'collections.deque'>
  36. # 从左边删除
  37. q.popleft()
  38. ret = q.popleft()
  39. print(ret)  # x
  40. print(q, type(q))  # deque(['a', 'b', 'c']) <class 'collections.deque'>
  41. print("----------- 2 -----------------")
  43. # 3 defaultdict 默认值 字典
  44. my_dict = defaultdict(list)  # 默认值 为list
  45. my_dict['key1']
  46. my_dict['key2']
  47. my_dict['key3']
  48. print(my_dict)  # defaultdict(<class 'list'>, {'key1': [], 'key2': [], 'key3': []})
  50. values = [11, 22, 33, 44, 55, 77, 88, 99, 90]
  51. for val in values:
  52.     if val > 66:
  53.         my_dict['key1'].append(val)
  54.     else:
  55.         my_dict['key2'].append(val)
  56. print(my_dict)  # defaultdict(<class 'list'>, {'key1': [77, 88, 99, 90], 'key2': [11, 22, 33, 44, 55], 'key3': []})
  57. print("----------- 3 -----------------")
  59. # 构建一个字典,字典的key 从1~100，对应的值都是666
  60. # {1：666，2：666，3：666......}
  61. # 方法1
  62. dic = dict.fromkeys(range(1,101),666)
  63. print(dic)
  64. print("----------- 4 -----------------")
  66. # 方法2
  67. print({key:666 for key in range(1,101)})
  68. print("----------- 5 -----------------")
  70. # 方法3
  71. def func():
  72.     return 666
  74. # my_dict = defaultdict(func)
  75. my_dict = defaultdict(lambda : 666)
  76. for i in range(1,101):
  77.     my_dict[i]
  78. print(my_dict)
  79. print("----------- 6 -----------------")
  81. # Counter 统计元素个数
  82. # s1 = '电脑电脑sldfjslffdsaf'
  83. s1 = ['电脑','电脑','电脑','电脑','书']
  84. c = Counter(s1)
  85. print(c, type(c))  # Counter({'电脑': 4, '书': 1}) <class 'collections.Counter'>
  86. print(c['f'])  # 0
  87. print(c['d'])  # 0
  88. print(c['电脑'])  # 4
  89. print(dict(c), type(dict(c)))  # {'电脑': 4, '书': 1} <class 'dict'>

shutil模块

  1. #!/usr/bin/env python3
  2. # author:Alnk(李成果)
  3. import shutil
  5. # 将文件内容拷贝到另一个文件中
  6. shutil.copyfileobj(open('log1','r'),open('log2','w'))
  8. # 复制文件
  9. shutil.copyfile('log1','log.bak')
  11. # 递归拷贝文件夹
  12. # shutil.copytree('./NB1', './nbb', ignore=shutil.ignore_patterns('*.pyc', 'tmp*'))
  14. # 打包和压缩
  15. import time
  16. import tarfile
  17. shutil.make_archive('NB1-%s' % time.strftime('%Y-%m-%d'), 'gztar', root_dir='NB1')
  19. # 解压
  20. t = tarfile.open('NB12019-01-10.tar.gz', 'r')
  21. t.extractall('ttt')
  22. t.close()

包

目录结构

  1. ├── aaa
  2. │   ├── __init__.py
  3. │		└── m2.py
  4. │   ├── bbb
  5. │   │   ├── __init__.py
  6. │   │   └── m3.py 
  7. ├── main.py

main.py文件

  1. #!/usr/bin/env python3
  2. # author:Alnk(李成果)
  3. import sys
  4. # 模块被引用发生了三件事
  5. # 1，创建一个以模块名命名的名称空间
  6. # 2，执行模块代码将模块里面的代码加载到模块名命名的名称空间的内存中
  7. # 3，调用模块内的名字必须通过模块名. 的方式调用
  8. print(sys.path)
  9. print("-------- 1 ------------------------------------")
  11. import aaa
  12. # 包也是模块，他是模块的集合体，所以引用包也会发生三件事情：
  13. # 1，创建一个以包名命名的名称空间。
  14. # 2，执行包中的__init__文件，将__init__里面的代码块加载到以包名明命的名称空间的内存中。
  15. # 3，调用包内的名字必须通过包名. 的方式调用。
  16. print(aaa.x)
  17. print(aaa.y)
  18. aaa.func1()
  19. print(aaa.m2)
  20. print(aaa.m2.xx)
  21. aaa.m2.func2()
  22. print("-------- 2 ------------------------------------")
  24. # 引用bbb这个包怎么做？
  25. print(aaa.bbb)
  26. print(aaa.bbb.oo)
  27. print(aaa.bbb.xxoo)
  28. print("-------- 3 ------------------------------------")
  30. # 想要在此文件引用 bbb包的m3模块 怎么做？
  31. # 第一步 在此文件 import aaa
  32. # 第二步：在aaa 的 __init__ 添加 from aaa import bbb
  33. # 第三步：在bbb 的 __init__ 添加 from aaa.bbb import m3
  34. # 完成以上三步，那么我在此执行文件就可以引用bbb包的m3模块里面的名字
  35. import aaa
  36. aaa.bbb.m3.func3()
  37. print("-------- 4 ------------------------------------")
  39. # 上面的需求满可以这么做：
  40. # from aaa.bbb import func3
  41. # func3()
  43. # 总结：
  44. #  from a.b import c  .的左边一定是个包,import 后面一定一个具体的名字
  45. # 包里面的__init__ 如果想要引用模块必须是 from ....import ... 不能直接 import
  46. # from a.b.c.d import e.f.g  错误
  47. # from a.b.c.d import e

aaa/__init__.py

  1. #!/usr/bin/env python3
  2. # author:Alnk(李成果)
  4. x = 111
  5. y = 222
  7. def func1():
  8.     print(555)
  10. # 如何让 main.py 这个执行文件找到m2文件？
  11. from aaa import m2
  12. # from aaa import *
  14. # 找到bbb这个包
  15. from aaa import bbb

aaa/m2.py

  1. #!/usr/bin/env python3
  2. # author:Alnk(李成果)
  4. xx = '老鼠药'
  6. def func2():
  7.     print('in m2 ')

aaa/bbb/__init__.py

  1. #!/usr/bin/env python3
  2. # author:Alnk(李成果)
  4. from aaa.bbb import m3  # 从执行文件的当前目录开始
  5. # from aaa.bbb.m3 import *  # 从执行文件的当前目录开始(上面的需求可以这么做)
  7. oo = 'tom'
  9. xxoo = 'www......'

aaa/bbb/m3.py

  1. #!/usr/bin/env python3
  2. # author:Alnk(李成果)
  4. def func3():
  5.     print('in m3')

相对导入和绝对导入

目录结构

  1. lichengguo@lichengguodeMacBook-Pro day16 模块与包 random % tree
  2. ├── main.py
  3. ├── nb
  4. │   ├── __init__.py
  5. │   ├── m1.py
  6. │   └── m2.py

main.py

  1. #!/usr/bin/env python3
  2. # author:Alnk(李成果)
  4. # 绝对导入: 以执行文件的sys.path为起始点开始导入,称之为绝对导入
  5. # 优点: 执行文件与被导入的模块中都可以使用
  6. # 缺点: 所有导入都是以sys.path为起始点,导入麻烦
  7. # import nb
  8. # nb.f1()
  9. # nb.f2()
  10. # nb.f3()
  11. # nb.f4()
  13. # 相对导入: 参照当前所在文件的文件夹为起始开始查找,称之为相对导入
  14. # 符号: .代表当前所在文件的文件加,..代表上一级文件夹,...代表上一级的上一级文件夹
  15. # 优点: 导入更加简单
  16. # 缺点: 只能在导入包中的模块时才能使用
  17. from nb import m1
  18. from nb import m1
  19. m1.f1()
  20. m1.f2()

nb/__init__.py

  1. #!/usr/bin/env python3
  2. # author:Alnk(李成果)
  4. # 绝对导入
  5. # from nb.m1 import f1, f2
  6. # from nb.m2 import f3, f4
  8. # 相对导入
  9. from .m1 import f1, f2
  10. from .m2 import f3, f4

nb/m1.py

  1. #!/usr/bin/env python3
  2. # author:Alnk(李成果)
  4. def f1():
  5.     print('in f1')
  7. def f2():
  8.     print('in f2')

nb/m2.py

  1. #!/usr/bin/env python3
  2. # author:Alnk(李成果)
  4. def f3():
  5.     print('in f3')
  7. def f4():
  8.     print('in f4')

练习题1

  1. #!/usr/bin/env python3
  2. # author:Alnk(李成果)
  3. # 1、计算两个格式化时间之间差了多少年月日时分秒
  4. # 例如 '1997-10-1 08:00:00' 和 '1997-10-2 09:00:00'
  5. import time
  6. def diff_time(t1, t2):
  7.     t1_struct = time.strptime(t1,'%Y-%m-%d %H:%M:%S')
  8.     t1_stamp = time.mktime(t1_struct)
  9.     t2_struct = time.strptime(t2,'%Y-%m-%d %H:%M:%S')
  10.     t2_stamp = time.mktime(t2_struct)
  11.     if t1_stamp > t2_stamp:
  12.         diff_t = t1_stamp - t2_stamp
  13.     else:
  14.         diff_t = t2_stamp - t1_stamp
  15.     diff_t_struct = time.gmtime(diff_t)
  16.     print('两个时间相差了 [%s]年 [%s]月 [%s]日 [%s]时 [%s]分 [%s]秒'
  17.           % (diff_t_struct.tm_year-1970, diff_t_struct.tm_mon-1,
  18.              diff_t_struct.tm_mday-1, diff_t_struct.tm_hour,
  19.              diff_t_struct.tm_min, diff_t_struct.tm_sec))
  21. t1 = '1997-10-1 08:00:00'
  22. t2 = '1997-10-2 09:00:00'
  23. diff_time(t1, t2)
  24. print("------------------- 1 -----------------------------------------")
  26. # 2、计算当前时间所在月1号的时间戳
  27. import time
  28. def get_time():
  29.     now_t = time.strftime('%Y-%m')
  30.     uct_t = time.strptime(now_t, '%Y-%m')
  31.     stamp_t = time.mktime(uct_t)
  32.     return stamp_t
  34. ret = get_time()
  35. print(ret)  # 1617206400.0
  36. # print(time.strftime('%Y-%m-%d %H:%M:%S', time.localtime(ret)))  # 2021-04-01 00:00:00
  37. print("------------------- 2 -----------------------------------------")
  39. # 3、生成一个6位随机验证码(包含数字和大小写字母)
  40. import random
  41. def get_code(n=6, flag=True):
  42.     code = ''
  43.     for i in range(n):
  44.         selectd = random.randint(0, 9)
  45.         if flag:
  46.             alp = random.randint(65, 90)
  47.             selectd = random.choice([selectd, chr(alp)])
  48.         code += str(selectd)
  49.     return code
  51. ret = get_code()
  52. print(ret)
  53. print("------------------- 3 -----------------------------------------")
  55. # 4、发红包、制定金额和个数，随机分配红包金额
  56. def hb(num, money):
  57.     # 定义空列表用来存储抽奖金额
  58.     lst = []
  60.     # 金额乘以100，便于计算，后续加入到列表在除以100
  61.     money = int(money * 100)
  63.     # 判断传递参数的合法性
  64.     if type(num) is int and num >=1 and (type(money) is int or type(money) is float):
  65.         # for循环应该比num少一次,例如2个红包个数，for循环1次就可以
  66.         for i in range(1, num):
  67.             # 保证不出现抽中0元的现象
  68.             p = random.randint(1, money - (num - i))
  69.             lst.append(p / 100)
  70.             # 需要减去已经抽取的红包金额
  71.             money = money - p
  72.         else:
  73.             # 循环结束了，把剩余的红包总金额放入到一个红包内
  74.             lst.append(money / 100)
  75.         return lst
  76.     else:
  77.         print('参数有误!')
  79. ret = hb(3, 0.04)
  80. print(ret)
  81. print("------------------- 4 -----------------------------------------")
  83. # 5、分别列出给定目录下所有的文件和文件夹
  84. import os
  85. def lis_file_path(path):
  86.     dir_list = []
  87.     file_list = []
  88.     # 拼接路径
  89.     ret_list = os.listdir(r'%s' % path)
  91.     for i in ret_list:
  92.         ret = os.path.join(path + '/%s' % i)
  93.         if os.path.isfile(ret):
  94.             file_list.append(i)
  95.         elif os.path.isdir(ret):
  96.             dir_list.append(i)
  97.     return dir_list,file_list
  99. ret = lis_file_path(r'/tmp')
  100. print('目录:', ret[0])
  101. print('文件:', ret[1])
  102. print("------------------- 5 -----------------------------------------")
  104. # 6、获取当前文件所在目录
  105. import os
  106. ret = os.path.abspath(__file__)
  107. print(os.path.dirname(ret))
  108. print("------------------- 6 -----------------------------------------")
  110. # 7、在当前目录下创建一个文件夹、在这个文件夹下创建一个文件
  111. import os
  112. def mk():
  113.     # 获取被运行的PY文件绝对目录
  114.     now_abs_dir = os.path.dirname(os.path.abspath(__file__))
  115.     # 拼接路径
  116.     ret_dir = os.path.join(now_abs_dir + '/new_dir')
  117.     # 创建一个文件夹
  118.     if not os.path.isdir(ret_dir):
  119.         os.mkdir(ret_dir)
  120.     # 拼接路径
  121.     ret_file = os.path.join(ret_dir + '/test.txt')
  122.     # 创建一个文件
  123.     with open(r'%s' % ret_file, encoding='utf-8', mode='w') as f:
  124.         pass
  126. mk()
  127. print("------------------- 7 -----------------------------------------")
  129. # 8、计算某路径下所有文件和文件夹的总大小
  130. import os
  131. # 文件总大小
  132. total_size = 0
  134. def lis_file_path(path):
  135.     global total_size
  136.     # 获取指定目录下的文件和子目录，返回一个列表
  137.     ret_list = os.listdir(r'%s' % path)
  138.     for i in ret_list:
  139.         # 拼接路径
  140.         ret = os.path.join(path + '/%s' % i)
  141.         # 如果是文件夹继续递归
  142.         if os.path.isdir(ret):
  143.             lis_file_path(ret)
  144.          # 如果是文件就直接计算大小，算入总值
  145.         elif os.path.isfile(ret):
  146.             size = os.path.getsize(ret)
  147.             total_size += size
  148.     return "%s%s" % (total_size/1024/1024, "MB")
  150. ret = lis_file_path('/Users/lichengguo/Documents/98-Python/python3-02/')
  151. print(ret)
  152. print("------------------- 8 -----------------------------------------")

练习题2

  1. #!/usr/bin/env python3
  2. # author:Alnk(李成果)
  4. """
  5. 需求:
  6. 实现加减乘除及拓号优先级解析
  7. 用户输入
  8. 1 - 2 * ( (60-30 +(-40/5) * (9-2*5/3 + 7 /3*99/4*2998 +10 * 568/14 )) - (-4*3)/ (16-3*2) )
  9. 等类似公式后，必须自己解析里面的(),+,-,*,/符号和公式
  10. 注意：不能调用eval等类似功能偷懒实现
  11. """
  13. import re
  15. def calc(s):
  16.     """计算加减乘除"""
  17.     # 去掉空格
  18.     s = s.replace(' ', '')
  19.     # 替换运算符号
  20.     s = s.replace('--', '+').replace('++', '+').replace('-+', '-').replace('+-', '-')
  22.     # 计算乘除
  23.     while re.search('[.\d]+[*/]+[-+]?[.\d]+', s):
  24.         # 匹配第一个乘除公式
  25.         res = re.search('[.\d]+[*/]+[-+]?[.\d]+', s).group()
  26.         # 判断乘除
  27.         if res.count('*'):
  28.             res_list = res.split('*')
  29.             ret = float(res_list[0]) * float(res_list[1])
  30.         else:
  31.             res_list = res.split('/')
  32.             ret = float(res_list[0]) / float(res_list[1])
  33.         # 把结果替换回原来的公式中，并且替换运算符
  34.         s = s.replace(res, str(ret)).replace('--', '+').replace('++', '+').replace('-+', '-').replace('+-', '-')
  36.     # 计算加减
  37.     # 找到所有的 正数或者负数，生成一个列表
  38.     s_list =  re.findall('[-]?[.\d]+', s)
  39.     sum = 0
  40.     # 循环列表，都做加法（减法可以看作加一个负数）
  41.     for i in s_list:
  42.         sum += float(i)
  43.     return sum
  45. def strip_kuohao(s):
  46.     # 去掉空格
  47.     s = s.replace(' ', '')
  48.     # 替换运算符号
  49.     s = s.replace('--', '+').replace('++', '+').replace('-+', '-').replace('+-', '-')
  50.     # 匹配最里层的括号
  51.     while re.search('\([^\(\)]+\)', s):
  52.         # 替换运算符号
  53.         s = s.replace('--', '+').replace('++', '+').replace('-+', '-').replace('+-', '-')
  54.         # 获取匹配到的最里层的括号公式
  55.         kuohao_res = re.search('\([^\(\)]+\)', s).group()
  56.         # 去掉括号，传入calc函数进行加减乘除运算
  57.         kuohao_res_strip = kuohao_res.strip('(,)')
  58.         ret = calc(kuohao_res_strip)
  59.         # 结果替换到原来的公式中
  60.         s = s.replace(kuohao_res, str(ret))
  61.     else:
  62.         # 最后没有括号的公式还要进行一次加减乘除运算，算出最后的结果
  63.         ret = calc(s)
  64.         s = s.replace(s, str(ret))
  65.     return  s
  67. s = '1 - 2 * ( (60-30 +(-40/5) * (9-2*5/3 + 7 /3*99/4*2998 +10 * 568/14 )) - (-4*3)/ (16-3*2) )'
  68. ret = strip_kuohao(s)
  69. print(ret)
  70. print(eval(s))

Python语言系列-05-模块和包的更多相关文章

  1. Python 入门基础13 --模块与包

    本节内容: 一.模块及使用 1.模块及使用 2.起别名.from导入 3.自执行与模块 二.包的使用 2.1 包中模块的使用:import 2.2 包的嵌套 2.3 包中模块的使用:from ...i ...

  2. 2015/9/15 Python基础(12)：模块和包

    模块是用来组织 Python 代码的方法,而包则是用来组织模块的. 当代码量很大时,我们一般会把代码分成几个有组织的代码段,然后每个代码段之间有一定的联系.代码单之间是共享的,所以Python允许调入 ...

  3. python（33）- 模块与包

    一 模块 1 什么是模块? 一个模块就是一个包含了python定义和声明的文件,文件名就是模块名字加上.py的后缀. 2 为何要使用模块? 如果你退出python解释器然后重新进入,那么你之前定义的函 ...

  4. Python Revisited Day 05(模块)

    目录 5.1 模块与包 5.1.1 包 5.2 Python 标准库概览 5.2.1 字符串处理 io.StringIO 类 5.2.3 命令行设计 5.2.4 数学与数字 5.2.5 时间与日期 5 ...

  5. python之旅：模块与包

    一.模块介绍 前言:引用廖雪峰大神的,说的很好!!! 在计算机程序的开发过程中,随着程序代码越写越多,在一个文件里代码就会越来越长,越来越不容易维护. 为了编写可维护的代码,我们把很多函数分组,分别放 ...

  6. Python基础入门（模块和包）

    1 模块 1.1 什么是模块 在 Python 中,一个 .py 文件就称之为一个模块(Module). 我们学习过函数,知道函数是实现一项或多项功能的一段程序 .其实模块就是函数功能的扩展.为什么这 ...

  7. Python学习笔记 - day9 - 模块与包

    模块与包 一个模块就是一个包含了Python定义和声明的文件,文件名就是模块名加上.py的后缀,导入一个py文件,解释器解释该py文件,导入一个包,解释器解释该包下的 __init__.py 文件,所 ...

  8. 【python基础语法】模块和包管理，文件的操作（第8天课堂笔记）

    ''' 模块和包管理 模块和包的定义: 模块:模块是一个Python文件,以.py结尾,包含了Python对象定义和Python语句 包:Python中的包就是一个包含__init__.py文件的目录 ...

  9. Python语言学习：模块

    一.模块 1. 模块(Module):以.py结尾的文件,包含python对象定义和python语句.使代码段更容易理解和使用. 模块分为两种:标准库(直接导入的库)和第三方库(需要下载安装的库). ...

随机推荐

  1. 对象池技术和通用实现GenericObjectPool

    对象池技术其实蛮常见的,比如线程池.数据库连接池 他们的特点是:对象创建代价较高.比较消耗资源.比较耗时: 比如 mysql数据库连接建立就要先建立 tcp三次握手.发送用户名/密码.进行身份校验.权 ...

  2. Centos-Springboot项目jar包自启动

    CentOS环境下部署Springboot项目的jar包开机自启动. 部署环境 Centos 7.5 Springboot 2.1.x 操作步骤 修改pom 在pom.xml文件中<plugin ...

  3. 增强采样软件PLUMED的安装与使用

    技术背景 增强采样(Enhanced Sampling)是一种在分子动力学模拟中常用的技术,其作用是帮助我们更加快速的在时间轴上找到尽可能多的体系结构及其对应的能量.比如一个氢气的燃烧反应,在中间过程 ...

  4. 深入理解 SynchronizationContext

    深入理解 SynchronizationContext 目录 深入理解 SynchronizationContext SynchronizationContext(后续以SC简称) 是什么? 1.1 ...

  5. 深入浅出图神经网络 第6章 GCN的性质 读书笔记

    第6章 GCN的性质 第5章最后讲到GCN结束的有些匆忙,作为GNN最经典的模型,其有很多性质需要我们去理解. 6.1 GCN与CNN的区别与联系 CNN卷积卷的是矩阵某个区域内的值,图卷积在空域视角 ...

  6. ESP32构建系统 (传统 GNU Make)

    概述: 一个 ESP-IDF 项目可以看作是多个不同组件的集合,ESP-IDF 可以显式地指定和配置每个组件.在构建项目的时候,构建系统会前往 ESP-IDF 目录.项目目录和用户自定义目录(可选)中 ...

  7. [刘阳Java]_Spring AOP入门_第7讲

    AOP技术个人认为是能够完善(改善)面向对象编程OOP.为什么这么说,我们得先从AOP的概念说起,然后通过一段简单的例子加以佐证.这样子大家就可以慢慢地了解AOP 1. AOP概念 AOP为Aspec ...

  8. Spring Boot 2.x基础教程：使用Elastic Job实现定时任务

    上一篇,我们介绍了如何使用Spring Boot自带的@Scheduled注解实现定时任务.文末也提及了这种方式的局限性.当在集群环境下的时候,如果任务的执行或操作依赖一些共享资源的话,就会存在竞争关 ...

  9. 每天五分钟Go - Map

    map的定义 var m map[type]type fmt.Println(m) 此种方法定义的m为nil //打印的结果为: map[] map的创建 1.使用make创建 var m1 = ma ...

  10. 【排序+模拟】魔法照片 luogu-1583

    题目描述 一共有n(n≤20000)个人(以1--n编号)向佳佳要照片,而佳佳只能把照片给其中的k个人.佳佳按照与他们的关系好坏的程度给每个人赋予了一个初始权值W[i].然后将初始权值从大到小进行排序 ...