python 学习笔记8 （模块）

Python 模块(Module)，是一个 Python 文件，以 .py 结尾，包含了 Python 对象定义和Python语句。

模块让你能够有逻辑地组织你的 Python 代码段。

把相关的代码分配到一个模块里能让你的代码更好用，更易懂。

模块能定义函数，类和变量，模块里也能包含可执行的代码。

通俗的讲：

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

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

如：os 是系统相关的模块；file是文件操作相关的模块

模块分为三种：

自定义模块
内置模块
开源模块

自定义模块

1、定义模块

情景一：

情景二：

情景三：

2、导入模块

Python之所以应用越来越广泛，在一定程度上也依赖于其为程序员提供了大量的模块以供使用，如果想要使用模块，则需要导入。导入模块有一下几种方法：

import module
from module.xx.xx import xx
from module.xx.xx import xx as rename
from module.xx.xx import *

导入模块其实就是告诉Python解释器去解释那个py文件

导入一个py文件，解释器解释该py文件
导入一个包，解释器解释该包下的 __init__.py 文件

那么问题来了，导入模块时是根据那个路径作为基准来进行的呢？即：sys.path

import sys
print(sys.path)['C:\\Users\\Administrator\\PycharmProjects\\suanfa', 'C:\\Users\\Administrator\\PycharmProjects\\suanfa', 'E:\\python\\python3\\python35.zip', 'E:\\python\\python3\\DLLs', 'E:\\python\\python3\\lib', 'E:\\python\\python3', 'C:\\Users\\Administrator\\AppData\\Roaming\\Python\\Python35\\site-packages', 'E:\\python\\python3\\lib\\site-packages', 'E:\\python\\python3\\lib\\site-packages\\win32', 'E:\\python\\python3\\lib\\site-packages\\win32\\lib', 'E:\\python\\python3\\lib\\site-packages\\Pythonwin']

如果sys.path路径列表没有你想要的路径，可以通过 sys.path.append('路径') 添加。
通过os模块可以获取各种目录，例如：

import sys
import ospre_path = os.path.abspath('../')
sys.path.append(pre_path)

View Code

开源模块

一、下载安装

下载安装有两种方式：

1.yum
pip
apt-get

2.下载源码
解压源码
进入目录
编译源码    python setup.py build
安装源码    python setup.py install

在使用源码安装时，需要使用到gcc编译和python开发环境，所以，需要先执行：

yum install gcc
yum install python-devel
或
apt-get python-dev

安装成功后，模块会自动安装到 sys.path 中的某个目录中，如：

/usr/lib/python2.7/site-packages/

二、导入模块

同自定义模块中导入的方式

三、模块 paramiko

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

1、下载安装

pip3 install paramiko或# pycrypto，由于 paramiko 模块内部依赖pycrypto，所以先下载安装pycrypto# 下载安装 pycrypto
wget http://files.cnblogs.com/files/wupeiqi/pycrypto-2.6.1.tar.gz
tar -xvf pycrypto-2.6.1.tar.gz
cd pycrypto-2.6.1
python setup.py build
python setup.py install# 进入python环境，导入Crypto检查是否安装成功# 下载安装 paramiko
wget http://files.cnblogs.com/files/wupeiqi/paramiko-1.10.1.tar.gz
tar -xvf paramiko-1.10.1.tar.gz
cd paramiko-1.10.1
python setup.py build
python setup.py install# 进入python环境，导入paramiko检查是否安装成功

View Code

2、使用模块

import paramikossh = paramiko.SSHClient()
ssh.set_missing_host_key_policy(paramiko.AutoAddPolicy())
ssh.connect('192.168.14.50', 22, 'liu', '123')
stdin, stdout, stderr = ssh.exec_command('df')
print stdout.read()
ssh.close();

执行命令 - 通过用户名和密码连接服务器

import paramikoprivate_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('ls')
print stdout.read()
ssh.close()

执行命令 - 过密钥链接服务器

import os,sys
import paramikot = paramiko.Transport(('192.168.14.50',22))
t.connect(username='liu',password='123')
sftp = paramiko.SFTPClient.from_transport(t)
sftp.put('/tmp/test.py','/tmp/test.py')
t.close()import os,sys
import paramikot = paramiko.Transport(('192.168.14.50',22))
t.connect(username='liu',password='123')
sftp = paramiko.SFTPClient.from_transport(t)
sftp.get('/tmp/test.py','/tmp/test2.py')
t.close()

