Попередні зауваження

У поданих нижче прикладах ввід та вивід розрізняються за допомогою присутності чи відсутності запрошень до вводу (">>>" та "... "): щоб повторити приклад, слід

ввести текст після того, як з'явиться запрошення. Рядки без запрошення

це вивід з інтерпретатора. Зауважте, що вторинне запрошення без жодного тексту означає, що треба ввести пустий рядок. Це використовується в багаторядкових командах.

Багато прикладів у цьому підручнику, включно з тими, що введено в діалоговому режимі, містять коментарі. Коментарі у Пітоні починаються ґраткою ("#") і тривають до кінця рядка. Коментар може з'явитися на початку рядка, після пробілу чи коду, але не всередині буквальної величини. Ґратка всередині рядка - звичайнісінький символ.

Окремі приклади:

# це перший коментар
SPAM = 1 # і це другий коментар 
# ... і це третій!
STRING = "# А це - не коментар."

Python як калькулятор

Спробуймо декілька простих команд на Пітоні. Запустіть інтерпретатор і дочекайтеся головного запрошення ">>> ". (Повинне з'явитися незабаром).

Числа

Інтерпретатор діє як простий калькулятор: ви вводите вираз і отримуєте результат. Синтаксис математичних виразів досить традиційний: опрератори +, -, *, / діють як і в більшості інших мов, напр., Pascal чи C. Дужки можуть використовуватися для групування. Наприклад:

>>> 2+2
4
>>> # Це - коментар
... 2+2
4
>>> 2+2 # і це коментар, на одному рядку з кодом
4
>>> (50-5*6)/4
5
>>> # Ділення цілих чисел повертає нижню цілочислову величину (floor):
... 7/3
2
>>> 7/-3
-3

Подібно до C, знак рівності ("=") служить для присвоєння величини змінній. Величина присвоєння не виводиться:

>>> shyryna = 20
>>> vysota = 5*9
>>> shyryna * vysota
900

Величина може бути присвоєна кільком змінним одночасно:

>>> x = y = z = 0 # x, y та z дорівнюють нулю
>>> x
0
>>> y
0
>>> z
0

Повністю підтримуються числа з рухомою комою; оператори зі змішаними типами компонентів перетворюють цілочислові компоненти на компоненти з рухомою комою:

>>> 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() та long()) не працюють із комплексними числами, тому що не існує правльного методу переведення комплексного числа в реальне. Слід використовувати abs(z), щоб отримати його абсоютну величину  (у вигляді числа з рухомою комою) чи z.real щоб отримати реальну частину.

>>> a=3.0+4.0j
>>> float(a)
Traceback (most recent call last):
 File "<stdin>", line 1, in ?
TypeError: can't convert complex to float; use abs(z)
>>> a.real
3.0
>>> a.imag
4.0
>>> abs(a) # sqrt(a.real**2 + a.imag**2)
5.0
>>>

У діаголовому режимі останній виведений вираз зберігається у змінній _. При використанні Пітона у якості настільного калькулятора ця риса дещо полегшує продовження обчислень:

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

Цю змінну слід вживати за таку, що можна лише зчитувати. Явне присвоєння їй певної величини призведе до створення незалежної локальної змінної з такою самою назвою, що затьмарить вбудовану змінну із її чарівними властивостями.

Ланцюжки

Окрім чисел Пітон може працювати і з ланцюжками, які можуть бути виражені у кілька способів. Вони можуть оточуватися одинарними чи подвійними лапками:

>>> '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.'

Буквальні величини, задані ланцюжками, можуть займати кілька рядків. Якщо рядок закінчується символом "\", то наступний рядок є продовженням першого:

hello = "Це досить довгий ланцюжок, що складається \n\
з кількох рядків тексту, подібно до того, як це робиться у Сі.\n\
 Зауважте, що додаткові пробіли на початку рядка теж рахуються."

print hello

Слід зазначити, що символи на позначення нового рядка (\n) повинні бути присутні; новий рядок, що йде за "\" не беруться до уваги. Наведений вище приклад повинен вивести таке:

Це досить довгий ланцюжок, що складається
з кількох рядків тексту, подібно до того, як це робиться у C.
 Зауважте, що додаткові пробіли на початку рядка теж рахуються.

Якщо створено "сирий" (raw) ланцюжок, послідовність символів \n не транслітерується у новий рядок, але сам символ "\" та новий рядок зберігаються. Таким чином цей приклад:

hello = r"Це досить довгий ланцюжок, що складається \n\
з кількох рядків тексту, подібно до того, як це робиться у C."

print hello

виводить:

