Day 12 python学习笔记

模块


内置模块

sys模块

概述:Python 的 sys 模块提供访问解释器使用或维护的变量,和与解释器进行交互的函数。通俗来讲,sys 模块为程序与 Python 解释器的交互,提供了一系列的函数和变量,用于操控 Python 运行时的环境

Day 12 python学习笔记_第1张图片

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
Xian

sys.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()
1000

sys.setrecursionlimit()

  • 设置Python解释器的堆栈最大深度为

  • 该限制可防止无限递归导致C堆栈溢出和Python崩溃。

  • 最高可能的限制取决于平台

>>> sys.setrecursionlimit(2000)
>>> sys.getrecursionlimit()
2000

sys.getrefcount()
  • 获取引用数量 引用计数的精确分析可能受到一些内部因素的影响,通常情况下你只需要关注相对引用的变化,而不必过于关注具体的引用次数。
  • 返回的引用次数。
  • 引用次数会比期望值值多一个,因为它包含getrefcount()参数的临时引用。
  • >>> class Test():
    >>>     pass
    >>> t = Test()
    >>> sys.getrefcount(t)  # t本身是Test,所以被引用了一次。      
    2

    引出:

    小整数对象池:python为了让程序简单化,运行更加迅速,在python解释器加载的那一刻将一些常用的数字创建好(范围:[-5,256])

    1. 范围内的数字称为小整数
    2. 这个范围称为小整数对象池
    >>> 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中为了知道引用我当前对象变量的个数,在每一个对象当中会存在一块小小的空间,里面存放着引用计数

    优点:

    1. 简单
    2. 实时性

    缺点:

    1. 消耗内存(循环引用的话计数永远不为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(, )
    • 返回的大小。
    • 以字节为单位。
    • >>> class Test():
      >>>     pass
      >>> t = Test()
      >>> sys.getsizeof(t)
      64

      sys.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.3079221

      time.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.0

      time.sleep(secs)

      time.sleep(secs):线程推迟指定的时间运行。单位为秒

      import time
      time.sleep(2)
      print("我执行了...")
      # 线程推迟2秒后执行

      datetime模块

      datetime.datetime模块

      Day 12 python学习笔记_第2张图片

      datetime.now( )

      datetime.now( ) :返回当前时间(注意这是datetime.datetime里的方法)

      >>> import datetime
      >>> datetime.now()
      Traceback (most recent call last):
        File "", line 1, in 
      AttributeError: module 'datetime' has no attribute 'now'
      >>> from datetime import datetime
      >>> datetime.now()
      datetime.datetime(2023, 10, 29, 18, 58, 18, 486190)
      >>>

      你可能感兴趣的:(python,学习,笔记,算法,python,开发语言,青少年编程,汇编)