Гэддис Т. Начинаем программировать на 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()
Исходный код логико-аналитической системы
from vpython import vector, cylinder, box, rate, distant_light
class HanoiMove:
def __init__(self, disk: int, source: int, destination: int):
self.disk = disk
self.source = source
self.destination = destination
def __repr__(self):
return f"Move disk #{self.disk} from rod {self.source} to rod {self.destination}"
class HanoiVisualizer:
def __init__(self, num_disks: int, num_rods: int):
self.num_disks = num_disks
self.num_rods = num_rods
self.disk_radius_factor = 1.0
self.disk_height = 0.2
self.rod_length = self.disk_height * (self.num_disks + 1)
self.disks = [
cylinder(
radius=self.disk_radius_factor * (i + 2) / (self.num_disks + 1),
length=self.disk_height,
axis=vector(0, 0, 1),
color=vector(0.0, 0.5, 1.0)
) for i in range(self.num_disks)
]
self.rods = [
cylinder(
radius=self.disk_radius_factor / (self.num_disks + 1),
color=vector(1.0, 0.5, 0.3),
length=self.rod_length,
axis=vector(0, 0, 1)
) for _ in range(self.num_rods)
]
# Position rods
spacing = 2 * self.disk_radius_factor
start_x = -spacing * (self.num_rods - 1) / 2
for idx, rod in enumerate(self.rods):
rod.pos.x = start_x + idx * spacing
# Initialize disk positions on the first rod
for i, disk in enumerate(self.disks):
self.place_disk(disk_index=i, rod_index=0, level=self.num_disks - i - 1)
# Create base
self.base = box(
pos=vector(0, 0, -self.disk_height / 2),
length=(self.num_rods + 0.5) * self.disk_radius_factor * 2,
width=self.disk_height,
height=self.disk_radius_factor * 2.5,
color=vector(0.2, 1.0, 0.2)
)
def place_disk(self, disk_index: int, rod_index: int, level: int):
self.disks[disk_index].pos = vector(
self.rods[rod_index].pos.x,
self.rods[rod_index].pos.y,
self.disk_height * level
)
def animate_move(self, move: HanoiMove, state):
disk = move.disk
target_rod = move.destination
current_level = state.disks_on_rods[target_rod]
# Lift disk
self.animate_motion(self.disks[disk], vector(self.disks[disk].pos.x, self.disks[disk].pos.y, self.rod_length + self.disk_height))
# Move horizontally to target rod
self.animate_motion(self.disks[disk], vector(self.rods[target_rod].pos.x, self.rods[target_rod].pos.y, self.rod_length + self.disk_height))
# Place disk on target rod
self.animate_motion(self.disks[disk], vector(self.rods[target_rod].pos.x, self.rods[target_rod].pos.y, self.disk_height * current_level))
# Update state
state.move_disk(disk, target_rod)
def animate_motion(self, disk, new_position):
steps = 30
for i in range(steps):
rate(40)
t = i / steps
disk.pos = disk.pos * (1 - t) + new_position * t
class HanoiState:
def __init__(self, num_disks: int, num_rods: int):
self.num_disks = num_disks
self.num_rods = num_rods
self.disks_on_rods = [0] * num_rods
self.disk_positions = [0] * num_disks # Tracks rod index for each disk
def initialize(self):
self.disks_on_rods[0] = self.num_disks
for disk in range(self.num_disks):
self.disk_positions[disk] = 0
def move_disk(self, disk: int, to_rod: int):
from_rod = self.disk_positions[disk]
self.disks_on_rods[from_rod] -= 1
self.disks_on_rods[to_rod] += 1
self.disk_positions[disk] = to_rod
def calculate_hanoi_moves(n: int, source: int, target: int, auxiliary: int) -> list:
if n == 0:
return []
moves = calculate_hanoi_moves(n - 1, source, auxiliary, target)
moves.append(HanoiMove(disk=n - 1, source=source, destination=target))
moves += calculate_hanoi_moves(n - 1, auxiliary, target, source)
return moves
def visualize_solution(num_disks: int):
num_rods = 3 # Standard Towers of Hanoi has 3 rods
visualizer = HanoiVisualizer(num_disks, num_rods)
state = HanoiState(num_disks, num_rods)
state.initialize()
def solve(from_rod, to_rod, aux_rod):
moves = calculate_hanoi_moves(num_disks, from_rod, to_rod, aux_rod)
for move in moves:
visualizer.animate_move(move, state)
solve(0, 2, 1)
if __name__ == "__main__":
# Настройка освещения
lights = [
distant_light(direction=vector(0, -1, 0), color=vector(1.0, 1.0, 1.0)),
distant_light(direction=vector(0, 1, 0), color=vector(1.0, 1.0, 1.0))
]
visualize_solution(num_disks=6)
