Python-сообщество

 #!/usr/bin/python3
import PyQt5
import PyQt5.QtWidgets
import sys
cell = 'Общая лексика'
class MyTableModel(PyQt5.QtCore.QAbstractTableModel):
    
    def __init__(self, datain, parent=None, *args):
        PyQt5.QtCore.QAbstractTableModel.__init__(self,parent,*args)
        self.datain = datain
    def rowCount(self,parent=None,*args,**kwargs):
        return 4
    def columnCount(self,parent=None,*args,**kwargs):
        return 4
    
    def data(self,index,role=PyQt5.QtCore.Qt.DisplayRole):
        if not index.isValid():
            return PyQt5.QtCore.QVariant()
        if role == PyQt5.QtCore.Qt.FontRole:
            return PyQt5.QtGui.QFont('Serif',14)
        else:
            try:
                return PyQt5.QtCore.QVariant(self.datain)
            except Exception as e:
                return PyQt5.QtCore.QVariant()
class Table(PyQt5.QtWidgets.QWidget):
    
    def __init__(self,*args,**kwargs):
        super().__init__(*args,**kwargs)
    
    def fill(self):
        table_item = PyQt5.QtWidgets.QTableWidgetItem(cell)
        self.table.setItem(0,0,table_item)
    
    def set_gui(self):
        self.table = PyQt5.QtWidgets.QTableWidget()
        self.table.setRowCount(4)
        self.table.setColumnCount(4)
        self.set_bindings()
        self.hheader = self.table.horizontalHeader()
        self.hheader.setSectionResizeMode(PyQt5.QtWidgets.QHeaderView.ResizeToContents)
        self.model = MyTableModel(datain=cell,parent=self.table)
        self.view = PyQt5.QtWidgets.QTableView(self.table)
        self.view.setModel(self.model)
        self.layout = PyQt5.QtWidgets.QVBoxLayout()
        self.layout.addWidget(self.view)
        self.setLayout(self.layout)
    
    def set_bindings(self):
        PyQt5.QtWidgets.QShortcut(PyQt5.QtGui.QKeySequence('Ctrl+Q'),self).activated.connect(self.close)
        PyQt5.QtWidgets.QShortcut(PyQt5.QtGui.QKeySequence('Esc'),self).activated.connect(self.close)
if __name__ == '__main__':
    f = 'controller.__main__'
    app = PyQt5.QtWidgets.QApplication(sys.argv)
    itable = Table()
    itable.set_gui()
    itable.fill()
    itable.showMaximized()
    sys.exit(app.exec())

 step = -0.01
for y30_ in np.arange(y30[0], y30[1], step):
    y00_ = function_vr(ph0b, et0, y30_)
    y10_ = function_vn(ph0b, et0, y30_)
    y20_ = function_o(ph0, et0, y30_)
    #print(f"y00_ = {y00_}, y10_ = {y10_}, y20_ = {y20_}, y30_ = {y30_}")
    
    for y50_ in np.arange(y50[0], y50[1], step):
      #print(y50_)
      
      for y60_ in np.arange(y60[1], y60[0], step):
        tn0_ = funct_tn(y50_, y60_)
        #print(y60_)
        
        for y70_ in np.arange(y70[1], y70[0], step):
          y80_ = funct_labt(y30_, y60_, y70_, y50_)
          function_gam(et0, y30_, ph0b, y50_, y60_, y70_, y80_)
          ht0, et0, y30_, ph0b, y50_, y60_, y70_, y80_  = symbols('ht0 et0 y30_ ph0b y50_ y60_ y70_ y80_')
          equation = Eq(ht0, (y50_ * et0 * cos(y30_) / sqrt(ph0b) + y60_ * -et0 * sin(y30_) / sqrt(ph0b) + y70_ * sqrt(1 / ph0b) * et0 * sin(y30_) + y80_ * (sqrt(1 / ph0b) * (1 + et0 * cos(y30_)) * (1 + et0 * cos(y30_))**2) / ph0b**2))
          #Use sympy.subs() method
          ham0 = solve(equation.subs(ht0, 0))
          #print(ham0)
          
          for y90_ in np.arange(y90[1], y90[0], step):
            function_propulsion(y40, y50_, y60_, y90_, ptb, mqb)
            function_deo(y40, y50_, y60_, y90_, ptb, mqb, pes)
 
    print(f"y00_ = {y00_}, y10_ = {y10_}, y20_ = {y20_}, y30_ = {y30_}, y50_ = {y50_}, y60_ = {y60_}, y70_ = {y70_}, y80_ = {y80_}, y90_ = {y90_}")

 class Excel:
    def __init__(self) -> None:
        self.wb = xl.Workbook()
        
        del self.wb['Sheet']
        self.consolas = NamedStyle(name='Consolas')
        self.consolas.font = Font(name='Consolas', size=10)
        self.consolas.alignment = Alignment(horizontal='center',vertical='center')
        # self.wb.active
        # self.file_name = 'unknown.xlsx'
    def file_exist(self, wb_name, ws_name):
        # проверяет на существование файла
        if os.path.isfile(wb_name) is True: # если файл существует 
            self.wb = load_workbook (wb_name) # то загружает его
            if ws_name in self.wb:
                self.wb.active
            else:
                self.wb.create_sheet(ws_name, 0)
                self.wb.active
        else:
            self.wb.create_sheet(ws_name, 0)
            self.wb.active
            self.wb.save(wb_name)
        return self.wb.save(wb_name)
    def last_column(self, wb_name, ws_name):
        self.wb = load_workbook (wb_name)
        self.ws = self.wb[ws_name]
        self.last_row = self.ws.max_row
        self.last_col = self.ws.max_column
        return self.last_col
    def col_writer(self, data_hat, data_meas, wb_name, ws_name):
        self.wb = load_workbook (wb_name)
        self.ws = self.wb[ws_name]
        self.last_row = self.ws.max_row
        self.last_col = self.ws.max_column
        for c_index, col in enumerate(data_hat, start=self.last_col+1):
            self.wb[ws_name].column_dimensions[get_column_letter(c_index)].width = 20
            for r_index, row in enumerate(col, start=1):
                self.wb[ws_name].cell(r_index, c_index, row)
        for c_index, col in enumerate(data_meas, start=self.last_col+1):
            for r_index, row in enumerate(col, start=11):
                self.wb[ws_name].cell(r_index, c_index, row)
            return self.wb.save(wb_name)

 import pytube
