Python как определить язык текста

Определение языка текста

Есть текст. Нужно определить язык этого текста: русский или украинский. Использовал api от яндекс переводчика, но там стоит лимит на один миллион символов в день. 1М это мало. Может кто то знает какие то библиотеки на python3? upd: мне хотя бы узнать, является ли текст украинским.

Отслеживать
12.5k 7 7 золотых знаков 19 19 серебряных знаков 48 48 бронзовых знаков
задан 23 янв 2017 в 20:34
1,066 2 2 золотых знака 15 15 серебряных знаков 32 32 бронзовых знака

Возможно вот эта библиотека подойдет: github.com/CLD2Owners/cld2 , и пример как заставить работать с Python: github.com/mikemccand/chromium-compact-language-detector

23 янв 2017 в 20:57

2 ответа 2

Сортировка: Сброс на вариант по умолчанию

In [65]: from langdetect import detect In [66]: %paste detect('"Зоряні війни" офіційно оголосили назву нового епізоду') ## -- End pasted text -- Out[66]: 'uk' In [67]: %paste detect('Дональд Трамп подписал указ об официальном выходе США из Транстихоокеанского партнерства') ## -- End pasted text -- Out[67]: 'ru'

Если нужно сделать оценку:

In [78]: from langdetect import detect_langs In [79]: %paste detect_langs('Спробуй вгадати який це "язык"') ## -- End pasted text -- Out[79]: [ru:0.7142865675080949, uk:0.28571330147081586] In [80]: %paste detect_langs('Ты говоришь на "мові"') ## -- End pasted text -- Out[80]: [uk:0.9999979837984605]

Отслеживать
ответ дан 23 янв 2017 в 21:25
MaxU — stand with Ukraine MaxU — stand with Ukraine
149k 12 12 золотых знаков 59 59 серебряных знаков 132 132 бронзовых знака

Самый простой и быстрый вариант использовать cld2-cffi:

pip3 install cld2-cffi

import cld2 # текст на Русском details = cld2.detect("Это мой образец текста") print(str(details)) # Вывод: # Detections(is_reliable=True, bytes_found=43, details=(Detection(language_name='RUSSIAN', language_code='ru', percent=97, score=658.0), Detection(language_name='Unknown', language_code='un', percent=0, score=0.0), Detection(language_name='Unknown', language_code='un', percent=0, score=0.0))) # текст на Украинском details = cld2.detect("Це мій зразок тексту") # Вывод: # Detections(is_reliable=True, bytes_found=39, details=(Detection(language_name='UKRAINIAN', language_code='uk', percent=97, score=862.0), Detection(language_name='Unknown', language_code='un', percent=0, score=0.0), Detection(language_name='Unknown', language_code='un', percent=0, score=0.0)))

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

У нас в компании YouScan в день обрабатывается около 100 млн. сообщений, на которых применяется много правил и разных смарт-функций. Для корректной их работы нужно правильно определить язык, потому что не все функции можно сделать агностическими относительно языка. В данной статье мы коротко расскажем про наше исследование данной задачи и покажем оценку качества на датасете из соц. сетей.

План статьи

Проблемы определения языка
Доступные публичные решения
- Compact Language Detector 2
- FastText
Оценка качества
Выводы

1. Проблемы определения языка

Определение языка достаточно старая проблема и многие ее пытаются решать в рамках мультиязычности своих продуктов. Более старые подходы используют решения основанные на н-граммах, когда считается к-во вхождений определенной н-граммы и на основе этого рассчитывается «скор» для каждого языка, после чего выбирается наиболее вероятный язык по нашей модели. Главный недостаток данных моделей в том, что абсолютно не учитывается контекст, поэтому определение языка для схожих языковых групп затрудняется. Но из-за простоты моделей мы получаем в итоге высокую скорость определения, что позволяет экономить ресурсы для высоконагруженных систем. Другой вариант, более современный, – решение на рекуррентных нейронных сетях. Данное решение уже строится не только на н-граммах, а и учитывает контекст, что должно дать прирост в качестве работы.

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

2. Доступные публичные решения

Compact Language Detector 2

CLD2 – это вероятностная модель на основе машинного обучения (Наивный Баессовский классификатор), которая может определять 83 различных языка для текста в формате UTF-8 или html/xml. Для смешанных языков модель возвращает топ-3 языка, где вероятность расчитывается как приблизительный процент текста от общего числа байт. Если модель не уверена в своем ответе, то возвращает тег «unc».

Точность и полнота данной модели на достаточно хорошем уровне, но главное преимущество – это скорость. Создатели заявляют про 30кб в 1ms, на наших тестах питоновской обертки мы получили от 21 до 26кб в 1ms (70000-85000 сообщений в секунду, средний размер которых 0.8кб, а медиана – 0.3кб).

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

Чтобы сделать прогноз, достаточно просто импортировать библиотеку pycld2 и написать одну дополнительную строчку кода:

Определение языка с помощью cld2

