📝 更新.gitignore文件，新增table.py忽略项；更新Python文档，优化JSON模块内容和正则表达式部分，提升文档的可读性和准确性。

Author: jiangyangcreate

.gitignore

@@ -14,6 +14,7 @@
 .env.development.local
 .env.test.local
 .env.production.local
+table.py
 
 npm-debug.log*
 yarn-debug.log*

docs/docs/选择编程语言/Python/Python内置模块/数据处理.mdx

@@ -5,15 +5,13 @@ json 模块提供了 python->json 以及 json->python 两种格式，转换规
 
 | JSON ->        | Python -> | JSON           |
 | -------------- | --------- | -------------- |
-| object -- 对象 | dict      | object -- 对象 |
+| object -- 对象  | dict      | object -- 对象 |
 | array          | list      | array          |
 | string         | str       | string         |
 | number (int)   | int       | number         |
 | number (real)  | float     | number         |
-| TRUE           | true      |                |
-| FALSE          | false     |                |
-|                | TRUE      | true           |
-|                | FALSE     | false          |
+| true           | True      | true           |
+| false          | False     | false          |
 | null           | None      | null           |
 |                | tuple     | array          |
 
@@ -26,7 +24,7 @@ json 模块还有一些其他参数可以控制：编码形式、格式化输出
 
 ### json.load 与 json.dump
 
-json.load 与 json.dump 是基于文件的转换
+json.load 与 json.dump 是基于文件的转换。
 
 ```python showLineNumbers
 import json
@@ -54,7 +52,7 @@ with open("data_file.json", "r") as read_content:
 
 ### json.loads 与 json.dumps
 
-json.load 与 json.dump 是直接基于数据的转换
+`json.loads` 与 `json.dumps` 是直接基于数据的转换，这里的`s`表示`string`(字符串)。
 
 ```python showLineNumbers
 import json
@@ -87,63 +85,59 @@ print(type(res_j)) # <class 'str'>
 
 ## 概括字符集
 
-## \\d：表示该位置上的字符是数字，即匹配成功
+### \\d：表示该位置上的字符是数字，即匹配成功
 - 等价于[0-9]
-## \\D：表示该位置上的字符不是数字，即匹配成功
+### \\D：表示该位置上的字符不是数字，即匹配成功
 - 等价于[^0-9]
-## \\w：表示该位置上的字符是字母或，即匹配成功
-- 等价于[A-Za-z ]
-## \\W：表示该位置上的字符不是是字母或_，即匹配成功
-- 等价于[^A-Za-z_]
-## \\s：表示该位置上是不可见字符(空格、制表符\\t、垂直制表符\\v、回车符\\r、换行符\\n、换页符\\f)，即匹配成功
+### \\w：使用(flags=re.ASCII)表示该位置上的字符是_或字母、数字，即匹配成功
+- 等价于[a-zA-Z0-9_]
+### \\W：使用(flags=re.ASCII)表示该位置上的字符不是_或字母、数字，即匹配成功
+- 等价于[^a-zA-Z0-9_]
+### \\s：表示该位置上是不可见字符(空格、制表符\\t、垂直制表符\\v、回车符\\r、换行符\\n、换页符\\f)，即匹配成功
 - 等价于[\\n\\t\\r\\f\\v]
-## \\S：表示该位置上不是不可见字符，即匹配成功
+### \\S：表示该位置上不是不可见字符，即匹配成功
 
 ## 数量词
 
-## {3}：表示前面的一个字符出现3次
-## {3,8}：表示前面的一个字符出现3-8次
-## ?：表示前面的一个字符出现0次或1次
-## +：表示前面的一个字符出现1次或无限多次
-## *：表示前面的一个字符出现0次或无限多次
+### {3}：表示前面的一个字符出现3次
+### {3,8}：表示前面的一个字符出现3-8次
+### ?：表示前面的一个字符出现0次或1次
+### +：表示前面的一个字符出现1次或无限多次
+### *：表示前面的一个字符出现0次或无限多次
 
 ## 边界匹配符
 
-## ^：表示只要是以后面的字符开头的，即匹配成功
-## $：表示只要是以前面的字符结尾的，即匹配成功
-## .：表示一个除换行符\n以外的所有字符
-## \\b：匹配一个单词边界，也就是指单词和空格间的位置。例如，'er\b' 可以匹配"never"中的'er'，但不能匹配"verb" 中的'er'。
-## \\B：匹配非单词边界。'er\B'能匹配"verb"中的er'，但不能匹配"never" 中的'er'。
+### ^：表示只要是以后面的字符开头的，即匹配成功
+### $：表示只要是以前面的字符结尾的，即匹配成功
+### .：表示一个除换行符\n以外的所有字符
+### \\b：匹配一个单词边界，也就是指单词和空格间的位置。例如，'er\b' 可以匹配"never"中的'er'，但不能匹配"verb" 中的'er'。
+### \\B：匹配非单词边界。'er\B'能匹配"verb"中的er'，但不能匹配"never" 中的'er'。
 
 ## 元字符
 
