Сделать задачку используя концепцию классов. Добавить Label на форму. Сделать так чтобы при клике на кнопку Привет в этот Label приветствовался пользователь. А также добавить вторую кнопку на форму, при клике на которую в Label будет выводится прощание с пользователем.
Как-то так:
Чтобы установить текст метки используйте свойство text, вот так:
self.label['text'] = "Привет, друг"
Добавить кнопку к приложению из подсказки, чтобы при нажатии на которую загрузились данные из файлика. Как-то так:
Добавить на форму поле для ввода позиции, в которую вставлять очередной элемент списка.
Добавить поле под отчество, при выводе списка показывать только имя фамилию. В общем чтобы как-то так работало:
Если лень зполнять список вручную можно использовать вот такой список: students.json
Кстати, чтобы сделать такой скроллбар как у меня надо добавить специальную компоненту в __init__
scrollbar = Scrollbar(gui)
scrollbar.place(x=220 + 160, y=10, height=130) # расположить ее справа от списка
scrollbar.config(command=self.studentsList.yview) # привязать скроллинг списка как реакцию на движение ползунка
self.studentsList.config(yscrollcommand=scrollbar.set) # привязать смещение ползунка, когда скролят список
Убрать кнопку сохранить в файл, заменить ее на кнопку добавить, которая будет добавлять нового студента, которого можно будет отредактировать. Как-то так:
Доработать приложение, добавить возможность привязать к пользователю изображение. Работать должно примерно так
Сегодня попробуем более грамотно работать с интерфейсами путем организации кода в так называемые классы.
И так, возьмем нашу базовую заготовку для запуска интерфейса, выглядит она вот так:
from tkinter import *
def my_setup(gui):
gui.geometry("600x200")
gui = Tk()
my_setup(gui)
gui.mainloop()
перепишем ее следующим образом
from tkinter import *
class UI():
def __init__(self, gui):
gui.geometry("600x200")
gui = Tk()
UI(gui)
gui.mainloop()
UI – это так называемый класс, классы позволяют нам более удобно работать с функциями. Например, добавим поле для ввода и кнопочку которая при клике будет приветствовать пользователя по имени которое он ввел:
from tkinter import *
class UI():
def __init__(self, gui):
gui.geometry("600x200")
text = Entry(gui)
text.place(x=10, y=10, width=300, height=20)
def button_click():
print(f"Привет {text.get()}")
button = Button(gui, text="Привет", command=button_click)
button.place(x=320, y=10)
gui = Tk()
UI(gui)
gui.mainloop()
возможно вас, как и меня раздражало то, что мы не можем взять функцию button_click и поместить, например, после создания элементов.
Так вот использование классов позволяет это сделать. Для этого код надо переписать следующим образом:
from tkinter import *
class UI():
def __init__(self, gui):
gui.geometry("600x200")
self.text = Entry(gui)
self.text.place(x=10, y=10, width=300, height=20)
self.button = Button(gui, text="Привет", command=self.button_click)
self.button.place(x=320, y=10)
def button_click(self):
print(f"Привет {self.text.get()}")
gui = Tk()
UI(gui)
gui.mainloop()
схема работы примерно такая
то есть появляется специальное слово self, это так называемая ссылка на область в памяти на самого себя. И мы привязываем к этому слову self (ну типа к самом себе), поле для ввода text.
Далее выносим реакцию на клик button_click из функции __init__ и добавляем в качестве парамерта это самое слово self.
Так как этот self и в __init__ и в button_click это один и тот же объект, то мы можем из функции button_click получить доступ к полю для ввода, которое было создано в __init__, обращаясь к нему через self.text
И по аналогии из __init__ мы можем получить доступ к функции button_click обращаясь к нему через self.button_click
Такой подход позволяют проще структурировать сложный код.
Попробуем теперь сохранить введённые в поля для ввода значения в файл, а потом сделаем так чтобы при открытии файла значения восстановились.
Начнем как всегда с базы:
from tkinter import *
class UI():
def __init__(self, gui):
gui.geometry("400x200")
gui = Tk()
UI(gui)
gui.mainloop()
теперь добавим функцию для создания полей для ввода:
from tkinter import *
def create_entry(x, y, label_text, entry_width):
label = Label(gui, text=label_text)
label.place(x=x, y=y)
gui.update()
entry = Entry(gui)
entry.place(x=x + label.winfo_width() + 10, y=y, width=entry_width)
gui.update()
return entry
class UI():
def __init__(self, gui):
gui.geometry("400x200")
gui = Tk()
UI(gui)
gui.mainloop()
теперь добавим поля для ввода:
from tkinter import *
def create_entry(x, y, label_text, entry_width):
# ...
class UI():
def __init__(self, gui):
gui.geometry("400x200")
# добавил три поля
self.name = create_entry(10, 10, "Имя", 120)
self.last_name = create_entry(10, 40, "Фамилия", 120)
self.age = create_entry(10, 70, "Возраст", 120)
gui = Tk()
UI(gui)
gui.mainloop()
если запустить получится что-то такое:
добавим еще кнопочку:
class UI():
def __init__(self, gui):
gui.geometry("400x200")
self.name = create_entry(10, 10, "Имя", 120)
self.last_name = create_entry(10, 40, "Фамилия", 120)
self.age = create_entry(10, 70, "Возраст", 120)
self.button = Button(text="Сохранить в файл")
self.button.place(x=10, y=100)
и реакцию к ней добавим:
class UI():
def __init__(self, gui):
gui.geometry("400x200")
self.name = create_entry(10, 10, "Имя", 120)
self.last_name = create_entry(10, 40, "Фамилия", 120)
self.age = create_entry(10, 70, "Возраст", 120)
# подключил функцию, через command=self.save_to_file
self.button = Button(text="Сохранить в файл", command=self.save_to_file)
self.button.place(x=10, y=100)
# собственно сама функция
def save_to_file(self):
print("Привет! =)")
а теперь попробуем сохранять то что ввели на форму в файл.
Для этого нам надо собрать данные с формы в так называемый словарик. Словарик — это еще одна структура данных по типу списка. Работает примерно так:
data = {
"ключ1": "значение1",
"ключ2": 234,
"ключ3": ["весна", "лето", "осень"],
}
# к привязанному к ключу значению получаем через квадратные скобочки
print(data['ключ1']) # напечатает "значение1"
print(data['ключ2']) # напечатает 234
print(data['ключ3']) # напечатает ["весна", "лето", "осень"]
То есть собирать будем так
class UI():
def __init__(self, gui):
# ...
def save_to_file(self):
# считаем значения с формы и сохраним в словарик
data = {
"name": self.name.get(),
"last_name": self.last_name.get(),
"age": self.age.get(),
}
print(data) # попробуем напечатать словарик в консольку
тестируем:
как видим словарик сформировался из значений на форме.
Мы можем эти значения сохранить в файл, для этого в python есть пакет json. Подключается он как обычно через import, добавим его в самый вверх:
from tkinter import *
import json # добавил импорт
def create_entry(x, y, label_text, entry_width):
# ...
class UI():
def __init__(self, gui):
# ...
def save_to_file(self):
# ...
gui = Tk()
UI(gui)
gui.mainloop()
а теперь воспользуемся этим пакетом чтобы сохранить данные в файл, делается это достаточно просто:
class UI():
def __init__(self, gui):
# ...
def save_to_file(self):
data = {
"name": self.name.get(),
"last_name": self.last_name.get(),
"age": self.age.get(),
}
print(data)
# открываем файл user.json на запись
with open("user.json", "w") as f:
json.dump(data, f) # собственно записываем словарик data в файл f
пробуем:
о файлик появился, только вместо букв какая-та абракадабра. Чтобы буквы писались нормально добавим несколько параметров:
class UI():
def __init__(self, gui):
# ...
def save_to_file(self):
data = {
"name": self.name.get(),
"last_name": self.last_name.get(),
"age": self.age.get(),
}
print(data)
# тут добавим encoding="utf8", указав таким образом кодировку, которая поддерживает все буквы
with open("user.json", "w", encoding="utf8") as f:
# тут добавим ensure_ascii=False чтобы русские буквы не преобразовывались в комбинации английских
# indent -- сделает вывод словарика более читабельным
json.dump(data, f, ensure_ascii=False, indent=2)
проверяем:
красота! =)
Теперь попробуем считать значения из этого файла и заполнять поля при старте приложения
class UI():
def __init__(self, gui):
# ...
self.button = Button(text="Сохранить в файл", command=self.save_to_file)
self.button.place(x=10, y=100)
# открываем файл для чтения
with open("user.json", encoding="utf8") as f:
# считываем словарик из файла в переменную
data = json.load(f)
# выведем считанный словарик в консоль
print(data)
def save_to_file(self):
# ...
gui = Tk()
UI(gui)
gui.mainloop()
по идее при запуске приложения сразу должно вывестись в консоль содержимое файла, проверяем:
так, попробуем какой-нибудь конкретный ключ вывести, допустим фамилию:
class UI():
def __init__(self, gui):
# ...
with open("user.json", encoding="utf8") as f:
data = json.load(f)
# выведем фамилию в консоль
print(data['last_name'])
def save_to_file(self):
# ...
gui = Tk()
UI(gui)
gui.mainloop()
класс! =О
Ну в принципе теперь можно без проблем заполнить поля на форме по этим полям:
class UI():
def __init__(self, gui):
# ...
print(data['last_name'])
# заполняем поля для ввода
self.name.insert(0, data['name'])
self.last_name.insert(0, data['last_name'])
self.age.insert(0, data['age'])
def save_to_file(self):
# ...
gui = Tk()
UI(gui)
gui.mainloop()
Попробуем теперь поработать со списком словариков. Допустим мы делаем программу с помощью которой можно формировать списки студентов. А сами списки чтобы можно было хранить в файле. Как бы мы могли это сделать?
Начнем с кода похожий на тот что был в прошлом задании:
from tkinter import *
import json
# это просто чтобы создавать поля для ввода
def create_entry(x, y, label_text, entry_width):
label = Label(gui, text=label_text)
label.place(x=x, y=y)
gui.update()
entry = Entry(gui)
entry.place(x=x + label.winfo_width() + 10, y=y, width=entry_width)
gui.update() # еще раз обновим интерфейс
return entry # вернем метку
class UI():
def __init__(self, gui):
gui.geometry("400x150")
# тут три поля под имя, фамилию, группу
self.name = create_entry(10, 10, "Имя", 120)
self.last_name = create_entry(10, 40, "Фамилия", 120)
self.group = create_entry(10, 70, "Группа", 120)
# кнопочка чтобы в файл сохранять
self.button = Button(text="Сохранить в файл", command=self.save_to_file)
self.button.place(x=10, y=100)
# собственно реакция на кнопочку для сохранения в файл
def save_to_file(self):
data = {
"name": self.name.get(),
"last_name": self.last_name.get(),
"group": self.group.get(),
}
with open("user.json", "w", encoding="utf8") as f:
json.dump(data, f, ensure_ascii=False, indent=2)
gui = Tk()
UI(gui)
gui.mainloop()
сейчас при попытке сохранить в файла она будет постоянно перезаписывать данные
поэтому надо как-то научится там делать сразу несколько записей.
Идея заключается в том, что мы вместо того чтобы хранить одну запись будем хранить список записей.
Можно для начала попробовать запихать в файлик просто список с одной записью:
class UI():
def __init__(self, gui):
# ...
def save_to_file(self):
# data это теперь список, внутри которого лежит один словарик:
data = [
{
"name": self.name.get(),
"last_name": self.last_name.get(),
"group": self.group.get(),
}
]
with open("user.json", "w", encoding="utf8") as f:
json.dump(data, f, ensure_ascii=False, indent=2)
теперь если на кнопочку кликнуть, то увидим, что внутри там стал тоже список, только уже с заполненными значениями
попробуем теперь немного реструктурировать код. Ведь по идее когда мы первый раз запустили программу список у нас пустой, а потому по клику мы добавляем в список нового студента. С точки зрения кода — это можно записать так:
class UI():
def __init__(self, gui):
# ...
def save_to_file(self):
data = [] # создали пустой список
data.append( # добавили в него элемент
{
"name": self.name.get(),
"last_name": self.last_name.get(),
"group": self.group.get(),
}
)
# перезаписываем файл
with open("user.json", "w", encoding="utf8") as f:
json.dump(data, f, ensure_ascii=False, indent=2)
работать это правда все равно будет так же, потому что наша кнопка при клике
поэтому нам надо сделать так чтобы при клике на кнопку:
пишем код:
class UI():
def __init__(self, gui):
# ...
def save_to_file(self):
# заружаем список из файла
with open("user.json", encoding="utf8") as f:
data = json.load(f) # кладем его в переменную data
# добавляем в этот список данные с формы
data.append(
{
"name": self.name.get(),
"last_name": self.last_name.get(),
"group": self.group.get(),
}
)
# сохраняем обновленный список в файл
with open("user.json", "w", encoding="utf8") as f:
json.dump(data, f, ensure_ascii=False, indent=2)
проверяем:
чудеса =О
Кстати у нас получается, что добавление идет всегда в конец файла, можно в принципе сделать чтобы добавление шло в начало списка.
Для этого надо добавлять элемент в список следующим образом:
class UI():
def __init__(self, gui):
# ...
def save_to_file(self):
with open("user.json", encoding="utf8") as f:
data = json.load(f)
# использую метод insert, у него первый параметр — это куда вставлять элемент,
# если указать 0 то будет вставлять элемент на первую позицию в списке
# если указать 1 то будет вставлять элемент на вторую позицию и т.д.
data.insert(0, {
"name": self.name.get(),
"last_name": self.last_name.get(),
"group": self.group.get(),
})
with open("user.json", "w", encoding="utf8") as f:
json.dump(data, f, ensure_ascii=False, indent=2)
Теперь, когда у нас есть файлик с несколькими записями попробуем вывести их сразу все на форму.
Для этого в tkinter встроена такая компонента как ListBox то бишь “коробочка под список”, выглядит он вот так:
Добавим ее на форму:
class UI():
def __init__(self, gui):
gui.geometry("400x150")
self.name = create_entry(10, 10, "Имя", 120)
self.last_name = create_entry(10, 40, "Фамилия", 120)
self.group = create_entry(10, 70, "Группа", 120)
self.button = Button(text="Сохранить в файл", command=self.save_to_file)
self.button.place(x=10, y=100)
# добавим список на форму
self.studentsList = Listbox(exportselection=False)
self.studentsList.place(x=220, y=10, height=130, width=170)
def save_to_file(self):
# ...
получится так:
Попробуем чего-нибудь добавить в этот список:
class UI():
def __init__(self, gui):
#...
self.studentsList = Listbox(exportselection=False)
self.studentsList.place(x=220, y=10, height=130, width=170)
# добавил три планеты
self.studentsList.insert(END, "Меркурий")
self.studentsList.insert(END, "Венера")
self.studentsList.insert(END, "Земля")
def save_to_file(self):
# ...
Попробуем теперь заполнить данными из файла:
class UI():
def __init__(self, gui):
self.studentsList = Listbox(exportselection=False)
self.studentsList.place(x=220, y=10, height=130, width=170)
"""
это убрали
self.studentsList.insert(END, "Меркурий")
self.studentsList.insert(END, "Венера")
self.studentsList.insert(END, "Земля")
"""
# открываем файл со студентами
with open("user.json", encoding="utf8") as f:
students = json.load(f)
# добавляем студентов в список
for s in students:
self.studentsList.insert(END, s)
# ...
смотрим что получится
ну в принципе вывелось, правда смотреть не удобно. Было бы лучше если выводил как-нибудь в виде имя фамилия.
class UI():
def __init__(self, gui):
# ...
with open("user.json", encoding="utf8") as f:
students = json.load(f)
for s in students:
# буду вместо s добавлять в список студента в виде "фамилия имя группа"
self.studentsList.insert(END, f"{s['last_name']} {s['name']} {s['group']}")
во, так уже лучше
Теперь попробуем сделать так, чтобы можно было кликнуть на студента в списке и подкорректировать запись.
Для этого есть возможность подцеплять так называемую реакцию на события к компоненте на форме.
В tkinter целая куча встроенных событий, например, мы можем добавить реакцию на клик мышкой. Делается это так:
class UI():
def __init__(self, gui):
# ...
self.studentsList = Listbox(exportselection=False)
self.studentsList.place(x=220, y=10, height=130, width=170)
# добавляем реакцию на клик мышки, чтобы вызывалась функция on_student_list_click
self.studentsList.bind("<Button>", self.on_student_list_click)
# ...
# собственно функция on_student_list_click
# обрати внимание на второй аргумент функции event, там информация о событии
def on_student_list_click(self, event):
print(event) # выведем информацию о событии
тестируем:
как мы видим он показывает координаты клика внутри списка. Еще есть там какой-то num, это номер кнопки мыши которую кликнули:
можно, например, подкорректировать функцию:
def on_student_list_click(self, event):
if event.num == 1:
print(f"Вы кликнули левой кнопкой в точку ({event.x}, {event.y})")
elif event.num == 2:
print(f"Вы кликнули средней кнопкой в точку ({event.x}, {event.y})")
elif event.num == 3:
print(f"Вы кликнули правой кнопкой в точку ({event.x}, {event.y})")
и потыкать разными кнопками мыши:
а как например понять, что кликнули именно на конкретный элемент, тут есть два способа, первый это узнать по y координате порядковый номер строки в списке, а потом по номеру получить текст в этой строке
def on_student_list_click(self, event):
item_index = self.studentsList.nearest(event.y) # по координате event.y получаем номер строки
item_text = self.studentsList.get(item_index) # по номеру строки берем текст в строке
print(item_text) # выводим его в консольку
кстати если в консольку не нравится, можно показать информационное сообщение, делается это так:
def on_student_list_click(self, event):
item_index = self.studentsList.nearest(event.y) # по координате event.y получаем номер строки
item_text = self.studentsList.get(item_index) # по номеру строки берем текст в строке
messagebox.showinfo("Сообщение! =О", item_text) # выводим информационное сообщение, первый параметр -- это заголовок окна
больше видов можно подсмотреть тут https://docs.python.org/3/library/tkinter.messagebox.html
тестируем
прекрасно! =)
И альтернативный способ, если брать выбранный элемент по координате y выглядит странно. Можно вместо события клика мышью использовать специальное событие выбора строки.
Подключается это дело так:
class UI():
def __init__(self, gui):
#...
self.studentsList = Listbox(exportselection=False)
self.studentsList.place(x=220, y=10, height=130, width=170)
self.studentsList.bind('<<ListboxSelect>>', self.on_student_list_click)
# эту строчку убираем self.studentsList.bind("<Button>", self.on_student_list_click)
# ...
def on_student_list_click(self, event):
# тут вместо nearest используем метод curselection(),
# возвращает список выбранных строк (теоретически их может быть несколько),
# так как нам нужна только одна то поэтому пишем curselection()[0]
item_index = self.studentsList.curselection()[0]
# а дальше как обычно
item_text = self.studentsList.get(item_index)
messagebox.showinfo("", item_text)
работает так же
Ну пока мы играемся, а как сделать чтобы при клике на элемент в списке, заполнялась форма. И можно было бы обновить запись.
На самом деле сделать это не так просто, потому что то что выводится на форме к исходному списку уже никак не привязано, это по сути отдельный список.
И как быть?
А надо просто исходный список который из файла грузим тоже сохранять привязанным к self
Делаем это так:
class UI():
def __init__(self, gui):
# ...
self.studentsList = Listbox(exportselection=False)
self.studentsList.place(x=220, y=10, height=130, width=170)
self.studentsList.bind('<<ListboxSelect>>', self.on_student_list_click)
# как обычно открываем файл со студентами
with open("user.json", encoding="utf8") as f:
# и теперь привязываем список из файла к self.students
self.students = json.load(f)
# ну итерируем по списку self.students
for s in self.students:
self.studentsList.insert(END, f"{s['last_name']} {s['name']} {s['group']}")
def on_student_list_click(self, event):
# в реакции на клик берем как обычно выбранный номер строки с формы
item_index = self.studentsList.curselection()[0]
# а значение берем не из списка на форме, а из self.students
item = self.students[item_index]
# и заполняем значения на форме
self.name.delete(0, END)
self.name.insert(0, item['name'])
self.last_name.delete(0, END)
self.last_name.insert(0, item['last_name'])
self.group.delete(0, END)
self.group.insert(0, item['group'])
def save_to_file(self):
# ...
тыкаем:
в принципе можно теперь задание пилить
Теперь попробуем реализовать возможность править данные на форме.
Ну то есть, например, беру я студента и меняю ему фамилию.
Сначала сделаем кнопочку, для сохранения изменений:
class UI():
def __init__(self, gui):
#...
# это наша старая кнопка, ее не трогаем
self.button = Button(text="Сохранить в файл", command=self.save_to_file)
self.button.place(x=10, y=130)
# а вот тут добавил новую кнопку, привязал к ней функцию
self.button = Button(text="Обновить", command=self.on_student_update_click)
self.button.place(x=130, y=130)
# ...
# ну и саму функцию добавил
def on_student_update_click(self):
print("Обновляю")
# ...
о как получится должно
Теперь попробуем описать поведение которое нам надо реализовать
Ну шо, ноги в руки и пишем:
class UI():
def __init__(self, gui):
# ...
def on_student_update_click(self):
item_index = self.studentsList.curselection()[0] # получаем номер выделенной записи в списке на форме
item = self.students[item_index] # по номеру вытаскиваем словарик соответствующий студенту на форме
item['name'] = self.name.get() # перезаполняем значения словарика
item['last_name'] = self.last_name.get() # перезаполняем значения словарика
item['group'] = self.group.get() # перезаполняем значения словарика
item['patronymic'] = self.patronymic.get() # перезаполняем значения словарика
тестируем:
хм, что-та не работает…
А! Точно, у нас ведь список на форме напрямую не привязан к данным students, поэтому, чтобы форма обновилась надо перезаполнить этот список с нуля. То есть сначала все выкинуть, а потом заполнить.
class UI():
def __init__(self, gui):
# ...
def on_student_update_click(self):
item_index = self.studentsList.curselection()[0]
item = self.students[item_index]
item['name'] = self.name.get()
item['last_name'] = self.last_name.get()
item['group'] = self.group.get()
item['patronymic'] = self.patronymic.get()
# очищаем список
self.studentsList.delete(0, END)
# и перезаполняем
for s in self.students:
self.studentsList.insert(END, f"{s['last_name']} {s['name']}")
пробуем:
о уже ничего-так, только почему-то обновляется всего один раз, а при попытке последовательно обновить и фамилию и имя падает ошибка.
Тут дело в том, что после того как мы удалили список у него слетает выбранный элемент. По идее после каждого клика на кнопку «обновить» надо тыкать еще и на запись в списке.
Но это не удобно, поэтому надо после перезаполнения списка восстанавливать выбранный элемент. Для этого достаточно добавить одну строчку:
class UI():
def __init__(self, gui):
# ...
def on_student_update_click(self):
item_index = self.studentsList.curselection()[0]
item = self.students[item_index]
item['name'] = self.name.get()
item['last_name'] = self.last_name.get()
item['group'] = self.group.get()
item['patronymic'] = self.patronymic.get()
self.studentsList.delete(0, END)
for s in self.students:
self.studentsList.insert(END, f"{s['last_name']} {s['name']}")
# восстанавливаем выделение строки, которую изменяли
self.studentsList.selection_set(item_index)
проверка:
Ну и напоследок давайте поменяем поведение кнопки сохранить в файл чтобы она сохраняла в файл наш именные список, а то получается мы сейчас данные поменяли, но при следующем запуске они слетят.
Сделаем чтобы она просто сохраняла данные в файл:
class UI():
def __init__(self, gui):
# ...
def on_student_update_click(self):
# ...
def on_student_list_click(self, event):
# ...
def save_to_file(self):
# просто перезаписываем файл
with open("user.json", "w", encoding="utf8") as f:
json.dump(self.students, f, ensure_ascii=False, indent=2)
теперь получается изменяя запись чтобы обновления сохранились в файл надо по идее нажать кнопку сохранить в файл.
Вообще, если так подумать, то какой смысл тыкать две кнопки при попытке обновить запись. Можно просто сделать так чтобы при клике на обновить происходило обновление файла
Для этого можно конечно скопипастить код и save_to_file, но проще просто вызывать эту функцию изнутри on_student_list_click, делается это так:
class UI():
def __init__(self, gui):
# ...
def on_student_update_click(self):
# ...
def on_student_list_click(self, event):
item_index = self.studentsList.curselection()[0]
item = self.students[item_index]
item['name'] = self.name.get()
item['last_name'] = self.last_name.get()
item['group'] = self.group.get()
item['patronymic'] = self.patronymic.get()
self.studentsList.delete(0, END)
for s in self.students:
self.studentsList.insert(END, f"{s['last_name']} {s['name']}")
self.studentsList.selection_set(item_index)
# добавили вызов функции сохранения в файл
self.save_to_file()
def save_to_file(self):
# ...
проверка:
Красота! =)
Попробуем теперь добавить картинку для студента.
Правда сначала нам надо поставить одну дополнительную библиотечку для работы с картинками. Библиотечка — это расширения для питона, которое можно скачать из интернета. Делается это следующим образом.
Сначала открываем папку где установлен питон и запускаем там WinPython Command Prompt
откроется консолька, вводим туда
pip install Pillow
правда в политехе доступ к интернету идет через прокси поэтому там надо ввести
pip install --proxy=http://172.27.100.5:4444 Pillow
и ждем пока пакет скачается, должны увидеть что-то в этом роде
теперь попробуем добавить картинку на форму.
Для вывода картинки используется простой label который мы обычно используем для текста, так вот в него можно передать картинку, корректируем код
class UI():
def __init__(self, gui):
gui.geometry("550x170") # поменял ширину формы на 550
# ...
# добавил лейбл
self.lblImage = Label(borderwidth=1, relief="solid") # чтобы лучше была видна граница картинки добавил рамочку
self.lblImage.place(x=405, y=10, width=130, height=130) # ну и размеры подогнал
получится так:
теперь возьмем какую-нибудь картинку, вот такую, например, (нажать на нее правой кнопкой и выбрать “Сохранить картинку как…”)
и сохраним ее в папку, теперь ее должно быть видно слева
попробуем ее теперь вывести на форму. Делается это в несколько этапов:
from tkinter import *
import json
from PIL import Image, ImageTk # добавляем объекты для работы с изображения из установленного выше пакета
def create_entry(x, y, label_text, entry_width):
# ...
class UI():
def __init__(self, gui):
# ...
self.lblImage = Label(borderwidth=1, relief="solid")
self.lblImage.place(x=405, y=10, width=130, height=130)
# считаем изображение из файла
# вообще сюда надо указать путь к файлу,
# но если файл лежит в той же папке что и файлик с кодом, то достаточно указать имя
image = Image.open("067_160322763013645002.jpg")
# и чтобы убедится, что изображение загрузилось попробуем вывести его размеры в консоль
print(image.size)
запускаем, и глядим в консоль:
ура! размеры определились, значит файл действительно загрузился в память.
Теперь передадим изображение в label. Тут немного хитро:
class UI():
def __init__(self, gui):
# ...
image = Image.open("067_160322763013645002.jpg")
print(image.size)
# создаем обертку для изображения которая нужна чтобы tkinter понял, что ему передали
# в image у нас по сути просто сырые данные, ну а-ля как будто картина по номерам,
# у которой краски отдельно, а на холсте еще никто не рисовал
# а photo_image это типа взяли и уже картинку нарисовали
self.photo_image = ImageTk.PhotoImage(image)
# и теперь этот photo_image надо передать в label, ну по сути картинку поставить в рамочку
self.lblImage.configure(image=self.photo_image)
проверяем:
красота! =)
Общая схема работы с изображением такое:
Image.open("067_160322763013645002.jpg")tkinter через ImageTk.PhotoImage(image)label через self.lblImage.configure(image=self.photo_image)Правда чет изображение какое-то здоровенное…
Вообще это стандартное поведение при выводе изображения, никто за нас его уменьшать не будет.
Сейчас мы по сути мы видим центральную часть изображения в исходном размере:
чтобы изображение уменьшить надо сделать это вручную, делается это между 1 и 2 пунктом
Image.open("067_160322763013645002.jpg")tkinter через ImageTk.PhotoImage(image)label через self.lblImage.configure(image=self.photo_image)всего одной строчкой:
class UI():
def __init__(self, gui):
# ...
# это не трогаем
image = Image.open("067_160322763013645002.jpg")
print(image.size)
# изменяем размеры, первым параметром передаем список из двух элементов [130, 130]
# это размеры по ширине и по длине, они должны совпадать с размером label
# второй параметр Image.ANTIALIAS это алгоритм по которому будут меняться размеры, ANTIALIAS обеспечивает плавный переход цветов пикселей
image.thumbnail([130, 130], Image.ANTIALIAS)
# это тоже не трогаем
self.photo_image = ImageTk.PhotoImage(image)
self.lblImage.configure(image=self.photo_image)
запускаем:
прекрасно! =)
Сделаем теперь чтобы можно было бы кликнуть на изображение, затем открылось окно для выбора файла и можно было бы поменять картинку.
Сначала привяжем реакцию на клик по label. Что-то похожее мы уже делали:
class UI():
def __init__(self, gui):
# ...
self.photo_image = ImageTk.PhotoImage(image)
self.lblImage.configure(image=self.photo_image)
# привязал функцию к клику на label
self.lblImage.bind("<Button>", self.on_lbl_image_click)
def on_lbl_image_click(self, event):
# при клике вывожу сообщение в консоль
print("нажал на картинку")
тестируем:
теперь сделаем так чтобы открывалось диалоговое окно в котором можно выбрать файл. Делается это так:
from tkinter import *
import json
from PIL import Image, ImageTk
import tkinter.filedialog # добавил пакет для работы с диалоговыми окнами
def create_entry(x, y, label_text, entry_width):
# ...
class UI():
def __init__(self, gui):
# ...
def on_lbl_image_click(self, event):
# открываем окно для выбора файла
image_file = tkinter.filedialog.askopenfile(
filetypes = [ # тут указываем фильтры, чтобы по умолчанию позволял только картинки выбирать
("Картинки", "*.jpg;*.jpeg;*.png;*.gif"),
("Все файлы", "*.*")
]
)
# напечатаем путь к файлу который вернет askopenfile
print(image_file.name)
проверяем:
получается, что image_file.name возвращает нам путь к файлу.
В принципе, теперь, чтобы открыть изображение достаточно просто добавить следующие строчки:
class UI():
def __init__(self, gui):
# ...
def on_lbl_image_click(self, event):
# это не трогаем
image_file = tkinter.filedialog.askopenfile(
filetypes = [
("Картинки", "*.jpg;*.png;*.gif"),
("Все файлы", "*.*")
]
)
print(image_file.name)
# грузим файлик в память используя путь в image_file.name
image = Image.open(image_file.name)
# уменьшаем до размеров лейбла
image.thumbnail((130, 130), Image.ANTIALIAS)
# ну и как обычно присваиваем изображение лейблу
self.photo_image = ImageTk.PhotoImage(image)
self.lblImage.configure(image=self.photo_image)
проверяем:
красота! =)