Гэддис Т. Начинаем программировать на Python. – 4-е изд.: Пер. с англ. – СПб.: БХВ-Петербург, 2019. – 768 с.
Шелудько, В. М. Основы программирования на языке высокого уровня Python: учебное пособие / В. М. Шелудько. – Ростов-на-Дону, Таганрог: Издательство Южного федерального университета, 2017. – 146 c. – ISBN 978-5-9275-2649-9. – Текст: электронный // Электронно-библиотечная система IPR BOOKS: [сайт]. – URL: http://www.iprbookshop.ru/87461.html (дата обращения: 01.12.2024). – Режим доступа: для авторизир. пользователей
Роббинс, А. Linux: программирование в примерах / А. Роббинс. - М.: КУДИЦ-Образ, 2019. - 611 c.
Котляров, В. П. Основы тестирования программного обеспечения / В.П. Котляров, Т.В. Коликова. - М.: Интернет-университет информационных технологий, Бином. Лаборатория знаний, 2020. - 288 c.
Приложения
Исходный код программы для анализа данных
def counter(data: str) -> dict:
counter = {}
data_lines = data.split('\n')
for line in data_lines:
for word in line.split():
if word in counter:
counter[word] += 1
else:
counter[word] = 1
return counter
def sort_answer(data: dict) -> str:
sorted_dict = {key: value for key, value in sorted(data.items(), key=lambda item: (item[1], item[0]), reverse=True)}
answer = ''
for key, value in sorted_dict.items():
answer += key + ' ' + str(value) + '\n'
return answer
def read_task(path: str) -> str:
with open(path) as inf:
data = inf.read().lower()
return data
def write_answer(path: str, data: str) -> None:
with open(path, 'w') as ouf:
ouf.write(data)
if __name__ == '__main__':
raw_data = read_task('resourse_1.txt')
data = counter(raw_data)
sorted_data = sort_answer(data)
print(sorted_data)
write_answer('result_1.txt', sorted_data)
Исходный код программы работы с банковскими счетами
import tkinter as tk
class BankAccount:
def __init__(self, name, balance=0):
self._name = name
self._balance = balance
def deposit(self, sum_):
self._balance += sum_
def withdraw(self, sum_):
self._balance -= sum_
def get_balance(self):
return self._name + ' ' + str(self._balance)
def get_income(self, income):
if self._balance > 0:
self._balance += int(self._balance / 100 * int(income))
def transfer(self, sum_, other):
other.deposit(sum_)
self._balance -= sum_
class ATMDataHandler:
def __init__(self, name: str, balance: int):
self.clients = {name: BankAccount(name, balance)}
def _get_client(self, client_name: str) -> BankAccount:
if client_name not in self.clients:
self.clients[client_name] = BankAccount(client_name)
return self.clients[client_name]
def process_data(self, query):
query_elements = query.split()
command = query_elements[0]
if command == 'DEPOSIT':
name = query_elements[1]
sum_ = int(query_elements[2])
self._get_client(name).deposit(sum_)
return ''
elif command == 'WITHDRAW':
name = query_elements[1]
sum_ = int(query_elements[2])
self._get_client(name).withdraw(sum_)
return ''
elif command == 'BALANCE':
result = ''
if len(query_elements) == 1:
for client in self.clients.values():
result += client.get_balance() + '\n'
else:
name = query_elements[1]
if name not in self.clients:
result = 'NO CLIENT\n'
else:
result = self._get_client(name).get_balance()
return result
elif command == 'TRANSFER':
name1 = query_elements[1]
name2 = query_elements[2]
sum_ = int(query_elements[3])
client1 = self._get_client(name1)
client2 = self._get_client(name2)
client1.transfer(sum_, client2)
return ''
elif command == 'INCOME':
p = query_elements[1]
for client in self.clients.values():
client.get_income(p)
return ''
else:
pass
class ProgramWindow:
def __init__(self, data_handler: ATMDataHandler):
self._handler = data_handler
self.window = tk.Tk()
self.window.title('Банкомат')
self.frame_left_top = tk.Frame(master=self.window, relief=tk.SUNKEN, borderwidth=1)
self.frame_right_top = tk.Frame(master=self.window, relief=tk.SUNKEN, borderwidth=1)
self.frame_left_bottom = tk.Frame(master=self.window, relief=tk.SUNKEN, borderwidth=1)
self.frame_right_bottom = tk.Frame(master=self.window, relief=tk.SUNKEN, borderwidth=1)
self.frame_left_top.grid(row=1, column=1)
self.frame_right_top.grid(row=1, column=2)
self.frame_left_bottom.grid(row=2, column=1)
self.frame_right_bottom.grid(row=2, column=2)
self.textbox = tk.Text(master=self.frame_left_top, width=50, height=20)
self.label = tk.Text(master=self.frame_right_top, width=50, height=20)
self.button_calc = tk.Button(master=self.frame_left_bottom, width=10, height=2,
text='Calculate', command=self.calculate)
self.button_clear = tk.Button(master=self.frame_right_bottom, width=10, height=2,
text='Clear', command=self.clear)
self.textbox.pack()
self.label.pack()
self.button_calc.pack()
self.button_clear.pack()
def calculate(self):
user_data = self.textbox.get('1.0', tk.END).split('\n')
queries = []
for line in user_data:
if line != '':
queries.append(line)
result = ''
for query in queries:
result += 'Command: ' + query + '\n'
result += '------------------\n'
result += self._handler.process_data(query)
result += '------------------\n'
self.label.insert('1.0', result)
def clear(self):
self.label.delete('1.0', tk.END)
self.textbox.delete('1.0', tk.END)
def get_event(self):
self.window.mainloop()
if __name__ == '__main__':
win = ProgramWindow(ATMDataHandler('Bondarev', 70156171))
win.get_event()
exit(0)
Исходный код программы-калькулятора
import tkinter as tk
import math
class Solver:
def calculate(self, expr: str) -> str:
expr = expr.replace('√', 'math.sqrt')
expr = expr.replace('×', '*')
expr = expr.replace('^', '**')
expr = expr.replace('acos', 'math.acos')
expr = expr.replace('asin', 'math.asin')
expr = expr.replace('atg', 'math.atan')
expr = expr.replace('log', 'math.log')
expr = expr.replace('fact', 'math.factorial')
expr = expr.replace('e', '*10**')
try:
answer = eval(expr)
except Exception as ex:
return 'Invalid Input'
else:
if len(str(answer)) > 20:
return '{:.10e}'.format(answer)
else:
return answer
class MemoryCell:
def __init__(self, master):
self.value = 0.0
self.master = master
def add(self, number: float):
self.value += number
def subtract(self, number: float):
self.value -= number
def clear(self):
self.value = 0.0
def copy(self):
self.master.clipboard_append(self.value)
def get(self) -> float:
return self.value
class Memory:
def __init__(self, master, cells_number=1):
self.mem_list = None
self.cell_idx = 0
self.master = master
self.initialize(cells_number)
def initialize(self, cells_number):
self.mem_list = list()
for _ in range(cells_number):
self.mem_list.append(MemoryCell(self.master))
def current_cell(self) -> MemoryCell:
return self.mem_list[self.cell_idx]
def change_cell(self, cell_idx: int):
self.cell_idx = cell_idx
class InterfaceObject:
def __init__(self):
self.obj = None
def delete(self):
self.obj.destroy()
class Keyboard(InterfaceObject):
def __init__(self, frame):
self.button_rows_desc = list()
self.button_objs = list()
self.frame = frame
def bind_buttons(self, mem_obj, scr_obj):
pass
def attach(self):
current_row = 1
current_col = 0
for row in self.button_rows_desc:
for name, callback in row.items():
new_btn = tk.Button(self.frame, text=name,
width=5, height=1, command=callback)
new_btn.grid(row=current_row, column=current_col)
self.button_objs.append(new_btn)
current_col += 1
current_col = 0
current_row += 1
def delete(self):
for button in self.button_objs:
button.destroy()
class StandartKeyboard(Keyboard):
def bind_buttons(self, memory_obj, screen_obj, solver_obj, mode_changer):
self.button_rows_desc.append({
'(': lambda: screen_obj.add_char('('),
')': lambda: screen_obj.add_char(')')
})
self.button_rows_desc.append({
'M+': lambda: memory_obj.current_cell().add(screen_obj.get()),
'M-': lambda: memory_obj.current_cell().subtract(screen_obj.get()),
'MR': lambda: screen_obj.add_char(memory_obj.current_cell().get()),
'MC': lambda: memory_obj.current_cell().clear(),
'MS': lambda: memory_obj.current_cell().copy()
})
self.button_rows_desc.append({
'7': lambda: screen_obj.add_char(7),
'8': lambda: screen_obj.add_char(8),
'9': lambda: screen_obj.add_char(9),
'÷': lambda: screen_obj.add_char('/'),
'CE': lambda: screen_obj.clear_line()
})
self.button_rows_desc.append({
'4': lambda: screen_obj.add_char(4),
'5': lambda: screen_obj.add_char(5),
'6': lambda: screen_obj.add_char(6),
'*': lambda: screen_obj.add_char('×'),
'√': lambda: screen_obj.add_char('√(')
})
self.button_rows_desc.append({
'1': lambda: screen_obj.add_char(1),
'2': lambda: screen_obj.add_char(2),
'3': lambda: screen_obj.add_char(3),
'-': lambda: screen_obj.add_char('-'),
'^': lambda: screen_obj.add_char('^')
})
self.button_rows_desc.append({
'0': lambda: screen_obj.add_char(0),
'.': lambda: screen_obj.add_char('.'),
'+': lambda: screen_obj.add_char('+'),
'=': lambda: screen_obj.add_answer(
solver_obj.calculate(screen_obj.get_expr())
),
'Adv': mode_changer
})
class AdvancedKeyboard(Keyboard):
def bind_buttons(self, memory_obj, screen_obj, solver_obj, mode_changer):
self.button_rows_desc.append({
'(': lambda: screen_obj.add_char('('),
')': lambda: screen_obj.add_char(')'),
',': lambda: screen_obj.add_char(',')
})
self.button_rows_desc.append({
'M+': lambda: memory_obj.current_cell().add(screen_obj.get()),
'M-': lambda: memory_obj.current_cell().subtract(screen_obj.get()),
'MR': lambda: screen_obj.add_char(memory_obj.current_cell().get()),
'MC': lambda: memory_obj.current_cell().clear(),
'MS': lambda: memory_obj.current_cell().copy()
})
self.button_rows_desc.append({
'M1': lambda: memory_obj.change_cell(0),
'M2': lambda: memory_obj.change_cell(1),
'M3': lambda: memory_obj.change_cell(2),
'M4': lambda: memory_obj.change_cell(3),
'M5': lambda: memory_obj.change_cell(4)
})
self.button_rows_desc.append({
'M6': lambda: memory_obj.change_cell(5),
'M7': lambda: memory_obj.change_cell(6),
'M8': lambda: memory_obj.change_cell(7),
'M9': lambda: memory_obj.change_cell(8),
'CE': lambda: screen_obj.clear_line()
})
self.button_rows_desc.append({
'acos': lambda: screen_obj.add_char('acos('),
'asin': lambda: screen_obj.add_char('asin('),
'atg': lambda: screen_obj.add_char('atg('),
'log_xy': lambda: screen_obj.add_char('log('),
'n!': lambda: screen_obj.add_char('fact(')
})
self.button_rows_desc.append({
'7': lambda: screen_obj.add_char(7),
'8': lambda: screen_obj.add_char(8),
'9': lambda: screen_obj.add_char(9),
'÷': lambda: screen_obj.add_char('/'),
'←': lambda: screen_obj.delete_last_position()
})
self.button_rows_desc.append({
'4': lambda: screen_obj.add_char(4),
'5': lambda: screen_obj.add_char(5),
'6': lambda: screen_obj.add_char(6),
'*': lambda: screen_obj.add_char('×'),
'√': lambda: screen_obj.add_char('√(')
})
self.button_rows_desc.append({
'1': lambda: screen_obj.add_char(1),
'2': lambda: screen_obj.add_char(2),
'3': lambda: screen_obj.add_char(3),
'-': lambda: screen_obj.add_char('-'),
'^': lambda: screen_obj.add_char('^')
})
self.button_rows_desc.append({
'0': lambda: screen_obj.add_char(0),
'.': lambda: screen_obj.add_char('.'),
'+': lambda: screen_obj.add_char('+'),
'=': lambda: screen_obj.add_answer(
solver_obj.calculate(screen_obj.get_expr())
),
'Adv': mode_changer
})
class Screen(InterfaceObject):
def __init__(self):
super().__init__()
self.width=24
self.height=10
self.font=('Arial', 18)
def create(self, master):
pass
def attach(self):
self.obj.grid(row=0, column=0, columnspan=6, sticky='w')
self.obj.focus_set()
self.obj.configure(state='disable')
def add_char(self):
pass
def get(self):
pass
def get_expr(self) -> str:
self.obj.configure(state='normal')
answer = self.obj.get()
self.obj.configure(state='disabled')
return answer
def delete_last_position(self):
self.obj.configure(state='normal')
if self.obj.get() != 'Invalid Input!':
temp = self.obj.get()[:-1]
self.obj.delete(0, tk.END)
self.obj.insert(0, temp)
else:
self.obj.delete(0, tk.END)
self.obj.configure(state='disabled')
def clear_line(self):
self.obj.configure(state='normal')
self.obj.delete(0, tk.END)
self.obj.configure(state='disabled')
def add_answer(self, answer):
pass
class StandartScreen(Screen):
def __init__(self, master):
super().__init__()
self.obj = tk.Entry(master, width=self.width, font=self.font)
self.attach()
def add_char(self, char):
self.obj.configure(state='normal')
if self.obj.get() == 'Invalid Input!':
self.obj.delete(0, tk.END)
self.obj.insert(tk.END, char)
self.obj.configure(state='disabled')
def get(self) -> float:
self.obj.configure(state='normal')
value_str = self.obj.get()
try:
result = float(value_str)
except Exception as ex:
self.obj.delete(0, tk.END)
self.obj.insert(0, 'Is not number!')
result = 0.0
self.obj.configure(state='disabled')
return result
def add_answer(self, answer):
self.clear_line()
self.add_char(answer)
class AdvancedScreen(Screen):
def __init__(self, master):
super().__init__()
self.cur_line = 0
self.cur_col = 0
self.lines = list()
self.lines.append('')
self.obj = tk.Text(master, width=self.width, height=self.height,
font=self.font)
self.attach()
def add_char(self, char):
char = str(char)
self.lines[-1] += char
self.display_lines()
def clear_line(self):
self.lines[-1] = ''
self.display_lines()
def delete_last_position(self):
new_val = self.lines[-1][:-1]
self.lines[-1] = new_val
self.display_lines()
def get_expr(self):
answer = self.lines[-1]
return answer
def display_lines(self):
self.obj.configure(state='normal')
self.obj.delete('1.0', 'end')
content = ''
for line in self.lines:
line = line + '\n'
content += line
self.obj.insert('1.0', content)
self.obj.configure(state='disabled')
def add_answer(self, answer):
answer = str(answer)
if len(self.lines) >= self.height-1:
self.lines = self.lines[2:]
self.lines.append(answer)
self.lines.append('')
self.display_lines()
def get(self) -> float:
try:
answer = float(self.lines[-1])
except Exception:
answer = None
self.add_answer('ERROR!')
return answer
class Application(tk.Frame):
def __init__(self, master):
tk.Frame.__init__(self, master)
self.master = master
self.screen = StandartScreen(self.master)
self.keyboard = StandartKeyboard(self)
self.memory = Memory(1)
self.solver = Solver()
self.create_standart_interface()
def create_standart_interface(self):
self.clear_interface()
self.screen = StandartScreen(self.master)
self.memory = Memory(self.master, cells_number=1)
self.solver = Solver()
self.keyboard = StandartKeyboard(self)
self.keyboard.bind_buttons(self.memory, self.screen, self.solver, self.change_mode)
self.keyboard.attach()
self.grid()
def create_advanced_interface(self):
self.clear_interface()
self.screen = AdvancedScreen(self.master)
self.memory = Memory(self.master, cells_number=9)
self.solver = Solver()
self.keyboard = AdvancedKeyboard(self)
self.keyboard.bind_buttons(self.memory, self.screen, self.solver, self.change_mode)
self.keyboard.attach()
self.grid()
def change_mode(self):
if isinstance(self.screen, StandartScreen) and isinstance(self.keyboard, StandartKeyboard):
self.create_advanced_interface()
elif isinstance(self.screen, AdvancedScreen) and isinstance(self.keyboard, AdvancedKeyboard):
self.create_standart_interface()
def clear_interface(self):
self.screen.delete()
self.keyboard.delete()
self.screen = None
self.keyboard = None
self.solver = None
if __name__ == '__main__':
root = tk.Tk()
root.title('Calculator')
root.geometry()
app = Application(root)
root.mainloop()
Исходный код логико-аналитической системы
__author__ = 'Adi Levin'
from vpython import vector, cylinder, box, rate, distant_light
class hanoi_move(object):
def __init__(self,disk_to_move,from_rod,to_rod):
self.disk_to_move = disk_to_move
self.from_rod = from_rod
self.to_rod = to_rod
def __repr__(self):
return 'Move disk #%i from rod %i to rod %i' % (self.disk_to_move,self.from_rod,self.to_rod)
class hanoi_graphics(object):
def __init__(self,num_of_disks,num_of_rods):
self.max_disk_radius = 1.0
self.disk_thickness = 0.2
self.rod_height = self.disk_thickness * (num_of_disks + 1)
self.disks = [cylinder(radius=self.max_disk_radius*(i+2)/(num_of_disks+1),
length=self.disk_thickness,
axis=vector(0,0,1),
color=vector(0.0,0.5,1.0)) \
for i in range(num_of_disks)]
self.rods = [cylinder(radius=self.max_disk_radius*1.0/(num_of_disks+1),
color=vector(1.0,0.5,0.3),
length=self.rod_height,
axis=vector(0,0,1)) for i in range(num_of_rods)]
for i in range(num_of_rods):
self.rods[i].pos.x = self.max_disk_radius*2*(i-(num_of_rods-1)*0.5)
for i in range(num_of_disks):
self.set_disk_pos(disk=i,rod=0,z_order=num_of_disks-i-1)
self.base = box(
pos=vector(0,0,-self.disk_thickness*0.5),
length=(num_of_rods+0.5)*self.max_disk_radius*2,
width=self.disk_thickness,
height=self.max_disk_radius*2.5,
color=vector(0.2,1.0,0.2))
def set_disk_pos(self,disk,rod,z_order):
self.disks[disk].pos.z = self.disk_thickness * z_order
self.disks[disk].pos.x = self.rods[rod].pos.x
def animate_disk_move(self,disk,to_rod,to_z_order):
self.animate_motion_to_pos(self.disks[disk],vector(self.disks[disk].pos.x,self.disks[disk].pos.y,self.rod_height + self.disk_thickness))
self.animate_motion_to_pos(self.disks[disk],vector(self.rods[to_rod].pos.x,self.rods[to_rod].pos.y,self.rod_height + self.disk_thickness))
self.animate_motion_to_pos(self.disks[disk],vector(self.rods[to_rod].pos.x,self.rods[to_rod].pos.y,self.disk_thickness * to_z_order))
def animate_motion_to_pos(self,shape,new_pos):
pos0 = shape.pos
pos1 = new_pos
num_steps = 30
for i in range(num_steps):
rate(40)
x = (i-1)*1.0/(num_steps-1)
shape.pos = (1-x)*pos0 + x*pos1
def calc_hanoi_sequence(num_of_disks,from_rod,to_rod):
if num_of_disks==0:
return []
l1 = calc_hanoi_sequence(num_of_disks=num_of_disks-1,from_rod=from_rod,to_rod=3-from_rod-to_rod)
l2 = [hanoi_move(disk_to_move=num_of_disks-1,from_rod=from_rod,to_rod=to_rod)]
l3 = calc_hanoi_sequence(num_of_disks=num_of_disks-1,from_rod=3-from_rod-to_rod,to_rod=to_rod)
return l1+l2+l3
class hanoi_state(object):
def __init__(self,num_of_disks):
self.num_of_disks_per_rod = [num_of_disks,0,0]
self.place_of_disk = [0]*num_of_disks
def move_disk_to_rod(self,disk,to_rod):
self.num_of_disks_per_rod[self.place_of_disk[disk]] -= 1
self.place_of_disk[disk] = to_rod
self.num_of_disks_per_rod[self.place_of_disk[disk]] += 1
def visualize_hanoi_solution(num_of_disks):
g = hanoi_graphics(num_of_disks,8)
state = hanoi_state(num_of_disks)
def solve_one(from_rod,to_rod):
moves = calc_hanoi_sequence(num_of_disks,from_rod,to_rod)
rate(1.0)
for move in moves:
g.animate_disk_move(disk=move.disk_to_move,to_rod=move.to_rod,to_z_order=state.num_of_disks_per_rod[move.to_rod])
state.move_disk_to_rod(disk=move.disk_to_move,to_rod=move.to_rod)
while True:
solve_one(0,2)
solve_one(2,0)
if __name__=='__main__':
lights = [distant_light(direction=vector(0,ydir,0), color=vector(1.0,1.0,1.0)) for ydir in [-1.0,1.0]]
visualize_hanoi_solution(num_of_disks=6)
