python基础

python文件

• open(r'path/filename','mode')返回一个stream，stream.close()关闭流的通道，释放资源
  若使用with open ('path/filename') as stream与stream = open(…)等效，with的方法可以直接释放资源
• mode=r方法read直接读取stream中的所有内容，readline按行读取stream中的内容，一次读取一行，并且换行，readlines按行读取，将读取的内容放到列表中去，readable判断其中的内容是否能够读取(注意：open将内容读取带stream中后，按照其中的stream中一个个读取)
  其中mode的方法如下，默认为rt的模式，图片，影音等可以用rb的方式进行读取
  
• mode = w方法write为覆盖的写法，writelines可以将可迭代的内容写到文件中去；
• mode = a，可继续使用上面的方法，但不覆盖原来的内容
• 利用os模块进行path拼接使用os.path.join，其中os.path模块的使用还有很多，都是关于文件操作的。

  # 复制图片
  with open(r'C:\Users\25148\Pictures\Saved Pictures\设计.jpg', 'rb') as stream:
  continer = stream.read()
  with open(r'C:\Users\25148\Desktop\12.jpg','wb') as wstream:
     wstream.write(continer)
  print('have done')
  # os.path.dirname(__file__) 返回当前文件的文件绝对路径
  # os.path.join(path,'字符串')路径拼接
  # 文件复制
  import os
  
  src_path = r'D:\p'
  target_path = r'D:\w'
  
  
  def copy (src, target):
      filelist = os.listdir(src)
      for file in filelist:
          # 拼接路径
          path = os.path.join(src, file)
          # 判断路径是文件还是文件夹
          if os.path.isdir(path):
              target_path1 = os.path.join(target, file)
              os.mkdir(target_path1)
              copy(path, target_path1)
          else:
              # 不是文件夹直接进行复制
              with open(path, 'rb') as rstream:
                  container = rstream.read()
                  path2 = os.path.join(target, file)
                  with open(path2, 'wb') as wstream:
                      wstream.write(container)
      else:
          print('复制完成')
  copy(src_path, target_path)
  

异常处理机制

• 异常机制try...except...[else...][finally...]except需要加入可能出现得error，使其进入该except而不报错而进入异常内容；else后内容是try的运行不报错时执行；finally后内容是无论是否出现异常都会执行；rasie手动抛出异常，利用Exception接异常
• except后可能会出现很多异常，像Exception这种大的异常类需要放在所以小异常类的下方，否则小的异常类将无法实现；
  使用except Exception as err print(err)将会打印出该异常
  如：若输入为两个数，需要进行运算，则可能出现两种情况得错误
  1. 输入得字符并非数字，而是一些其它得字符
  2. 在运算除法的时候，可能会除以0，而导致结果无法输入
     （可以使用如下的except进行异常处理，需要报名其except的错误）
     

生成器

• 推导式，集合也能用{x for x in [1 , 2 , 3 , 1 , 2]}={ 1,2,3 }；字典也能用{value:key for key value in dict1.items() }（用于交换key，value的值），大佬写法dict(zip(dict1.values(), dict1.keys()))
• 生成器是通过列表推导式产生很大的len(list)很大的列表，但是受到内存的限制，列表容量有限，且一旦创建很多元素的列表会占用很大的空间，若我们需要访问前几个元素，那后面的元素占用的空间就拜拜浪费了；我们可以使用生成器(type=generator)，利用列表推导式的循环机制，将元素逐个进行获取
  eg：

  g = (x * 3 for x in range(10))  # type(g) == <class 'generator'>
  # 两种方式可以对生成器中的内容元素获取
  g.__next__()   # 0
  next(g)  # 3
  next(g)  # 6
  

