day5(老男孩-Python3.5-S14期全栈开发)

作者：赵俊            发布日期：2020/09/03

三、模块定义、导入、优化详解1

1、定义

　　模块：用来从逻辑上组织python代码，本质就是.py结尾的一个python文件

　　包：从逻辑上组织模块，本质就是一个目录（必须带有一个__init__.py文件）

2、导入方法

　　导入单个模块>>>>>import 模块名

　　导入多个模块>>>>>import 模块名1，模块名2，............

　　以上导入使用时格式，模块名.变量或函数名()

　　直接导入所有>>>>>from 模块名 import *(不建议这么使用，会和本身代码中的函数冲突)

　　直接导入函数或变量>>>>>from 模块名 import 函数名

　　直接导入函数或变量>>>>>from 模块名 import 函数名 as 别名，调用时使用别名，避免冲突

　　以上导入使用时格式，直接使用变量或函数名()

3、import本质

　　导入模块的本质就是把python文件解释一遍

　　导入包的本质就是执行包下面的init.py文件

四、模块定义、导入、优化详解2

在__init__.py文件里直接使用import好像不起作用，使用from . import module可以导入模块

导入优化 -----------from 模块名 import 函数名，使用这个避免了重复查找模块，提高程序效率

五、内置模块详解之time与datetime模块

 python模块的分类：

　　标准库，系统自带的模块

　　开源模块，程序爱好者开发并开源的模块

　　自定义模块，自己写的模块

1、time模块

　　在python中有三种表示时间的方式：

　　　　1）时间戳，是当下时间与1970年1月1日零时零分零秒的一个时间差

　　　　2）格式化的时间字符串

　　　　3）元祖（共九个元素） 返回值分别代表，年/月/日/时/分/秒/一周第几天/一年第几天/夏令时

# Author:ZHJ
import time
print(time.sleep(1))  # 休眠几秒
#返回元祖的语句
print("返回元祖------------------------------------------------------")
print(time.gmtime())  # 传入时间戳参数，返回元祖形式时间，转换的时间是UTC时间，不是当地时间
print(time.localtime())  # 传入时间戳参数，返回元祖形式时间，转换的时间是本地时间（UTC+8）
print(time.strptime("2803-2>>12","%Y-%m>>%d"))  # 传入需要的格式化的字符串时间和格式标注，返回元祖
print("返回秒------------------------------------------------------")
#返回秒的语句
print(time.timezone)  # 本地标准时间与标准UTC的时间差，单位为秒，除以3600就为时区，负数为东，正数为西
print(time.altzone)  # 本地夏令时间与标准UTC的时间差，单位为秒
print("返回时间戳------------------------------------------------------")
#返回时间戳
print(time.time())  # 获取时间戳
x = time.localtime()
print(time.mktime(x))  # 传入元祖，返回时间戳
print("返回格式化字符串------------------------------------------------------")
#返回格式化字符串时间
print(time.strftime("%Y-%m>>%d", x))  # 传入需要的标准格式和元祖，返回格式化的字符串时间
print(time.asctime())  # 传入元祖，返回格式化字符串时间，没有传变量使用当前时间元祖
print(time.ctime())  # 传入秒，返回格式化字符串时间，没有传变量使用当前时间秒
"""
    strftime格式化
    %Y  Year with century as a decimal number.
    %m  Month as a decimal number [01,12].
    %d  Day of the month as a decimal number [01,31].
    %H  Hour (24-hour clock) as a decimal number [00,23].
    %M  Minute as a decimal number [00,59].
    %S  Second as a decimal number [00,61].
    %z  Time zone offset from UTC.
    %a  Locale's abbreviated weekday name.
    %A  Locale's full weekday name.
    %b  Locale's abbreviated month name.
    %B  Locale's full month name.
    %c  Locale's appropriate date and time representation.
    %I  Hour (12-hour clock) as a decimal number [01,12].
    %p  Locale's equivalent of either AM or PM.
"""

None
返回元祖------------------------------------------------------
time.struct_time(tm_year=2020, tm_mon=8, tm_mday=26, tm_hour=3, tm_min=41, tm_sec=13, tm_wday=2, tm_yday=239, tm_isdst=0)
time.struct_time(tm_year=2020, tm_mon=8, tm_mday=26, tm_hour=11, tm_min=41, tm_sec=13, tm_wday=2, tm_yday=239, tm_isdst=0)
time.struct_time(tm_year=2803, tm_mon=2, tm_mday=12, tm_hour=0, tm_min=0, tm_sec=0, tm_wday=2, tm_yday=43, tm_isdst=-1)
返回秒------------------------------------------------------
-28800
-32400
返回时间戳------------------------------------------------------
1598413273.624613
1598413273.0
返回格式化字符串------------------------------------------------------
2020-08>>26
Wed Aug 26 11:41:13 2020
Wed Aug 26 11:41:13 2020

2、datetime模块

# Author:ZHJ
import datetime

print(datetime.datetime.now()) # 返回2020-08-26 11:46:14.354203
print(datetime.datetime.now() + datetime.timedelta(3)) # 返回三天后时间2020-08-29 11:47:53.891897
print(datetime.datetime.now() + datetime.timedelta(hours=3)) # 返回三小时后时间2020-08-26 14:48:56.034451
print(datetime.datetime.now() + datetime.timedelta(minutes=30)) # 返回30分钟后时间2020-08-26 12:19:50.847586
# 需要之前时间传递参数为负值


# 时间替换,不是真的改系统时间
print(datetime.datetime.now())
c_time = datetime.datetime.now()
print(c_time.replace(minute=30,hour=12))

六、内置模块详解之Random模块

 自己取文件名一定要与导入的模块名区别开，如果相同会导致导入模块错误

# Author:ZHJ
import random

# print(random.random())
print(random.random())  # 0-1的随机浮点数
print(random.randint(1, 5))  # 左闭右闭区间取随机整数
print(random.randrange(1, 2))  # 左闭右开区间取随机整数，random.randrange([start], stop[, step])
print(random.choice("asdfghjk1234567890"))  # 从序列中获取一个随机元素,list, tuple, 字符串都属于序列
print(random.sample("asdfg34sdfw34", 5))  # 从序列中随机获取5个元素，作为一个片断返回
print(random.uniform(1,2))  # 区间随机浮点数

list_t = [1,2,3,5,5,15,12,5,1,25,12,]
random.shuffle(list_t)  # 将列表的元素打乱
print(list_t)

验证码
# Author:ZHJ
import random
code = ""
for i in random.sample("0123456789ABCDEFGHIJKLMNOPQRSTUVWXYZ", 5):
    code += i
print(code)

七、内置模块详解之OS模块

# Author:ZHJ
import  os
import time
# print(os.getcwd())  # 获取当前工作目录，及当前python脚本目录路径
# print(os.chdir("F:\Python\Project"))  # 改变当前脚本的工作目录
# print(os.curdir)  # 返回当前目录
# os.makedirs("aa/bb/cc")  # 可生成多层递归目录,注意反斜杠
# os.removedirs("aa/bb/cc")  # 若目录为空则删除，递归到上一层，若也为空则山，以此类推
# os.mkdir("cc") # 生成单级目录
# os.rmdir("cc")  # 删除单级目录，非空则不删除，报错
# os.listdir("C:\\") # 列出目录下的所有子目录和文件，包括隐藏文件，返回列表
# os.remove("新建文本文档.txt")  # 删除指定文件
# os.rename("456.txt","123.txt")  # 重命名文件
# print(os.stat("F:\Python\Project\Day5")) #获取文件或目录信息
# print(os.sep)  # 输出操作系统路径分隔符
# print(os.linesep)  # 输出操作系统行终止符
# print(os.pathsep)  # 用于分割文件路径的字符串，就是环境 变量里分割路径的字符串
# print(os.name)  # 指示当前使用平台
# print(os.system("dir"))  # 指示当前使用平台,dos命令
# print(os.environ)  # 获取系统环境变量
# print(os.path.abspath(os.getcwd()))  # 返回path规范化的绝对路径
print(os.path.split(os.getcwd()))  # 将path分割成目录和文件名元组返回
print(os.path.dirname(os.getcwd()))  # 返回这个os.path.split返回元祖的第一个元素
print(os.path.basename(os.getcwd()))  # 返回这个os.path.split返回元祖的第二个元素
print(os.path.exists(os.getcwd()))  # 路径存在返回True，否则返回false
print(os.path.isabs(os.getcwd()))  # 是否是绝对路径
print(os.path.isfile(os.getcwd()))  # 路径是一个存在的文件返回True
print(os.path.isdir(os.getcwd()))  # 是否是一个目录
print(os.path.join(os.getcwd()),"/au")  # 多个路径组合后返回，第一个绝对路径前的参数将被忽略
print(time.ctime(os.path.getatime(r"F:\Python\Project\123.txt")))  # 路径所指文件或目录的最后访问时间
print(time.ctime(os.path.getmtime(r"F:\Python\Project\123.txt")))  # 路径所指文件或目录的最后修改时间

