В которой, в сжатой форме,
рассказывают об основах языка 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 во многом похож на синтаксис таких языков, как Perl, C и Java, но вместе с этим имеет ряд отличий от этих языков программирования. В этой статье мы рассмотрим необходимые основы этого языка программирования .
Во-первых, следует отметить, что на Python вы можете программировать в двух режимах: интерактивном и скриптовом
Без передачи в качестве аргумента названия файла запустит интерпретатор Python :
Введите следующий текст после строки приглашения Python и нажмите Enter:
>>> print "Hello, Python!"
Если вы все сделали правильно, то интерпретатор выдаст строку:
Если вы получили ошибку - удостоверьтесь, что правильно переписали код и что используете интерпретатор версии 2.х (для версии 3.х следует использовать команду print ("Hello, Python"))
Запуск в командной строке python с названием файла (он еще называется скрипт) в качестве параметра, начнет выполнение кода, записанного в данном файле. После завершения выполнения скрипта, интерпретатор будет снова неактивен.
Давайте, создадим простую программу-скрипт на Python . Откройте любой текстовый редактор (Sublime, Notepad++, gedit...), создайте в нем файл с именем test и расширением.py (все файлы, содержащие код на Python должны иметь расширение .py ) и запишите в этот файл уже знакомый нам код и сохраните файл:
Print "Hello, Python!"
(Предполагается, что интерпретатор Python у вас задан в переменной PATH, то есть вы находясь в любой директории можете ввести python для запуска интерпретатора)
После этого введите следующую строку в командной строке и нажмите Enter:
Идентификаторы в Python это имена используемые для обозначения переменной, функции, класса, модуля или другого объекта. Идентификатор должен начинаться с буквы (от a до Z) или со знака подчеркивания (_), после которых может идти произвольное количество букв, знаков подчеркивания и чисел (от 0 до 9).
В Python недопустимо использование знаков препинания или специальных символов, таких как @, $ или % в качестве идентификаторов. Кроме того, Python чуствителен к регистру, то есть cat и Cat это два разных имени.
В Python существует следующая договоренность для названия идентификаторов:
В данной таблице собраны все ключевые слова Python .
| and | elif | if | |
| as | else | import | raise |
| assert | except | in | return |
| break | exec | is | try |
| class | finally | lambda | while |
| continue | for | not | which |
| def | from | or | yield |
| del | global | pass |
Эти зарезервированные слова нельзя использовать в качестве имени переменной или любого другого идентификатора. Все ключевые слова Python состоят только из букв в нижнем регистре. Получить список ключевых слов возможно в интерпретаторе командой
Help("keywords")
Одна из первых особенностей Python , которая бросается в глаза программистам, начинающим изучать этот язык программирования, это то, что в нем не используются скобки для обозначения отдельных блоков кода. Вместо них в Python используются двоеточия и отступы.
Количество пробелов в отступах произвольно и выбирается каждым на свое усмотрение, однако по договоренности равняется четырем пробелам. При этом отступ всего блока должен быть одинаковым.
Например, этот блок кода будет работать (хотя так писать не стоит):
If True: print "Hi" else: print "Bye"
А этот уже вызовет ошибку:
If True: print "Hi" print "Bye"
Таким образом, в Python несколько строк кода с одинаковым отступом будут формировать отдельный блок кода. Благодаря такой системе значительно повышается читаемость кода и прививается привычка писать понятно и структурировано.
Выражения в Python , как правило, заканчиваются новой строкой. Однако, в этом языке программирования существует специальный символ переноса строки (\), показывающий, что с окончанием строки не заканчивается код. Например:
Total = item1 + \ item2 + \ item3
Выражения, которые находятся внутри скобок: квадратных (), фигурных ({ }) или круглых (()) не нуждаются в символе переноса строки. Например:
Days = ["Sunday", "Monday", "Tuesday", "Wednesday", "Thursday", "Friday", "Saturday"]
В Python можно использовать одинарные ("), двойные (") и тройные (""" или """) кавычки чтобы обозначить строчный тип данных, при этом начинаться и заканчиваться строка должна одинаковыми кавычками. Строка занимающая несколько строк кода должна быть обрамлена тройными кавычками. Например:
Name = "wasd" description = "Some text" biography = """ Some long text for few lines of code """
Синтаксис языка Python, как и сам язык, очень прост.
Конец строки является концом инструкции (точка с запятой не требуется).
Вложенные инструкции объединяются в блоки по величине отступов. Отступ может быть любым, главное, чтобы в пределах одного вложенного блока отступ был одинаков. И про читаемость кода не забывайте. Отступ в 1 пробел, к примеру, не лучшее решение. Используйте 4 пробела (или знак табуляции, на худой конец).
Вложенные инструкции в Python записываются в соответствии с одним и тем же шаблоном, когда основная инструкция завершается двоеточием, вслед за которым располагается вложенный блок кода, обычно с отступом под строкой основной инструкции.
Основная инструкция : Вложенный блок инструкцийИногда возможно записать несколько инструкций в одной строке, разделяя их точкой с запятой:
a = 1 ; b = 2 ; print (a , b )Но не делайте это слишком часто! Помните об удобочитаемости. А лучше вообще так не делайте.
Допустимо записывать одну инструкцию в нескольких строках. Достаточно ее заключить в пару круглых, квадратных или фигурных скобок:
if (a == 1 and b == 2 and c == 3 and d == 4 ): # Не забываем про двоеточие print ("spam" * 3 )Тело составной инструкции может располагаться в той же строке, что и тело основной, если тело составной инструкции не содержит составных инструкций. Ну я думаю, вы поняли:). Давайте лучше пример приведу.
В приведенных далее примерах, ввод и вывод различаются присутствием и отсутствием приглашений соответственно (приглашениями являются >>> и...): чтобы воспроизвести пример - вам нужно ввести всё, что следует за приглашением, после его появления; строки, не начинающиеся с приглашений являются выводом интерпретатора. Обратите внимание, что строка, в которой содержится лишь вспомогательное приглашение (" ... ") означает, что вам нужно ввести пустую строку - этот способ используется для завершения многострочных команд.
Большинство примеров в этом руководстве - даже те, которые вводятся в интерактивном режиме - содержат комментарии. Комментарии в Python начинаются с символа решетки # (hash) - и продолжаются до физического конца строки. Комментарии могут находиться как в начале строки, так и следовать за пробельными символами или кодом - но не содержаться внутри строки. Символ решётки в строке остаётся лишь символом решётки. Поскольку комментарии предназначены для того, чтобы сделать код более понятным, и не интерпретируются Python - при вводе примеров они могут быть опущены.
Несколько примеров:
# это первый комментарий SPAM = 1 # а это второй комментарий # ... и наконец третий! STRING = "# Это не комментарий."
Давайте опробуем несколько простых команд Python. Запустите интерпретатор и дождитесь появления основного приглашения - >>> . (Это не должно занять много времени.)
Поведение интерпретатора сходно поведению калькулятора: вы вводите выражение, а в ответ он выводит значение. Синтаксис выражений привычен: операции + , - , * и / работают также как и в большинстве других языков (например, Паскале или C); для группировки можно использовать скобки. Например:
>>> 2 +2 4 >>> # Это комментарий ... 2 +2 4 >>> 2 +2 # а вот комментарий на одной строке с кодом 4 >>> (50 -5 * 6 ) /4 5.0 >>> 8 /5 # При делении целых чисел дробные части не теряются 1.6000000000000001
Заметьте : Вы можете получить результат, несколько отличный от представленного: результаты деления с плавающей запятой могут различаться на разных системах. Позже мы расскажем о том, как контролировать вывод чисел с плавающей запятой. Здесь использован наиболее информативный вариант вывода этого значения, а не более легко-читаемый, какой возможен:
>>> print (8 /5 ) 1.6
Чтобы учебник читался легче, мы будем показывать упрощённый вывод чисел с плавающей точкой и объясним позже, почему эти два способа отображения чисел с плавающей точкой стали различными. Обратитесь к приложению Арифметика с плавающей точкой: Проблемы и ограничения , чтобы ознакомится с подробным обсуждением.
Для получения целого результата при делении целых чисел, отсекая дробные результаты, предназначена другая операция: // :
>>> # Деление целых чисел возвращает округлённое к минимальному значение: ... 7 //3 2 >>> 7 //-3 -3
Знак равенства ("=") используется для присваивания переменной какого-либо значения. После этого действия в интерактивном режиме ничего не выводится:
>>> width = 20 >>> height = 5 * 9 >>> width * height 900
Значение может быть присвоено нескольким переменным одновременно:
>>> x = y = z = 0 # Нулевые x, y и z >>> x 0 >>> y 0 >>> z 0
Переменные должны быть определены (defined) (должны иметь присвоенное значение) перед использованием, иначе будет сгенерирована ошибка:
>>>
# попытка получить доступ к неопределённой переменной
... n
Traceback (most recent call last)
:
File "
Присутствует полная поддержка операций с плавающей точкой; операции над операндами смешанного типа конвертируют целочисленный операнд в число с плавающей запятой:
>>> 3 * 3.75 / 1.5 7.5 >>> 7.0 / 2 3.5
Поддерживаются и комплексные числа, добавлением к мнимым частям суффикса j или J . Комплексные числа с ненулевым вещественным компонентом записываются в виде (<вещественная_часть> +<мнимая_часть> j) , или могут быть созданы с помощью функции complex(<вещественная_часть> , <мнимая_часть> ) .
>>> 1j * 1J (-1+0j) >>> 1j * complex (0 , 1 ) (-1 +0j) >>> 3 +1j* 3 (3 +3j) >>> (3 +1j) * 3 (9 +3j) >>> (1 +2j) /(1 +1j) (1.5 +0.5j)
Комплексные числа всегда представлены в виде двух чисел с плавающей запятой - вещественной и мнимой частями. Для получения этих частей из комплексного числа z используется z.real и z.imag соответственно.
>>> a=1.5 +0.5j >>> a.real 1.5 >>> a.imag 0.5
Функции конвертации (приведения) к вещественным и целым числам (float() , int()) не работают с комплексными числами, так как нет единственно правильного способа сконвертировать комплексное число в вещественное. Используйте функцию abs(z) чтобы получить модуль числа (в виде числа с плавающей точкой) или z.real чтобы получить его вещественную часть:
>>>
a=3.0+4.0j
>>>
float
(a)
Traceback (most recent call last)
:
File "
В интерактивном режиме последнее выведенное выражение сохраняется в переменной _ . Это значит, что если вы используете Python в качестве настольного калькулятора - всегда есть способ продолжить вычисления с меньшими усилиями, например:
>>> tax = 12.5 / 100 >>> price = 100.50 >>> price * tax 12.5625 >>> price + _ 113.0625 >>> round (_, 2 ) 113.06 >>>
Эта переменная для пользователя должна иметь статус только для чтения . Не навязывайте ей значение собственноручно - вы создадите независимую переменную с таким же именем, скрывающую встроенную переменную вместе с её магическими свойствами.
Помимо чисел, Python может работать со строками, которые, в свою очередь, могут быть описаны различными способами. Строки могут быть заключены в одинарные или двойные кавычки:
>>> "spam eggs" "spam eggs" >>> "doesn\" t" "doesn"t" >>> "doesn"t" "doesn"t" >>> ""Yes," he said." ""Yes," he said." >>> "\" Yes,\" he said." ""Yes," he said." >>> ""Isn\" t," she said." ""Isn\" t," she said."
Интерпретатор выводит результаты операций над строками тем же способом, каким они были введены: обрамляя в кавычки, и, кроме того, экранируя обратными слэшами внутренние кавычки и другие забавные символы - для того, чтобы отобразить точное значение. Строка заключается в двойные кавычки, если строка содержит одинарные кавычки и ни одной двойной, иначе она заключается в одинарные кавычки. Повторимся, функция print() предоставляет более читаемый вывод.
Строковые литералы могут быть разнесены на несколько строк различными способами. Могут быть использованы продолжающие строки , с обратным слэшем в качестве последнего символа строки, сообщающим о том, что следующая строка есть продолжение текущей:
Hello = "This is a rather long string containing\n \ several lines of text just as you would do in C.\n \ Note that whitespace at the beginning of the line is\ significant." print (hello)
Обратите внимание, что новые строки все ещё нужно подключать в строку через \n ; новая строка, за которой следут обратный слэш - не обрабатывается. Запуск примера выведет следующее:
This is a rather long string containing several lines of text just as you would do in C. Note that whitespace at the beginning of the line is significant.
Если мы объявим строковой литерал сырым (raw) - символы \n не будут конвертированы в новые строки, но и обратный слэш в конце строки, и символ новой строки в исходном коде - будут добавлены в строку в виде данных. Следовательно, код из примера:
Hello = r"This is a rather long string containing\n \ several lines of text much as you would do in C." print (hello)
This is a rather long string containing\n\ several lines of text much as you would do in C.
Или, строки могут быть обрамлены совпадающей парой тройных кавычек: """ или """ . Окончания строк не нужно завершать тройными кавычками - при этом будут включены в строку.
Print (""" Usage: thingy -h Display this usage message -H hostname Hostname to connect to """ )
выводит в результате следующее:
Usage: thingy -h Display this usage message -H hostname Hostname to connect to
Строки могут конкатенироваться (склеиваться вместе) операцией + и быть повторенными операцией * :
>>>
word = "Help"
+ "A"
>>>
word
"HelpA"
>>>
"<"
+ word*
5
+ ">"
"
Два строковых литерала, расположенные друг за другом, автоматически конкатенируются; первая строка в предыдущем примере также могла быть записана как word = "Help" "A" ; это работает только с двумя литералами - не с произвольными выражениями, содержащими строки.
>>>
"str"
"ing"
# <- Так - верно
"string"
>>>
"str"
.strip
()
+ "ing"
# <- Так - верно
"string"
>>>
"str"
.strip
()
"ing"
# <- Так - не верно
File "
Строки могут быть проиндексированы; также как и в C, первый символ строки имеет индекс 0 . Отсутствует отдельный тип для символов; символ является строкой с единичной длиной. Как и в языке программирования Icon, подстроки могут определены через нотацию срезов (slice): два индекса, разделенных двоеточием.
>>> word[ 4 ] "A" >>> word[ 0 :2 ] "He" >>> word[ 2 :4 ] "lp"
Индексы срезов имеют полезные значения по умолчанию; опущенный первый индекс заменяется нулём, опущенный второй индекс подменяется размером срезаемой строки.
>>> word[ :2 ] # Первые два символа "He" >>> word[ 2 :] # Всё, исключая первые два символа "lpA"
В отличие от строк в C, строки Python не могут быть изменены. Присваивание по позиции индекса строки вызывает ошибку:
>>>
word[
0
]
= "x"
Traceback (most recent call last)
:
File "
Тем не менее, создание новой строки со смешанным содержимым - процесс легкий и очевидный:
>>> "x" + word[ 1 :] "xelpA" >>> "Splat" + word[ 4 ] "SplatA"
Полезный инвариант операции среза: s[:i] + s эквивалентно s .
>>> word[ :2 ] + word[ 2 :] "HelpA" >>> word[ :3 ] + word[ 3 :] "HelpA"
Вырождения индексов срезов обрабатываются элегантно: чересчур большой индекс заменяется на размер строки, а верхняя граница меньшая нижней возвращает пустую строку.
>>> word[ 1 :100 ] "elpA" >>> word[ 10 :] "" >>> word[ 2 :1 ] ""
Индексы могут быть отрицательными числами, обозначая при этом отсчет справа налево. Например:
>>> word[ -1 ] # Последний символ "A" >>> word[ -2 ] # Предпоследний символ "p" >>> word[ -2 :] # Последние два символа "pA" >>> word[ :-2 ] # Всё, кроме последних двух символов "Hel"
Но обратите внимание, что -0 действительно эквивалентен 0 - это не отсчет справа.
>>> word[ -0 ] # (поскольку -0 равен 0) "H"
Отрицательные индексы вне диапазона обрезаются, но не советуем делать это с одно-элементными индексами (не-срезами ):
>>>
word[
-100
:]
"HelpA"
>>>
word[
-10
]
# ошибка
Traceback (most recent call last)
:
File "
Один из способов запомнить, как работают срезы - думать о них, как об указателях на места между символами, где левый край первого символа установлен в ноль, а правый край последнего символа строки из n символов имеет индекс n , например:
+---+---+---+---+---+ | H | e | l | p | A | +---+---+---+---+---+ 0 1 2 3 4 5 -5 -4 -3 -2 -1
Первый ряд чисел дает позицию индексов строки от 0 до 5; второй ряд описывает соответствующие отрицательные индексы. Срез от i до j состоит из всех символов между правым и левым краями, отмеченными, соответственно, через i и j .
Для всех индексов, больших или равных нулю, длина среза - разность между индексами, при условии что оба индекса находятся в диапазоне. Например, длина word - 2.
Встроенная функция len() возвращает длину строки:
>>> s = "supercalifragilisticexpialidocious" >>> len (s) 34
| Смотрите также : Перечисляемые типы Строки - вид перечисляемых типов и они поддерживают привычные для этих типов операции. Строковые методы Строки поддерживают большое количество методов для поиска и простых трансформаций. Форматирование строк Здесь описано форматирование строк с применением функции str.format() Операции форматирования строк в старом стиле Операции форматирования, вызывающиеся тогда, когда обычные строки или строки в Unicode оказываются левым операндом относительно операции % , более детально рассмотрены здесь. |
Начиная с Python версии 3.0, строковый тип поддерживает только Unicode (см. http://www.unicode.org/).
Преимущество набора Unicode состоит в том, что он предоставляет порядковый номер для любого символа из любой письменности, использовавшейся в современных или древнейших текстах. До этих пор для символов в сценарии было доступно лишь 256 номеров. Тексты обычно привязывались к кодовой странице, которая устанавливала в соответствие порядковые номера и символы сценария. Это приводило к серьезной путанице, особенно в том, что касалось интернационализации программного продукта. Unicode решает эти проблемы, определяя единую кодовую страницу для всех письменностей.
Для вставки в строку специального символа можно использовать Unicode-экранирование (Python Unicode-Escape encoding). Следующий пример всё пояснит:
>>> "Hello\u 0020World !" "Hello World !"
Экранированная последовательность \u0020 задаёт символ Unicode с порядковым номером 0x0020 (символ пробела).
Другие символы интерпретируются с использованием соответствующих им порядковых значений тем же способом, что и порядковые номера Unicode. Первые 128 символов кодировки Unicode полностью совпадают с 128 символами кодировки Latin-1 , использующейся во многих западных странах.
Помимо стандартных способов кодирования, Python предоставляет целый набор различных способов создания Unicode-строк, основываясь на известной кодировке.
Для конвертирования Unicode-строки в последовательность байтов с использованием желаемой кодировки, строковые объекты предоставляют метод encode() , принимающий единственный параметр - название кодировки. Предпочитаются названия кодировок, записанные в нижнем регистре.
>>> "Äpfel" .encode ("utf-8" ) b"\x c3\x 84pfel"
В языке Python доступно некоторое количество составных типов данных, использующихся для группировки прочих значений вместе. Наиболее гибкий из них - список (list). Его можно выразить в тексте программы через разделённые запятыми значения (элементы ), заключённые в квадратные скобки. Элементы списка могут быть разных типов.
>>> a = [ "spam" , "eggs" , 100 , 1234 ] >>> a [ "spam" , "eggs" , 100 , 1234 ]
Подобно индексам в строках, индексы списков начинаются с нуля, списки могут быть срезаны, объединены (конкатенированы ) и так далее:
>>> a[ 0 ] "spam" >>> a[ 3 ] 1234 >>> a[ -2 ] 100 >>> a[ 1 :-1 ] [ "eggs" , 100 ] >>> a[ :2 ] + [ "bacon" , 2 * 2 ] [ "spam" , "eggs" , "bacon" , 4 ] >>> 3 * a[ :3 ] + [ "Boo!" ] [ "spam" , "eggs" , 100 , "spam" , "eggs" , 100 , "spam" , "eggs" , 100 , "Boo!" ]
В отличие от строк, являющихся неизменяемыми, изменить индивидуальные элементы списка вполне возможно:
>>> a [ "spam" , "eggs" , 100 , 1234 ] >>> a[ 2 ] = a[ 2 ] + 23 >>> a [ "spam" , "eggs" , 123 , 1234 ]
Присваивание срезу также возможно, и это действие может даже изменить размер списка или полностью его очистить:123 , "bletch" , "xyzzy" , 1234 ] >>> # Вставим (копию) самого себя в начало >>> a[ :0 ] = a >>> a [ 123 , "bletch" , "xyzzy" , 1234 , 123 , "bletch" , "xyzzy" , 1234 ] >>> # Очистка списка: замена всех значений пустым списком >>> a[ :] = >>> a
Встроенная функция len() также применима к спискам:
>>> a = [ "a" , "b" , "c" , "d" 1 ] .append ("xtra" ) >>> p [ 1 , [ 2 , 3 , "xtra" ] , 4 ] >>> q [ 2 , 3 , "xtra" ]
Обратите внимание, что в последнем примере p и q на самом деле ссылаются на один и тот же объект! Мы вернёмся к семантике объектов позже.
Безусловно, Python можно использовать для более сложных задач, чем сложение двух чисел. Например, мы можем вывести начало последовательности чисел Фибоначчи таким образом:
>>> # Ряд Фибоначчи: ... # сумма двух элементов определяет следущий элемент ... a , b = 0, 1 >>> while b < 10: ... print (b) ... a , b = b, a+b ... 1 1 2 3 5 8
Этот пример показывает нам некоторые новые возможности.
В которой, в сжатой форме,
рассказывают об основах языка 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. Я надеюсь что эта статья поможет вам, если вы захотите и в дальнейшем изучать этот язык программирования.
Теги: Добавить метки