-## [a-z]：表示该位置上的字符在a-z之间，即匹配成功
-## [^a-z]：表示该位置上的字符不在a-z之间，即匹配成功
-## [abf]：表示该位置上的字符为a或者b或者f，即匹配成功
+### [a-z]：表示该位置上的字符在a-z之间，即匹配成功
+### [^a-z]：表示该位置上的字符不在a-z之间，即匹配成功
+### [abf]：表示该位置上的字符为a或者b或者f，即匹配成功
 - result = re.findall('a[de]c', target)
 
 ## 修饰符
 
-## re.I：使匹配对大小写不敏感
-## re.L：做本地化识别(locale-aware)匹配
-## re.M：多行匹配，影响 ^和$
-## re.S：使.匹配包括换行在内的所有字符
-## re.U：根据Unicode字符集解析字符。这个标志影响\w, \W, \b, \B.
-## re.X：该标志通过给予你更灵活的格式以便你将正则表达式写得更易于理解。
+### re.I：使匹配对大小写不敏感
+### re.L：做本地化识别(locale-aware)匹配
+### re.M：多行匹配，影响 ^和$
+### re.S：使.匹配包括换行在内的所有字符
+### re.U：根据Unicode字符集解析字符。这个标志影响\w, \W, \b, \B.
+### re.X：该标志通过给予你更灵活的格式以便你将正则表达式写得更易于理解。
 
-## 匹配所有
+## 匹配
 
-## findall
+### re.findall(pattern, string, flags=0)
 
 - 如果匹配到就返回一个列表，没有匹配到就返回空列表。
 
-## finditer
+### re.finditer(pattern, string, flags=0)
 
-- 和 findal 类似，在字符串中找到正则表达式所匹配的所有子串，并把它们作为一个迭代器返回。
-
-## 匹配一次
-
-## match
+- 和 findall 类似，在字符串中找到正则表达式所匹配的所有子串，并把它们作为一个迭代器返回。
 
 ### re.match(pattern, string, flags=0)
 
@@ -152,37 +146,31 @@ print(type(res_j)) # <class 'str'>
 - flags: 标志位，用于控制正则表达式的匹配方式，如是否区分大小写，多行匹配等等。参见:正则表达式修饰符中可选标志
 - re.match只匹配字符串的开始，如果字符串开始不符合正则表达式，则匹配失败，函数返回None
 
-## search
-
-### re.search(pattern, string, flags=0)
-- pattern: 匹配的正则表达式
-- string: 要匹配的字符串
-- flags: 标志位，用于控制正则表达式的匹配方式，如是否区分大小写，多行匹配等等。参见:正则表达式修饰符中可选标志
-- re.search匹配整个字符串，直到找到一个匹配。
 
 ## 组
 
-## (\\d+)
+### (\\d+)
 
 - ()内的内容构成一个组，只要当前位置满足\d+就匹配成功，返回()内匹配成功的内容
 
-## group(num=0)
+### group(num=0)
 
 - 匹配的整个表达式的字符串，group() 可以一次输入多个组号，在这种情况下它将返回一个包含那些组所对应值的元组。
 
-## group()
+### group()
 
 - 返回一个包含所有小组字符串的元组，从1到 所含的小组号。
 
-## 序列
-
-## str.span()
-
-- #返回匹配值的下标,左闭右开
 
 ## 检索和替换
 
-## re.sub(pattern, repl, string, count=0, flags=0)
+### re.search(pattern, string, flags=0)
+- pattern: 匹配的正则表达式
+- string: 要匹配的字符串
+- flags: 标志位，用于控制正则表达式的匹配方式，如是否区分大小写，多行匹配等等。参见:正则表达式修饰符中可选标志
+- re.search匹配整个字符串，直到找到一个匹配。
+
+### re.sub(pattern, repl, string, count=0, flags=0)
 
 - pattern: 正则中的模式字符串。
 - repl: 替换的字符串，也可为一个函数。
@@ -191,14 +179,14 @@ print(type(res_j)) # <class 'str'>
 
 ## 编译正则表达式
 
-## re.compile(pattern[, flags])
+### re.compile(pattern[, flags])
 - pattern: 一个字符串形式的正则表达式
 - flags: 可选，表示匹配模式，比如忽略大小写，多行模式等，具体参数为：re.I, re.M
 - compile 函数用于编译正则表达式，生成一个正则表达式(Pattern)对象，供match()和 search() 这两个函数使用。
 
 ## 正则分割
 
