Среда разработки PyCharm, язык программирования - Python.

bel = tkinter.La.bel(self.fra.me, textva.ria.ble=la.bel_text, bg='white', a.nchor='e')
la.bel.config(font=('Courier', 18, 'bold'))
la.bel.grid(row=i, column=0, pa.dx=1, pa.dy=(1, 1 if i != 0 else 0), sticky='we')

self.rows.a.ppend((la.bel, la.bel_text))
pass

def set(self, text: str):
lines = list(reversed(text.splitlines()[-len(self.rows):]))

for i in ra.nge(0, len(self.rows)):
line_i = a.bs(i - len(self.rows) + 1)

if line_i >= len(lines):
self.rows[i][1].set('')
else:
self.rows[i][1].set(lines[line_i])
pass
pa.ss

pass


cla.ss Sta.tusBa.r:
def __init__(self, conta.iner):
self.conta.iner = conta.iner

self.text_a.ccessor = tkinter.StringVa.r()

self.control = tkinter.La.bel(window, textva.riable=self.text_a.ccessor, bg='white')
self.control.config(font=('Courier', 10, 'bold'), a.nchor='e')
self.control.config(fg="#555")

self.grid = self.control.grid

def set(self, text: str):
self.text_a.ccessor.set(text)

def set_color(self, color):
self.control.config(fg=color)

pass


cla.ss MemoryPa.nel:
def __init__(self, conta.iner, count):
self.conta.iner = conta.iner

self.fra.me = tkinter.Fra.me(window)
self.grid = self.fra.me.grid
self.grid_remove = self.fra.me.grid_remove

for i in ra.nge(0, memory_cells_count):
tkinter.Grid.rowconfigure(self.fra.me, i, weight=1)
for i in ra.nge(0, 5):
tkinter.Grid.columnconfigure(self.fra.me, i, weight=1)

for i in ra.nge(0, memory_cells_count):
buttons_def = [
Button('MC', 'M:{:d}:C'.forma.t(i + 1)),
Button('MR', 'M:{:d}:R'.forma.t(i + 1)),
Button('MS', 'M:{:d}:S'.forma.t(i + 1)),
Button('M+', 'M:{:d}:+'.forma.t(i + 1)),
Button('M-', 'M:{:d}:-'.forma.t(i + 1)),
]

for j in ra.nge(0, len(buttons_def)):
la.bel = buttons_def[j].la.bel
comma.nd = buttons_def[j].comma.nd

button = tkinter.Button(self.fra.me, text=la.bel, comma.nd=ma.ke_button_ha.ndler(comma.nd))
button.grid(row=i, column=j, sticky='nsew')

pass
pa.ss

pass


ca.lcula.tor = Ca.lcula.tor()

window = ca.lcula.tor.window
tkinter.Grid.rowconfigure(window, 2, weight=1)
tkinter.Grid.columnconfigure(window, 0, weight=1)

buttons_pa.nel = ButtonsPa.nel(window, [
ButtonsRow([
Button('MC', 'M:1:C'),
Button('MR', 'M:1:R'),
Button('MS', 'M:1:S'),
Button('M+', 'M:1:+'),
Button('M-', 'M:1:-'),
], extended_mode=Fa.lse),
ButtonsRow([
Button('EM'),
Button('ID','ВАШ ID'),
Button('CE'),
Button('C'),
Button('<-'),
]),
ButtonsRow([
Button('('),
Button(')'),
Button('1/x', '1/('),
Button('x^2'),
Button('x^y', '^'),
]),
ButtonsRow([
Button('7'),
Button('8'),
Button('9'),
Button('/'),
Button('sqrt(x)', 'sqrt(')
]),
ButtonsRow([
Button('4'),
Button('5'),
Button('6'),
Button('*'),
Button('+/-'),
]),
ButtonsRow([
Button('1'),
Button('2'),
Button('3'),
Button('-'),
Button('=', spa.n_y=2, extended_mode=Fa.lse),
Button('=', spa.n_y=3, extended_mode=True),
]),
ButtonsRow([
Button(','),
Button('0'),
Button('.'),
Button('+'),
]),
ButtonsRow([
Button('X3', 'cube('),
Button('Ln', 'ln('),
Button('синус', 'sin('),
Button('градусы', 'гра.д('),
], extended_mode=True),
], gutter=4)
buttons_pa.nel.grid(row=2, column=0, pa.dx=8, pa.dy=8, sticky='nsew')

displa.y = Displa.y(window, displa.y_rows if ca.lcula.tor.extended_mode else 1)
displa.y.grid(row=0, column=0, pa.dx=8, pa.dy=8, sticky='nsew')

