Possibly misspelt word python что это

Обновлено: 04.07.2024

Я работаю над програвком для текстового виджета Tkinter. У меня он работает, чтобы пользователь мог выбрать неверное слово и заменить все экземпляры неверного слова в текстовый виджет. Однако, если слово появляется внутри другое слово, он также заменит его. Я не хочу этого.

Например: Скажем, у пользователя есть предложение: Hello how ay you today И они пропустили написанные слова « 'AS' AY ', они могли щелкнуть правой кнопкой мыши на нем, чтобы заменить все экземпляры или слово« AY ' появляется в « '. Это означает, что когда пользователь щелчна щелчникам « AY », он превращается в « сегодня » в ' todare ' - замена " AY 'IN' сегодня "с ' '

Чтобы заменить слово, которое я использую функцию поиска. Я подумал о проверке, если персонажи по обе стороны от прошедшего слова были пробелами, но я не знал, как это реализовать. Вот мой код ниже (ПРИМЕЧАНИЕ - это значительно упрощено, и мой фактический код длинна длиной тысячи строк. В реальной программе кнопка - это контекстное меню):

Как я уже сказал, если пользователь пишет ll ll hello , где ' ll ' пропускает написанный (давайте скажем, программа исправлена ее, я), когда пользователь нажимает кнопку Следует заменить все слова " ll ', но не замените" ll "в Hello '.

Это: ll ll hello - & gt; I'll I'll hello , не: ll ll hello - & gt; I'll I'll heI'llo

Спасибо за вашу помощь.

(Я использую Windows 10 с Python 3.7)

1 ответ

Решение вашей проблемы состоит в том, чтобы использовать Регулярные выражения. Регулярные выражения позволяют найти больше, чем просто текст. Вы также можете искать шаблоны и другие метасимволы. Например, выражение может соответствовать только строке в начале строки или начала слова.

В вашем случае вы хотите найти целые слова. В контексте Widget Text search метод, целое слово можно искать, на окружении строки, которую вы ищете с \m (запуск Word) и \M (конец слово).

Например, чтобы найти «LL» только в целом слово, вы должны искать \mll\M . Поскольку обратная косание является специальным символом в Python, и нам нужна обратная косание для передачи на метод search , его необходимо защитить. Самый простой способ - использовать сырую строку.

Итак, дано слово в переменной (например,: word="ll" ), мы можем сделать шаблон, который выглядит так:

Другая вещь, которую нам нужно сделать, это убедиться, что поиск останавливается в конце виджета, в противном случае он будет обернуть к началу и продолжать поиск навсегда.

Как только у нас все это на месте, мы можем искать строку «LL» в текстовом виджете только в виде целых слов с чем-то вроде этого:

При этом pos отмечает начало совпадения и pos_end отмечает конец совпадения. Если pos - пустая строка, то мы знаем, что TKinter не нашел совпадение (и в этом случае мы можем пропустить вычисления pos_end ).

Сделав все вместе, мы можем создать функцию общего назначения, которая находит и подчеркивает все слова в списке с чем-то вроде этого:

Мы можем использовать эту функцию следующим образом:

Регулярные выражения, используемые в текстовом виджете search метода, немного отличаются от регулярных выражений Python. Например, Python использует \b , чтобы означать начало или конец слова, тогда как метод < search использует \m и \M . Для подробного объяснения синтаксиса экспрессии, используемого методом < search , см. TCL's re_syntax человек страница

Документ РЕР8 содержит детализированные правила написания кода на Python. По мере развития языка этот документ постоянно обновляется. Было бы неплохо, если бы вы прочитали целиком все руководство

Ниже приведены некоторые правила, которых следует обязательно придерживаться.

Пробелы

В языке Python пробелы имеют синтаксическое значение. Особое значение Pythоn-программисты придают влиянию пробелов на удобочитаемость кода.