import sys,os
def run():
    print("sys.path[0]返回路径-----",sys.path[0])
    print("sys.argv[0]返回路径-----",sys.argv[0])
    print("os.getcwd()返回路径-----",os.getcwd())
    print("__file__返回路径-----",__file__)
    print("os.path.abspath('.')返回路径-----",os.path.abspath('.'))
    print("os.path.realpath('.')返回路径-----",os.path.realpath('.'))
run()

# 被调用时执行结果
# sys.path[0]返回路径----- F:\Python\Project\路径测试
# sys.argv[0]返回路径----- F:/Python/Project/路径测试/test.py
# os.getcwd()返回路径----- F:\Python\Project\路径测试
# __file__返回路径----- F:\Python\Project\路径测试\ad\sss\t.py
# os.path.abspath('.')返回路径----- F:\Python\Project\路径测试
# 自己执行结果
# sys.path[0]返回路径----- F:\Python\Project\路径测试\ad\sss
# sys.argv[0]返回路径----- F:/Python/Project/路径测试/ad/sss/t.py
# os.getcwd()返回路径----- F:\Python\Project\路径测试\ad\sss
# __file__返回路径----- F:/Python/Project/路径测试/ad/sss/t.py
# os.path.abspath('.')返回路径----- F:\Python\Project\路径测试\ad\sss

根据上面的执行结果，可以看出使用__file__形式可以保证路径的一致性

八、内置模块详解之Sys和shutil模块

 1、sys

import sys
x = sys.argv  # 接收命令行传递的参数
print(x)

x = sys.path  # 打印系统环境变量
print(x)

x = sys.version  # 获取解释器版本
print(x)

x = sys.platform  # 返回操作系统平台名称
print(x)

sys.stdout.write("输出的文本")  # print输出自动换行，这个不换行
print("输出的文本")  #

"""
sys.stdin.readline( )会将标准输入全部获取，包括末尾的'\n'，
因此用len计算长度时是把换行符'\n'算进去了的，但是input( )获取输入时返回的结果是不包含末尾的换行符'\n'的。
"""
print("请输入！")
x = sys.stdin.readline()  # input()括号内可以直接填写说明文字，sys.stdin还需要加个print方法给出提示信息。
print(x)
x = input("请输入！")
print(x)

x = sys.stdin.readline( )[:-1]  # 去掉结尾换行

2、shutil

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

import shutil
"""
必须先打开文件才可以复制
"""
# f1 = open("复制.txt", "r", encoding="utf-8")
# f2 = open("复制_副本.txt", "w", encoding="utf-8")
# shutil.copyfileobj(f1, f2, 20)

"""
直接给文件名，就可以复制，源文件必须存在
"""
# shutil.copyfile("复制.txt", "复制_副本.txt")

"""
递归的拷贝目录和文件
"""
# shutil.copytree("a", "aa")

"""
递归的删除目录和文件
"""
#shutil.rmtree("aa")

