zoukankan      html  css  js  c++  java
  • python常用模块

    模块,用一砣代码实现了某个功能的代码集合。 

    类似于函数式编程和面向过程编程,函数式编程则完成一个功能,其他代码用来调用即可,提供了代码的重用性和代码间的耦合。而对于一个复杂的功能来,可能需要多个函数才能完成(函数又可以在不同的.py文件中),n个 .py 文件组成的代码集合就称为模块。

    如:os 是系统相关的模块;file是文件操作相关的模块

    内置模块

    1、OS

    用于提供系统级别的操作

    os.getcwd() 获取当前工作目录,即当前python脚本工作的目录路径
    os.chdir("dirname")  改变当前脚本工作目录;相当于shell下cd
    os.curdir  返回当前目录: ('.')
    os.pardir  获取当前目录的父目录字符串名:('..')
    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.sep    输出操作系统特定的路径分隔符,win下为"\",Linux下为"/"
    os.linesep    输出当前平台使用的行终止符,win下为"	
    ",Linux下为"
    "
    os.pathsep    输出用于分割文件路径的字符串
    os.name    输出字符串指示当前使用平台。win->'nt'; Linux->'posix'
    os.system("bash command")  运行shell命令,直接显示
    os.environ  获取系统环境变量
    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所指向的文件或者目录的最后修改时间
    更多模块访问:https://docs.python.org/2/library/os.html?highlight=os#module-os
    
    
    二、sys
    用于提供对解释器相关的操作
    sys.argv           命令行参数List,第一个元素是程序本身路径
    sys.exit(n)        退出程序,正常退出时exit(0)
    sys.version        获取Python解释程序的版本信息
    sys.maxint         最大的Int值
    sys.path           返回模块的搜索路径,初始化时使用PYTHONPATH环境变量的值
    sys.platform       返回操作系统平台名称
    sys.stdout.write('please:')
    val = sys.stdin.readline()[:-1]
    
    
    三、hashlib
    用于加密相关的操作,代替了md5模块和sha模块,主要提供SHA1,SHA224,SHA256,SHA384,SHA512,MD5算法
    
    
    废弃
    MD5
    import md5
    hash = md5.new()
    hash.update('admin')
    print hash.hexdigest()
    
    
    SHA
    import sha
    
    hash = sha.new()
    hash.update('admin')
    print hash.hexdigest()
    
    
    import hashlib
     
    # ######## md5 ########
     
    hash = hashlib.md5()
    hash.update('admin')
    print hash.hexdigest()
     
    # ######## sha1 ########
     
    hash = hashlib.sha1()
    hash.update('admin')
    print hash.hexdigest()
     
    # ######## sha256 ########
     
    hash = hashlib.sha256()
    hash.update('admin')
    print hash.hexdigest()
     
     
    # ######## sha384 ########
     
    hash = hashlib.sha384()
    hash.update('admin')
    print hash.hexdigest()
     
    # ######## sha512 ########
     
    hash = hashlib.sha512()
    hash.update('admin')
    print hash.hexdigest()
     
    以上加密算法虽然依然非常厉害,但时候存在缺陷,即:通过撞库可以反解。所以,有必要对加密算法中添加自定义key再来做加密。
    import hashlib
     
    # ######## md5 ########
     
    hash = hashlib.md5('898oaFs09f')
    hash.update('admin')
    print hash.hexdigest()
     
    还不够吊?python 还有一个 hmac 模块,它内部对我们创建 key 和 内容 再进行处理然后再加密
    import hmac
    h = hmac.new('wueiqi')
    h.update('hellowo')
    print h.hexdigest()
     
    四、json和pickle

    用于序列化的两个模块

    • json,用于字符串 和 python数据类型间进行转换
    • pickle,用于python特有的类型 和 python的数据类型间进行转换

    Json模块提供了四个功能:dumps、dump、loads、load

    pickle模块提供了四个功能:dumps、dump、loads、load

    例:

    import pickle

    data = {‘k1’:123,’k2’:Hello}

    #pickle.dumps 将数据通过特殊的形式转换为只有python语言认识的字符串

    p_str =pickle.dumps(data)

    print(p_str)

    #pickle.dump将数据通过特殊的形式转换为只有python语言认识的字符串,并写入文件

    with open(‘D: esult.pk’,’w’) as fp:

    pickle.dump(data,fp)

    import json

    #json.dumps将数据通过特殊的形式转换为所有程序语言都认识的字符串

    j_str = json.dumps(data)

    print(j_str)

    #json.dump将数据通过特殊的形式转换为所有程序语言都认识的字符串,并写入文件
    with open(‘D: esult.json’,’w’) as fp:
    json.dump(data,fp)
     
    五、执行系统命令
    可以执行shell命令的相关模块和函数有:
     
    • os.system
    • os.spawn*
    • os.popen*          --废弃
    • popen2.*           --废弃
    • commands.*      --废弃,3.x中被移除
    • 
      
      import commands
      result = commands.getoutput('cmd')
      result = commands.getstatus('cmd')
      result = commands.getstatusoutput('cmd’)
      以上执行shell命令的相关的模块和函数的功能均在 subprocess 模块中实现,并提供了更丰富的功能。

      call 

      执行命令,返回状态码

      1
      2
      ret = subprocess.call(["ls", "-l"], shell=False)
      ret = subprocess.call("ls -l", shell=True)

      shell = True ,允许 shell 命令是字符串形式

      check_call

      执行命令,如果执行状态码是 0 ,则返回0,否则抛异常

      1
      2
      subprocess.check_call(["ls", "-l"])
      subprocess.check_call("exit 1", shell=True)

      check_output

      执行命令,如果状态码是 0 ,则返回执行结果,否则抛异常

      1
      2
      subprocess.check_output(["echo", "Hello World!"])
      subprocess.check_output("exit 1", shell=True)

      subprocess.Popen(...)

      用于执行复杂的系统命令

      参数:

      • args:shell命令,可以是字符串或者序列类型(如:list,元组)
      • bufsize:指定缓冲。0 无缓冲,1 行缓冲,其他 缓冲区大小,负值 系统缓冲
      • stdin, stdout, stderr:分别表示程序的标准输入、输出、错误句柄
      • preexec_fn:只在Unix平台下有效,用于指定一个可执行对象(callable object),它将在子进程运行之前被调用
      • close_sfs:在windows平台下,如果close_fds被设置为True,则新创建的子进程将不会继承父进程的输入、输出、错误管道。
        所以不能将close_fds设置为True同时重定向子进程的标准输入、输出与错误(stdin, stdout, stderr)。
      • shell:同上
      • cwd:用于设置子进程的当前目录
      • env:用于指定子进程的环境变量。如果env = None,子进程的环境变量将从父进程中继承。
      • universal_newlines:不同系统的换行符不同,True -> 同意使用
      • startupinfo与createionflags只在windows下有效
        将被传递给底层的CreateProcess()函数,用于设置子进程的一些属性,如:主窗口的外观,进程的优先级等等
       
      import subprocess
      ret1 = subprocess.Popen(["mkdir","t1"])
      ret2 = subprocess.Popen("mkdir t2", shell=True)
      
      

      终端输入的命令分为两种:

      • 输入即可得到输出,如:ifconfig
      • 输入进行某环境,依赖再输入,如:python
       
      代码1
      import subprocess
      obj = subprocess.Popen("mkdir t3", shell=True, cwd='/home/dev’,)
      
      
      代码2
      import subprocess
      
      obj = subprocess.Popen(["python"], stdin=subprocess.PIPE, stdout=subprocess.PIPE, stderr=subprocess.PIPE)
      obj.stdin.write('print 1 
       ')
      obj.stdin.write('print 2 
       ')
      obj.stdin.write('print 3 
       ')
      obj.stdin.write('print 4 
       ')
      obj.stdin.close()
      
      cmd_out = obj.stdout.read()
      obj.stdout.close()
      cmd_error = obj.stderr.read()
      obj.stderr.close()
      
      代码三
      print cmd_out
      print cmd_error
      
      
      import subprocess
      
      obj = subprocess.Popen(["python"], stdin=subprocess.PIPE, stdout=subprocess.PIPE, stderr=subprocess.PIPE)
      obj.stdin.write('print 1 
       ')
      obj.stdin.write('print 2 
       ')
      obj.stdin.write('print 3 
       ')
      obj.stdin.write('print 4 
       ')
      
      out_error_list = obj.communicate()
      print out_error_list
      
      
      代码四
      import subprocess
      
      obj = subprocess.Popen(["python"], stdin=subprocess.PIPE, stdout=subprocess.PIPE, stderr=subprocess.PIPE)
      out_error_list = obj.communicate('print "hello"')
      print out_error_list
      
      
      更多在这里:https://docs.python.org/2/library/subprocess.html?highlight=subprocess#frequently-used-arguments
      
      
      六、shutil

      高级的 文件、文件夹、压缩包 处理模块

      shutil.copyfileobj(fsrc, fdst[, length])
      将文件内容拷贝到另一个文件中,可以部分内容

      def copyfileobj(fsrc, fdst, length=16*1024):
          """copy data from file-like object fsrc to file-like object fdst"""
          while 1:
              buf = fsrc.read(length)
              if not buf:
                  break
              fdst.write(buf)
      shutil.copyfile(src, dst)
      拷贝文件
      def copyfile(src, dst):
          """Copy data from src to dst"""
          if _samefile(src, dst):
              raise Error("`%s` and `%s` are the same file" % (src, dst))
      
          for fn in [src, dst]:
              try:
                  st = os.stat(fn)
              except OSError:
                  # File most likely does not exist
                  pass
              else:
                  # XXX What about other special files? (sockets, devices...)
                  if stat.S_ISFIFO(st.st_mode):
                      raise SpecialFileError("`%s` is a named pipe" % fn)
      
          with open(src, 'rb') as fsrc:
              with open(dst, 'wb') as fdst:
                  copyfileobj(fsrc, fdst)
      
      
      shutil.copymode(src, dst)
      仅拷贝权限。内容、组、用户均不变
      def copymode(src, dst):
          """Copy mode bits from src to dst"""
          if hasattr(os, 'chmod'):
              st = os.stat(src)
              mode = stat.S_IMODE(st.st_mode)
              os.chmod(dst, mode)
      
      
      shutil.copystat(src, dst)
      拷贝状态的信息,包括:mode bits, atime, mtime, flags
      def copystat(src, dst):
          """Copy all stat info (mode bits, atime, mtime, flags) from src to dst"""
          st = os.stat(src)
          mode = stat.S_IMODE(st.st_mode)
          if hasattr(os, 'utime'):
              os.utime(dst, (st.st_atime, st.st_mtime))
          if hasattr(os, 'chmod'):
              os.chmod(dst, mode)
          if hasattr(os, 'chflags') and hasattr(st, 'st_flags'):
              try:
                  os.chflags(dst, st.st_flags)
              except OSError, why:
                  for err in 'EOPNOTSUPP', 'ENOTSUP':
                      if hasattr(errno, err) and why.errno == getattr(errno, err):
                          break
                  else:
                      raise
      
      
      shutil.copy(src, dst)
      拷贝文件和权限
      def copy(src, dst):
          """Copy data and mode bits ("cp src dst").
      
          The destination may be a directory.
      
          """
          if os.path.isdir(dst):
              dst = os.path.join(dst, os.path.basename(src))
          copyfile(src, dst)
          copymode(src, dst)
      
      
      shutil.copy2(src, dst)
      拷贝文件和状态信息
      def copy2(src, dst):
          """Copy data and all stat info ("cp -p src dst").
      
          The destination may be a directory.
      
          """
          if os.path.isdir(dst):
              dst = os.path.join(dst, os.path.basename(src))
          copyfile(src, dst)
          copystat(src, dst)
      
      

      shutil.ignore_patterns(*patterns)
      shutil.copytree(src, dst, symlinks=False, ignore=None)
      递归的去拷贝文件

      例如:copytree(source, destination, ignore=ignore_patterns('*.pyc', 'tmp*’))

      def ignore_patterns(*patterns):
          """Function that can be used as copytree() ignore parameter.
      
          Patterns is a sequence of glob-style patterns
          that are used to exclude files"""
          def _ignore_patterns(path, names):
              ignored_names = []
              for pattern in patterns:
                  ignored_names.extend(fnmatch.filter(names, pattern))
              return set(ignored_names)
          return _ignore_patterns
      
      def copytree(src, dst, symlinks=False, ignore=None):
          """Recursively copy a directory tree using copy2().
      
          The destination directory must not already exist.
          If exception(s) occur, an Error is raised with a list of reasons.
      
          If the optional symlinks flag is true, symbolic links in the
          source tree result in symbolic links in the destination tree; if
          it is false, the contents of the files pointed to by symbolic
          links are copied.
      
          The optional ignore argument is a callable. If given, it
          is called with the `src` parameter, which is the directory
          being visited by copytree(), and `names` which is the list of
          `src` contents, as returned by os.listdir():
      
              callable(src, names) -> ignored_names
      
          Since copytree() is called recursively, the callable will be
          called once for each directory that is copied. It returns a
          list of names relative to the `src` directory that should
          not be copied.
      
          XXX Consider this example code rather than the ultimate tool.
      
          """
          names = os.listdir(src)
          if ignore is not None:
              ignored_names = ignore(src, names)
          else:
              ignored_names = set()
      
          os.makedirs(dst)
          errors = []
          for name in names:
              if name in ignored_names:
                  continue
              srcname = os.path.join(src, name)
              dstname = os.path.join(dst, name)
              try:
                  if symlinks and os.path.islink(srcname):
                      linkto = os.readlink(srcname)
                      os.symlink(linkto, dstname)
                  elif os.path.isdir(srcname):
                      copytree(srcname, dstname, symlinks, ignore)
                  else:
                      # Will raise a SpecialFileError for unsupported file types
                      copy2(srcname, dstname)
              # catch the Error from the recursive copytree so that we can
              # continue with other files
              except Error, err:
                  errors.extend(err.args[0])
              except EnvironmentError, why:
                  errors.append((srcname, dstname, str(why)))
          try:
              copystat(src, dst)
          except OSError, why:
              if WindowsError is not None and isinstance(why, WindowsError):
                  # Copying file access times may fail on Windows
                  pass
              else:
                  errors.append((src, dst, str(why)))
          if errors:
              raise Error, errors
      
      
      shutil.rmtree(path[, ignore_errors[, onerror]])
      递归的去删除文件
      def rmtree(path, ignore_errors=False, onerror=None):
          """Recursively delete a directory tree.
      
          If ignore_errors is set, errors are ignored; otherwise, if onerror
          is set, it is called to handle the error with arguments (func,
          path, exc_info) where func is os.listdir, os.remove, or os.rmdir;
          path is the argument to that function that caused it to fail; and
          exc_info is a tuple returned by sys.exc_info().  If ignore_errors
          is false and onerror is None, an exception is raised.
      
          """
          if ignore_errors:
              def onerror(*args):
                  pass
          elif onerror is None:
              def onerror(*args):
                  raise
          try:
              if os.path.islink(path):
                  # symlinks to directories are forbidden, see bug #1669
                  raise OSError("Cannot call rmtree on a symbolic link")
          except OSError:
              onerror(os.path.islink, path, sys.exc_info())
              # can't continue even if onerror hook returns
              return
          names = []
          try:
              names = os.listdir(path)
          except os.error, err:
              onerror(os.listdir, path, sys.exc_info())
          for name in names:
              fullname = os.path.join(path, name)
              try:
                  mode = os.lstat(fullname).st_mode
              except os.error:
                  mode = 0
              if stat.S_ISDIR(mode):
                  rmtree(fullname, ignore_errors, onerror)
              else:
                  try:
                      os.remove(fullname)
                  except os.error, err:
                      onerror(os.remove, fullname, sys.exc_info())
          try:
              os.rmdir(path)
          except os.error:
              onerror(os.rmdir, path, sys.exc_info())
      
      
      shutil.move(src, dst)
      递归的去移动文件
      def move(src, dst):
          """Recursively move a file or directory to another location. This is
          similar to the Unix "mv" command.
      
          If the destination is a directory or a symlink to a directory, the source
          is moved inside the directory. The destination path must not already
          exist.
      
          If the destination already exists but is not a directory, it may be
          overwritten depending on os.rename() semantics.
      
          If the destination is on our current filesystem, then rename() is used.
          Otherwise, src is copied to the destination and then removed.
          A lot more could be done here...  A look at a mv.c shows a lot of
          the issues this implementation glosses over.
      
          """
          real_dst = dst
          if os.path.isdir(dst):
              if _samefile(src, dst):
                  # We might be on a case insensitive filesystem,
                  # perform the rename anyway.
                  os.rename(src, dst)
                  return
      
              real_dst = os.path.join(dst, _basename(src))
              if os.path.exists(real_dst):
                  raise Error, "Destination path '%s' already exists" % real_dst
          try:
              os.rename(src, real_dst)
          except OSError:
              if os.path.isdir(src):
                  if _destinsrc(src, dst):
                      raise Error, "Cannot move a directory '%s' into itself '%s'." % (src, dst)
                  copytree(src, real_dst, symlinks=True)
                  rmtree(src)
              else:
                  copy2(src, real_dst)
                  os.unlink(src)
      
      

      shutil.make_archive(base_name, format,...)

      创建压缩包并返回文件路径,例如:zip、tar

      • base_name: 压缩包的文件名,也可以是压缩包的路径。只是文件名时,则保存至当前目录,否则保存至指定路径,
        如:www                        =>保存至当前路径
        如:/Users/wupeiqi/www =>保存至/Users/wupeiqi/
      • format: 压缩包种类,“zip”, “tar”, “bztar”,“gztar”
      • root_dir: 要压缩的文件夹路径(默认当前目录)
      • owner: 用户,默认当前用户
      • group: 组,默认当前组
      • logger: 用于记录日志,通常是logging.Logger对象
       
      #将 /Users/wupeiqi/Downloads/test 下的文件打包放置当前程序目录
       
      import shutil
      ret = shutil.make_archive("wwwwwwwwww", 'gztar', root_dir='/Users/wupeiqi/Downloads/test')
       
       
      #将 /Users/wupeiqi/Downloads/test 下的文件打包放置 /Users/wupeiqi/目录
      import shutil
      ret = shutil.make_archive("/Users/wupeiqi/wwwwwwwwww", 'gztar', root_dir='/Users/wupeiqi/Downloads/test’)
       
       
      代码案例:
      def make_archive(base_name, format, root_dir=None, base_dir=None, verbose=0,
                       dry_run=0, owner=None, group=None, logger=None):
          """Create an archive file (eg. zip or tar).
      
          'base_name' is the name of the file to create, minus any format-specific
          extension; 'format' is the archive format: one of "zip", "tar", "bztar"
          or "gztar".
      
          'root_dir' is a directory that will be the root directory of the
          archive; ie. we typically chdir into 'root_dir' before creating the
          archive.  'base_dir' is the directory where we start archiving from;
          ie. 'base_dir' will be the common prefix of all files and
          directories in the archive.  'root_dir' and 'base_dir' both default
          to the current directory.  Returns the name of the archive file.
      
          'owner' and 'group' are used when creating a tar archive. By default,
          uses the current owner and group.
          """
          save_cwd = os.getcwd()
          if root_dir is not None:
              if logger is not None:
                  logger.debug("changing into '%s'", root_dir)
              base_name = os.path.abspath(base_name)
              if not dry_run:
                  os.chdir(root_dir)
      
          if base_dir is None:
              base_dir = os.curdir
      
          kwargs = {'dry_run': dry_run, 'logger': logger}
      
          try:
              format_info = _ARCHIVE_FORMATS[format]
          except KeyError:
              raise ValueError, "unknown archive format '%s'" % format
      
          func = format_info[0]
          for arg, val in format_info[1]:
              kwargs[arg] = val
      
          if format != 'zip':
              kwargs['owner'] = owner
              kwargs['group'] = group
      
          try:
              filename = func(base_name, base_dir, **kwargs)
          finally:
              if root_dir is not None:
                  if logger is not None:
                      logger.debug("changing back to '%s'", save_cwd)
                  os.chdir(save_cwd)
      
          return filename
      
      
      shutil 对压缩包的处理是调用 ZipFile 和 TarFile 两个模块来进行的,详细:
      import zipfile
      
      zipfile压缩解压
      # 压缩
      z = zipfile.ZipFile('laxi.zip', 'w')
      z.write('a.log')
      z.write('data.data')
      z.close()
      
      # 解压
      z = zipfile.ZipFile('laxi.zip', 'r')
      z.extractall()
      z.close()
      
      
      tarfile压缩解压
      import tarfile
      
      # 压缩
      tar = tarfile.open('your.tar','w')
      tar.add('/Users/wupeiqi/PycharmProjects/bbs2.zip', arcname='bbs2.zip')
      tar.add('/Users/wupeiqi/PycharmProjects/cmdb.zip', arcname='cmdb.zip')
      tar.close()
      
      # 解压
      tar = tarfile.open('your.tar','r')
      tar.extractall()  # 可设置解压地址
      tar.close()
      
      
      七、ConfigParser
      
      
      用于对特定的配置进行操作,当前模块的名称在 python 3.x 版本中变更为 configparser。
      import ConfigParser
       
      config = ConfigParser.ConfigParser()
      config.read('i.cfg')
       
      # ########## 读 ##########
      #secs = config.sections()
      #print secs
      #options = config.options('group2')
      #print options
       
      #item_list = config.items('group2')
      #print item_list
       
      #val = config.get('group1','key')
      #val = config.getint('group1','key')
       
      # ########## 改写 ##########
      #sec = config.remove_section('group1')
      #config.write(open('i.cfg', "w"))
       
      #sec = config.has_section('wupeiqi')
      #sec = config.add_section('wupeiqi')
      #config.write(open('i.cfg', "w"))
       
       
      #config.set('group2','k1',11111)
      #config.write(open('i.cfg', "w"))
       
      #config.remove_option('group2','age')
      #config.write(open('i.cfg', "w”))
       
      八、logging
       

      用于便捷记录日志且线程安全的模块

      1
      2
      3
      4
      5
      6
      7
      8
      9
      10
      11
      12
      13
      14
      import logging
       
       
      logging.basicConfig(filename='log.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('warning')
      logging.error('error')
      logging.critical('critical')
      logging.log(10,'log')

      对于等级:

      1
      2
      3
      4
      5
      6
      7
      8
      CRITICAL = 50
      FATAL = CRITICAL
      ERROR = 40
      WARNING = 30
      WARN = WARNING
      INFO = 20
      DEBUG = 10
      NOTSET = 0

      只有大于当前日志等级的操作才会被记录。

      对于格式,有如下属性可是配置:

       

      九、time

      时间相关的操作,时间有三种表示方式:

      • 时间戳               1970年1月1日之后的秒,即:time.time()
      • 格式化的字符串    2014-11-11 11:11,    即:time.strftime('%Y-%m-%d')
      • 结构化时间          元组包含了:年、日、星期等... time.struct_time    即:time.localtime()
      print time.time()
      print time.mktime(time.localtime())
        
      print time.gmtime()    #可加时间戳参数
      print time.localtime() #可加时间戳参数
      print time.strptime('2014-11-11''%Y-%m-%d')
        
      print time.strftime('%Y-%m-%d'#默认当前时间
      print time.strftime('%Y-%m-%d',time.localtime()) #默认当前时间
      print time.asctime()
      print time.asctime(time.localtime())
      print time.ctime(time.time())
        
      import datetime
      '''
      datetime.date:表示日期的类。常用的属性有year, month, day
      datetime.time:表示时间的类。常用的属性有hour, minute, second, microsecond
      datetime.datetime:表示日期时间
      datetime.timedelta:表示时间间隔,即两个时间点之间的长度
      timedelta([days[, seconds[, microseconds[, milliseconds[, minutes[, hours[, weeks]]]]]]])
      strftime("%Y-%m-%d")
      '''
      import datetime
      print datetime.datetime.now()
      print datetime.datetime.now() - datetime.timedelta(days=5)
       
       

      十、re 

      re模块用于对python的正则表达式的操作。

      字符:

        . 匹配除换行符以外的任意字符
        w 匹配字母或数字或下划线或汉字
        s 匹配任意的空白符
        d 匹配数字
         匹配单词的开始或结束
        ^ 匹配字符串的开始
        $ 匹配字符串的结束

      次数:

        * 重复零次或更多次
        + 重复一次或更多次
        ? 重复零次或一次
        {n} 重复n次
        {n,} 重复n次或更多次
        {n,m} 重复n到m次

      IP:
      ^(25[0-5]|2[0-4]d|[0-1]?d?d)(.(25[0-5]|2[0-4]d|[0-1]?d?d)){3}$
      手机号:
      ^1[3|4|5|8][0-9]d{8}$

      1、match(pattern, string, flags=0)

      从起始位置开始根据模型去字符串中匹配指定内容,匹配单个

      • 正则表达式
      • 要匹配的字符串
      • 标志位,用于控制正则表达式的匹配方式
      import re
      
      obj = re.match('d+', '123uuasf')
      if obj:
          print obj.group()

      2、search(pattern, string, flags=0)

      根据模型去字符串中匹配指定内容,匹配单个

      import re
      
      obj = re.search('d+', 'u123uu888asf')
      if obj:
          print obj.group()

      3、group和groups

      复制代码
      a = "123abc456"
      print re.search("([0-9]*)([a-z]*)([0-9]*)", a).group()
      
      print re.search("([0-9]*)([a-z]*)([0-9]*)", a).group(0)
      print re.search("([0-9]*)([a-z]*)([0-9]*)", a).group(1)
      print re.search("([0-9]*)([a-z]*)([0-9]*)", a).group(2)
      
      print re.search("([0-9]*)([a-z]*)([0-9]*)", a).groups()
      复制代码

      4、findall(pattern, string, flags=0)

      上述两中方式均用于匹配单值,即:只能匹配字符串中的一个,如果想要匹配到字符串中所有符合条件的元素,则需要使用 findall。

      import re
      
      obj = re.findall('d+', 'fa123uu888asf')
      print obj

      5、sub(pattern, repl, string, count=0, flags=0)

      用于替换匹配的字符串

      content = "123abc456"
      new_content = re.sub('d+', 'sb', content)
      # new_content = re.sub('d+', 'sb', content, 1)
      print new_content

      相比于str.replace功能更加强大

      6、split(pattern, string, maxsplit=0, flags=0)

      根据指定匹配进行分组

      content = "'1 - 2 * ((60-30+1*(9-2*5/3+7/3*99/4*2998+10*568/14))-(-4*3)/(16-3*2) )'"
      new_content = re.split('*', content)
      # new_content = re.split('*', content, 1)
      print new_content
      content = "'1 - 2 * ((60-30+1*(9-2*5/3+7/3*99/4*2998+10*568/14))-(-4*3)/(16-3*2) )'"
      new_content = re.split('[+-*/]+', content)
      # new_content = re.split('*', content, 1)
      print new_content
      inpp = '1-2*((60-30 +(-40-5)*(9-2*5/3 + 7 /3*99/4*2998 +10 * 568/14 )) - (-4*3)/ (16-3*2))'
      inpp = re.sub('s*','',inpp)
      new_content = re.split('(([+-*/]?d+[+-*/]?d+){1})', inpp, 1)
      print new_content

      相比于str.split更加强大 

      计算器原码:http://www.cnblogs.com/wupeiqi/articles/4949995.html

      十一、random

      随机数

      mport random
      print random.random()
      print random.randint(1,2)
      print random.randrange(1,10)


      随机验证码实例:

      import random
      checkcode = ''
      for in range(4):
          current = random.randrange(0,4)
          if current != i:
              temp = chr(random.randint(65,90))
          else:
              temp = random.randint(0,9)
          checkcode += str(temp)
      print checkcode
       
      此文档采用:http://www.cnblogs.com/wupeiqi/articles/4963027.html
  • 相关阅读:
    容斥原理算法总结(bzoj 2986 2839)
    网络流系列算法总结(bzoj 3438 1061)
    bzoj 2746: [HEOI2012]旅行问题 AC自动机fail树
    bzoj 3283: 运算器 扩展Baby Step Giant Step && 快速阶乘
    计算几何考场绘图技巧
    bzoj 1845: [Cqoi2005] 三角形面积并 扫描线
    bzoj 3784: 树上的路径 堆维护第k大
    BZOJ 1231: [Usaco2008 Nov]mixup2 混乱的奶牛
    BZOJ 1112: [POI2008]砖块Klo
    BZOJ 1003: [ZJOI2006]物流运输trans DP+最短路
  • 原文地址:https://www.cnblogs.com/TaleG/p/6685170.html
Copyright © 2011-2022 走看看