Гэддис Т. Начинаем программировать на 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.
Приложения
Исходный код программы для анализа данных
import collections
def read_file(filepath: str) -> str:
with open(filepath, 'r', encoding='utf-8') as file:
return file.read().lower()
def count_words(text: str) -> collections.Counter:
words = text.split()
return collections.Counter(words)
def sort_words(word_counts: collections.Counter) -> list:
return sorted(word_counts.items(), key=lambda x: (-x[1], x[0]))
def format_output(sorted_words: list) -> str:
return '\n'.join(f"{word} {count}" for word, count in sorted_words) + '\n'
def save_results(filepath: str, content: str) -> None:
with open(filepath, 'w', encoding='utf-8') as file:
file.write(content)
def main():
input_path = 'resourse_1.txt'
output_path = 'result_1.txt'
text = read_file(input_path)
word_counts = count_words(text)
sorted_word_list = sort_words(word_counts)
output_content = format_output(sorted_word_list)
print(output_content)
save_results(output_path, output_content)
if __name__ == '__main__':
main()
Исходный код программы работы с банковскими счетами
import tkinter as tk
from tkinter import messagebox
class BankAccount:
def __init__(self, owner: str, initial_balance: float = 0.0):
self.owner = owner
self.balance = initial_balance
def deposit(self, amount: float):
if amount > 0:
self.balance += amount
else:
raise ValueError("Deposit amount must be positive.")
def withdraw(self, amount: float):
if 0 < amount <= self.balance:
self.balance -= amount
else:
raise ValueError("Insufficient funds or invalid withdrawal amount.")
def apply_interest(self, rate: float):
if self.balance > 0:
self.balance += self.balance * rate / 100
def transfer(self, amount: float, target_account):
self.withdraw(amount)
target_account.deposit(amount)
def __str__(self):
return f"{self.owner}: {self.balance:.2f}"
class AccountManager:
def __init__(self):
self.accounts = {}
def get_or_create_account(self, owner: str) -> BankAccount:
return self.accounts.setdefault(owner, BankAccount(owner))
def execute_command(self, command: str) -> str:
parts = command.strip().split()
if not parts:
return "Empty command."
action = parts[0].upper()
try:
if action == 'DEPOSIT' and len(parts) == 3:
account = self.get_or_create_account(parts[1])
amount = float(parts[2])
account.deposit(amount)
return f"Deposited {amount:.2f} to {account.owner}."
elif action == 'WITHDRAW' and len(parts) == 3:
account = self.get_or_create_account(parts[1])
amount = float(parts[2])
account.withdraw(amount)
return f"Withdrew {amount:.2f} from {account.owner}."
elif action == 'BALANCE':
if len(parts) == 1:
return '\n'.join(str(acc) for acc in self.accounts.values())
else:
account = self.accounts.get(parts[1])
return str(account) if account else "NO CLIENT"
elif action == 'TRANSFER' and len(parts) == 4:
from_acc = self.get_or_create_account(parts[1])
to_acc = self.get_or_create_account(parts[2])
amount = float(parts[3])
from_acc.transfer(amount, to_acc)
return f"Transferred {amount:.2f} from {from_acc.owner} to {to_acc.owner}."
elif action == 'INCOME' and len(parts) == 2:
rate = float(parts[1])
for acc in self.accounts.values():
acc.apply_interest(rate)
return f"Applied {rate}% interest to all accounts."
else:
return "Invalid command or parameters."
except ValueError as ve:
return f"Error: {ve}"
class BankGUI:
def __init__(self, master):
self.manager = AccountManager()
self.master = master
self.master.title("Bank Account Manager")
# Frames
self.input_frame = tk.Frame(master)
self.output_frame = tk.Frame(master)
self.button_frame = tk.Frame(master)
self.input_frame.pack(padx=10, pady=5)
self.output_frame.pack(padx=10, pady=5)
self.button_frame.pack(padx=10, pady=5)
# Input Text
self.input_text = tk.Text(self.input_frame, width=60, height=10)
self.input_text.pack()
# Output Text
self.output_text = tk.Text(self.output_frame, width=60, height=10, state='disabled')
self.output_text.pack()
# Buttons
self.calculate_btn = tk.Button(self.button_frame, text="Calculate", command=self.calculate)
self.clear_btn = tk.Button(self.button_frame, text="Clear", command=self.clear)
self.calculate_btn.pack(side='left', padx=5)
self.clear_btn.pack(side='left', padx=5)
def calculate(self):
commands = self.input_text.get("1.0", tk.END).strip().split('\n')
results = []
for cmd in commands:
if cmd.strip():
result = self.manager.execute_command(cmd)
results.append(f"Command: {cmd}\nResult: {result}\n{'-'*20}")
output = '\n'.join(results)
self.output_text.configure(state='normal')
self.output_text.delete("1.0", tk.END)
self.output_text.insert(tk.END, output)
self.output_text.configure(state='disabled')
def clear(self):
self.input_text.delete("1.0", tk.END)
self.output_text.configure(state='normal')
self.output_text.delete("1.0", tk.END)
self.output_text.configure(state='disabled')
def main():
root = tk.Tk()
gui = BankGUI(root)
root.mainloop()
if __name__ == "__main__":
main()
Исходный код программы-калькулятора
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='disabled')
def add_char(self):
pass
def get(self):
pass
def get_expr(self) -> str:
self.obj.configure(state='normal')
expression = self.obj.get()
self.obj.configure(state='disabled')
return expression
def delete_last_position(self):
self.obj.configure(state='normal')
if self.obj.get() != 'Invalid Input!':
updated = self.obj.get()[:-1]
self.obj.delete(0, tk.END)
self.obj.insert(0, updated)
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 ValueError:
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(str(answer))
class AdvancedScreen(Screen):
def __init__(self, master):
super().__init__()
self.lines = ['']
self.obj = tk.Text(master, width=self.width, height=self.height, font=self.font)
self.attach()
def add_char(self, char):
self.lines[-1] += str(char)
self.refresh_display()
def clear_line(self):
self.lines[-1] = ''
self.refresh_display()
def delete_last_position(self):
if self.lines[-1] != 'Invalid Input!':
self.lines[-1] = self.lines[-1][:-1]
else:
self.lines[-1] = ''
self.refresh_display()
def get_expr(self) -> str:
return self.lines[-1]
def refresh_display(self):
self.obj.configure(state='normal')
self.obj.delete('1.0', tk.END)
self.obj.insert(tk.END, '\n'.join(self.lines) + '\n')
self.obj.configure(state='disabled')
def add_answer(self, answer):
if len(self.lines) >= self.height - 1:
self.lines = self.lines[1:]
self.lines.append(str(answer))
self.lines.append('')
self.refresh_display()
def get(self) -> float:
try:
return float(self.lines[-1])
except ValueError:
self.add_answer('ERROR!')
return 0.0
class Application(tk.Frame):
def __init__(self, master):
super().__init__(master)
self.master = master
self.memory = Memory(master, cells_number=1)
self.solver = Solver()
self.screen = StandartScreen(master)
self.keyboard = StandartKeyboard(self)
self.keyboard.bind_buttons(self.memory, self.screen, self.solver, self.toggle_mode)
self.keyboard.attach()
self.grid()
def toggle_mode(self):
if isinstance(self.screen, StandartScreen):
self.switch_to_advanced()
else:
self.switch_to_standard()
def switch_to_advanced(self):
self.clear_interface()
self.screen = AdvancedScreen(self.master)
self.memory = Memory(self.master, cells_number=9)
self.keyboard = AdvancedKeyboard(self)
self.keyboard.bind_buttons(self.memory, self.screen, self.solver, self.toggle_mode)
self.keyboard.attach()
self.grid()
def switch_to_standard(self):
self.clear_interface()
self.screen = StandartScreen(self.master)
self.memory = Memory(self.master, cells_number=1)
self.keyboard = StandartKeyboard(self)
self.keyboard.bind_buttons(self.memory, self.screen, self.solver, self.toggle_mode)
self.keyboard.attach()
self.grid()
def clear_interface(self):
self.screen.delete()
self.keyboard.delete()
def main():
root = tk.Tk()
root.title('Calculator')
app = Application(root)
root.mainloop()
if __name__ == '__main__':
main()
Исходный код логико-аналитической системы
import tkinter as tk
from tkinter import ttk
import random
import copy
def create_disk_layout(input_str):
spindle_disks = {}
for idx, ch in enumerate(input_str):
spindle_id = 8 - idx
disk_count = int(ch)
disks = [spindle_id * 10 + i + 1 for i in range(disk_count)]
spindle_disks[spindle_id] = disks
reversed_layout = {k: v[::-1] for k, v in spindle_disks.items()}
return reversed_layout
def reorganize_disks(disk_data, source, dest, temp, path, max_steps=None, counter=None):
if not disk_data[source]:
return
steps_taken = 0
total_steps = 0
for _ in range(len(disk_data[source]) - 1):
if max_steps and total_steps >= max_steps:
return
disk_data[temp].append(disk_data[source].pop())
steps_taken += 1
total_steps += 1
if counter:
counter[0] += 1
for node in path:
if max_steps and total_steps >= max_steps:
return
disk_data[node].append(disk_data[source][0])
if node != dest:
disk_data[node].remove(disk_data[node][-1])
total_steps += 1
if counter:
counter[0] += 1
disk_data[source].pop(0)
for _ in range(steps_taken):
if max_steps and total_steps >= max_steps:
return
disk_data[source].append(disk_data[temp].pop())
total_steps += 1
if counter:
counter[0] += 1
while disk_data[source]:
reorganize_disks(disk_data, source, dest, temp, path, max_steps, counter)
class TowerPuzzle:
def __init__(self, root, user_code="70185749"):
self.user_code = user_code
self.progress_points = [70, 18, 57, 49]
self.root = root
self.root.title("Модифицированная ханойская башня")
self.disk_counts = [int(c) for c in user_code]
self.total_spindles = 8
self.initial_setup = create_disk_layout(self.user_code)
self.current_setup = copy.deepcopy(self.initial_setup)
self.final_config, self.total_steps = self.calculate_final_config()
self.intermediate_states = [self.calculate_partial_state(p) for p in self.progress_points]
self.disk_colors = [f'#{random.randint(0, 0xFFFFFF):06x}' for _ in range(sum(self.disk_counts))]
self.main_frame = ttk.Frame(root, padding=10)
self.main_frame.grid(row=0, column=0, sticky="nsew")
self.drawing_area = tk.Canvas(self.main_frame, width=1280, height=800, bg='white')
self.drawing_area.grid(row=0, column=0, sticky="nsew")
self.vert_scroll = ttk.Scrollbar(self.main_frame, orient=tk.VERTICAL, command=self.drawing_area.yview)
self.horz_scroll = ttk.Scrollbar(self.main_frame, orient=tk.HORIZONTAL, command=self.drawing_area.xview)
self.vert_scroll.grid(row=0, column=1, sticky="ns")
self.horz_scroll.grid(row=1, column=0, sticky="ew")
self.drawing_area.configure(yscrollcommand=self.vert_scroll.set, xscrollcommand=self.horz_scroll.set)
self.content_frame = ttk.Frame(self.drawing_area)
self.drawing_area.create_window((0, 0), window=self.content_frame, anchor="nw")
self.content_frame.bind("<Configure>",
lambda e: self.drawing_area.configure(scrollregion=self.drawing_area.bbox("all")))
self.redraw_towers()
self.control_frame = ttk.Frame(self.main_frame)
self.control_frame.grid(row=2, column=0, sticky="ew", pady=10)
self.control_frame.columnconfigure(0, weight=1)
self.button_frame = ttk.Frame(self.control_frame)
self.button_frame.grid(row=0, column=0)
ttk.Button(self.button_frame, text="Reset", command=self.show_initial).grid(row=0, column=0, padx=5, pady=5)
self.progress_entries = []
for i, val in enumerate(self.progress_points):
entry = ttk.Entry(self.button_frame, width=5)
entry.insert(0, str(val))
entry.grid(row=0, column=2 * i + 1, padx=5, pady=5)
self.progress_entries.append(entry)
ttk.Button(self.button_frame, text=f"Step {i + 1}", command=lambda i=i: self.show_intermediate(i)).grid(
row=0, column=2 * i + 2, padx=5, pady=5)
ttk.Button(self.button_frame, text="Complete", command=self.show_final).grid(row=0, column=9, padx=5, pady=5)
self.moves_display = ttk.Label(self.control_frame, text="Steps: 0")
self.moves_display.grid(row=1, column=0, pady=5)
def calculate_final_config(self):
disk_arrangement = create_disk_layout(self.user_code)
step_counter = [0]
if disk_arrangement[1]:
disk_arrangement[2].extend(disk_arrangement[1])
disk_arrangement[1] = []
reorganize_disks(disk_arrangement, 8, 1, 7, [6, 5, 4, 3, 2, 1], counter=step_counter)
reorganize_disks(disk_arrangement, 7, 1, 8, [6, 5, 4, 3, 2, 1], counter=step_counter)
reorganize_disks(disk_arrangement, 6, 1, 7, [5, 4, 3, 2, 1], counter=step_counter)
reorganize_disks(disk_arrangement, 5, 1, 6, [4, 3, 2, 1], counter=step_counter)
reorganize_disks(disk_arrangement, 4, 1, 5, [3, 2, 1], counter=step_counter)
reorganize_disks(disk_arrangement, 3, 1, 4, [2, 1], counter=step_counter)
reorganize_disks(disk_arrangement, 2, 1, 3, [1], counter=step_counter)
return {k: disk_arrangement.get(k, []) for k in range(8, 0, -1)}, step_counter[0]
def calculate_partial_state(self, percentage):
max_steps = int(percentage)
disk_arrangement = create_disk_layout(self.user_code)
step_counter = [0]
if disk_arrangement[1]:
disk_arrangement[2].extend(disk_arrangement[1])
disk_arrangement[1] = []
reorganize_disks(disk_arrangement, 8, 1, 7, [6, 5, 4, 3, 2, 1], max_steps=max_steps, counter=step_counter)
return disk_arrangement, step_counter[0]
def redraw_towers(self):
self.drawing_area.delete("all")
self.drawing_area.create_rectangle(50, 700, 1230, 720, fill='saddle brown')
column_spacing = 120
for col in range(self.total_spindles):
x_pos = 120 + col * column_spacing
self.drawing_area.create_rectangle(x_pos - 5, 200, x_pos + 5, 700, fill='sienna')
self.drawing_area.create_text(x_pos, 740, text=str(8 - col), font=('Helvetica', 12))
color_idx = 0
layer_height = 12
for spindle in range(self.total_spindles):
base_x = 120 + spindle * column_spacing
current_y = 690
for disk in self.current_setup.get(8 - spindle, []):
disk_size = disk
disk_color = self.disk_colors[color_idx % len(self.disk_colors)]
color_idx += 1
self.drawing_area.create_rectangle(
base_x - disk_size / 2, current_y - layer_height,
base_x + disk_size / 2, current_y,
fill=disk_color, outline='black'
)
self.drawing_area.create_text(base_x, current_y - layer_height // 2,
text=str(disk), fill='white')
current_y -= layer_height + 5
def show_initial(self):
self.current_setup = copy.deepcopy(self.initial_setup)
self.moves_display.config(text="Steps: 0")
self.redraw_towers()
def show_final(self):
self.current_setup = copy.deepcopy(self.final_config)
self.moves_display.config(text=f"Steps: {self.total_steps}")
self.redraw_towers()
def show_intermediate(self, idx):
self.current_setup, steps = self.intermediate_states[idx]
self.moves_display.config(text=f"Steps: {steps}")
self.redraw_towers()
if __name__ == "__main__":
app_window = tk.Tk()
puzzle = TowerPuzzle(app_window)
app_window.mainloop()
