Возникают ошибки при работе кода Python
Возникают подобные ошибки, как это исправить? Shadows name 'x' from outer scope
Shadows name 'y' from outer scope
Shadows name 'z' from outer scope
Shadows name 't1' from outer scope
Shadows name 't2' from outer scope
Shadows name 't3' from outer scope
Parameter 'process1' value is not used
Parameter 'process2' value is not used
Parameter 'process3' value is not used
Parameter 'process4' value is not used
Parameter 'process5' value is not used
Parameter 'process6' value is not used
Parameter 'res_list' value is not used
Shadows name 'res_list' from outer scope
Local variable 'process_list' value is not used
Local variable 'res_list' value is not used
Shadows name 'res_list' from outer scope
Local variable 'current_res' value is not used
Local variable 'st' value is not used
Local variable 'current' value is not used
Parameter 'event' value is not used
Shadows name 'x' from outer scope
Вот сам код:
#!/usr/bin/env python3
# -*- config: utf-8 -*-
from tkinter import *
import queue
import threading
import time
class QueueThread(threading.Thread):
def __init__(self, name):
threading.Thread.__init__(self)
self.name = name
def run(self) -> None:
print(f'Старт потока {self.name}')
process_queue()
print(f'Завершение потока {self.name}')
def process_queue():
while True:
try:
x = ps_queue.get(block=False)
process1 = idx[x]
y = ps_queue.get(block=False)
process2 = idx2[y]
z = ps_queue.get(block=False)
process3 = idx3[z]
t1 = ps_queue.get(block=False)
process4 = idx4[t1]
t2 = ps_queue.get(block=False)
process5 = idx5[t2]
t3 = ps_queue.get(block=False)
process6 = idx6[t3]
except queue.Empty:
return
else:
print_factors(x, y, z, t1, t2, t3, process1, process2, process3, process4, process5, process6, res_list)
time.sleep(1)
def print_factors(x, y, z, t1, t2, t3, process1, process2, process3, process4, process5, process6, res_list):
try:
for g in results:
process_list = g[x]
except KeyError:
res_list = []
current_res = []
st = time.time()
try:
begin = drop_list[x]
except KeyError:
begin = 1
for i in range(begin, x + 1):
current = time.time()
if i == x:
del idx[x]
elif y == 24:
term.insert(END, f'Процесс PID:1 перешел в состояние STATE - 1:\n'
f'Класс приоритета: {class_grades[x]}, PRIOR - {x} \n'
f'Время выполнения процесса - {t1}с \n \n'
f'----------------------------------------------------------------\n \n')
time.sleep(1.5)
term.insert(END, f'Процесс PID:1 перешел в состояние STATE - 2:\n'
f'Класс приоритета: {class_grades[x]}, PRIOR - {x} \n'
f'Время выполнения процесса - {t1}с \n \n'
f'----------------------------------------------------------------\n \n')
time.sleep(1.5)
term.insert(END, f'Процесс PID:1 перешел в состояние STATE - 4:\n'
f'Класс приоритета: {class_grades[x]}, PRIOR - {x} \n'
f'Время выполнения процесса - {t2}с \n \n'
f'----------------------------------------------------------------\n \n')
time.sleep(1.5)
term.insert(END, f'Процесс PID:2 перешел в состояние STATE - 1:\n'
f'Класс приоритета: {class_grades[y]}, PRIOR - {y} \n'
f'Время выполнения процесса - {t2}с \n \n'
f'----------------------------------------------------------------\n \n')
time.sleep(1.5)
term.insert(END, f'Процесс PID:2 перешел в состояние STATE - 2:\n'
f'Класс приоритета: {class_grades[y]}, PRIOR - {y} \n'
f'Время выполнения процесса - {t2}с \n \n'
f'----------------------------------------------------------------\n \n')
time.sleep(1.5)
term.insert(END, f'Процесс PID:2 перешел в состояние STATE - 16:\n'
f'Класс приоритета: {class_grades[y]}, PRIOR - {y} \n'
f'Время выполнения процесса - {t2}с \n \n'
f'----------------------------------------------------------------\n \n')
time.sleep(t2)
term.insert(END, f'Процесс PID:2 завершил работу, и перешел в состояние STATE - 8:\n'
f'Класс приоритета: {class_grades[y]}, PRIOR - {y} \n'
f'Время выполнения процесса - {t2}с \n \n'
f'----------------------------------------------------------------\n \n')
time.sleep(1.5)
term.insert(END, f'Процесс PID:3 перешел в состояние STATE - 1:\n'
f'Класс приоритета: {class_grades[z]}, PRIOR - {z} \n'
f'Время выполнения процесса - {t3}с \n \n'
f'----------------------------------------------------------------\n \n')
time.sleep(1.5)
term.insert(END, f'Процесс PID:3 перешел в состояние STATE - 2:\n'
f'Класс приоритета: {class_grades[z]}, PRIOR - {z} \n'
f'Время выполнения процесса - {t3}с \n \n'
f'----------------------------------------------------------------\n \n')
time.sleep(1.5)
term.insert(END, f'Процесс PID:3 перешел в состояние STATE - 4:\n'
f'Класс приоритета: {class_grades[x]}, PRIOR - {z} \n'
f'Время выполнения процесса - {t3}с \n \n'
f'----------------------------------------------------------------\n \n')
time.sleep(1.5)
term.insert(END, f'Процесс PID:1 перешел в состояние STATE - 16:\n'
f'Класс приоритета: {class_grades[x]}, PRIOR - {x} \n'
f'Время выполнения процесса - {t1}с \n \n'
f'----------------------------------------------------------------\n \n')
time.sleep(t1)
term.insert(END, f'Процесс PID:1 перешел в состояние STATE - 8:\n'
f'Класс приоритета: {class_grades[x]}, PRIOR - {x} \n'
f'Время выполнения процесса - {t1}с \n \n'
f'----------------------------------------------------------------\n \n')
time.sleep(1.5)
term.insert(END, f'Процесс PID:3 перешел в состояние STATE - 16:\n'
f'Класс приоритета: {class_grades[z]}, PRIOR - {z} \n'
f'Время выполнения процесса - {t3}с \n \n'
f'----------------------------------------------------------------\n \n')
time.sleep(t3)
term.insert(END, f'Процесс PID:3 перешел в состояние STATE - 8:\n'
f'Класс приоритета: {class_grades[z]}, PRIOR - {z} \n'
f'Время выполнения процесса - {t3}с \n \n'
f'----------------------------------------------------------------\n \n')
time.sleep(1.5)
break
elif x == 24:
term.insert(END, f'Процесс PID:1 перешел в состояние STATE - 1:\n'
f'Класс приоритета: {class_grades[x]}, PRIOR - {x} \n'
f'Время выполнения процесса - {t1}с \n \n'
f'----------------------------------------------------------------\n \n')
time.sleep(1.5)
term.insert(END, f'Процесс PID:1 перешел в состояние STATE - 2:\n'
f'Класс приоритета: {class_grades[x]}, PRIOR - {x} \n'
f'Время выполнения процесса - {t1}с \n \n'
f'----------------------------------------------------------------\n \n')
time.sleep(1.5)
term.insert(END, f'Процесс PID:1 перешел в состояние STATE - 16:\n'
f'Класс приоритета: {class_grades[x]}, PRIOR - {x} \n'
f'Время выполнения процесса - {t1}с \n \n'
f'----------------------------------------------------------------\n \n')
time.sleep(t1)
term.insert(END, f'Процесс PID:1 завершил работу, и перешел в состояние STATE - 8:\n'
f'Класс приоритета: {class_grades[x]}, PRIOR - {x} \n'
f'Время выполнения процесса - {t1}с \n \n'
f'----------------------------------------------------------------\n \n')
time.sleep(1.5)
term.insert(END, f'Процесс PID:2 перешел в состояние STATE - 1:\n'
f'Класс приоритета: {class_grades[y]}, PRIOR - {y} \n'
f'Время выполнения процесса - {t2}с \n \n'
f'----------------------------------------------------------------\n \n')
time.sleep(1.5)
term.insert(END, f'Процесс PID:2 перешел в состояние STATE - 2:\n'
f'Класс приоритета: {class_grades[y]}, PRIOR - {y} \n'
f'Время выполнения процесса - {t2}с \n \n'
f'----------------------------------------------------------------\n \n')
time.sleep(1.5)
term.insert(END, f'Процесс PID:2 перешел в состояние STATE - 16:\n'
f'Класс приоритета: {class_grades[y]}, PRIOR - {y} \n'
f'Время выполнения процесса - {t2}с \n \n'
f'----------------------------------------------------------------\n \n')
time.sleep(t2)
term.insert(END, f'Процесс PID:2 завершил работу, и перешел в состояние STATE - 8:\n'
f'Класс приоритета: {class_grades[y]}, PRIOR - {y} \n'
f'Время выполнения процесса - {t2}с \n \n'
f'----------------------------------------------------------------\n \n')
time.sleep(1.5)
term.insert(END, f'Процесс PID:3 перешел в состояние STATE - 1:\n'
f'Класс приоритета: {class_grades[z]}, PRIOR - {z} \n'
f'Время выполнения процесса - {t3}с \n \n'
f'----------------------------------------------------------------\n \n')
time.sleep(1.5)
term.insert(END, f'Процесс PID:3 перешел в состояние STATE - 2:\n'
f'Класс приоритета: {class_grades[z]}, PRIOR - {z} \n'
f'Время выполнения процесса - {t3}с \n \n'
f'----------------------------------------------------------------\n \n')
time.sleep(1.5)
term.insert(END, f'Процесс PID:3 перешел в состояние STATE - 16:\n'
f'Класс приоритета: {class_grades[z]}, PRIOR - {z} \n'
f'Время выполнения процесса - {t3}с \n \n'
f'----------------------------------------------------------------\n \n')
time.sleep(t3)
term.insert(END, f'Процесс PID:3 завершил работу, и перешел в состояние STATE - 8:\n'
f'Класс приоритета: {class_grades[z]}, PRIOR - {z} \n'
f'Время выполнения процесса - {t3}с \n \n'
f'----------------------------------------------------------------\n \n')
time.sleep(1.5)
break
elif z == 24:
term.insert(END, f'Процесс PID:1 перешел в состояние STATE - 1:\n'
f'Класс приоритета: {class_grades[x]}, PRIOR - {x} \n'
f'Время выполнения процесса - {t1}с \n \n'
f'----------------------------------------------------------------\n \n')
time.sleep(1.5)
term.insert(END, f'Процесс PID:1 перешел в состояние STATE - 2:\n'
f'Класс приоритета: {class_grades[x]}, PRIOR - {x} \n'
f'Время выполнения процесса - {t1}с \n \n'
f'----------------------------------------------------------------\n \n')
time.sleep(1.5)
term.insert(END, f'Процесс PID:1 перешел в состояние STATE - 4:\n'
f'Класс приоритета: {class_grades[x]}, PRIOR - {x} \n'
f'Время выполнения процесса - {t1}с \n \n'
f'----------------------------------------------------------------\n \n')
time.sleep(1.5)
term.insert(END, f'Процесс PID:3 перешел в состояние STATE - 1:\n'
f'Класс приоритета: {class_grades[z]}, PRIOR - {z} \n'
f'Время выполнения процесса - {t3}с \n \n'
f'----------------------------------------------------------------\n \n')
time.sleep(1.5)
term.insert(END, f'Процесс PID:3 перешел в состояние STATE - 2:\n'
f'Класс приоритета: {class_grades[z]}, PRIOR - {z} \n'
f'Время выполнения процесса - {t3}с \n \n'
f'----------------------------------------------------------------\n \n')
time.sleep(1.5)
term.insert(END, f'Процесс PID:3 перешел в состояние STATE - 16:\n'
f'Класс приоритета: {class_grades[z]}, PRIOR - {z} \n'
f'Время выполнения процесса - {t3}с \n \n'
f'----------------------------------------------------------------\n \n')
time.sleep(t3)
term.insert(END, f'Процесс PID:3 завершил работу, и перешел в состояние STATE - 8:\n'
f'Класс приоритета: {class_grades[z]}, PRIOR - {z} \n'
f'Время выполнения процесса - {t3}с \n \n'
f'----------------------------------------------------------------\n \n')
time.sleep(1.5)
term.insert(END, f'Процесс PID:1 перешел в состояние STATE - 16:\n'
f'Класс приоритета: {class_grades[x]}, PRIOR - {x} \n'
f'Время выполнения процесса - {t1}с \n \n'
f'----------------------------------------------------------------\n \n')
time.sleep(t1)
term.insert(END, f'Процесс PID:1 завершил работу, и перешел в состояние STATE - 8:\n'
f'Класс приоритета: {class_grades[x]}, PRIOR - {x} \n'
f'Время выполнения процесса - {t1}с \n \n'
f'----------------------------------------------------------------\n \n')
time.sleep(1.5)
term.insert(END, f'Процесс PID:2 перешел в состояние STATE - 1:\n'
f'Класс приоритета: {class_grades[y]}, PRIOR - {y} \n'
f'Время выполнения процесса - {t2}с \n \n'
f'----------------------------------------------------------------\n \n')
time.sleep(1.5)
term.insert(END, f'Процесс PID:2 перешел в состояние STATE - 2:\n'
f'Класс приоритета: {class_grades[y]}, PRIOR - {y} \n'
f'Время выполнения процесса - {t2}с \n \n'
f'----------------------------------------------------------------\n \n')
time.sleep(1.5)
term.insert(END, f'Процесс PID:2 перешел в состояние STATE - 16:\n'
f'Класс приоритета: {class_grades[y]}, PRIOR - {y} \n'
f'Время выполнения процесса - {t2}с \n \n'
f'----------------------------------------------------------------\n \n')
time.sleep(t2)
term.insert(END, f'Процесс PID:2 завершил работу, и перешел в состояние STATE - 8:\n'
f'Класс приоритета: {class_grades[y]}, PRIOR - {y} \n'
f'Время выполнения процесса - {t2}с \n \n'
f'----------------------------------------------------------------\n \n')
time.sleep(1.5)
break
def entry_get(event):
global idx, cm_list, ps_queue
command = en1.get()
term.insert(END, f'# {command} \n')
cm_list.append(command)
en1.delete(0, 'end')
if command == 'exit':
root.destroy()
elif command.startswith('add1 '):
parts = command.split(' ', maxsplit=3)
num = int(parts[1])
proc = float(0.5)
idx[num] = proc
ps_queue.put(num)
elif command.startswith('add2 '):
parts = command.split(' ', maxsplit=3)
num = int(parts[1])
proc = float(0.5)
idx2[num] = proc
ps_queue.put(num)
elif command.startswith('add3 '):
parts = command.split(' ', maxsplit=3)
num = int(parts[1])
proc = float(0.5)
idx3[num] = proc
ps_queue.put(num)
elif command.startswith('addt1 '):
parts = command.split(' ', maxsplit=3)
num = int(parts[1])
proc = float(0.5)
idx4[num] = proc
ps_queue.put(num)
elif command.startswith('addt2 '):
parts = command.split(' ', maxsplit=3)
num = int(parts[1])
proc = float(0.5)
idx5[num] = proc
ps_queue.put(num)
elif command.startswith('addt3 '):
parts = command.split(' ', maxsplit=3)
num = int(parts[1])
proc = float(0.5)
idx6[num] = proc
ps_queue.put(num)
elif command == 'clear':
term.delete(0.0, END)
elif command == 'start':
thread1 = QueueThread('A')
thread1.start()
elif command == 'list':
term.insert(END, f'Список приоритетов, состовляющих алгоритм планирования \n')
for i in idx:
term.insert(END, f'{i} \n')
for i in idx2:
term.insert(END, f'{i} \n')
for i in idx3:
term.insert(END, f'{i} \n')
elif command == 'help':
term.insert(END, f'"add1 PRIOR" - добавляет уровень приоритета PID1. \n')
term.insert(END, f'"add2 PRIOR" - добавляет уровень приоритета PID2. \n')
term.insert(END, f'"add3 PRIOR" - добавляет уровень приоритета PID3. \n')
term.insert(END, f'"addt1 TIME" - добавляет время выполнения процесса PID1. \n')
term.insert(END, f'"addt2 TIME" - добавляет время выполнения процесса PID2. \n')
term.insert(END, f'"addt3 TIME" - добавляет время выполнения процесса PID3. \n')
term.insert(END, f'"list" - выводит список приоритетов, для алгоритма планирования. \n')
term.insert(END, f'"clear" - очищает терминал. \n')
term.insert(END, f'"help" - выводит список команд. \n')
term.insert(END, f'"start" - запускает алгоритм планирования. \n')
term.insert(END, f'"exit" - выход. \n')
else:
term.insert(END, f'{command} -- неизвестная комманда, используйте "help". \n')
if __name__ == '__main__':
idx = {}
idx2 = {}
idx3 = {}
idx4 = {}
idx5 = {}
idx6 = {}
res_list = []
results = []
drop_list = {}
cm_list = []
ps_queue = queue.Queue()
for x in idx:
ps_queue.put(x)
for y in idx2:
ps_queue.put(y)
for z in idx3:
ps_queue.put(z)
for t1 in idx4:
ps_queue.put(t1)
for t2 in idx5:
ps_queue.put(t2)
for t3 in idx6:
ps_queue.put(t3)
class_grades = {24: "Real time class",
13: "High class",
10: "Above normal class",
8: "Normal class",
6: "Below normal class",
4: "Idle class"}
root = Tk()
root.geometry('570x400')
root.title("Подсистема управления процессами с алгоритмом планирования на основе абсолютных приоритетов")
root.resizable(False, False)
lb1 = Label(text='Командная строка:', width=0)
lb2 = Label(width=0)
en1 = Entry(width=65, bg='#333333', fg='white')
term = Text(bg='#333333', width=65, height=19, fg='white')
en1.bind('<Return>', entry_get)
en1.bind('<Button-1>', lambda x: print(idx))
lb1.grid(row=0, column=0, sticky=W, pady=10, padx=5)
lb2.grid(row=1, column=1, sticky=W)
en1.grid(row=0, column=1, sticky=W)
term.grid(row=2, column=0, columnspan=2, padx=20, pady=10)
root.mainloop()