import pycld2 as cld2 cld2.detect("Bonjour, Habr!") # (True, # 14, # (('FRENCH', 'fr', 92, 1102.0), # ('Unknown', 'un', 0, 0.0), # ('Unknown', 'un', 0, 0.0)))

Ответ детектора – это tuple из трех элементов:

определился язык или нет;
к-во символов;
tuple из трех наиболее вероятных языков, где на первом месте идет полное название,
на втором – сокращение по стандарту ISO 3166 Codes, на третьем – процент символов пренадлежащих данному языку, на четвертом – к-во байт.

FastText

FastText – это библиотека написанная фейсбуком для эффективного обучения и классификации текстов. В рамках данного проекта фейсбук ресерч представил эмбеддинги для 157 языков, которые показывают state-of-the-art результаты на разных задачах, а также модель для определения языка и другие супервайзд задачи.

Для модели определения языка они использовали данные Wikipedia, Tatoeba and SETimes, а в качестве классификатора – свое решение на фасттексте.

Разработчики фейсбук ресерч предоставляют две модели:

lid.176.bin, которая немного быстрее и точнее второй модели, но весит 128Мб;
lid.176.ftz – сжатая версия оригинальной модели.

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

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

Определение языка с помощью модели FastText

from pyfasttext import FastText model = FastText('../model/lid.176.bin') model.predict_proba(["Bonjour, Habr!"], 3) #[[('fr', 0.7602248429835308), # ('en', 0.05550386696556002), # ('ca', 0.04721488914800802)]]

Модель FastText’a позволяет предсказывать вероятность для n-языков, где по дефолту n=1, но в этом примере мы вывели результат для топ-3 языков. Для этой модели это уже общая вероятность предсказания языка для текста, а не к-во символов, которые пренадлежат определенному языку, как было в модели cld2. Скорость работы тоже достаточно высокая – больше 60000 сообщений в секунду.

3. Оценка качества

Оценивать качество работы алгоритмов будем на данных из соц.сетей за случайное время, взятых из системы YouScan (приблизительно 500 тысяч упоминаний), поэтому в выборке будет больше русского и английского языков, 43% и 32% соответственно, украинского, испанского и португальского – около 2% каждого, из остальных языков меньше 1%. За правильный таргет мы будем брать разметку через google translate, так как на данный момент гугл очень хорошо справляется не только с переводом, а и с определением языка текстов. Конечно, его разметка неидеальна, но в большинстве случаев ей можно доверять.

Метриками для оценки качества определения языка будут точность, полнота и f1. Давайте их посчитаем и выведем в таблице:

Сравнение качества двух алгоритмов

with open("../data/lang_data.txt", "r") as f: text_l, cld2_l, ft_l, g_l = [], [], [], [] s = '' for i in f: s += i if ' |end\n' in s: text, cld2, ft, g = s.strip().rsplit(" ||| ", 3) text_l.append(text) cld2_l.append(cld2) ft_l.append(ft) g_l.append(g.replace(" |end", "")) s='' data = pd.DataFrame() def lang_summary(lang, col): prec = (data.loc[data[col] == lang, "google"] == data.loc[data[col] == lang, col]).mean() rec = (data.loc[data["google"] == lang, "google"] == data.loc[data["google"] == lang, col]).mean() return round(prec, 3), round(rec, 3), round(2*prec*rec / (prec + rec),3) results = <> for approach in ["cld2", "ft"]: results[approach] = <> for l in data["google"].value_counts().index[:20]: results[approach][l] = lang_summary(l, approach) res = pd.DataFrame.from_dict(results) res["cld2_prec"], res["cld2_rec"], res["cld2_f1"] = res["cld2"].apply(lambda x: [x[0], x[1], x[2]]).str res["ft_prec"], res["ft_rec"], res["ft_f1"] = res["ft"].apply(lambda x: [x[0], x[1], x[2]]).str res.drop(columns=["cld2", "ft"], inplace=True) arrays = [['cld2', 'cld2', 'cld2', 'ft', 'ft', 'ft'], ['precision', 'recall', 'f1_score', 'precision', 'recall', 'f1_score']] tuples = list(zip(*arrays)) res.columns = pd.MultiIndex.from_tuples(tuples, names=["approach", "metrics"])

