Как в python

Операторы и выражения¶

Большинство предложений (логических строк) в программах содержат выражения. Простой пример выражения: 2 + 3 . Выражение можно разделить на операторы и операнды.

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

Операторы¶

Кратко рассмотрим операторы и их применение:

Обратите внимание, вычислить значения выражений, данных в примерах, можно также используя интерпретатор интерактивно. Например, для проверки выражения 2 + 3 воспользуйтесь интерактивной командной строкой интерпретатора Python:

>>> 2 + 3 5 >>> 3 * 5 15

Операторы и их применение

Можно составлять произвольные цепочки сравнений: 3 < 5 < 7 даёт True .

Краткая запись мат. операций и присваивания¶

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

Вы можете записать:

a = 2; a = a * 3

a = 2; a *= 3

Обратите внимание, что выражения вида “ переменная = переменная операция выражение ” принимает вид “ переменная операция = выражение ”.

Порядок вычисления¶

Если имеется выражение вида 2 + 3 * 4 , что производится раньше: сложение или умножение? Школьный курс математики говорит нам, что умножение должно производиться в первую очередь. Это означает, что оператор умножения имеет более высокий приоритет, чем оператор сложения.

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

Эта таблица взята из Справочника по языку Python (англ.) и приводится здесь для полноты описания. На практике лучше использовать скобки для группировки операторов и операндов, чтобы в явном виде указать порядок вычисления выражений. Заодно это облегчит чтение программы. Более подробно см. в разделе Изменение порядка вычисления ниже.

Приоритет операторов

Оператор	Описание
lambda	лямбда-выражение
or	Логическое “ИЛИ”
and	Логическое “И”
not x	Логическое “НЕ”
in , not in	Проверка принадлежности
is , is not	Проверка тождественности
< , , >= , != , ==	Сравнения
\|	Побитовое “ИЛИ”
^	Побитовое “ИСКЛЮЧИТЕЛЬНО ИЛИ”
&	Побитовое “И”
>	Сдвиги
+ , —	Сложение и вычитание
* , / , // , %	Умножение, деление, целочисленное деление и остаток от деления
+x , -x	Положительное, отрицательное
~x	Побитовое НЕ
**	Возведение в степень
x.attribute	Ссылка на атрибут
x[индекс]	Обращение по индексу
x[индекс1:индекс2]	Вырезка
f(аргументы . )	Вызов функции
(выражения, . )	Связка или кортеж [2]
[выражения, . ]	Список
	Словарь

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

В этой таблице операторы с равным приоритетом расположены в одной строке. Например, + и — имеют равный приоритет.

Изменение порядка вычисления¶

Для облегчения чтения выражений можно использовать скобки. Например, 2 + (3 * 4) определённо легче понять, чем 2 + 3 * 4 , которое требует знания приоритета операторов. Как и всё остальное, скобки нужно использовать разумно (не перестарайтесь) и избегать излишних, как в (2 + (3 * 4)) .

Есть ещё одно преимущество в использовании скобок – они дают возможность изменить порядок вычисления выражений. Например, если сложение необходимо произвести прежде умножения, можно записать нечто вроде (2 + 3) * 4 .

Ассоциативность¶

Операторы обычно обрабатываются слева направо. Это означает, что операторы с равным приоритетом будут обработаны по порядку от левого до правого. Например, 2 + 3 + 4 обрабатывается как (2 + 3) + 4 .

Выражения¶

Пример (сохраните как expression.py ):

length = 5 breadth = 2 area = length * breadth print('Площадь равна', area) print('Периметр равен', 2 * (length + breadth))

Вывод:

$ python expression.py Площадь равна 10 Периметр равен 14

Как это работает:

Длина и ширина прямоугольника хранятся в переменных length и breadth соответственно. Мы используем их для вычисления периметра и площади прямоугольника при помощи выражений. Результат выражения length * breadth сохраняется в переменной area , после чего выводится на экран функцией print . Во втором случае мы напрямую подставляем значение выражения 2 * (length + breadth) в функцию print .

