Підручник мови Python/Неформальний вступ до мови Python

Матеріал з Вікіпідручника
Перейти до навігації Перейти до пошуку

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

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

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

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

# це перший коментар
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(re,im)".

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

Текстові рядки, можуть займати кілька рядків. (примітка перекладу. Каламбур multiline string (багаторядковий рядок) - це текстова константа, в якій міститься кілька символів переходу на новий рядок).

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

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

Перший ряд чисел дає позиції індексів від 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 (див. [1]) і добре інтегрується з існуючими рядковими об'єктами та здійснює автоматичну конверсію за потребою.

Перевага кодування 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"&auml;&ouml;&uuml;"
u'\xe4\xf6\xfc'
>>> str(u"&auml;&ouml;&uuml;")
Traceback (most recent call last):
 File "&lt;stdin&gt;", line 1, in ?
UnicodeEncodeError: 'ascii' codec can't encode characters in position 0-2: ordinal not in range(128)

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

>>> u"&auml;&ouml;&uuml;".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: < (менше ніж), > (більше ніж), == (дорівнює), <= (менше ніж або дорівнює), >= (більше ніж або дорівнює) і != (не дорівнює).
  • Тіло циклу виділяється відступами: у цей спосіб Пайтон групує інструкції. Наразі Пайтон (ще![1]) не має розумної системи для редагування вводу, отже табуляції чи пробіли потрібно вводити "вручну" для кожного виділеного рядка. На практиці складніші програми на Пайтоні створюються за допомогою текстового редактора і більшість текстових редакторів має певний механізм для автоматичного виділення тексту. При вводі блоку інструкцій у діалоговому режимі він повинен закінчуватись пустим рядком, щоб позначає завершення (тому що інакше парсер не може вгадати, коли було введено останій рядок). Слід зауважити, що всередині простого блоку, всі рядки повинні бути виділені однаковою кількістю пробілів (чи табуляцій).
  • Оператор 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

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

Примітки[ред.]

  1. Радимо звернути увагу на оболонку інтерпритатора bpython.



наступний
Контрольні структури