-## re.split(pattern, string[, maxsplit=0, flags=0])
+### re.split(pattern, string[, maxsplit=0, flags=0])
 
 - pattern: 正则中的模式字符串。
 - string: 要匹配的字符串。
@@ -207,9 +195,9 @@ print(type(res_j)) # <class 'str'>
 
 ## 贪婪和非贪婪
 
-## 贪婪模式就是尽可能多地去匹配字符
+### 贪婪模式就是尽可能多地去匹配字符
 
-## 非贪婪模式就是尽可能少地去匹配字符，python默认采取的是贪婪模式。
+### 非贪婪模式就是尽可能少地去匹配字符，python默认采取的是贪婪模式。
 
 `} />
 
@@ -285,20 +273,26 @@ print(re.sub('(?P<value>\d+)', double, s))
 #贪婪与非贪婪
 content = '发布于2018/12/23'
 result = re.findall('.*?(\d.*\d)', content)
-# 这里的?表示的就是非贪婪模式，第一个.*会尽可能少地去匹配内容，因为后面跟的是\d，所以碰见第一个数字就终止了。
-print(result)
+"""
+这里的?表示的就是非贪婪模式，第一个.*会尽可能少地去匹配内容
+因为后面跟的是\d，所以碰见第一个数字就终止了。
+"""
+print(result) # ['2018/12/23']
 
 result = re.findall('.*(\d.*\d)', content)
-# 这里的第一个.*后面没有添加问号，表示的就是贪婪模式，第一个.*会尽可能多地去匹配
-#内容，后面跟的是\d，碰见第一个数字并不一定会终止，当它匹配到2018的2的时候，发现剩#下的内容依然满足(\d.*\d)，所以会一直匹配下去，直到匹配到12后面的/的时候，发现剩下
-#的23依然满足(\d.*\d)，但是如果再匹配下去，匹配到23的2的话，剩下的3就不满足
-#(\d.*\d)了，所以第一个.*就会停止匹配，(\d.*\d)最终匹配到的结果就只剩下23了。
-print(result)
+"""
+这里的第一个.*后面没有添加问号，表示的就是贪婪模式，第一个.*会尽可能多地去匹配内容
+后面跟的是\d，碰见第一个数字并不一定会终止，当它匹配到2018的2的时候，发现剩#下的内容依然满足(\d.*\d)，所以会一直匹配下去
+直到匹配到12后面的/的时候，发现剩下的23依然满足(\d.*\d)，但是如果再匹配下去，匹配到23的2的话，剩下的3就不满足(\d.*\d)了
+所以第一个.*就会停止匹配，(\d.*\d)最终匹配到的结果就只剩下23了。
+"""
+print(result) # ['23']
 
 result = re.findall('.*?(\d.*?\d)', content)
-# 这里的第一个.*?表示非贪婪模式(非贪婪模式就是尽可能少地去匹配字符)，匹配到2018前面的'于'之后就停止了
-# 括号里的.*?也是表示非贪婪模式，括号里的内容从2018的2开始匹配，因为后面一个数字
-#是0，那么也就满足了(\d.*?\d)，所以就直接返回结果了，同样的，接下来的18也是这样，一
-#直匹配到23才结束
-print(result)
+"""
+这里的第一个.*?表示非贪婪模式(非贪婪模式就是尽可能少地去匹配字符)，匹配到2018前面的'于'之后就停止了
+括号里的.*?也是表示非贪婪模式，括号里的内容从2018的2开始匹配，因为后面一个数字是0，那么也就满足了(\d.*?\d)
+所以就直接返回结果了，同样的，接下来的18也是这样，一直匹配到23才结束
+"""
+print(result) # ['20', '18', '12', '23']
 ```

docs/docs/选择编程语言/Python/Python内置模块/网络与通信/index.mdx

@@ -0,0 +1,46 @@
+---
+sidebar_position: 100
+title: 网络与通信
+---
+
+
+## IP地址
+
+IP地址是计算机在网络中的唯一标识，由32位二进制数组成，分为IPv4和IPv6两种。
+
+IPv4地址可被写作任何表示一个32位整数值的形式，但为了方便人类阅读和分析，它通常被写作点分十进制的形式，即四个字节被分开用十进制写出，中间用点分隔。
+
+即由4个字节组成，每个字节用点分隔，例如`192.168.1.1`。
+
+每个段都是0-255之间的整数。（2的8次方减1，占8位），合计4段，共32位二进制。
+
+- IPv6地址<Highlight>通常被写作冒号分隔的形式</Highlight>，即由8个16位十六进制数组成，每个数用冒号分隔，例如`2001:0db8:85a3:0000:0000:8a2e:0370:7334`。
+
+:::info
+原则上每个设备只要连上公网，就必须有一个IP地址，这个IP地址是唯一的，不能重复。
+
+但是目前世界上IP地址已经不够用了，所以如果需要遵循这个原则，则需使用IPv6地址。
+
+如果不遵循这个原则可以在你的家里设置一个路由器，这个路由器可以上网，家里所有的设备把想和公网交换的数据发给这个路由器，然后这个路由再转发给公网。这个方案被称之为NAT(Network Address Translation)
+:::
+
+### IPV4地址分类
+
+
+
+### 特殊的IPV4地址
+
+这部分地址主要用于内部网络，比如你的家庭网络，公司网络，学校网络等。
+
+| 名字      | 地址范围                     | 地址数量    | 有类别的描述         | 最大的CIDR地址块    |
+|----------|-----------------------------|------------|---------------------|---------------------|
+| 24位块   | 10.0.0.0–10.255.255.255     | 16,777,216 | 一个A类             | 10.0.0.0/8         |
+| 20位块   | 172.16.0.0–172.31.255.255   | 1,048,576  | 连续的16个B类       | 172.16.0.0/12      |
+| 16位块   | 192.168.0.0–192.168.255.255 | 65,536     | 连续的256个C类      | 192.168.0.0/16     |
+
+
+回环地址: `127.0.0.1` ~ `127.255.255.255` 用于测试本机网络。其中最常见的地址是`127.0.0.1`，其他地址在技术上完全等效，只是没有人使用罢了。
+
+
+
+<DocCardList />

docs/docs/选择编程语言/Python/Python内置模块/网络与通信/socket.mdx

@@ -0,0 +1 @@
+socket是一个应用网络通信协议的库，可以设置不同参数用来实现不同的类型的网络通信。

…/docs/选择编程语言/Python/Python内置模块/网络与通信.mdx …择编程语言/Python/Python内置模块/网络与通信/urllib.mdxdocs/docs/选择编程语言/Python/Python内置模块/网络与通信.mdx renamed to docs/docs/选择编程语言/Python/Python内置模块/网络与通信/urllib.mdx docs/docs/选择编程语言/Python/Python内置模块/网络与通信.mdx renamed to docs/docs/选择编程语言/Python/Python内置模块/网络与通信/urllib.mdx

@@ -1,14 +1,10 @@
-# 网络与通信
-
-### webbrowser 模块
-
-### urllib 模块
+## urllib 模块
 
 urllib 是一个收集了多个涉及 URL 的模块的自带包：可以打开和读取 URL、 抛出异常、解析 URL、解析 robots.txt 文件是最底层的模块。虽然仅支持 HTTP1.0 仅同步 ，但是解码和解析功能是真的很好用
 
 [urllib 模块代码文档](https://docs.python.org/zh-cn/3/library/urllib.html?highlight=urllib#module-urllib)
 
-#### urllib 发送请求
+### urllib 发送请求
 
 ```python showLineNumbers
 import urllib.request
@@ -27,7 +23,7 @@ print(response.getheaders())
 [('Connection', 'close'), ('Content-Length', '50064'), ('Server', 'nginx'), ('Content-Type', 'text/html; charset=utf-8'), ('X-Frame-Options', 'DENY'), ('Via', '1.1 vegur, 1.1 varnish, 1.1 varnish'), ('Accept-Ranges', 'bytes'), ('Date', 'Tue, 17 Jan 2023 14:37:33 GMT'), ('Age', '1938'), ('X-Served-By', 'cache-iad-kiad7000025-IAD, cache-nrt-rjtf7700057-NRT'), ('X-Cache', 'HIT, HIT'), ('X-Cache-Hits', '263, 1190'), ('X-Timer', 'S1673966254.566369,VS0,VE0'), ('Vary', 'Cookie'), ('Strict-Transport-Security', 'max-age=63072000; includeSubDomains')]
 ```
 
-#### urllib 异常处理
+### urllib 异常处理
 
 URLError 是 OSError 的一个子类，所有请求问题都会被捕获。
 
@@ -47,7 +43,7 @@ if __name__ == "__main__":
         print(e) # <urlopen error [Errno 11002] getaddrinfo failed>
 ```
 
-#### urllib 解析 URL
+### urllib 解析 URL
 
 你肯定经历过复制网址出现乱码，这是因为网址必须以通用码的形式传送，而且还要避免几个特殊字符，因此网址要经编码，汉字经过编码后自然就是不可辨认的乱码了。
 
@@ -68,7 +64,7 @@ print( 'https://www.baidu.com/s?ie=UTF-8&wd='+quote('科技&技术'))
 # 结果为'https://www.baidu.com/s?ie=UTF-8&wd=%E7%A7%91%E6%8A%80&%E6%8A%80%E6%9C%AF'
 ```
 
-#### urllib 解析 robots.txt 文件
+### urllib 解析 robots.txt 文件
 
 ```python showLineNumbers
 import urllib.robotparser