博刊：今日物语：CP1——2020.07 初周目


浏览次数 :  次   
博文字数统计 : 2.8k字   |   阅读所需时长 : 12分
× 文章目录
  1. 1. 博刊：今日物语CP1——2020.07 初周目
    1. 1.1. 2020.07.13
      1. 1.1.1. 1. Python
      2. 1.1.2. 2. Light 新闻编辑
      3. 1.1.3. 3 文件整理
    2. 1.2. 2020.07.14
      1. 1.2.1. 1. Python
      2. 1.2.2. 2. Light 新闻编辑
    3. 1.3. 2020.07.15
      1. 1.3.1. 1. Python
      2. 1.3.2. 2. 课程相关
    4. 1.4. 2020.07.16
      1. 1.4.1. 1. Python
      2. 1.4.2. 2. 课程相关
    5. 1.5. 2020.07.17
      1. 1.5.1. 1. Python
      2. 1.5.2. 2. 课程相关
    6. 1.6. 2020.07.20
      1. 1.6.1. 1. Python
      2. 1.6.2. 2. Matlab
      3. 1.6.3. 3. Typora
      4. 1.6.4. 4. 课程相关
    7. 1.7. 2020.07.21
      1. 1.7.1. 1. Python
      2. 1.7.2. 2. Excel
    8. 1.8. 2020.07.22
      1. 1.8.1. 1. Python
      2. 1.8.2. 2. Review—Python
    9. 1.9. 2020.07.23
      1. 1.9.1. 1. Python
      2. 1.9.2. 2. Review—Python
    10. 1.10. 2020.07.24
      1. 1.10.1. 1. Python
      2. 1.10.2. 2. Review—Python
    11. 1.11. 2020.07.25
      1. 1.11.1. 1. Python
      2. 1.11.2. 2. Review—Python
    12. 1.12. 2020.07.26
      1. 1.12.1. 1. MySQL
      2. 1.12.2. 2. OJ刷题
  • 博刊：今日物语：CP1——2020.07 初周目
  • 时间：2020.07.13~2020.07.26

博刊：今日物语CP1——2020.07 初周目

2020.07.13

1. Python

  • 进程(Process)的概念、PID
  • 进程的创建、运行、进程守护
  • 进程的参数传递、全局变量，数据共享：不会自动共享
  • 进程与线程的对比

2. Light 新闻编辑

3 文件整理

  • 将PC端的大学阶段的一些文件、数据传到云端备份。

2020.07.14

1. Python

  • 进程(Process)间的数据通信，队列(Queue)的用法

  • 队列(Queue)的创建、操作、常用判断

    • queue.put()
    • queue.get()
    • queue.qsize()

  • 进程池(Pool)的概念与用法

    • multiprocessing.Pool(n)

    • 同步：pool.apply(函数名, 参数)

    • 异步：pool.apply_async(函数名, 参数)

      • pool.close()
      • pool.join()

  • 进程池中的队列

    • multiprocessing.Manager().Queue(n)

  • 实例——多进程文件夹copy器

  • 实例——多进程的Web服务器

2. Light 新闻编辑

  • Mini-LED, Micro-LED and OLED displays: Present status and future perspectivesMini-LED, Micro-LED and OLED displays: Present status and future perspectives
  • 综述：Mini-LED, Micro-LED and OLED的性能比较与前景展望
  • https://doi.org/10.1038/s41377-020-0341-9

2020.07.15

1. Python

  • 可迭代对象(Iterable)和迭代器(Iterator)
    • __iter__
    • __next__
  • 迭代器应用—自定义列表
  • 迭代器应用—斐波那契数列

2. 课程相关

  • 完成信息论课程论文

2020.07.16

1. Python

  • 生成器(Generator)—特殊的迭代器
    • yield
    • return 捕获异常
    • send(para)
  • 生成器应用—斐波那契数列

2. 课程相关

  • 完成微纳光子学课程论文

2020.07.17

1. Python

  • 协程(Coroutine)—特殊的生成器—微线程
    • yield
    • greenlet
      • from greenlet import greenlet
      • 创建对象：g1 = greenlet(func)
      • 切换任务(协程)：g1. switch(args)
    • gevent
      • import gevent
      • 指派任务：g1 = gevent.spawn(func, args1，args2，….)
      • g1.join
      • gevent.sleep()
      • 导入模块 from gevent import monkey
      • 破解所有：monkey.patch_all()
  • 线程、进程、协程的对比

2. 课程相关

  • 完成自然辩证法课程论文

2020.07.20