上传或者下载文件 - 通过用户名和密码

import paramikopravie_key_path = '/home/auto/.ssh/id_rsa'
key = paramiko.RSAKey.from_private_key_file(pravie_key_path)t = paramiko.Transport(('192.168.14.51',22))
t.connect(username='liu',pkey=key)sftp = paramiko.SFTPClient.from_transport(t)
sftp.put('/tmp/test3.py','/tmp/test3.py') t.close()import paramikopravie_key_path = '/home/auto/.ssh/id_rsa'
key = paramiko.RSAKey.from_private_key_file(pravie_key_path)t = paramiko.Transport(('192.168.14.51',22))
t.connect(username='liu',pkey=key)sftp = paramiko.SFTPClient.from_transport(t)
sftp.get('/tmp/test3.py','/tmp/test4.py') t.close()

上传或下载文件 - 通过密钥

内置模块

一、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下为"\t\n",Linux下为"\n"
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所指向的文件或者目录的最后修改时间

View Code

二、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]

View Code

三、hashlib

用于加密相关的操作，代替了md5模块和sha模块，主要提供 SHA1, SHA224, SHA256, SHA384, SHA512 ，MD5 算法

废弃的md5
import md5
hash = md5.new()
hash.update('admin')
print hash.hexdigest()废弃的sha
import shahash = 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()

View Code

以上加密算法虽然依然非常厉害，但时候存在缺陷，即：通过撞库可以反解。所以，有必要对加密算法中添加自定义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()

View Code

四、json 和 pickle

JSON(JavaScript Object Notation) 是一种轻量级的数据交换格式。它基于ECMAScript的一个子集。 JSON采用完全独立于语言的文本格式，但是也使用了类似于C语言家族的习惯(包括C、C++、Java、JavaScript、Perl、Python等)。这些特性使JSON成为理想的数据交换语言。易于人阅读和编写，同时也易于机器解析和生成(一般用于提升网络传输速率)。
JSON在python中分别由list和dict组成。

pickle模块实现了python的所有数据序列和反序列化。基本上功能使用和JSON模块没有太大区别，方法也同样是dumps/dump和loads/load。

与JSON不同的是pickle不是用于多种语言间的数据传输，它仅作为python对象的持久化或者python程序间进行互相传输对象的方法，因此它支持了python所有的数据类型。

pickle反序列化后的对象与原对象是等值的副本对象，类似与deepcopy。

简易来讲就是这两个模块是用于序列化的

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

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

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

import json
dic = {"name":"liu"}
data = json.dumps(dic)
f = open("Json_test","w")
f.write(data)
f.close()import json
f = open("Json_test","r")
json.load(f)
f.close()

import pickle
def foo():print("ok")
f = open("Pickle_test","wb")
data = pickle.dump(foo,f)
f.close()import pickle
def foo():print("ok")
f = open("Pickle_test","rb")
pickle.load(f)
f.close()

dumps:　　将对象序列化import json# 简单编码===========================================
print json.dumps(['foo', {'bar': ('baz', None, 1.0, 2)}])
# ["foo", {"bar": ["baz", null, 1.0, 2]}]#字典排序
print json.dumps({"c": 0, "b": 0, "a": 0}, sort_keys=True)
# {"a": 0, "b": 0, "c": 0}#自定义分隔符
print json.dumps([1,2,3,{'4': 5, '6': 7}], sort_keys=True, separators=(',',':'))
# [1,2,3,{"4":5,"6":7}]
print json.dumps([1,2,3,{'4': 5, '6': 7}], sort_keys=True, separators=('/','-'))
# [1/2/3/{"4"-5/"6"-7}]#增加缩进，增强可读性，但缩进空格会使数据变大
print json.dumps({'4': 5, '6': 7}, sort_keys=True,indent=2, separators=(',', ': '))
# {#   "4": 5,
#   "6": 7
# }# 另一个比较有用的dumps参数是skipkeys，默认为False。
# dumps方法存储dict对象时，key必须是str类型，如果出现了其他类型的话，那么会产生TypeError异常，如果开启该参数，设为True的话，会忽略这个key。
data = {'a':1,(1,2):123}
print json.dumps(data,skipkeys=True)
#{"a": 1}