Используйте пробелы, а не символы табуляции для создания отступов.
Используйте по 4 пробела для каждого уровня синтаксически значимых отступов.
Длина строк не должна превышать 79 символов.
Дополнительные строки, являющиеся продолжением длинных выражений, должны выделяться четырьмя дополнительными пробелами сверх обычного их количества для отступов данного уровня.
Между определениями функций и классов в файлах следует вставлять две пустые строки.
Между определениями методов в классах следует вставлять одну пустую строку.
Не окружайте пробелами индексы элементов списков вызовы функций и операторы присваивания значений именованным аргументам.
Помещайте по одному и только одному пробелу до и после оператора присваивания.

Имена

В документе РЕР8 для различных элементов языка предлагается свой стиль имен. Благодаря этому можно легко определить в процессе чтения кода, какому типу соответствует то или иное имя:

Имена функций, переменных и атрибутов должны следовать формату lowercase_underscore (нижний регистр букв, разделение слов символами подчеркивания) .
Имена защищенных атрибутов экземпляра должны следовать _leading_underscore (один символ подчеркивания в начале).
Имена закрытых атрибутов экземпляра должны следовать формату __leading_underscore (два символа подчеркивания в начале).
Имена классов и исключений должны следовать формату CapitalizeWord (каждое слово начинается с прописной буквы).
Константы уровня модуля должны записываться в формате ALL_CAPS (все буквы прописные, в качестве разделителя используется символ подчеркивания).
В определениях методов экземпляров классов в качестве имени первого параметра следует всегда указывать self (это имя ссылается на текущий объект).
В определениях методов классов в качестве имени первого параметра следует всегда указывать cls (это имя ссылается на текущий класс).

Выражения и инструкции

В каждом подразделе модули должны располагаться в алфавитном порядке.

Что следует запомнить

Всегда следуйте рекомендациям по оформлению кода Python, изложенным в документе РЕР 8.
Использование общего с многочисленными членами Руthоn-сообщества стиля оформления кода облегчает коллективную разработку.
Использование единообразного стиля упрощает изменение кода впоследствии.

Если вы спросите программистов Python, что им больше всего нравится в Python, они часто будут ссылаться на его высокую читабельность. Действительно, высокий уровень читабельности лежит в основе дизайна языка Python, следуя общепризнанному факту, что код читается гораздо чаще, чем пишется.

Одной из причин высокой читабельности кода Python является его полный набор рекомендаций PEP8 по стилю кода и «Pythonic» идиом.

Когда ветеран Python-разработчик (Pythonista) называет части кода не «Pythonic», они обычно означают, что эти строки кода не следуют общим правилам и не выражают свое намерение в том, что считается лучшим (слушайте: наиболее читаемый) путь.

В некоторых случаях не было достигнуто соглашения о том, как выразить намерение в коде Python, но такие случаи редки.

Явный код

Хотя в Python возможен любой вид черной магии, наиболее явный и простой способ предпочтителен.

Плохо

Хорошо

В приведенном выше хорошем коде x и y явно принимаются от вызывающей стороны, и возвращается явный словарь. Разработчик, использующий эту функцию, точно знает, что делать, читая первые и последние строки, что не так с плохим примером.

Одно утверждение на строку

Несмотря на то, что некоторые составные операторы, такие как списочные выражения, допускаются и ценятся за их краткость и выразительность, использование двух разделенных операторов в одной строке кода является плохой практикой.

Плохо

Хорошо

Аргументы функции

Аргументы могут быть переданы в функции четырьмя различными способами.

Позиционные аргументы являются обязательными и не имеют значений по умолчанию. Они являются простейшей формой аргументов и могут использоваться для нескольких аргументов функции, которые полностью являются частью значения функции, и их порядок является естественным. Например, пользователь или пользователь функции без труда помнит, что эти две функции требуют двух аргументов и в каком порядке. send(message, recipient) point(x, y)

В этих двух случаях, можно использовать имена аргументов при вызове функции и, делая это, можно изменить порядок аргументов, вызывая, например , и , но это снижает читаемость и излишне многословные, по сравнению с более простыми вызовами к и . send(recipient='World', message='Hello') point(y=2, x=1) send('Hello', 'World') point(1, 2)