1. Python

  • 协程(Coroutine)
  • 实例——协程并发下载器
    • urllib.request.urlopen(网址)
    • gevent.joinall([协程的列表])
  • 实例——协程版Web服务器
    • 导入猴子补丁并破解
    • 创建协程
    • gevent.join() 主线程一直在循环，因此join()可省略

2. Matlab

  • 三维插值函数 (Interpolant—内插式)
    • griddata
    • TriScatteredInterp
    • scatteredInterpolant
  • N维插值函数
    • griddatan
    • griddedInterpolant

3. Typora

  • 侧边栏折叠显示设置
  • 字体设置
    • 修改conf.user.json 用户设置文件
    • 修改github.css 等主题设置文件 theme.css

4. 课程相关

  • 完成工程伦理课程论文

2020.07.21

1. Python

  • 正则表达式
  • 正则表达式单字符匹配
  • 多字符匹配
  • 开头结尾匹配

2. Excel

Python 读取、修改excel文件的相关模块及用法

  • xlrd模块—读取、导入Excel

  • xlwt模块—写入Excel

    注意

    xlrd和xlwt模块都只能处理xls文件，不能处理xlsx文件

    两者都只能处理小文件，不能处理大文件

    xlwt模块每次写入文件只能创建一个新文件，不能修改原文件(在原文件上追加内容)

  • xlutils模块的copy函数

    弥补xlwt不能修改原文件的问题

    先读取原文件，再用xlutils.copy复制一份

    最后对复制的文件实现写入

  • xlsxwriter模块

    写入xlsx文件，不能处理xls文件

    可处理大文件

  • openpyxl模块

    既可以读取文件，也可以写文件，还可以修改文件

    对象为xlsx、xlsm文件，不能处理xls文件

    可以处理大文件

2020.07.22

1. Python

  • re模块的常用方法和应用场景

    • re.match(pattern, string, flags=0)

      pattern:正则匹配模型—正则表达式

      string:要匹配的字符串

      flags:匹配模式

      边界匹配符：$

      返回 match object 对象

      1
      result = re.match(pattern, string, flags=0)

    • match object 对象的常用方法

      result.group()

      返回被匹配的字符串

      result.start()

      返回匹配开始的位置

      result.end()

      返回匹配结束的位置

      result.span()

      返回⼀个元组，包含匹配(开始,结束)的位置

  • 匹配分组

    • 匹配符: |

      a|b 匹配|左右两端的正则表达式

      eg: 匹配身份证号: 15 位，首位不为0,；18位，末尾可为x

      1
      pattern = '^([1-9]\d{16}[0-9x]|[1-9]\d{14})$'

    • 匹配符: ()

      (ab) 将括号中字符作为⼀个分组

      正则表达式中的每个()会有个编号，从1开始，可以用此提取()内匹配项

      常与 | 、?结合使用

      eg: 匹配身份证号

      1
      pattern = '^[1-9]\d{14}(\d{2}[0-9x])?$'

      eg: 匹配多个邮箱

      1
      pattern = '\w{6,15}@(163|126|qq|gmail)\.com'

      eg: 匹配并获取区号、电话号 3+8位；4+7位

      1
      2
      3
      4
      5
      6
      7
      8
      import re
      pattern = '(\d{3,4})-(\d{7,8})'
      str_phone = '010-12345678'
      re_phone = re.match(pattern, str_phone)
      print(re_phone.group())
      # 提出子匹配项
      print('区号为:', re_phone.group(1))
      print('电话号为:', re_phone.group(2))

    • 匹配符: \ num —引用 () 对应 \ num

      \num 表示引用已有的分组()编号为num的分组的匹配符

      适用于匹配html代码的匹配

      \num 的\需要用’'转义，或者在字符串之前加 r，让整个字符串不转义

      1
      2
      '<[a-zA-Z\d]+>.*</[a-zA-Z\d]+>'  
      # 该正则表达式无法保证html标签<html>和</html>匹配
      1
      2
      3
      4
      5
      6
      7
      8
      9
      10
      import re
      str_html1 = '<html>test</html>'
      pattern1 = r'<([a-zA-Z\d]+)>.*</\1>'
      # pattern = '<([a-zA-Z\d]+)>.*</\\1>'
      str_html2 = '<html><h1>new test</h1></html>'
      pattern2 = r'<([a-zA-Z\d]+)><([a-zA-Z\d]+)>.*</\2></\1>'
      re_html1 = re.match(pattern1, str_html)
      re_html2 = re.match(pattern2, str_html2)
      print(re_html1.group())
      print(re_html2.group())

    • 匹配符: (?P<name.>) —为该分组起一个别名name，用于引用，代替编号引用

    • 匹配符: (?P=name) —引用别名为name的分组

      (?P<name.>) 对应 (?P=name) 

      1
      2
      3
      4
      5
      import re
      str_html = '<html><h1>new test</h1></html>'
      pattern = r'<(?P<n1>[a-zA-Z\d]+)><(?P<n2>[a-zA-Z\d]+)>.*</(?P=n2)></(?P=n1)>'
      re_html1 = re.match(pattern, str_html)
      print(re_html.group())

2. Review—Python

  • map(func, iterable)

    对可迭代对象iterable中的每一个值做func函数功能

  • zip(iterable1, iterable2)

    将两个可迭代对象—序列的元素一一对应起来

    eg: zip([1,6,8], [2,3,3]) 返回zip object(zip对象)

    用list转换为列表显示: list(zip([1,6,8], [2,3,3]) )

  • max(args, key=func)

    求输入参数为args时，函数func的返回值最大时对应的args

    key默认是return self，即max函数查找最大值

    max(list1, key=lambda x : list1.count(x)) 查找list1中出现次数最多的元素

    等价于 max(list1, key=list1.count)

  • random.uniform(a,b)

    生成[a, b) 内一个随机数

  • random.shuffle(sequence)

    随机打乱序列的排序，一般用list—-常用于机器学习时打乱训练集

  • 实例

    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
    12
    13
    >import random
    >x = [1, 2, 3, 4, 5, 6]
    >y = [0, 1, 0, 0, 1, 1]
    >zipped_data = list(zip(x, y))
    >random.shuffle(zipped_data)
    >new_zipped_data = list(map(list, zip(*zipped_data)))
    ># zip(*)反向解压，map()逐项转换类型，list()做最后转换
    >new_X, new_y = new_zipped_data[0], new_zipped_data[1]
    ># 返回打乱后的新数据
    >print('x:',x,'\n','y:',y)
    >print('new_x:',new_x, '\n', 'new_y:',new_y)

    >print(zipped_data)

2020.07.23

1. Python

  • re模块高阶用法

    • re.match(pattern, string, flags=0)

    • re.search(pattern, string, flags=0)

    • re.findall(pattern, string, count=0, flags=0)

  • re.split(pattern, string, maxsplit=0, flags=0)

  • re.sub(pattern, repl, string, count=0, flags=0)

  • 贪婪：’*’、’+’、’?’、’{}’

  • 非贪婪：在后面加一个?

    爬虫时匹配网址、图片地址

2. Review—Python

  • dict 字典创建方法

    可哈希对象才可以作为字典的key，不可哈希对象不能

    可变对象—不可哈希；不可变对象—可哈希

    d = dict({‘c’:3,’d’:4},e=5,f=6)

    键对值+关键字参数+dict构造函数

    d = dict([(‘a’,1),(‘b’,2)],e=5,f=6)

    可迭代对象+关键字参数+dict构造函数

    fromkeys()方法

  • set集合

    可哈希对象才可以作为集合的元素，不可哈希对象不能

    • 并集

      set1.union(set2, set3, …)

    • 交集

      set1.intersection(set2, set3, …)

    • 差集

      set1.difference(set2, set3, …)

    • 子集

      set1.issubset(set2)

2020.07.24

1. Python

  • 简单爬虫

2. Review—Python

  • lambda x:func(x)

    一些内置函数中的key=func关键字常与lambda匿名函数结合使用

  • dict 例子

    • dict.setdefault 添加单个键值对，返回添加的键值对的value

    • dict.update 添加多个键值对，返回值None

      dict.setdefault(key,value)

      dict.update([(key1,value1), (key2,value2)])

      dict.update(key1=value1, key2=value2)

      dict.update({key1:value1, key2:value2})

    • 字典并集

      简单合并

      dict_new = {*dict1,\*dict2} # 生成一个新的字典，改变dict_new不会影响dict1、dict2

      逻辑上合并

      使用collections模块的ChainMap函数，改变生成的新字典的键对值，会影响dict1、dict2

      1
      2
      3
      4
      5
      6
      7
      from collections import ChainMap
      dict1 = {'a': 1, "b": 5}
      dict2 = {"c": 3, 's': 8}
      dict_new = ChainMap(dict1, dict2)
      print(dict_new)  # 返回ChainMap对象，ChainMap(dict1, dict2})
      # 改变ChainMap对象的键对值，可以影响dict1、dict2
      print(dict(dict_new))  # 转变为一个dict---改变该dict对dict1、dict2无影响

      改变ChainMap对象的键对值，可以影响dict1、dict2

    • 字典差集 d1, d2

      dict([k, v] for k, v in d1.items() if k not in d2)

    • 排序sorted(dict, key=)

      按key sorted 返回的是list，其元素为由key, value组成的元组

      sorted(dict1.items(), key=lambda x:x[0])

      按value [(key1,value1),(key2,value2)]

      sorted(dict1.items(), key=lambda x:x[1])

    • 查找字典的前n个最大值对应的键

      1
      2
      3
      4
      5
      from heapq import nlargest
      dict1 = {'a': 1, "b": 5, "c": 3, 's': 8, 'm': 4}
      def topn_dict(d, n):
      return nlargest(n, d, key=lambda x: d[x])
      print(topn_dict(dict1, 3))
      1
      2
      3
      4
      5
      6
      7
      8
      dict1 = {'a': 1, "b": 5, "c": 3, 's': 8, 'm': 4}
      dict_sort = sorted(dict1.items(), key=lambda x:x[1]) # dict_sort 是 list，从小到大
      dict_sort = dict_sort[::-1] # 逆序，从大到小
      n = 3
      key_max = []
      for i in range(n):
      key_max.append(dict_sort[i][0])
      print(key_max)

  • set例子

    • 判断list、str是否没有重复的元素(单字符串)

      len(set(str1)) == len(str1)

2020.07.25

1. Python

  • 多线程爬虫

2. Review—Python

  • 数学运算内置函数

    / : 表示该符号之前的参数都是位置参数

    * : 表示该符号之后的参数都是关键字参数

    • len(s)

    • max(iterable,*[,key,default])

      key: max寻找最大值的函数依据

      default: 若传入的iterable(如列表)为空([])，返回default的值，默认报错empty sequence

    • min(iterable,*[,key,default])

    • pow(x, y, z=None, /)

      z : 给出时，求x的y次幂后在取z的余

    • round(number[, ndigits])

      ndigits : 四舍五入后保留的小数位数

    • sum(iterable, / start=0)

      start : 求和的初始值，默认为0

    • abs(x, /)

    • divmod(a, b)

      返回元组，第一位为商，第二位为余

    • complex(real[, [imag]])

    • hash(object)

      返回对象的哈希值

    • id(object)

  • 逻辑运算内置函数

    • all(iterable)

      iterable元素全为真(非0)—返回True

    • any(iterable)

      iterable元素有至少一个为真(非0)—返回True

  • 进制转换内置函数

    • ascii(object)
    • bin(object)
    • oct(x) 八进制
    • hex(x) 十六进制

2020.07.26

1. MySQL

  • 数据库概念
  • 数据库分类
  • 数据库作用

2. OJ刷题

  • 字节跳动真题：ZJ19：万万没想到之抓捕孔连顺
  • 华为机试：HJ91：201301 JAVA 题目2-3级 棋盘走法
  • 华为机试：HJ15：求int数据的二进制表示中的1的个数
  • 华为机试：HJ11、HJ12、HJ106：数字颠倒、字符串颠倒
  • 华为机试：HJ108：最小公倍数、最大公约数
  • 华为机试：HJ100：等差数列、等比数列求和
  • 华为机试：HJ86：求最大连续bit数(二进制连1数)
本文作者： Chthollists
发布时间： 2020-08-03 16:53:10
最后更新： 2022-01-21 23:09:05
本文标题： 博刊：今日物语：CP1——2020.07 初周目
本文链接： https://chthollists.github.io/post/307d9cf0.html
版权声明： 本作品采用 CC BY-NC-SA 4.0 许可协议进行许可。转载请注明作者和出处！
知识共享许可协议
支持

感谢您的支持

支付宝
微信

扫一扫，分享到微信

微信分享二维码

tag:

    缺失模块。
    1、请确保node版本大于6.2
    2、在博客根目录（注意不是yilia根目录）执行以下命令：
    npm i hexo-generator-json-content --save

    3、在根目录_config.yml里添加配置： 

      jsonContent:
    meta: false
    pages: false
    posts:
      title: true
      date: true
      path: true
      text: false
      raw: false
      content: false
      slug: false
      updated: false
      comments: false
      link: false
      permalink: false
      excerpt: false
      categories: false
      tags: true

<font color="purple" face="Microsoft YaHei" size= 5><b>待到雄图卷毕 &nbsp;&nbsp;隐居山水里<br>坐看炊烟旖旎 &nbsp;&nbsp;浅池戏双鲤<br> </b></font>