python函数大全及详解下载（python函数csdn）



hashlib加密

hashlib主要提供字符加密功能，将md5和sha模块整合到了一起，支持md5,sha1, sha224, sha256, sha384, sha512等算法

具体应用

#!/usr/bin/env python # -*- coding: UTF-8 -*- #pyversion:python3.5 #owner:fuzj 

import hashlib

# # md5 # string = "beyongjie"

md5 = hashlib.md5() md5.update(string.encode('utf-8')) #注意转码 res = md5.hexdigest() print("md5加密结果:",res)

# # sha1 # sha1 = hashlib.sha1() sha1.update(string.encode('utf-8')) res = sha1.hexdigest() print("sha1加密结果:",res)

# # sha256 # sha256 = hashlib.sha256() sha256.update(string.encode('utf-8')) res = sha256.hexdigest() print("sha256加密结果:",res)

# # sha384 # sha384 = hashlib.sha384() sha384.update(string.encode('utf-8')) res = sha384.hexdigest() print("sha384加密结果:",res)

# # sha512 # sha512= hashlib.sha512() sha512.update(string.encode('utf-8')) res = sha512.hexdigest() print("sha512加密结果:",res)

输出结果：

md5加密结果: 0e725eff4076f774dc312d4748 sha1加密结果: 458d32be8ea38bab0a8c0bf sha256加密结果: 1e62b55bfd0f885f6a0998af7cc9cfb95c8ac4a9f30ecccb7c05ec9f4 sha384加密结果: e91cdf0d2570de5c96ee84e8a12cddfe7a03b3ecfcd54b7f52183e20197cff7c07ff0ba4875b sha512加密结果: 3f0020a726e9c1cb5d22290c967f3dd1bcecb409a51a8088dbc876aaec3f17a70d7981cd575ed4b89471f743f3f24a146a39d59f215ae3e208d0

注意：hashlib 加密啊的字符串类型为二进制编码，直接加密字符串会报如下错误：

sha1 = hashlib.sha1() sha1.update(string) res = sha1.hexdigest() print("sha1加密结果:",res) 

TypeError: Unicode-objects must be encoded before hashing

可以使用encode进行转换

shaa1 = hashlib.sha1() shaa1.update(string.encode('utf-8')) res = shaa1.hexdigest() print("sha1采用encode转换加密结果:",res)

或者使用byte转换为二进制

shab1 = hashlib.sha1() shab1.update(bytes(string,encoding='utf-8')) res = shab1.hexdigest() print("sha1采用byte转换的结果:",res)

以上输出：

sha1采用encode转换加密结果: 458d32be8ea38bab0a8c0bf sha1采用byte转换的结果: 458d32be8ea38bab0a8c0bf

常用方法

• hash.update(arg) 更新哈希对象以字符串参数, 注意：如果同一个hash对象重复调用该方法，则m.update(a); m.update(b) 等效于 m.update(a+b)，看下面例子

m = hashlib.md5() m.update('a'.encode('utf-8')) res = m.hexdigest() print("第一次a加密:",res) 

m.update('b'.encode('utf-8')) res = m.hexdigest() print("第二次b加密:",res)

m1 = hashlib.md5() m1.update('b'.encode('utf-8')) res = m1.hexdigest() print("b单独加密:",res)

m2 = hashlib.md5() m2.update('ab'.encode('utf-8')) res = m2.hexdigest() print("ab单独加密:",res)

输出结果： 第一次a加密: 0cc175b9c0f1b6a831c399e 第二次b加密: 187efd1cc2f40dc2b92f0eba0 b单独加密: 92eb5ffee6ae2fec3ad71cf ab单独加密: 187efd1cc2f40dc2b92f0eba0

• hash.digest() 返回摘要，作为二进制数据字符串值,
• hash.hexdigest() 返回摘要，作为十六进制数据字符串值,
• hash.copy() 复制

高级加密

以上加密算法虽然依然非常厉害，但时候存在缺陷，即：通过撞库可以反解。所以，有必要对加密算法中添加自定义key再来做加密。

low = hashlib.md5() low.update('ab'.encode('utf-8')) res = low.hexdigest() print("普通加密:",res) 

high = hashlib.md5(b'beyondjie') high.update('ab'.encode('utf-8')) res = high.hexdigest() print("采用key加密:",res)

输出结果： 普通加密: 187efd1cc2f40dc2b92f0eba0 采用key加密: 1b073f6b8cffee4c98537b7653

附加HMAC-SHA1各语言版本实现

在各大开放平台大行其道的互联网开发潮流中，调用各平台的API接口过程中，无一例外都会用到计算签名值(sig值)。而在各种计算签名的方法中，经常被采用的就是HMAC-SHA1，现对HMAC-SHA1做一个简单的介绍： 

Token：即接口的key

data：要加密的数据

logging模块是Python内置的标准模块，主要用于输出运行日志，可以设置输出日志的等级、日志保存路径、日志文件回滚等；相比print，具备如下优点：