Также обратите внимание, как Python “красиво печатает” результат. Несмотря на то, что мы не указали пробела между ‘Площадь равна’ и переменной area , Python подставляет его за нас, чтобы получить красивый и понятный вывод. Программа же остаётся при этом легкочитаемой (поскольку нам не нужно заботиться о пробелах между строками, которые мы выводим). Это пример того, как Python облегчает жизнь программисту.

Резюме¶

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

Примечания¶

[1]	“True” — англ. “Верно (Правда)”; “False” — англ. “Ошибочно (Ложь)”. (прим. перев.)

[2]	“tuple” — англ. “кортеж” (прим. перев.)

Функции в Python для начинающих

В этой части мы изучим функции — составные инструкции, которые могут принимать данные ввода, выполнять указания и возвращать данные вывода. Функции позволяют определять и повторно использовать определенную функциональность в компактной форме.

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

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

f(x) = x * 2

Левая часть определяет функцию f , принимающую один параметр, x . А правая часть — это определение функции, которое использует переданный параметр x , чтобы произвести вычисление и вернуть результат. В этом случае значением функции является ее параметр, умноженный на два.

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

def имя_функции(параметры): определениие_функции

Математическая функция f(x) = x * 2 в Python будет выглядеть вот так:

def f(x):
 return x * 2

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

Как только вы присвоили своей функции имя, укажите после него круглые скобки. Внутри скобок должен содержаться один или несколько параметров.

После скобок ставится двоеточие, а новая строка начинается с отступа в четыре пробела. Любой код с отступом в четыре пробела после двоеточия является телом функции. В этом случае тело нашей функции состоит только из одной строки:

return x * 2

Ключевое слово return используется для определения значения, которое функция возвращает при вызове.

Чтобы вызвать функцию в Python, мы используем синтаксис имя_функции(параметры, через, запятую) .

Ниже описан вызов функции f из предыдущего примера с параметром 2 .

Консоль ничего не вывела. Можно сохранить вывод вашей функции в переменной и передать ее функции print .

# Продолжение
# предыдущего примера
def f(x):
 return x * 2
result = f(2)
print(result) # 4

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

def f(x):
 return x + 1
 z = f(4)
if z == 5:
 print("z равно 5")
else:
 print ("z не равно 5")

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

def f():
 return 1 + 1
 result = f()
print(result) # 2

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

def f(x, y, z):
 return x + y + z
 result = f(1, 2, 3)
print(result) # 6

Наконец, функция не обязана содержать инструкцию return. Если функции нечего возвращать, она возвращает значение None .

def f():
 z = 1 + 1
result = f()
print(result) # None

Обязательные и необязательные параметры ¶

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

В Python есть и другой вид параметров — опциональные. Опциональные параметры определяются с помощью следующего синтаксиса: имя_функции(имя_параметра = значение_параметра) . Как и обязательные, опциональные параметры нужно отделять запятыми. Ниже приведен пример функции, в коде которой используется опциональный параметр.

def f(x=2):
 return x**x
 print (f()) # 4
print (f(4)) # 16

Сначала функция вызывается без передачи параметра. Так как параметр необязательный, x автоматически становится равен 2 , и функция возвращает 4 .

Затем та же функция вызывается с параметром 4 . То есть x будет равен 4 и функция вернет 16 . Вы можете определить функцию, которая принимает как обязательные, так и опциональные параметры, но обязательные нужно определять в первую очередь.

def add(x, y=10):
 return x + y
result = add(2)
print(result)

Хотите выучить Python на практике?

Строки и функция print в Python

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

«Строка Python.»

‘Строка Python.’

Это позволяет использовать внутренние кавычки в строках. «Язык программирования ‘Python’ «. Рассмотрим операции со строками.

Содержание страницы:
1. Функция print()
2. Табуляция и разрыв строк
3. Изменение регистра символов в строках
4. F-строки. Форматирование строк
5. Удаление пропусков
6. Комментарии

1. Функция print() в Python .

Встроенная функция print() выводит свой аргумент в строке текста.

>>> print( ‘Hello world!’ )
Hello world!
>>> print( «Hello world!» )
Hello world
>>> print( «Hello», ‘world!’ )
Hello world

В каждом случае аргументом является строка Hello world! Кроме того, print() не выводит кавычки, в которые заключена строка. Строка может быть заключена как в одинарные так и в двойные кавычки. В третьем случае, функция print() , получила список аргументов «Hello» и ‘world’, разделенных запятыми. Каждый аргумент выводится, отделяясь от следующего пробелом. В итоге во всех трех случаях получается один и тот же результат.

2. Табуляция и разрыв строк в Python.

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

В таблице приведены наиболее часто встречаемые комбинации символов.

Для добавления в текст табуляции используется комбинация символов \t . Разрыв строки добавляется с помощью комбинации символов \n .

>>> print(«Python»)
Python
>>> print(» \t Python»)
Python
>>> print(«Языки программирования: \n Python \n Java \n C»)
Языки программирования:
Python
Java
C

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

>>> print(«Языки программирования: \n\t Python \n\t Java \n\t C»)
Языки программирования:
Python
Java
C

3. Изменение регистра символов в строках в Python.

Одной из частых операций, выполняемых со строками — это изменение регистра символов. Например, у нас есть переменная name, в которой сохранена строка «Hello world!». Для преобразования символов к верхнему или нижнему регистру существует несколько методов.

>>> name = «Hello world!»
>>> print(name. title() )
Hello World!
>>> print(name. upper() )
HELLO WORLD!
>>> print(name. lower() )
hello world!

В первом случае за именем переменной в команде print() следует вызов метода title() . Метод — это действие, которое Python выполняет с данными. Точка после name приказывает Python применить метод title() к переменной name. За именем метода всегда следует пара круглых скобок () . Методам для выполнения их работы часто требуется дополнительные данные, и они указываются в скобках. В данный момент дополнительная информация не нужна, поэтому в скобках ничего нет. Метод title() преобразует первый символ каждого слова к верхнему регистру, остальные символы выводятся, как и были. Во втором случае используется метод upper() , в котором все символы преобразовываются к верхнему регистру. В третьем случае в методе lower() идет преобразование всех символов к нижнему регистру.

Метод lower() очень часто используется для хранения данных. Редко при вводе данных все пользователи вводят данные с точным соблюдением регистра. После ввода все данные преобразуются к нижнему регистру и уже затем выводится информация с использованием регистра, наиболее подходящего.

4. F-строки. Форматирование строк в Python.

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

Для того чтобы вставить значение переменных в строку, нужно поставить букву f непосредственно перед открывающейся кавычкой. Заключить имя или имена переменных в фигурные скобки <> .

Python заменить каждую переменную на ее значение при выводе строки.

>>> name = «Александр»
>>> surname = «Пушкин»
>>> full_name = f» »
>>> print(full_name)
Александр Пушкин

Буква f происходит от слова format, потому что Python форматирует строку, заменяя имена переменных в фигурных скобках на их значения. В итоге выводится строка имя и фамилия.

Если в переменной имя и фамилия записана с маленькой буквы, то на помощь придет метод title() . Так же с помощью f строк можно строить сообщения, которые затем сохраняются в переменной.

>>> name = «александр»
>>> surname = «пушкин»
>>> full_name = f» »
>>> print( f» Русский поэт ! » )
Русский поэт Александр Пушкин!
>>> message = f» Мой любимый поэт »
>>> print(message)
Мой любимый поэт Александр Пушкин

Важно: F-строки впервые появились в Python3.6. Если вы используете более раннею версию, используйте метод format. Что бы использовать метод format(), перечислите переменные в круглых скобках после format.

full_name = «<> <>«.format(name, surname)

5. Удаление пропусков в Python.

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

Удаление пропусков в Python

метод	описание
rstrip()	удаляет пропуск у правого края
lstrip()	удаляет пропуск у правого края
strip()	удаляет пропуски с обоих концов

Python может искать лишние пропуски у правого и левого края строки, так же может удалить с обоих концов строки.

>>> language. rstrip ()
‘ python’
>>> language. lstrip ()
‘python ‘
>>> language. strip ()
‘python’
>>> language
‘ python ‘

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

>>> language = ‘ python ‘
>>> language
‘ python ‘
>>> language = language. strip ()
>>> language
‘python’

Сначала пропуски удаляются методом strip() и потом записываются в исходную переменную.

6. Комментарии в Python.

В Python признаком комментария является символ «решетка» ( # ). Интерпретатор Python игнорирует все символы, следующие в коде после # до конца строки.

>>> print(‘Hello Python’)
Hello Python
>>> # print(‘Hello Python’)

Основная задача комментария — объяснить, как работает ваш код и что он делает. В процессе работы над проектом вы понимаете, как работают все компоненты, но если вы вернетесь к этому проекту спустя месяц или годы, то придется заново разбираться. Так же при совместной разработке с другими программистами без комментариев вам не обойтись. Рекомендуется сразу писать комментарии в процессе разработки. Удалить комментарии намного проще, чем возвращаться и добавлять комментарии в программу.

Неформальное введение в Python

В приведенных далее примерах, ввод и вывод различаются присутствием и отсутствием приглашений соответственно (приглашениями являются >>> и . ): чтобы воспроизвести пример — вам нужно ввести всё, что следует за приглашением, после его появления; строки, не начинающиеся с приглашений являются выводом интерпретатора. Обратите внимание, что строка, в которой содержится лишь вспомогательное приглашение («. ») означает, что вам нужно ввести пустую строку — этот способ используется для завершения многострочных команд.

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

# это первый комментарий spam = 1 # а это второй комментарий # . а сейчас третий! text = "# Это не комментарий, потому что он внутри кавычек."

Использование Python в качестве калькулятора

Давайте опробуем несколько простых команд Python. Запустите интерпретатор и дождитесь появления основного приглашения — >>> . (Это не должно занять много времени).

Числа

Поведение интерпретатора сходно поведению калькулятора: вы вводите выражение, а в ответ он выводит значение. Синтаксис выражений привычен: операции + , — , * и / работают также как и в большинстве других языков (например, Паскале или C); для группировки можно использовать скобки ( () ). Например:

>>> 2 + 2 4 >>> 50 - 5*6 20 >>> (50 - 5*6) / 4 5.0 >>> 8 / 5 # деление всегда возвращает число с плавающей точкой 1.6

Целые числа (например, 2 , 4 , 20 ) имеют тип int, те, что с дробной частью, (e.g. 5.0 , 1.6 ) имеют тип float. Мы узнаем больше о числовых типах далее в руководстве.

Деление ( / ) всегда возвращает float. Чтобы сделать целочисленное деление (отметая дробную часть) вы можете использовать оператор // ; чтобы посчитать остаток от деления, вы можете использовать % :

>>> 17 / 3 # классическое деление возвращает float 5.666666666666667 >>> >>> 17 // 3 # floor division discards the fractional part 5 >>> 17 % 3 # the % operator returns the remainder of the division 2 >>> 5 * 3 + 2 # result * divisor + remainder 17

С помощью Python можно использовать оператор ** для возведения в степень [1]:

>>> 5 ** 2 # 5 squared 25 >>> 2 ** 7 # 2 to the power of 7 128

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

>>> width = 20 >>> height = 5 * 9 >>> width * height 900

Если переменная не «определена» (ей не присвоено значение), то попытка использовать ее выдаст ошибку:

>>> n # try to access an undefined variable Traceback (most recent call last): File "", line 1, in NameError: name 'n' is not defined

Присутствует полная поддержка операций с плавающей точкой; операции над операндами смешанного типа конвертируют целочисленный операнд в число с плавающей запятой:

>>> 3 * 3.75 / 1.5 7.5 >>> 7.0 / 2 3.5

В интерактивном режиме последнее распечатанное выражение присваивается переменной _ . Это означает, что когда вы используете Python как калькулятор, то так проще продолжить расчеты, например:

>>> tax = 12.5 / 100 >>> price = 100.50 >>> price * tax 12.5625 >>> price + _ 113.0625 >>> round(_, 2) 113.06

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

В дополнении к int и float Python поддерживает другие типы чисел, такие как Decimal и Fraction. Python также имеет встроенную поддержку для комплексных чисел, и использует суффикс j или J для указания мнимой части (например, 3+5j ).

Строки

Помимо чисел, Python может работать со строками, которые, в свою очередь, могут быть описаны различными способами. Строки могут быть заключены в одинарные ( ‘. ‘ ) или двойные кавычки ( «. » ), без разницы [2]; \ может быть использован для экранирования кавычек:

>>> 'spam eggs' # single quotes 'spam eggs' >>> 'doesn\'t' # use \' to escape the single quote. "doesn't" >>> "doesn't" # . or use double quotes instead "doesn't" >>> '"Yes," he said.' '"Yes," he said.' >>> "\"Yes,\" he said." '"Yes," he said.' >>> '"Isn\'t," she said.' '"Isn\'t," she said.'

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

>>> '"Isn\'t," she said.' '"Isn\'t," she said.' >>> print('"Isn\'t," she said.') "Isn't," she said. >>> s = 'First line.\nSecond line.' # \n means newline >>> s # without print(), \n is included in the output 'First line.\nSecond line.' >>> print(s) # with print(), \n produces a new line First line. Second line.

Если вы не хотите, чтобы символы, предваренные \ , были интерпретированы как специальные, то вы можете использовать сырые строки добавлением r перед первой кавычкой:

>>> print('C:\some\name') # here \n means newline! C:\some ame >>> print(r'C:\some\name') # note the r before the quote C:\some\name

Строковые литералы могут занимать несколько строк. Один из способов сделать это — тройные кавычки: «»». «»» или »’. »’ . Концы строк автоматически включаются в строку, но возможно избежать этого добавлением \ в конце строки. Следующий пример:

print("""\ Usage: thingy [OPTIONS] -h Display this usage message -H hostname Hostname to connect to """)

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

Usage: thingy [OPTIONS] -h Display this usage message -H hostname Hostname to connect to

Строки могут быть конкатенированы (соединены вместе) с помощью оператора + , и повторены с помощью * :

>>> # 3 times 'un', followed by 'ium' >>> 3 * 'un' + 'ium' 'unununium'

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

>>> 'Py' 'thon' 'Python'

Хотя это работает только с литералами, не с переменными или выражениями:

>>> prefix = 'Py' >>> prefix 'thon' # нельзя конкатенировать переменную и строковый литерал . SyntaxError: invalid syntax >>> ('un' * 3) 'ium' . SyntaxError: invalid syntax

Если вы хотите конкатенировать переменные или переменную или литерал, используйте + :

>>> prefix + 'thon' 'Python'

Эта функция особенно полезна, когда вы хотите разбить длинные строки:

>>> text = ('Put several strings within parentheses ' . 'to have them joined together.') >>> text 'Put several strings within parentheses to have them joined together.'

К символам строки можно обращаться по индексу, первая буква имеет индекс нуль. Отдельного типа для символов нет; символ это просто строка размером 1:

>>> word = 'Python' >>> word[0] # символ с позицией 0 'P' >>> word[5] # символ с позицией 5 'n'

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

>>> word[-1] # последний символ 'n' >>> word[-2] # предпоследний символ 'o' >>> word[-6] 'P'

Заметьте, так как -0 это тоже 0, то негативные индексы начинаются с -1.

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

>>> word[0:2] # символы с позициями от 0 (включительно) до 2 (не включая) 'Py' >>> word[2:5] # символы с позициями от 2 (включительно) до 5 (не включая) 'tho'

Заметьте, что начальный символ всегда включается, а конец — всегда исключается. Это гарантирует, что s[:i] + s[i:] всегда равно s :

>>> word[:2] + word[2:] 'Python' >>> word[:4] + word[4:] 'Python'

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

>>> word[:2] # символы с начала до позиции 2 (не включая) 'Py' >>> word[4:] # символы с позиции 4 (включительно) до конца 'on' >>> word[-2:] # символы с предпоследней позиции (включительно) до конца 'on'

Один из способов запомнить, как работают срезы — думать, что индексы указываются между символами, с левым краем первого символа, пронумерованным 0. Тогда правый край последнего символа строки из n символов имеет идекс n, например:

+---+---+---+---+---+---+ | P | y | t | h | o | n | +---+---+---+---+---+---+ 0 1 2 3 4 5 6 -6 -5 -4 -3 -2 -1

Первый ряд чисел дает позицию индексов 0. 6 в строке; второй ряд дает соответствующие негативные индексы. Срез от i до j состоит из всех символов между краями, отмеченными i и j, соответственно.

Для неотрицательных индексов длина среза есть разница индексов, если оба индекса в пределах границ. Например, длина word[1:3] равна 2.

Попытка использовать индекс, который слишком велик, приводит к ошибке:

>>> word[42] # в слове только 6 символов Traceback (most recent call last): File "", line 1, in IndexError: string index out of range

Однако, индексы срезов вне диапазона обрабатываются корректно при нарезании:

>>> word[4:42] 'on' >>> word[42:] ''

Python-строки не могут быть изменены — они являются immutable/иммутабельными. Поэтому присвоение по индексу строки приводит к ошибке:

>>> word[0] = 'J' . TypeError: 'str' object does not support item assignment >>> word[2:] = 'py' . TypeError: 'str' object does not support item assignment

Если вам нужна другая строка, вам следует создать новую:

>>> 'J' + word[1:] 'Jython' >>> word[:2] + 'py' 'Pypy'

Встроенная функция len() возвращает длину строки:

>>> s = 'supercalifragilisticexpialidocious' >>> len(s) 34

Текстовый последовательный тип — str Строки являются примерами последовательного типа, и поддерживают привычные для этих типов операции. Строковые методы Строки поддерживают большое количество методов для поиска и простых трансформаций. Форматирование строковых литералов Строковые литералы, имеющие встроенные выражения. Синтаксис форматирования строк Информация о форматировании строк с применением функции str.format() printf-стиль форматирования строк Старые операции форматирования, вызывающиеся тогда, когда обычные строки или строки в Unicode оказываются левым операндом относительно операции % , более детально рассмотрены здесь.

Списки

В языке Python доступно некоторое количество составных типов данных, использующихся для группировки прочих значений вместе. Наиболее гибкий из них — список (list). Его можно выразить в тексте программы через разделённые запятыми значения (элементы), заключённые в квадратные скобки. Элементы списка могут быть разных типов, но обычно элементы все имеют тот же тип.

>>> squares = [1, 4, 9, 16, 25] >>> squares [1, 4, 9, 16, 25]

Подобно строкам (и всем другим встроенным последовательным типам), списки могут быть индексированы и срезаны:

>>> squares[0] # индексация возвращает элемент 1 >>> squares[-1] 25 >>> squares[-3:] # срез возвращает новый список [9, 16, 25]

Все срезовые операции возвращают новые список, содержащий запрашиваемые элементы. Это означает, что следующий срез возвращает новую (легковесную) копию списка:

>>> squares[:] [1, 4, 9, 16, 25]

Списки также поддерживают такие операции, как конкатенация:

>>> squares + [36, 49, 64, 81, 100] [1, 4, 9, 16, 25, 36, 49, 64, 81, 100]

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

>>> cubes = [1, 8, 27, 65, 125] # что-то здесь не так >>> 4 ** 3 # куб от 4 — 64, не 65! 64 >>> cubes[3] = 64 # заменить неправильное значение >>> cubes [1, 8, 27, 64, 125]

Вы также можете добавить новые элементы в конец списка, используя метод append() (позже мы узнаем больше о методах):

>>> cubes.append(216) # добавить куб 6 >>> cubes.append(7 ** 3) # и куб 7 >>> cubes [1, 8, 27, 64, 125, 216, 343]

Присвоение спискам также возможно, и это может даже изменить размер списка или очистить его полностью:

>>> letters = ['a', 'b', 'c', 'd', 'e', 'f', 'g'] >>> letters ['a', 'b', 'c', 'd', 'e', 'f', 'g'] >>> # заменить некоторые значения >>> letters[2:5] = ['C', 'D', 'E'] >>> letters ['a', 'b', 'C', 'D', 'E', 'f', 'g'] >>> # теперь удалить их >>> letters[2:5] = [] >>> letters ['a', 'b', 'f', 'g'] >>> # очистить список заменой всех элементов пустым списком >>> letters[:] = [] >>> letters []

Встроенная функция len() также применима к спискам:

>>> letters = ['a', 'b', 'c', 'd'] >>> len(letters) 4

Можно вкладывать списки (создавать списки, содержащие другие списки), например:

>>> a = ['a', 'b', 'c'] >>> n = [1, 2, 3] >>> x = [a, n] >>> x [['a', 'b', 'c'], [1, 2, 3]] >>> x[0] ['a', 'b', 'c'] >>> x[0][1] 'b'

Первые шаги к программированию

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

>>> # последовательность Фибоначчи: . # сумма двух элементов определяет следующий . a, b = 0, 1 >>> while b < 10: . print(b) . a, b = b, a+b . 1 1 2 3 5 8

Этот пример показывает нам некоторые новые возможности.

Первая строка содержит множественное присваивание: переменные a и b параллельно получают новые значения — 0 и 1. В последней строке этот метод используется снова, демонстрируя тот факт, что выражения по правую сторону [от оператора присваивания] всегда вычисляются раньше каких бы то ни было присваиваний. Правая часть выражения оцениваются слева направо.
Цикл while (пока) исполняется до тех пор, пока условие (здесь: b < 10 ) остается истиной. В Python, также как и в C, любое ненулевое значение является истиной ( True ); ноль является ложью ( False ). Условием может быть строка, список или вообще любая последовательность; все, что имеет ненулевую длину, играет роль истины, пустые последовательности — лжи. Использованная в примере проверка — простое условие. Стандартные операции сравнения записываются так же, как и в C: < (меньше чем), >(больше чем), == (равно), = (больше или равно) и != (не равно).
Тело цикла выделено отступом. Отступы — это средство группировки операторов в Python. В интерактивном режиме необходимо использовать табуляции или пробелы для отступа в каждой строке. На практике более сложный текст на Python готовится в текстовом редакторе, а большинство из них имеют функцию авто-отступа. По окончанию ввода составного выражения в интерактивном режиме, необходимо закончить его пустой строкой — признаком завершения (поскольку интерпретатор не может угадать, когда вами была введена последняя строка). Обратите внимание, что размер отступа в каждой строке основного блока должен быть одним и тем же.
Функция print() выводит значения переданных ей выражений. Поведение этой функции отличается от обычного вывода выражения (как происходило выше в примерах с калькулятором) тем, каким способом обрабатываются ряды выражений, величины с плавающей точкой и строки. Строки выводятся без кавычек и между элементами вставляются пробелы, благодаря чему форматирование вывода улучшается — как, например, здесь:

>>> i = 256*256 >>> print('The value of i is', i) The value of i is 65536

Для отключения перевода строки после вывода или завершения вывода другой строкой используется именованный параметр end:

>>> a, b = 0, 1 >>> while b < 1000: . print(b, end=',') . a, b = b, a+b . 1,1,2,3,5,8,13,21,34,55,89,144,233,377,610,987,

">[1]

Так как ** имеет более высокий приоритет, чем - , то -3**2 будет интерпретирован как -(3**2) и поэтому приведет к -9 . Чтобы избежать этого и получить 9 , вы можете использовать (-3)**2 .

">[2]

В отличие от других языков, специальные символы, такие как \n , имеют тот же смысл и с одинарными( '. ' ), и с двойными ( ". " ) кавычками. Единственная разница между ними — что внутри одинарных кавычек вам нужно экранировать " (но вам придется экранировать \' ), и наоборот.

Содержание

Неформальное введение в Python
- Использование Python в качестве калькулятора
  - Числа
  - Строки
  - Списки
  Похожие публикации: