Python学习——Day10

一、sys模块

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

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.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.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
中途退出

sys.copyright  包含 Python 解释器有关的版权信息的字符串

>>> sys.copyright
'Copyright (c) 2001-2019 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.getrefcount()
  • 返回的引用次数。
  • 引用次数会比期望值值多一个,因为它包含getrefcount()参数的临时引用。
  • >>> class Test():
    >>>     pass
    >>> t = Test()
    >>> sys.getrefcount(t) # t 本身是Test,所以被引用了一次。      
    2

    sys.getrecursionlimit()

    • 返回当前递归的限制也就是Python解释器堆栈最大深度的值。
    • 该限制可防止无限递归导致C堆栈溢出和Python崩溃。它可以通过setrecursionlimit()设置。
    >>> sys.getrecursionlimit()
    1000

    sys.setrecursionlimit()

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

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

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

    >>> sys.setrecursionlimit(999)
    >>> sys.getrecursionlimit()
    999

    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)

      参考网站:

      大师兄的Python学习笔记(六): 常用库之sys包 - 简书

      二、time模块

       time.time( )返回当前时间的时间戳

      import time
      print(time.time())
      # 1596760621.3079221
      

      time.ctime([secs])返回当前时间

            把一个时间戳(按秒计算的浮点数)转化为time.asctime()的形式。如果参数未给或者为None的时候,将会默认time.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.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.sleep(secs)线程推迟指定的时间运行。单位为秒

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

      time.mktime(t)将一个struct_time转化为时间戳

      time.mktime(time.localtime())
      #Output: 1634864031.0
      

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

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

      time.strftime(format[, t])

              把一个代表时间的元组或者struct_time(如由time.localtime()和time.gmtime()返回)转化为格式化的时间字符串。如果t未指定,将传入time.localtime()。如果元组中任何一个元素越界,ValueError的错误将会被抛出

      time.strftime("%Y-%m-%d %X", time.localtime())
      time.strftime("%Y-%m-%d %x", time.localtime())
      Output1: '2021-10-22 09:13:55'
      Output2: '2021-10-22 10/22/21'
      

      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)
      

      三、面向对象

      • 类(Class): 用来描述具有相同的属性和方法的对象的集合。它定义了该集合中每个对象所共有的属性和方法。对象是类的实例。
      • 方法:类中定义的函数。
      • 类变量:类变量在整个实例化的对象中是公用的。类变量定义在类中且在函数体之外。类变量通常不作为实例变量使用。
      • 数据成员:类变量或者实例变量用于处理类及其实例对象的相关的数据。
      • 方法重写:如果从父类继承的方法不能满足子类的需求,可以对其进行改写,这个过程叫方法的覆盖(override),也称为方法的重写。
      • 局部变量:定义在方法中的变量,只作用于当前实例的类。
      • 实例变量:在类的声明中,属性是用变量来表示的,这种变量就称为实例变量,实例变量就是一个用 self 修饰的变量。
      • 继承:即一个派生类(derived class)继承基类(base class)的字段和方法。继承也允许把一个派生类的对象作为一个基类对象对待。例如,有这样一个设计:一个Dog类型的对象派生自Animal类,这是模拟"是一个(is-a)"关系(例图,Dog是一个Animal)。
      • 实例化:创建一个类的实例,类的具体对象。
      • 对象:通过类定义的数据结构实例。对象包括两个数据成员(类变量和实例变量)和方法。

      类定义

      class ClassName:      #class  类名 :

       类对象

      类对象支持两种操作:属性引用和实例化

      属性引用使用和 Python 中所有的属性引用一样的标准语法:obj.name

      #!/usr/bin/python3
       
      class MyClass:
          """一个简单的类实例"""
          i = 12345
          def f(self):
              return 'hello world'
       
      # 实例化类
      x = MyClass()
       
      # 访问类的属性和方法
      print("MyClass 类的属性 i 为:", x.i)
      print("MyClass 类的方法 f 输出为:", x.f())

      类有一个名为 __init__() 的特殊方法(构造方法),该方法在类实例化时会自动调用,像下面这样:

      def __init__(self):
          self.data = []

       类定义了 __init__() 方法,类的实例化操作会自动调用 __init__() 方法

      class Complex:
          def __init__(self, realpart, imagpart):
              self.r = realpart
              self.i = imagpart
      x = Complex(3.0, -4.5)
      print(x.r, x.i)   # 输出结果:3.0 -4.5

      self代表类的实例,而非类

      类的方法与普通的函数只有一个特别的区别——它们必须有一个额外的第一个参数名称, 按照惯例它的名称是 self

      类的方法

      在类的内部,使用 def 关键字来定义一个方法,与一般函数定义不同,类方法必须包含参数 self, 且为第一个参数。

      self 代表的是类的实例:

      #类定义
      class people:
          #定义基本属性
          name = ''
          age = 0
          #定义私有属性,私有属性在类外部无法直接进行访问
          __weight = 0
          #定义构造方法
          def __init__(self,n,a,w):
              self.name = n
              self.age = a
              self.__weight = w
          def speak(self):
              print("%s 说: 我 %d 岁。" %(self.name,self.age))
       
      # 实例化类
      p = people('runoob',10,30)
      p.speak()

      runoob 说: 我 10 岁。

      类属性与方法

      类的私有属性

      __private_attrs:(private:私有的  attrs:属性)两个下划线开头,声明该属性为私有,不能在类的外部被使用或直接访问。在类内部的方法中使用时 self.__private_attrs

      类的方法

      在类的内部,使用 def 关键字来定义一个方法,与一般函数定义不同,类方法必须包含参数 self,且为第一个参数,self 代表的是类的实例。

      self 的名字并不是规定死的,也可以使用 this,但是最好还是按照约定使用 self。

      类的私有方法

      __private_method:两个下划线开头,声明该方法为私有方法,只能在类的内部调用 ,不能在类的外部调用。self.__private_methods

      实例

      类的私有属性实例如下:

      class JustCounter:
          __secretCount = 0  # 私有变量
          publicCount = 0    # 公开变量
       
          def count(self):
              self.__secretCount += 1
              self.publicCount += 1
              print (self.__secretCount)
       
      counter = JustCounter()
      counter.count()
      counter.count()
      print (counter.publicCount)
      print (counter.__secretCount)  # 报错,实例不能访问私有变量

      1
      2
      2
      Traceback (most recent call last):
        File "test.py", line 16, in
          print (counter.__secretCount)  # 报错,实例不能访问私有变量
      AttributeError: 'JustCounter' object has no attribute '__secretCount'

       私有化

      Python中的私有,事实上是不存在的,只是对私有的属性或者方法进行重名,将__属性  改名为  __类名__ 属性

      你可能感兴趣的:(学习,python,笔记)