来自Java程序员的Python新手入门小结

谁借莪１个温暖的怀抱￠ 2022-09-14 06:25 181阅读 0赞

### 欢迎访问我的GitHub ###

> 这里分类和汇总了欣宸的全部原创(含配套源码)：[https://github.com/zq2599/blog\_demos][https_github.com_zq2599_blog_demos]

### 本篇概览 ###

*  欣宸是个Java程序员，最近正在学习Python，本文记录了学习过程，以及一点自己的思考，主要用途是作为笔记来总结和温习，另外如果您也是一位初学Python的Java程序员，希望本文能给您一些参考；

### 版本 ###

操作系统：macOS Big Sur (11.6)  
Anaconda3：2021.05  
python：3.7.3  
Jupyter Notebook：5.7.8

### 工具 ###

*  编辑器用的是Jupyter Notebook，以下三个快捷键最常用到，尤其是第三个，执行当前行，并新增一行：  
    ![在这里插入图片描述][c41c48a72b8c43d2b599334e092aead4.png]
 *  废话不多说了，直接开始动手操作；

### 除法 ###

*  一个斜杠的除法，结果是浮点型，两个斜杠的触发，结果是整形：  
    ![在这里插入图片描述][ce323e0164b54151a74d829c47a23005.png]

### 字符串 ###

*  格式化的时候，可以不指定参数索引，此时按照出现顺序处理：  
    ![在这里插入图片描述][4a9c7f695c4a49c7a9f74be8c1e8d1c6.png]
 *  也可以在花括号中添加数字：  
    ![在这里插入图片描述][d0d21815f47c445d93b2855cf6bfdfd3.png]
 *  还可以在花括号中添加冒号，在冒号之后添加特定的输出格式
 *  保留小数点后三位，**f**表示浮点数：  
    ![在这里插入图片描述][6ca9a1edf82d4bb2a4a936d5bae81fee.png]
 *  带符号保留小数点后三位，**f**表示浮点数：  
    ![在这里插入图片描述][16113f963ce949f687e0bce1bbafd8a7.png]
 *  不显示小数：  
    ![在这里插入图片描述][9e6d74d1a0084baaa26da0c16cdab09d.png]

### 列表 ###

*  逗号分隔，方括号包裹：  
    ![在这里插入图片描述][0c0a47befeaf44edbee8fe3496d0234f.png]
 *  列表各个元素的类型无需相同（这一点和Java数组是不同的）
 *  访问列表中的元素，使用方括号+索引(从0开始)：  
    ![在这里插入图片描述][ce895b3a0ea94eabbee64b83d9edbaf6.png]
 *  索引数值可以为负，负一表示倒数第一：  
    ![在这里插入图片描述][2f93c49a37d8461c9fa6994750fe8052.png]
 *  与字符串的字符不同之处在于，列表的元素可以修改：  
    ![在这里插入图片描述][0864fddc37eb456c8c4061340b060816.png]
 *  分片，下面代码表示从0开始，一直取到2-1位置（左闭右开）：  
    ![在这里插入图片描述][13649221a62f4300a001e7b4d4ff5aa6.png]
 *  分片的时候，冒号左边不填就表示从0开始，右边不填表示直到最后一个元素：  
    ![在这里插入图片描述][79a90822831742c6bcc7b96041febfe5.png]
 *  分片可以接受第三个参数：步长，下面的表示每遍历两个元素才取一个  
    ![在这里插入图片描述][758d7543e4ae4c1f8f73e26ac97c5122.png]
 *  当步长等于负一的时候，相当于反转了：  
    ![在这里插入图片描述][469f8c3b3c904a42973bd3968afd0e3d.png]
 *  用加号实现两个列表相连：  
    ![在这里插入图片描述][23d216a2c4ab458d809787a7e22fded0.png]
 *  列表乘以数字N，表示生成一个新的列表，内容是原列表的N份复制：  
    ![在这里插入图片描述][e599259a6670436a9be5d8696b1e76b5.png]
 *  append：尾部追加元素  
    ![在这里插入图片描述][59bf5d25fde944d6831df1f78ac11eb2.png]
 *  insert：将元素插入在指定位置  
    ![在这里插入图片描述][76c72dfca53143d9b980f8f89fbd7713.png]
 *  extend：将一个列表追加到另一个列表尾部  
    ![在这里插入图片描述][445e976cb9cd481199a2139d22618bb6.png]
 *  方法id可以查看对象的内存地址，如下图，可见经历了append、insert、extend等操作后，内存地址不变，也就是说这些都是原地操作(in place)：  
    ![在这里插入图片描述][watermark_type_ZHJvaWRzYW5zZmFsbGJhY2s_shadow_50_text_Q1NETiBA56iL5bqP5ZGY5qyj5a64_size_11_color_FFFFFF_t_70_g_se_x_16]

### 列表的删除操作 ###

*  删除列表元素有三种方式：pop、remove、clear
 *  pop()会弹出最后一个元素：  
    ![在这里插入图片描述][0412f8a106714f56921f3e0586a695b5.png]
 *  也可以将索引作为入参传入，这样就能删除指定元素：  
    ![在这里插入图片描述][watermark_type_ZHJvaWRzYW5zZmFsbGJhY2s_shadow_50_text_Q1NETiBA56iL5bqP5ZGY5qyj5a64_size_10_color_FFFFFF_t_70_g_se_x_16]
 *  remove方法的入参是列表中的值，也就是找到列表中与入参相同的元素，将其删掉，下图可见，myList中有两个’abc’，用remove会删除第一个：  
    ![在这里插入图片描述][fcdedc1e89e34cddbfcffccd8596b66d.png]
 *  clear方法会清空列表：  
    ![在这里插入图片描述][8534bdb3f00445019b80a47142fb2440.png]

### 列表的记数和索引 ###

*  count方法统计指定元素在列表中的数量，从下图可见1在列表中出现了两次：  
    ![在这里插入图片描述][65a18c9f4d4b465aa3e37f271220705b.png]
 *  index查找指定元素出现的位置：  
    ![在这里插入图片描述][793c6bc5e3574c5f803a7c3b25b6bf1a.png]

### 列表排序 ###

*  sort方法用来排序，默认是比较元素大小：  
    ![在这里插入图片描述][7c91955929ff459d91ee2f273aeebccf.png]
 *  默认是升序，添加reverse=True表示降序：  
    ![在这里插入图片描述][ea06640da31e4c6d929dc44c04be5e28.png]
 *  sort操作的是列表对象本身，还可以用全局函数sorted来排序，该函数会生成一个新的副本，如下图，newList是排序后的列表，而原有的myList保持不变：  
    ![在这里插入图片描述][watermark_type_ZHJvaWRzYW5zZmFsbGJhY2s_shadow_50_text_Q1NETiBA56iL5bqP5ZGY5qyj5a64_size_9_color_FFFFFF_t_70_g_se_x_16]

### 与列表相关的常用全局函数 ###

*  除了sorted，还有一些常用的全局函数和列表有关：
 *  operator(取代原有的cmp)，用于比较大小以及是否相等：  
    ![在这里插入图片描述][watermark_type_ZHJvaWRzYW5zZmFsbGJhY2s_shadow_50_text_Q1NETiBA56iL5bqP5ZGY5qyj5a64_size_12_color_FFFFFF_t_70_g_se_x_16]
 *  len：计算个数  
    ![在这里插入图片描述][b749da6e8cf447bb92a0131fbdf56bf8.png]
 *  max：返回最大值  
    ![在这里插入图片描述][5de21fbbf5524e9eb21e9b853c633d12.png]
 *  min：返回最小值  
    ![在这里插入图片描述][04452c4a1ca944c28916f520c8eff8a6.png]
 *  list：元组转为列表  
    ![在这里插入图片描述][e47bb7731be240979ddf861c96da323f.png]
 *  zip：两个列表中，同位置元素结合成一个元组，最终得到一个元组列表：  
    ![在这里插入图片描述][watermark_type_ZHJvaWRzYW5zZmFsbGJhY2s_shadow_50_text_Q1NETiBA56iL5bqP5ZGY5qyj5a64_size_18_color_FFFFFF_t_70_g_se_x_16]
 *  enumerate：将指定列表的每个元素与其位置下表组成一个元组，最终得到一个元组列表（和上面的zip用法相似，不过简单多了，range操作已经在enumerate内部实现）,如下图：  
    ![在这里插入图片描述][b2ea3e7c02134fcfaaf5a08183122f54.png]

### 元组 ###

*  元组与列表相似，但是一旦创建就不能修改，创建使用的是圆括号（列表是方括号）  
    ![在这里插入图片描述][b87f46b27ac3469183c03a35c38d9b4a.png]
 *  要注意的是，只有一个元素的元组也要带逗号，例如(1,)，这很好理解，毕竟(1)就是个整数而已
 *  没有括号，只有逗号，也是元组：  
    ![在这里插入图片描述][66409f0295ff4a5ca10c195f7e3df26b.png]
 *  下标操作和列表相同：  
    ![在这里插入图片描述][798244906bec48daaeb5da1554e2a7c5.png]
 *  列表转元组用tuple函数：  
    ![在这里插入图片描述][098cd060cd87426fb7aaa24c0bf6a46b.png]
 *  tuple函数还能将字符串直接转为元组：  
    ![在这里插入图片描述][43de5790e1804b538ce02a7470fb8627.png]
 *  修改元组会失败：  
    ![在这里插入图片描述][1619b050d33a45eb97b808f8271e0720.png]
 *  修改元组的思路是创建新的元组，如下图，用三个元组拼接的方式生成了一个新的元组，相比旧的，新元组的第三个元素已经从2变为’a’，给人以修改过的感觉:  
    ![在这里插入图片描述][5bf4f4a1d7294d5ba67e80561ae5f04f.png]

### 字典 ###

*  字典和Java的map相似，由多个键值对构成，键和值之间用冒号分隔，多个键值之间用逗号分隔，外面用大括号包裹：  
    ![在这里插入图片描述][f86ab2ccb6d4406b99b9e963b2e2bd3a.png]
 *  字典看起来很像json
 *  items方法返回所有元素，keys返回所有键，values返回所有值：  
    ![在这里插入图片描述][7004da6764a74fb28620ecc393448969.png]
 *  可以用键查找值，和Java的map一样，不过语法是中括号：  
    ![在这里插入图片描述][7622104c5a5b408891679da510c0401a.png]
 *  也可以用get方法返回键对应的值，还能指定键不存在时的默认值：  
    ![在这里插入图片描述][3203ab6ad1d1498ba37a2cc9a7763443.png]
 *  直接用方括号，可以修改，如果键不存在就是添加：  
    ![在这里插入图片描述][watermark_type_ZHJvaWRzYW5zZmFsbGJhY2s_shadow_50_text_Q1NETiBA56iL5bqP5ZGY5qyj5a64_size_19_color_FFFFFF_t_70_g_se_x_16]
 *  update方法的入参是另一个字典，该方法可以将入参字典的内容合并进自身：  
    ![在这里插入图片描述][79ebe35d58054a87a88a350883ade8e8.png]
 *  pop方法删除指定元素，popitem方法删除最后一个元素：  
    ![在这里插入图片描述][watermark_type_ZHJvaWRzYW5zZmFsbGJhY2s_shadow_50_text_Q1NETiBA56iL5bqP5ZGY5qyj5a64_size_16_color_FFFFFF_t_70_g_se_x_16]

### 集合(Set) ###

*  提到Set，Java程序员应该不陌生，就是咱们经常用来排重的那个Set，是个无序元素集
 *  集合用逗号分隔，大括号包裹：  
    ![在这里插入图片描述][e3494ef2cc95426f84f8482a690da107.png]
 *  小结三种包裹方式：列表方括号，元组圆括号，字典和集合大括号（字典的元素是键值对，集合是单个元素），另外元组可以不包裹，有逗号就行
 *  set方法可以将列表转为集合：  
    ![在这里插入图片描述][878b11c252f549f6b63c174b8244a7c7.png]
 *  集合的元素都是不可变类型的，如数值、字符串、元组
 *  可变类型不能作为集合的元素，如列表、字典、集合，至于其中原因，看看下图红框的错误信息，如果您是个Java程序员，应该get到了：  
    ![在这里插入图片描述][f162e17cc394450aa9bb1a070156607d.png]
 *  可以用减号或者difference方法求两个集合的差集：  
    ![在这里插入图片描述][b0759f9720fc4462b82a31edcf838ceb.png]

### 程序逻辑控制 ###

*  if判断，是用if、elif、else的组合，注意if、elif、else的行末尾都有冒号：  
    ![在这里插入图片描述][74d9718ab2744c549e83baed7aa2858e.png]
 *  python不支持switch
 *  if判断的三元操作符，赋值的时候可用if else组合：  
    ![在这里插入图片描述][7e5709863c1b4b2ca0b31a9612eb8ac4.png]
 *  普通的for循环：  
    ![在这里插入图片描述][0c219ff4a56544e59918dbeabf66ce2e.png]
 *  内置函数range可以创建整数列表，也能在for循环中遍历：  
    ![在这里插入图片描述][87920e09d88d43598d069a3b4ee05923.png]
 *  while循环的语法和java相似：  
    ![在这里插入图片描述][27fa7cbdb05e46abb17d3c6c24e5a1c2.png]
 *  循环中的break和continue与Java类似，就不赘述了

### 推导式：列表 ###

*  格式如下：

[生成表达式 for 变量 in 序列或迭代对象]

*  测试如下，a就是列表推导式生成的列表：  
    ![在这里插入图片描述][0a36369a418441b0b73628774d69e1cb.png]
 *  还可以通过if增加筛选条件，例如下面是只保留偶数：  
    ![在这里插入图片描述][94ff196e108e47ffb864d51e60256a4d.png]
 *  如果列表的元素也是列表，我们可以用列表推导将其解开，平铺为一层，下图的例子中，a\_element是a的元素，a\_element自身也是列表，还可以用推导将其展开：  
    ![在这里插入图片描述][e16ba8309c8f490cbd61a9b17b76f45c.png]

### 推导式：字典 ###

*  对字典用推导式，可以取得键和值的处理，下面是用推导式生成一个新的字典，剔除了键为age的键值对：  
    ![在这里插入图片描述][f7e27bd16383460fb7c3f9289be4d551.png]

### 推导式：集合 ###

*  下面使用推导式，利用列表生成一个新集合，里面的值是原列表每个元素的平方，而且由于集合的不重复性，原列表中重复的元素已经被过滤为只剩一个：  
    ![在这里插入图片描述][4369539c8d72443294d5216bf569a4aa.png]

### 导入库 ###

*  语法：

import 模块名 [as 别名]

*  例如导入math模块来计算正弦值：  
    ![在这里插入图片描述][213a72a704aa4f5daf5cd4eca7ac0817.png]
 *  如果觉得每次在代码中写math太麻烦，还可以在导入时设置别名：  
    ![在这里插入图片描述][0b56c0f561b74383b8411aa39fd9c226.png]
 *  如果觉得别名也麻烦，能不能把m.也去掉，可以用以下语法：

from 模块名 import 对象名

例如：  
![在这里插入图片描述][watermark_type_ZHJvaWRzYW5zZmFsbGJhY2s_shadow_50_text_Q1NETiBA56iL5bqP5ZGY5qyj5a64_size_17_color_FFFFFF_t_70_g_se_x_16]

*  上述极简的方式是不推荐使用的，因为缺少了namespace隔离，在API的正确性上就缺少了保障

### 关于自己的模块 ###

*  假设有一个python文件hello.py，内容如下，定义了名为doHello的方法，再执行一下试试：

def doHello():
    	print("hello world!")
    
    doHello()

*  现在另一个文件test.py，里面会调用hello.py中的doHello的方法：

import hello
    
    hello()

*  执行命令python test.py，结果如下，可见hello world!输出了两次：

will$ python test.py 
    hello world!
    hello world!

*  上述结果显然不是我们想要的，test.py只是想使用doHello方法，结果将hello.py中的doHello()也执行了，需要一种方式来避免test.py中的doHello()被执行
 *  这时候内置变量**name**就派上用场了（注意前后都是两个下划线），将hello.py改成如下内容，如果执行python hello.py，内置变量**name**的值就是**main**，其他时候，例如hello.py被其他文件import的时候，它的值就是模块名(这里就是hello)：

def doHello():
    	print("hello world!")
    
    if __name__=='__main__':
    	doHello()

*  再试试python test.py，这次只有一次输出了：

will$ python test.py 
    hello world!

*  我们再试试python hello.py，也能按照预期输出：

will$ python hello.py
    hello world!

### 包 ###

*  对于Java程序员来说，包很好理解，在python中也很相似，接下来咱们尝试一下，创建名为test的包，里面有两个模块：test1和test2
 *  加入包名为test，咱们创建名为test的文件夹
 *  test文件夹下，新增文件**init**.py，这是个空文件
 *  创建文件test1.py：

def doTest1():
    	print("hello test1!")

*  再创建文件tes2.py:

def doTest2():
    	print("hello test2!")

*  现在回到test2.py文件的上一层目录，创建文件hello.py，用来验证如何使用包，可见访问方式是包名.模块名.方法名：

import test.test1 as test1
    import test.test2 as test2
    
    test1.doTest1()
    test2.doTest2()

*  运行hello.py试试：

will$ python hello.py
    hello test1!
    hello test2!

### 内建模块：collections ###

*  Java程序员对collections包不会陌生，这里面都是一些和容器相关的类，为咱们的开发提供了极大便利，接下来看看该模块常用的几个类
 *  namedtuple：可以用名字访问内容的元组子类，从下面的代码可见，namedtuple可以方便的定义一个对象，很像java中的bean：

from collections import namedtuple
    
    # 自定义元组对象
    Student = namedtuple('Student', ['name', 'age'])
    
    # 实例化Student
    student = Student('Tom', 11)
    
    # 看一下student的类型
    print(type(student))
    
    # 使用name字段
    print(student.name)
    
    # 使用age字段
    print(student.age)

*  执行结果如下，可见student的name和age字段都能方便的访问到，而student实例的类型是class：

will$ python test.py
    <class '__main__.Student'>
    Tom
    11

### 内建模块：deque ###

*  deque是双向队列，在增加和删除数据的时候比列表的性能更好（列表的读性能更好），基本操作如下所示：

from collections import deque
    
    # 实例化deque
    dq = deque([1,2,3])
    
    # 队列右侧增加元素
    dq.append(4)
    
    print('1. {}'.format(dq))
    
    # 队列左侧增加元素
    dq.appendleft(5)
    
    print('2. {}'.format(dq))
    
    # 指定位置增加元素
    dq.insert(1, 6)
    
    print('3. {}'.format(dq))
    
    # 最右侧元素弹出（删除）
    dq.pop()
    
    print('4. {}'.format(dq))
    
    # 最左侧元素弹出
    dq.popleft()
    
    print('5. {}'.format(dq))
    
    # 删除元素，注意2是值，不是位置
    dq.remove(2)
    
    print('6. {}'.format(dq))
    
    # 倒排
    dq.reverse()
    
    print('7. {}'.format(dq))

*  执行结果如下：

will$ python deque.py
    1. deque([1, 2, 3, 4])
    2. deque([5, 1, 2, 3, 4])
    3. deque([5, 6, 1, 2, 3, 4])
    4. deque([5, 6, 1, 2, 3])
    5. deque([6, 1, 2, 3])
    6. deque([6, 1, 3])
    7. deque([3, 1, 6])

### 内建模块：OrderedDict ###

*  OrderedDict是有顺序的字典，如果您了解LFU（Least frequently used）算法，那么就很容易理解有序的字典了，OrderedDict中的顺序是元素被添加的先后顺序，普通用法如下：

from collections import OrderedDict
    
    # 实例化
    od = OrderedDict()
    
    # 添加
    od['a'] = 1
    od['c'] = 2
    od['b'] = 3
    
    # 顺序是添加的先后顺序
    print("1. {}".format(od))
    
    # 打印所有的键
    print(od.keys())
    
    # 把一个字典合并进来
    od.update({ 'e':'4'})
    
    # 顺序是添加的先后顺序
    print("2. {}".format(od))
    
    # 根据键删除键值对
    od.pop('a')
    
    print("3. {}".format(od))
    
    # 把指定键的键值对移到末尾
    od.move_to_end('c')
    
    print("4. {}".format(od))

*  输出如下：

will$ python ordered.py
    1. OrderedDict([('a', 1), ('c', 2), ('b', 3)])
    odict_keys(['a', 'c', 'b'])
    2. OrderedDict([('a', 1), ('c', 2), ('b', 3), ('e', '4')])
    3. OrderedDict([('c', 2), ('b', 3), ('e', '4')])
    4. OrderedDict([('b', 3), ('e', '4'), ('c', 2)])

### 内建模块：defaultdict ###

*  defaultdict容易理解：带有默认值的字典，用法如下所示，要注意的是defaultdict实例化的入参是lambda表达式，至于这个lambda，相信java程序员并不陌生：

from collections import defaultdict
    
    dd = defaultdict(lambda: 'ABC')
    
    dd['a'] = 1
    
    # 打印一个存在的键值
    print(dd['a'])
    
    # 打印一个不存在的键值
    print(dd['b'])

*  输出如下：

will$ python defaultdict.py 
    1
    ABC

### 内建模块：Counter ###

*  Counter提供了计数器功能，下面的demo演示了用Counter将列表转为了每个元素的统计结果，要注意的是most\_common方法，相当于排序和列表的功能，该方法的返回值是列表，里面的元素是元组：

from collections import Counter
    
    # 一个普通列表
    colors = ['aa', 'bb', 'cc', 'aa']
    
    # 将列表传给Counter进行统计
    result = Counter(colors)
    
    # 打印result类型
    print(type(result))
    
    # 打印result内容
    print(result)
    
    # 用内置函数dict将Counter实例转为字典
    print(dict(result))
    
    # 取统计值最高的前两个元素
    most = result.most_common(2)
    
    # 检查most_common返回值的类型
    print("most_common's type {}".format(type(most)))
    
    # 检查most_common返回值的类型
    print("most_common's value : {}".format(most))

*  输出结果如下：

will$ python Counter.py
    <class 'collections.Counter'>
    Counter({ 'aa': 2, 'bb': 1, 'cc': 1})
    { 'aa': 2, 'bb': 1, 'cc': 1}
    most_common's type <class 'list'>
    most_common's value : [('aa', 2), ('bb', 1)]

### 内建模块：datetime ###

*  名为datetime的模块中，有个名为datetime的类  
    ![在这里插入图片描述][watermark_type_ZHJvaWRzYW5zZmFsbGJhY2s_shadow_50_text_Q1NETiBA56iL5bqP5ZGY5qyj5a64_size_20_color_FFFFFF_t_70_g_se_x_16]
 *  还可以实例化datetime对象：  
    ![在这里插入图片描述][watermark_type_ZHJvaWRzYW5zZmFsbGJhY2s_shadow_50_text_Q1NETiBA56iL5bqP5ZGY5qyj5a64_size_20_color_FFFFFF_t_70_g_se_x_16 1]
 *  datetime对象的年月日时分秒等字段：  
    ![在这里插入图片描述][watermark_type_ZHJvaWRzYW5zZmFsbGJhY2s_shadow_50_text_Q1NETiBA56iL5bqP5ZGY5qyj5a64_size_12_color_FFFFFF_t_70_g_se_x_16 1]
 *  转时间戳：  
    ![在这里插入图片描述][2e68a0dfa1dd4241a1721b4f34cf66ff.png]
 *  还可以通过strptime方法将指定格式的字符串转为datetime对象：  
    ![在这里插入图片描述][watermark_type_ZHJvaWRzYW5zZmFsbGJhY2s_shadow_50_text_Q1NETiBA56iL5bqP5ZGY5qyj5a64_size_20_color_FFFFFF_t_70_g_se_x_16 2]
 *  datetime对象转字符串也是常见操作，用的是strftime方法：  
    ![在这里插入图片描述][watermark_type_ZHJvaWRzYW5zZmFsbGJhY2s_shadow_50_text_Q1NETiBA56iL5bqP5ZGY5qyj5a64_size_20_color_FFFFFF_t_70_g_se_x_16 3]
 *  时间的计算，例如一天前，一小时后等操作，可以使用datetime包的timedelta类完成：  
    ![在这里插入图片描述][watermark_type_ZHJvaWRzYW5zZmFsbGJhY2s_shadow_50_text_Q1NETiBA56iL5bqP5ZGY5qyj5a64_size_20_color_FFFFFF_t_70_g_se_x_16 4]
 *  datetime对象可以用减法结算时间差：  
    ![在这里插入图片描述][1e978e6c4bd64b32af938093d6df84ad.png]
 *  减法特性在计算日期间隔的时候很有用：  
    ![在这里插入图片描述][watermark_type_ZHJvaWRzYW5zZmFsbGJhY2s_shadow_50_text_Q1NETiBA56iL5bqP5ZGY5qyj5a64_size_20_color_FFFFFF_t_70_g_se_x_16 5]

### JSON处理 ###

*  利用json进行对象和字符串之间的序列化、反序列化转换：  
    ![在这里插入图片描述][watermark_type_ZHJvaWRzYW5zZmFsbGJhY2s_shadow_50_text_Q1NETiBA56iL5bqP5ZGY5qyj5a64_size_20_color_FFFFFF_t_70_g_se_x_16 6]
 *  还可以用dump和load方法通过文件进行序列化反序列化操作

### 内置模块：random ###

*  生成随机数也是常见操作：  
    ![在这里插入图片描述][watermark_type_ZHJvaWRzYW5zZmFsbGJhY2s_shadow_50_text_Q1NETiBA56iL5bqP5ZGY5qyj5a64_size_20_color_FFFFFF_t_70_g_se_x_16 7]
 *  还可以产生整形随机数，设置内容范围和递增单位：  
    ![在这里插入图片描述][watermark_type_ZHJvaWRzYW5zZmFsbGJhY2s_shadow_50_text_Q1NETiBA56iL5bqP5ZGY5qyj5a64_size_20_color_FFFFFF_t_70_g_se_x_16 8]
 *  在一堆内容中做随机选择：  
    ![在这里插入图片描述][watermark_type_ZHJvaWRzYW5zZmFsbGJhY2s_shadow_50_text_Q1NETiBA56iL5bqP5ZGY5qyj5a64_size_19_color_FFFFFF_t_70_g_se_x_16 1]
 *  用choices方法（注意不是choice），可以随机选择指定数量的结果：  
    ![在这里插入图片描述][7c64b877e0f8425b924e531ab5994708.png]
 *  choices得到的结果可能重复，如果想不重复可以用sample方法：  
    ![在这里插入图片描述][81ac93fbd71a4660b1862e95b476ff72.png]
 *  将原有集合数据的顺序打乱，相当于洗牌的效果：  
    ![在这里插入图片描述][watermark_type_ZHJvaWRzYW5zZmFsbGJhY2s_shadow_50_text_Q1NETiBA56iL5bqP5ZGY5qyj5a64_size_16_color_FFFFFF_t_70_g_se_x_16 1]

### 函数 ###

*  基本函数语法：

def 函数名([参数列表]):
    	函数体

*  和Java不同的是，函数的入参类型并不固定：  
    ![在这里插入图片描述][watermark_type_ZHJvaWRzYW5zZmFsbGJhY2s_shadow_50_text_Q1NETiBA56iL5bqP5ZGY5qyj5a64_size_20_color_FFFFFF_t_70_g_se_x_16 9]
 *  使用关键字pass，可以定义一个空方法：

def test():
        pass

*  一个函数可以返回多个值（本质上是个元组），调用的时候用多个变量来接收即可：  
    ![在这里插入图片描述][watermark_type_ZHJvaWRzYW5zZmFsbGJhY2s_shadow_50_text_Q1NETiBA56iL5bqP5ZGY5qyj5a64_size_16_color_FFFFFF_t_70_g_se_x_16 2]
 *  还可以给函数增加说明文档，然后用help命令查看：  
    ![在这里插入图片描述][watermark_type_ZHJvaWRzYW5zZmFsbGJhY2s_shadow_50_text_Q1NETiBA56iL5bqP5ZGY5qyj5a64_size_20_color_FFFFFF_t_70_g_se_x_16 10]
 *  调用参数的时候可以用参数名=xxx的形式传入参数，此时参数参数的先后顺序可以随意，无所有谁先谁后：  
    ![在这里插入图片描述][watermark_type_ZHJvaWRzYW5zZmFsbGJhY2s_shadow_50_text_Q1NETiBA56iL5bqP5ZGY5qyj5a64_size_20_color_FFFFFF_t_70_g_se_x_16 11]
 *  可变参数和Java的方法也相似，先看一个星号的可变参数，可以理解为元组：  
    ![在这里插入图片描述][watermark_type_ZHJvaWRzYW5zZmFsbGJhY2s_shadow_50_text_Q1NETiBA56iL5bqP5ZGY5qyj5a64_size_20_color_FFFFFF_t_70_g_se_x_16 12]
 *  再看两个星号的可变参数，可以理解为字典：  
    ![在这里插入图片描述][watermark_type_ZHJvaWRzYW5zZmFsbGJhY2s_shadow_50_text_Q1NETiBA56iL5bqP5ZGY5qyj5a64_size_20_color_FFFFFF_t_70_g_se_x_16 13]
 *  对于固定参数的函数，还可以直接将字典作为入参，不过要加两个星号：  
    ![在这里插入图片描述][watermark_type_ZHJvaWRzYW5zZmFsbGJhY2s_shadow_50_text_Q1NETiBA56iL5bqP5ZGY5qyj5a64_size_20_color_FFFFFF_t_70_g_se_x_16 14]
 *  还可以设置默认参数：  
    ![在这里插入图片描述][watermark_type_ZHJvaWRzYW5zZmFsbGJhY2s_shadow_50_text_Q1NETiBA56iL5bqP5ZGY5qyj5a64_size_20_color_FFFFFF_t_70_g_se_x_16 15]

### lambda表达式 ###

*  java程序员对lambda表达式很熟悉，这里也差不多，来看看如何定义和使用：  
    ![在这里插入图片描述][watermark_type_ZHJvaWRzYW5zZmFsbGJhY2s_shadow_50_text_Q1NETiBA56iL5bqP5ZGY5qyj5a64_size_20_color_FFFFFF_t_70_g_se_x_16 16]
 *  再来看看几个支持lambda的内置函数，熟悉lambda的使用
 *  filter：过滤器，下面是个过滤奇偶数的例子，第一个参数是判断是否过滤的逻辑，True保留，第二个参数是列表，最终奇数全部被剔除，只留下偶数：  
    ![在这里插入图片描述][watermark_type_ZHJvaWRzYW5zZmFsbGJhY2s_shadow_50_text_Q1NETiBA56iL5bqP5ZGY5qyj5a64_size_20_color_FFFFFF_t_70_g_se_x_16 17]
 *  map：逐一转换，下面是将奇数转为False，偶数转为True的例子：  
    ![在这里插入图片描述][watermark_type_ZHJvaWRzYW5zZmFsbGJhY2s_shadow_50_text_Q1NETiBA56iL5bqP5ZGY5qyj5a64_size_20_color_FFFFFF_t_70_g_se_x_16 18]
 *  reduce：大名鼎鼎的map reduce，您应该有所耳闻，reduce会将集合中的数据逐个取出来和前面一轮的结果做同样的处理，最典型的当属累加：  
    ![在这里插入图片描述][watermark_type_ZHJvaWRzYW5zZmFsbGJhY2s_shadow_50_text_Q1NETiBA56iL5bqP5ZGY5qyj5a64_size_20_color_FFFFFF_t_70_g_se_x_16 19]
 *  sort：排序，先来看看最简单的：  
    ![在这里插入图片描述][911b4092721d4a99aa6f122a9128306c.png]
 *  sorted可以接受排序处理函数作为参数，例如按照绝对值进行排序，内置函数是abs，被作为参数传给sorted：  
    ![在这里插入图片描述][96cbaea1f62c44f2b4848f5b6075586c.png]
 *  sorted方法会生成一个新的列表，如果想直接改变原列表就不适合用sorted方法了，此时用列表的sort方法即可，如下图，还用了reverse参数试试倒排序的功能：  
    ![在这里插入图片描述][watermark_type_ZHJvaWRzYW5zZmFsbGJhY2s_shadow_50_text_Q1NETiBA56iL5bqP5ZGY5qyj5a64_size_20_color_FFFFFF_t_70_g_se_x_16 20]

### 面向对象 ###

*  身为Java程序员，天天和对象打交道，下面的代码您应该很容易看懂：  
    ![在这里插入图片描述][watermark_type_ZHJvaWRzYW5zZmFsbGJhY2s_shadow_50_text_Q1NETiBA56iL5bqP5ZGY5qyj5a64_size_20_color_FFFFFF_t_70_g_se_x_16 21]
 *  如果变量名是由两个下划线开始的，就表示改变量是私有成员变量，不能在外部访问：  
    ![在这里插入图片描述][watermark_type_ZHJvaWRzYW5zZmFsbGJhY2s_shadow_50_text_Q1NETiBA56iL5bqP5ZGY5qyj5a64_size_20_color_FFFFFF_t_70_g_se_x_16 22]
 *  与Java不同的是，创建对象不需要关键字new
 *  继承：

class 派生类名 (父类名):
    	语句...

*  下面是个继承的例子，Student是父类，Pupil是子类：

# 父类
    class Student:
        # 成员变量
        name = '未知'
        age = 11
        __addr= 'ShangHai'
    
        # 构造方法
        def __init__(self, name, age, addr):
            print('执行构造方法')
            self.name = name
            self.age = age
            self.__addr = addr
    
        def myInfo(self):
            print('学生姓名[{}]，年龄[{}，地址[{}]]'.format(self.name, self.age, self.__addr))
    
    class Pupil(Student):
        #成员变量
        grade = 1
    
        # 构造方法
        def __init__(self, name, age, addr, grade):
            # 显式调用父类构造方法
            Student.__init__(self, name, age, grade)
    
            print('执行构造方法（子类）')
            self.grade = grade
    
        # 子类自己的方法
        def myGrade(self):
            print('学生年级[{}]'.format(self.grade))

*  执行效果如下，符合预期：  
    ![在这里插入图片描述][watermark_type_ZHJvaWRzYW5zZmFsbGJhY2s_shadow_50_text_Q1NETiBA56iL5bqP5ZGY5qyj5a64_size_20_color_FFFFFF_t_70_g_se_x_16 23]

### 生成器 ###

*  先回顾一下列表推导，下面的代码会生成一个列表：

a = [x*2 for x in range(10)]

*  如果列表很大就会很占用内存空间，此时我们还有另一个选择：生成器，简单的说就是将上述代码的方括号改成圆括号，这样a就不是列表了，而是生成器，这是种特殊的迭代器：  
    ![在这里插入图片描述][watermark_type_ZHJvaWRzYW5zZmFsbGJhY2s_shadow_50_text_Q1NETiBA56iL5bqP5ZGY5qyj5a64_size_20_color_FFFFFF_t_70_g_se_x_16 24]

### 异常处理 ###

*  习惯了java的try-catch-finally，对python的异常处理就容易理解了，捕获和处理如下：

try:
        x = 1/0
        print('不可能打印这一句')
    except ZeroDivisionError as err:
        print('发生异常', err)
    finally:
        print('执行finally')

*  输出如下图：  
    ![在这里插入图片描述][watermark_type_ZHJvaWRzYW5zZmFsbGJhY2s_shadow_50_text_Q1NETiBA56iL5bqP5ZGY5qyj5a64_size_20_color_FFFFFF_t_70_g_se_x_16 25]
 *  关键字raise可以主动抛出异常：  
    ![在这里插入图片描述][watermark_type_ZHJvaWRzYW5zZmFsbGJhY2s_shadow_50_text_Q1NETiBA56iL5bqP5ZGY5qyj5a64_size_20_color_FFFFFF_t_70_g_se_x_16 26]
 *  以上就是欣宸在自学Python过程中的简化版笔记，希望能帮助您在初期抓住重点，快速入门；

### 你不孤单，欣宸原创一路相伴 ###

1.  [Java系列][Java]
2.  [Spring系列][Spring]
3.  [Docker系列][Docker]
4.  [kubernetes系列][kubernetes]
5.  [数据库+中间件系列][Link 1]
6.  [DevOps系列][DevOps]

[https_github.com_zq2599_blog_demos]: https://github.com/zq2599/blog_demos
[c41c48a72b8c43d2b599334e092aead4.png]: /images/20220828/324da4b18a1f4fa0b96e3b473ff38030.png
[ce323e0164b54151a74d829c47a23005.png]: /images/20220828/8e6179de1e6a4d5387931e22b92a8816.png
[4a9c7f695c4a49c7a9f74be8c1e8d1c6.png]: /images/20220828/53340406ef3b43d78dce2973ca443eb5.png
[d0d21815f47c445d93b2855cf6bfdfd3.png]: /images/20220828/95a0976859fa49ec886b6e3a79057e78.png
[6ca9a1edf82d4bb2a4a936d5bae81fee.png]: /images/20220828/f857fb7a0c4c454fbbff62edb5981f5d.png
[16113f963ce949f687e0bce1bbafd8a7.png]: /images/20220828/92318c9ba196443caf940000cecb9057.png
[9e6d74d1a0084baaa26da0c16cdab09d.png]: /images/20220828/5f7f4b6f076b48dd89fa49d88c281680.png
[0c0a47befeaf44edbee8fe3496d0234f.png]: /images/20220828/8c20b73347a941e1a03a53ec82957a0c.png
[ce895b3a0ea94eabbee64b83d9edbaf6.png]: /images/20220828/590baf5a7b9347e2a45b5a978f352649.png
[2f93c49a37d8461c9fa6994750fe8052.png]: /images/20220828/4f7935c5edd1492da14f017fe3249fba.png
[0864fddc37eb456c8c4061340b060816.png]: /images/20220828/02520eeac86c43c7b4340e4653b24456.png
[13649221a62f4300a001e7b4d4ff5aa6.png]: /images/20220828/49d34612a9ff4afbb0c4deadf5ae04c3.png
[79a90822831742c6bcc7b96041febfe5.png]: /images/20220828/4ebb1c6dd1c0472f96319759745c96cc.png
[758d7543e4ae4c1f8f73e26ac97c5122.png]: /images/20220828/5bd141aadba242e1934156236b092d23.png
[469f8c3b3c904a42973bd3968afd0e3d.png]: /images/20220828/54e4266d94864d0fab09458b41e1fabd.png
[23d216a2c4ab458d809787a7e22fded0.png]: /images/20220828/248f4377a7944b6495be9e69ca31ca95.png
[e599259a6670436a9be5d8696b1e76b5.png]: /images/20220828/a3023a768e0141f58a505fe82235328a.png
[59bf5d25fde944d6831df1f78ac11eb2.png]: /images/20220828/4a69a6153cde417e9236f12d0538dc05.png
[76c72dfca53143d9b980f8f89fbd7713.png]: /images/20220828/35df7b13ed1e4dd5935126054fdbcba9.png
[445e976cb9cd481199a2139d22618bb6.png]: /images/20220828/d1b4106665b541d3833436a6f9521b2f.png
[watermark_type_ZHJvaWRzYW5zZmFsbGJhY2s_shadow_50_text_Q1NETiBA56iL5bqP5ZGY5qyj5a64_size_11_color_FFFFFF_t_70_g_se_x_16]: /images/20220828/627ded99cd5840adbce8ce6cbfc0c70b.png
[0412f8a106714f56921f3e0586a695b5.png]: /images/20220828/df022270274145e6a4aaa8b31313fc1c.png
[watermark_type_ZHJvaWRzYW5zZmFsbGJhY2s_shadow_50_text_Q1NETiBA56iL5bqP5ZGY5qyj5a64_size_10_color_FFFFFF_t_70_g_se_x_16]: /images/20220828/a97e8682b2314c0498a0c0bb2a6f7558.png
[fcdedc1e89e34cddbfcffccd8596b66d.png]: /images/20220828/ee2eca9d7ec64ecdbbdc5d54c2dece4c.png
[8534bdb3f00445019b80a47142fb2440.png]: /images/20220828/82b7250ca79b4774bdd785e6323f063b.png
[65a18c9f4d4b465aa3e37f271220705b.png]: /images/20220828/1b18569177a3459cb335ac7d03f65524.png
[793c6bc5e3574c5f803a7c3b25b6bf1a.png]: /images/20220828/12938e9def5340ea81ba0473faa322cd.png
[7c91955929ff459d91ee2f273aeebccf.png]: /images/20220828/ff41e55c719d450bb0de1112385c701d.png
[ea06640da31e4c6d929dc44c04be5e28.png]: /images/20220828/6408d0a9afb34bcabbc11ea9fa854f31.png
[watermark_type_ZHJvaWRzYW5zZmFsbGJhY2s_shadow_50_text_Q1NETiBA56iL5bqP5ZGY5qyj5a64_size_9_color_FFFFFF_t_70_g_se_x_16]: /images/20220828/282f109828be4f8b8434eb4eb84787d8.png
[watermark_type_ZHJvaWRzYW5zZmFsbGJhY2s_shadow_50_text_Q1NETiBA56iL5bqP5ZGY5qyj5a64_size_12_color_FFFFFF_t_70_g_se_x_16]: /images/20220828/ce41db5642de4ef1a4f0e592d1a68c3a.png
[b749da6e8cf447bb92a0131fbdf56bf8.png]: /images/20220828/f368a2be7f2b4220b62cf6be3426c78c.png
[5de21fbbf5524e9eb21e9b853c633d12.png]: /images/20220828/3028fb6e65f2497d9079a3b376e767ba.png
[04452c4a1ca944c28916f520c8eff8a6.png]: /images/20220828/9df7d808831c4a4d9ba61965959bc2c7.png
[e47bb7731be240979ddf861c96da323f.png]: /images/20220828/7ab470721c8246d9a485a9d54b759629.png
[watermark_type_ZHJvaWRzYW5zZmFsbGJhY2s_shadow_50_text_Q1NETiBA56iL5bqP5ZGY5qyj5a64_size_18_color_FFFFFF_t_70_g_se_x_16]: /images/20220828/7719f80bd4f944d3ac7cee4b20a65e3a.png
[b2ea3e7c02134fcfaaf5a08183122f54.png]: /images/20220828/12ef87efe4634c1cbc1f8acc1f7a6771.png
[b87f46b27ac3469183c03a35c38d9b4a.png]: /images/20220828/ce258203fc15447fa60e622fdac4fe9f.png
[66409f0295ff4a5ca10c195f7e3df26b.png]: /images/20220828/c57f8092f79e4dc592f81112d3162c93.png
[798244906bec48daaeb5da1554e2a7c5.png]: /images/20220828/61e2ee02e24b4ceda8961b691c2cd47c.png
[098cd060cd87426fb7aaa24c0bf6a46b.png]: /images/20220828/da574d8e054d4689a2a3cd03d661ba4e.png
[43de5790e1804b538ce02a7470fb8627.png]: /images/20220828/df3d5f6946e64650b788d12d5b4afc98.png
[1619b050d33a45eb97b808f8271e0720.png]: /images/20220828/16712ee2e91f49f386f41afde6ef99c9.png
[5bf4f4a1d7294d5ba67e80561ae5f04f.png]: /images/20220828/df086c68929c47cdb17398a7d0200463.png
[f86ab2ccb6d4406b99b9e963b2e2bd3a.png]: /images/20220828/aa7234ec6b9a4b3085d949864075aef2.png
[7004da6764a74fb28620ecc393448969.png]: /images/20220828/0ac2a6ead51a41fd91a97bc290aa5058.png
[7622104c5a5b408891679da510c0401a.png]: /images/20220828/f0822d0e8b9d45f28de537e493b555ad.png
[3203ab6ad1d1498ba37a2cc9a7763443.png]: /images/20220828/9d538e7fffae4f9ebfccf9daf4358716.png
[watermark_type_ZHJvaWRzYW5zZmFsbGJhY2s_shadow_50_text_Q1NETiBA56iL5bqP5ZGY5qyj5a64_size_19_color_FFFFFF_t_70_g_se_x_16]: /images/20220828/37460057c02b44f5995cb388befbfd04.png
[79ebe35d58054a87a88a350883ade8e8.png]: /images/20220828/558f451aacc347899741984cdb027e57.png
[watermark_type_ZHJvaWRzYW5zZmFsbGJhY2s_shadow_50_text_Q1NETiBA56iL5bqP5ZGY5qyj5a64_size_16_color_FFFFFF_t_70_g_se_x_16]: /images/20220828/f0503b66341f42fb92878b7100b0ea44.png
[e3494ef2cc95426f84f8482a690da107.png]: /images/20220828/a7847acb893b415fa6082d973cdc2020.png
[878b11c252f549f6b63c174b8244a7c7.png]: /images/20220828/3d35eeb8b581466e9f1916f67b5f3a92.png
[f162e17cc394450aa9bb1a070156607d.png]: /images/20220828/bcbf94bf3d754393ab68980d4e0ae85a.png
[b0759f9720fc4462b82a31edcf838ceb.png]: /images/20220828/4e9e4a7e62ab46ff9031ed76d0643cb7.png
[74d9718ab2744c549e83baed7aa2858e.png]: /images/20220828/c16c21c2a5214196a544bfb9e2529d2b.png
[7e5709863c1b4b2ca0b31a9612eb8ac4.png]: /images/20220828/e22b55a510dd491da2b98dbb33e0bd0f.png
[0c219ff4a56544e59918dbeabf66ce2e.png]: /images/20220828/aac6ff0ba9fc4c73889569ba7aa48822.png
[87920e09d88d43598d069a3b4ee05923.png]: /images/20220828/4e01010c5d5d4f15bbc7b1e7ba32fbf7.png
[27fa7cbdb05e46abb17d3c6c24e5a1c2.png]: /images/20220828/77ff6c2eb15e40a29c9c19e50d2b4524.png
[0a36369a418441b0b73628774d69e1cb.png]: /images/20220828/2d43663b5190409d8d0f48e37002b387.png
[94ff196e108e47ffb864d51e60256a4d.png]: /images/20220828/ee7e12aeacf744c99ba2624ce64a45e2.png
[e16ba8309c8f490cbd61a9b17b76f45c.png]: /images/20220828/572d590b209b4394aba36ed1a1cb44e6.png
[f7e27bd16383460fb7c3f9289be4d551.png]: /images/20220828/f9f3e9d9864c460e85d76c9e1f9d0dec.png
[4369539c8d72443294d5216bf569a4aa.png]: /images/20220828/d3d2176439234ad193b3650401f5bd9b.png
[213a72a704aa4f5daf5cd4eca7ac0817.png]: /images/20220828/c8d0f09ec59848cb890595a63bde2ecc.png
[0b56c0f561b74383b8411aa39fd9c226.png]: /images/20220828/17c63685ebbb4a7b8c941638856efacb.png
[watermark_type_ZHJvaWRzYW5zZmFsbGJhY2s_shadow_50_text_Q1NETiBA56iL5bqP5ZGY5qyj5a64_size_17_color_FFFFFF_t_70_g_se_x_16]: /images/20220828/71d110fbc8b947858882bd39c649d15a.png
[watermark_type_ZHJvaWRzYW5zZmFsbGJhY2s_shadow_50_text_Q1NETiBA56iL5bqP5ZGY5qyj5a64_size_20_color_FFFFFF_t_70_g_se_x_16]: /images/20220828/06100f36e8ab4d6bb04f7a5bf5f3554c.png
[watermark_type_ZHJvaWRzYW5zZmFsbGJhY2s_shadow_50_text_Q1NETiBA56iL5bqP5ZGY5qyj5a64_size_20_color_FFFFFF_t_70_g_se_x_16 1]: /images/20220828/d60aec99dd3f48adba29b390dcb9b806.png
[watermark_type_ZHJvaWRzYW5zZmFsbGJhY2s_shadow_50_text_Q1NETiBA56iL5bqP5ZGY5qyj5a64_size_12_color_FFFFFF_t_70_g_se_x_16 1]: /images/20220828/df3f781fe2624e699b27d10a723cfc41.png
[2e68a0dfa1dd4241a1721b4f34cf66ff.png]: /images/20220828/2aebf8a98979432793bc3f6a3c2b3470.png
[watermark_type_ZHJvaWRzYW5zZmFsbGJhY2s_shadow_50_text_Q1NETiBA56iL5bqP5ZGY5qyj5a64_size_20_color_FFFFFF_t_70_g_se_x_16 2]: /images/20220828/45f384de2fd6408b825ab3d77e2f2d26.png
[watermark_type_ZHJvaWRzYW5zZmFsbGJhY2s_shadow_50_text_Q1NETiBA56iL5bqP5ZGY5qyj5a64_size_20_color_FFFFFF_t_70_g_se_x_16 3]: /images/20220828/931414fdac66498f9a616f9e435db161.png
[watermark_type_ZHJvaWRzYW5zZmFsbGJhY2s_shadow_50_text_Q1NETiBA56iL5bqP5ZGY5qyj5a64_size_20_color_FFFFFF_t_70_g_se_x_16 4]: /images/20220828/59a397b2d2524a6694b2eb3342d9983a.png
[1e978e6c4bd64b32af938093d6df84ad.png]: /images/20220828/731db52aa81d4672913108cc9327cc84.png
[watermark_type_ZHJvaWRzYW5zZmFsbGJhY2s_shadow_50_text_Q1NETiBA56iL5bqP5ZGY5qyj5a64_size_20_color_FFFFFF_t_70_g_se_x_16 5]: /images/20220828/7a230125dff743999ec5ccf3654b0d43.png
[watermark_type_ZHJvaWRzYW5zZmFsbGJhY2s_shadow_50_text_Q1NETiBA56iL5bqP5ZGY5qyj5a64_size_20_color_FFFFFF_t_70_g_se_x_16 6]: /images/20220828/a018f1cf41d6410bb50ba595e47951cb.png
[watermark_type_ZHJvaWRzYW5zZmFsbGJhY2s_shadow_50_text_Q1NETiBA56iL5bqP5ZGY5qyj5a64_size_20_color_FFFFFF_t_70_g_se_x_16 7]: /images/20220828/570c02c16d5148f8ade86808e8cf9a78.png
[watermark_type_ZHJvaWRzYW5zZmFsbGJhY2s_shadow_50_text_Q1NETiBA56iL5bqP5ZGY5qyj5a64_size_20_color_FFFFFF_t_70_g_se_x_16 8]: /images/20220828/34d543ecf42340fd9e43dd0d07323109.png
[watermark_type_ZHJvaWRzYW5zZmFsbGJhY2s_shadow_50_text_Q1NETiBA56iL5bqP5ZGY5qyj5a64_size_19_color_FFFFFF_t_70_g_se_x_16 1]: /images/20220828/6f5da8dfa6c64ef9b0e2d1809ac6a0f6.png
[7c64b877e0f8425b924e531ab5994708.png]: /images/20220828/b7f0a6979a5643e29c395a1c406b962d.png
[81ac93fbd71a4660b1862e95b476ff72.png]: /images/20220828/1def5e25ec00436898a284d6e632779a.png
[watermark_type_ZHJvaWRzYW5zZmFsbGJhY2s_shadow_50_text_Q1NETiBA56iL5bqP5ZGY5qyj5a64_size_16_color_FFFFFF_t_70_g_se_x_16 1]: /images/20220828/48a5756b91fc440b8fddbf8eb52175db.png
[watermark_type_ZHJvaWRzYW5zZmFsbGJhY2s_shadow_50_text_Q1NETiBA56iL5bqP5ZGY5qyj5a64_size_20_color_FFFFFF_t_70_g_se_x_16 9]: /images/20220828/4767e5c196e6481ba44233ff2b99abcc.png
[watermark_type_ZHJvaWRzYW5zZmFsbGJhY2s_shadow_50_text_Q1NETiBA56iL5bqP5ZGY5qyj5a64_size_16_color_FFFFFF_t_70_g_se_x_16 2]: /images/20220828/7d6c43e1ca3746f58de5f97f42ec9e64.png
[watermark_type_ZHJvaWRzYW5zZmFsbGJhY2s_shadow_50_text_Q1NETiBA56iL5bqP5ZGY5qyj5a64_size_20_color_FFFFFF_t_70_g_se_x_16 10]: /images/20220828/497358b0055c4d4aaec696da91c8946f.png
[watermark_type_ZHJvaWRzYW5zZmFsbGJhY2s_shadow_50_text_Q1NETiBA56iL5bqP5ZGY5qyj5a64_size_20_color_FFFFFF_t_70_g_se_x_16 11]: /images/20220828/7720b9064da344b3a3b2c5df3094bbbd.png
[watermark_type_ZHJvaWRzYW5zZmFsbGJhY2s_shadow_50_text_Q1NETiBA56iL5bqP5ZGY5qyj5a64_size_20_color_FFFFFF_t_70_g_se_x_16 12]: /images/20220828/c5e2c4f4c7b54c6ba8a1d518c1ec5616.png
[watermark_type_ZHJvaWRzYW5zZmFsbGJhY2s_shadow_50_text_Q1NETiBA56iL5bqP5ZGY5qyj5a64_size_20_color_FFFFFF_t_70_g_se_x_16 13]: /images/20220828/10f981a7f41b4b71b558b3db1b05c202.png
[watermark_type_ZHJvaWRzYW5zZmFsbGJhY2s_shadow_50_text_Q1NETiBA56iL5bqP5ZGY5qyj5a64_size_20_color_FFFFFF_t_70_g_se_x_16 14]: /images/20220828/a0608e1432aa4276826aceeb8ed16883.png
[watermark_type_ZHJvaWRzYW5zZmFsbGJhY2s_shadow_50_text_Q1NETiBA56iL5bqP5ZGY5qyj5a64_size_20_color_FFFFFF_t_70_g_se_x_16 15]: /images/20220828/0a2663480b734cf68c476c156b8f9ea8.png
[watermark_type_ZHJvaWRzYW5zZmFsbGJhY2s_shadow_50_text_Q1NETiBA56iL5bqP5ZGY5qyj5a64_size_20_color_FFFFFF_t_70_g_se_x_16 16]: /images/20220828/347e69ae50e6498f8ebebd519ac6391a.png
[watermark_type_ZHJvaWRzYW5zZmFsbGJhY2s_shadow_50_text_Q1NETiBA56iL5bqP5ZGY5qyj5a64_size_20_color_FFFFFF_t_70_g_se_x_16 17]: /images/20220828/fbe96cfcc3ea43d3934f2700be4a2662.png
[watermark_type_ZHJvaWRzYW5zZmFsbGJhY2s_shadow_50_text_Q1NETiBA56iL5bqP5ZGY5qyj5a64_size_20_color_FFFFFF_t_70_g_se_x_16 18]: /images/20220828/95a4646c27b54d97981ceea7416405ca.png
[watermark_type_ZHJvaWRzYW5zZmFsbGJhY2s_shadow_50_text_Q1NETiBA56iL5bqP5ZGY5qyj5a64_size_20_color_FFFFFF_t_70_g_se_x_16 19]: /images/20220828/e997693a124049e5bbabeef81da3fff3.png
[911b4092721d4a99aa6f122a9128306c.png]: /images/20220828/80839edd99ef4ccfaf463ed6e5ef9b54.png
[96cbaea1f62c44f2b4848f5b6075586c.png]: /images/20220828/d74c4bd623224939904e518937c34a46.png
[watermark_type_ZHJvaWRzYW5zZmFsbGJhY2s_shadow_50_text_Q1NETiBA56iL5bqP5ZGY5qyj5a64_size_20_color_FFFFFF_t_70_g_se_x_16 20]: /images/20220828/d79f974da19148b68d91e1a317e4b788.png
[watermark_type_ZHJvaWRzYW5zZmFsbGJhY2s_shadow_50_text_Q1NETiBA56iL5bqP5ZGY5qyj5a64_size_20_color_FFFFFF_t_70_g_se_x_16 21]: /images/20220828/cef17d969b90441d86c64da7adac2821.png
[watermark_type_ZHJvaWRzYW5zZmFsbGJhY2s_shadow_50_text_Q1NETiBA56iL5bqP5ZGY5qyj5a64_size_20_color_FFFFFF_t_70_g_se_x_16 22]: /images/20220828/2429297065214a97b39ebcbe4a295c32.png
[watermark_type_ZHJvaWRzYW5zZmFsbGJhY2s_shadow_50_text_Q1NETiBA56iL5bqP5ZGY5qyj5a64_size_20_color_FFFFFF_t_70_g_se_x_16 23]: /images/20220828/62e7e105e0a14bc09d64ac4dfc43d64f.png
[watermark_type_ZHJvaWRzYW5zZmFsbGJhY2s_shadow_50_text_Q1NETiBA56iL5bqP5ZGY5qyj5a64_size_20_color_FFFFFF_t_70_g_se_x_16 24]: /images/20220828/3ee4e3b6dafa47d692627f5dd1db1c23.png
[watermark_type_ZHJvaWRzYW5zZmFsbGJhY2s_shadow_50_text_Q1NETiBA56iL5bqP5ZGY5qyj5a64_size_20_color_FFFFFF_t_70_g_se_x_16 25]: /images/20220828/71f3c9ed587d485499b43356b8704ac3.png
[watermark_type_ZHJvaWRzYW5zZmFsbGJhY2s_shadow_50_text_Q1NETiBA56iL5bqP5ZGY5qyj5a64_size_20_color_FFFFFF_t_70_g_se_x_16 26]: /images/20220828/265ed2d9a14840f0ab3d187127d908ed.png
[Java]: https://xinchen.blog.csdn.net/article/details/105068742
[Spring]: https://xinchen.blog.csdn.net/article/details/105086498
[Docker]: https://xinchen.blog.csdn.net/article/details/105086732
[kubernetes]: https://xinchen.blog.csdn.net/article/details/105086794
[Link 1]: https://xinchen.blog.csdn.net/article/details/105086850
[DevOps]: https://xinchen.blog.csdn.net/article/details/105086920