model	cld2	ft	ans
metrics	prec	rec	f1	prec	rec	f1	prec	rec	f1
ar	0.992	0.725	0.838	0.918	0.697	0.793	0.968	0.788	0.869
az	0.95	0.752	0.839	0.888	0.547	0.677	0.914	0.787	0.845
bg	0.529	0.136	0.217	0.286	0.178	0.219	0.408	0.214	0.281
en	0.949	0.844	0.894	0.885	0.869	0.877	0.912	0.925	0.918
es	0.987	0.653	0.786	0.709	0.814	0.758	0.828	0.834	0.831
fr	0.991	0.713	0.829	0.53	0.803	0.638	0.713	0.81	0.758
id	0.763	0.543	0.634	0.481	0.404	0.439	0.659	0.603	0.63
it	0.975	0.466	0.631	0.519	0.778	0.622	0.666	0.752	0.706
ja	0.994	0.899	0.944	0.602	0.842	0.702	0.847	0.905	0.875
ka	0.962	0.995	0.979	0.959	0.905	0.931	0.958	0.995	0.976
kk	0.908	0.653	0.759	0.804	0.584	0.677	0.831	0.713	0.767
ko	0.984	0.886	0.933	0.94	0.704	0.805	0.966	0.91	0.937
ms	0.801	0.578	0.672	0.369	0.101	0.159	0.73	0.586	0.65
pt	0.968	0.753	0.847	0.805	0.771	0.788	0.867	0.864	0.865
ru	0.987	0.809	0.889	0.936	0.933	0.935	0.953	0.948	0.95
sr	0.093	0.114	0.103	0.174	0.103	0.13	0.106	0.16	0.128
th	0.989	0.986	0.987	0.973	0.927	0.95	0.979	0.986	0.983
tr	0.961	0.639	0.768	0.607	0.73	0.663	0.769	0.764	0.767
uk	0.949	0.671	0.786	0.615	0.733	0.669	0.774	0.777	0.775
uz	0.666	0.512	0.579	0.77	0.169	0.278	0.655	0.541	0.592

По результатам хорошо видно, что у подхода cld2 очень высокая точность определения языка, только для непопулярных языков она падает ниже 90%, и в 90% случаев результат лучше, чем у fasttext’a. При примерно одинаковой полноте для двух подходов, f1 скор больше у cld2.
Особенность cld2 модели в том, что она выдает прогноз только для тех сообщений, где она достаточно уверена, это объясняет высокую точность. Модель fasttext’a выдает ответ для большинства сообщений, поэтому точность существенно ниже, но странно, что полнота не существенно выше, а в половине случаев – ниже. Но если «подкрутить» порог для модели fasttext’a, то можно улучшить точность.

4. Выводы

В целом, обе модели дают хороший результат и могут быть использованы для решения задачи определения языка в разных доменах. Главное их преимущество – высокая скорость, которая дает возможность сделать так называемый «ансамбль» и добавить необходимый препроцессинг для повышения качества.

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

Также можете посмотреть тестирование этих решений в другой статье, где сравнивается точность и скорость на 6 западноевропейских языках.

А теперь поговорим о другом. Краткий курс языка Python

Это минимальный вводный курс по программированию на языке Python. Для более глубокого изучения взгляните на документацию на сайте www.python.org; особенно рекомендую Руководство (Tutorial). А если вам любопытно, почему вы должны интересоваться языком Python, взгляните на страничку Сравнение, где Python сравнивается с другими языками.

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

(Главная страничка по языку Python)

Примечание: Чтобы примеры нормально работали, пишите коды программ в текстовом файле, а потом запускайте с помощью интерпретатора; не пытайтесь запускать их прямо в интерактивном интерпретаторе — некоторые из них не будут работать. (Пожалуйста, не спрашивайте меня, почему так. Лучше почитайте документацию). [1]

1. Основы

Для начала представляйте себе Python в виде псевдокода. Это почти так и есть. Переменные не имеют типов, поэтому их не надо объявлять. [2] Они появляются, когда вы присваиваете им значения, и исчезают, когда вы их больше не используете. Присваивание производится оператором =. Проверка на равенство делается оператором ==. Вы можете присваивать значения нескольким переменным сразу: [3]

x,y,z = 1,2,3
first, second = second, first
a = b = 123

Блоки определяются посредством смещения и только таким образом (никаких BEGIN/END или скобок). Наиболее распространенными управляющими структурами являются следующие:

if x 10 and x = 0:
print «x все еще не отрицательно.»
x = x-1

Первые два примера эквивалентны. [4]

Индексная переменная, стоящая в цикле for , проходит по элементам списка (он пишется так же, как в примере). Для создания «обычного» цикла for (т.е. цикла со счетчиком), используйте встроенную функцию range() . [5]

for value in range(100):
print value

(Строка, начинающаяся с «#», представляет собой комментарий и игнорируется интерпретатором).

Хорошо; теперь вы знаете достаточно для того, чтобы (теоретически) реализовать любой алгоритм на языке Python. Давайте добавим несколько простейших понятий, касающихся взаимодействия с пользователем. Для получения ввода от пользователя (из текстового приглашения), используйте встроенную функцию input .

x = input(«Пожалуйста, введите число: «)
print «Квадрат этого числа равен», x*x

Функция input отображает указанное в ней приглашение (оно может быть пустым) и дает пользователю возможность ввести любое корректное для языка Python значение. В данном случае мы предполагали ввод числового значения — если бы было введено что-либо другое (например, строка), программа рухнула бы. Чтобы избежать этого, нам нужна какая-нибудь проверка ошибок. Я не буду углубляться в это сейчас; достаточно сказать, что если вы хотите, чтобы значение, введенное пользователем, хранилось буквально в виде строки (чтобы можно было ввести любое значение), используйте функцию raw_input . Если вы затем захотите преобразовать введенную строку s в целое число, вы сможете использовать выражение int(s) .

Примечание: Если вы хотите ввести строку с помощью input , пользователю придется явно заключить ее в кавычки. В языке Python строки могут заключаться как в одинарные (апострофы), так и в обычные двойные кавычки.

Таким образом, мы рассмотрели контрольные структуры, ввод и вывод — теперь нам нужно несколько впечатляющих примеров структур данных. Самые важные — это списки и словари. Списки записываются в квадратных скобках и (естественно) могут быть вложенными:

Одним из привлекательных качеств списков является возможность обращения как к их отдельным элементам, так и к группам элементов, с помощью индексирования (indexing) и срезов (slicing). Индексирование осуществляется (как и во многих других языках) путем добавления к списку индекса, заключенного в квадратные скобки. (Заметьте, что первый элемент имеет индекс 0).

print name[1], name[0]
name[0] = «Смит»

Срез напоминает индексирование, за исключением того, что вы указываете и стартовый и конечный индексы результата через двоеточие(«:»):

x = [«фарш»,»фарш»,»фарш»,»фарш»,»фарш»,»яйца»,»и»,»фарш»]
print x[5:7] # Печать списка [«яйца»,»и»]

Заметьте, что последний элемент (в данном случае с индексом 7) не включается в срез. Если один из индексов опущен, подразумевается, что вы хотите получить все элементы в этом направлении. То есть list[:3] означает «все элементы с начала списка ( list ) до элемента 3, не включая этот элемент «. [6] (Можно возразить, что на самом деле это элемент 4, поскольку подсчет начинается с 0. Ну, пусть так.) С другой стороны, list[3:] будет означать «любой элемент из списка ( list ), начиная с элемента 3 (включительно) и до последнего (включая его!)». Интересно то, что вы можете использовать отрицательные числа в качестве индексов: list[-3] представляет собой третий элемент с конца списка.

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

Ну, а что же насчет словарей? Говоря просто, они похожи на списки, только их содержимое неупорядоченно. Как же тогда их индексировать? А очень просто — каждый элемент имеет ключ, или «имя», которое используется для поиска элемента так же, как в настоящем словаре. Вот пара примеров словарей:

< "Алиса" : 23452532, "Борис" : 252336, "Кларисса" : 2352525, "Дорис" : 23624643>
person = < 'фамилия': "Робин", 'имя': "Гуд", 'профессия': "Разбойник" >

Теперь, чтобы получить профессию некоторого лица ( person ), мы можем использовать выражение person[«профессия»] . Если мы хотим изменить его фамилию, мы можем написать:

person[‘фамилия’] = «Локсли»

Просто, не правда ли? Как и списки, словари могут содержать другие словари (или списки). И, естественно, списки также могут содержать словари. Таким образом, вы можете с легкостью создавать весьма сложные структуры данных.

2. Функции

Следующий шаг: Абстракция. Мы хотим присвоить некоторое имя фрагменту кода и вызвать его с парой параметров. Другими словами, мы хотим определить функцию (или «процедуру»). Это просто. Используйте ключевое слово def , как в следующем примере:

def square(x):
return x*x
print square(2)

Для тех из вас, кто разбирается в этом: Все параметры в языке Python передаются по ссылке (как, например, в языке Java). Для тех, кто не разбирается: Не волнуйтесь 🙂

Python содержит все положенные примочки вроде именованных аргументов и аргументов по умолчанию и поддерживает функции с переменным числом аргументов. Чтобы разобраться с этим подробнее, загляните в Руководство по языку Python раздел 4.7.

Если вы в принципе знакомы с использованием функций, это в основном все, что вам нужно знать о них в языке Python. (Ах, да. Ключевое слово return прекращает выполнение функции и возвращает соответствующее значение).

Кроме того полезно знать, что в языке Python функции являются значениями. То есть если у вас есть функция типа square , вы можете сделать что-нибудь вроде:

queeble = square
print queeble(2)

Для вызова функции без аргументов вы должны не забыть написать doit(), а не doit. Последнее выражение, как было показано, всего лишь возвращает функцию саму по себе, как значение (это подводит нас к разговору о методах, связанных с объектами. См. ниже).

3. Объекты и прочее.

Думаю, вы знакомы с принципами объектно-ориентированного программирования. (Если нет, этот раздел, возможно, будет вам несколько непонятен. Ничего страшного. Вы можете начать писать на языке Python и без использования объектов :)). В этом языке вы определяете классы с помощью (сюрприз!) ключевого слова class , как это сделано в следующем примере:

def __init__(self,contents=None):
self.contents = contents or []

def add(self,element):
self.contents.append(element)

Все методы (функции в объекте) получают дополнительный аргумент в начале списка аргументов. Этот аргумент содержит сам объект. (В этом примере он назван self , как это обычно принято).
Методы вызываются как: object.method(arg1,arg2) . [7]
Некоторые имена методов, наподобие __init__ , предопределены и означают что-то специальное. __init__ — это имя конструктора класса, то есть функции, вызываемой, когда вы создаете объект этого класса. [8]
Некоторые аргументы могут быть необязательными и им могут присваиваться значения по умолчанию (как упоминалось выше, в разделе, посвященном функциям). Это можно сделать, написав определение, как в следующем примере:

if a:
print a
else:
print b

Может быть записано:

print a or b

В действительности, это что-то вроде идиомы языка Python, поэтому можете постепенно привыкать так и писать. Это то же, что мы делали в методе Basket.__init__ . Аргумент contents имеет значение по умолчанию None (которое, между прочим, ложно). Следовательно, чтобы проверить, имеет ли он некоторое значение, мы могли бы написать:

if contents:
self.contents = contents
else:
self.contents = []

Безусловно, теперь вы знаете, лучший способ. А почему бы нам тогда не присвоить ему сразу значение по умолчанию [] ? А потому, что согласно принципам работы языка Python, в результате этого всем «Baskets» присвоился бы один и тот же пустой список значений, который задан в значении по умолчанию. Как только один из них начал бы заполняться, все остальные получали бы те же самые элементы, и значение по умолчанию больше не было бы пустым. Чтобы лучше разобраться в этом, прочитайте документацию и обратите внимание на различие между идентичностью и равенством. Все вышеизложенное можно сделать и другим способом:

def __init__(self, contents=[]):
self.contents = contents[:]

Можете догадаться, как это работает? Вместо использования везде одного и того же пустого списка, мы задействовали выражение contents[:] , чтобы сделать копию. (Просто срезали все целиком). Так, чтобы действительно создать объект Basket и использовать его (то есть вызвать какие-либо его методы), мы можем сделать что-то вроде:

b = Basket([‘яблоко’,’апельсин’])
b.add(«лимон»)
b.print_me()

Есть и другие волшебные методы, помимо __init__ . Один из таких методов — __str__ , определяющий, как объект хотел бы выглядеть в строчном представлении. Мы можем использовать на нашем примере вместо print_me :

def __str__(self):
result = «»
for element in self.contents:
result = result + » » + `element`
return «Contains:»+result

Теперь, если мы захотим напечатать Basket b, мы сможем просто указать:

print b

Неплохо, а?
Производные классы создаются так:

Python допускает множественное наследование, поэтому в скобках может быть указано несколько базовых классов, разделяемых запятыми. Классы воплощаются (т.е. объекты конструируются) следующим образом: x = Basket() . Конструкторы задаются, как уже упоминалось, путем определения специального метода __init__ . Давайте предположим, что SpamBasket имеет коструктор __init__(self,type) . Тогда вы можете создать корзину с фаршем следующим образом: y = SpamBasket(«apples») . Если вам в конструкторе SpamBasket нужно вызвать конструктор одного или нескольких базовых классов, вы можете сделать это так: Basket.__init__(self) . Заметьте, что в дополнение к обычным параметрам вам следует явно задать self , поскольку метод __init__ базового класса не знает, с каким объектом он имеет дело. Чтобы лучше разобраться в замечательных возможностях объектно-ориентированного программирования в языке Python, загляните в Руководство, раздел 9.

4. Приемы Джедаев

(Этот раздел вставлен сюда только потому, что он мне нравится. Для того, чтобы начать знакомство с языком Python, он абсолютно не нужен). Вам нравятся головокружительные концепции? Тогда, если вы так бесстрашны, вам, возможно, будет интересно ознакомиться с эссе Гвидо ван Россума (Guido van Rossum) по метаклассам. Если же вам не слишком хочется подвергать свой разум таким испытаниям, вероятно, вам вполне хватит и этого небольшого приемчика. Python использует динамические пространства имен (dynamic namespaces) как противоположность лексическим пространствам имен (static namespaces). Это означает, что если у вас есть функция, наподобие следующей:

def orange_juice():
return x*2

. где переменная (в данном случае x ) не привязана к какому-либо аргументу и внутри функции ей не присваивается значение, Python будет использовать то значение, которое она имеет там и тогда, где и когда вызывается эта функция. В данном случае:

x = 3
y = orange_juice()

x = 1
y = orange_juice()

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

x = 4
def apple_juice(x=x):
return x*2

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

x = 3
y = apple_juice()

x = 1
y = apple_juice()

То есть — значение x не изменилось. Если это все, чего мы хотели, то могли бы с тем же успехом написать:

def tomato_juice():
x = 4
return x*2

или даже:

def carrot_juice():
return 8

Тем не менее, суть в том, что значение x берется из окружения в момент определения функции. Для чего это может быть полезно? Давайте рассмотрим пример — функция, сочетающая две других функции. Мы хотим создать функцию, которая будет работать как:

from math import sin, cos
sincos = compose(sin,cos)
x = sincos(3)

где compose представляет собой функцию, которую мы хотим создать, а x имеет значение -0.836021861538 , что то же самое, что и sin(cos(3)) . Ну, и как же мы это сделаем? (Заметьте, что здесь мы используем функции как аргументы. Это очень изящный прием сам по себе). Понятно, что compose принимает две функции как параметры и возвращает одну функцию, которая, в свою очередь, принимает один параметр. Таким образом, схема решения может быть такой:

def compose(fun1, fun2):
def inner(x):
pass
return inner

Нам может захотеться поместить return fun1(fun2(x)) внутрь функции inner и так и оставить там. Нет, нет и нет. Такая конструкция поведет себя весьма странно. Представьте себе следующий сценарий:

from math import sin, cos
def fun1(x):
return x + » мир!»

def fun2(x):
return «Привет,»

sincos = compose(sin,cos) # Использование неверной версии
x = sincos(3)

Ну а теперь, каково значение x ? Правильно: «Привет, мир» . А почему так? Потому что когда ее вызывают, она берет значения fun1 и fun2 из окружения, а не те, что имеются рядом в момент ее создания. Все что мы должны сделать, чтобы получить нормально работающее решение, — это использовать тот прием, который описывался ранее:

def compose(fun1, fun2):
def inner(x, fun1=fun1, fun2=fun2):
return fun1(fun2(x))
return inner

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

def compose(f1, f2):
return lambda x, f1=f1, f2=f2: f1(f2(x))

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

5. И наконец.

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

import string
x = string.split(y)

либо.

from string import split
x = split(y)

За дополнительной информацией по стандартным библиотечным модулям обращайтесь к сайту www.python.org/doc/lib. Там лежит множество весьма полезных вещей. Весь код в модуле/скрипте запускается, когда его импортируешь. Если вы хотите, чтобы ваша программа была как импортируемым модулем, так и запускаемой программой, вы, возможно, захотите добавить в ее конец что-нибудь вроде:

if __name__ == «__main__»: go()

Это волшебный способ указать на то, что если этот модуль запускается как исполняемый скрипт (то есть не импортируется в другой скрипт), тогда должна вызываться функция go . Безусловно, вы можете написать что угодно после поставленного там двоеточия. 🙂 Вниманию тех, кто хочет создать исполняемый скрипт под UN*X — воспользуйтесь следующей первой строкой, чтобы сделать его самозапускающимся:

И, наконец, коротко о важном: Исключения. Некоторые операции (такие, как деление на ноль или чтение из несуществующего файла) порождают условия возникновения ошибки (error condition), или исключения. Вы можете даже создать свои собственные исключения и возбуждать их в соответствующие моменты. В случае, если возбуждено исключение и ничего не сделано для его перехвата, ваша программа завершается и выдает сообщение об ошибке. Вы можете избежать этого с помощью выражения try/except . Например:

def safe_division(a,b):
try:
return a/b
except ZeroDivisionError:
return None

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

try:
unsafe_division(a,b)
except ZeroDivisionError:
print «Something was divided by zero in unsafe_division»

В случаях, когда у вас обычно отсутствуют специфическая проблема, но она может возникнуть, использование исключений позволит вам избежать дорогостоящего тестирования и т.п. Ну, в общем-то, все. Надеюсь, вы чему-нибудь научились. А теперь — идите и пробуйте. И помните девиз обучения языку Python: «Use the source, Luke!» (используй исходники, Люк!). (Перевод: Читайте все коды, до которых только можете добраться :)) Для начала, вот здесь лежит пример. Это общеизвестный алгоритм Быстрой сортировки (QuickSort) Хоара (Hoare’s). Версия с выделенным цветным синтаксисом лежит здесь. Об этом примере стоит сказать пару слов. Переменная done отслеживает, закончила ли partition движение по элементам. Так, когда один из двух внутренних циклов хочет завершить всю последовательность обмена, он присваивает done 1 и затем завершается через break . Почему внутренние циклы используют done ? Потому что, когда первый вложенный цикл заканчивается через break , начнется или нет следующий цикл, зависит от того, закончился ли главный цикл, то есть, имеет ли done значение, равное 1:

while not done:
while not done:

Эквивалентной и, возможно, более понятной, но менее симпатичной версией будет следующая:

while not done:
while 1:

if not done:
while 1:

Единственная причина, по которой я использовал переменную done в первом цикле, состоит в том, что мне понравилась идея сохранить симметрию между двумя циклами. Поэтому если кто-то изменит их порядок, алгоритм все равно будет работать. Еще ряд примеров вы можете найти на страничке штучек Джоуи Страута (Joe Strout) . [1] На самом деле, простые выражения, занимающие одну строку (наподобие print b + c) гораздо удобнее вводить в интерактивном интерпретаторе, и работать они будут всегда. Проблемы могут возникать с многострочными выражениями, поскольку управляющие блоки в Python задаются смещением текста; тем не менее, многие составные операторы также могут быть введены в одну строчку; более того, несколько операторов могут быть введены на одной строке, например:>

if x
(Прим. Перев.)

[2] Переменная получает тип при присваивании, например:

v = 10
v = «Hello, world!»

(Прим. Перев.)

