Язык программирования Python — с чего начинать? Как работает Python.

Программирование на Python

Часть 1. Возможности языка и основы синтаксиса

Серия контента:

Стоит ли изучать Python?

Python – это один из наиболее популярных современных языков программирования. Он пригоден для решения разнообразных задач и предлагает те же возможности, что и другие языки программирования: динамичность, поддержку ООП и кросс-платформенность. Разработку Python начал Гвидо Ван Россум (Guido Van Rossum) еще в середине 1990-х годов, поэтому к настоящему времени удалось избавиться от стандартных «детских» болезней, существенно развить лучшие стороны языка и привлечь множество программистов, использующих Python для реализации своих проектов.

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

Изучить в совершенстве два таких языка как Java и C++ достаточно сложно и заняло бы много времени; кроме того, многие аспекты этих языков противоречат друг другу. В то же время Python идеально подходит на роль второго языка, так как он сразу же усваивается благодаря уже имеющимся знаниям в ООП, и тому, что его возможности не конфликтуют, а дополняют опыт, накопленный при работе с другим языком программирования.

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

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

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

Архитектура Python

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

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

К Python это не относится, так как это язык простой, но упрощенный. Дело в том, что Python является языком с более высоким уровнем абстракции, выше, например, чем у Java и C++, и позволяет передать такое же количество информации в меньшем объеме исходного кода.

Также Python является языком общего назначения, поэтому может применяться практически в любой области разработки ПО (standalone, клиент-сервер, Web-приложения) и в любой предметной области. Кроме того, Python легко интегрируется с уже существующими компонентами, что позволяет внедрять Python в уже написанные приложения.

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

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

Среда исполнения Python

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

В среду исполнения Java дополнительно входит компилятор, так как исходный код необходимо скомпилировать в байт-код для виртуальной Java-машины. В среду исполнения Python входит только интерпретатор, который одновременно является и компилятором, однако компилирует исходный код Python непосредственно в машинный код целевой платформы.

На данный момент существуют три известных реализации среды исполнения для Python: CPython, Jython и Python.NET. Как можно догадаться из названия, первая среда реализована на языке C, вторая на языке Java, а последняя – на платформе.NET.

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

Среда исполнения Jython – это реализация Python для работы с виртуальной Java-машиной (JVM). Поддерживается любая версия JVM, начиная с версии 1.2.2 (текущая версия Java – 1.6). Для работы с Jython требуется установленная Java-машина (среда исполнения Java) и определенное знание языка программирования Java. Уметь писать исходный код на языке Java не обязательно, однако придется иметь дело c JAR-файлами и Java-апплетами, а также документацией в формате JavaDOC.

Какую версию среды выбрать – зависит исключительно от предпочтений программиста, вообще же рекомендуется держать на компьютере и CPython, и Jython, так как они не конфликтуют между собой, а взаимно дополняют друг друга. Среда CPython работает быстрее, так как нет промежуточного уровня в виде JVM; кроме того, обновленные версии Python сначала выпускают именно в виде среды CPython. Однако Jython может использовать любой класс Java в качестве модуля расширения и работать на любой платформе, для которой существует реализация JVM.

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

Начало работы с Python

Прежде чем начать использовать Python, необходимо установить его среду исполнения – в данной статье это CPython и соответственно интерпретатор python. Существуют различные способы установки: опытные пользователи могут сами скомпилировать Python из его общедоступного исходного кода, также можно загрузить с Web-сайта www.python.org уже готовые исполняемые файлы для конкретной операционной системы, наконец, многие дистрибутивы Linux поставляются с уже предустановленным интерпретатором Python. В этой статье используется версия Python 2.x для ОС Windows, однако представленные примеры можно запускать на любой версии Python.

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

  • PATH . В этой переменной должен содержаться путь к каталогу, где установлен Python, чтобы его могла найти операционная система.
  • PYTHONHOME . Эта переменная должна содержать только путь к каталогу, где установлен Python. Также в этом каталоге должен содержаться подкаталог lib, в котором будет выполняться поиск стандартных модулей Python.
  • PYTHONPATH . Переменная со списком каталогов, содержащих модули расширения, которые будут подключаться к Python (элементы списка должны разделяться системным разделителем).
  • PYTHONSTARTUP . Не обязательная переменная, определяющая путь к сценарию Python, который должен выполняться каждый раз при запуске интерактивного сеанса интерпретатора Python.

Командная строка для работы с интерпретатором имеет следующую структуру.

PYTHONHOME\python (опции) [ -с команда | файл со сценарием | - ] {аргументы}

Интерактивный режим работы Python

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

Значение вычисленного выражения сохраняется в специальную переменную с именем «Одиночное подчеркивание» (_), так что его можно использовать в последующих выражениях. Завершить интерактивный сеанс можно сочетанием клавиш Ctrl–Z в ОС Windows или Ctrl–D в ОС Linux.

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

Для проверки правильности установки и работоспособности Python можно выполнить следующие команды:

c:\> python- v
c:\> python –c “import time; print time.asctime()”

Опция –v выводит версию используемой реализации Python и завершает работы, а вторая команда распечатывает на экран значение системного времени.

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

Основы синтаксиса Python

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

Далее приведен очень важный аспект, который может показаться странным программистам, изучающим Python в качестве второго языка программирования. Дело в том, что в Python нет символа, который бы отвечал за отделение выражений друг от друга в исходном коде, как, например, точка с запятой (;) в C++ или Java. Точка с запятой позволяет разделить несколько инструкций, если они находятся на одной физической строке. Также отсутствует такая конструкция, как фигурные скобки {}, позволяющая объединить группу инструкций в единый блок.

Физические строки разделяются самим символом конца строки, но если выражение слишком длинное для одной строки, то две физических строки можно объединить в одну логическую. Для этого необходимо в конце первой строки ввести символ обратного слеша (\), и тогда следующую строку интерпретатор будет трактовать как продолжение первой, однако при этом нельзя, чтобы на первой строке за символом \ находились бы другие символы, например, комментарий с #. Для выделения блоков кода используются исключительно отступы. Логические строки с одинаковым размером отступа формируют блок, и заканчивается блок в том случае, когда появляется логическая строка с отступом меньшего размера. Именно поэтому первая строка в сценарии Python не должна иметь отступа. Усвоение этих несложных правил поможет избежать большинства ошибок, связанных с освоением нового языка.

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

Типы данных, используемых в Python

Типы данных, используемых в Python, также совпадают с другими языками – целые и вещественные типы данных; дополнительно поддерживается комплексный тип данных – с вещественной и мнимой частью (пример такого числа – 1.5J или 2j, где J представляет собой квадратный корень из -1). Python поддерживает строки, которые могут быть заключены в одинарные, двойные или тройные кавычки, при этом строки, как и в Java, являются immutable-объектами, т.е. не могут изменять свое значение после создания.

Есть в Python и логический тип данных bool c двумя вариантами значения – True и False. Однако в старых версиях Python такого типа данных не было, и, кроме того, любой тип данных мог быть приведен к логическому значению True или False. Все числа, отличные от нуля, и непустые строки или коллекции с данными трактовались как True, а пустые и нулевые значения рассматривались как False. Эта возможность сохранилась и в новых версиях Python, однако для повышения читаемости кода рекомендуется использовать для логических переменных тип bool. В то же время, если необходимо поддерживать обратную совместимость со старыми реализациями Python, то в качестве логических переменных стоит использовать 1 (True) или 0 (False).

Функциональность для работы с наборами данных

В Python определены три типа коллекций для хранения наборов данных:

  • кортеж (tuple);
  • список (list);
  • словарь (dictionary).

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

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

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

В листинге 1 приведены примеры различных коллекций, доступных в Python.

Листинг 1. Виды коллекций, доступные в Python
(‘w’,‘o’,‘r’,‘l’,‘d’) # кортеж из пяти элементов (2.62,) # кортеж из одного элемента [“test”,"me"] # список из двух элементов # пустой список { 5:‘a’, 6:‘b’, 7:‘c’ } # словарь из трех элементов с ключами типа int

Определение функций в Python

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

Синтаксис определения функций в Python крайне простой; с учетом изложенных выше требований:

def ИМЯ_ФУНКЦИИ(параметры): выражение № 1 выражение № 2 ...

Как видно, необходимо использовать служебное слово def, двоеточие и отступы. Вызвать функцию также очень просто:

ИМЯ_ФУНКЦИИ(параметры)

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

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

#функция, выполняющая деление нацело – с помощью оператора // def foo(delimoe, delitel): return delimoe // delitel print divide(50,5) # результат работы: 10 print divide(delitel=5, delimoe=50) # результат работы: 10

Функция в Python обязательно возвращает значение – это делается либо явно с помощью оператора return, за которым следует возвращаемое значение, либо, в случае отсутствия оператора return, возвращается константа None, когда достигается конец функции. Как видно из примеров объявлений функций, в Python нет необходимости указывать, возвращается что-либо из функции или нет, однако если в функции имеется один оператор return, возвращающей значение, то и другие операторы return в этой функции должны возвращать значения, а если такого значения нет, то необходимо явно прописывать return None.

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

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

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

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

1. Invent Your Own Computer Games With Python

У вас уже может быть своя любимая книга по Python, но я советую вам прочитать эту . Вы можете приобрести её, прочитать онлайн или бесплатно скачать в PDF. Мне нравится одинаковая структура глав: сперва ставится задача, а потом идут примеры решений задач с подробными объяснениями. Этот же автор написал ещё 3 замечательных книги.

2. Skulpt

Мне приходилось работать в школах, где по тем или иным причинам (обычно в целях безопасности) Python был недоступен. Skulpt исполняет Python-скрипты в браузере и включает в себя несколько примеров. Первый из них использует модуль Turtle для вывода геометрических фигур. Я часто использую его для проверки знаний учеников.

3. Угадай число

8. Random

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

Import random coin = [‘heads’,’tails’] flip = random.choice(coin) print(flip)

9. Anti Gravity

Я редко использую модуль anti gravity . Но когда мне приходится это делать, я спрашиваю у учеников, что произойдёт, когда они импортируют его. Обычно я получаю много различных ответов, порой даже предполагают, что начнётся реальный эффект невесомости - считают, что Python настолько мощный 🙂 Можете попробовать сами и предложить своим ученикам.

Import antigravity

10. Саботаж

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

Введение


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

В связи с этим, определенный интерес представляет рассмотрение сравнительно нового языка программирования Python (пайтон), который был создан его автором Гвидо ван Россумом (Guido van Rossum) в начале 90-х годов.

Общие сведения о Python. Достоинства и недостатки


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

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

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

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

  • Numerical Python - расширенные математические возможности, такие как манипуляции с целыми векторами и матрицами;
  • Tkinter - построение приложений с использованием графического пользовательского интерфейса (GUI) на основе широко распространенного на X-Windows Tk-интерфейса;
  • OpenGL - использование обширной библиотеки графического моделирования двух- и трехмерных объектов Open Graphics Library фирмы Silicon Graphics Inc. Данный стандарт поддерживается, в том числе, в таких распространенных операционных системах как Microsoft Windows 95 OSR 2, 98 и Windows NT 4.0.
Недостатки языка.
Единственным недостатком, замеченным автором, является сравнительно невысокая скорость выполнения Python-программы, что обусловлено ее интерпретируемостью. Однако, на наш взгляд, это с лихвой окупается достоинствами языка при написании программ не очень критичных к скорости выполнения.

Обзор особенностей


1. Python, в отличие от многих языков (Pascal, C++, Java, и т.д.), не требует описания переменных. Они создаются в месте их инициализации, т.е. при первом присваивании переменной какого-либо значения. Значит, тип переменной определяется типом присваиваемого значения. В этом отношении Python напоминает Basic.
Тип переменной не является неизменным. Любое присваивание для нее корректно и это приводит лишь к тому, что типом переменной становится тип нового присваиваемого значения.