"""
shutil.make_archive(base_name, format,...)
base_name： 压缩包的文件名，也可以是压缩包的路径。只是文件名时，则保存至当前目录，否则保存至指定路径，
如：www                        =>保存至当前路径
如：/Users/wupeiqi/www =>保存至/Users/wupeiqi/
format： 压缩包种类，“zip”, “tar”, “bztar”，“gztar”
root_dir： 要压缩的文件夹路径（默认当前目录）
owner： 用户，默认当前用户
group： 组，默认当前组
logger： 用于记录日志，通常是logging.Logger对象
"""
shutil.make_archive("ATM", "zip", "F:\Python\Project\Day4") # 指定文件所在目录的所有文件打包

　　shutil 对压缩包的处理是调用 ZipFile 和 TarFile 两个模块来进行的

import 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()

九、内置模块详解之Shelve模块

 shelve模块是一个简单的k,v将内存数据通过文件持久化的模块，可以持久化任何pickle可支持的python数据格式

import shelve
"""
shelve模块是一个简单的k,v将内存数据通过文件持久化的模块
"""
d = shelve.open("test123")  # 文件可以不用存在
# d["a"] = [123, 244, "hello"]
# d.close()

print(d.get("a"))  # 取回时使用get方法

十、内置模块详解之Xml模块1

遍历

import xml.etree.ElementTree as ET
 
tree = ET.parse("xmltest.xml")
root = tree.getroot()
print(root.tag)
 
#遍历xml文档
for child in root:
    print(child.tag, child.attrib)
    for i in child:
        print(i.tag,i.text)
 
#只遍历year 节点
for node in root.iter('year'):
    print(node.tag,node.text)

十一、内置模块详解之Xml模块2

修改和删除xml文档内容

import xml.etree.ElementTree as ET
 
tree = ET.parse("xmltest.xml")
root = tree.getroot()
 
#修改
for node in root.iter('year'):
    new_year = int(node.text) + 1
    node.text = str(new_year)
    node.set("updated","yes")
 
tree.write("xmltest.xml")
 
 
#删除node
for country in root.findall('country'):
   rank = int(country.find('rank').text)
   if rank > 50:
     root.remove(country)
 
tree.write('output.xml')

自己创建xml文档

import xml.etree.ElementTree as ET
 
 
new_xml = ET.Element("namelist")
name = ET.SubElement(new_xml,"name",attrib={"enrolled":"yes"})
age = ET.SubElement(name,"age",attrib={"checked":"no"})
sex = ET.SubElement(name,"sex")
sex.text = '33'
name2 = ET.SubElement(new_xml,"name",attrib={"enrolled":"no"})
age = ET.SubElement(name2,"age")
age.text = '19'
 
et = ET.ElementTree(new_xml) #生成文档对象
et.write("test.xml", encoding="utf-8",xml_declaration=True)
 
ET.dump(new_xml) #打印生成的格式

十二、内置模块详解之Configparser模块

用于生成和修改常见配置文档，当前模块的名称在 python 3.x 版本中变更为 configparser。

来看一个好多软件的常见文档格式如下

[DEFAULT]
ServerAliveInterval = 45
Compression = yes
CompressionLevel = 9
ForwardX11 = yes
 
[bitbucket.org]
User = hg
 
[topsecret.server.com]
Port = 50022
ForwardX11 = no

如果想用python生成一个这样的文档怎么做呢？

import configparser
 
config = configparser.ConfigParser()
config["DEFAULT"] = {'ServerAliveInterval': '45',
                      'Compression': 'yes',
                     'CompressionLevel': '9'}
 
config['bitbucket.org'] = {}
config['bitbucket.org']['User'] = 'hg'
config['topsecret.server.com'] = {}
topsecret = config['topsecret.server.com']
topsecret['Host Port'] = '50022'     # mutates the parser
topsecret['ForwardX11'] = 'no'  # same here
config['DEFAULT']['ForwardX11'] = 'yes'
with open('example.ini', 'w') as configfile:
   config.write(configfile)

写完了还可以再读出来