1. 可以通过设置不同的日志等级，在release版本中只输出重要信息，而不必显示大量的调试信息；
2. print将所有信息都输出到标准输出中，严重影响开发者从标准输出中查看其它数据；logging则可以由开发者决定将信息输出到什么地方，以及怎么输出；

配置logging基本的设置，然后在控制台输出日志，

import logging logging.basicConfig(level = logging.INFO,format = '%(asctime)s - %(name)s - %(levelname)s - %(message)s') logger = logging.getLogger(__name__) 

logger.info("Start print log") logger.debug("Do something") logger.warning("Something maybe fail.") logger.info("Finish")

运行时，控制台输出，

logging中可以选择很多消息级别，如debug、info、warning、error以及critical。通过赋予logger或者handler不同的级别，开发者就可以只输出错误信息到特定的记录文件，或者在调试时只记录调试信息。

例如，我们将logger的级别改为DEBUG，再观察一下输出结果，

logging.basicConfig(level = logging.DEBUG,format = '%(asctime)s - %(name)s - %(levelname)s - %(message)s')

控制台输出，可以发现，输出了debug的信息。

logging.basicConfig函数各参数：

filename：指定日志文件名；

filemode：和file函数意义相同，指定日志文件的打开模式，'w'或者'a'；

format：指定输出的格式和内容，format可以输出很多有用的信息，

datefmt：指定时间格式，同time.strftime()；

level：设置日志级别，默认为logging.WARNNING；

stream：指定将日志的输出流，可以指定输出到sys.stderr，sys.stdout或者文件，默认输出到sys.stderr，当stream和filename同时指定时，stream被忽略；

2.2.1 将日志写入到文件

设置logging，创建一个FileHandler，并对输出消息的格式进行设置，将其添加到logger，然后将日志写入到指定的文件中，

import logging logger = logging.getLogger(__name__) logger.setLevel(level = logging.INFO) handler = logging.FileHandler("log.txt") handler.setLevel(logging.INFO) formatter = logging.Formatter('%(asctime)s - %(name)s - %(levelname)s - %(message)s') handler.setFormatter(formatter) logger.addHandler(handler) 

logger.info("Start print log") logger.debug("Do something") logger.warning("Something maybe fail.") logger.info("Finish")

log.txt中日志数据为，

2.2.2 将日志同时输出到屏幕和日志文件

logger中添加StreamHandler，可以将日志输出到屏幕上，

import logging logger = logging.getLogger(__name__) logger.setLevel(level = logging.INFO) handler = logging.FileHandler("log.txt") handler.setLevel(logging.INFO) formatter = logging.Formatter('%(asctime)s - %(name)s - %(levelname)s - %(message)s') handler.setFormatter(formatter) 

console = logging.StreamHandler() console.setLevel(logging.INFO)

logger.addHandler(handler) logger.addHandler(console)

logger.info("Start print log") logger.debug("Do something") logger.warning("Something maybe fail.") logger.info("Finish")

可以在log.txt文件和控制台中看到，

可以发现，logging有一个日志处理的主对象，其他处理方式都是通过addHandler添加进去，logging中包含的handler主要有如下几种，

2.2.3 日志回滚

使用RotatingFileHandler，可以实现日志回滚，

import logging from logging.handlers import RotatingFileHandler logger = logging.getLogger(__name__) logger.setLevel(level = logging.INFO) #定义一个RotatingFileHandler，最多备份3个日志文件，每个日志文件最大1K rHandler = RotatingFileHandler("log.txt",maxBytes = 1*1024,backupCount = 3) rHandler.setLevel(logging.INFO) formatter = logging.Formatter('%(asctime)s - %(name)s - %(levelname)s - %(message)s') rHandler.setFormatter(formatter) 

console = logging.StreamHandler() console.setLevel(logging.INFO) console.setFormatter(formatter)

logger.addHandler(rHandler) logger.addHandler(console)

logger.info("Start print log") logger.debug("Do something") logger.warning("Something maybe fail.") logger.info("Finish")

可以在工程目录中看到，备份的日志文件，

可以设置不同的日志等级，用于控制日志的输出，

Python中的traceback模块被用于跟踪异常返回信息，可以在logging中记录下traceback，

代码，

import logging logger = logging.getLogger(__name__) logger.setLevel(level = logging.INFO) handler = logging.FileHandler("log.txt") handler.setLevel(logging.INFO) formatter = logging.Formatter('%(asctime)s - %(name)s - %(levelname)s - %(message)s') handler.setFormatter(formatter) 

console = logging.StreamHandler() console.setLevel(logging.INFO)

logger.addHandler(handler) logger.addHandler(console)

logger.info("Start print log") logger.debug("Do something") logger.warning("Something maybe fail.") try: open("sklearn.txt","rb") except (SystemExit,KeyboardInterrupt): raise except Exception: logger.error("Faild to open sklearn.txt from logger.error",exc_info = True)