[3] Список переменных пробегается слева направо и каждой переменной присваивается соответствующее значение из списка значений справа от оператора присваивания.
(Прим. Перев.)

[4] Обратите внимание на запись операторов сравнения в следующем примере:

if x
В языке Python, в отличие от большинства других языков программирования, можно записывать сравнение так же, как в обычной математической записи ( 10 ).
(Прим. Перев.)

[5] Для больших диапазонов предпочтительно использовать функцию xrange() .
(Прим. Перев.)

[6] Т.е., список, состоящий из элементов 0, 1, 2 исходного списка.
(Прим. Перев.)

[7] Для программистов на C++ — обратите внимание, что обращение к членам класса внутри функций-членов также всегда производится с явным указанием объекта, для которого вызывается функция-член. Это сделано не для того, чтобы затруднить вам жизнь, а потому, что в связи с динамическим разрешением пространства имен в языке Python логика «по умолчанию» может приводить к весьма неожиданным (и неприятным) последствиям. (C++ использует статические пространства имен).
(Прим. Перев.)

[8] Вообще, любой метод, имя которого начинается и заканчивается __ (двумя подчеркиваниями) — специальный.
(Прим. Перев.)

[9] В Python’е есть специальное «пустое» значение None , наподобие NULL в C.
(Прим. Перев.)

[10] Логика короткого замыкания замечательна еще и тем, что вычисляются только те подвыражения логического выражения, которые необходимы для того, чтобы получить результат. Это может играть существенную роль, если подвыражения обладают побочным эффектом, например:

def fn(x):
print x, » Автор: Магнус Ли Хетланд

Основы языка программирования Python

Python – это высокоуровневый язык программирования, который был разработан в конце 1980-х годов. Его разработчик, Гвидо ван Россум, вложил в основу языка простоту и читабельность кода, что позволяет использовать Python для быстрой и эффективной разработки. Много популярных веб-сайтов, компьютерных игр и программ, написанных на Python, вы используете ежедневно: Dropbox, Uber, Sims, Google, GIMP и другие.

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

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

Преимущества Python

Простой и читаемый код. Python предлагает понятный синтаксис, что делает его привлекательным для опытных разработчиков и доступным для новичков.
Большое число полезных библиотек и модулей для Python позволяет быстро и легко решать различные задачи, такие как обработка данных, машинное обучение, работа с базами данных.
Язык подходит для большинства операционных систем. Код, написанный при помощи Python, может быть запущен на популярных ОС: Windows, macOS, Linux.
Python позволяет легко интегрировать код на других языках, таких как C ++ и Java. Это позволяет использовать уже существующий код и библиотеки на этих языках, чтобы расширять функциональность Python.
Активное сообщество разработчиков помогающее и поддерживающее новичков. Это значит, что всегда можно получить ответы на возникающие вопросы или найти готовый код для решения своих задач.

Основные свойства и возможности Python

Python интерпретируемый язык программирования – код на нем выполняется построчно, в режиме реального времени. Это свойство позволяет быстро исправлять и проверять код без необходимости компиляции.
Python является языком с динамической типизацией, то есть тип переменной определяется автоматически, во время выполнения кода. Это упрощает процесс программирования и делает его гибким при работе с данными различного типа.
Python поддерживает объектно-ориентированное программирование (ООП), что позволяет разрабатывать код в виде объектов, которые взаимодействуют друг с другом. Это делает код более модульным и повторно используемым.
Python поддерживает также императивное, функциональное и аспектно-ориентированное программирование. Таким образом, разработчики имеют возможность выбирать нужный подход для решения конкретной задачи.

Аренда выделенного сервера – надежный способ хранения ваших данных. Для проектов с высокими требованиями к безопасности рекомендуем приобрести услугу Аренда физического сервера от RU-CENTER.

Синтаксис языка Python

Синтаксис Python отличается своей простотой и ясностью. Рассмотрим основные элементы:

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

print(«x больше 5»)

print(«x меньше или равно 5»)

Комментарии начинаются с символа # и необходимы для пояснения кода или временного отключения определенных участков.

print(«Hello!») # Комментарий после кода

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

x = 7 # переменная целого числа

y = 3.11 # переменная числа с плавающей запятой

name = «Ivan» # переменная строки

Python поддерживает все основные математические действия (сложение, вычитание, умножение, деление, равенство, неравенство, больше, меньше и др.).

difference = x — y

print(sum, difference, product, quotient) # выводит: 14, 4, 45, 1.8

В Python используются операторы if, elif и else для выполнения разных блоков кода в зависимости от условий.

В Python используются циклы for и while для повторения блоков кода.

Пример цикла for:

vegetables = [«огурец», «помидор», «морковь»]

for vegetable in vegetables:

Пример цикла while:

Структуры данных языка Python

Python поддерживает следующие структуры данных:

Списки – упорядоченные коллекции элементов, которые могут быть любого типа данных. Доступ к элементам списка осуществляется по индексу.
Кортежи – упорядоченные коллекции элементов, которые могут быть любого типа данных, но не могут быть изменены после создания.
Словари – неупорядоченные коллекции пар «ключ-значение». Доступ к значениям словаря осуществляется по ключу.
Множества – неупорядоченные коллекции уникальных элементов.
Стеки и очереди – для реализации стеков и очередей используются списки.
Генераторы – функции, которые используются для генерации последовательностей значений.
Итераторы – объекты, которые позволяют проходить по последовательности значений, например, списку или словарю.
Файлы – структура данных, которая используется для чтения и записи информации на диске.

Строки в языке Python

При оформление строк в Python могут быть использованы различные методы и синтаксические возможности, например:

Кавычки. Строки в Python могут быть оформлены с использованием одиночных кавычек (»), двойных кавычек («») или тройных кавычек (»’ »’, «»» «»»).
Чтобы использовать специальные символы, например, одинарная или двойная кавычка, внутри строки, используется обратный слеш (\).

message = «She said, \»Hello!\»»

Для объединения строк используется оператор «+». Это называется конкатенацией строк.

greeting = «Hello, » + name + «!»

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

message = f»My name is {name} and I’m {age} years old.»

Для форматирования строк используется метод format() и оператор %.

message = «My name is {} and I’m {} years old.».format(name, age)

message = «My name is %s and I’m %d years old.» % (name, age)

Операторы в языке Python

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

Оператор присваивания (=) используется для присваивания значения переменной.
Оператор арифметических вычислений (+, -, *, /) используются для выполнения арифметических операций.
Оператор сравнения (==, !=, >, >=,
Оператор логического И (and), ИЛИ (or), НЕ (not) используются для комбинирования условий в логические выражения.
Оператор ветвления if-else используется для выполнения определенного блока кода в зависимости от условия.

print(«x is greater than 6»)

print(«x is less than or equal to 6»)

Оператор цикла for используется для выполнения определенного блока кода для каждого элемента в указанной последовательности.

Пример: for i in range(5):

Оператор цикла while используется для выполнения определенного блока кода, пока указанное условие истинно.

Оператор ветвления try-except используется для обработки исключений в коде.

print(«Error: can’t divide by zero»)

Функции языка Python

Встроенные функции Python используются для решения различных задач. Примеры некоторых из них:

– ` print()` – для вывода текста или переменных на консоль.

– `input()` – запрашивает ввод данных от пользователя.

– `len()` – возвращает длину объекта (например, строки, списка или кортежа).

– `type()` – возвращает тип объекта.

– `range()` – создает последовательность чисел.

– `int()`, `float()`, `str()`, `bool()` – используются для преобразования объектов в целые числа, числа с плавающей запятой, строки и булевые значения соответственно.

– `sum()` – суммирует элементы последовательности чисел.

– `sorted()` – сортирует элементы последовательности.

– `max()` и `min()` – возвращают максимальный и минимальный элементы последовательности.

– `abs()` – возвращает абсолютное значение числа.

– round()` – Округляет число до указанного количества знаков после запятой.

– `str.upper()`, `str.lower()` – преобразуют все символы в строке в верхний или нижний регистр соответственно.

Классы языка Python

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

Пример создания класса в Python:

def __init__(self, name, age):

Исключения в языке Python

Исключения в Python – тип данных, с помощью которых разработчик узнает об ошибках и необычных ситуациях. Примеры исключений в Python:

TypeError означает, что операция выполняется над объектом несовместимого типа данных.
ValueError возникает, когда функция получает аргумент правильного типа, но с неправильным значением.
IndexError появляется, когда происходит попытка получить доступ к элементу списка или строки с использованием недопустимого индекса.
KeyError – при попытке получить доступ к элементу словаря по ключу, которого нет в словаре.
FileNotFoundError – возникает, при открывании файла, которого не существует.
ZeroDivisionError – деление на ноль происходит в программе.
IOError – появляется, когда возникают проблемы с вводом-выводом, например, при чтении или записи файлов.

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

Импорт в языке Python

Импорты используются для подключения модулей или библиотек.

Импорт всего модуля: import module_name
Импорт модуля с псевдонимом: import module_name as alias_name
Импорт конкретной функции или класса из модуля:

from module_name import function_name

from module_name import class_name

Импорт нескольких функций или классов из модуля:

from module_name import function_name1, function_name2

from module_name import class_name1, class_name2

Импорт всего модуля со всеми его функциями и классами: from module_name import *

Обратите внимание, на корректность указания имени модуля и функции и их доступность для импорта.

Работа с файловой системой в языке Python

С помощью модуля os или pathlib возможна работа с файловой системой в Python. Приведем несколько примеров с использованием этих модулей:

# Создание нового каталога

# Открытие файла для записи

with open(«file.txt», «w») as file:

Модуль pathlib (для версии Python 3.4 и выше):

from pathlib import Path

# Чтобы создать новый каталог

# Чтобы переименовать каталог

# Чтобы открыть файл для записи

with open(path / «file.txt», «w») as file:

# Чтобы удалить файл

# Чтобы удалить каталог

Заключение

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

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

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