>>> import configparser
>>> config = configparser.ConfigParser()
>>> config.sections()
[]
>>> config.read('example.ini')
['example.ini']
>>> config.sections()
['bitbucket.org', 'topsecret.server.com']
>>> 'bitbucket.org' in config
True
>>> 'bytebong.com' in config
False
>>> config['bitbucket.org']['User']
'hg'
>>> config['DEFAULT']['Compression']
'yes'
>>> topsecret = config['topsecret.server.com']
>>> topsecret['ForwardX11']
'no'
>>> topsecret['Port']
'50022'
>>> for key in config['bitbucket.org']: print(key)
...
user
compressionlevel
serveraliveinterval
compression
forwardx11
>>> config['bitbucket.org']['ForwardX11']
'yes'

configparser增删改查语法

[section1]
k1 = v1
k2:v2
  
[section2]
k1 = v1
 
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"))

十三、内置模块详解之Hashlib、Hmac模块

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

import hashlib
 
m = hashlib.md5()
m.update(b"Hello")
m.update(b"It's me")
print(m.digest())
m.update(b"It's been a long time since last time we ...")
 
print(m.digest()) #2进制格式hash
print(len(m.hexdigest())) #16进制格式hash
'''
def digest(self, *args, **kwargs): # real signature unknown
    """ Return the digest value as a string of binary data. """
    pass
 
def hexdigest(self, *args, **kwargs): # real signature unknown
    """ Return the digest value as a string of hexadecimal digits. """
    pass
 
'''
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())

散列消息鉴别码，简称HMAC，是一种基于消息鉴别码MAC（Message Authentication Code）的鉴别机制。使用HMAC时,消息通讯的双方，通过验证消息中加入的鉴别密钥K来鉴别消息的真伪；

一般用于网络通信中消息加密，前提是双方先要约定好key,就像接头暗号一样，然后消息发送把用key把消息加密，接收方用key ＋ 消息明文再加密，拿加密后的值 跟 发送者的相对比是否相等，这样就能验证消息的真实性，及发送者的合法性了。

import hmac
2 h = hmac.new('中文'.encode(encoding="utf-8"), '中文怎么办'.encode(encoding="utf-8"))
print h.hexdigest()

十四、正则表达式Re模块使用详解

 用正则表达式符号

'.'     默认匹配除\n之外的任意一个字符，若指定flag DOTALL,则匹配任意字符，包括换行
'^'     匹配字符开头，若指定flags MULTILINE,这种也可以匹配上(r"^a","\nabc\neee",flags=re.MULTILINE)
'$'     匹配字符结尾，或e.search("foo$","bfoo\nsdfsf",flags=re.MULTILINE).group()也可以
'*'     匹配*号前的字符0次或多次，re.findall("ab*","cabb3abcbbac")  结果为['abb', 'ab', 'a']
'+'     匹配前一个字符1次或多次，re.findall("ab+","ab+cd+abb+bba") 结果['ab', 'abb']
'?'     匹配前一个字符1次或0次
'{m}'   匹配前一个字符m次
'{n,m}' 匹配前一个字符n到m次，re.findall("ab{1,3}","abb abc abbcbbb") 结果'abb', 'ab', 'abb']
'|'     匹配|左或|右的字符，re.search("abc|ABC","ABCBabcCD").group() 结果'ABC'
'(...)' 分组匹配，re.search("(abc){2}a(123|456)c", "abcabca456c").group() 结果 abcabca456c
 
 
'\A'    只从字符开头匹配，re.search("\Aabc","alexabc") 是匹配不到的
'\Z'    匹配字符结尾，同$
'\d'    匹配数字0-9
'\D'    匹配非数字
'\w'    匹配[A-Za-z0-9]
'\W'    匹配非[A-Za-z0-9]
's'     匹配空白字符、\t、\n、\r , re.search("\s+","ab\tc1\n3").group() 结果 '\t'
 
'(?P<name>...)' 分组匹配 re.search("(?P<province>[0-9]{4})(?P<city>[0-9]{2})(?P<birthday>[0-9]{4})","371481199306143242").groupdict("city") 结果{'province': '3714', 'city': '81', 'birthday': '1993'}

最常用的匹配语法

re.match 从头开始匹配
re.search 匹配包含
re.findall 把所有匹配到的字符放到以列表中的元素返回
re.splitall 以匹配到的字符当做列表分隔符
re.sub      匹配字符并替换

反斜杠的困扰
与大多数编程语言相同，正则表达式里使用"\"作为转义字符，这就可能造成反斜杠困扰。假如你需要匹配文本中的字符"\"，那么使用编程语言表示的正则表达式里将需要4个反斜杠"\\\\"：前两个和后两个分别用于在编程语言里转义成反斜杠，转换成两个反斜杠后再在正则表达式里转义成一个反斜杠。Python里的原生字符串很好地解决了这个问题，这个例子中的正则表达式可以使用r"\\"表示。同样，匹配一个数字的"\\d"可以写成r"\d"。有了原生字符串，你再也不用担心是不是漏写了反斜杠，写出来的表达式也更直观。

 

import re
info = "abbb3cabb3abc6bbac"
# x = re.match("ab*", info)  # 从头开始匹配,匹配一个
# x = re.search("ab*", info)  # 整个字符串，找到匹配样式的第一个位置，并返回一个相应的 匹配对象
# x = re.fullmatch("abbbcabb3abcbbac", info)  # 完全匹配，表达式和字符串完全一样
# lt1 = re.split("\d", info)  # 用正则表达式分开字符串，并返回列表
# lt2 = re.findall("ab{0,2}", info)  # 匹配所有， string 从左到右进行扫描，匹配按找到的顺序返回
# info = "heggfdello"
# lt3 = re.findall("e.+e", info)
# info = "576h"
# x = re.search("\A[0-9]+[a-z]$", info)
# print(lt1)
# print(lt2)
# print(lt3)
# if x:
#     print(x.group())
# else:
#     print("没有匹配对象")

#(?P<name>...)' 分组匹配 '
# 分割身份证号码案例
# x = re.search("(?P<province>[0-9]{2})(?P<city>[0-9]{2})(?P<county>[0-9]{2})(?P<birthday>[0-9]{8})(?P<ID>[0-9]{4})", "610121198711026734")
# if x:
#     print(x.groupdict())
# else:
#     print("没有匹配对象")

x = re.sub("[0-9]","@","cjh378jj68ubdh9jhd3du8",count= 2)  # 将字符串中的数字替换成@符号,count替换几次
print(x)

作业：开发一个简单的python计算器

1. 实现加减乘除及括号优先级解析
2. 用户输入 1 - 2 * ( (60-30 +(-40/5) * (9-2*5/3 + 7 /3*99/4*2998 +10 * 568/14 )) - (-4*3)/ (16-3*2) )等类似公式后，必须自己解析里面的(),+,-,*,/符号和公式(不能调用eval等类似功能偷懒实现)，运算后得出结果，结果必须与真实的计算器所得出的结果一致

　　过程中遇到的麻烦：

# int()函数里面不能传浮点数，但fload()函数里可以传整数

# TypeError: 'str' object is not callable
# 细看了一下代码，原来是之前将一个变量命名为 str，
# 之后又把它作为底层 str() 进行调用。其实这时候，它已经不再是 Python 的底层函数咯。

# 递归函数返回值为None 的问题，解决办法的思路就是：使每次递归都要能够执行到return语句 。

# 不匹配两边括号的正则，只匹配括号里内容(?<=\()[^\(\)]+(?=\))

# Author:ZHJ
import re
#  int()函数里面不能传浮点数，但fload()函数里可以传整数

#  TypeError: 'str' object is not callable
#  细看了一下代码，原来是之前将一个变量命名为 str，
#  之后又把它作为底层 str() 进行调用。其实这时候，它已经不再是 Python 的底层函数咯。

#递归函数返回值为None 的问题，解决办法的思路就是：使每次递归都要能够执行到return语句 。

# 不匹配两边括号的正则，只匹配括号里内容(?<=\()[^\(\)]+(?=\))