logger.info("Finish")

控制台和日志文件log.txt中输出，

也可以使用logger.exception(msg,_args)，它等价于logger.error(msg,exc_info = True,_args)，

将

替换为，

控制台和日志文件log.txt中输出，

主模块mainModule.py，

import logging import subModule logger = logging.getLogger("mainModule") logger.setLevel(level = logging.INFO) handler = logging.FileHandler("log.txt") handler.setLevel(logging.INFO) formatter = logging.Formatter('%(asctime)s - %(name)s - %(levelname)s - %(message)s') handler.setFormatter(formatter) 

console = logging.StreamHandler() console.setLevel(logging.INFO) console.setFormatter(formatter)

logger.addHandler(handler) logger.addHandler(console)

logger.info("creating an instance of subModule.subModuleClass") a = subModule.SubModuleClass() logger.info("calling subModule.subModuleClass.doSomething") a.doSomething() logger.info("done with subModule.subModuleClass.doSomething") logger.info("calling subModule.some_function") subModule.som_function() logger.info("done with subModule.some_function")

子模块subModule.py，

import logging 

module_logger = logging.getLogger("mainModule.sub") class SubModuleClass(object): def init(self): self.logger = logging.getLogger("mainModule.sub.module") self.logger.info("creating an instance in SubModuleClass") def doSomething(self): self.logger.info("do something in SubModule") a = [] a.append(1) self.logger.debug("list a = " + str(a)) self.logger.info("finish something in SubModuleClass")

def som_function(): module_logger.info("call function some_function")

执行之后，在控制和日志文件log.txt中输出，

首先在主模块定义了logger'mainModule'，并对它进行了配置，就可以在解释器进程里面的其他地方通过getLogger('mainModule')得到的对象都是一样的，不需要重新配置，可以直接使用。定义的该logger的子logger，都可以共享父logger的定义和配置，所谓的父子logger是通过命名来识别，任意以'mainModule'开头的logger都是它的子logger，例如'mainModule.sub'。

实际开发一个application，首先可以通过logging配置文件编写好这个application所对应的配置，可以生成一个根logger，如'PythonAPP'，然后在主函数中通过fileConfig加载logging配置，接着在application的其他地方、不同的模块中，可以使用根logger的子logger，如'PythonAPP.Core'，'PythonAPP.Web'来进行log，而不需要反复的定义和配置各个模块的logger。

尽管可以在Python代码中配置logging，但是这样并不够灵活，最好的方法是使用一个配置文件来配置。在Python 2.7及以后的版本中，可以从字典中加载logging配置，也就意味着可以通过JSON或者YAML文件加载日志的配置。

JSON配置文件，

通过JSON加载配置文件，然后通过logging.dictConfig配置logging，

import json import logging.config import os 

def setup_logging(default_path = "logging.json",default_level = logging.INFO,env_key = "LOG_CFG"): path = default_path value = os.getenv(env_key,None) if value: path = value if os.path.exists(path): with open(path,"r") as f: config = json.load(f) logging.config.dictConfig(config) else: logging.basicConfig(level = default_level)

def func(): logging.info("start func")

if name == "main": setup_logging(default_path = "logging.json") func()

通过YAML文件进行配置，比JSON看起来更加简介明了，

通过YAML加载配置文件，然后通过logging.dictConfig配置logging，

import yaml import logging.config import os 

def setup_logging(default_path = "logging.yaml",default_level = logging.INFO,env_key = "LOG_CFG"): path = default_path value = os.getenv(env_key,None) if value: path = value if os.path.exists(path): with open(path,"r") as f: config = yaml.load(f) logging.config.dictConfig(config) else: logging.basicConfig(level = default_level)

def func(): logging.info("start func")

if name == "main": setup_logging(default_path = "logging.yaml") func()

subprocess是Python 2.4中新增的一个模块，它允许你生成新的进程，连接到它们的 input/output/error 管道，并获取它们的返回（状态）码。这个模块的目的在于替换几个旧的模块和方法，如：

• os.system
• os.spawn*

1. subprocess模块中的常用函数

说明：

1. 在Python 3.5之后的版本中，官方文档中提倡通过subprocess.run()函数替代其他函数来使用subproccess模块的功能；
2. 在Python 3.5之前的版本中，我们可以通过subprocess.call()，subprocess.getoutput()等上面列出的其他函数来使用subprocess模块的功能；
3. subprocess.run()、subprocess.call()、subprocess.check_call()和subprocess.check_output()都是通过对subprocess.Popen的封装来实现的高级函数，因此如果我们需要更复杂功能时，可以通过subprocess.Popen来完成。
4. subprocess.getoutput()和subprocess.getstatusoutput()函数是来自Python 2.x的commands模块的两个遗留函数。它们隐式的调用系统shell，并且不保证其他函数所具有的安全性和异常处理的一致性。另外，它们从Python 3.3.4开始才支持Windows平台。

2. 上面各函数的定义及参数说明

函数参数列表：

' 
 
   
 
 
  
    
  
 
   运行 
  
 
 
   
 

参数说明：

• args： 要执行的shell命令，默认应该是一个字符串序列，如['df', '-Th']或('df', '-Th')，也可以是一个字符串，如'df -Th'，但是此时需要把shell参数的值置为True。
• shell： 如果shell为True，那么指定的命令将通过shell执行。如果我们需要访问某些shell的特性，如管道、文件名通配符、环境变量扩展功能，这将是非常有用的。当然，python本身也提供了许多类似shell的特性的实现，如glob、fnmatch、os.walk()、os.path.expandvars()、os.expanduser()和shutil等。
• check： 如果check参数的值是True，且执行命令的进程以非0状态码退出，则会抛出一个CalledProcessError的异常，且该异常对象会包含 参数、退出状态码、以及stdout和stderr(如果它们有被捕获的话)。
• stdout, stderr：
• run()函数默认不会捕获命令执行结果的正常输出和错误输出，如果我们向获取这些内容需要传递subprocess.PIPE，然后可以通过返回的CompletedProcess类实例的stdout和stderr属性或捕获相应的内容；
• call()和check_call()函数返回的是命令执行的状态码，而不是CompletedProcess类实例，所以对于它们而言，stdout和stderr不适合赋值为subprocess.PIPE；
• check_output()函数默认就会返回命令执行结果，所以不用设置stdout的值，如果我们希望在结果中捕获错误信息，可以执行stderr=subprocess.STDOUT。
• input： 该参数是传递给Popen.communicate()，通常该参数的值必须是一个字节序列，如果universal_newlines=True，则其值应该是一个字符串。
• universal_newlines： 该参数影响的是输入与输出的数据格式，比如它的值默认为False，此时stdout和stderr的输出是字节序列；当该参数的值设置为True时，stdout和stderr的输出是字符串。

3. subprocess.CompletedProcess类介绍

需要说明的是，subprocess.run()函数是Python3.5中新增的一个高级函数，其返回值是一个subprocess.CompletedPorcess类的实例，因此，subprocess.completedPorcess类也是Python 3.5中才存在的。它表示的是一个已结束进程的状态信息，它所包含的属性如下：

• args： 用于加载该进程的参数，这可能是一个列表或一个字符串
• returncode： 子进程的退出状态码。通常情况下，退出状态码为0则表示进程成功运行了；一个负值-N表示这个子进程被信号N终止了
• stdout： 从子进程捕获的stdout。这通常是一个字节序列，如果run()函数被调用时指定universal_newlines=True，则该属性值是一个字符串。如果run()函数被调用时指定stderr=subprocess.STDOUT，那么stdout和stderr将会被整合到这一个属性中，且stderr将会为None
• stderr： 从子进程捕获的stderr。它的值与stdout一样，是一个字节序列或一个字符串。如果stderr灭有被捕获的话，它的值就为None
• check_returncode()： 如果returncode是一个非0值，则该方法会抛出一个CalledProcessError异常。

4. 实例

subprocess.run()

subprocess.call()

suprocess.check_call()

sbuprocess.check_output()

subprocess.getoutput()与subprocess.getstatusoutput()

该类用于在一个新的进程中执行一个子程序。前面我们提到过，上面介绍的这些函数都是基于subprocess.Popen类实现的，通过使用这些被封装后的高级函数可以很方面的完成一些常见的需求。由于subprocess模块底层的进程创建和管理是由Popen类来处理的，因此，当我们无法通过上面哪些高级函数来实现一些不太常见的功能时就可以通过subprocess.Popen类提供的灵活的api来完成。

1.subprocess.Popen的构造函数

参数说明：

• args： 要执行的shell命令，可以是字符串，也可以是命令各个参数组成的序列。当该参数的值是一个字符串时，该命令的解释过程是与平台相关的，因此通常建议将args参数作为一个序列传递。
• bufsize： 指定缓存策略，0表示不缓冲，1表示行缓冲，其他大于1的数字表示缓冲区大小，负数 表示使用系统默认缓冲策略。
• stdin, stdout, stderr： 分别表示程序标准输入、输出、错误句柄。
• preexec_fn： 用于指定一个将在子进程运行之前被调用的可执行对象，只在Unix平台下有效。
• close_fds： 如果该参数的值为True，则除了0,1和2之外的所有文件描述符都将会在子进程执行之前被关闭。
• shell： 该参数用于标识是否使用shell作为要执行的程序，如果shell值为True，则建议将args参数作为一个字符串传递而不要作为一个序列传递。
• cwd： 如果该参数值不是None，则该函数将会在执行这个子进程之前改变当前工作目录。
• env： 用于指定子进程的环境变量，如果env=None，那么子进程的环境变量将从父进程中继承。如果env!=None，它的值必须是一个映射对象。
• universal_newlines： 如果该参数值为True，则该文件对象的stdin，stdout和stderr将会作为文本流被打开，否则他们将会被作为二进制流被打开。
• startupinfo和creationflags： 这两个参数只在Windows下有效，它们将被传递给底层的CreateProcess()函数，用于设置子进程的一些属性，如主窗口的外观，进程优先级等。

2. subprocess.Popen类的实例可调用的方法

关于communicate()方法的说明：

• 该方法中的可选参数 input 应该是将被发送给子进程的数据，或者如没有数据发送给子进程，该参数应该是None。input参数的数据类型必须是字节串，如果universal_newlines参数值为True，则input参数的数据类型必须是字符串。
• 该方法返回一个元组(stdout_data, stderr_data)，这些数据将会是字节穿或字符串（如果universal_newlines的值为True）。
• 如果在timeout指定的秒数后该进程还没有结束，将会抛出一个TimeoutExpired异常。捕获这个异常，然后重新尝试通信不会丢失任何输出的数据。但是超时之后子进程并没有被杀死，为了合理的清除相应的内容，一个好的应用应该手动杀死这个子进程来结束通信。
• 需要注意的是，这里读取的数据是缓冲在内存中的，所以，如果数据大小非常大或者是无限的，就不应该使用这个方法。

3. subprocess.Popen使用实例

实例1：

实例2：

实例3：

实例4：

实现类似命令的功能，实际上就是实现shell中管道的共功能。

那么我们到底该用哪个模块、哪个函数来执行命令与系统及系统进行交互呢？下面我们来做个总结：

• 首先应该知道的是，Python2.4版本引入了subprocess模块用来替换os.system()、os.popen()、os.spawn*()等函数以及commands模块；也就是说如果你使用的是Python 2.4及以上的版本就应该使用subprocess模块了。
• 如果你的应用使用的Python 2.4以上，但是是Python 3.5以下的版本，Python官方给出的建议是使用subprocess.call()函数。Python 2.5中新增了一个subprocess.check_call()函数，Python 2.7中新增了一个subprocess.check_output()函数，这两个函数也可以按照需求进行使用。
• 如果你的应用使用的是Python 3.5及以上的版本（目前应该还很少），Python官方给出的建议是尽量使用subprocess.run()函数。
• 当subprocess.call()、subprocess.check_call()、subprocess.check_output()和subprocess.run()这些高级函数无法满足需求时，我们可以使用subprocess.Popen类来实现我们需要的复杂功能。

JSON(JavaScript Object Notation, JS 对象标记) 是一种轻量级的数据交换格式。JSON的数据格式其实就是python里面的字典格式，里面可以包含方括号括起来的数组，也就是python里面的列表。

在python中，有专门处理json格式的模块—— json 和 picle模块

Json 模块提供了四个方法： dumps、dump、loads、load

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

一. dumps 和 dump:

dumps和dump 序列化方法

dumps只完成了序列化为str，

dump必须传文件描述符，将序列化的str保存到文件中

查看源码：

def dumps(obj, skipkeys=False, ensure_ascii=True, check_circular=True, allow_nan=True, cls=None, indent=None, separators=None, default=None, sort_keys=False, kw): # Serialize ``obj`` to a JSON formatted ``str``. # 序列号 “obj” 数据类型 转换为 JSON格式的字符串 

def dump(obj, fp, skipkeys=False, ensure_ascii=True, check_circular=True, allow_nan=True, cls=None, indent=None, separators=None, default=None, sort_keys=False, kw): """Serialize ``obj`` as a JSON formatted stream to ``fp`` (a ``.write()``-supporting file-like object). 我理解为两个动作，一个动作是将”obj“转换为JSON格式的字符串，还有一个动作是将字符串写入到文件中，也就是说文件描述符fp是必须要的参数 """

示例代码：

>>> import json >>> json.dumps([]) # dumps可以格式化所有的基本数据类型为字符串 '[]' >>> json.dumps(1) # 数字 '1' >>> json.dumps('1') # 字符串 '"1"' >>> dict = {"name":"Tom", "age":23} >>> json.dumps(dict) # 字典 '{"name": "Tom", "age": 23}'

a = {"name":"Tom", "age":23} with open("test.json", "w", encoding='utf-8') as f: # indent 超级好用，格式化保存字典，默认为None，小于0为零个空格 f.write(json.dumps(a, indent=4)) # json.dump(a,f,indent=4) # 和上面的效果一样

保存的文件效果：

二. loads 和 load

loads和load 反序列化方法

loads 只完成了反序列化，

load 只接收文件描述符，完成了读取文件和反序列化

查看源码：

def loads(s, encoding=None, cls=None, object_hook=None, parse_float=None, parse_int=None, parse_constant=None, object_pairs_hook=None, kw): """Deserialize ``s`` (a ``str`` instance containing a JSON document) to a Python object. 将包含str类型的JSON文档反序列化为一个python对象"""

