devbox
你好赵伟
这个屌丝很懒，什么也没留下！
关注作者
热门标签
热门文章
当前位置:   article > 正文

Python 动物专家识别系统_用python编写动物识别系统

作者：你好赵伟 | 2024-04-08 05:48:12

赞

踩

用python编写动物识别系统
  1. from tkinter import *
  2. import copy
  3.  
  4. def find_data(process_data_list):
  5.     # 依次进行循环查找并对过程排序
  6.     #print(data_process_list)
  7.     #print(data_result_list)
  8.     #print(dict_input)
  9.     for p, data_process in enumerate(data_process_list):
  10.         # 用于判断此过程是否成立
  11.         count = 0
  12.         #print(process_data_list)
  13.         #print(data_process)
  14.         for i in process_data_list:
  15.             if i in data_process:
  16.                 #print(i+'1')
  17.                 count += 1
  18.         # 过程成立则数值相同，可以进入下一步
  19.         if count == len(data_process):
  20.             # 此过程中结果是否为最终结果，不是将此过程结果加入到过程中
  21.             if data_result_list[p] not in result_list:
  22.                 # 弹出过程和此过程结果，因为此过程已经进行过，此结果存入需要查找的过程中
  23.                 result = data_result_list.pop(p)
  24.                 process = data_process_list.pop(p)
  25.                 #ins1(result,process)
  26.                 # 判断结果是否已经存在过程中，存在则重新寻找，不存在则加入过程，并将其存入最终结果
  27.                 if result not in process_data_list:
  28.                     dict_input['，'.join(process)] = result
  29.                     end_result = find_data(process_data_list + [result])
  30.                     if end_result == 1:
  31.                         return 1
  32.                     else:
  33.                         return 0
  34.                 # 存在则直接寻找
  35.                 else:
  36.                     end_result = find_data(process_data_list)
  37.                     if end_result == 1:
  38.                         return 1
  39.                     else:
  40.                         return 0
  41.             # 找到最终结果，取出结果后返回
  42.             else:
  43.                 process = data_process_list.pop(p)
  44.                 dict_input['，'.join(process)] = data_result_list[p]
  45.                 return 1
  46.     return 0
  47. def ini1(data_process_list, data_result_list):
  48.     Lstbox1.delete(0, END)
  49.     for item in data_process_list:
  50.         Lstbox1.insert(END, item)
  51.     Lstbox2.delete(0, END)
  52.     for item in data_result_list:
  53.         Lstbox2.insert(END, item)
  54.  
  55.  
  56. def clear():
  57.     Lstbox1.delete(0, END)
  58.     Lstbox2.delete(0, END)
  59.     txt.delete(1.0,END)
  60.  
  61.  
  62. def ins1(x,y):
  63.     Lstbox1.insert(Lstbox1.size(),x)
  64.     Lstbox2.insert(Lstbox2.size(),y)
  65.  
  66. def ins():
  67.     if entry.get() != '':
  68.         if Lstbox1.curselection() == ():
  69.             Lstbox1.insert(Lstbox1.size(), entry.get())
  70.         else:
  71.             Lstbox1.insert(Lstbox1.curselection(), entry.get())
  72.         s = entry.get()
  73.         global data_process_list
  74.         data_process_list.append(s)
  75.  
  76.  
  77. def ins2():
  78.     if entry.get() != '':
  79.         if Lstbox2.curselection() == ():
  80.             Lstbox2.insert(Lstbox2.size(), entry.get())
  81.             # s = entry.get()
  82.             # t = Lstbox2.size()
  83.             # global data_result_list
  84.             # data_result_list[t] = s
  85.         else:
  86.             Lstbox2.insert(Lstbox2.curselection(), entry.get())
  87.             # s = entry.get()
  88.             # t = Lstbox2.curselection()
  89.             # global data_result_list
  90.             # data_result_list[t] = s
  91.         s = entry.get()
  92.         global data_result_list
  93.         data_result_list.append(s)
  94.  
  95.  
  96. def updt():
  97.     if entry.get() != '' and Lstbox1.curselection() != ():
  98.         selected = Lstbox1.curselection()[0]
  99.         Lstbox1.delete(selected)
  100.         Lstbox1.insert(selected, entry.get())
  101.         s1 = entry.get()
  102.         global data_process_list
  103.         data_process_list[selected] = s1
  104.         s = '你已经成功修改'
  105.         gettt(s)
  106.  
  107. def updt1():
  108.     if entry.get() != '' and Lstbox2.curselection() != ():
  109.         selected = Lstbox2.curselection()[0]
  110.         Lstbox2.delete(selected)
  111.         Lstbox2.insert(selected, entry.get())
  112.         s1 = entry.get()
  113.         global data_result_list
  114.         data_result_list[selected]=s1
  115.         s = '你已经成功修改'
  116.         gettt(s)
  117.  
  118.  
  119.  
  120. def delt():
  121.     if Lstbox1.curselection() != ():
  122.         t = list(Lstbox1.curselection())
  123.         Lstbox1.delete(Lstbox1.curselection())
  124.         Lstbox2.delete(t)
  125.         t1 = Lstbox1.curselection()
  126.         global data_process_list
  127.         del data_process_list[t1]
  128.         global data_result_list
  129.         del data_result_list[t1]
  130.         s='你已经成功删除'
  131.         gettt(s)
  132.  
  133. def gettt(s):
  134.     txt.delete(1.0,END)
  135.     txt.insert(END, s)
  136.  
  137.  
  138. def plus():
  139.     term=entry.get()
  140.     #print(term)
  141.     if term=='0':
  142.         entry.delete(0,'end')
  143.         #print(list_data)
  144.         global data_result_list
  145.         tdataq_result_list=data_result_list.copy()
  146.         global dict_input
  147.         dict_input.clear()
  148.         global data_process_list
  149.         tdata_process_list=data_process_list.copy()
  150.         end_result = find_data(list_data)
  151.         data_result_list=tdataq_result_list
  152.         data_process_list=tdata_process_list
  153.         print(data_result_list)
  154.         print(dict_input)
  155.         print(end_result)
  156.         if end_result == 1:
  157.             s='推理：'+'\n'
  158.             s3='综合数据库：'
  159.             s3 = s3 + ' '.join(list_data) + ' '
  160.             # 将结果进行打印
  161.             for i in dict_input.keys():
  162.  
  163.                 if dict_input[i] not in result_list:
  164.                     s3 = s3 + dict_input[i] + ' '
  165.                 s1=i+'-->'+dict_input[i]+'\n'
  166.                 s=s+s1
  167.                 #print(s)
  168.                 #print(f"{i}->{dict_input[i]}")
  169.                 # 得到最终结果即输出所识别动物
  170.                 if dict_input[i] in result_list:
  171.                     s2='所识别的动物为'+dict_input[i]+'\n'
  172.                     s=s+s2
  173.             s=s3+'\n'+s
  174.             gettt(s)
  175.         else:
  176.             # 将结果进行打印
  177.             s3 = '综合数据库：'
  178.             s3 = s3 + ' '.join(list_data) + ' '
  179.  
  180.             for i in dict_input.keys():
  181.                 s1='推理：'
  182.  
  183.                 if dict_input[i] not in result_list:
  184.                     s3 = s3 + dict_input[i] + ' '
  185.  
  186.                 s=i+'->'+dict_input[i]+'\n'+'并未得出最终结论，请继续补充事实'
  187.                 s=s3+'\n'+s1+s
  188.                 #print(s)
  189.                 gettt(s)
  190.  
  191.  
  192.     if term:
  193.             if database[term] not in list_data:
  194.                 list_data.append(database[term])
  195.     else:
  196.         s='输入为空'
  197.         gettt(s)
  198.     entry.delete(0,'end')
  199.     # 打印前提条件
  200.     s='前提条件为：'
  201.     s1=' '.join(list_data) + '\n'
  202.     s1=s+s1
  203.     gettt(s1)
  204.     # 进行递归查找，直到找到最终结果,返回1则找到最终结果
  205.  
  206.  
  207. # 用于储存中间过程
  208. global data_process_list
  209. data_process_list = []
  210. # 用于存储过程对应的结果
  211. global data_result_list
  212. data_result_list = []
  213. # 存储用于查询的数据
  214. global list_data
  215. list_data = []
  216. # 用于存储输出结果
  217. global dict_input
  218. dict_input = {}
  219. #做一个联系
  220. dict1={}
  221. # 规则库
  222. txt = '''有毛发，是哺乳动物
  223. 有奶，是哺乳动物
  224. 有羽毛，是鸟
  225. 会飞，会下蛋，是鸟
  226. 吃肉，是肉食动物
  227. 有犬齿，有爪，眼盯前方，是食肉动物
  228. 是哺乳动物，有蹄，是蹄类动物
  229. 是哺乳动物，是咀嚼反刍动物，是蹄类动物
  230. 是哺乳动物，是肉食动物，是黄褐色，身上有暗斑点，金钱豹
  231. 是哺乳动物，是肉食动物，是黄褐色，身上有黑色条纹，虎
  232. 是蹄类动物，有长脖子，有长腿，身上有暗斑点，长颈鹿
  233. 是蹄类动物，身上有黑色条纹，斑马
  234. 是鸟，有长脖子，有长腿，不会飞，有黑白二色，鸵鸟
  235. 是鸟，会游泳，不会飞，有黑白二色，企鹅
  236. 是鸟，善飞，信天翁'''
  237. # 将数据预处理
  238. datas = txt.split('\n')
  239. #print(datas)
  240. for data in datas:
  241.     data = data.split('，')
  242.     data_process_list.append(data[:-1])
  243.     #print(data_process_list)
  244.     data_result_list.append(data[-1].replace('\n', ''))
  245.     # print(data_result_list)
  246. result_list = ['信天翁', '鸵鸟', '斑马', '长颈鹿', '虎', '金钱豹', '企鹅']
  247.     # 数据库对应的过程
  248. database = {'有毛发': '有毛发', '有奶': '有奶', '有羽毛': '有羽毛', '会飞': '会飞', '会下蛋': '会下蛋', '吃肉': '吃肉', '有犬齿': '有犬齿',
  249.             '有爪': '有爪', '眼盯前方': '眼盯前方', '有蹄': '有蹄', '是咀嚼反刍动物': '是咀嚼反刍动物', '是黄褐色': '是黄褐色', '身上有暗斑点': '身上有暗斑点', '身上有黑色条纹': '身上有黑色条纹',
  250.             '有长脖子': '有长脖子', '有长腿': '有长腿', '不会飞': '不会飞', '会游泳': '会游泳', '有黑白二色': '有黑白二色', '善飞': '善飞', '是哺乳动物': '是哺乳动物',
  251.             '是鸟': '是鸟', '是食肉动物': '是食肉动物', '是蹄类动物': '是蹄类动物', '金钱豹': '金钱豹', '虎': '虎', '长颈鹿': '长颈鹿', '斑马': '斑马',
  252.             '鸵鸟': '鸵鸟', '企鹅': '企鹅', '信天翁': '信天翁'}
  253.  
  254.  
  255. root = Tk()
  256. root.title('夏雨花费脑筋的动物专家识别系统')
  257. root.geometry('900x600')
  258.  
  259. frame1 = Frame(root, relief=RAISED)
  260. frame1.place(relx=0.0)
  261.  
  262. frame3 = Frame(root, relief=RAISED)
  263. frame3.place(relx=0.2)
  264.  
  265. frame4 = Frame(root, relief=RAISED)
  266. frame4.place(relx=0.4,relheight=0.4,width=300)
  267.  
  268. frame2 = Frame(root, relief=GROOVE)
  269. frame2.place(relx=0.8)
  270.  
  271. Lstbox1 = Listbox(frame1)
  272. Lstbox1.pack()
  273.  
  274. Lstbox2 = Listbox(frame3)
  275. Lstbox2.pack()
  276.  
  277. txt=Text(frame4)
  278. txt.pack()
  279.  
  280. entry = Entry(frame2)
  281. entry.pack()
  282.  
  283. btn1 = Button(frame2, text='初始化', command=lambda: ini1(data_process_list, data_result_list))
  284. btn1.pack(fill=X)
  285.  
  286. btn2 = Button(frame2, text='添加', command=ins)
  287. btn2.pack(fill=X)
  288.  
  289. btn3 = Button(frame2, text='添加2', command=ins2)  # 添加和插入功能实质上是一样的
  290. btn3.pack(fill=X)
  291.  
  292. btn4 = Button(frame2, text='修改', command=updt)
  293. btn4.pack(fill=X)
  294.  
  295. btn9 = Button(frame2, text='修改2', command=updt1)
  296. btn9.pack(fill=X)
  297.  
  298. btn5 = Button(frame2, text='删除', command=delt)
  299. btn5.pack(fill=X)
  300.  
  301. btn6 = Button(frame2, text='清空', command=clear)
  302. btn6.pack(fill=X)
  303.  
  304. btn7 = Button(frame2, text='查找', command=lambda:find_data(list_data))
  305. btn7.pack(fill=X)
  306.  
  307. btn8 = Button(frame2, text='加入', command=plus)
  308. btn8.pack(fill=X)
  309. # 最终结果列表
  310.  
  311.  
  312.  
  313.  
  314. root.mainloop()

 其实也是参照了其他博主的代码，然后改了一些，添加了一些自己的东西

声明：本文内容由网友自发贡献，不代表【wpsshop博客】立场，版权归原作者所有，本站不承担相应法律责任。如您发现有侵权的内容，请联系我们。转载请注明出处：https://www.wpsshop.cn/w/你好赵伟/article/detail/383380
推荐阅读
相关标签

Copyright © 2003-2013 www.wpsshop.cn 版权所有，并保留所有权利。

  

闽ICP备14008679号