2. В таких языках как Pascal, C, C++ организация списков представляла некоторые трудности. Для их реализации приходилось хорошо изучать принципы работы с указателями и динамической памятью. И даже имея хорошую квалификацию, программист, каждый раз заново реализуя механизмы создания, работы и уничтожения списков, мог легко допустить трудноуловимые ошибки. Ввиду этого были созданы некоторые средства для работы со списками. Например, в Delphi Pascal имеется класс TList, реализующий списки; для С++ разработана библиотека STL (Standard Template Library), содержащая такие структуры как векторы, списки, множества, словари, стеки и очереди. Однако, такие средства имеются не во всех языках и их реализациях.

Одной из отличительных черт Python является наличие таких встроенных в сам язык структур как тьюплы (tuple), списки (list) и словари (dictionary), которые иногда называют картами (map). Рассмотрим их поподробней.

  1. Тьюпл . Он чем-то напоминает массив: состоит из элементов и имеет строго определенную длину. Элементами могут быть любые значения - простые константы или объекты. В отличие от массива, элементы тьюпла не обязательно однородны. А тем, что отличает тьюпл от списка (list) является то, что тьюпл не может быть изменен, т.е. мы не можем i-тому элементу тьюпла присвоить что-то новое и не можем добавлять новые элементы. Таким образом, тьюпл можно назвать списком-константой. Синтаксически тьюпл задается путем перечисления через запятую всех элементов, и все это заключено в круглые скобки:

    2. (1, 2, 5, 8)
    (3.14, ‘ string ’, -4)
    Все элементы индексируются с нуля. Для получения i-го элемента необходимо указать имя тьюпла затем индекс i в квадратных скобках. Пример:
    t = (0, 1, 2, 3, 4)
    print t, t[-1], t[-3]
    Результат : 0 4 2
    Таким образом, тьюпл можно было назвать вектором-константой, если бы его элементы всегда были однородными.
  2. Список . Хорошим, частным примером списка может служить строка (string) языка Turbo Pascal. Элементами строки являются одиночные символы, ее длина не фиксирована, имеется возможность удалять элементы или, напротив, вставлять их в любом месте строки. Элементами же списка могут быть произвольные объекты не обязательно одного и того же типа. Чтобы создать список, достаточно перечислить его элементы через запятую, заключив все это в квадратные скобки:


    3. [‘string’, (0,1,8), ]
    В отличие от тьюпла, списки можно модифицировать по своему желанию. Доступ к элементам осуществляется также как и в тьюплах. Пример:
    l = ]
    print l, l, l[-2], l[-1]
    Результат : 1 s (2,8) 0
  3. Словарь . Напоминает тип запись (record) в Pascal или структуры (structure) в С. Однако, вместо схемы "поле записи"-"значение" здесь применяется "ключ"-"значение". Словарь представляет собой набор пар "ключ"-"значение". Здесь "ключ" - константа любого типа (но преимущественно применяются строки), он служит для именования (индексирования) некоторого соответствующего ему значения (которое можно менять).

    4. Словарь создается путем перечисления его элементов (пар "ключ"-"значение", разделенных двоеточием), через запятую и заключения всего этого в фигурные скобки. Для получения доступа к некоторому значению необходимо, после имени словаря, в квадратных скобках записать соответствующий ключ. Пример:
    d = {"a": 1, "b": 3, 5: 3.14, "name": "John"}
    d["b"] = d
    print d["a"], d["b"], d, d["name"]
    Результат : 1 3.14 3.14 John
    Для добавления новой пары "ключ"-"значение" достаточно присвоить элементу с новым ключом соответствующее значение:
    d["new"] = "new value"
    print d
    Результат : {"a":1, "b":3, 5:3.14, "name":"John", "new":"new value"}

3. Python в отличие от Pascal, C, C++ не поддерживает работу с указателями, динамической памятью и адресную арифметику. В этом он похож на Java. Как известно, указатели служат источником трудноуловимых ошибок и работа с ними относится больше к программированию на низком уровне. Для обеспечения большей надежности и простоты они небыли включены в Python.

4. Одним из особенностей Python является то, как происходит присваивание одной переменной другой, т.е. когда по обе стороны от оператора "= " стоят переменные.

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

Когда же присваивание приводит к созданию нового объекта (здесь объект - в смысле участка памяти для хранения значения какого-либо типа) и копированию в него содержимого присваиваемой переменной, этот случай назовем семантикой копирования . Таким образом, если при копировании действует семантика копирования, то переменные по обе стороны от знака "=" будут означать два независимых объекта с одинаковым содержанием. И здесь последующее изменение одной переменной никак не скажется на другой.

Присваивание в Python происходит следующим образом: если присваеваемый объект является экземпляром таких типов как числа или строки, то действует семантика копирования, если же в правой части стоит экземпляр класса, список, словарь или тьюпл, то действует семантика указателей. Пример:
a = 2; b = a; b = 3
print " семантика копирования: a=", a, "b=", b
a = ; b = a; b = 3
print " семантика указателей: a=", a, "b=", b
Результат :
семантика копирования: a= 2 b= 3
семантика указателей: a= b=

Для тех из вас, кто хочет знать в чем тут дело, я приведу другой взгляд на присваивание в Python. Если в таких языках как Basic, Pascal, C/C++ мы имели дело с переменными-"емкостями", и хранимыми в них константами (числовыми, символьными, строковыми - не суть важно), а операция присваивания означала "занесение" константы в присваиваемую переменную, то в Python мы уже должны работать с переменными-"именами" и именуемыми ими объектами. (Замечаете некоторую аналогию с языком Prolog?) Что же такое объект в Python? Это все то, чему можно дать имя: числа, строки, списки, словари, экземпляры классов (которые в Object Pascal и называются объектами), сами классы (!), функции, модули и т.д. Так вот, при присваивании переменной некоторого объекта, переменная становится его "именем", причем таких "имен" объект может иметь сколько угодно и все они никак не зависят друг от друга.

Теперь, объекты делятся на модифицируемые (мутируемые) и неизменные. Мутируемые - те, которые могут изменить свое "внутреннее содержание", например, списки, словари, экземпляры классов. А неизменные - такие как числа, тьюплы, строки (да, строки тоже; можно переменной присвоить новую строку, полученную из старой, но саму старую строку модифицировать не получится).

Так вот, если мы пишем a = ; b = a; b = 3 , Python это интерпретирует так:

  • дать объекту "список " имя a ;
  • дать этому объекту еще одно имя - b ;
  • модифицировать нулевой элемент объекта.

    • Вот и получилась "псевдо" семантика указателей.

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

    T = (1, 2, , "string") t = 6 # так нельзя del t # тоже ошибка t = 0 # допустимо, теперь третья компонента - список t = "S" # ошибка: строки не мутируемы

    5. Весьма оригинальным является то, как в Python группируются операторы. В Pascal для этого служат операторные скобки begin-end , в C, C++, Java - фигурные скобки {}, в Basic применяются закрывающие окончания конструкций языка (NEXT, WEND, END IF, END SUB).
    В языке Python все гораздо проще: выделение блока операторов осуществляется путем сдвига выделяемой группы на один или более пробелов или символов табуляции вправо относительно заголовка конструкции к которой и будет относиться данный блок. Например:

    if x > 0: print ‘ x > 0 ’ x = x - 8 else: print ‘ x <= 0 ’ x = 0 Тем самым, хороший стиль записи программ, к которому призывают преподаватели языков Pascal, C++, Java и т.д., здесь приобретается с самого начала, поскольку, по-другому просто не получится.

    Описание языка. Управляющие конструкции



    Обработка исключительных ситуаций


    try:
    <оператор1>
    [ except [<исключение> [, <переменная>] ]:
    <оператор2>]
    [ else <оператор3>]     		Выполняется <оператор1>, если при этом возникла исключительная ситуация <исключение>, то выполняется <оператор2>. Если <исключение> имеет значение, то оно присваивается <переменной>.
    В случае успешного завершения <оператора1>, выполняется <оператор3>.
    try:
    <оператор1>
    finally:
    <оператор2>
    		Выполняется <оператор1>. Если не возникло исключений, то выполняется <оператор2>. Иначе выполняется <оператор2> и немедленно инициируется исключительная ситуация.
    raise <исключение> [<значение>] Инициирует исключительную ситуацию <исключение> с параметром <значение>.

    Исключения - это просто строки (string). Пример:

    My_ex = ‘bad index’ try: if bad: raise my_ex, bad except my_ex, value: print ‘ Error ’, value

    Объявление функций



    Объявление классов



    Class cMyClass: def __init__(self, val): self.value = val # def printVal (self): print ‘ value = ’, self.value # # end cMyClass obj = cMyClass (3.14) obj.printVal () obj.value = " string now " obj.printVal () Результат:
    value = 3.14
    value = string now

    Операторы для всех типов последовательностей (списки, тьюплы, строки)


    Операторы для списков (list)


    s[i] = x i-тый элемент s заменяется на x.
    s = t часть элементов s от i до j-1 заменяется на t (t может быть также списком).
    del s удаляет часть s (также как и s = ).
    s.append (x) добавляет элемент x к концу s.
    s.count (x) возвращает количество элементов s равных x.
    s.index (x) возвращает наименьший i, такой, что s[i]==x.
    s.insert (i,j) часть s, начиная с i-го элемента, сдвигается вправо, и s[i] присваивается x.
    s.remove (x) то же, что и del s[ s.index(x) ] - удаляет первый элемент s, равный x.
    s.reverse () записывает строку в обратном порядке
    s.sort () сортирует список по возрастанию.

    Операторы для словарей (dictionary)


    Файловые объекты


    Создаются встроенной функцией open() (ее описание смотрите ниже). Например: f = open (‘mydan.dat’,‘r’) .
    Методы:

    Другие элементы языка и встроенные функции


    = присваивание.
    print [ < c1 > [, < c2 >]* [, ] ] выводит значения < c1 >, < c2 > в стандартный вывод. Ставит пробел между аргументами. Если запятая в конце перечня аргументов отсутствует, то осуществляет переход на новую строку.
    abs (x) возвращает абсолютное значение x.
    apply (f, <аргументы>) вызывает функцию (или метод) f с < аргументами >.
    chr (i) возвращает односимвольную строку с ASCII кодом i.
    cmp (x, y) возвращает отрицательное, ноль, или положительное значение, если, соответственно, x <, ==, или > чем y.
    divmod (a, b) возвращает тьюпл (a/b, a%b), где a/b - это a div b (целая часть результата деления), a%b - это a mod b (остаток от деления).
    eval (s)
    		возвращает объект, заданный в s как строка (string). S может содержать любую структуру языка. S также может быть кодовым объектом, например: x = 1 ; incr_x = eval ("x+1") .
    float (x) возвращает вещественное значение равное числу x.
    hex (x) возвращает строку, содержащую шестнадцатеричное представление числа x.
    input (<строка>) выводит <строку>, считывает и возвращает значение со стандартного ввода.
    int (x) возвращает целое значение числа x.
    len (s) возвращает длину (количество элементов) объекта.
    long (x) возвращает значение типа длинного целого числа x.
    max (s) , min (s) возвращают наибольший и наименьший из элементов последовательности s (т.е. s - строка, список или тьюпл).
    oct (x) возвращает строку, содержащую представление числа x.
    open (<имя файла>, <режим>=‘r’) возвращает файловый объект, открытый для чтения. <режим> = ‘w’ - открытие для записи.
    ord (c) возвращает ASCII код символа (строки длины 1) c.
    pow (x, y) возвращает значение x в степени y.
    range (<начало>, <конец>, <шаг>) возвращает список целых чисел, больших либо равных <начало> и меньших чем <конец>, сгенерированных с заданным <шагом>.
    raw_input ( [ <текст> ] ) выводит <текст> на стандартный вывод и считывает строку (string) со стандартного ввода.
    round (x, n=0) возвращает вещественное x, округленное до n-го разряда после запятой.
    str (<объект>) возвращает строковое представление <объекта>.
    type (<объект>) возвращает тип объекта.
    Например: if type(x) == type(‘’): print ‘ это строка ’
    xrange (<начало>, <конец>, <шаг>) аналогичен range, но лишь имитирует список, не создавая его. Используется в цикле for.

    Cпециальные функции для работы со списками


    filter (<функция>, <список>) возвращает список из тех элементов <спиcка>, для которых <функция> принимает значение "истина".
    map (<функция>, <список>) применяет <функцию> к каждому элементу <списка> и возвращает список результатов.
    reduce (f, <список>,
    [, <начальное значение> ] )     		возвращает значение полученное "редуцированием" <списка> функцией f. Это значит, что имеется некая внутренняя переменная p, которая инициализируется <начальным значением>, затем, для каждого элемента <списка>, вызывается функция f с двумя параметрами: p и элементом <списка>. Возвращаемый f результат присваивается p. После перебора всего <списка> reduce возвращает p.
    С помощью данной функции можно, к примеру, вычислить сумму элементов списка: def func (red, el): return red+el sum = reduce (func, , 0) # теперь sum == 15
    lambda [<список параметров>] : <выражение> "анонимная" функция, не имеющая своего имени и записываемая в месте своего вызова. Принимает параметры, заданные в <списке параметров>, и возвращает значение <выражения>. Используется для filter, reduce, map. Например: >>>print filter (lambda x: x>3, ) >>>print map (lambda x: x*2, ) >>>p=reduce (lambda r, x: r*x, , 1) >>>print p 24

    Импортирование модулей



    Стандартный модуль math


    Переменные: pi , e .
    Функции (аналогичны функциям языка C):

    acos(x) cosh(x) ldexp(x,y) sqrt(x)
    asin(x) exp(x) log(x) tan(x)
    atan(x) fabs(x) sinh(x) frexp(x)
    atan2(x,y) floor(x) pow(x,y) modf(x)
    ceil(x) fmod(x,y) sin(x)
    cos(x) log10(x) tanh(x)

    Модуль string


    Функции:

    Заключение


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

    Литература


    1. Бадд Т. Объектно-ориентированное программирование. - СПб.: Питер, 1997.
    2. Guido van Rossum . Python Tutorial. (www.python.org)
    3. Chris Hoffman . A Python Quick Reference. (www.python.org)
    4. Guido van Rossum . Python Library Reference. (www.python.org)
    5. Guido van Rossum . Python Reference Manual. (www.python.org)
    6. Гвидо ван Россум . Семинар по программированию на Python. (http://sultan.da.ru)

    В которой, в сжатой форме,
    рассказывают об основах языка Python. Я предлагаю вам перевод этой статьи. Перевод не дословный. Я постарался подробнее объяснить некоторые моменты, которые могут быть непонятны.

    Если вы собрались изучать язык Python, но не можете найти подходящего руководства, то эта
    статья вам очень пригодится! За короткое время, вы сможете познакомиться с
    основами языка Python. Хотя эта статья часто опирается
    на то, что вы уже имеете опыт программирования, но, я надеюсь, даже новичкам
    этот материал будет полезен. Внимательно прочитайте каждый параграф. В связи с
    сжатостью материала, некоторые темы рассмотрены поверхностно, но содержат весь
    необходимый метриал.

    Основные свойства

    Python не требует явного объявления переменных, является регистро-зависим (переменная var не эквивалентна переменной Var или VAR - это три разные переменные) объектно-ориентированным языком.

    Синтаксис

    Во первых стоит отметить интересную особенность Python. Он не содержит операторных скобок (begin..end в pascal или {..}в Си), вместо этого блоки выделяются отступами : пробелами или табуляцией, а вход в блок из операторов осуществляется двоеточием. Однострочные комментарии начинаются со знака фунта «#», многострочные - начинаются и заканчиваются тремя двойными кавычками «"""».
    Чтобы присвоить значение пременной используется знак «=», а для сравнения -
    «==». Для увеличения значения переменной, или добавления к строке используется оператор «+=», а для уменьшения - «-=». Все эти операции могут взаимодействовать с большинством типов, в том числе со строками. Например


    >>> myvar = 3
    >>> myvar += 2
    >>> myvar -= 1
    ""«Это многострочный комментарий
    Строки заключенные в три двойные кавычки игнорируются»""
    >>> mystring = «Hello»
    >>> mystring += " world."
    >>> print mystring
    Hello world.
    # Следующая строка меняет
    значения переменных местами. (Всего одна строка!)
    >>> myvar, mystring = mystring, myvar

    Структуры данных

    Python содержит такие структуры данных как списки (lists), кортежи (tuples) и словари (dictionaries ). Списки - похожи на одномерные массивы (но вы можете использовать Список включающий списки - многомерный массив), кортежи - неизменяемые списки, словари - тоже списки, но индексы могут быть любого типа, а не только числовыми. "Массивы" в Python могут содержать данные любого типа, то есть в одном массиве может могут находиться числовые, строковые и другие типы данных. Массивы начинаются с индекса 0, а последний элемент можно получить по индексу -1 Вы можете присваивать переменным функции и использовать их соответственно.


    >>> sample = , («a» , «tuple» )] #Список состоит из целого числа, другого списка и кортежа
    >>> #Этот список содержит строку, целое и дробное число
    >>> mylist = «List item 1 again» #Изменяем первый (нулевой) элемент листа mylist
    >>> mylist[-1 ] = 3 .14 #Изменяем последний элемент листа
    >>> mydict = {«Key 1» : «Value 1» , 2 : 3 , «pi» : 3 .14 } #Создаем словарь, с числовыми и целочисленным индексами
    >>> mydict[«pi» ] = 3 .15 #Изменяем элемент словаря под индексом «pi».
    >>> mytuple = (1 , 2 , 3 ) #Задаем кортеж
    >>> myfunction = len #Python позволяет таким образом объявлять синонимы функции
    >>> print myfunction(list )
    3

    Вы можете использовать часть массива, задавая первый и последний индекс через двоеточие «:». В таком случае вы получите часть массива, от первого индекса до второго не включительно. Если не указан первый элемент, то отсчет начинается с начала массива, а если не указан последний - то масив считывается до последнего элемента. Отрицательные значения определяют положение элемента с конца. Например:


    >>> mylist = [«List item 1» , 2 , 3 .14 ]
    >>> print mylist[:] #Считываются все элементы массива
    ["List item 1" , 2 , 3 .1400000000000001 ]
    >>> print mylist #Считываются нулевой и первый элемент массива.
    ["List item 1" , 2 ]
    >>> print mylist[-3 :-1 ] #Считываются элементы от нулевого (-3) до второго (-1) (не включительно)
    ["List item 1" , 2 ]
    >>> print mylist #Считываются элементы от первого, до последнего

    Строки

    Строки в Python обособляются кавычками двойными «"» или одинарными «"» . Внутри двойных ковычек могут присутствовать одинарные или наоборот. К примеру строка «Он сказал "привет"!» будет выведена на экран как «Он сказал "привет"!». Если нужно использовать строку из несколько строчек, то эту строку надо начинать и заканчивать тремя двойными кавычками «"""». Вы можете подставить в шаблон строки элементы из кортежа или словаря. Знак процента «%» между строкой и кортежем, заменяет в строке символы «%s» на элемент кортежа. Словари позволяют вставлять в строку элемент под заданным индексом. Для этого надо использовать в строке конструкцию «%(индекс)s». В этом случае вместо «%(индекс)s» будет подставлено значение словаря под заданным индексом.


    >>>print «Name: %s\nNumber: %s\nString: %s» % (myclass .name, 3 , 3 * "-" )
    Name: Poromenos
    Number: 3
    String: -
    strString = ""«Этот текст расположен
    на нескольких строках»""

    >>> print «This %(verb)s a %(noun)s.» % {«noun» : «test» , «verb» : «is» }
    This is a test.

    Операторы

    Операторы while, if , for составляют операторы перемещения. Здесь нет аналога оператора select, так что придется обходиться if . В операторе for происходит сравнение переменной и списка . Чтобы получить список цифр до числа - используйте функцию range(). Вот пример использования операторов


    rangelist = range (10 ) #Получаем список из десяти цифр (от 0 до 9)
    >>> print rangelist
    for number in rangelist: #Пока переменная number (которая каждый раз увеличивается на единицу) входит в список…
    # Проверяем входит ли переменная
    # numbers в кортеж чисел (3 , 4 , 7 , 9 )
    if number in (3 , 4 , 7 , 9 ): #Если переменная number входит в кортеж (3, 4, 7, 9)...
    # Операция «break » обеспечивает
    # выход из цикла в любой момент
    break
    else :
    # «continue » осуществляет «прокрутку»
    # цикла. Здесь это не требуется, так как после этой операции
    # в любом случае программа переходит опять к обработке цикла
    continue
    else :
    # «else » указывать необязательно. Условие выполняется
    # если цикл не был прерван при помощи «break ».
    pass # Ничего не делать

    if rangelist == 2 :
    print «The second item (lists are 0-based) is 2»
    elif rangelist == 3 :
    print «The second item (lists are 0-based) is 3»
    else :
    print «Dunno»

    while rangelist == 1 :
    pass

    Функции

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


    # arg2 и arg3 - необязательые аргументы, принимают значение объявленное по умолчни,
    # если не задать им другое значение при вызове функци.
    def myfunction(arg1, arg2 = 100 , arg3 = «test» ):
    return arg3, arg2, arg1
    #Функция вызывается со значением первого аргумента - "Argument 1", второго - по умолчанию, и третьего - "Named argument" .
    >>>ret1, ret2, ret3 = myfunction(«Argument 1» , arg3 = «Named argument» )
    # ret1, ret2 и ret3 принимают значения "Named argument", 100, "Argument 1" соответственно
    >>> print ret1, ret2, ret3
    Named argument 100 Argument 1

    # Следующая запись эквивалентна def f(x): return x + 1
    functionvar = lambda x: x + 1
    >>> print functionvar(1 )
    2

    Классы

    Язык Python ограничен в множественном наследовании в классах. Внутренние переменные и внутренние методы классов начинаются с двух знаков нижнего подчеркивания «__» (например «__myprivatevar»). Мы можем также присвоить значение переменной класса извне. Пример:


    class Myclass :
    common = 10
    def __init__(self ):
    self .myvariable = 3
    def myfunction(self , arg1, arg2):
    return self .myvariable

    # Здесь мы объявили класс Myclass . Функция __init__ вызывается автоматически при инициализации классов.
    >>> classinstance = Myclass () # Мы инициализировали класс и переменная myvariable приобрела значение 3 как заявлено в методе инициализации
    >>> #Метод myfunction класса Myclass возвращает значение переменной myvariable
    3
    # Переменная common объявлена во всех классах
    >>> classinstance2 = Myclass ()
    >>> classinstance.common
    10
    >>> classinstance2.common
    10
    # Поэтому, если мы изменим ее значение в классе Myclass изменятся
    # и ее значения в объектах, инициализированных классом Myclass
    >>> Myclass.common = 30
    >>> classinstance.common
    30
    >>> classinstance2.common
    30
    # А здесь мы не изменяем переменную класса. Вместо этого
    # мы объявляем оную в объекте и присваиваем ей новое значение
    >>> classinstance.common = 10
    >>> classinstance.common
    10
    >>> classinstance2.common
    30
    >>> Myclass.common = 50
    # Теперь изменение переменной класса не коснется
    # переменных объектов этого класса
    >>> classinstance.common
    10
    >>> classinstance2.common
    50

    # Следующий класс является наследником класса Myclass
    # наследуя его свойства и методы, ктому же класс может
    # наследоваться из нескольких классов, в этом случае запись
    # такая: class Otherclass(Myclass1, Myclass2, MyclassN)
    class Otherclass(Myclass):
    def __init__(self , arg1):
    self .myvariable = 3
    print arg1

    >>> classinstance = Otherclass(«hello» )
    hello
    >>> classinstance.myfunction(1 , 2 )
    3
    # Этот класс не имеет совйтсва test, но мы можем
    # объявить такую переменную для объекта. Причем
    # tэта переменная будет членом только class instance.
    >>> classinstance.test = 10
    >>> classinstance.test
    10

    Исключения

    Исключения в Python имеют структуру try -except [except ionname]:


    def somefunction():
    try :
    # Деление на ноль вызывает ошибку
    10 / 0
    except ZeroDivisionError :
    # Но программа не "Выполняет недопустимую операцию"
    # А обрабатывает блок исключения соответствующий ошибке «ZeroDivisionError»
    print «Oops, invalid.»

    >>> fnexcept ()
    Oops, invalid.

    Импорт

    Внешние библиотеки можно подключить процедурой «import », где - название подключаемой библиотеки. Вы так же можете использовать команду «from import », чтобы вы могли использовать функцию из библиотеки


    import random #Импортируем библиотеку «random»
    from time import clock #И заодно функцию «clock» из библиотеки «time»

    Randomint = random .randint(1 , 100 )
    >>> print randomint
    64

    Работа с файловой системой

    Python имеет много встроенных библиотек. В этом примере мы попробуем сохранить в бинарном файле структуру списка, прочитать ее и сохраним строку в текстовом файле. Для преобразования структуры данных мы будем использовать стандартную библиотеку «pickle»


    import pickle
    mylist = [«This» , «is» , 4 , 13327 ]
    # Откроем файл C:\binary.dat для записи. Символ «r»
    # предотвращает замену специальных сиволов (таких как \n, \t, \b и др.).
    myfile = file (r«C:\binary.dat» , «w» )
    pickle .dump(mylist, myfile)
    myfile.close()

    Myfile = file (r«C:\text.txt» , «w» )
    myfile.write(«This is a sample string» )
    myfile.close()

    Myfile = file (r«C:\text.txt» )
    >>> print myfile.read()
    "This is a sample string"
    myfile.close()

    # Открываем файл для чтения
    myfile = file (r«C:\binary.dat» )
    loadedlist = pickle .load(myfile)
    myfile.close()
    >>> print loadedlist
    ["This" , "is" , 4 , 13327 ]

    Особенности

    • Условия могут комбинироваться. 1 < a < 3 выполняется тогда, когда а больше 1, но меньше 3.
    • Используйте операцию «del » чтобы очищать переменные или элементы массива .
    • Python предлагает большие возможности для работы со списками . Вы можете использовать операторы объявлении структуры списка. Оператор for позволяет задавать элементы списка в определенной последовательности, а if - позволяет выбирать элементы по условию.
    >>> lst1 =
    >>> lst2 =
    >>> print
    >>> print
    # Оператор «any» возвращает true, если хотя
    # бы одно из условий, входящих в него, выполняется.
    >>> any(i % 3 for i in )
    True
    # Следующая процедура подсчитывает количество
    # подходящих элементов в списке
    >>> sum (1 for i in if i == 3 )
    3
    >>> del lst1
    >>> print lst1
    >>> del lst1
    • Глобальные переменные объявляются вне функций и могут быть прочитанны без каких либо объявлений. Но если вам необходимо изменить значение глобальной переменной из функции, то вам необходимо объявить ее в начале функции ключевым словом «global », если вы этого не сделаете, то Python объявит переменную, доступную только для этой функции.
    number = 5

    def myfunc():
    # Выводит 5
    print number

    def anotherfunc():
    # Это вызывает исключение, поскольку глобальная апеременная
    # не была вызванна из функции. Python в этом случае создает
    # одноименную переменную внутри этой функции и доступную
    # только для операторов этой функции.
    print number
    number = 3

    def yetanotherfunc():
    global number
    # И только из этой функции значение переменной изменяется.
    number = 3

    Эпилог

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

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

    • Скорость выполнения программ написанных на Python очень высока. Это связанно с тем, что основные библиотеки Python
      написаны на C++ и выполнение задач занимает меньше времени, чем на других языках высокого уровня.
    • В связи с этим вы можете писать свои собственные модули для Python на C или C++
    • В стандартныx библиотеках Python вы можете найти средства для работы с электронной почтой, протоколами
      Интернета, FTP, HTTP, базами данных, и пр.
    • Скрипты, написанные при помощи Python выполняются на большинстве современных ОС. Такая переносимость обеспечивает Python применение в самых различных областях.
    • Python подходит для любых решений в области программирования, будь то офисные программы, вэб-приложения, GUI-приложения и т.д.
    • Над разработкой Python трудились тысячи энтузиастов со всего мира. Поддержкой современных технологий в стандартных библиотеках мы можем быть обязаны именно тому, что Python был открыт для всех желающих.

    Теги: Добавить метки

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

    Python для начинающих. Глава первая. «О чем это мы»

    На всякий случай, немного скучного «evangelism». Кому он надоел, можно пропустить несколько абзацев.
    Python (читается как «Пайтон» а не «питон») - скриптовый язык, разработанный Гвидо ван Россумом в качестве простого языка, легкого в изучении новичку.
    В наше время Пайтон – широко распространенный язык, который используется во многих областях:
    - Разработка прикладного ПО (например linux-утилиты yum, pirut, system-config-*, IM-клиент Gajim и многие другие)
    - Разработка web-приложений (мощнейший Application-сервер Zope и разработанная на его основе CMS Plone, на основе которой работает например сайт ЦРУ, и масса фреймворков для быстрой разработки приложений Plones, Django, TurboGears и многие другие)
    - Использование в качестве встраиваемого скриптового языка во многих играх, и не только (в офисном пакете OpenOffice.org, 3d редакторе Blender, СУБД Postgre)
    - Использование в научных рассчетах (с пакетами SciPy и numPy для расчетов и PyPlot для рисования графиков Пайтон становится практически сравним с пакетами типа MatLab)

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

    1. Сам интерпретатор, его можно взять тут (http://python.org/download/).
    2. Среда разработки. Она для начала необязательна, да и идущий в дистрибутиве IDLE подойдет новичку, но для серъезных проектов нужно что-то посерьезней.
    Для Windows я использую замечательный легковесный PyScripter (http://tinyurl.com/5jc63t), для Linux – Komodo IDE.

    Хотя для первого урока достаточно будет просто интерактивной оболочки самого Пайтона.

    Просто запустите python.exe. Приглашение ввода не заставит себя долго ждать, оно выглядит так:

    Также можно записывать программы в файлы с расширением py, в вашем любимом текстовом редакторе, который не добавляет к тексту своих символов разметки (нет Word не подойдет). Также желательно чтобы этот редактор умел делать «умные табуляторы» и не заменял пробелы знаком табуляции.
    Для запуска файлов на исполнение по ним можно щелкать 2 раза. Если консольное окно закрывается слишком быстро, вставьте в конце программы следующую строку:

    Тогда интерпретатор будет в конце программы ждать нажатия enter.

    Или ассоциируйте py-файлы в Far с Пайтоном и открывайте нажимая enter.

    Наконец можно воспользоваться одной из многих удобных IDE для Пайтона, которые предоставляют и возможности отладки и подсветку синтаксиса и многие другие «удобства».

    Немного теории.

    Для начала, Пайтон – язык со строгой динамической типизацией. Что это означает?

    Есть языки со строгой типизацией (pascal, java, c и т.п.), у которых тип переменной определяется заранее и не может быть изменен, и есть языки с динамической типизацией (python, ruby, vb), в которых тип переменной трактуется в зависимости от присвоенного значения.
    Языки с динамической типизацией можно разделить еще на 2 вида. Строгие, которые не допускают неявного преобразования типа (Пайтон) и нестрогие, которые выполняют неявные преобразования типа (например VB, в котором можно легко сложить строку "123" и число 456).
    Разобравшись с классификацией Пайтона, попробуем немного «поиграть» с интерпретатором.

    >>> a = b = 1 >>> a, b (1, 1) >>> b = 2 >>> a, b (1, 2) >>> a, b = b, a >>> a, b (2, 1)

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

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

    Условие задается с помощью оператора if, который заканчивается «:». Альтернативные условия которые будут выполняться если первая проверка «не прошла» задаются оператором elif. Наконец else задает ветку, которая будет выполнена если ни одно из условий не подошло.
    Обратите внимание, что после ввода if интерпретатор с помощью приглашения «...» показывает что он ожидает продолжения ввода. Чтобы сообщить ему что мы закончили, необходимо ввести пустую строку.

    (Пример с ветвлениями почему-то рвет разметку на хабре, не смотря на танцы с тегами pre и code. Простите за неудобство, я его кинул сюда pastebin.com/f66af97ba , если кто-то подскажет что не так - буду очень признателен)

    Циклы.

    Простейшим случаем цикла является цикл while. В качестве параметра он принимает условие и выполняется до тех пор, пока оно истино.
    Вот маленький пример.

    >>> x = 0 >>> while x<=10: ... print x ... x += 1 ... 0 1 2 ........... 10

    Обратите внимание что поскольку и print x и x+=1 написаны с одинаковым отступом, они считаются телом цикла (помните что я говорил про блоки? ;-)).

    Второй вид циклов в Пайтон – цикл for. Он аналогичен циклу foreach других языков. Его синтаксис условно таков.

    For переменная in список:
    команды

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

    Вот простой пример. В роли списка будет выступать строка, которая является ничем иным как списком символов.

    >>> x = "Hello, Python!" >>> for char in x: ... print char ... H e l ........... !

    Таким образом мы можем разложить строку по символам.
    Что же делать если нам нужен цикл, повторяющийся определенное число раз? Очень просто, на помощь придет функция range.

    На входе она принимает от одного до трех параметров, на выходе возвращает список чисел, по которому мы можем «пройтись» оператором for.

    Вот несколько примеров использования функции range, которые объясняют роль ее параметров.

    >>> range(10) >>> range(2, 12) >>> range(2, 12, 3) >>> range(12, 2, -2)

    И маленький пример с циклом.

    >>> for x in range(10): ... print x ... 0 1 2 ..... 9

    Ввод-вывод

    Последнее, что следует знать перед тем как начать использовать Пайтон полноценно – это как осуществляется в нем ввод-вывод.

    Для вывода используется команда print, которая выводит на печать все свои аргументы в удобочитаемом виде.

    Для ввода с консоли используется функция raw_input(приглашение), которая выводит на экран приглашение и ожидает ввода пользователя, возвращая то что ввел пользователь в виде своего значения.

    X = int(raw_input ("Введи число:")) print "Квадрат этого числа составляет ", x * x

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

    Вот и все для первого урока.

    Домашнее задание.

    1. Составить программу расчета гипотенузы прямоугольного треугольника. Длина катетов запрашивается у пользователя.
    2. Составить программу нахождения корней квадратного уравнения в общем виде. Коэффициенты запрашиваются у пользователя.
    3. Составить программу вывода таблицы умножения на число M. Таблица составляется от M * a, до M * b, где M, a, b запрашиваются у пользователя. Вывод должен осуществляется в столбик, по одному примеру на строку в следующем виде (например):
    5 х 4 = 20
    5 х 5 = 25
    И так далее.