常用模块

目录

一、re正则模块

1.正则表达式

在线测试工具 http://tool.chinaz.com/regex/


​ 1.找出字符串中符合正则的内容
​ 2.返回列表，列表中是正则表达匹配的内容

2.search(往后查找，搜索) ：

​ 1.返回一个对象，必须调用group才能看到结果
​ 2.根据正则查找一次，只要查到结果就不会往后查找
​ 3.当查找结果不存在（返回的None），再调用group直接报错，因为none没有group方法
3.match(匹配开头)：
​ 1.match匹配字符串开头
​ 2.没有同样返回None
​ 3.同样调用group报错

其他方法：

4.split(切割)

5.sub(替换，指定替换个数)

6.subn(替换，返回元组)

7.compile(编译成对象)

8.finditer(迭代)

9.分组，起别名： ?P<别名>

1.findall(全文查找返回):

res = re.findall('a','asd jeff ball')
res1 = re.findall('[a-z]+','asd jeff ball')
print(res1)

2.search(从上至下查找):

res2 = re.search('a','asd jeff ball')
if res2:
print(res2.group())

3.match(匹配开头):

res3 = re.match('a','asd jeff ball')

if res3:
print(res3.group())

4.split(切割)：

ret = re.split('[ab]', 'abcd') # 先按'a'分割得到''和'bcd',在对''和'bcd'分别按'b'分割
print(ret) # ['', '', 'cd']

str = "abcd,ssdhu,123";
print str.split( );       # 以空格为分隔符，包含 

print str.split(' ,', 1 ); # 以逗号为分隔符，分隔成两个

5.sub(替换)

ret = re.sub('999', 'H', 'jeff age max 999 8884', 2) # 将数字替换成'H'，参数1表示只替换1个

print(ret) # evaHegon4yuan4

6.subn(替换，返回元组)

ret = re.subn('d', 'H', 'eva3egon4yuan4') # 将数字替换成'H'，返回元组(替换的结果,替换了多少次)
print(ret)

7.compile(正则封装为对象)

obj = re.compile('d{3}') #将正则表达式编译成为一个 正则表达式对象，规则要匹配的是3个数字
ret = obj.search('abc123eeee') #正则表达式对象调用search，参数为待匹配的字符串
print(ret.group()) #结果 ： 123

8.finditer(迭代)

ret = re.finditer('d', 'ds3sy4784a') #finditer返回一个存放匹配结果的迭代器
print(ret) # <callable_iterator object at 0x10195f940>
print(next(ret).group()) #查看第一个结果
print(next(ret).group()) #查看第二个结果
print([i.group() for i in ret]) #查看剩余的左右结果

9.分组

