今日我们分享2个机器学习的实践代码海量文件遍历和简单计算器实现。

海量文件遍历

In [40]

!tree -L 3 ./data/

./data/
├── data19638
│   ├── insects
│   │   └── insects
│   └── insects.zip
└── data55217├── Zebra│   ├── others│   └── zebra crossing└── Zebra.zip7 directories, 2 files

In [41]

import zipfile
def unzip_data(src_path,target_path):# 解压原始数据集，将src_path路径下的zip包解压至target_path目录下if(not os.path.isdir(target_path)):     z = zipfile.ZipFile(src_path, 'r')z.extractall(path=target_path)z.close()unzip_data('data/data19638/insects.zip','data/data19638/insects')
unzip_data('data/data55217/Zebra.zip','data/data55217/Zebra')

In [42]

!tree -L 6 ./data/

17 directories, 2627 files

In [43]

import os"""
通过给定目录，统计所有的不同子文件类型及占用内存
"""
size_dict = {}
type_dict = {}
def get_size_type(path):files = os.listdir(path)for filename in files:temp_path = os.path.join(path, filename)if os.path.isdir(temp_path):# 递归调用函数，实现深度文件名解析get_size_type(temp_path)     elif os.path.isfile(temp_path):# 获取文件后缀type_name=os.path.splitext(temp_path)[1]   #无后缀名的文件if not type_name:type_dict.setdefault("None", 0)type_dict["None"] += 1size_dict.setdefault("None", 0)size_dict["None"] += os.path.getsize(temp_path)# 有后缀的文件else:type_dict.setdefault(type_name, 0)type_dict[type_name] += 1size_dict.setdefault(type_name, 0)# 获取文件大小size_dict[type_name] += os.path.getsize(temp_path)  

In [44]

path= "data/"
get_size_type(path)
for each_type in type_dict.keys():print ("%5s下共有【%5s】的文件【%5d】个,占用内存【%7.2f】MB" %     (path,each_type,type_dict[each_type],\size_dict[each_type]/(1024*1024)))
print("总文件数:  【%d】"%(sum(type_dict.values())))
print("总内存大小:【%.2f】GB"%(sum(size_dict.values())/(1024**3)))

data/下共有【 .png】的文件【  442】个,占用内存【   1.88】MB
data/下共有【 .zip】的文件【    2】个,占用内存【1182.19】MB
data/下共有【.jpeg】的文件【 2183】个,占用内存【1216.01】MB
data/下共有【 .xml】的文件【 1938】个,占用内存【   3.25】MB
总文件数:  【4565】
总内存大小:【2.35】GB

简单计算器实现

抽象出几个函数：

（1）弹栈时计算‘两个数字和运算符组成的算式’结果的函数。

（2）判断元素是数字还是运算符的函数。

（3）把算式处理成列表形式的函数。如：'-1-2*((-2+3)+(-2/2))' 应该处理成：['-1', '-', '2', '*', '(', '(', '-2', '+', '3', ')', '+', '(', '-2', '/', '2', ')', ')'] 。

（4）决策函数，决定应该是入栈，弹栈运算，还是弹栈丢弃。

（5）主函数，遍历算式列表，计算最终结果。

In [2]

import re

传入两个数字，一个运算符，根据运算符不同返回相应结果。即计算加减乘除

In [3]

def calculate(n1, n2, operator):''':param n1: float:param n2: float:param operator: + - * /:return: float'''result = 0if operator == "+":result = n1 + n2if operator == "-":result = n1 - n2if operator == "*":result = n1 * n2if operator == "/":result = n1 / n2return result

In [4]

 # 判断是否是运算符，如果是返回True
def is_operator(e):''':param e: str:return: bool'''opers = ['+', '-', '*', '/', '(', ')']return True if e in opers else False

In [5]

# 将算式处理成列表，解决-是负数还是减号
def formula_format(formula):# 去掉算式中的空格formula = re.sub(' ', '', formula)# 以 '横杠数字' 分割， 其中正则表达式：(\-\d+\.?\d*) 括号内：# \- 表示匹配横杠开头； \d+ 表示匹配数字1次或多次；\.?表示匹配小数点0次或1次;\d*表示匹配数字1次或多次。formula_list = [i for i in re.split('(\-\d+\.?\d*)', formula) if i]# 最终的算式列表final_formula = []for item in formula_list:# 第一个是以横杠开头的数字（包括小数）final_formula。即第一个是负数，横杠就不是减号if len(final_formula) == 0 and re.search('^\-\d+\.?\d*$', item):final_formula.append(item)continueif len(final_formula) > 0:# 如果final_formal最后一个元素是运算符['+', '-', '*', '/', '('], 则横杠数字不是负数if re.search('[\+\-\*\/\(]$', final_formula[-1]):final_formula.append(item)continue# 按照运算符分割开item_split = [i for i in re.split('([\+\-\*\/\(\)])', item) if i]final_formula += item_splitreturn final_formula

In [5]

def decision(tail_op, now_op):''':param tail_op: 运算符栈的最后一个运算符:param now_op: 从算式列表取出的当前运算符:return: 1 代表弹栈运算，0 代表弹运算符栈最后一个元素， -1 表示入栈'''# 定义4种运算符级别rate1 = ['+', '-']rate2 = ['*', '/']rate3 = ['(']rate4 = [')']if tail_op in rate1:if now_op in rate2 or now_op in rate3:# 说明连续两个运算优先级不一样，需要入栈return -1else:return 1elif tail_op in rate2:if now_op in rate3:return -1else:return 1elif tail_op in rate3:if now_op in rate4:return 0   # ( 遇上 ) 需要弹出 (，丢掉 )else:return -1  # 只要栈顶元素为(，当前元素不是)都应入栈。else:return -1

In [6]

def final_calc(formula_list):num_stack = []       # 数字栈op_stack = []        # 运算符栈for e in formula_list:operator = is_operator(e)if not operator:# 压入数字栈# 字符串转换为符点数num_stack.append(float(e))else:# 如果是运算符while True:# 如果运算符栈等于0无条件入栈if len(op_stack) == 0:op_stack.append(e)break# decision 函数做决策tag = decision(op_stack[-1], e)if tag == -1:# 如果是-1压入运算符栈进入下一次循环op_stack.append(e)breakelif tag == 0:# 如果是0弹出运算符栈内最后一个(, 丢掉当前)，进入下一次循环op_stack.pop()breakelif tag == 1:# 如果是1弹出运算符栈内最后两个元素，弹出数字栈最后两位元素。op = op_stack.pop()num2 = num_stack.pop()num1 = num_stack.pop()# 执行计算# 计算之后压入数字栈num_stack.append(calculate(num1, num2, op))# 处理大循环结束后 数字栈和运算符栈中可能还有元素 的情况while len(op_stack) != 0:op = op_stack.pop()num2 = num_stack.pop()num1 = num_stack.pop()num_stack.append(calculate(num1, num2, op))return num_stack, op_stack

In [1]

if __name__ == '__main__':formula = input('请输入：\n')# formula = "1 - 2 * ( (60-30 +(-40/5) * (9-2*5/3 + 7 /3*99/4*2998 +10 * 568/14 )) - (-4*3)/ (16-3*2))"print("算式：", formula)formula_list = formula_format(formula)result, _ = final_calc(formula_list)print("计算结果：", result[0])