• 在函数中，若使用yield将会使函数变为生成器的类型，其作用相当于return + 暂停；
  eg：

  def fib (length):		# 实现斐波那契数列的打印
      a, b = 0, 1
      n = 0
      while n < length:
          yield b		# return b +  暂停于此，一旦下次调用next，将从此处向下内容执行
          a, b = b, a + b
          n += 1
      return "所输入长度已经计算完毕"
  
  g = fib(5)
  print(g.__next__())
  print(next(g))
  print(g.__next__())
  print(next(g))
  print(g.__next__())
  # print(next(g))  若打印则会出现错误
  def gen ():
      i = 0
      while i < 5:
          temp = yield i
          for i in range(temp):
              print('---->', i)
          i += 1
      return '没有数据进行处理了'	
  g = gen()
  print(g.send(None))
  print(g.send(3))
  print(g.send(5)) # 会出现报错"没有数据进行处理了"
  # 结果如下
  '''
  0
  ----> 0
  ----> 1
  ----> 2
  3
  ----> 0
  ----> 1
  ----> 2
  ----> 3
  ----> 4
  '''
  # 利用生成器对两个执行的函数进行同步工作
  def task1 (n):
      for i in range(n):
          print('正在搬第{}块砖'.format(i))
          yield None
  
  def task2 (n):
      for i in range(n):
          print('正在听第{}首歌'.format(i))
          yield None
  	
  g1 = task1(5)
  g2 = task2(5)
  while True:
      try:
          g1.__next__()
          g2.__next__()
      except:
          print('工作完毕')
          break
  

• 迭代器，生成器都是迭代器；迭代器是从一个记住扁你位置的对象，从第一个元素开始访问，直到都被访问。
  可以被next()函数调用，并不断返回下一个值的对象称为迭代器：Iterator。可迭代的对象经过iter()将其变为迭代器，其访问时通过next来调用

类与对象

可调用对象（callable），我们平时自定义的函数、内置函数和类都属于可调用对象，但凡是可以把一对括号()应用到某个对象身上都可称之为可调用对象，判断对象是否为可调用对象可以用函数 callable；eg：max()

• dir()函数不带参数时，返回当前范围内的变量、方法和定义的类型列表；带参数时，返回参数的属性、方法列表。如果参数包含方法__dir__()，该方法将被调用。如果参数不包含__dir__()，该方法将最大限度地收集参数信息
• python的类方法：默认参数为(cls)，需要使用@classmethod进行修饰，可以通过类名直接调用，也可以通过对象进行调用(不推荐)
• python静态方法， 同函数一样，只不过是定义在class中，为类名空间的一部分，用@staticmethod来进行修饰，类与对象都能对它进行调用
• python使用类的调用实例方法eg

  class CLanguage:
  def info(self):
      print("我正在学 Python")
  #通过类名直接调用实例方法
  CLanguage.info()
  '''
  Traceback (most recent call last):
  File "D:\python3.6\demo.py", line 5, in <module>
  CLanguage.info()
  TypeError: info() missing 1 required positional argument: 'self'
  其中，最后一行报错信息提示我们，调用 info() 类方式时缺少给 self 参数传参。这意味着，和使用类对象调用实例方法不同，通过类名直接调用实例方法时，Python 并不会自动给 self 参数传值。
  '''
  #通过类名直接调用实例方法
  CLanguage.info(clang)
  #通过类名直接调用实例方法
  CLanguage.info(clang)
  

魔术方法

魔术方法在类或对象的某些事件出发后会自动执行，让类具有神奇的“魔力”。如果希望根据自己的程序定制自己特殊功能的类，那么就需要对这些方法进行重写。

• __init__：所有类都有一个名为 init() 的函数，该函数总是在类启动时执行,在对象创建时自动调用。
  使用 __init__() 函数将值分配给对象属性，或在创建对象时需要执行的其他操作。
• __new__：此方法比较复杂,，其主要为实例化对象开辟一个空间，接着才实现__init__的方法，其主要调用super().__new__的方法，一般情况下不去重写该方法.
• __call__：一旦在类中实现了该方法，那么该类所创建的对象将会成为可调用对象

  	a = A()
  print(callable(a))  # True 判断是不是可调用对象
  
  class GDistance:
  def __init__(self, g):
      self.g = g
  def __call__(self, t):
      # 自由落体下降距离 s=g*t^2
      return (self.g * t ** 2)/2
  e_gdist = GDistance(9.8)
  for t in range(11):
      print("%d 秒 下降%.2f 米" %(t, e_gdist(t))) ## 将实例化对象直接当函数用
  '''
  # 输出如下
   0 秒 下降0.00 米
  1 秒 下降4.90 米
  2 秒 下降19.60 米
  3 秒 下降44.10 米
  4 秒 下降78.40 米
  5 秒 下降122.50 米
  6 秒 下降176.40 米
  7 秒 下降240.10 米
  8 秒 下降313.60 米
  9 秒 下降396.90 米
  10 秒 下降490.00 米
  '''
  

• __del__：用于销毁对象，清除所占用的空间，使用sys.getrefcount(对象)可以查看该对象所引用的个数，其中该方法也算一次，引用只有引用计数 == 0时，__del__()才会被执行，同样一般情况下不去重写该方法.
• __str__：打印一个实例化对象时，打印的其实时一个对象的地址。而通过__str__()函数就可以帮助我们打印对象中具体的属性值，或者你想得到的东西。
• 装饰器@property可以直接通过方法名来访问类中的普通方法，不需要在方法名后添加一对“（）”小括号。 （http://c.biancheng.net/view/4561.html<—装饰器介绍）
  主要用于私有属性的访问，首先修饰的一般为类似java中的可以获取所有变量值，接着使用所修饰方法的@方法名.setter进行类似java中set为类中可以修改所有变量的方法

设计模式~单例模式

• 设计模式
  
  设计模式社死前任工作的总结和提炼，针对某一特定成熟的问题的解决方案
  
  提高代码的复用性，增强代码的可靠性

• 单例设计模式
  
  让类创建的对象，在内存中只有一钟实例
  
  每一次实例化生成一个对象，内存地址使相同的

  eg:一个系统中可以存在多个打印任务，但是只能有一个正在工作的任务；一个音乐播放器里可以播放很多音乐，但一次只能播放一首音乐

  需要使用__new__的方法，该方法为对象创建空间，并返回对象的引用到__init__方法

  class Player:
      __instance = None
      __flag = False
  
      def __new__ (cls, *args, **kwargs):
          print("new执行了")
          if cls.__instance is None: # 第一次为None，调用super的__new__方法，创建空间引用
              cls.__instance = object.__new__(cls)
          return cls.__instance # 之后就直接返回原来已经创建的空间引用
  
      def __init__ (self):
          if not Player.__flag: # init执行判断，和__new__一样，第一次执行，后面直接返回引用
              print('init被执行了')
              Player.__flag = True
  
  print(Player.mro()) 
  video = Player()
  print(video)
  music = Player()
  print(music)
  # 结果如下
  '''
  [<class '__main__.Player'>, <class 'object'>]
  new执行了
  init被执行了
  <__main__.Player object at 0x00000230127A30A0>
  new执行了
  <__main__.Player object at 0x00000230127A30A0>
  '''
  

模块

在模块中，使用__all__=[“类型”…]将会限定模块导的入，其导入只能位列表中的内容，在固定的文件中，其作用是限定访问类型，放置在__init__.py文件中，在直接导入包的时候，限定可导入的模块

• sys模块
  • sys.argv()，可以 接收来自外部的参数，返回的列表第一个值是脚本本身的路径
  • sys.exit()，退出当前程序，并返回SystemExit异常，(0)表示正常退出，(""程序退出)显示“程序退出“的提示信息。
  • sys.path()，返回文件搜索的路径的列表
• time模块
  • 时间主要分为三种表达形式，“元组，时间戳，格式化的时间”
  • 获取当前时间戳：time.time()；将时间直接转为字符串：time.ctime()；延迟执行该函数之下的代码seconds：time.sleep(seconds)

    '''
    元组形式--->time.struct_time(tm_year=2023, tm_mon=3, tm_mday=12, tm_hour=8, tm_min=5, tm_sec=48, tm_wday=6, tm_yday=71, tm_isdst=0)
    时间戳形式--->1678608418.4563084
    格式化形式--->2023-3-12
    '''
    

• datetime模块
  模块内容太多，后面可以慢慢看
  讲解传送阵
• random模块
  讲解传送阵
• hashlib模块
  讲解传送阵
• re模块
  讲解传送阵