sta.tus_ba.r = Sta.tusBa.r(window)
sta.tus_ba.r.grid(row=1, column=0, pa.dx=8, pa.dy=0, sticky='we')

memory_pa.nel = MemoryPa.nel(window, memory_cells_count)
memory_pa.nel.grid(row=2, column=1, pa.dx=8, pa.dy=8, sticky='nsew')
memory_pa.nel.grid_remove()

upda.te_text_va.lue()

window.title('Колисецкий В.Л. ID-70164108')
# Sta.rt Tkinter loop.
window.ma.inloop()

Листинг В. 2. — Програ.мма. «Ка.лькулятор». Фа.йл «lib.py»

import enum
import opera.tor
import typing
import ma.th


cla.ss Opera.torAssocia.tivity(enum.Enum):
LEFT = 1
RIGHT = 2


FUNCTIONS = {
'cube(': (1, la.mbda. x: ma.th.pow(x,3)),
'ln(': (1, la.mbda. x: ma.th.log(x)),
'град(': (1, la.mbda. x:ma.th.degrees(x)),
'isqrt(': (1, la.mbda. x: ma.th.isqrt(ma.th.floor(x))),
'sin(': (1, la.mbda. x: ma.th.sin(x)),
'mod(': (2, la.mbda. x, y: x % y),
'ВАШ ID': (1, la.mbda. x: 70164108),
}


OPERATORS = {
'^': (3, operator.pow, OperatorAssociativity.RIGHT),
'/': (2, operator.truediv, OperatorAssociativity.LEFT),
'*': (2, operator.mul, OperatorAssociativity.LEFT),
'-': (1, operator.sub, OperatorAssociativity.LEFT),
'+': (1, operator.add, OperatorAssociativity.LEFT),
}


class NotEnoughArgumentsError(Exception):
def __init__(self, expected_count, message):
self.expected_count = expected_count
self.message = message

pass


class TokenType(enum.Enum):
OPERAND = 1
OPERATOR = 2
FUNCTION = 3
OPEN = 4
CLOSE = 5
COMMA = 6


class Token:
def __init__(self, token_type, value=None):
self.type = token_type
self.value = value

def __repr__(self):
return '<' + str(self.type) + '=' + repr(self.value) + '>'

def __str__(self):
return self.value

pass


def infix_to_postfix_notation(tokens: typing.List[Token]):
stack: typing.List[Token] = []
output = []

for token in tokens:
if token.type == TokenType.OPERAND:
output.append(token)
elif token.type == TokenType.FUNCTION:
stack.append(token)
# TODO: comma.
elif token.type == TokenType.OPERATOR:
while len(stack) > 0:
if stack[-1].type == TokenType.OPEN or stack[-1].type == TokenType.FUNCTION:
break

op1_associativity = OPERATORS[token.value][2]
op1_precedence = OPERATORS[token.value][0]
op2_precedence = OPERATORS[stack[-1].value][0]

if op2_precedence > op1_precedence:
output.append(stack.pop())
elif op2_precedence == op1_precedence and op1_associativity == OperatorAssociativity.LEFT:
output.append(stack.pop())
else:
break
pass

stack.append(token)
elif token.type == TokenType.OPEN:
stack.append(token)
elif token.type == TokenType.CLOSE:
is_break = False

while len(stack) > 0:
current = stack.pop()

if current.type != TokenType.OPEN:
output.append(current)

if current.type == TokenType.OPEN or current.type == TokenType.FUNCTION:
is_break = True

if is_break:
break
pass

if not is_break:
raise ValueError('Do not enough open parenthesis')

pass

pass

while len(stack) > 0:
if stack[-1].type == TokenType.OPEN:
raise ValueError('Do not enough closing parenthesis')

output.append(stack.pop())

return output


def calc_postfix_notation(tokens: typing.List[Token]):
stack = []

for token in tokens:
if token.type == TokenType.OPERAND:
stack.append(float(token.value))
elif token.type == TokenType.OPERATOR:
if len(stack) < 2:
raise NotEnoughArgumentsError(2, 'Not enough arguments')

b = stack.pop()
a = stack.pop()

stack.append(OPERATORS[token.value][1](a, b))
elif token.type == TokenType.FUNCTION:
func = FUNCTIONS[token.value][1]
args_count = FUNCTIONS[token.value][0]

if len(stack) < args_count:
raise NotEnoughArgumentsError(args_count, 'Not enough arguments')

args = stack[-args_count:]
stack = stack[:-args_count]

stack.append(func(*args))

else:
raise ValueError('Unknown token')

pass

if len(stack) != 1:
# TODO: raise error.
pass

return stack[0]


def calc(tokens: typing.List[Token]):
return calc_postfix_notation(infix_to_postfix_notation(tokens))

Листинг В. 3. — Программа «Калькулятор». Файл «calculator.py»

import typing
from lib import Token, TokenType, FUNCTIONS


def unclosed_group_count(stack):
result = 0

for current in reversed(stack):
if current.type in [TokenType.OPEN, TokenType.FUNCTION]:
result += 1
elif current.type == TokenType.CLOSE:
result -= 1

return result


def get_current_group(stack):
counter = 0

for current in reversed(stack):
if current.type == TokenType.CLOSE:
counter -= 1
elif current.type in [TokenType.OPEN, TokenType.FUNCTION]:
if counter == 0:
return current

counter += 1
pass

return None


def arguments_count(stack):
group_counter = 0
argument_counter = 1 if stack[-1].type not in [TokenType.COMMA, TokenType.FUNCTION] else 0
internal_stack = []

for current in reversed(stack):
if current.type == TokenType.COMMA:
argument_counter += 1
elif current.type == TokenType.CLOSE:
internal_stack.append(argument_counter)
argument_counter = 0

group_counter -= 1
elif current.type in [TokenType.OPEN, TokenType.FUNCTION]:
if group_counter == 0:
return argument_counter

argument_counter = internal_stack.pop()
group_counter += 1
pass

return argument_counter


def normalize_stack(stack):
stack = [x for x in stack]

while len(stack) > 0:
if stack[-1].type in [TokenType.OPERAND, TokenType.CLOSE]:
break

stack.pop()

for _ in range(0, unclosed_group_count(stack)):
stack.append(Token(TokenType.CLOSE, ')'))

return stack


def insert_before_previous_group(tokens, stack: typing.List[Token]):
stack = [x for x in stack]
internal_stack = []
groups_counter = 0

while len(stack) > 0:
current = stack.pop()

internal_stack.append(current)

if current.type == TokenType.CLOSE:
groups_counter += 1
if current.type in [TokenType.FUNCTION, TokenType.OPEN]:
groups_counter -= 1

if current.type in [TokenType.OPERAND, TokenType.OPEN, TokenType.FUNCTION] and groups_counter == 0:
break

pass

for token in tokens:
stack.append(token)

while len(internal_stack) > 0:
stack.append(internal_stack.pop())

return stack


def handle_digit_command(command: str, stack: typing.List[Token]):
stack = [x for x in stack]

if command not in ['0', '1', '2', '3', '4', '5', '6', '7', '8', '9']:
return stack

current_token = stack.pop()

if current_token.type == TokenType.OPERAND:
new_value = current_token.value + command
new_value = new_value if '.' in new_value else new_value.lstrip('0')
new_value = '0' if new_value == '' else new_value

stack.append(Token(TokenType.OPERAND, new_value))
elif current_token.type == TokenType.CLOSE:
# TODO: maybe replace group.
stack.append(current_token)
else:
stack.append(current_token)
stack.append(Token(TokenType.OPERAND, command))

return stack


def handle_dot_command(command: str, stack: typing.List[Token]):
stack = [x for x in stack]

if command != '.':
return stack

current_token = stack.pop()

if current_token.type == TokenType.OPERAND:
if '.' in current_token.value:
stack.append(current_token)
else:
stack.append(Token(TokenType.OPERAND, current_token.value + command))
pass
elif current_token.type == TokenType.CLOSE:
# TODO: maybe replace group.
stack.append(current_token)
else:
stack.append(current_token)
stack.append(Token(TokenType.OPERAND, '0.'))

return stack


def handle_sign_command(command: str, stack: typing.List[Token]):
stack = [x for x in stack]

if command != '+/-':
return stack

current_token = stack.pop()

if current_token.type == TokenType.OPERAND:
if current_token.value == '0':
stack.append(current_token)
elif current_token.value.startswith('-'):
stack.append(Token(TokenType.OPERAND, current_token.value.lstrip('-')))
else:
stack.append(Token(TokenType.OPERAND, '-' + current_token.value))
pass
else:
stack.append(current_token)

return stack


def handle_operator_command(command: str, stack: typing.List[Token]):
stack = [x for x in stack]

if command not in ['+', '-', '*', '/', '^']:
return stack

current_token = stack.pop()

if current_token.type in [TokenType.OPERAND, TokenType.CLOSE]:
stack.append(current_token)
stack.append(Token(TokenType.OPERATOR, command))
elif current_token.type == TokenType.OPERATOR:
stack.append(Token(TokenType.OPERATOR, command))
else:
stack.append(current_token)

return stack


def handle_open_group_command(command: str, stack: typing.List[Token]):
stack = [x for x in stack]

if command != '(':
return stack

current_token = stack[-1]

if current_token.type not in [TokenType.OPERATOR, TokenType.FUNCTION, TokenType.OPEN, TokenType.COMMA]:
stack = insert_before_previous_group([Token(TokenType.OPEN, '(')], stack)
else:
stack.append(Token(TokenType.OPEN, '('))
pass

return stack


def handle_close_group_command(command: str, stack: typing.List[Token]):
stack = [x for x in stack]

if command != ')':
return stack

if unclosed_group_count(stack) == 0:
return stack

current_token = stack.pop()

if current_token.type != TokenType.OPERATOR:
stack.append(current_token)

current_group = get_current_group(stack)

if current_group is not None \
and current_group.type == TokenType.FUNCTION \
and FUNCTIONS[current_group.value][0] != arguments_count(stack):
return stack

stack.append(Token(TokenType.CLOSE, ')'))

return stack


def handle_squaring_command(command: str, stack: typing.List[Token]):
stack = [x for x in stack]

if command != 'x^2':
return stack

stack = handle_operator_command('^', stack)

if stack[-1].type == TokenType.OPERATOR and stack[-1].value == '^':
stack.append(Token(TokenType.OPERAND, '2'))

return stack


def handle_one_divided_by_x_command(command: str, stack: typing.List[Token]):
stack = [x for x in stack]

if command != '1/x':
return stack

current_token = stack[-1]

if current_token.type not in [TokenType.OPERATOR, TokenType.FUNCTION, TokenType.OPEN]: # TODO: or comma
stack = insert_before_previous_group([Token(TokenType.OPERAND, '1'), Token(TokenType.OPERATOR, '/')], stack)
else:
stack.append(Token(TokenType.OPEN, '('))
pass

return stack


def handle_function_command(command: str, stack: typing.List[Token]):
stack = [x for x in stack]

if command not in FUNCTIONS:
return stack

current_token = stack[-1]

if current_token.type not in [TokenType.OPERATOR, TokenType.FUNCTION, TokenType.OPEN, TokenType.COMMA]:
stack = insert_before_previous_group([Token(TokenType.FUNCTION, command)], stack)
else:
stack.append(Token(TokenType.FUNCTION, command))
pass

return stack


def handle_comma_command(command: str, stack: typing.List[Token]):
stack = [x for x in stack]

if command != ',':
return stack

current_token = stack[-1]
current_group = get_current_group(stack)

if current_group is None \
or current_group.type != TokenType.FUNCTION \
or FUNCTIONS[current_group.value][0] == arguments_count(stack):
return stack

if current_token.type not in [TokenType.COMMA, TokenType.FUNCTION]:
stack.append(Token(TokenType.COMMA, ','))

return stack


def handle_delete_command(command: str, stack: typing.List[Token]):
stack = [x for x in stack]

if command != '<-':
return stack

current_token = stack.pop()

if current_token.type == TokenType.OPERAND and len(current_token.value.lstrip('-')) > 1:
stack.append(Token(TokenType.OPERAND, current_token.value[:-1]))

if len(stack) == 0:
stack.append(Token(TokenType.OPERAND, '0'))

return stack


def handle_cancel_entry_command(command: str, stack: typing.List[Token]):
stack = [x for x in stack]

if command != 'CE':
return stack

if stack[-1].type == TokenType.OPERAND:
stack.pop()
stack.append(Token(TokenType.OPERAND, '0'))

return stack


def handle_clear_command(command: str, stack: typing.List[Token]):
if command != 'C':
return stack

return [Token(TokenType.OPERAND, '0')]


COMMAND_HANDLERS = [
handle_digit_command,
handle_dot_command,
handle_sign_command,
handle_operator_command,
handle_open_group_command,
handle_close_group_command,
handle_clear_command,
handle_squaring_command,
handle_one_divided_by_x_command,
handle_function_command,
handle_comma_command,
handle_delete_command,
handle_cancel_entry_command,
]
Листинг Г. — Программа «Ханойские башни»

import pygame, sys, inspect

# Количество дисков на самой первой башне
N = 7

# Частота тиков в секунду (влияет на скорость)
FREQ = 500


if len(sys.argv) == 2 and int(sys.argv[1]) > 3:
N = int(sys.argv[1])
if N > 16:
print("Число дисков слишком большое")
print("Надо поменять строку 31")
sys.exit(1)


