Все ранее рассматриваемые программы имели линейную структуру: все инструкции выполнялись последовательно одна за одной, каждая записанная инструкция обязательно выполняется.
Допустим мы хотим по данному числу x определить его абсолютную величину (модуль). Программа должна напечатать значение переменной x, если x>0 или же величину -x в противном случае. Линейная структура программы нарушается: в зависимости от справедливости условия x>0 должна быть выведена одна или другая величина. Соответствующий фрагмент программы на Питоне имеет вид:
273 x = int(input()) if x > 0: print(x) else: print(-x)
В этой программе используется условная инструкция if (если). После слова if указывается проверяемое условие (x > 0) , завершающееся двоеточием. После этого идет блок (последовательность) инструкций, который будет выполнен, если условие истинно, в нашем примере это вывод на экран величины x . Затем идет слово else (иначе), также завершающееся двоеточием, и блок инструкций, который будет выполнен, если проверяемое условие неверно, в данном случае будет выведено значение -x .
Итак, условная инструкция в Питоне имеет следующий синтаксис:
If Условие: Блок инструкций 1 else: Блок инструкций 2
Блок инструкций 1 будет выполнен, если Условие истинно. Если Условие ложно, будет выполнен Блок инструкций 2 .
В условной инструкции может отсутствовать слово else и последующий блок. Такая инструкция называется неполным ветвлением. Например, если дано число x и мы хотим заменить его на абсолютную величину x , то это можно сделать следующим образом:
273 x = int(input()) if x < 0: x = -x print(x)
В этом примере переменной x будет присвоено значение -x , но только в том случае, когда x<0 . А вот инструкция print(x) будет выполнена всегда, независимо от проверяемого условия.
Для выделения блока инструкций, относящихся к инструкции if или else в языке Питон используются отступы. Все инструкции, которые относятся к одному блоку, должны иметь равную величину отступа, то есть одинаковое число пробелов в начале строки. Рекомендуется использовать отступ в 4 пробела и не рекомедуется использовать в качестве отступа символ табуляции.
Это одно из существенных отличий синтаксиса Питона от синтаксиса большинства языков, в которых блоки выделяются специальными словами, например, нц... кц в Кумире, begin... end в Паскале или фигурными скобками в Си.
Внутри условных инструкций можно использовать любые инструкции языка Питон, в том числе и условную инструкцию. Получаем вложенное ветвление - после одной развилки в ходе исполнения программы появляется другая развилка. При этом вложенные блоки имеют больший размер отступа (например, 8 пробелов). Покажем это на примере программы, которая по данным ненулевым числам x и y определяет, в какой из четвертей координатной плоскости находится точка (x,y):
2 -3 x = int(input()) y = int(input()) if x > 0: if y > 0: # x > 0, y > 0 print("Первая четверть") else: # x > 0, y < 0 print("Четвертая четверть") else: if y > 0: # x < 0, y > 0 print("Вторая четверть") else: # x < 0, y < 0 print("Третья четверть")
В этом примере мы использовали комментарии - текст, который интерпретатор игнорирует. Комментариями в Питоне является символ # и весь текст после этого символа до конца строки.
Как правило, в качестве проверяемого условия используется результат вычисления
одного из следующих операторов сравнения:
< Меньше — условие верно, если первый операнд меньше второго.
> Больше — условие верно, если первый операнд больше второго.
<= Меньше или равно.
>= Больше или равно.
== Равенство. Условие верно, если два операнда равны.
!= Неравенство. Условие верно, если два операнда неравны.
Например, условие (x * x < 1000) означает “значение x * x меньше 1000”, а условие (2 * x != y) означает “удвоенное значение переменной x не равно значению переменной y ”.
Операторы сравнения в Питоне можно объединять в цепочки (в отличии от большинства других языков программирования, где для этого нужно использовать логические связки), например, a == b == c или 1 <= x <= 10 .
Операторы сравнения возвращают значения специального логического типа bool . Значения логического типа могут принимать одно из двух значений: True (истина) или False (ложь). Если преобразовать логическое True к типу int , то получится 1, а преобразование False даст 0. При обратном преобразовании число 0 преобразуется в False , а любое ненулевое число в True . При преобразовании str в bool пустая строка преобразовывается в False , а любая непустая строка в True .
Иногда нужно проверить одновременно не одно, а несколько условий. Например, проверить, является ли данное число четным можно при помощи условия (n % 2 == 0) (остаток от деления n на 2 равен 0), а если необходимо проверить, что два данных целых числа n и m являются четными, необходимо проверить справедливость обоих условий: n % 2 == 0 и m % 2 == 0 , для чего их необходимо объединить при помощи оператора and (логическое И): n % 2 == 0 and m % 2 == 0 .
В Питоне существуют стандартные логические операторы: логическое И, логическое ИЛИ, логическое отрицание.
Логическое И является бинарным оператором (то есть оператором с двумя операндами: левым и правым) и имеет вид and . Оператор and возвращает True тогда и только тогда, когда оба его операнда имеют значение True .
Логическое ИЛИ является бинарным оператором и возвращает True тогда и только тогда, когда хотя бы один операнд равен True . Оператор “логическое ИЛИ” имеет вид or .
Логическое НЕ (отрицание) является унарным (то есть с одним операндом) оператором и имеет вид not , за которым следует единственный операнд. Логическое НЕ возвращает True , если операнд равен False и наоборот.
Пример. Проверим, что хотя бы одно из чисел a или b оканчивается на 0:
15 40 a = int(input()) b = int(input()) if a % 10 == 0 or b % 10 == 0: print("YES") else: print("NO")
Проверим, что число a — положительное, а b — неотрицательное:
If a > 0 and not (b < 0):
Или можно вместо not (b < 0) записать (b >= 0) .
Пример программы, определяющий четверть координатной плоскости, можно переписать используя “каскадную“ последовательность операцией if... elif... else:
5 7 x = int(input()) y = int(input()) if x > 0 and y > 0: print("Первая четверть") elif x > 0 and y < 0: print("Четвертая четверть") elif y > 0: print("Вторая четверть") else: print("Третья четверть")
В такой конструкции условия if , ..., elif проверяются по очереди, выполняется блок, соответствующий первому из истинных условий. Если все проверяемые условия ложны, то выполняется блок else , если он присутствует.
Python
- мощный и простой для изучения язык программирования. В нём предоставлены удобные высокоуровневые структуры данных и простой, но эффективный подход к объектно-ориентированному программированию. Python
интерпретируемый язык. Для запуска написанных программ требуется наличие интерпретатора CPython . Интерпретатор python и большая стандартная библиотека находятся в свободном доступе в виде исходных и бинарных файлов для всех основных платформ на официальном сайте Python
http://www.python.org и могут распространяться без ограничений. Кроме этого на сайте содержатся дистрибутивы и ссылки на многочисленные модули третьих сторон и подробная документация.
Язык обладает чётким и последовательным синтаксисом, продуманной модульностью и масштабируемостью, благодаря чему исходный код написанных на Python
программ легко читаем. Разработчики языка Python
придерживаются определённой философии программирования, называемой «The Zen of Python». Её текст выдаётся интерпретатором по команде import this:
В переводе это звучит так:
Python - активно развивающийся язык программирования, новые версии выходят примерно раз в два с половиной года. Вследствие этого и некоторых других причин на Python отсутствуют стандарт ANSI, ISO или другие официальные стандарты, их роль выполняет CPython.
Разработка языка Python была начата в конце 1980-х годов сотрудником голландского института CWI . Распределённой ОС Amoeba требовался расширяемый скриптовый язык для которой Гвидо ван Россум и создал Python. Новый язык позаимствовал некоторые наработки для языка ABC, который был ориентирован на обучение программированию. В феврале 1991 года Гвидо опубликовал исходный текст в ньюсгруппе alt.sources. Название языка произошло не от вида пресмыкающихся. Автор назвал язык в честь популярного британского комедийного телешоу 1970-х «Летающий цирк Монти Пайтона». Тем не менее эмблему языка изображают змеиные головы. После длительного тестирования, вышла первая версия Python 3.0. На сегодня поддерживаются обе ветви развития (Python 3.x и 2.x).
Python создавался под влиянием множества языков программирования: Modula-3, С, C++, Smalltalk, Lisp, Fortran, Java, Miranda, Icon. Несмотря на то, что Python обладает достаточно самобытным синтаксисом, одним из принципов дизайна этого языка является принцип наименьшего удивления.
Богатая стандартная библиотека является одной из привлекательных сторон Python. Здесь имеются средства для работы со многими сетевыми протоколами и форматами Интернета. Существуют модули для работы с регулярными выражениями, текстовыми кодировками, мультимедийными форматами, криптографическими протоколами, архивами. Помимо стандартной библиотеки существует множество библиотек, предоставляющих интерфейс ко всем системным вызовам на разных платформах.
Для Python принята спецификация программного интерфейса к базам данных DB-API 2 и разработаны соответствующие этой спецификации пакеты для доступа к различным СУБД: Oracle, MySQL, PostgreSQL, Sybase, Firebird (Interbase), Informix, Microsoft SQL Server и SQLite.
Библиотека NumPy для работы с многомерными массивами позволяет достичь производительности научных расчётов, сравнимой со специализированными пакетами. SciPy использует NumPy и предоставляет доступ к обширному спектру математических алгоритмов. Numarray специально разработан для операций с большими объёмами научных данных.
Python предоставляет простой и удобный программный интерфейс Си API для написания собственных модулей на языках Си и C++. Такой инструмент как SWIG позволяет почти автоматически получать привязки для использования C/C++ библиотек в коде на Python. Инструмент стандартной библиотеки ctypes позволяет программам Python напрямую обращаться к динамическим библиотекам, написанным на Си. Существуют модули, позволяющие встраивать код на С/C++ прямо в исходные файлы Python, создавая расширения «на лету».
Python и подавляющее большинство библиотек к нему бесплатны и поставляются в исходных кодах. Более того, в отличие от многих открытых систем, лицензия никак не ограничивает использование Python в коммерческих разработках и не налагает никаких обязательств кроме указания авторских прав.
Python - стабильный и распространённый язык. Он используется во многих проектах и в различных качествах: как основной язык программирования или для создания расширений и интеграции приложений. На Python реализовано большое количество проектов, также он активно используется для создания прототипов будущих программ. Python используется во многих крупных компаниях.
Python с пакетами NumPy, SciPy и MatPlotLib активно используется как универсальная среда для научных расчётов в качестве замены распространенным специализированным коммерческим пакетам Matlab, IDL и др.
В профессиональных программах трехмерной графики, таких как Houdini и Nuke, Python используется для расширения стандартных возможностей программ.
Подготовить сообщения:
Python является широко используемым, высокоуровневым языком программирования, который был назван в честь знаменитого британского комедийного телешоу «Летающий цирк Монти Пайтона ». Язык Python простой по своей структуре, и в то же время невероятно гибкий и мощный. Учитывая, что код Python легко читаемый и без излишней строгости в синтаксисе, многие считают, что он является лучшим вводным языком программирования.
Python — описание языка, которое дали в Foundation описывает Python :
Python – это интерпретируемый, интерактивный, объектно-ориентированный язык программирования. Он включает в себя модули, исключения, динамическую типизацию, высокоуровневые динамические типы данных и классы. Python сочетает в себе отличную производительность с понятным синтаксисом. В нем реализованы интерфейсы ко многим системным вызовам и библиотекам, а также различным оконным системам и он расширяем с помощью C и C++. Python используется как язык расширения для приложений, которым нужен программный интерфейс. И наконец, Python — это кроссплатформенный язык: он работает на многих версиях Unix, на Mac и на компьютерах под управлением MS-DOS, Windows, Windows NT и OS/2.
Можно начать изучение с Python языка программирования. Чтобы проиллюстрировать, чем Python отличается от других вводных языков, вспомните время, когда вы были подростком.
Изучение программирования с помощью Python подобно вождению родительского минивэна. Как только вы сделаете на нем несколько кругов по парковке, вы начнете понимать, как управлять автомобилем.
Пытаться изучить программирование с помощью C (или даже ассемблера ) это как, учиться водить, собирая минивэн ваших родителей. Вы застрянете в гараже на несколько лет, компонуя части вместе, и когда у вас появится полное понимание того, как работает машина, и будете способны выявлять неисправности и прогнозировать будущие проблемы, вы уже перегорите, прежде чем когда-либо сядете за руль.
Язык Python для начинающих универсален. Вы можете автоматизировать рабочие процессы, создавать сайты, а также настольные приложения и игры с помощью Python . К слову, спрос на разработчиков Python (PostgreSQL, OOP, Flask, Django ) резко вырос за последние несколько лет в таких компаниях, как Instagram , Reddit , Tumblr , YouTube и Pinterest .
Python относится к высокоуровневым языкам программирования. Используя его, вы сможете создавать практически любые типы программного обеспечения. Эта универсальность поддерживает ваш интерес, так как вы разрабатываете программы и решения, ориентированные на ваши интересы, а не застреваете в дебрях языка, беспокоясь о его синтаксисе.
Язык программирования Python для начинающих является интерпретируемым, а это значит, что вам не нужно знать, как компилировать код. Поскольку этап компиляции отсутствует, возрастает производительность, а время для редактирования, тестирования и отладки в значительной мере уменьшается. Просто скачайте интегрированную среду разработки (IDE ), напишите свой код и нажмите «Выполнить » (Run ).
Простой, легкий в изучении синтаксис Python делает упор на читаемость и задает хороший стиль программирования. С Python вы можете выразить свою концепцию меньшим количеством строк кода. Этот язык также заставляет вас обдумывать логику программы и алгоритмы. В связи с этим он часто используется как скриптовый или интегрирующий язык (glue language ), чтобы связать существующие компоненты вместе и писать большие объемы легко читаемого и работоспособного кода в короткие промежутки времени.
Нельзя назвать язык программирования в честь Монти Пайтона , не имея чувства юмора. Более того, было проведено тестирование для сравнения времени, необходимого для написания простого скрипта на различных языках (Python, Java, C, J, BASIC ):
…Python требует меньше времени, меньше строк кода и меньше концептов, чтобы достичь поставленной цели… И в довершение всего, программирование на Python это весело! Веселье и частый успех порождает уверенность и интерес у студентов, которые становятся лучше подготовленными к дальнейшему изучению языка Python.
Перевод статьи «Why Learn Python? » был подготовлен дружной командой проекта .
Хорошо Плохо
В которой, в сжатой форме,
рассказывают об основах языка 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
происходит сравнение переменной и списка
. Чтобы получить список цифр до числа
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 ]
>>> lst1 =
>>> lst2 =
# Оператор «any» возвращает true, если хотя
# бы одно из условий, входящих в него, выполняется.
>>> any(i % 3 for i in )
True
# Следующая процедура подсчитывает количество
# подходящих элементов в списке
>>> sum (1 for i in if i == 3 )
3
>>> del lst1
>>> print lst1
>>> del lst1
number = 5def myfunc():
# Выводит 5
print numberdef anotherfunc():
# Это вызывает исключение, поскольку глобальная апеременная
# не была вызванна из функции. Python в этом случае создает
# одноименную переменную внутри этой функции и доступную
# только для операторов этой функции.
print number
number = 3def yetanotherfunc():
global number
# И только из этой функции значение переменной изменяется.
number = 3
Разумеется в этой статье не описываются все возможности Python. Я надеюсь что эта статья поможет вам, если вы захотите и в дальнейшем изучать этот язык программирования.
Теги:
Введение
В связи с наблюдаемым в настоящее время стремительным развитием персональной вычислительной техники, происходит постепенное изменение требований, предъявляемых к языкам программирования. Все большую роль начинают играть интерпретируемые языки, поскольку возрастающая мощь персональных компьютеров начинает обеспечивать достаточную скорость выполнения интерпретируемых программ. А единственным существенным преимуществом компилируемых языков программирования является создаваемый ими высокоскоростной код. Когда скорость выполнения программы не является критичной величиной, наиболее правильным выбором будет интерпретируемый язык, как более простой и гибкий инструмент программирования.
В связи с этим, определенный интерес представляет рассмотрение сравнительно
нового языка программирования Python (пайтон), который был создан его автором Гвидо
ван Россумом (Guido van Rossum) в начале 90-х годов.
Общие сведения о Python. Достоинства и недостатки
Python является интерпретируемым, изначально объектно-ориентированным языком программирования. Он чрезвычайно прост и содержит небольшое число ключевых слов, вместе с тем очень гибок и выразителен. Это язык более высокого уровня нежели Pascal, C++ и, естественно C, что достигается, в основном, за счет встроенных высокоуровневых структур данных (списки, словари, тьюплы).
Достоинства языка.
Несомненным достоинством является то, что интерпретатор Python
реализован практически на всех платформах и операционных системах. Первым
таким языком был C, однако его типы данных на разных машинах могли занимать разное
количество памяти и это служило некоторым препятствием при написании действительно
переносимой программы. Python же таким недостатком не обладает.
Следующая немаловажная черта - расширяемость языка, этому придается большое значение и, как пишет сам автор, язык был задуман именно как расширяемый. Это означает, что имеется возможность совершенствования языка всеми всеми заинтересованными программистами. Интерпретатор написан на С и исходный код доступен для любых манипуляций. В случае необходимости, можно вставить его в свою программу и использовать как встроенную оболочку. Или же, написав на C свои дополнения к Python и скомпилировав программу, получить "расширенный" интерпретатор с новыми возможностями.
Следующее достоинство - наличие большого числа подключаемых к программе модулей, обеспечивающих различные дополнительные возможности. Такие модули пишутся на С и на самом Python и могут быть разработаны всеми достаточно квалифицированными программистами. В качестве примера можно привести следующие модули:
Обзор особенностей
1. Python, в отличие от многих языков (Pascal,
C++, Java, и т.д.), не требует описания переменных. Они создаются в месте
их инициализации, т.е. при первом присваивании переменной какого-либо значения.
Значит, тип переменной определяется типом присваиваемого значения. В этом
отношении Python напоминает Basic.
Тип переменной не является неизменным. Любое присваивание для нее корректно
и это приводит лишь к тому, что типом переменной становится тип нового
присваиваемого значения.
2. В таких языках как Pascal, C, C++ организация списков представляла некоторые трудности. Для их реализации приходилось хорошо изучать принципы работы с указателями и динамической памятью. И даже имея хорошую квалификацию, программист, каждый раз заново реализуя механизмы создания, работы и уничтожения списков, мог легко допустить трудноуловимые ошибки. Ввиду этого были созданы некоторые средства для работы со списками. Например, в Delphi Pascal имеется класс TList, реализующий списки; для С++ разработана библиотека STL (Standard Template Library), содержащая такие структуры как векторы, списки, множества, словари, стеки и очереди. Однако, такие средства имеются не во всех языках и их реализациях.
Одной из отличительных черт Python является наличие таких встроенных в сам язык структур как тьюплы (tuple), списки (list) и словари (dictionary), которые иногда называют картами (map). Рассмотрим их поподробней.
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 это интерпретирует так:
И последнее, что стоит сказать насчет этого: хотя нет возможности изменения структуры тьюпла, но содержащиеся в нем мутируемые компоненты по-прежнему доступны для модификации:
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 все гораздо проще: выделение блока операторов осуществляется
путем сдвига выделяемой группы на один или более пробелов или символов
табуляции вправо относительно заголовка конструкции к которой и будет относиться
данный блок. Например:
Описание языка. Управляющие конструкции
Обработка исключительных ситуаций
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 хорошо зарекомендовал себя при разработке программ работы с графами,
генерации деревьев.
Литература