def calculate_dual(equation):
    """
    计算两个数值的加减乘除
    :param equation: 是一个字符串，例：3*4
    :return: 返回加减乘除的结果
    """
    if re.search("[0-9]+\*(\-?)[0-9]+",equation):  # 如果两个数相乘可以匹配到
        lt = re.split("\*", equation)  # 以乘号分割
        return float(lt[0]) * float(lt[1])  #分隔后两个列表元素相乘返回
    elif re.search("(\-?)[0-9]+\/(\-?)[0-9]+",equation):
        lt = re.split("\/", equation)
        return float(lt[0]) / float(lt[1])
    elif re.search("(\-?)[0-9]+\+(\-?)[0-9]+",equation):
        lt = re.split("\+", equation)
        return float(lt[0]) + float(lt[1])
    elif re.search("(\-?)[0-9]+\-(\-?)[0-9]+",equation):
        lt = re.split("\-", equation)
        return float(lt[0]) - float(lt[1])


def cl_mul_and_div(equation):
    """
    计算一个算式中的乘除，用正则匹配第一个乘或除，计算后替换原来算式，递归后接着算，知道匹配不上乘除
    说明式子中只剩加减；
    递归函数中是用返回值，返回none，需要在每一次递归时要执行返回值，需要把递归那一句代码也加return
    :param equation:
    :return:
    """
    # print(equation)
    z = re.search("[0-9]*\.?[0-9]+(\*|\/)(\-?)[0-9]*\.?[0-9]+",equation)
    if z:
        # print(z.group())
        t = re.sub(re.escape(z.group()), str(calculate_dual(z.group())),equation)
        # print(calculate_dual(z.group()))
        return cl_mul_and_div(t)
    else:
        # print("sss",equation)
        return equation


def cl_add_and_sub(equation):
    """
    计算一个算式中的加减，用正则匹配第一个加或减，计算后替换原来算式，递归后接着算，知道匹配不上加减
    说明已经算出结果
    :param equation:
    :return:
    """
    # print(equation)
    z = re.search("(\-?)[0-9]*\.?[0-9]+(\+|\-)[0-9]*\.?[0-9]+",equation)
    if z:
        # print(z.group())
        t = re.sub(re.escape(z.group()), str(calculate_dual(z.group())),equation)
        #print(t)
        return cl_add_and_sub(t)
    else:
        return equation


def cl_inner_brackets(p):
    """
    计算在括号里的算式
    :param p:
    :return:
    """
    return cl_add_and_sub(cl_mul_and_div(p))
def remove_brackets(s):
    """
    去掉两边的括号
    :param s:
    :return:
    """
    #print(s)
    return re.search("(?<=\()[^\(\)]+(?=\))", s).group()
def chu_li_fu_hao(s):
    """
    处理正负号
    :param s:
    :return:
    """
    # print("处理符号前",s)
    while True:
        a = re.search("(\+\-)", s)
        #print(a)
        b = re.search("(\-\-)", s)
        if a:
            s = re.sub(re.escape(a.group()), "-", s)
            # print("处理符号后",s)
        elif b:
            s = re.sub(re.escape(b.group()), "+", s)
            # print("处理符号后", s)
        else:
            return s
temp = "1-2*((60-30+(-40/5)*(9-2*5/3+7/3*99/4*2998+10*568/14))-(-4*3)/(16-3*2))"
# temp = "(9-10+5)*3+3-98/(4+99)*3/3+(1*6)"
def cl(temp):
    x = re.search("(\()[^\(\)]+(\))", temp)

    if x:
        # print("被替换的",x.group())
        # print("计算结果", remove_brackets(cl_inner_brackets(x.group())))
        t = re.sub(re.escape(x.group()),remove_brackets(cl_inner_brackets(x.group())),temp)

        t = chu_li_fu_hao(t)
        # print("ass",x)
        return cl(t)
    else:
        if re.search("[\+\-\*\/]", temp):
            # print(temp)
            w = chu_li_fu_hao(cl_inner_brackets(temp))
            return cl(w)
        else:
            return temp
print("user->",cl(temp))
print("eval->",eval(temp))

Python 递归函数返回值为None的解决办法

 https://blog.csdn.net/ha_hha/article/details/79393041

__file__