dump:　　将对象序列化并保存到文件#将对象序列化并保存到文件
obj = ['foo', {'bar': ('baz', None, 1.0, 2)}]
with open(r"c:\json.txt","w+") as f:json.dump(obj,f)loads:　　将序列化字符串反序列化import jsonobj = ['foo', {'bar': ('baz', None, 1.0, 2)}]
a= json.dumps(obj)
print json.loads(a)
# [u'foo', {u'bar': [u'baz', None, 1.0, 2]}]
load:　　将序列化字符串从文件读取并反序列化with open(r"c:\json.txt","r") as f:print json.load(f)

json四个功能

自定义复杂数据类型编解码

例如我们碰到对象datetime，或者自定义的类对象等json默认不支持的数据类型时，我们就需要自定义编解码函数。有两种方法来实现自定义编解码。

方法一：自定义编解码函数

import datetime,jsondt = datetime.datetime.now()def time2str(obj):#python to jsonif isinstance(obj, datetime.datetime):json_str = {"datetime":obj.strftime("%Y-%m-%d %X")}return json_strreturn objdef str2time(json_obj):#json to pythonif "datetime" in json_obj:date_str,time_str = json_obj["datetime"].split(' ')date = [int(x) for x in date_str.split('-')]time = [int(x) for x in time_str.split(':')]dt = datetime.datetime(date[0],date[1], date[2], time[0],time[1], time[2])return dtreturn json_obja = json.dumps(dt,default=time2str)
print a
# {"datetime": "2016-10-27 17:38:31"}
print json.loads(a,object_hook=str2time)
# 2016-9-2 17:38:31

View Code

方法二：继承JSONEncoder和JSONDecoder类，重写相关方法

import datetime,jsondt = datetime.datetime.now()
dd = [dt,[1,2,3]]class MyEncoder(json.JSONEncoder):def default(self,obj):#python to jsonif isinstance(obj, datetime.datetime):json_str = {"datetime":obj.strftime("%Y-%m-%d %X")}return json_strreturn objclass MyDecoder(json.JSONDecoder):def __init__(self):json.JSONDecoder.__init__(self, object_hook=self.str2time)def str2time(self,json_obj):#json to pythonif "datetime" in json_obj:date_str,time_str = json_obj["datetime"].split(' ')date = [int(x) for x in date_str.split('-')]time = [int(x) for x in time_str.split(':')]dt = datetime.datetime(date[0],date[1], date[2], time[0],time[1], time[2])return dtreturn json_obj# a = json.dumps(dt,default=time2str)
a =MyEncoder().encode(dd)
print a
# [{"datetime": "2016-10-27 18:14:54"}, [1, 2, 3]]
print MyDecoder().decode(a)
# [datetime.datetime(2016, 9, 27, 18, 14, 54), [1, 2, 3]]

View Code

dumps/dump序列化from datetime import datetry:import cPickle as pickle    #python 2
except ImportError as e:import pickle   #python 3
src_dic = {"date":date.today(),"oth":([1,"a"],None,True,False),}
det_str = pickle.dumps(src_dic)
print det_str
# (dp1
# S'date'
# p2
# cdatetime
# date
# p3
# (S'\x07\xe0\n\x1b'
# tRp4
# sS'oth'
# p5
# ((lp6
# I1
# aS'a'
# aNI01
# I00
# tp7
# s.
with open(r"c:\pickle.txt","w") as f:pickle.dump(src_dic,f)loads/load反序列化from datetime import datetry:import cPickle as pickle    #python 2
except ImportError as e:import pickle   #python 3
src_dic = {"date":date.today(),"oth":([1,"a"],None,True,False),}
det_str = pickle.dumps(src_dic)
with open(r"c:\pickle.txt","r") as f:print pickle.load(f)
# {'date': datetime.date(2016, 9, 27), 'oth': ([1, 'a'], None, True, False)}

pickle 功能

JSON和pickle模块的区别

1、JSON只能处理基本数据类型。pickle能处理所有Python的数据类型。

2、JSON用于各种语言之间的字符转换。pickle用于Python程序对象的持久化或者Python程序间对象网络传输，但不同版本的Python序列化可能还有差异。

五、执行系统命令

可以执行shell命令的相关模块和函数有：

os.system
os.spawn*
os.popen* --废弃
popen2.* --废弃
commands.* --废弃，3.x中被移除

import commandsresult = commands.getoutput('cmd')
result = commands.getstatus('cmd')
result = commands.getstatusoutput('cmd')

commands

以上执行shell命令的相关的模块和函数的功能均在 subprocess 模块中实现，并提供了更丰富的功能。

