欢迎加入 Linux_Python 学习群
群号:478616847
目录:
模块是某个功能代码的集合,模块是一种组织形式,它将彼此有关系的 python 代码组织到一个个文件中,模块可以包含可执行代码,
函数和类或者这些东西的组合。一个模块创建之后, 你可以从另一个模块中使用 import 语句导入这个模块来使用。想想看写一个大
的项目的时候是不是有很多代码,那么我们就需要使用模块把这些代码按照功能结构进行划分,放在不同的目录或者是包中。
形象的来说模块就是有一些功能的 py 文件,我们通过 import 可以导入这个功能模块,并使用它
模块分为三种:
内置模块
三方开源模块
自定义模块
内置模块:
在安装完成 python 后,python 本身就带有库,这个库叫做 python 内置库,那么内置模块也被称之为标准库
三方开源模块:
那么 python 内置的模块,有很多不能满足我们的需求,那么就会有很多人去自己写模块,并且把它开源出来,就是三方模块、
那么这些三方模块,会有一些统一下载的地方, 这个地址是 pip 的网站,里面现在收录了 99886 个三方模块
这么多的三方模块得益于开源精神,所以我们也是可以在这个网站上上传自己的模块供大家使用。
自定义模块:
自定义模块就是你自己写的代码组成的功能,这些功能称之为一个模块
导入模块
模块是有了,但是要在自己的代码中使用模块,是需要导入的,导入的方式有以下这么几种
导入模块
- 1 import module
- 2 from module import xx
- 3 from module import xx as rename
- 4 from module import *
- 5
- 6
- 7 import sys
- 8 print(sys.path)
- 9
- 10 from sys import path
- 11 print(path)
- 12
- 13 from sys import path as new_path
- 14 print(new_path)
- 15
- 16 from sys import *
- 17 print(path)
- 18 print(argv)
import sys 直接导入 sys 模块,想要用 sys 模块的功能需要 sys.path (拿 path 举例)
from sys import path 导入 sys 模块中的 path 功能,使用时直接使用 path
from sys import path as new_path 导入 sys 模块中的 path 功能,并通过 as 给 path 功能重命名,使用时直接使用新名字即可这个功能主要分防止功能名冲突
from sys import * 导入 sys 模块中的所有功能,使用时直接用功能名即可
导入自定义模块
导入自定义模块其实也非常简单,首先在同级目录下我们有 main.py 和 print_mode.py 两个文件,在 print_mode python 文件中定义一个函数内容如下
print_mode
- 1 #!/usr/bin/env python
- 2 # -*- coding: utf-8 -*-
- 3
- 4
- 5 def new_print(arg):
- 6 print("\033[31m%s\033[0m"%arg)
然后我们在 main.py 文件使用 new_print 这个函数,下面演示了上面的四种导入方法
导入使用自定义模块
- 1 #!/usr/bin/env python
- 2 # -*- coding: utf-8 -*-
- 3 import print_mode
- 4 print_mode.new_print("Hello world")
- 5
- 6
- 7 from print_mode import new_print
- 8 new_print("Hello world")
- 9
- 10
- 11 from print_mode import new_print as pr
- 12 pr("Hello world")
- 13
- 14
- 15 from print_mode import *
- 16 new_print("Hello world")
注意在上面我把同级目录下加粗了,也就说这种方法只能导入同级目录下的自定义模块,下面介绍如何导入不是同级目录下的模块
1、首先我们知道,操作系统有默认的环境变量,比如想要在 cmd 中使用 python 就需要在 PATH 环境变量中加入 python 的安装目录
那么如果我们想要导入其它目录下自定义模块,也要给 python 的 PATH 变量中加入模块所在的目录,我的目录结构如图
要知道的是我们的程序在其它计算机上面使用是安装到不同位置的,所以我们肯定不能再 PATH 环境变量中添加当前主机的程序位置
所以用 os.path.abspath(__file__) 得到当前文件绝对路径,然后我们要得到 bin 目录的上层目录,因为只有这样才能找到 mode 目录
通过 os.path.dirname(os.path.abspath(__file__)) 得到的是 bin 目录的绝对路径,也就是现在这句话得到的是 bin 目录,我们的
目的是得到 test 目录所以 os.path.dirname(os.path.dirname(os.path.abspath(__file__))),得到 test 目录的绝对路径了,接下来
把得到的绝对路径通过 sys.path.appen 加入到 python 环境变量里面,那么我们就可以导入 mode 目录下的 python_mode 模块了
导入其它目录中的自定义模块 main(文件内容)
- 1 #!/usr/bin/env python
- 2 # -*- coding: utf-8 -*-
- 3
- 4 import os,sys
- 5
- 6 print(os.path.abspath(__file__))
- 7 print(os.path.dirname(os.path.abspath(__file__)))
- 8 print(os.path.dirname(os.path.dirname(os.path.abspath(__file__))))
- 9
- 10
- 11 print("原:",sys.path)
- 12 base_dir = os.path.dirname(os.path.dirname(os.path.abspath(__file__)))
- 13 sys.path.append(base_dir)
- 14 print("新:",sys.path)
- 15
- 16 from mode import print_mode
- 17 print_mode.new_print("Hello world")
注意!如果在 print_mode 文件中有一个 print()语句,那么在 print_mode 文件被第一次导入的时候就会执行这个 print 语句,这是因为
第一次导入的时候会把 print_mode 文件内容加载到内存,为了防止你重复导入,python 的优化手段会把后续的 import 语句仅是对已经加
载大内存中的模块对象增加了一次引用,不会重新执行模块内的语句。
第三方模块的安装
安装第三方模块我们可以使用 pip 和源码进行安装,源码安装只需要做以下的操作
以 paramiko 模块为例,第三方模块在安装过程中就在 Python 的 PATH 环境变量中,因此用法和内置模块一样
安装第三方模块
- 1 # pip install paramiko pip安装方式
- 2
- 3 # pycrypto,由于 paramiko 模块内部依赖pycrypto,所以先下载安装pycrypto
- 4
- 5 # 下载安装 pycrypto
- 6 wget http://files.cnblogs.com/files/wupeiqi/pycrypto-2.6.1.tar.gz
- 7 tar -xvf pycrypto-2.6.1.tar.gz
- 8 cd pycrypto-2.6.1
- 9 python setup.py build
- 10 python setup.py install
- 11
- 12 # 进入python环境,导入Crypto检查是否安装成功
- 13
- 14 # 下载安装 paramiko
- 15 wget http://files.cnblogs.com/files/wupeiqi/paramiko-1.10.1.tar.gz
- 16 tar -xvf paramiko-1.10.1.tar.gz
- 17 cd paramiko-1.10.1
- 18 python setup.py build
- 19 python setup.py install
- 20
- 21 # 进入python环境,import paramiko检查是否安装成功即可
更多运维中常用的第三方模块请参考
包是一种通过使用 ". 模块名" 来组织 python 模块名称空间的方式,其实 python 中的包 就是一个包含__init__.py 文件的目录。模块称之为文件
那么包就是文件的集合,在我们使用目录来存储模块,会造成模块名冲突的问题,那么包就可以有效地避免模块名冲突的问题, 在学习包之前
首先创建了一个根目录目录和 app,bin,config 这三个包,每个包里都有 py 文件
文件内容
- 1 #app_one
- 2 def conf_app_one():
- 3 print("From app_one")
- 4
- 5 #app_two
- 6 def conf_app_two1():
- 7 print("From 1 app_two.py")
- 8
- 9 def conf_app_two2():
- 10 print("From 2 app_two.py")
- 11
- 12 #conf
- 13 def conf_func():
- 14 print("From conf.py")
导入包
包的导入也分为 import,和 from...import,import 导入语句也是导入同级目录的所以这里不做演示 无论是 import 形式还是 from...import 形式,凡是在导入语
句中(而不是在使用时)遇到带点的,都是关于包才有的导入语法, 并且 from 后面的 import 导入的模块是不能带点的,所以点的左边必须是一个包
错误方法:from aa import bb.c
第一次导入包的时候,会执行包中的 __init__.py 文件,首先我们可以在 config 模块中的 __init__.py 写一句 print,然后在 main。py 中导入 config 模块试一下
导入模块触发__init__
- 1 #!/usr/bin/env python
- 2 # -*- coding:utf-8 -*-
- 3
- 4 import os,sys
- 5 path = os.path.dirname(os.path.dirname(os.path.abspath(__file__)))
- 6 sys.path.append(path)
- 7
- 8 from config import conf
当我们运行 main.py 后就触发了在 config 模块中的 __init__.py 的 print 语句
__all__
那么这个__init__.py 还能干什么事呢?
这次我们导入 app 包下的模块,看看 * 能不能把 app 下面的文件全部导入进来
__all__的作用
- 1 #!/usr/bin/env python
- 2 # -*- coding:utf-8 -*-
- 3
- 4
- 5 #main文件
- 6 import os,sys
- 7 path = os.path.dirname(os.path.dirname(os.path.abspath(__file__)))
- 8 sys.path.append(path)
- 9
- 10 from app import *
- 11
- 12 app_one.conf_app_one()
- 13 app_two.conf_app_two1()
然而我们一运行发现报错,说 app_one 没有定义!
这不科学,安装道理说 from app import * 应该导入 app 包下的所有 py 文件啊!其实在 app 下的__init__文件中加入__all__ = ["app_one","app_two"],就可以这样调用了。
最后我们来看正常导入的方式
包的导入
- 1 #!/usr/bin/env python
- 2 # -*- coding:utf-8 -*-
- 3
- 4 import os,sys
- 5 path = os.path.dirname(os.path.dirname(os.path.abspath(__file__)))
- 6 sys.path.append(path)
- 7
- 8 from app import app_two
- 9 app_two.conf_app_two1()
- 10
- 11 from app import app_two as two
- 12 two.conf_app_two2()
- 13
- 14 from app.app_one import *
- 15 conf_app_one()
pyc 文件
有一天我突然打开包的目录,忽然发现,目录中多出了__pycache__的文件夹,里面有. pyc 的文件,在好奇心的驱使下我百度出它的真面目
原来 python 为了提高模块的加载速度,Python 缓存编译的版本,每个模块在__pycache__目录下有着以 module.version.pyc 的形式命名
的文件,这些文件名包含了 python 的版本号,模块名,如 CPython 版本 3.5,并且 Python 会检查源文件的修改时间与编译的版本进行对比,
如果过期就需要重新编译。这是完全自动的过程。不同的版本编译后的 pyc 文件不同,2.5 编译的 pyc 文件不能到 3.5 上执行,并且 pyc 文件是
可以反编译的,因而它的出现仅仅是用来提升模块的加载速度的。
接下来开始学习常用的内置模块,内置模块就是集成在 python 中的工具包,我们要学习常用的工具包的用法,这些用法非常简单
在平时的代码中,经常要与实际打交道与时间处理有关的模块就包括:time,datetime 以及 calendar 这里讲解前两个模块
Time 模块
python 中通常有这几种形式来表示时间:1、时间戳 2、格式化的时间字符串 3、元祖
1、time.localtime() 会通过 time.struct_time 的 class 类转换成特殊时间的格式,括号中可以传入时间戳,如果不传入则用的是当前时间,我们可以通过下标取出对应的值
time.struct_time(tm_year=2017, tm_mon=3, tm_mday=10, tm_hour=15, tm_min=53, tm_sec=53, tm_wday=4, tm_yday=69, tm_isdst=0)
2、time.gmtime() 与 time.localtime() 方法类似,只不过会把当前时间转换成 0 时区的时间
time.struct_time(tm_year=2017, tm_mon=3, tm_mday=10, tm_hour=16, tm_min=1, tm_sec=16, tm_wday=4, tm_yday=69, tm_isdst=0)
time.struct_time(tm_year=2017, tm_mon=3, tm_mday=10, tm_hour=8, tm_min=1, tm_sec=16, tm_wday=4, tm_yday=69, tm_isdst=0)
3、time.time():返回当前时间的时间戳。
4、time.mktime(t):将一个 struct_time 转化为时间戳。
5、time.sleep(secs):线程推迟指定的时间运行。单位为秒,可以是小数
6、time.clock():在 UNIX 系统上,它返回的是" 进程时间 ",它是用秒表示的浮点数(时间戳)。而在 WINDOWS 中,第一次调用,返回的是进程运行的实际时间。
而第二次之后的调用是自第一次调用以后到现在的运行时间。
7、time.asctime([t]):把一个表示时间的元组或者 struct_time 表示为这种形式:'Sun Jun 20 23:21:05 1993'。如果没有参数,将会将 time.localtime() 作为参数传入。
8、time.ctime([secs]):把一个时间戳(按秒计算的浮点数)转化为 time.asctime() 的形式。如果参数未给或者为 None 的时候,将会默认 time.time() 为参数。
它的作用相当于 time.asctime(time.localtime(secs))。
输出自定义的日期格式
自定义日志输出格式
- 1 import time
- 2
- 3 print(time.strftime("%Y:%m:%d,%H",time.localtime(time.time())))
可以看到其中双引号的内容就是调用了下面的格式
datetime 模块
这个模块可以理解为 data 和 time 两个部分,主要用于时间的加减,也可以计算时间差
datatime
- 1 import datetime
- 2 import time
- 3
- 4 #返回 当前时间
- 5 print(datetime.datetime.now())
- 6 # 时间戳直接转成日期格式 2016-08-19
- 7 print(datetime.date.fromtimestamp(time.time()) )
- 8
- 9 #当前时间+3天
- 10 print(datetime.datetime.now() + datetime.timedelta(3))
- 11 #当前时间-3天
- 12 print(datetime.datetime.now() + datetime.timedelta(-3))
- 13 #当前时间+3小时
- 14 print(datetime.datetime.now() + datetime.timedelta(hours=3))
- 15 #当前时间+30分
- 16 print(datetime.datetime.now() + datetime.timedelta(minutes=30))
- 17
- 18 #时间替换
- 19 c_time = datetime.datetime.now()
- 20 print(c_time.replace(minute=3,hour=2))
- 21
- 22
- 23 #计算时间差,返回天数
- 24 datas = "2016-08-19"
- 25 def Repayment(past_time):
- 26 def conversion(str_data):#把每个元素变成int类型
- 27 data_list = str_data.split("-")
- 28 for i in data_list:data_list[data_list.index(i)] = int(i)
- 29 return data_list
- 30 #得到新老时间的列表
- 31 new_time_list = conversion(time.strftime("%Y-%m-%d",time.localtime(time.time())))
- 32 past_time_list = conversion(past_time)
- 33 n_time = datetime.datetime(new_time_list[0],new_time_list[1],new_time_list[2])
- 34 p_time = datetime.datetime(past_time_list[0],past_time_list[1],past_time_list[2])
- 35 return ((n_time - p_time).days)
- 36 print(Repayment(datas))
生成随机数
random 用法
- 1 #!/usr/bin/env python
- 2
- 3 import random
- 4
- 5 #生成一个0到1的随机浮点数
- 6 print(random.random())
- 7
- 8 #用于生成一个指定范围内的随机符点数
- 9 print( random.uniform(10, 20))
- 10 print( random.uniform(10, 20))
- 11
- 12 #用于生成一个指定范围内的整数。
- 13 print(random.randint(10, 20))
- 14
- 15 #指定范围内,按指定基数递增的集合中 获取一个随机数。
- 16 #例子中也就是只会从 10 12 14 ... 18取得随机数,第三个参数为2的时候也就是取偶数
- 17 print(random.randrange(10,20, 2))
- 18
- 19 #从序列中获取一个随机元素。
- 20 data_str = "I love Python"
- 21 data_list = [1,2,3,4,5,6]
- 22 data_tuple = ("A","B","C","D","E")
- 23 print(random.choice(data_str))
- 24 print(random.choice(data_list))
- 25 print(random.choice(data_tuple))
- 26
- 27 #用于将一个列表中的元素打乱。
- 28 data_list = [1,2,3,4,5,6]
- 29 random.shuffle(data_list)
- 30 print(data_list)
- 31
- 32 #从指定序列中随机获取指定长度的片断
- 33 data_list = [1,2,3,4,5,6]
- 34 print(random.sample(data_list,3))
小例子:生成随机的验证码
生成随机验证码或者密码
- 1 #!/usr/bin/env python
- 2
- 3 import random
- 4 # 第一版
- 5 def code(number):
- 6 '''
- 7 随机数生成器
- 8 '''
- 9 number_check = ''
- 10 for i in range(0,number):
- 11 number_curr = random.randrange(0,5)
- 12 if number_curr != i:
- 13 number_temp = chr(random.randint(97,122))
- 14 else:
- 15 number_temp = random.randint(0,9)
- 16 number_check += str(number_temp)
- 17 return number_check
- 18 print(code(5))
- 19
- 20 # 第二版
- 21 import string
- 22 source = string.digits + string.ascii_uppercase + string.ascii_lowercase
- 23 print("".join(random.sample(source, 4)))
os 模块之前我们接触了与文件相关的发放,os 模块还有很多与操作系统交互的函数
os 模块
- 1 os.getcwd() 获取当前工作目录,即当前python脚本工作的目录路径
- 2 os.chdir("dirname") 改变当前脚本工作目录;相当于shell下cd
- 3 os.curdir 返回当前目录: ('.')
- 4 os.pardir 获取当前目录的父目录字符串名:('..')
- 5 os.makedirs('dirname1/dirname2') 可生成多层递归目录
- 6 os.removedirs('dirname1') 若目录为空,则删除,并递归到上一级目录,如若也为空,则删除,依此类推
- 7 os.mkdir('dirname') 生成单级目录;相当于shell中mkdir dirname
- 8 os.rmdir('dirname') 删除单级空目录,若目录不为空则无法删除,报错;相当于shell中rmdir dirname
- 9 os.listdir('dirname') 列出指定目录下的所有文件和子目录,包括隐藏文件,并以列表方式打印
- 10 os.remove() 删除一个文件
- 11 os.rename("oldname","newname") 重命名文件/目录
- 12 os.stat('path/filename') 获取文件/目录信息
- 13 os.sep 输出操作系统特定的路径分隔符,win下为"\\",Linux下为"/"
- 14 os.linesep 输出当前平台使用的行终止符,win下为"\t\n",Linux下为"\n"
- 15 os.pathsep 输出用于分割文件路径的字符串 win下为;,Linux下为:
- 16 os.name 输出字符串指示当前使用平台。win->'nt'; Linux->'posix'
- 17 os.system("bash command") 运行shell命令,直接显示
- 18 os.environ 获取系统环境变量
- 19 os.path.abspath(path) 返回path规范化的绝对路径
- 20 os.path.split(path) 将path分割成目录和文件名二元组返回
- 21 os.path.dirname(path) 返回path的目录。其实就是os.path.split(path)的第一个元素
- 22 os.path.basename(path) 返回path最后的文件名。如何path以/或\结尾,那么就会返回空值。即os.path.split(path)的第二个元素
- 23 os.path.exists(path) 如果path存在,返回True;如果path不存在,返回False
- 24 os.path.isabs(path) 如果path是绝对路径,返回True
- 25 os.path.isfile(path) 如果path是一个存在的文件,返回True。否则返回False
- 26 os.path.isdir(path) 如果path是一个存在的目录,则返回True。否则返回False
- 27 os.path.join(path1[, path2[, ...]]) 将多个路径组合后返回,第一个绝对路径之前的参数将被忽略
- 28 os.path.getatime(path) 返回path所指向的文件或者目录的最后存取时间
- 29 os.path.getmtime(path) 返回path所指向的文件或者目录的最后修改时间
- 30 os.path.normpath(path) #规范化路径,转换path的大小写和斜杠
sys 模块也是比较常用的模块,比如获取命令执行 python 是后面的参数
sys 功能
- 1 sys.argv 命令行参数List,第一个元素是程序本身路径
- 2 sys.exit(n) 退出程序,正常退出时exit(0)
- 3 sys.version 获取Python解释程序的版本信息
- 4 sys.maxint 最大的Int值
- 5 sys.path 返回模块的搜索路径,初始化时使用PYTHONPATH环境变量的值
- 6 sys.platform 返回操作系统平台名称
shutil 是一种高层次的文件操作工具,提供了大量的文件高级操作(可以用 print(help(shutil)) 来查看),比如 拷贝删除,压缩等等
shutil
- 1 #!/usr/bin/env python
- 2
- 3 import shutil
- 4
- 5 #1、将文件拷贝到另一个文件中
- 6 shutil.copyfileobj(open('test','r'), open('test2', 'w'))
- 7
- 8 #2、拷贝文件
- 9 shutil.copyfile('test', 'test2.conf')
- 10
- 11 #3、拷贝权限 内容、组、用户均不变(目标文件必须存在)
- 12 shutil.copymode('test', 'test2.conf')
- 13
- 14 #4、仅拷贝状态的信息,包括:mode bits, atime, mtime, flags(目标文件必须存在)
- 15 shutil.copystat('test', 'test2.conf')
- 16
- 17 #5、拷贝文件和权限
- 18 shutil.copy('test', 'test3')
- 19
- 20 #6、拷贝文件和状态信息
- 21 shutil.copy2('test', 'test3')
- 22
- 23 #7、递归的去拷贝文件夹
- 24 shutil.copytree('testlist', 'test2list', ignore=shutil.ignore_patterns('main.py',))
- 25 """目标目录不能存在,注意对test2list目录父级目录要有可写权限,
- 26 ignore的意思是排除,这里表示不拷贝main.py文件,多个可以用逗号隔开,也可以用*.py"""
- 27
- 28 #拷贝软连接
- 29 shutil.copytree('f1', 'f2', symlinks=True, ignore=shutil.ignore_patterns('*.pyc'))
- 30 #通常的拷贝都把软连接拷贝成硬链接,即对待软连接来说,创建新的文件
- 31
- 32 #8、递归的去删除文件
- 33 shutil.rmtree('test2list')
- 34
- 35 #9、递归的去移动文件,它类似mv命令,其实就是重命名。
- 36 shutil.move("testlist", "testlist2")
压缩 shutil.make_archive(base_name, format,...)
创建压缩包并返回文件路径,例如:zip、tar
打包
- 1 #!/usr/bin/env python
- 2
- 3 import shutil
- 4
- 5 #打包当前目录下的testlist目录,打包成a_bk.zip
- 6 #支持方法"zip", "tar", "bztar" "gztar".
- 7 tar = shutil.make_archive("a_bk","zip",root_dir="./testlist")
- 8
- 9 #把打包结果文件刚在/mnt/目录下
- 10 tar2 = shutil.make_archive("/mnt/a_bk","gztar",root_dir="./testlist")
shutil 对压缩包的处理是调用 ZipFile 和 TarFile 两个模块来进行的
在程序运行的过程中,变量都是在变化的,并且当程序结束后变量将消失,那么为了让程序下次运行的时候还可以用上次的变量,就需要对这些变量,字典,列表通过
序列化保存在文件中,下一次读取文件中的内容进行反序列化就可得到上次运行时的变量数据,那么 json 和 pickle 是用于数据序列化的模块,有些童鞋会经常听见开发说
,这个 Api 返回的是一串 json,所以 json 就是不同平台直接传输数据的,因为在 java 中在 html 中都支持 json 格式的数据
Json 和 Pickle 都提供了四个功能:dumps、dump、loads、load
Json
Json
- 1 #!/usr/bin/env python
- 2 import json
- 3
- 4 #-----------序列化---------#
- 5 dic = {"name":'aaa',"age":22,}
- 6 lis = [1,2,3,"4"]
- 7
- 8 with open("test","w") as file:
- 9 file.write(json.dumps(dic))
- 10 with open("test2","w") as file:
- 11 json.dump(lis,file)
- 12
- 13 #----------反序列化---------#
- 14 with open("test","r") as file:
- 15 data_dic = json.loads(file.read())
- 16 with open("test2","r") as file:
- 17 data_lis = json.load(file)
- 18 print(type(data_lis),":",data_lis)
- 19 print(type(data_dic),":",data_dic)
注!Json 不能保存函数和类对象,但是 Pickle 可以
Pickle,是 python 独有的,其它语言并不支持,并且保存的数据类时要用 bytes 方式写入
Pickle
- 1 #!/usr/bin/env python
- 2 import pickle
- 3
- 4 #-----------序列化---------#
- 5 dic = {"name":'aaa',"age":22,}
- 6 def func():
- 7 return "Hello"
- 8
- 9 with open("test","wb") as file:
- 10 file.write(pickle.dumps(dic))
- 11 with open("test2","wb") as file:
- 12 pickle.dump(func,file)
- 13
- 14 #----------反序列化---------#
- 15 with open("test","rb") as file:
- 16 data_dic = pickle.loads(file.read())
- 17 with open("test2","rb") as file:
- 18 data_func = pickle.load(file)
- 19 print(type(data_func),":",data_func)
- 20 print(data_func())
- 21 print(type(data_dic),":",data_dic)
xml 也是实现不同语言或程序之间的数据交互,跟 json 差不多,它是诞生在 json 之前,如今很多传统公司和金融行业的系统主要的
接口还是 xml
xml 数据格式如下
xml 文件
- 1 '1.0' encoding='utf-8'?>
- 2
- 3 "XiaoMing">
- 4 22
- 5 Men
- 6
- 7 "XiaoHong">
- 8 19
- 9 Women
- 10
- 11
创建上面内容的 xml 文件
生成 xml 文件
- 1 #生成 最外层的<userdata>
- 2 new_xml = ET.Element("userdata")
- 3
- 4 #生成<name Name="XiaoMing">
- 5 name1 = ET.SubElement(new_xml,"name",attrib={"Name":"XiaoMing"})
- 6 #生成<name Name="XiaoMing">中的<age>22</age>
- 7 age = ET.SubElement(name1,"age")
- 8 age.text = "22"
- 9 #生成<name Name="XiaoMing">中的<gender>Men</gender>
- 10 gender = ET.SubElement(name1,"gender")
- 11 gender.text = "Men"
- 12
- 13 #生成<name Name="XiaoHong">
- 14 name2 = ET.SubElement(new_xml,"name",attrib={"Name":"XiaoHong"})
- 15 #生成<name Name="XiaoHong">中的<age>19</age>
- 16 age = ET.SubElement(name2,"age")
- 17 age.text = '19'
- 18 #生成<name Name="XiaoHong">中的<gender>Women</gender>
- 19 gender = ET.SubElement(name2,"gender")
- 20 gender.text = "Women"
- 21
- 22 et = ET.ElementTree(new_xml) #生成文档对象
- 23 et.write("test.xml", encoding="utf-8",xml_declaration=True)#写入
读取 xml 文件内容
读取 xml 文件内容
- 1 #获取最外层的<userdata>
- 2 tree = ET.parse("test.xml")
- 3 root = tree.getroot()
- 4 print(root.tag)
- 5 print("-----------------遍历xml文档------------------")
- 6 #遍历xml文档
- 7 for child in root:
- 8 print(child.tag,child.attrib)#打印<name Name="XiaoMing">和<name Name="XiaoHong">
- 9 for i in child:
- 10 print(i.tag,i.text)#分别打印年龄和性别
- 11
- 12 print("-----------------只遍历age 节点------------------")
- 13 #只遍历age 节点
- 14 for node in root.iter("age"):
- 15 print(node.tag,node.text)
更改删除 xml 文件内容
更改删除 xml 文件内容这个内置模块呢一般用处用来做配置文件的操作, 可以操作以下格式的文件
文件内容
- 1 [www.test.org]
- 2 user = test
- 3 port = 20012
- 4
- 5 [www.test2.org]
- 6 user = test2
- 7 port = 20011
- 8 forwardx11 = no
语法:读操作
-read(filename) 直接读取文件内容
-sections() 得到所有的 section,并以列表的形式返回
-options(section) 得到该 section 的所有 option
-items(section) 得到该 section 的所有键值对
-get(section,option) 得到 section 中 option 的值,返回为 string 类型
-getint(section,option) 得到 section 中 option 的值,返回为 int 类型
写操作
-add_section(section) 添加一个新的 section
-set(section, option, value) 对 section 中的 option 进行设置
示例代码
configparser 操作
- 1 #!/usr/bin/env python
- 2
- 3 import configparser
- 4 import time
- 5
- 6 conf = configparser.ConfigParser()
- 7 conf.read('conf')
- 8
- 9 print("----------------读----------------")
- 10 #得到所有的section,并以列表的形式返回
- 11 print(conf.sections())
- 12 #得到该section的所有option
- 13 print(conf.options('www.test.org'))
- 14 #得到该section的所有键值对
- 15 print(conf.items('www.test2.org'))
- 16 print(conf.get('www.test2.org',"User"))#得到section中option的值,返回为string类型
- 17 time.sleep(2)
- 18
- 19 print("----------------改----------------")
- 20 conf.set('www.test2.org','port',"1234")
- 21 conf.write(open('conf', "w"))
- 22 time.sleep(2)
- 23
- 24 print("----------------判断---------------")
- 25 print(conf.has_section('www.test2.org'))
- 26 time.sleep(2)
- 27
- 28 print("----------------删----------------")
- 29 #删除section中的option
- 30 conf.remove_option('www.test.org','port')
- 31 #删除section
- 32 conf.remove_section('www.test.org')
- 33 conf.write(open('conf', "w"))
- 34 time.sleep(2)
- 35
- 36 print("----------------写----------------")
- 37 #添加section
- 38 conf.add_section('www.test3.org')
- 39 #添加section中的option
- 40 conf.set('www.test3.org','port',"222")
- 41 conf.write(open('conf', "w"))
hashlib 在 python3 中代替了 MD5 和 sha 模块,主要提供了 SHA1, SHA224, SHA256, SHA384, SHA512 ,MD5 算法,在 python3 中已经废弃了
md5 和 sha 模块,其中最为常用的 MD5 算法,我们经常看到下载一个光盘镜像的时候,后面会告诉你一个 MD5 值,这个就是用来做文件完整性验证的
所以同一种字符串计算出来的 MD5 值是一样的
特点:1、相同的内容 hash 运输的结果是相同的 2、这种计算是不可逆的 3、相同算法,无论校验多长的数据,得到的哈希值长度固定。
以常见的摘要算法 MD5 为例,计算出一个字符串的 MD5 值:
hashlib
- 1 #!/usr/bin/env python
- 2
- 3 import hashlib
- 4
- 5 #首先定义一个hashlib的对象
- 6 ha = hashlib.md5()#用的md5加密方式,这里还可以用SHA1, SHA224, SHA256, SHA384, SHA512算法
- 7 ha.update("Hello".encode("utf-8"))
- 8 print(ha.hexdigest())#返回16进制
- 9 print(ha.digest())#返回二进制
- 10 #结果 8b1a9953c4611296a827abf8c47804d7 b"\x8b\x1a\x99S\xc4a\x12\x96\xa8'\xab\xf8\xc4x\x04\xd7"
subprocess 用于执行本地命令,它是通过管道的形式,连接到他们的输入 / 输出 / 错误, 并获得他们的返回代码。
示例代码:()
- 1 import subprocess
- 2 #执行命令,如果命令结果为0,就正常返回,否则抛异常
- 3 retcode = subprocess.call(["ls", "-l"])
- 4
- 5 #接收字符串格式命令,返回元组形式,第1个元素是执行状态,第2个是命令结果
- 6 results = subprocess.getstatusoutput('ls /bin/ls')
- 7 print(results)
- 8
- 9 #接收字符串格式命令,并返回结果
- 10 print(subprocess.getoutput('ls /bin/ls'))
- 11
- 12 #执行命令,并返回结果,注意是返回结果,不是打印,下例结果返回给res<
来源: http://www.cnblogs.com/bj-xy/p/6441031.html