def load(fp, cls=None, object_hook=None, parse_float=None, parse_int=None, parse_constant=None, object_pairs_hook=None, kw): """Deserialize ``fp`` (a ``.read()``-supporting file-like object containing a JSON document) to a Python object. 将一个包含JSON格式数据的可读文件饭序列化为一个python对象"""

实例：

>>> json.loads('{"name":"Tom", "age":23}') {'age': 23, 'name': 'Tom'}

import json with open("test.json", "r", encoding='utf-8') as f: aa = json.loads(f.read()) f.seek(0) bb = json.load(f) # 与 json.loads(f.read()) print(aa) print(bb) 

# 输出： {'name': 'Tom', 'age': 23} {'name': 'Tom', 'age': 23}

三. json 和 pickle 模块

json模块和pickle模块都有 dumps、dump、loads、load四种方法，而且用法一样。

不用的是json模块序列化出来的是通用格式，其它编程语言都认识，就是普通的字符串，

而picle模块序列化出来的只有python可以认识，其他编程语言不认识的，表现为乱码

不过picle可以序列化函数，但是其他文件想用该函数，在该文件中需要有该文件的定义（定义和参数必须相同，内容可以不同）

四. python对象（obj） 与json对象的对应关系

 +-------------------+---------------+ | Python | JSON | +===================+===============+ | dict | object | +-------------------+---------------+ | list, tuple | array | +-------------------+---------------+ | str | string | +-------------------+---------------+ | int, float | number | +-------------------+---------------+ | True | true | +-------------------+---------------+ | False | false | +-------------------+---------------+ | None | null | +-------------------+---------------+

五. 总结

1. json序列化方法：

dumps：无文件操作 dump：序列化+写入文件

2. json反序列化方法：

loads：无文件操作 load： 读文件+反序列化

3. json模块序列化的数据 更通用

picle模块序列化的数据 仅python可用，但功能强大，可以序列号函数

4. json模块可以序列化和反序列化的 数据类型 见 python对象（obj） 与json对象的对应关系表

5. 格式化写入文件利用 indent = 4

' 
    
      
    
 
     
       
     
 
      运行 
     
 
    
      
    

' 
    
      
    
 
     
       
     
 
      运行 
     
 
    
      
    

configparser 简介

configparser 常用方法

初始化实例

使用 configparser 首先需要初始化实例，并读取配置文件：

或者可以直接读字典

获取所有 sections

获取指定 section 的 keys & values

' 
 
   
 
 
  
    
  
 
   运行 
  
 
 
   
 

获取指定 section 的 keys

' 
 
   
 
 
  
    
  
 
   运行 
  
 
 
   
 

获取指定 key 的 value

' 
 
   
 
 
  
    
  
 
   运行 
  
 
 
   
 

检查

' 
 
   
 
 
  
    
  
 
   运行 
  
 
 
   
 

' 
 
   
 
 
  
    
  
 
   运行 
  
 
 
   
 

添加

' 
 
   
 
 
  
    
  
 
   运行 
  
 
 
   
 

删除

' 
 
   
 
 
  
    
  
 
   运行 
  
 
 
   
 

关于 [DEFAULT]

但指定删除和修改 [DEFAULT] 里的 keys & values 是可以的：

' 
 
   
 
 
  
    
  
 
   运行 
  
 
 
   
 

还有个特殊的是，has_section() 也无效，可以和 in 区别使用

' 
 
   
 
 
  
    
  
 
   运行 
  
 
 
   
 

更多用法请看官方文档：https://docshttp://www.360doc.com/content/24/0821/00/3.6/library/configparser.html

randmon（获取随机数）

random.random
random.random()用于生成一个0到1的随机符点数: 0 <= n < 1.0

random.uniform
random.uniform(a, b)，用于生成一个指定范围内的随机符点数，两个参数其中一个是上限，一个是下限。如果a > b，则生成的随机数n: a <= n <= b。如果 a <b， 则 b <= n <= a

random.randint
random.randint(a, b)，用于生成一个指定范围内的整数。其中参数a是下限，参数b是上限，生成的随机数n: a <= n <= b

random.randrange
random.randrange([start], stop[, step])，从指定范围内，按指定基数递增的集合中 获取一个随机数。如：random.randrange(10, 100, 2)，结果相当于从[10, 12, 14, 16, ... 96, 98]序列中获取一个随机数。random.randrange(10, 100, 2)在结果上与 random.choice(range(10, 100, 2) 等效

random.choice
random.choice从序列中获取一个随机元素。其函数原型为：random.choice(sequence)。参数sequence表示一个有序类型。这里要说明 一下：sequence在python不是一种特定的类型，而是泛指一系列的类型。list, tuple, 字符串都属于sequence。有关sequence可以查看python手册数据模型这一章。下面是使用choice的一些例子：

random.shuffle
random.shuffle(x[, random])，用于将一个列表中的元素打乱。如:

random.sample
random.sample(sequence, k)，从指定序列中随机获取指定长度的片断。sample函数不会修改原有序列

随机选取0到100间的偶数：

随机浮点数：

随机字符：

多个字符中选取特定数量的字符：

多个字符中选取特定数量的字符组成新字符串：

随机选取字符串：

洗牌：

paramiko是一个用于做远程控制的模块，使用该模块可以对远程服务器进行命令或文件操作，值得一说的是，fabric和ansible内部的远程管理就是使用的paramiko来现实。

1、下载安装

2、模块使用

#!/usr/bin/env python #coding:utf-8 

import paramiko

ssh = paramiko.SSHClient() ssh.set_missing_host_key_policy(paramiko.AutoAddPolicy()) ssh.connect('192.168.1.108', 22, 'alex', '123') stdin, stdout, stderr = ssh.exec_command('df') print stdout.read() ssh.close();

import paramiko 

private_key_path = '/home/auto/.ssh/id_rsa' key = paramiko.RSAKey.from_private_key_file(private_key_path)

ssh = paramiko.SSHClient() ssh.set_missing_host_key_policy(paramiko.AutoAddPolicy()) ssh.connect('主机名 ', 端口, '用户名', key)

stdin, stdout, stderr = ssh.exec_command('df') print stdout.read() ssh.close()

import os,sys import paramiko 

t = paramiko.Transport(('182.92.219.86',22)) t.connect(username='wupeiqi',password='123') sftp = paramiko.SFTPClient.from_transport(t) sftp.put('/tmp/test.py','/tmp/test.py') t.close()

import os,sys import paramiko

t = paramiko.Transport(('182.92.219.86',22)) t.connect(username='wupeiqi',password='123') sftp = paramiko.SFTPClient.from_transport(t) sftp.get('/tmp/test.py','/tmp/test2.py') t.close()

import paramiko 

pravie_key_path = '/home/auto/.ssh/id_rsa' key = paramiko.RSAKey.from_private_key_file(pravie_key_path)

t = paramiko.Transport(('182.92.219.86',22)) t.connect(username='wupeiqi',pkey=key)

sftp = paramiko.SFTPClient.from_transport(t) sftp.put('/tmp/test3.py','/tmp/test3.py')

t.close()

import paramiko

pravie_key_path = '/home/auto/.ssh/id_rsa' key = paramiko.RSAKey.from_private_key_file(pravie_key_path)

t = paramiko.Transport(('182.92.219.86',22)) t.connect(username='wupeiqi',pkey=key)

sftp = paramiko.SFTPClient.from_transport(t) sftp.get('/tmp/test3.py','/tmp/test4.py')

t.close()

Python标准库中提供了：urllib等模块以供Http请求，但是，它的 API 太渣了。它是为另一个时代、另一个互联网所创建的。它需要巨量的工作，甚至包括各种方法覆盖，来完成最简单的任务。

import urllib.request 

f = urllib.request.urlopen('http://wwwhttp://www.360doc.com/content/24/0821/00//webservices/OnlineWebService.asmx/CheckOnline?Code=') result = f.read().decode('utf-8')

import urllib.request 

req = urllib.request.Request('http://wwwhttp://www.360doc.com/content/24/0821/00/') req.add_header('Referer', 'http://wwwhttp://www.360doc.com/content/24/0821/00/') r = urllib.request.urlopen(req)

result = f.read().decode('utf-8')

注：更多见Python官方文档：https://docshttp://www.360doc.com/content/24/0821/00/3.5/library/urllib.request.html#module-urllib.request

Requests 是使用 Apache2 Licensed 许可证的 基于Python开发的HTTP 库，其在Python内置模块的基础上进行了高度的封装，从而使得Pythoner进行网络请求时，变得美好了许多，使用Requests可以轻而易举的完成浏览器可有的任何操作。

1、安装模块

2、使用模块

# 1、无参数实例 import requests ret = requests.get('https://github.com/timeline.json') print(ret.url) print(ret.text) # 2、有参数实例 import requests payload = {'key1': 'value1', 'key2': 'value2'} ret = requests.get("http:///get", params=payload) print(ret.url) print(ret.text)

# 1、基本POST实例 import requests payload = {'key1': 'value1', 'key2': 'value2'} ret = requests.post("http:///post", data=payload) print(ret.text) # 2、发送请求头和数据实例 import requests import json url = 'https://api.github.com/some/endpoint' payload = {'some': 'data'} headers = {'content-type': 'application/json'} ret = requests.post(url, data=json.dumps(payload), headers=headers) print(ret.text) print(ret.cookies)

requests.get(url, params=None, kwargs) requests.post(url, data=None, json=None, kwargs) requests.put(url, data=None, kwargs) requests.head(url, kwargs) requests.delete(url, kwargs) requests.patch(url, data=None, kwargs) requests.options(url, kwargs) # 以上方法均是在此方法的基础上构建 requests.request(method, url, kwargs)

更多requests模块相关的文档见：http://cnhttp://www.360doc.com/content/24/0821/00/zh_CN/latest/

3、Http请求和XML实例

实例：检测账号是否在线

import urllib import requests from xml.etree import ElementTree as ET 

# 使用内置模块urllib发送HTTP请求，或者XML格式内容 <> f = urllib.request.urlopen('http://wwwhttp://www.360doc.com/content/24/0821/00//webservices/OnlineWebService.asmx/CheckOnline?Code=') result = f.read().decode('utf-8') >

# 使用第三方模块requests发送HTTP请求，或者XML格式内容 r = requests.get('http://wwwhttp://www.360doc.com/content/24/0821/00//webservices/OnlineWebService.asmx/CheckOnline?Code=') result = r.text

# 解析XML格式内容 node = ET.XML(result)

# 获取内容 if node.text == "Y": print("在线") else: print("离线")

实例：查看火车停靠信息

import urllib import requests from xml.etree import ElementTree as ET 

# 使用内置模块urllib发送HTTP请求，或者XML格式内容 <> f = urllib.request.urlopen('http://wwwhttp://www.360doc.com/content/24/0821/00/WebServices/TrainTimeWebService.asmx/getDetailInfoByTrainCode?TrainCode=G666&UserID=') result = f.read().decode('utf-8') >

# 使用第三方模块requests发送HTTP请求，或者XML格式内容 r = requests.get('http://wwwhttp://www.360doc.com/content/24/0821/00/WebServices/TrainTimeWebService.asmx/getDetailInfoByTrainCode?TrainCode=G666&UserID=') result = r.text

# 解析XML格式内容 root = ET.XML(result) for node in root.iter('TrainDetailInfo'): print(node.find('TrainStation').text,node.find('StartTime').text,node.tag,node.attrib)

注：更多接口猛击这里

paramiko模块

import paramiko 

# 创建SSH对象 ssh = paramiko.SSHClient() # 允许连接不在known_hosts文件上的主机 ssh.set_missing_host_key_policy(paramiko.AutoAddPolicy()) # 连接服务器 ssh.connect(hostname="192.168.0.99", port=22, username="root", password="rootroot") # 执行命令 stdin, stdout, stderr = ssh.exec_command('df') # 获取结果 result = stdout.read().decode() # 获取错误提示（stdout、stderr只会输出其中一个） err = stderr.read() # 关闭连接 ssh.close() print(stdin, result, err)

注：如果注释“ssh.set_missing_host_key_policy(paramiko.AutoAddPolicy())”这句，会报错。

类似问题可以为linux系统中~/.ssh/known_hosts文件中的内容。

二、实现SFTP功能

import paramiko # 连接虚拟机centos上的ip及端口 transport = paramiko.Transport(("192.168.0.99", 22)) transport.connect(username="root", password="rootroot") # 将实例化的Transport作为参数传入SFTPClient中 sftp = paramiko.SFTPClient.from_transport(transport) # 将“calculator.py”上传到filelist文件夹中 sftp.put('D:python库Python_shellday05calculator.py', '/filelist/calculator.py') # 将centos中的aaa.txt文件下载到桌面 sftp.get('/filedir/aaa.txt', r'C:Usersduany_000Desktop est_aaa.txt') transport.close()

注：如果遇到Windows中路径问题，链接如下网址http://blog.csdn.net/elang6962/article/details/

三、使用秘钥实现SSH功能

import paramiko private_key = paramiko.RSAKey.from_private_key_file('id_rsa31') # 创建SSH对象 ssh = paramiko.SSHClient() ssh.set_missing_host_key_policy(paramiko.AutoAddPolicy()) # 连接服务器 ssh.connect(hostname='192.168.79.9', port=22, username='root', pkey=private_key) stdin, stdout, stderr = ssh.exec_command('ifconfig') res_out = stdout.read() print(res_out.decode()) ssh.close()

四、使用秘钥实现SFTP功能

import paramiko private_key = paramiko.RSAKey.from_private_key_file('id_rsa31') # 连接虚拟机centos上的ip及端口 transport = paramiko.Transport(("192.168.79.9", 22)) transport.connect(username="root", pkey=private_key) # 将实例化的Transport作为参数传入SFTPClient中 sftp = paramiko.SFTPClient.from_transport(transport) # 将“calculator.py”上传到filelist文件夹中 sftp.put('D:python库Python_shellday05calculator.py', '/filedir/calculator.py') # 将centos中的aaa.txt文件下载到桌面 sftp.get('/filedir/oldtext.txt', r'C:Usersduany_000Desktopoldtext.txt') transport.close()

版权声明：

本文来自互联网用户投稿，该文观点仅代表作者本人，不代表本站立场。本站仅提供信息存储空间服务，不拥有所有权，不承担相关法律责任。
如若内容造成侵权、违法违规、事实不符，请将相关资料发送至xkadmin@xkablog.com进行投诉反馈，一经查实，立即处理！

转载请注明出处，原文链接：https://www.xkablog.com/pythonbc/76231.html