call

执行命令，返回状态码

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

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

check_call

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

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

check_output

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

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 -> 同意使用 \n
startupinfo与createionflags只在windows下有效
将被传递给底层的CreateProcess()函数，用于设置子进程的一些属性，如：主窗口的外观，进程的优先级等等

import subprocess
ret1 = subprocess.Popen(["mkdir","t1"])
ret2 = subprocess.Popen("mkdir t2", shell=True)

执行普通命令

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

输入即可得到输出，如：ifconfig
输入进行某环境，依赖再输入，如：python

import subprocessobj = subprocess.Popen("mkdir t3", shell=True, cwd='/home/dev',)

View Code

import subprocessobj = subprocess.Popen(["python"], stdin=subprocess.PIPE, stdout=subprocess.PIPE, stderr=subprocess.PIPE)
obj.stdin.write('print 1 \n ')
obj.stdin.write('print 2 \n ')
obj.stdin.write('print 3 \n ')
obj.stdin.write('print 4 \n ')
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)

View Code

import subprocessobj = subprocess.Popen(["python"], stdin=subprocess.PIPE, stdout=subprocess.PIPE, stderr=subprocess.PIPE)
obj.stdin.write('print 1 \n ')
obj.stdin.write('print 2 \n ')
obj.stdin.write('print 3 \n ')
obj.stdin.write('print 4 \n ')out_error_list = obj.communicate()
print (out_error_list)

View Code

import subprocessobj = subprocess.Popen(["python"], stdin=subprocess.PIPE, stdout=subprocess.PIPE, stderr=subprocess.PIPE)
out_error_list = obj.communicate('print "hello"')
print(out_error_list)

View Code

六、logging

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

组成

主要分为四个部分：

Loggers：提供应用程序直接使用的接口
Handlers：将Loggers产生的日志传到指定位置
Filters：对输出日志进行过滤
Formatters：控制输出格式

import logginglogging.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')

等级：

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)

View Code

八、re

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

字符：

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

次数：

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

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

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

正则表达式
要匹配的字符串
标志位，用于控制正则表达式的匹配方式

import reobj = re.match('\d+', '123uuasf')
if obj:print（obj.group()）

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

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

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

3、group和groups

import re
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())结果
123abc456
123abc456
123
abc
('123', 'abc', '456')

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

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

import re
obj = re.findall('\d+', 'fa123uu888asf')
print (obj)结果
['123', '888']

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)结果
sbabcsb

相比于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)结果：
["'1 ", ' 2 ', ' ((60', '30', '1', '(9', '2', '5', '3', '7', '3', '99', '4', '2998', '10', '568', '14))', '(', '4', '3)', '(16', '3', "2) )'"]

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)结果：
['1-2*((60-30+', '-40-5', '*(9-2*5/3+7/3*99/4*2998+10*568/14))-(-4*3)/(16-3*2))']

#!/usr/bin/env python
# -*- coding:utf-8 -*-
"""
该计算器思路：1、递归寻找表达式中只含有 数字和运算符的表达式，并计算结果2、由于整数计算会忽略小数，所有的数字都认为是浮点型操作，以此来保留小数
使用技术：1、正则表达式2、递归执行流程如下：
******************** 请计算表达式： 1 - 2 * ( (60-30 +(-40.0/5) * (9-2*5/3 + 7 /3*99/4*2998 +10 * 568/14 )) - (-4*3)/ (16-3*2) ) ********************
before： ['1-2*((60-30+(-40.0/5)*(9-2*5/3+7/3*99/4*2998+10*568/14))-(-4*3)/(16-3*2))']
-40.0/5=-8.0
after： ['1-2*((60-30+-8.0*(9-2*5/3+7/3*99/4*2998+10*568/14))-(-4*3)/(16-3*2))']
========== 上一次计算结束 ==========
before： ['1-2*((60-30+-8.0*(9-2*5/3+7/3*99/4*2998+10*568/14))-(-4*3)/(16-3*2))']
9-2*5/3+7/3*99/4*2998+10*568/14=173545.880953
after： ['1-2*((60-30+-8.0*173545.880953)-(-4*3)/(16-3*2))']
========== 上一次计算结束 ==========
before： ['1-2*((60-30+-8.0*173545.880953)-(-4*3)/(16-3*2))']
60-30+-8.0*173545.880953=-1388337.04762
after： ['1-2*(-1388337.04762-(-4*3)/(16-3*2))']
========== 上一次计算结束 ==========
before： ['1-2*(-1388337.04762-(-4*3)/(16-3*2))']
-4*3=-12.0
after： ['1-2*(-1388337.04762--12.0/(16-3*2))']
========== 上一次计算结束 ==========
before： ['1-2*(-1388337.04762--12.0/(16-3*2))']
16-3*2=10.0
after： ['1-2*(-1388337.04762--12.0/10.0)']
========== 上一次计算结束 ==========
before： ['1-2*(-1388337.04762--12.0/10.0)']
-1388337.04762--12.0/10.0=-1388335.84762
after： ['1-2*-1388335.84762']
========== 上一次计算结束 ==========
我的计算结果： 2776672.69524
"""import redef compute_mul_div(arg):""" 操作乘除:param expression:表达式:return:计算结果"""val = arg[0]mch = re.search('\d+\.*\d*[\*\/]+[\+\-]?\d+\.*\d*', val)if not mch:returncontent = re.search('\d+\.*\d*[\*\/]+[\+\-]?\d+\.*\d*', val).group()if len(content.split('*'))>1:n1, n2 = content.split('*')value = float(n1) * float(n2)else:n1, n2 = content.split('/')value = float(n1) / float(n2)before, after = re.split('\d+\.*\d*[\*\/]+[\+\-]?\d+\.*\d*', val, 1)new_str = "%s%s%s" % (before,value,after)arg[0] = new_strcompute_mul_div(arg)def compute_add_sub(arg):""" 操作加减:param expression:表达式:return:计算结果"""while True:if arg[0].__contains__('+-') or arg[0].__contains__("++") or arg[0].__contains__('-+') or arg[0].__contains__("--"):arg[0] = arg[0].replace('+-','-')arg[0] = arg[0].replace('++','+')arg[0] = arg[0].replace('-+','-')arg[0] = arg[0].replace('--','+')else:breakif arg[0].startswith('-'):arg[1] += 1arg[0] = arg[0].replace('-','&')arg[0] = arg[0].replace('+','-')arg[0] = arg[0].replace('&','+')arg[0] = arg[0][1:]val = arg[0]mch = re.search('\d+\.*\d*[\+\-]{1}\d+\.*\d*', val)if not mch:returncontent = re.search('\d+\.*\d*[\+\-]{1}\d+\.*\d*', val).group()if len(content.split('+'))>1:n1, n2 = content.split('+')value = float(n1) + float(n2)else:n1, n2 = content.split('-')value = float(n1) - float(n2)before, after = re.split('\d+\.*\d*[\+\-]{1}\d+\.*\d*', val, 1)new_str = "%s%s%s" % (before,value,after)arg[0] = new_strcompute_add_sub(arg)def compute(expression):""" 操作加减乘除:param expression:表达式:return:计算结果"""inp = [expression,0]# 处理表达式中的乘除
    compute_mul_div(inp)# 处理
    compute_add_sub(inp)if divmod(inp[1],2)[1] == 1:result = float(inp[0])result = result * -1else:result = float(inp[0])return resultdef exec_bracket(expression):""" 递归处理括号，并计算:param expression: 表达式:return:最终计算结果"""# 如果表达式中已经没有括号，则直接调用负责计算的函数，将表达式结果返回，如：2*1-82+444if not re.search('\(([\+\-\*\/]*\d+\.*\d*){2,}\)', expression):final = compute(expression)return final# 获取 第一个 只含有 数字/小数 和 操作符 的括号# 如：#    ['1-2*((60-30+(-40.0/5)*(9-2*5/3+7/3*99/4*2998+10*568/14))-(-4*3)/(16-3*2))']#    找出：(-40.0/5)content = re.search('\(([\+\-\*\/]*\d+\.*\d*){2,}\)', expression).group()# 分割表达式，即：# 将['1-2*((60-30+(-40.0/5)*(9-2*5/3+7/3*99/4*2998+10*568/14))-(-4*3)/(16-3*2))']# 分割更三部分：['1-2*((60-30+(    (-40.0/5)      *(9-2*5/3+7/3*99/4*2998+10*568/14))-(-4*3)/(16-3*2))']before, nothing, after = re.split('\(([\+\-\*\/]*\d+\.*\d*){2,}\)', expression, 1)print 'before：',expressioncontent = content[1:len(content)-1]# 计算，提取的表示 (-40.0/5)，并活的结果，即：-40.0/5=-8.0ret = compute(content)print '%s=%s' %( content, ret)# 将执行结果拼接，['1-2*((60-30+(      -8.0     *(9-2*5/3+7/3*99/4*2998+10*568/14))-(-4*3)/(16-3*2))']expression = "%s%s%s" %(before, ret, after)print 'after：',expressionprint "="*10,'上一次计算结束',"="*10# 循环继续下次括号处理操作，本次携带者的是已被处理后的表达式，即：# ['1-2*((60-30+   -8.0  *(9-2*5/3+7/3*99/4*2998+10*568/14))-(-4*3)/(16-3*2))']# 如此周而复始的操作，直到表达式中不再含有括号return exec_bracket(expression)# 使用 __name__ 的目的：