Це досить довгий ланцюжок, що складається \n\
з кількох рядків тексту, подібно до того, як церобиться у Сі.

Також ланцюжки можуть оточуватися трьома лапками: """ та '''. Вживання символа "\" наприкінці рядка непотрібне, але він може бути всередині ланцюжка:

print """
Використання: назва [ОПЦІЇ] 
 -h                 Виводить це повідомлення
 -H назва сервера   Сервер, до якого потрібно підключитися
"""

Виводиться такий результат:

Використання: назва [ОПЦІЇ] 
 -h                 Виводить це повідомлення
 -H назва сервера   Сервер, до якого потрібно підключитися

Інтерпретатор виводить ланцюжок точнісінько так само, як його було задано всередині лапок, при цьому всі спеціальні символи можуть задаватися за допомогою контрольних послідовностей, що починаються зі зворотньої скісної риски (). Ланцюжок береться в подвійні лапки, якщо всередині є одинарні лапки і немає подвійних, інакше - в одинарні лапки. (Твердження print, описане далі, може використовуватися для виводу ланцюжків без лапок чи контрольних послідовностей).

Конкатенація (з'єднання) ланцюжків робиться за допомогою оператора +, а повторення - за допомогою *:

>>> word = 'Help' + 'A'
>>> word
'HelpA'
>>> '<' + word*5 + '>'
'<HelpAHelpAHelpAHelpAHelpA>'

Дві буквальні величини, виражені ланцюжками, автоматично з'єднуються, якщо вони розташовані поруч. У наведеному вище прикладі перший рядок може бути написаний як "word = 'Help' 'A'". Це працює лише з двома буквальними величинами, а не з будь-якими виразами, що являють собою ланцюжки:

>>> 'str' 'ing' # <- Гаразд
'string'
>>> 'str'.strip() + 'ing' # <- Гаразд
'string'
>>> 'str'.strip() 'ing' # <- А це не годиться
 File "<stdin>", line 1, in ?
 'str'.strip() 'ing'
 ^
SyntaxError: invalid syntax

Ланцюжки можуть бути індексовані. Подібно до C перший символ ланцюжка має індекс 0. Окремого символьного типу не існує; символ - це просто ланцюжок довжиною в один символ. Подібно до мови Icon, частини ланцюжків можуть позначатися за допомогою двох індексів, розділених двокрапкою.

>>> word[4]
'A'
>>> word[0:2]
'He'
>>> word[2:4]
'lp'

Пропуск першого індексу рівнозначний нулю, а пропуск останього - довжині ланцюжка.

>>> word[:2] # Перші два символи
'He'
>>> word[2:] # Усі символи, крім перших двох
'lpA'

На відміну від C, лацюжки у Пітоні не можуть бути змінені. Присвоєння величини індексованій позиції ланцюжка призводить до помилки:

>>> word[0] = 'x'
Traceback (most recent call last):
 File "<stdin>", line 1, in ?
TypeError: object doesn't support item assignment
>>> word[:1] = 'Splat'
Traceback (most recent call last):
 File "<stdin>", line 1, in ?
TypeError: object doesn't support slice assignment

Натомість створення нового ланцюжка за допомогою індексованих елементів швидке й ефективне:

>>> 'x' + word[1:]
'xelpA'
>>> 'Splat' + word[4]
'SplatA'

Ось корисна інваріантна операція, де s[:i] + s[i:] дорівнює 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 "<stdin>", line 1, in ?
IndexError: string index out of range

Найкращий спосіб запам'ятати, як діє фрагментація ланцюжків, це уявити, що індески вказують на позицію між символами, де лівий край має індекс 0. Тоді правий край ланцюжка довжиною в 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[1:3] дорівнює 2.

Вмонтована функція len() видає довжину ланцюжка:

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

Дивіться також (зовнішні посилання, англійською):

• Послідовнісні типи (Sequence Types).
  Ланцюжки (як однобайтові, так і у форматі Unicode), описані у наступній секції, є прикладами типів послідовностей (sequence types) і підтримують спільні операції, притаманні цим типам.
• Ланцюжкові методи (String Methods).
  До ланцюжків (як однобайтових, так і у форматі Unicode) можуть бути застосовані численні методи для базових трансформацій та пошуку.
• Операції форматування ланцюжків (String Formatting Operations)
  Тут детальніше описано операції форматування, коли ланцюжки (як однобайтові, так і у форматі Unicode) є операндами, розташованими по ліву сторону оператора %.

Ланцюжки у кодуванні Unicode

Починаючи з версії 2.0, Пітон має новий тип даних для зберігання тексту: юнікодовий об'єкт. Він може використовуватися для зберігання та обробки даних у Unicode (див. http://www.unicode.org/) і добре інтегрується з існуючими ланцюжковими об'єктами та здійснює автоматичну конверсію за потребою.

Перевага кодування Unicode полягає в тому, що воно визначає єдину ординальну величину для кожного символа у будь-якій письмовій системі сучасних чи давніх мов. До цього існувало лише 256 ординальних величин для позначення символів і текст здебільшого прив'язувався до кодування, що поєднувало ординальні величини з символами алфавіту. Це призводило до численних непорозумінь, особливо при інтернаціоналізації (цей термін традиційно позначається як "i18n" -- "i" + 18 символів посередині + "n") програмного забезпечення. Ця проблема вирішена в кодуванні Unicode, де одна кодова сторінка описує всі скрипти.

Створення юнікодових ланцюжків у Пітоні таке ж просте, як і створення звичайних ланцюжків:

>>> u'Hello World !'
u'Hello World !'

Маленький символ "u" перед лапками означає, що задається юнікодовий ланцюжок. Задання спеціальних символів у ланцюжку може бути зроблено за допомогою юнікодових контрольних послідовностей (Unicode-Escape encoding) мови Пітон, як це показано у наступному прикладі:

>>> u'Hello\u0020World !'
u'Hello World !'

Контрольна послідовність \u0020 вказує, що у заданій позиції повинен бути вставлений символ, що має ординальну величину 0x0020 (пробіл).

Інші символи інтерпретуються через пряме використання їхніх ординальних величин як ординальних величин кодування Unicode. Якщо ваші буквальні величини задано за допомогою кодування Latin-1, що використовується у багатьох західних країнах, то для вас перші 256 символів кодування Unicode ті самі, що й 256 симаволів кодування Latin-1.

Подібно до звичайних ланцюжків, юнікодові ланцюжки можуть задаватися у сирому режимі. Для цього слід додати префікс 'ur' перед відкриттям лапок для того, щоб Пітон використовував "сире" кодуваня юнікодових контрольних послідовностей (Raw-Unicode-Escape encoding). При цьому переведення послідовностей \uXXXX у юнікодові символи відбудеться лише тоді, коли маленькій літері 'u' передує непарна кількість зворотніх скісних рисок (\).

>>> ur'Hello\u0020World !'
u'Hello World !'
>>> ur'Hello\\u0020World !'
u'Hello\\\\u0020World !'

Сирий режим найкорисніший, коли потрібно ввести багато зворотніх скісних рисок, що може бути необхідно у регулярних виразах.

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

Вбудована функція unicode() надає доступ до всіх зареєстрованих юнікодових кодеків (codec < "COders and DECoders"). Одні з найвдоміших кодувань, що можуть конвертуватися цими кодеками - це Latin-1, ASCII, UTF-8, та UTF-16. Останні два - кодування змінної довжини, що зберігають юнікодові символи в одному чи більше байтах. Типове кодування - це здебільшого ASCII, що дозволяє лише симлоли від 0 до 127 і видає помилку, коли знаходить інші символи. Коли юнікодовий ланцюжок виводиться на сандартний вивід, записується у файл чи конвертується за допомогою str(), то конверсія відбувається за допомогою цього стандартного кодування.

>>> u"abc"
u'abc'
>>> str(u"abc")
'abc'
>>> u"äöü"
u'\xe4\xf6\xfc'
>>> str(u"äöü")
Traceback (most recent call last):
 File "<stdin>", line 1, in ?
UnicodeEncodeError: 'ascii' codec can't encode characters in position 0-2: ordinal not in range(128)

Для конверсії юнікодових ланцюжків у восьмибітові за допомогою певного кодування, юнікодові об'єкти мають спеціальний метод encode(), що отримує назву кодування як аргумент. Бажано вживати маленькі літери на позначення кодування.

>>> u"äöü".encode('utf-8')
'\xc3\xa4\xc3\xb6\xc3\xbc'

Якщо ви маєте дані у певному кодуванні і хочете утворити з них відповідний юнікодовий ланцюжок, то можете використовувати функцію unicode(), чий другий аргумент є назвою кодування.

>>> unicode('\xc3\xa4\xc3\xb6\xc3\xbc', 'utf-8')
u'\xe4\xf6\xfc'

Списки

Пітон знає кілька складних типів даних, що використовуються для групування величин. Найбільш універсальним є список, що може бути ствовений як послідовність величин (одиниць), розділених комами і оточених прямими дужками. Елементи списку не повині обов'язково належати до одного типу.

>>> a = ['spam', 'eggs', 100, 1234]
>>> a
['spam', 'eggs', 100, 1234]

Подібно до ланцюжків ідекси списків починаються з 0. Списки можуть поділятися на частини, з'єднуватися тощо:

>>> 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] + ['Boe!']
['spam', 'eggs', 100, 'spam', 'eggs', 100, 'spam', 'eggs', 100, 'Boe!']

На відміну від ланцюжків, що є незмінними, індивідуальний елемент списку може бути змінено:

>>> a
['spam', 'eggs', 100, 1234]
>>> a[2] = a[2] + 23
>>> a
['spam', 'eggs', 123, 1234]

Призначення нових елементів частині списку можливе. Ця операція може навіть змінити розмір списку:

>>> # Замінити певні елементи:
... a[0:2] = [1, 12]
>>> a
[1, 12, 123, 1234]
>>> # Видалити елементи:
... a[0:2] = []
>>> a
[123, 1234]
>>> # Додати:
... a[1:1] = ['bletch', 'xyzzy']
>>> a
[123, 'bletch', 'xyzzy', 1234]
>>> a[:0] = a # Вставити (копію) самого себе на початку
>>> a
[123, 'bletch', 'xyzzy', 1234, 123, 'bletch', 'xyzzy', 1234]

Стандартна функція len() також застосовується до списків:

>>> len(a)
8

Можливо також створити вкладені списки (тобто списки, що містять інші списки), наприклад:

>>> q = [2, 3]
>>> p = [1, q, 4]
>>> len(p)
3
>>> p[1]
[2, 3]
>>> p[1][0]
2
>>> p[1].append('xtra') # Див. розділ 5.1
>>> p
[1, [2, 3, 'xtra'], 4]
>>> q
[2, 3, 'xtra']

Слід зауважити, що в останьому прикладі, p[1] і q посилаються та той самий об'єкт! Ми повернемося до об'єктної семантики пізніше.

Перші кроки до програмування

Звичайно, Пітон може використовуватися і для вирішення складніших задач, аніж додавання двох до двох. Зокрема, ми могли б написати початок послідовності чисел Фібоначчі таким чином:

>>> # числа Фібоначчі:
... # сума двох елементів визначає наступний:
... a, b = 0, 1
>>> while b < 10:
...     print b
...     a, b = b, a+b
... 
1
1
2
3
5
8

Цей приклад ілюструє кілька нових рис:

• У першому рядку є численне присвоєння (multiple assignment): змінні a та b одночасно отримують нові величини 0 та 1. В останьому рядку ми знову зустрічаємо подібне присвоєння, при цьому вирази, розташовані по праву сторону знаку присвоєння, обчислюються перед тим як відбувається присвоєння. Правосторонні вирази обчислюються зліва направо.
• Цикл while виконується поки умова (тут: b < 10) залишається істинною. У Пітоні, як і в C, будь-яка ненульова цілочислова величина є істинною, а нульова - хибною. Умова може також бути ланцюжком або списком, та й взагалі будь-якою послідовністю. Будь-яка величина з ненульовою довжиною - істинна, а пуста послідовність - хибна. Умова, використана у цьому прикладі, - просте порівняння. Стандартні оператори порівняння пишуться так само, як і в C: < (менше ніж), > (більше ніж), == (дорівнює), <= (менше ніж або дорівнює), >= (більше ніж або дорівнює) і != (не дорівнює).
• Тіло циклу виділяється пробілами: у цей спосіб Пітон групує твердження. Наразі Пітон (ще!) не має розумної системи для редагування вводу, отже табулятор(и) чи пробіл(и) потрібно вводити "вручну" для кожного виділеного рядка. На практиці складніші програми на Пітоні створюються за допомогою текстового редактора і більшість текстових редакторів має певний механізм для автоматичного виділення тексту. При вводі складного твердження у діалоговому режимі воно повинно закриватися пустим рядком, що позначає завершення (тому що інакше парсер не може вгадати, коли було введено останій рядок). Слід зауважити, що всередині простого блоку, всі рядки повинні бути виділені однаковою кількістю пробілів (чи табуляторів).

• Твердження print виводить величину поданих виразів. Воно відрізняється від простого написання величини для виводу (як це робилося у попередніх прикладах з калькулятором) тим, що за його допомогою вожна вивести більше, ніж один вираз. Ланцюжки виводяться без лапок і пробіл вставляється між окремими елементами, як показано тут:

    >>> i = 256*256
    >>> print 'Величина i складає', i
    Величина i складає 65536
  

Кінцева кома  означає, що вивід не закінчується новим рядком:

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

Зауважте, що інтерпретатор додає символ нового рядка перед тим, як вивести запрошення до вводу, якщо останній рядок не було закрито.