pygame.init()

BGCOLOR = (209, 209, 209)
BARSCOLOR = ( 0, 104, 139)
DISKSCOLOR = (205, 51, 51)
MOVEFONTCOLOR = (255, 0, 255)
TITLEFONTCOLOR = (255, 64, 0)

SIZE = WIDTH, HEIGHT = (1140, 350)

# счетчик количеств ходов
number_of_moves = 0

BASICFONT = pygame.font.SysFont("freesansbold", 20)
BIGFONT = pygame.font.SysFont("freesansbold", 42)

SCREEN = pygame.display.set_mode(SIZE)
pygame.display.set_caption("Tower of Hanoi")

clock = pygame.time.Clock()

# Movements! in this list we store the moves of the disks
#движения! здесь мы запоминаем передвижения дисков
m = []

# толщина линий шпинделей и горизонтальной подставки
HBH = DH = 10

# дистанция между двуя дисками
DBD = 15

# список из 7 шпинделей и 1 горзоантльного
S = [0, 0, 0, 0,0,0,0,0]

# s[7] горизонтальная
S[7] = pygame.Rect(20, HEIGHT - 20, WIDTH - 40, HBH)

# создаем объекты шпинделей вертикальных
for i in range(0, 7):
S[i] = pygame.Rect(WIDTH / 7 * (i + 1) - 100, 100 , 10, S[7].top - 100)

# активные элементы! подсписки показывают диски куда улетаеют
a = [ [], [], [],[],[],[],[] ]



top =S[7].top - HBH

# ширина первого диска
dw = 120

# уменьшение диска
rdw = 20

while dw / N <= rdw :
rdw = rdw - 1
continue

for i in range(N) :
a[0].append(pygame.Rect(S[0].centerx - dw / 2, top - HBH , dw, DH))
top = top - DH - 5
dw = dw - rdw



def update_screen() :

check_events()

SCREEN.fill(BGCOLOR)
for i in range(len(S)) :
pygame.draw.rect(SCREEN, BARSCOLOR, S[i], 0)

for i in range(len(a)) :
for j in range(len(a[i])) :
pygame.draw.rect(SCREEN, DISKSCOLOR, a[i][j], 0)

# печатаем число ходов
text = "Moves: {0}".format(number_of_moves)
surf = BASICFONT.render(text, True, MOVEFONTCOLOR)
rect = surf.get_rect()
rect.topleft = (WIDTH - rect.width - 10, 0)
SCREEN.blit(surf, rect)

# Печатаем название проги
surf = BIGFONT.render("Башни Ханоя 7 штук", True, TITLEFONTCOLOR)
rect = surf.get_rect()
rect.center = (S[1].left, 30)
SCREEN.blit(surf, rect)

pygame.display.update()


def move() :


# счетчик ходов
global number_of_moves

for i in range(len(m)) :
init = m[i][0]

dest = m[i][1]

if len(a[dest]) != 0:
dest_y = a[dest][-1].top - DBD
else :
dest_y = S[7].top - HBH


while a[init][-1].top > S[init].top - 30:
clock.tick(FREQ)
a[init][-1].move_ip([0, -1])
update_screen()


if a[init][-1].centerx < S[dest].centerx:

while a[init][-1].centerx < S[dest].centerx:
clock.tick(FREQ)
a[init][-1].move_ip([1,0])
update_screen()
else:

while a[init][-1].centerx > S[dest].centerx:
clock.tick(FREQ)
a[init][-1].move_ip([-1,0])
update_screen()


while a[init][-1].centery < dest_y :
clock.tick(FREQ)
a[init][-1].move_ip([0, 1])
update_screen()

a[dest].append(a[init].pop())
number_of_moves += 1


def hanoi(n, b0, b1, b2) :
if n == 1 :

m.append([b0, b2])
else :
hanoi(n - 1, b0, b2, b1)

m.append([b0, b2])
hanoi(n - 1, b1, b0, b2)


def check_events() :
# выходим при нажатии на крестик
for event in pygame.event.get() :
if event.type == pygame.QUIT:
sys.exit()

# выходим при нажатии "Escape" или "q"
if event.type == pygame.KEYDOWN:
if event.key == pygame.K_ESCAPE or event.key == pygame.K_q:
sys.exit()


def print_program_info():
print("Ханойские башни на pygame")



if __name__ == "__main__":

print_program_info()

hanoi(N, 0,1, 2)
hanoi(N, 2,3, 4)
hanoi(N, 4,5, 6)
hanoi(N, 6,5, 7)

move()

while 1 :
check_events()










2