Аргументы ключевых слов не являются обязательными и имеют значения по умолчанию. Они часто используются для необязательных параметров, отправляемых в функцию. Когда функция имеет более двух или трех позиционных параметров, ее сигнатуру труднее запомнить, и полезно использовать аргументы ключевых слов со значениями по умолчанию. Например, более полная send функция может быть определена как . Здесь и не являются обязательными, и оценивают, когда им не передается другое значение. send(message, to, cc=None, bcc=None) cc bcc None

В качестве примечания, следуя принципу YAGNI , зачастую сложнее удалить необязательный аргумент (и его логику внутри функции), который был добавлен «на всякий случай» и, по-видимому, никогда не используется, чем добавить новый необязательный аргумент и его логика, когда это необходимо.

Однако эта конструкция имеет некоторые недостатки и должна использоваться с осторожностью. Если функция получает список аргументов одинаковой природы, часто более понятно определить ее как функцию одного аргумента, причем этот аргумент является списком или любой последовательностью. Здесь, если send есть несколько получателей, лучше определить это явно: и вызвать его с помощью . Таким образом, пользователь функции может заранее манипулировать списком получателей как списком, и это открывает возможность для передачи любой последовательности, включая итераторы, которая не может быть распакована как другие последовательности. send(message, recipients) send('Hello', ['God', 'Mom', 'Cthulhu'])

Произвольный ключевой слово словарь аргумента является последним способом передать аргументы функции. Если функции требуется неопределенная серия именованных аргументов, можно использовать **kwargs конструкцию. В теле функции kwargs будет словарь всех переданных именованных аргументов, которые не были перехвачены другими ключевыми аргументами в сигнатуре функции.

Необходима та же осторожность, что и в случае списка произвольных аргументов , по аналогичным причинам: эти мощные методы должны использоваться, когда существует явная необходимость их использования, и их не следует использовать, если более простая и понятная конструкция достаточна для выразить намерение функции.

легко читается (имя и аргументы не нуждаются в объяснениях)
легко изменить (добавление нового ключевого аргумента не нарушает другие части кода)

Избегайте волшебной палочки

Мощный инструмент для хакеров, Python поставляется с очень богатым набором хуков и инструментов, позволяющих вам выполнять практически любые хитрые трюки. Например, можно выполнить каждое из следующих действий:

изменить способ создания и создания объектов
изменить способ импорта модулей интерпретатором Python
Можно даже (и рекомендуется при необходимости) встроить подпрограммы C в Python.

Тем не менее, все эти варианты имеют много недостатков, и всегда лучше использовать самый простой способ для достижения вашей цели. Основным недостатком является то, что читаемость сильно страдает при использовании этих конструкций. Многие инструменты анализа кода, такие как pylint или pyflakes, не смогут проанализировать этот «волшебный» код.

Мы считаем, что разработчик Python должен знать об этих почти безграничных возможностях, потому что это вселяет уверенность в том, что на пути не будет непроходимых проблем. Однако очень важно знать, как и, в частности, когда их не использовать.

Подобно мастеру кунг-фу, питонист знает, как убивать одним пальцем, и никогда не делать этого на самом деле.

Мы все ответственные пользователи

Как видно выше, Python допускает множество трюков, и некоторые из них потенциально опасны. Хорошим примером является то, что любой клиентский код может переопределять свойства и методы объекта: в Python нет ключевого слова «private». Эта философия, очень отличающаяся от языков с высокой степенью защиты, таких как Java, которые предоставляют множество механизмов для предотвращения любого неправильного использования, выражается высказыванием: «Мы все ответственные пользователи».

Это не означает, что, например, никакие свойства не считаются закрытыми и что правильная инкапсуляция невозможна в Python. Скорее, вместо того, чтобы полагаться на бетонные стены, возводимые разработчиками между их кодом и чужим, сообщество Python предпочитает полагаться на ряд соглашений, указывающих, что к этим элементам не следует обращаться напрямую.