import os
video_link = 'https://www.youtube.com/watch?v=d0XCoaiCXDw'
yt = pytube.YouTube(video_link)
path = 'C:\\Users\\Desktop\\01'
video.download(path)

 class Component:
	
	defaults = dict()
	Catalog = dict()
	ComponentTypes = dict()
	def __new__(cls, entity=None):
		class_name = cls.__name__
		if class_name not in Component.ComponentTypes:
			Component.ComponentTypes[class_name] = cls
			cls.Catalog = dict()
		if entity not in cls.Catalog:
			component = super(Component, cls).__new__(cls, entity=entity)
		else:
			component = cls.Catalog(entity)
			
		return component
	def __init__(self, entity=None):
		self.entity = entity
		for prop, val in self.default.items():
			setattr(self, prop, properties.get(prop, val))

[code python]
# Функция чтения команд из файла
def text_command():
    file = open('command.txt')
    commands = file.readlines()
    for line in commands:
        if line[0] == 'z':
            line = line.replace('z','')
            line = line.replace(';', '')
            line = line.replace('\n', '')
            QtCore.QTimer.singleShot(int(line), text_command)
        else:
            line = line.replace('\n', '')
            serial.writeData(str(line).encode())
    file.close
ui.pushButton.clicked.connect(text_command)
[/code]


Эта функция отправляет данные в сериал, а их, в сою очередь, принимает ардуинка, и в зависимости от первого символа устанавливает определенный сервопривод в указанный угол.
При вызове моей функции, к сожалению, я не получаю нужный мне результат, отправка строк происходит без задержки. 
Как мне организовать подобную задержку?

Первый мой вопрос на форуме в процессе обучения, если оформил неправильно или непонятно объяснил свою задачу - исправлюсь.

ОС Windows7 
Python 3.8
PyQt5 5.15.6

 def getInternet():
    try:
        try:
            requests.get('https://www.google.com')
        except requests.ConnectTimeout:
            requests.get('http://1.1.1.1')
        return True
    except requests.ConnectionError:
        return False
lock = threading.Lock()
if getInternet() == True:
    dictionary = requests.get(
        'https://mail.ru').text.strip().split('\n')
else:
    pass
def getNew(addr):
    try:
        response = requests.get(
            f'https://ya.ru')
        return (
            response.json()
        )

[code python]                            for i in selfcalls: # перебираем значения колонок цен и страйков
                                sum_a_calls += i['A'] # значения цен
                                sum_i_calls += i['I'] # значение страйков
                                sp_calls_ai += i['A'] * i["I"] # все значения А и I перемножаются
                                sp_calls_i += i["I"]
                                up_level = sp_calls_ai / sp_calls_i / 10000
                                print(sum_a_calls)
                                if i['A'] < 11000: ################# не работает
                                    sum_low_calls_a += i['A']
                                    sum_low_calls_i += i['I']
                                    sp_low_calls_ai = sp_low_calls_ai + i['A'] * i["I"]
                                    sp_low_calls_i += i["I"]
                                    down_balance_level = sp_low_calls_ai / sp_low_calls_i / 10000[/code]

 elif voice_input == "список команд" or voice_input == "помощь":
    canvas = Canvas(tk, width=500, height=560)
    canvas.pack()
    tk.title("List of commands")
    canvas.create_text(70, 20, text="1. Расскажи о себе")
    #там много строк, поэтому оставил только одну
    tk.mainloop()