模块
内置模块
sys模块
概述：Python 的 sys 模块提供访问解释器使用或维护的变量，和与解释器进行交互的函数。通俗来讲，sys 模块为程序与 Python 解释器的交互，提供了一系列的函数和变量，用于操控 Python 运行时的环境
sys.argv
sys.argv ：实现从程序外部向程序传递参数
sys.argv 变量是一个包含了命令行参数的字符串列表，利用命令行向程序传递参数。其中，脚本的名称总是 sys.argv 列表的第一个参数。
import sys
print(sys.argv[0]) #sys.argv[0]表示代码本身的文件路径
print("命令行参数如下：")
for i in sys.argv:
print(i)
命令行输入参数如下:
D:\st13\python\1.20\python lx.py Welcome to Xian
运行结果:
lx.py #sys.argv[0]
命令行参数如下：
lx.py
Welcome
to
Xiansys.copyright
sys.copyright 包含 Python 解释器有关的版权信息的字符串
>>> import sys
>>> sys.copyright
'Copyright (c) 2001-2022 Python Software Foundation.\nAll Rights Reserved
.\n\nCopyright (c) 2000 BeOpen.com.\nAll Rights Reserved
.\n\nCopyright (c) 1995-2001 Corporation for National Research Initiatives
.\nAll Rights Reserved.\n\nCopyright (c) 1991-1995 Stichting
Mathematisch Centrum, Amsterdam.\nAll Rights Reserved.'
>>>sys.exit([arg])
sys.exit([arg]) : 一般情况下执行到主程序末尾，解释器自动退出，但是如果需要中途退出程序，可以调用 sys.exit() 函数，带有一个可选的整数参数返回给调用它的程序，表示你可以在主程序中捕获对 sys.exit() 的调用。（0是正常退出，其他为异常）当然也可以用字符串参数，表示错误不成功的报错信息。
下面的例子，首先打印 'Hello'，执行完 sys.exit(1)，执行 except 语句，将 '中途退出' 作为参数传递给函数 exitfunc()，然后将 '中途退出' 打印出来，程序正常退出，不执行后面的 print("Welcome") 语句
import sys
def exitfunc(value):
print(value)
sys.exit(0)
print("Hello")
try:
sys.exit(1)
except SystemExit as value:
exitfunc('中途退出')
print("Welcome")
运行结果：
Hello
中途退出或者在终端上退出python解释器
>>> sys.exit()
C:\Users\朱俊杰>sys.getrecursionlimit()
- 返回当前递归的限制也就是Python解释器堆栈最大深度的值。
- 该限制可防止无限递归导致C堆栈溢出和Python崩溃。它可以通过setrecursionlimit()设置。
>>> sys.getrecursionlimit()
1000sys.setrecursionlimit(<limit>)
设置Python解释器的堆栈最大深度为<limit>。
该限制可防止无限递归导致C堆栈溢出和Python崩溃。
最高可能的限制取决于平台
>>> sys.setrecursionlimit(2000)
>>> sys.getrecursionlimit()
2000sys.getrefcount(<object>)
- 获取引用数量 引用计数的精确分析可能受到一些内部因素的影响，通常情况下你只需要关注相对引用的变化，而不必过于关注具体的引用次数。
- 返回<object>的引用次数。
- 引用次数会比期望值值多一个，因为它包含getrefcount()参数的临时引用。
>>> class Test():
>>> pass
>>> t = Test()
>>> sys.getrefcount(t) # t本身是Test,所以被引用了一次。
2引出：
小整数对象池：python为了让程序简单化，运行更加迅速，在python解释器加载的那一刻将一些常用的数字创建好（范围：[-5,256]）
- 范围内的数字称为小整数
- 这个范围称为小整数对象池
>>> a = [1,2,3,4]
>>> b = [1,2,3,4]
>>> id(a)
2312403015936
>>> id(b)
2312403230080 #尽管内容相同，但不同变量地址不同
>>> c = 5
>>> d = 5
>>> id(c)
2312401846640
>>> id(d)
2312401846640 #证明5是小整数对象池里的（常用）
>>> e = -10
>>> f = -10
>>> id(e)
2312402870448
>>> id(f)
2312402870704 #证明-10不是小整数对象池里的（不常用）
>>>字符串驻留机制（Intern机制）：创建普通字符串（不含空格等特殊字符）时打开，不重复创建字符串地址
>>> a = "love"
>>> b = "love" #普通字符串
>>> id(a)
2312403517808
>>> id(b)
2312403517808
>>> c = "l love you"
>>> d = "l love you" #字符串内含空格等特殊字符，不开启字符串驻留机制
>>> id(c)
2312403517872
>>> id(d)
2312403517936
>>>引用计数机制：python中为了知道引用我当前对象变量的个数，在每一个对象当中会存在一块小小的空间，里面存放着引用计数
优点：
- 简单
- 实时性
缺点：
- 消耗内存（循环引用的话计数永远不为0，即不会释放）
例：
[1,2,3] 空间存在一个数据
引用计数机制开辟一个小空间记录这个数据被引用的次数
[1,2,3] 0(被引用次数为0)
a = [1,2,3] 1（被引用一次）
b = a 2（被引用两次）
b = None 1（被引用一次，切断了b的引用）
a = None 0（没有被引用，切断了a的引用）
当引用计数为0时，证明没人使用，python解释器就会将数据释放出来
计算机垃圾回收机制:代码在内存中运行，函数等会进行弹栈进行内存释放，那么堆如何进行内存释放呢？
java、python、c++不需要程序员自行回收机制，因为对程序员的要求太高，提供复杂的回收算法，其中引用计时法（解决80%问题，缺点，循环引用）看内存有无被其他内存引用，别人指向我，我有用。
循环引用会出现问题------出现标记、清除算法。
sys.path
sys.path：获取指定模块搜索路径的目录名列表，列表中的第一项为当前的工作目录
import sys
print(sys.path)
运行结果：
['D:\\st13\\python\\1.20', 'C:\\Python36\\python36.zip',
'C:\\Python36\\DLLs', 'C:\\Python36\\lib', 'C:\\Python36',
'C:\\Python36\\lib\\site-packages']sys.getsizeof(<object>, <default>)
- 返回<object>的大小。
- 以字节为单位。
>>> class Test():
>>> pass
>>> t = Test()
>>> sys.getsizeof(t)
64sys.hash_info
- 一个包含哈希参数的元祖。
- 返回的属性包含:
>>>sys.hash_info
sys.hash_info(width=64, modulus=2305843009213693951, inf=314159,
nan=0, imag=1000003, algorithm='siphash24', hash_bits=64,
seed_bits=128, cutoff=0)time模块
time.time( )
time.time( ) ：返回当前时间的时间戳
#时间戳：指格林威治时间1970年01月01日00时00分00秒（北京时间1970年01月01日08时00分00秒）起至现在的总秒数
import time
print(time.time())
# 1596760621.3079221time.ctime([secs])
time.ctime([secs])：返回当前时间
把一个时间戳（按秒计算的浮点数）转化为time.asctime()的形式。如果参数未给或者为None的时候，将会默认time.time()为参数
>>> time.ctime()
'Sun Oct 29 18:26:36 2023'
>>>time.localtime([secs])
time.localtime([secs])：将一个时间戳转换为当前时区的struct_time（结果为元组）
import time
print(time.localtime())
结果：
time.struct_time(tm_year=2020, tm_mon=8, tm_mday=7, tm_hour=8,
tm_min=38, tm_sec=57, tm_wday=4, tm_yday=220, tm_isdst=0)time.strftime(格式，时间元组)
time.strftime(格式，时间元组) ：将时间元组换一种格式（时间字符串）打印出来
如果时间元组未指定，则默认传入time.localtime()
%Y 四位的年
%y 两位的年
%m 月
%d 日
%H 时
%M 分
%S 秒
%X = %H:%M:%S
例：打印格式为：2023/10/21 11:11:11
>>> time.strftime("%Y/%m/%d %H:%M:%S",time.localtime())
'2023/10/29 18:39:57'
>>>
>>> time.strftime("%Y/%m/%d %H:%M:%S")
'2023/10/29 18:42:09'
>>>time.strptime(string[, format])
time.strptime(string[, format])： 把一个格式化时间字符串转化为struct_time。实际上它和strftime()是逆操作。在这个函数中，format默认为："%a %b %d %H:%M:%S %Y"
time.strptime('2011-05-05 16:37:06', '%Y-%m-%d %X') #要一一对应
Output: time.struct_time(tm_year=2011, tm_mon=5, tm_mday=5,
tm_hour=16, tm_min=37, tm_sec=6, tm_wday=3, tm_yday=125, tm_isdst=-1)time.mktime(t)
time.mktime(t)：将一个struct_time（时间元组）转化为时间戳
time.mktime(time.localtime())
#Output: 1634864031.0time.sleep(secs)
time.sleep(secs)：线程推迟指定的时间运行。单位为秒
import time
time.sleep(2)
print("我执行了...")
# 线程推迟2秒后执行datetime模块
datetime.datetime模块
datetime.now( )
datetime.now( ) ：返回当前时间（注意这是datetime.datetime里的方法）
>>> import datetime
>>> datetime.now()
Traceback (most recent call last):
File "<stdin>", line 1, in <module>
AttributeError: module 'datetime' has no attribute 'now'
>>> from datetime import datetime
>>> datetime.now()
datetime.datetime(2023, 10, 29, 18, 58, 18, 486190)
>>>