Основное соглашение для частных свойств и деталей реализации заключается в добавлении префикса ко всем «внутренним элементам». Если клиентский код нарушает это правило и получает доступ к этим отмеченным элементам, любое неправильное поведение или проблемы, возникшие при изменении кода, являются ответственностью клиентского кода.

Использование этого соглашения приветствуется: любой метод или свойство, которые не предназначены для использования клиентским кодом, должны начинаться с подчеркивания. Это гарантирует лучшее разделение обязанностей и более легкую модификацию существующего кода; всегда будет возможно обнародовать частную собственность, но сделать публичную собственность частной может быть гораздо более сложной операцией.

Возвращение значения

Когда функция усложняется, нередко используют несколько операторов return внутри тела функции. Однако, чтобы сохранить четкое намерение и устойчивый уровень читабельности, желательно избегать возврата значимых значений из многих выходных точек в теле.

Существует два основных случая возврата значений в функцию: результат возврата функции, когда она была обработана нормально, и случаи ошибок, которые указывают на неправильный входной параметр, или любую другую причину, по которой функция не может завершить вычисление или задача.

Если вы не хотите вызывать исключения для второго случая, может потребоваться возврат значения, такого как None или False, указывающего, что функция не может работать правильно. В этом случае лучше вернуться, как только был обнаружен неправильный контекст. Это поможет сгладить структуру функции: весь код после оператора return-from-of-error может предполагать, что условие выполнено для дальнейшего вычисления основного результата функции. Наличие нескольких таких операторов возврата часто необходимо.

Однако, когда функция имеет несколько основных точек выхода для своего нормального хода, становится трудно отлаживать возвращаемый результат, поэтому может быть предпочтительнее сохранить одну точку выхода. Это также поможет выделить некоторые пути кода, а несколько точек выхода являются вероятным признаком того, что такой рефакторинг необходим.

Идиомы

Идиоматический код Python часто называют Pythonic .

Ниже приведены некоторые распространенные идиомы Python:

Распаковка

Если вы знаете длину списка или кортежа, вы можете назначить имена его элементам при распаковке. Например, поскольку enumerate() будет предоставлять кортеж из двух элементов для каждого элемента в списке:

Вы также можете использовать это для замены переменных:

Вложенная распаковка тоже работает:

В Python 3 новый метод расширенной распаковки был представлен PEP3132 :

Создать игнорируемую переменную

Если вам нужно что-то назначить (например, в распаковке ), но вам не понадобится эта переменная, используйте __ :

Заметка

Многие руководства по стилю Python рекомендуют использовать одно подчеркивание « _ » для одноразовых переменных, а не двойное подчеркивание « __ », рекомендованное здесь.Проблема заключается в том, что « _ » обычно используется в качестве псевдонима для gettext() функции, а также в интерактивном приглашении для хранения значения последней операции.Вместо этого использование двойного подчеркивания является столь же понятным и почти таким же удобным, и исключает риск случайного вмешательства в любой из этих других случаев использования.

Создайте список длины N того же самого

Используйте * оператор списка Python :

Создание списка длины N списков

Поскольку списки являются изменяемыми, * оператор (как указано выше) создаст список из N ссылок на один и тот же список, что вряд ли вам нужно. Вместо этого используйте понимание списка:

Примечание: используйте range () вместо xrange () в Python 3.

Создать строку из списка

Это установит значение переменной word в «spam». Эта идиома может применяться к спискам и кортежам.

Поиск предмета в коллекции

Иногда нам нужно искать в коллекции вещей. Давайте рассмотрим два варианта: списки и наборы.

Возьмите следующий код для примера:

Хотя обе функции выглядят одинаково, поскольку lookup_set использует тот факт, что наборы в Python являются хеш-таблицами, производительность поиска между ними очень различна. Чтобы определить, есть ли элемент в списке, Python должен будет просмотреть каждый элемент, пока не найдет соответствующий элемент. Это отнимает много времени, особенно для длинных списков. В наборе, с другой стороны, хеш элемента сообщит Python, где в наборе искать соответствующий элемент. В результате поиск может быть выполнен быстро, даже если набор большой. Поиск в словарях работает так же. Для получения дополнительной информации см. Эту страницу StackOverflow . Для получения подробной информации о времени, которое различные общие операции выполняют для каждой из этих структур данных, см. Эту страницу .

Из-за этих различий в производительности часто рекомендуется использовать наборы или словари вместо списков в случаях, когда:

Коллекция будет содержать большое количество предметов
Вы будете неоднократно искать предметы в коллекции
У вас нет дубликатов.

Для небольших коллекций или коллекций, в которых вы не часто будете искать, дополнительное время и память, необходимые для настройки хэш-таблицы, часто будут больше, чем время, сэкономленное благодаря улучшенной скорости поиска.

Дзен питона

Также известен как PEP 20 , руководящие принципы для дизайна Python.

Некоторые примеры хорошего стиля Python см. На этих слайдах из группы пользователей Python .

Соглашения PEP8

Вот некоторые соглашения, которым вы должны следовать, чтобы сделать ваш код легче для чтения.

Проверьте, равна ли переменная постоянной

Плохо :

Хорошо :

Доступ к элементу словаря

Не используйте dict.has_key() метод. Вместо этого используйте синтаксис или передайте аргумент по умолчанию для . x in d dict.get()

Плохо :

Хорошо :

Короткие способы манипулирования списками

Постижения списков предоставляют мощный и лаконичный способ работы со списками.

Выражения генератора следуют почти тому же синтаксису, что и списки, но возвращают генератор вместо списка.

Создание нового списка требует больше работы и использует больше памяти. Если вы просто собираетесь пройтись по новому списку, используйте вместо этого итератор.

Плохо :

Хорошо :

Используйте списки, когда вам действительно нужно создать второй список, например, если вам нужно использовать результат несколько раз.

Если ваша логика слишком сложна для понимания короткого списка или выражения генератора, рассмотрите возможность использования функции генератора вместо возврата списка.

Хорошо :

Никогда не используйте списочное понимание только для его побочных эффектов.

Плохо :

Хорошо :

Фильтрация списка

Плохо :

Никогда не удаляйте элементы из списка, пока вы просматриваете его.

Не делайте несколько проходов по списку.

Хорошо :

Используйте понимание списка или выражение генератора.

Возможные побочные эффекты изменения исходного списка

Изменение исходного списка может быть рискованным, если на него ссылаются другие переменные. Но вы можете использовать назначение срезов, если вы действительно хотите это сделать.

Изменение значений в списке

Плохо :

Помните, что назначение никогда не создает новый объект. Если две или более переменных ссылаются на один и тот же список, изменение одной из них изменит их все.

Хорошо :

Безопаснее создать новый объект списка и оставить оригинал в покое.

Используйте enumerate() счетчик вашего места в списке.

enumerate() Функция имеет лучшую читаемость , чем обработка счетчика вручную. Более того, он лучше оптимизирован для итераторов.

Читать из файла

Используйте синтаксис для чтения из файлов. Это автоматически закроет файлы для вас. with open

Плохо :

Хорошо :

Это with утверждение лучше, потому что оно гарантирует, что вы всегда закроете файл, даже если внутри with блока возникнет исключение .

Продолжение строки

Когда логическая строка кода длиннее допустимого предела, вам необходимо разбить ее на несколько физических строк. Интерпретатор Python объединяет последовательные строки, если последний символ строки является обратной косой чертой. Это полезно в некоторых случаях, но, как правило, его следует избегать из-за его хрупкости: пробел, добавленный в конец строки после обратной косой черты, нарушит код и может привести к неожиданным результатам.

Плохо :

Хорошо :

Однако чаще всего разделение длинной логической строки является признаком того, что вы пытаетесь сделать слишком много вещей одновременно, что может ухудшить читабельность.

Читайте также: