Create a Text Editor in Python
In this tutorial, we will learn how to create a text editor like notepad in Python.
Text Editor is the first most and essential need of a software developer those are willing to write code or simply edit the existing one, working becomes easier due to the different functionality provided to the user, they are customizable according to the user needs. As though the ultimate work of a text editor is to edit files then too, choosing the best editor for programming is a trending topic of all-time in the tech industry, depending upon you can predict the power and importance of text editor in developer’s life.
So in this tutorial, we will be learning how to create a simple text editor using Python Programming Language. In this, we will be using the Tkinter library and two additional modules supported by Tkinter, ‘MessageBox’ and ‘FileDialog’ for providing some additional functionality to our editor.
Introduction to the libraries and modules used
-
– This is one of the most Powerful, Widely Used and Platform Independent library available in Python for creating seamless and nice-looking GUI applications, it is very easy to use and understand different widgets provided by Tkinter. – This module provides the template classes and a variety of inbuilt functions for alerting the user, these message boxes can be an info message, an error message or ask yes/no message.
- FileDialog – This module provides the classes and inbuilt functions for creating file or directory selection windows.
Creating Text Editor Using Python
Before getting started with code we need to install required libraries:
Installation:
Now, comes our Actual Code:
Source Code:
I would suggest you, read the code thoroughly because it is very easy to understand and I have added comments for almost every single line for your better understanding.
Output:
Run the text editor file:
Click on the file menu and select open command:
Select the file you want to open:
Click on open Button:
Now you can enjoy editing your file:
So In this way, you can create a simple text editor using Python and Tkinter library. I hope this tutorial was helpful to you, thank you ‘Keep Learning Keep Coding’.
10 responses to “Create a Text Editor in Python”
Hey, I love the tutorial but you used read mode in askopenfilename that is only meant to read not edit or write to the file content.
HI. How can i change the color of the background window??
I try this:
And is not working.
I like it a lot but if I spell a word wrong, it doesn’t correct me…or even put a red line under it to tell me that it is spelled wrong
Very cool. I used this for a text compression project.
I did make some minor changes, as I needed it to compress the text, and it didn’t handle UTF-8 text well.
The final project is on my GitHub. codeBodger/Text-Compression
very interesting Text editor. how to add a small dictionary to correct a spelling error?
i want add kannada word writing on this text editing , how to do this?
bro,
what does (self.) after every line means here??
Excuse me, mister Sameer, But would you mind if I copied your code, gave you explicit credit, modified the fonts a little bit, and made this into an opensource text editor project? I would really like it if we made an opensource project and it became famous because we very kewl. I thinking about adding a customizable gui and a package manager for code libraries, used for syntax checking.
Создание блокнота с использованием PyQt5 — Python
В этой статье мы увидим, как создать блокнот с помощью PyQt5.
Блокнот — это универсальный текстовый редактор, который позволяет создавать, открывать, редактировать и читать файлы с открытым текстом.
PyQt5 — это кроссплатформенный инструментарий с графическим интерфейсом, набор привязок python для Qt v5. Можно с легкостью разработать интерактивное настольное приложение благодаря инструментам и простоте, предоставляемым этой библиотекой.
Используйте эту команду для установки PyQt5:
GUI Implementation Steps :
1. Create a Vertical layout
2. Create a QPlainTextEdit object and add it to the layout
3. Create a container i.e QWidget object
4. Set this vertical layout to the container
5. Create a status bar to show status tips
6. Create file menu bar and add file actions below is how file menu bar will look like
7. Create an edit menu bar and add various edit action to it, below is how edit menu bar will look like
8. Create two toolbar for file and edit actions, below is how the toolbars will look like
Back End Implementation Steps :
1. Create a path variable and set it to None
2. Add actions to each of the file menu actions these are same of toolbar actions as both share same actions
3. Create a critical method that shows the passed value in the pop up, it is used to show if any error occurs during saving or opening file
4. Create update title method that changes the window title according to the name of the file
5. Inside the file open action, create a try-except block that try to open the file and then update the title and path
6. Inside the save action if path is none call the save as method else save file to the path
7. Inside the save as method save the file at the selected path by user
8. Inside the print action print the file using QPrintDialog object
9. Inside the edit toogle bar action set the line wrap mode of editor according to the checked state
10. Similarly set action for undo, redo, cut, copy, paste and select all using the QPlainTextEdit object built in functions
Как сделать текстовый редактор на python
- Open with Desktop
- View raw
- Copy raw contents Copy raw contents
Copy raw contents
Copy raw contents
Наверное самый лучший способ работы с предлагаемым материалом — изучать код, запускать его на компьютере и затем снова анализировать код. В комментариях разъясняется каждый новый фрагмент кода по мере его расширения. Полный работающий модуль находится в корневой директории. Для просмотра кода перейдите по ссылке, указанных ниже, в данном руководстве.
Первый модуль Python window_01.py создает пустое окно 200×150 с названием «myWindow», расположенное в центре экрана.
С этой строки начинается всякий исполняемый модуль Python [в Linux]. Символ # используется в Python для комментариев, так что интерпретатор строчку проигнорирует. Но в bash, базовом языке сценариев Linux, это не комментарий, и данная строка будет прочитана. В ней содержатся путь к интерпретатору python и указание исполнить код, записанный на Python. Такие инструкции называют «the pound bang» [«Pound» — «фунт» — так часто называют знак «#». «Bang» — сленговое название восклицательного знака «!»], и их ставят в каждой программе на первой строке. Можно забыть, для чего они нужны, но нельзя забывать вставлять их в код.
Данная строка загружает в Python весь модуль Tkinter целиком. В результате у Python появляется библиотека для построения оконного интерфейса.
Tk() — это функция Tkinter, открывающая главное окно любого приложения. Здесь мы создаем экземпляр с именем root. Это общая черта всех классов Tkinter — они должны быть присвоены какой-либо переменной. В следующих двух командах задаются некоторые свойства root, определяющие заголовок и размеры окна. Это другой общий факт — взаимодействие с объектами Tkinter происходит через задание свойств [и вызов методов]. ‘200×150+300+225’ означает [ширина x высота + координата_x_верхнего_левого_угла + координата_y_верхнего_левого_угла].
Наконец, в этой строке происходит вызов метода Tk() под названием mainloop(), который держит окно раскрытым, пока оно не будет закрыто нажатием кнопки [x] на окне или вызовом метода Tk() destroy().
Экземпляры классов — это объекты, обладающие свойствами и методами. Объектно-ориентированные читатели уже знают об этом.
Довольно просто, не так ли? Понадобилось всего шесть строчек кода. Запустите Python; загрузите модуль Tkinter; присвойте какой-либо переменной значение Tk(); затем настройте три метода Tk() для этой переменной. Итак, запускаем window_01.py. Voila! Вы создали окно — фундаментальный элемент любого графического интерфейса пользователя Tkinter.
Создание «дочернего» окна
Следующий модуль Python — window_02.py помещает на экран еще одно пустое «дочернее» окно 200×150. В большинстве графических интерфейсов для организации диалога используют всплывающие окна. «Дочернее» окно исчезает при закрытии основного окна.
Toplevel() — это класс Tkinter, с помощью которого можно создавать любое окно кроме главного. Он также присваивается переменной child. Toplevel(root) означает дочернее окно child, относящееся и зависящее от родительского окна root. Следующие две команды формируют заголовок и размеры дочернего окна аналогично случаю родительского окна. Коду дочернего окна не нужен свой метод mainloop(). Он запускается из родительского окна.
Снова довольно просто. Потребовалось лишь три дополнительные строчки кода. Присвойте Toplevel() новой переменной; свяжите его с корневым окном root с помощью Toplevel(root); затем задайте значения пары свойств Toplevel(root). Наконец, запустите window_02.py. Мы движемся быстро. Мы умеем создавать родительское окно и любое число дочерних окон. Закрытие родительского окна вызывает закрытие и окна дочернего, но не наоборот.
Уже похоже на интерфейс.
Работа с классами
Python — это объектно-ориентированный язык программирования. Tk() и Toplevel() являются классами Tkinter, принимающими форму объектов для создания на экране графических окон. Программирование на Tkinter подразумевает комбинирование и преобразование встроенных классов Tkinter в новые классы с индивидуальными свойствами и методами.
Следующей задачей данного руководства будет воспроизведение визуального эффекта, достигнутого в последнем примере window_02.py, объектно-ориентированными средствами, заложенными в Python, т.е. путем создания классов. Приведенный выше код объявляет и определяет класс. Объект — это экземпляр класса. В данном случае мы собираемся создать простые классы родительских и дочерних окон. Позже мы будем формировать классы с их собственными (добавленными) свойствами и методами. Модуль, который рассматривается в этой части руководства, находится по ссылке window_03.py.
Вот обобщенная форма для создания классов. Замечание: отступы обязательны!
Здесь указывается, что будет создан класс с именем имя-класса со следующими определениями [def]. Команду __init__(self) проще показать в действии, чем объяснить. __init__() — это конструктор объектов, позволяющий создавать экземпляр объекта во время исполнения программы. self — это метка экземпляра, необходимая для привязки переменных класса к данному объекту. Таким образом инструкция self.master = root создает переменную master и присваивает ей глобальное значение root [пока еще не определенное]. В оставшейся части кода вы увидите, как теперь определяется то же самое окно внутри класса main. Итак, что же такое child()?
child() — это вызов другого класса, определенного в модуле. Так класс main генерирует экземпляр дочернего окна.
При запуске модуля на выполнение происходит вызов Python, загрузка Tkinter и сохранение определений классов main и child. Команды, приведенные выше, сначала задают значение переменной root, чтобы создать экземпляр Tk(), затем открывают окно, активируя main [который, в свою очередь, активирует child]. Обратите внимание, что mainloop() расположен «внутри» класса main. Запустите window_03.py. Он должен сделать то же самое, что и предыдущий пример.
Если этот пример — ваша первая встреча с классами, объектами и т.п., в голову вполне может прийти мысль: «К чему такие сложности?» Но стоит нам перейти к более сложным примерам, как тотчас станет очевидно, что инкапсуляция кода внутрь классов — это отличный способ писать лаконичные, пригодные для многократного использования программы на Python. Потерпите немного. Некоторые из нас помнят, как учились составлять «макаронные» программы [‘spaghetti’ coding — слабо структурированные программы с большим размером процедур и интенсивным использованием оператора goto; трудны для изучения и модификаций], а потом изучали «структурное» программирование. Так что «объектно-ориентированное» программирование — это еще одна новинка.
Классы и элементы управления
Запустите следующий модуль, что б ознакомится с элементами управления window_04.py.
Оставим на время разработку дочернего окна, чтобы сосредоточить все внимание на классах. Рассмотрим, как передавать классу информацию, и добавим к классу элемент управления [в данном случае кнопку (Button)], [и объект и окно].
В последнем примере window_03.py вас, возможно, удивило, что класс main содержит ссылку на переменную root, которая в программе еще не создана. Я сделал это специально, чтобы продемонстрировать, что классы ничего не делают, пока на их базе не будут созданы экземпляры объектов. Но есть лучший путь достичь того же самого. Объекту можно передать глобальную переменную root, и именно так сделано в нашем коде. Благодаря вызову main(root) параметр root передается переменной master класса main. В последующих примерах подобным же образом мы будем передавать классам множество различных параметров.
Ну, наконец и элемент управления. В Tkinter имеется определенное число графических элементов управления, которые можно размещать в нашем окне. В данном случае это будет кнопка (Button). Мы уже пользовались двумя элементами управления — Tk() и Toplevel(). Код self.button = Button(self.master, text = ‘myButton’) связывает элемент управления Button() с классом main [все элементы управления кроме Tk() кому-нибудь «принадлежат»], а text = ‘myButton’ задает значение свойства text [текст, который отобразится на кнопке во время исполнения программы]. Строка self.button.pack(side = BOTTOM) определяет, в какой части окна появится наша кнопка. Позже мы рассмотрим pack подробнее.
Между прочим, эта кнопка пока ничего не делает. Итак, запускаем window_04.py и нажимаем бесполезную кнопку.
Любая кнопка должна что-нибудь делать. В данном случае мы свяжем событие «нажатие кнопки» с открытием дочернего окна из одного из прошлых примеров. Для этого в класс main вводится метод openDialog, который создает экземпляр объекта child.
Для определения метода openDialog не нужна функция __init__(). Не создается экземпляра метода, — но метод создает экземпляр объекта child. Метод — это то, что класс main делает, а не то, чем класс main является.
Обращение к openDialog содержит вездесущее self. Это означает, что метод openDialog является внутренним по отношению к main.
Toplevel() из класса child узнает о том, что относится к дочернему классу класса main, довольно мучительным путем. Tk(), связанный с root, передается классу main через параметр master [в main], а затем пересылается другому параметру master [в child]. Всякий класс имеет свою переменную master, локальную по отношению к данному классу. Их имена могут быть различными. Ага! Метод. Запускаем window_05.py и испытываем работающую кнопку.
Модальное дочернее окно
В некоторых программах требуется для вывода информации создать дочернее окно, продолжая в тоже время использовать главное. При этом часто бывает нужно, чтобы все процессы, происходящие в дочернем окне, завершились до того, как вы продолжите работу. Такое окно называют модальным. Это значит, что оно будет удерживать фокус пока не будет закрыто. В Python дочернее окно можно превратить в модальное с помощью трех методов Toplevel():
child перехватывает все события, происходящие в приложении.
child захватывает фокус.
child ждет, когда будет уничтожен текущий объект, не возобновляя работы [но и не оказывая влияния на основной цикл].
Итак, рецепт. Если нужно создать модальное окно, воспользуйтесь этими тремя методами. Как говорится, «Просто сделай это!» window_06.py
Отсылка сообщения от родительского элемента к дочернему
Модальные дочерние окна используются, главным образом, в роли диалоговых окон. Нам нужен способ передачи информации от родительского окна к дочернему и наоборот. Сперва пойдем от main к child. В данный пример внесено три добавления по сравнению с предыдущими: Поле для ввода текста в классе main. Текстовое окно в классе child для отображения введенной информации. Механизм передачи информации от текстового окна в main текстовому окну в child.
Стоит создать один элемент управления, как все остальное становится ясно. Единственно стоит отметить, что элемент управления text имеет свойство background (фон) со значением ‘white’ (белый) и что пришло время поговорить о pack. Метод pack() размещает в окне элемент управления. Итак: side (сторона) определяет, какой стороны окна будет «держаться» элемент управления варианты: TOP (сверху) RIGHT (справа) LEFT (слева) BOTTOM (снизу) по умолчанию: NONE (никак) fill (заполнение) показывает, заполнит элемент доступное пространство или нет. варианты: X Y BOTH (X Y оба) по умолчанию: NONE (никак) expand (растяжение) указывает, будет ли элемент управления менять свой размер при изменении размеров окна. варианты: YES (да) по умолчанию: 0
В метод openDialog() мы ввели инструкцию self.text.get(‘0.0’, END), которая является методом элемента управления Text. Она собирает все содержимое текстового окна от строки 0 символа 0 и до конца, чтобы передать его классу/окну child [как myText].
Как работает текстовый элемент управления child интуитивно ясно. Он заполняется текстом из главного окна посредством def __init__(self, master, myText = »). Информация из myText вставляется в элемент управления text с помощью метода self.text.insert(‘0.0’, myText), который помещает ее, начиная со строки 0 символа 0. Испытайте window_07.py, напечатав в нем какой-нибудь текст и отослав его.
Общение — хорошая штука, но оно должно быть улицей с двухсторонним движением.
Отсылка сообщений в обоих направлениях
Сначала посмотрите на код window_08.py.
Мы хотим, чтобы информация шла от родительского окна к дочернему И от дочернего к родительскому. Последнего можно добиться, добавив к дочернему окну кнопку accept и метод для регистрации всех изменений, произведенных в передаваемом тексте; также введем метод go как для создания экземпляра дочернего окна, так и для управления процессом обмена информацией. Такое применение методов [go] для открытия дочерних окон — полезный инстру. мент, который приобретет особую важность, когда мы будем иметь дело с более сложными операциями в последующих руководствах. Сейчас же он создает пустую переменную newValue, в которую будет записан измененный текст [если он был изменен].
При вызове дочернего метода go введенный текст вставляется в дочернее текстовое окно. Если текст редактировался и пользователь нажимает кнопку accept, исправленный текст возвращается как newValue. Если дочернее окно просто закрывается, newValue возвращается с пустым значением.
При возврате метод openDialog класса main осуществляет проверку. Если возвращаемая строка не пустая, возвращаемый текст будет вставлен в текстовое окно main.
Запускаем window_08.py. Убедитесь, что вы «уловили», как работает go. Нам придется еще довольно много иметь дело с этим методом.
Мы приближаемся к концу начала. Рассмотрим еще несколько приемов, которые будут использоваться позднее в «реальном» приложении: кнопки принятия (accept) и отмены (cancel), а также «перехват» закрытия основного окна с соответствующим диалогом.
Пока все просто. Размещение в дочерних диалоговых окнах кнопки отмены (cancel) — довольно стандартный прием. При этом происходит уничтожение дочернего окна без изменения newValue.
«Перехват» закрытия пользователем главного окна немного сложнее. Для чего это может потребоваться? Допустим, в случае текстового редактора нам бы хотелось фиксировать ситуации, когда не был сохранен измененный файл, чтобы предохранить пользователя от нечаянного уничтожения плодов всех его усилий из-за преждевременного закрытия окна.
Секрет спрятался в строке self.master.protocol(‘WM_DELETE_WINDOW’, self.exitMethod). WM_DELETE_WINDOW — это часть оконного протокола, которая обычно бывает связана с self.destroy(). Но в данной строке вместо этого она связывается с одним из разработанных нами методов. Итак, взгляните на def exitMethod(self): здесь вызывается message и выход происходит, только если message (сообщение) равно TRUE (ИСТИНА). message управляется целым новым классом yesno, обладающим своим собственным методом go [Я предупреждал, что go еще пригодится.].
Запустите window_09.py, чтобы увидеть нашу программу в действии.
Наша программа растет. У нас получается. И что еще более важно, ее части возможно использовать повторно. Класс yesno может быть применен еще раз в этом же приложении или даже в будущих приложениях. Итак, в коде, приводимом ниже, мы разбиваем программу на три отдельных модуля, которые будут храниться в трех отдельных автономных файлах. Основной файл myWindow.py использует классы dialog и yesno так же, как и раньше, но, вместо того чтобы включить их в код, они импортируются из других файлов — myDialog.py и myBoolean.py.
Просмотрите завершающие части файлов myDialog.py и myBoolean.py. Там есть тестовая команда. Включать подобную команду в конец любого файла, который не выполняется напрямую, — стандартное правило. С помощью оператора if __name__ == ‘__main__’: она проверяет, запущен файл из другой программы или сам по себе. В последнем случае открывается пустое окно, которое затем убирается с экрана командой root.withdraw(). Но именно к этому фиктивному окну привязывается рабочий код, позволяющий запускать данный файл. Это очень полезный инструмент для отладки. Использование тестов приводит к тому, что все модули становятся «исполняемыми».
Итак, запустим все три файла — myWindow.py, myDialog.py, myBoolean.py — и посмотрим, что произойдет.
Мини-руководство по Tkinter
Программа, которую мы составили, не сильно впечатляет — что-то вроде импровизации на тему «Hello World!». Предыдущая страница была названа «святым граалем» по двум причинам. Прежде всего, Python никак не связан со змеей. Это название взято из известного сериала Monty Python and the Quest for the Holy Grail. Кроме того, в легенде о Граале рассказывается о том, как нечто искали повсюду, и, когда, наконец, оно было найдено, оказалось, что ищущий обладал им с самого начала. Это учебное руководство было написано пять или шесть лет тому назад. Тогда оно не было опубликовано, поскольку я посчитал его слишком примитивным. Позднее это руководство выручило меня самого, облегчив вспоминание Tkinter. Сейчас я сознаю, что оно уже содержало все необходимые идеи, чтобы начать использовать Tkinter для интересующих меня задач. Если вы похожи на меня, то будете применять Python для написания различных утилит, которые часто бывают полезны в повседневной жизни. Это превосходный язык для таких целей [а Tkinter — почти совершенный GUI]. Но для создания коммерческих мегапрограмм, чтобы заработать много денег, ни Python, ни Tkinter не годятся. [Как, впрочем, и само программирование в целом. Лучше идите учиться на менеджера!].
Перечислим элементы управления, с которыми мы уже успели познакомиться, вместе с их свойствами и методами, использованными в примерах. Общий стиль Tkinter — это размещение свойств внутри круглых скобок: Имя_класса(свойство1 = значение1, свойство2 = значение2) и использование методов в роли особых «точечных» команд: Имя_класса.метод(параметры)