res = re.search('[1]d{14}(d{2}[0-9x])?$',110105199812067023
print(res)

print(res.group(1)) # 获取正则表达式括号阔起来分组的内容
print(res.group(2)) # search与match均支持获取分组内容的操作 跟正则无关是python机制

10.起别名：

re.search('[2]?P(d{14})(d{2}[0-9x])?$',110105199812067023)
print(res.group(passwd))

整则表达式符号：

[a-z]:匹配小写a至z的字母 # ASCLL码表，从小到大
[A-Z]：匹配大写A至Z的字母

. :出换行符的任意字符

w：匹配字母数字下划线 单词word
s : 匹配空白符 单词space
d:匹配数字

W:匹配除字母数字下划线
S:匹配除空白符
D:匹配除数字

:匹配换行符
:匹配制表符

:以什么什么结尾的单词 eg:n————表示以n结尾的单词 还可以：tion以tion结尾的单词

$ :p匹配字符串的结尾 eg:[0-9x]$: 表示以0-9或x结尾的 tion$ :以tion结尾的字符串
　　　　　　　　　　　　　　　注意：^与$连用，叫精确匹配，中间写什么匹配什么。 eg: ^jeff$ :匹配jeff,以jeff开头并以jeff结尾
a|b :匹配字符a或b eg（错误）：ab|abc：先匹配ab,abc就匹配不到了。eg(正确)：eg:abc|ab ：先匹配abc,再匹配ab，都能匹配到。将长的放在前面

（）：匹配括号里的表达式，表示一个组

^ :匹配字符串的开头 eg:[3]：表示以0至9开头的 ^art :以art开头
[^...]：表示非，除了字符组中的所有字符。 eg:[^ab]:匹配所有除了ab的字符

量词：

　　　　1.必须跟在正则表达后

　　　　2.量词只能限制紧挨着的一个表达

：重复零次或多次

+：一次或多次

？：零次或一次

{n}:表示重复n次 eg: d{11}————匹配11位数字
{n,}:重复n次或更多次
{n,m}:重复n到m次 eg:d{2,5}————匹配2位至5位的数字

img

取消贪婪匹配：

贪婪匹配：默认都是贪婪匹配。贪婪匹配都是取大，比如: 表示更多次、+表示多次、?表示一次，当然这只是默认的，当默认贪婪匹配不到，就会表示零次、+表示一次、？表示零次

取消贪婪匹配：量词后面加问号（？）。 eg: 待匹配：李杰和李莲英和李二棍子 正则表达式：李.+? 结果：李杰 李莲 李二 ，因为+后面跟了？，所以+表示一次

转义符：

: 取消转义

　　eg: 表示

二、import模块

1.import 与from ...import的区别

import : 导入模块

from 模块名 import ...

import 就相当于：把超市给我

from 超市 import 矿泉水：把超市里的矿泉水给我

例子1：不会报错

import aaa
aaa.func1()
aaa.func2()

img

例子2：报错，因为没有导入func2

from aaa import func1
func1()
func2()

img

2.模块基本说明

1.什么是模块？

　　模块就是一系列的功能结合体：

　　　　模块的三种来源：

　　　　　　1.内置的模块（pycharm内置自带的）

　　　　　　2.第三方的（别人写的）

　　　　　　3.自定义的（自己写的）

2.为什么要用模块？

　　1.在python编程中，写程序的时候尽量多去调用模块来完成功能，因为这是python的特点，这样效率高，速度快，提高开发效率

　　2.当程序比较庞大的时候，需要用模块的形式将庞大的程序一步步拆分，更加的详细清楚

3.模块的查找顺序

　　1.先从内存中查找

　　2.pycharm内置中找

　　3.sys.path中找（环境变量）

4.导入模块的路径

1.绝对导入：无论在执行文件中还是被导入文件中都适用

2.相对导入：

　　　　‘.’点代表当前路径

　　　　‘..’点点代表上一级路径

　　　　‘...’点点点代表上上一级路径

注意：

　　相对导入不能在执行文件中使用，只能在被导入的模块中使用，相对导入需要知道模块与模块之间的路径关系

　　　

三、collertion模块

1.collertion模块基本方法：

1.namedtuple 具名元组(给元组取名)
2.deque 双端队列(左中右添加值，左右取值)
3.OrderedDict 有序字典
4.Counter方法(计算计算字符串的每个字符的个数，并以字典返回)

1.namedtuple 具名元组

from collections import namedtuple
point = namedtuple('坐标', ['x', 'y', 'z'])
p = point(2, 5, 8)
print(p)
print(p.x)
print(p.y)
print(p.z)

结果：坐标(x=2, y=5, z=8)   2   5    8

from collections import namedtuple
card = namedtuple('扑克牌', 'color number')
A = card('♠', 'A')
print(A)
print(A.color)
print(A.number)
结果：扑克牌(color='♠', number='A')    ♠  A

2.queue.Queue队列 deque双端队列

import queue
q = queue.Queue()  # 生成队列对象
q.put('one')   # 传值
q.put('two')
q.put('three')

print(q.get())  # 朝着队列要值，如果取完了，程序原地等待(不结束)
print(q.get())
print(q.get())
print(q.get())

2.deque双端队列

四个方法：
1.append 尾部追加
2.appendleft 左边追加
3.pop 末尾取值
4.popleft 左边取值
5.insert(索引,'值') 根据索引插值

from collections import deque
q = deque(['a', 'b', 'c'])
q.append('尾')
q.appendleft('左')
q.insert(1, '插')   # 在索引1位置插入
print(q.pop())  # 结果： 尾
print(q.popleft())  # 结果： 左
print(q.popleft())  # 结果： 插

3.有序字典

from collections import OrderedDict
k = OrderedDict()
k['x'] = 1  # 给固定的键传值
k['y'] = 2
k['z'] = 3

表现：

print(k)
for i in k:
    print(i)

4.Counter计算字符次数方法与普通for循环方法

计算字符串中每隔字符出现的次数：

k = 'abcaabca'
d = {}
# 字典的key是固定的，先建一个值为0的字典
for i in k:
    d[i] = 0
# 每个字符和字典的key作比较，有就加1
for q in k:
    for n in d:
        if n == q:
            d[q] += 1
print(d)
2.Counter方法
from collections import Counter
k = 'abcaabca'
res = Counter(k)
print(res)

四、time与datetime模块

1.time与datetime模块:

import time
print(time.time())  # 距离1970.01.01的秒数
print(time.strftime('%Y-%m-%d %H:%M:%S'))  # 拼接时间格式
print(time.localtime())
time.sleep(3)  # 程序暂停3秒

2.时间：

import datetime
print(datetime.date.today())  # 年月日
print(datetime.datetime.today())  # 年月日 时分秒
res = datetime.date.today()
res1 = datetime.datetime.today()
print(res.year)  # 年
print(res.month)  # 月
print(res.day)   # 日
print(res.weekday())  # 第几个星期(从0开始)
print(res.isoweekday())  # 第几个星期(从1开始)

3.时间计算

# 时间计算
import datetime
a = datetime.datetime(2019, 12, 15, 5, 5, 5)
b = datetime.datetime.today()
print(a-b)  #  现在时间-指定时间
UTC时间：
import datetime
a = datetime.datetime.today()
b = datetime.datetime.now()
c = datetime.datetime.utcnow()   #一区时间，上海东八区
print(a)
print(b)
print(c)

五、random随机模块

# 随机模块
import random

print(random.randint(0, 9))  # 随机取一个0-9的数字，包含头尾
print(random.random)  # 取0-1之间的小数
print(random.choice([1, 2, 3, 4]))  # 随机从列表中取一个值

打乱顺序shuffle:

res = [1, 2, 3, 4, 5]
random.shuffle(res)  # 打乱列表的顺序
print(res)
# 生成随机验证码
a = str(random.randint(0, 9))   # 转成字符串型，才可以相加拼接
b = chr(random.randint(65, 90))  # 大写字母 65-90
c = chr(random.randint(97, 122))  # 小写字母  97-122
# print(a, b, c)
k = ''
for i in range(5):
    m = random.choice([a, b, c])
    k += m   # 让字符串相加，而不是数字
print(k)
m = random.randint(0, 9)
print(type(a))
print(type(m))

六、sys模块和subprocess子进程模块

1.sys模块跟python解释器打交道的

2.sys中的一些方法

import sys
sys.path.append() # 将某个路径添加到环境变量中
print(sys.platform) # 查看当前操作系统
print(sys.version) # python解释器的版本
print(sys.argv) # 命令启动文件 可以做身份验证

3.subprocess 子进程模块

subprocess 子进程模块
"""
sub :子
process:进程
"""

例子1：
输出cmd命令并返回结果：
while True:
    cmd = input('cmd>>>:').strip()
    import subprocess
    obj = subprocess.Popen(cmd,shell=True,stdout=subprocess.PIPE,stderr=subprocess.PIPE)
    print('正确命令返回结果stdout',obj.stdout.read().decode('gbk'))
    print('错误命令返回的提示信息stdout',obj.stdout.read().decode('gbk'))

七、json和pickle序列化模块

1.json和pickle的区别特点

json:可以和其他语言玩

pickle:只能和自己（python）玩

2.json 中的一些方法

dumps(转): 将其他数据类型转成json格式的字符串
loads（解）: 将json格式字符串转换成其他数据类型
dump(转文件): 将其他数据类型转成json格式的字符串
load（解文件）: 将json格式字符串转换成其他数据类型

ensure_ascii=False False表示字典中的汉字不转,Turn表示转中文，默认为Trun

优点： 1.所有语言都支持json格式
缺点： 2.支持的数据类型少
pickle()
优点： 1.python所有数据类型都支持
缺点： 2.只支持python

3.序列化

序列化：
序列：字符串
序列化：其他数据类型转成字符串的过程
　　序列化：其他数据类型转成字符串的过程
　　反序列化：字符串转成其他数据类型

注意：
　　写入文件的数据必须是字符串（二进制）
　　基于网络传输的数据必须是二进制

例子1：
将字典转换成字符串：k = {'name': 'jeff'}
res = json.dumps(k)
print(res) # 结果：{"name": "jeff"}
print(res, type(res)) # 结果：{"name": "jeff"} <class 'str'>

将上面的字符串转为字典：

res1 = json.loads(res)
print(res1, type(res1))  结果：{'name': 'jeff'} <class 'dict'>

例子2：对文件的中的内容转换：

转换类型，并写入文件：

d = {"name":"jeff"}
with open(r'userinfo','w',encoding='utf-8') as f:
    json.dump(d, f)  # 转字符，并自动写入文件

读取内容，并解为python类型：

with open(r'userinfo', 'r', encoding='utf-8') as f:
    res = json.load(f)  # 解字符，并读取
    print(res, type(res))


例子3：
ensure_ascii=False  表示字典中的汉字不转
中文不转码：
d = {'name': '辜老板'}
print(json.dumps(d, ensure_ascii=False))   # ensure_ascii=False识别中文不转码
#结果：{"name": "辜老板"}

中文转码：

d = {'name': '辜老板'}
print(json.dumps(d, ensure_ascii=True))   # ensure_ascii=False识别中文不转码
# 结果：{"name": "u8f9cu8001u677f"}    中文转码了

八、hashlib加密模块

hashlib加密模块：不可逆，但是可以撞库

1.hashlib常用方法

md.update('数据'): 没有提示，记住单词
md.hexdigest() ：获取密文，记住单词

hashlib加盐：用手动传入假数据（动态）和真数据混合在一起加密

MD5：常用加密算法

2.hashlib应用场景

1.密码的密文储存
2.校验文件内容是否一致

1.加密：

md = hashlib.md5()   #  加密，不可逆
md.update('hello'.encode('utf-8'))   # 往对象里传数据加密  ，update只能接受bytes类型
md.update(b'hello')
print(md.hexdigest())

结果：23b431acfeb41e15d466d75de822307c

2.加盐加密：自己添加的东西和客户的真密码一起加密，自己添加的东西可以是动态的

2.加盐  ：自己添加的东西和客户的真密码一起加密，自己添加的东西可以是动态的
md = hashlib.md5()
md.update(b'yan.com')
md.update(b'hello')   # 加密
print(md.hexdigest())  # 获取密文

例子1：给客户输入的密码加盐加密

import hashlib
# 加盐
def get_md5(date):
    md = hashlib.md5()
    md.update('加盐'.encode('utf-8'))
    md.update(date.encode('utf-8'))
    return md.hexdigest()
password = input('password>>>:')
res = get_md5(password)
print(res)

九、loggin日志模块

一、日志级别

CRITICAL = 50 #FATAL = CRITICAL
ERROR = 40
WARNING = 30 #WARN = WARNING
INFO = 20
DEBUG = 10
NOTSET = 0 #不设置

二、默认级别为warning，默认打印到终端

import logging

logging.debug('调试debug')
logging.info('消息info')
logging.warning('警告warn')
logging.error('错误error')
logging.critical('严重critical')

'''
WARNING:root:警告warn
ERROR:root:错误error
CRITICAL:root:严重critical
'''

三、为logging模块指定全局配置，针对所有logger有效，控制打印到文件中

可在logging.basicConfig()函数中通过具体参数来更改logging模块默认行为，可用参数有
filename：用指定的文件名创建FiledHandler（后边会具体讲解handler的概念），这样日志会被存储在指定的文件中。
filemode：文件打开方式，在指定了filename时使用这个参数，默认值为“a”还可指定为“w”。
format：指定handler使用的日志显示格式。 
datefmt：指定日期时间格式。 
level：设置rootlogger（后边会讲解具体概念）的日志级别 
stream：用指定的stream创建StreamHandler。可以指定输出到sys.stderr,sys.stdout或者文件，默认为sys.stderr。若同时列出了filename和stream两个参数，则stream参数会被忽略。



#格式
%(name)s：Logger的名字，并非用户名，详细查看

%(levelno)s：数字形式的日志级别

%(levelname)s：文本形式的日志级别

%(pathname)s：调用日志输出函数的模块的完整路径名，可能没有

%(filename)s：调用日志输出函数的模块的文件名

%(module)s：调用日志输出函数的模块名

%(funcName)s：调用日志输出函数的函数名

%(lineno)d：调用日志输出函数的语句所在的代码行

%(created)f：当前时间，用UNIX标准的表示时间的浮 点数表示

%(relativeCreated)d：输出日志信息时的，自Logger创建以 来的毫秒数

%(asctime)s：字符串形式的当前时间。默认格式是 “2003-07-08 16:49:45,896”。逗号后面的是毫秒

%(thread)d：线程ID。可能没有

%(threadName)s：线程名。可能没有

%(process)d：进程ID。可能没有

%(message)s：用户输出的消息

介绍

#======介绍
可在logging.basicConfig()函数中可通过具体参数来更改logging模块默认行为，可用参数有
filename：用指定的文件名创建FiledHandler（后边会具体讲解handler的概念），这样日志会被存储在指定的文件中。
filemode：文件打开方式，在指定了filename时使用这个参数，默认值为“a”还可指定为“w”。
format：指定handler使用的日志显示格式。
datefmt：指定日期时间格式。
level：设置rootlogger（后边会讲解具体概念）的日志级别
stream：用指定的stream创建StreamHandler。可以指定输出到sys.stderr,sys.stdout或者文件，默认为sys.stderr。若同时列出了filename和stream两个参数，则stream参数会被忽略。


format参数中可能用到的格式化串：
%(name)s Logger的名字
%(levelno)s 数字形式的日志级别
%(levelname)s 文本形式的日志级别
%(pathname)s 调用日志输出函数的模块的完整路径名，可能没有
%(filename)s 调用日志输出函数的模块的文件名
%(module)s 调用日志输出函数的模块名
%(funcName)s 调用日志输出函数的函数名
%(lineno)d 调用日志输出函数的语句所在的代码行
%(created)f 当前时间，用UNIX标准的表示时间的浮 点数表示
%(relativeCreated)d 输出日志信息时的，自Logger创建以 来的毫秒数
%(asctime)s 字符串形式的当前时间。默认格式是 “2003-07-08 16:49:45,896”。逗号后面的是毫秒
%(thread)d 线程ID。可能没有
%(threadName)s 线程名。可能没有
%(process)d 进程ID。可能没有
%(message)s用户输出的消息

使用

#========使用
import logging
logging.basicConfig(filename='access.log',
                    format='%(asctime)s - %(name)s - %(levelname)s -%(module)s:  %(message)s',
                    datefmt='%Y-%m-%d %H:%M:%S %p',
                    level=10)

logging.debug('调试debug')
logging.info('消息info')
logging.warning('警告warn')
logging.error('错误error')
logging.critical('严重critical')





#========结果
access.log内容:
2017-07-28 20:32:17 PM - root - DEBUG -test:  调试debug
2017-07-28 20:32:17 PM - root - INFO -test:  消息info
2017-07-28 20:32:17 PM - root - WARNING -test:  警告warn
2017-07-28 20:32:17 PM - root - ERROR -test:  错误error
2017-07-28 20:32:17 PM - root - CRITICAL -test:  严重critical

part2: 可以为loggin
    g模块指定模块级的配置,即所有logger的配置

十、requests爬虫模块

requests 模块

import requests

response = requests.get('https://www.taobao.com')
if response.status_code == 200:
    print(len(response.text))

十一、pymysql模块

这个模块可以操作MySQL的模块

用的时候需要下载一下这个模块

例子：

import pymysql

conn = pymysql.connect(
    host = '127.0.0.1',
    port = 3306,
    user = 'root',
    password = '123',
    database = 'jeff',
    charset = 'utf8'
)

cursor = conn.cursor(pymysql.cursors.DictCursor)  # 产生游标对象，以字典的形式返回
sql = 'select * from teacher'
cursor.execute(sql)  # 执行传入的sql语句
# print(cursor.fetchone())  # 只获取一条数据
# print(cursor.fetchone())  # 只获取一条数据
# print(cursor.fetchone())  # 只获取一条数据
# print(cursor.fetchone())  # 只获取一条数据
# cursor.scroll(2,'absolute')  # 控制光标移动   absolute相对于其实位置 往后移动几位
# cursor.scroll(1,'relative')  # relative相对于当前位置 往后移动几位
print(cursor.fetchall())  # 获取所有的数据  返回的结果是一个列表

十二、uuid

  1. uuid.uuid1([node[, clock_seq]]) -- 基于时间戳

由 MAC 地址（主机物理地址）、当前时间戳、随机数生成。可以保证全球范围内的唯一性，
但 MAC 的使用同时带来安全性问题，局域网中可以使用 IP 来代替MAC。

该函数有两个参数, 如果 node 参数未指定, 系统将会自动调用 getnode() 函数来获取主机的硬件地址. 如果 clock_seq 参数未指定系统会使用一个随机产生的14位序列号来代替.

注意： uuid1() 返回的不是普通的字符串，而是一个 uuid 对象，其内含有丰富的成员函数和变量。

  1. uuid.uuid2() -- 基于分布式计算环境DCE（Python中没有这个函数）

算法与uuid1相同，不同的是把时间戳的前 4 位置换为 POSIX 的 UID。
实际中很少用到该方法。

  1. uuid.uuid3(namespace, name) -- 基于名字的MD5散列值

通过计算名字和命名空间的MD5散列值得到，保证了同一命名空间中不同名字的唯一性，
和不同命名空间的唯一性，但同一命名空间的同一名字生成相同的uuid。

  1. uuid.uuid4() -- 基于随机数

由伪随机数得到，有一定的重复概率，该概率可以计算出来。

产生一个唯一的随机字符串
import uuid
a = str(uuid.uuid4())
print(len(a))
print(a)
  1. uuid.uuid5() -- 基于名字的SHA-1散列值

算法与uuid3相同，不同的是使用 Secure Hash Algorithm 1 算法

十三.OS模块

os.makedirs('dirname1/dirname2')    可生成多层递归目录
os.removedirs('dirname1')    若目录为空，则删除，并递归到上一级目录，如若也为空，则删除，依此类推
os.mkdir('dirname')    生成单级目录；相当于shell中mkdir dirname
os.rmdir('dirname')    删除单级空目录，若目录不为空则无法删除，报错；相当于shell中rmdir dirname
os.listdir('dirname')    列出指定目录下的所有文件和子目录，包括隐藏文件，并以列表方式打印
os.remove()  删除一个文件
os.rename("oldname","newname")  重命名文件/目录
os.stat('path/filename')  获取文件/目录信息

os.system("bash command")  运行shell命令，直接显示
os.popen("bash command).read()  运行shell命令，获取执行结果
os.getcwd() 获取当前工作目录，即当前python脚本工作的目录路径
os.chdir("dirname")  改变当前脚本工作目录；相当于shell下cd

os.path
os.path.abspath(path) 返回path规范化的绝对路径
os.path.split(path) 将path分割成目录和文件名二元组返回 
os.path.dirname(path) 返回path的目录。其实就是os.path.split(path)的第一个元素 
os.path.basename(path) 返回path最后的文件名。如何path以／或结尾，那么就会返回空值。即os.path.split(path)的第二个元素
os.path.exists(path)  如果path存在，返回True；如果path不存在，返回False
os.path.isabs(path)  如果path是绝对路径，返回True
os.path.isfile(path)  如果path是一个存在的文件，返回True。否则返回False
os.path.isdir(path)  如果path是一个存在的目录，则返回True。否则返回False
os.path.join(path1[, path2[, ...]])  将多个路径组合后返回，第一个绝对路径之前的参数将被忽略
os.path.getatime(path)  返回path所指向的文件或者目录的最后访问时间
os.path.getmtime(path)  返回path所指向的文件或者目录的最后修改时间
os.path.getsize(path) 返回path的大小


注意：os.stat('path/filename')  获取文件/目录信息 的结构说明


复制代码
stat 结构:

st_mode: inode 保护模式
st_ino: inode 节点号。
st_dev: inode 驻留的设备。
st_nlink: inode 的链接数。
st_uid: 所有者的用户ID。
st_gid: 所有者的组ID。
st_size: 普通文件以字节为单位的大小；包含等待某些特殊文件的数据。
st_atime: 上次访问的时间。
st_mtime: 最后一次修改的时间。
st_ctime: 由操作系统报告的"ctime"。在某些系统上（如Unix）是最新的元数据更改的时间，在其它系统上（如Windows）是创建时间（详细信息参见平台的文档）。
复制代码

os.sep    输出操作系统特定的路径分隔符，win下为"\",Linux下为"/"
os.linesep    输出当前平台使用的行终止符，win下为"
",Linux下为"
"
os.pathsep    输出用于分割文件路径的字符串 win下为;,Linux下为:
os.name    输出字符串指示当前使用平台。win->'nt'; Linux->'posix'

  1. 1-9 ↩︎

  2. 1-9 ↩︎

  3. 0-9 ↩︎

【推广】 免费学中医，健康全家人
原文地址：https://www.cnblogs.com/WQ577098649/p/11887424.html