#   只有执行 python index.py 时，以下代码才执行
#   如果其他人导入该模块，以下代码不执行
if __name__ == "__main__":#print '*'*20,"请计算表达式：", "1 - 2 * ( (60-30 +(-40.0/5) * (9-2*5/3 + 7 /3*99/4*2998 +10 * 568/14 )) - (-4*3)/ (16-3*2) )" ,'*'*20#inpp = '1 - 2 * ( (60-30 +(-40.0/5) * (9-2*5/3 + 7 /3*99/4*2998 +10 * 568/14 )) - (-4*3)/ (16-3*2) ) 'inpp = "1-2*-30/-12*(-20+200*-3/-200*-300-100)"#inpp = "1-5*980.0"inpp = re.sub('\s*','',inpp)# 表达式保存在列表中result = exec_bracket(inpp)print result

大王版计算器

#__author__:Administrator
#__date__:2016/9/13
import re
def mi(arg):while True:relust = re.split("(\d+\.?\d*-?[*]{2}-?\d+\.?\d*)", arg, 1)if len(relust) == 3:x = relust[0]y = relust[1]z = relust[2]if "**" in y:start,end = y.split("**")finlly = float(start) ** float(end)arg = x + str(finlly) + zelse:return arg
def chengchu(arg):while True:                                                                 #while循环每一次传进来的运算arg = arg.replace("++","+")arg = arg.replace("+-","-")arg = arg.replace("-+","-")arg = arg.replace("--","+")arg = arg.replace("*+","*")arg = arg.replace("/+","/")relust = re.split("(\d+\.?\d*-?[*/]-?\d+\.?\d*)",arg,1)              #把从左往右第一次匹配到得乘法if len(relust) ==3:x = relust[0]y = relust[1]z = relust[2]if "*" in y :start,end = y.split("*")                                 #用“*”把分割开赋值给start，endfinlly = float(start) * float(end)                             #运算出乘法arg = x+str(finlly)+z                                #替换原来的运算式else:start, end = y.split("/")                                #用/分割开赋值给start，endfinlly = float(start) / float(end)arg = x + str(finlly) + z                             #替换原来的元算式else:return arg                                                         #将运算结果返回去
def jiajian(arg):result = re.findall("[+-]?\d+\.?\d*",arg)                            #列出所有的元素start = 0                                                                  #定义空值依次去加for i in result:start += float(i)                                       #所有元素相加return start                                                     #返回运算结果
def jisuan(source):while True:source = source.replace(" ", "")                                       #去掉空格res = re.split("\(([^()]*)\)",source,1)                                   #先取出括号里面的值if len(res) ==3:x = res[0]                                                          #分别将元素赋值给三个值y = res[1]z = res[2]powe = mi(y)ch = chengchu(powe)                                        #执行乘除jj = jiajian(ch)                                                 #执行加减res = x + str(jj) + z                                      #运算结果替换原来等式source = res                                                            #赋值给其他传进来元素else:                                                              #没括号得等式powe = mi(source)ch = chengchu(powe)                                             #计算乘法法jj = jiajian(ch)                                                 #计算加法source = jjreturn source
while True:choice = input("请输入计算等式(q\退出):")if choice =="q":print("再见！")breakelif choice == "":print("-----请输入算式-----")continueelif re.findall("[a-zA-Z@#￥%&]", choice):print("--输入不规范,请输入算式!--")continueelse:value = jisuan(choice)print("计算结果为:%s" % value)print("eval结果为:%s" % eval(choice))

自己版计算器

九、random

随机数

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

import random
checkcode = ''
for i 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)

随机验证码实例

转载于:https://www.cnblogs.com/lst1010/p/6561129.html