Подякувати Студентському архіву довільною сумою
Admin
26.02.2023 12:38
Дякуємо, що користуєтесь нашим архівом!
Мова програмування Python
Інформація про навчальний заклад
ВУЗ:
Національний університет Львівська політехніка
Інститут:
Інститут комп’ютерних наук та інформаційних технологій
Факультет:
Не вказано
Кафедра:
Кафедра систем автоматизованого проектування
Інформація про роботу
Рік:
2010
Тип роботи:
Курсова робота
Предмет:
Технологія розробки великих комп’ютерних систем
Група:
ІТП-12м
Частина тексту файла (без зображень, графіків і формул):
МІНІСТЕРСТВО ОСВІТИ І НАУКИ УКРАЇНИ
НАЦІОНАЛЬНИЙ УНІВЕРСИТЕТ "ЛЬВІВСЬКА ПОЛІТЕХНІКА"
Інститут комп’ютерних наук та інформаційних технологій
Кафедра систем автоматизованого проектування
ПОЯСНЮВАЛЬНА ЗАПИСКА
до курсового проекту
з дисципліни "Технологія розробки великих комп’ютерних систем"
на тему: "Мова програмування Python "
Допущено до захисту:
Дата: _______________
Виконав: ІТП-12м
студент групи
Прийняв:
Оцінка __________
Львів 2010 Національний Університет «Львівська Політехніка»
Інститут комп’ютерних наук та інформаційних технологій
Кафедра САПР
Дисципліна: « Технологія розробки великих комп’ютерних систем»
Спеціальність: Комп’ютерні науки
Курс: п’ятий Група: ІТП-12м Семестр: дев’ятий
Завдання
на курсовий проект студента
Шишко Миколи
Тема роботи: Мова програмування Python.
Термін здачі студентом закінченого проекту: ____________
Календарний план
№ п/п
Назва етапів курсової роботи
Термін виконання етапів роботи
Примітки
1
Отримання індивідуального завдання
2
Пошук необхідної літератури
3
Обробка відповідної літератури
4
Написання програми
5
Написання теоретичної частини курсової роботи
6
Висновки по курсовій роботі
7
Остаточна перевірка, закінчення курсової роботи
Студент: ___________Шишко М. П.
Керівник:___________ Стех Ю.В.
____________2010р.
Анотація
Студент: Шишко М. П.
“Мова програмування Python”. Курсова робота. – НУ „Львівська політехніка”, каф.: САПР, дисципліна: “ Технологія розробки великих комп’ютерних систем ”, 2010.
Дана курсова робота містить в собі 149 сторінок, 25 таблиць, 13 малюнків.
Виконання курсової роботи має за мету:
поглибити теоретичні знання по технології розробки великих комп’ютерних систем ;
розширити знання одержані при вивченні дисциплін основи програмування;
розвинути навики самостійної роботи з складання математичних алгоритмів і розробки та відлагодження програмного забезпечення.
ЗМІСТ
Завдання на курсову роботу………………………………………………….
Календарний план……………………………………………………………..
Анотація…………………………………………………………………………
Вступ……………………………………………………………………………..
Вступ в програмування на мові Python
Історія мови Python……………………………………………………….
Інструкція з встановлення………………………………………………..
Необхідне ПЗ………………………………………………………
Встановлення Python……………………………………………...
Програма на Python……………………………………………………….
Основні алгоритмічні конструкції……………………………………….
Послідовність операторів…………………………………………
Оператор умови і вибору………………………………………….
Цикли……………………………………………………………….
Функції………………………………………………………………
Винятки……………………………………………………………..
Вбудовані типи даних……………………………………………………
Вирази…………………………………………………………………….
Імена………………………………………………………………………
Основні стандартні модулі Python
Поняття модуля ……………………………………………………………
Модулі в Python ……………………………………………………………
Вбудовані функції …………………………………………………………
Огляд стандартної бібліотеки …………………………………………….
Сервіси періоду виконання ………………………………………….
Підтримка циклу розробки …………………………………………..
Взаємодія з операційною системою …………………………………
Багатопотокові обчислення …………………………………………..
Зберігання даних. Архівація ………………………………………….
Платформо-залежні модулі …………………………………………..
Підтримка мережі. Протоколи Інтернет ……………………………..
Підтримка Internet. Формати даних …………………………………..
Елементи функціонального програмування
Функціональне програмування…………………………………………….
Функціональна програма…………………………………………………..
Функція: визначення і виклик……………………………………………….
Рекурсія……………………………………………………………………….
Опції як параметри і результат………………………………………………
Обробка послідовностей……………………………………………………..
Спискові включення…………………………………………………………..
Ітератори……………………………………………………………………….
Власний ітератор………………………………………………………………
Прості генератори…………………………………………………………..
Каррінг……………………………………………………………………….
Об'єктно-орієнтоване програмування
Основні поняття……………………………………………………………...
Абстракція і декомпозиція……………………………………………………
Об'єкти…………………………………………………………………………
Типи і класи…………………………………………………………………...
Інкапсуляція…………………………………………………………………...
Поліморфізм……………………………………………………………………
Імітація типів…………………………………………………………………..
Відносини між класами……………………………………………………….
Успадкування…………………………………………………………….
Агрегація………………………………………………………………….
Асоціація………………………………………………………………….
Статичний метод…………………………………………………………
Метод класу………………………………………………………………
Метакласи………………………………………………………………..
Мультиметоди…………………………………………………………..
Стійкі об'єкти……………………………………………………………….
Чисельні алгоритми. Матричні обчислення
Модуль Numeric………………………………………………………………
Модуль LinearAlgebra………………………………………………………..
Модуль RandomArray………………………………………………………..
Обробка текстів. Регулярні вирази. Unicode
Рядки………………………………………………………………………….
Регулярні вирази……………………………………………………………..
Приклади застосування регулярного виразів………………………………
Робота з Unicode……………………………………………………………...
Розробка Web-додатків
CGI-сценарії…………………………………………………………………..
Середовища розробки………………………………………………………..
Мережеві додатки на Python
Робота з сокетами……………………………………………………………..
Модуль smtplib………………………………………………………………...
Модуль poplib………………………………………………………………….
Модулі для клієнта WWW…………………………………………………….
XML-RPC сервер………………………………………………………………
Робота з базою даних
Основні поняття реляційної СУБД…………………………………………..
Що таке DB-API 2……………………………………………………………..
Опис DB API 2.0……………………………………………………………….
Інтерфейс модуля………………………………………………………………
Робота з базою даних у Python-додатках……………………………………..
Інші СУБД і Python……………………………………………………………..
Створення додатків із графічним інтерфейсом користувача
Огляд графічних бібліотек…………………………………………………
Про графічний інтерфейс…………………………………………………..
Основи Tk…………………………………………………………………………..
Висновок
Список літератури
Вступ
Python - інтерпретована об'єктно-орієнтована високорівнева мова програмування з динамічною семантикою. Вбудовані високорівневі структури даних у поєднанні з динамічними типізацією і зв'язуванням роблять мову привабливим для швидкої розробки додатків (RAD, Rapid Application Development). Крім того, його можна використовувати як сценарну мови для зв'язку програмних компонентів. Синтаксис Python простий у вивченні, в ньому надається особливе значення читабельності коду, а це скорочує витрати на супровід програмних продуктів. Python підтримує модулі та пакети, заохочуючи модульність і повторне використання коду. Інтерпретатор Python і велика стандартна бібліотека доступні безкоштовно у вигляді вихідних і виконуваних кодів для всіх основних платформ і можуть вільно поширюватися.
Python - це універсальна мова програмування. Він має свої переваги і недоліки, а також сфери застосування. У комплект постачання Python входить велика стандартна бібліотека для вирішення широкого кола завдань. В Інтернеті доступні якісні бібліотеки для Python в різних предметних областях: засоби обробки текстів і технології Інтернет, обробка зображень, інструменти для створення додатків, механізми доступу до баз даних, пакети для наукових обчислень, бібліотеки побудови графічного інтерфейсу і т.п. Крім того, Python має досить прості засоби для інтеграції з мовами C, C (і Java) як шляхом вбудовування (embedding) інтерпретатора в програми на цих мовах, так і навпаки, за допомогою використання бібліотек, написаних на цих мовах, в Python-програмах. Мова Python підтримує кілька парадигм програмування: імперативне (процедурний, структурний, модульний підходи), об'єктно-орієнтоване і функціональне програмування.
Можна вважати, що Python - це ціла технологія для створення програмних продуктів (і їх прототипів). Вона доступна майже на всіх сучасних платформах (як 32-бітових, так і на 64-бітових) з компілятором C і на платформі Java.
Вступ в програмування на мові Python
1.1. Історія мови Python
Створення Python було розпочато Гвідо ван Россумом (Guido van Rossum) в 1991 році, коли він працював над розподіленою ОС Амеба. Йому була потрібна розширювана мова, який би забезпечив підтримку системних викликів. За основу були взяті ABC і Модула-3. В якості назви він вибрав Python на честь комедійних серій BBC "Літаючий цирк Монті Пітона-", а зовсім не за назвою змії. З тих пір Python розвивався за підтримки тих організацій, в яких Гвідо працював. Особливо активно мова вдосконалюється в даний час, коли над нею працює не лише команда творців, а й ціле співтовариство програмістів зі всього світу. І все-таки останнє слово за напрямком розвитку мови залишається за Гвідо ван Россумом.
1.2. Інструкція з встановлення
1.2.1. Необхідне програмне забезпечення.
Завантажити необхідну версію IDE можна на офіційному сайті Python за адресою: http://www.python.org/download.
Доступні інсталятори:
Python 2.7 Windows installer - Windows інсталятор
Python 2.7 Windows X86-64 installer – інсталятор для версій Windows, що підримують 64-розрядні процесори AMD64 / Intel 64 / X86-64 b
Python 2.7 32-bit Mac OS X Installer Disk Image – інсталятор для Mac OS X від 10.3 до 10.6 версії.
Python 2.7 PPC/i386/x86-64 Mac OS X Installer Disk Image – для версій Mac OS X від 10.5 і старше.
Python 2.7 compressed source tarball (for Linux, Unix or OS X)- стиснена версія
Portable Python - портативна версія Python, яка не потребує встановлення і може використовуватися зі змінних носіїв інформації.
Для початку завантаження:
Виберіть потрібну версію
Натисніть на посилання з цією версією
Збережіть файл програми установки на комп’ютері.
1.2.2. Встановлення програмного забезпечення
Для встановлення програмного забезпечення:
1. Після завершення завантаження запустіть програму установки.
2. Для Windows двічі клацніть файл установки для її запуску.
Мал 1.1. Початкове вікно програми установки Python
На Рис 1. представлене початкове вікно, в якому вибираємо варіант установки (доступний для всіх користувачів чи особистий ). Вибравши потрібний, натискаємо “Next”.
Мал. 1.2. Вибір каталогу встановлення
На Рис 2. представлене діалогове вікно вибору катологу встановлення (за замовчуванням C:\Python27)
Мал 1.3. Вибір необхідних компонент
Мал. 1.4. Вікно Python IDLE
На Рис 4. відображене вікно середовища Python, по замовчуванню воно працює в інтерактивному режимі.
1.3. Програма на Python
Програма на мові Python може складатися з одного або декількох модулів. Кожен модуль являє собою текстовий файл у кодуванні, сумісної з 7-бітної кодуванням ASCII. Для кодувань, що використовують старший біт, необхідно явно вказувати назву кодування. Наприклад, модуль, коментарі або рядкові літерали якого записано в кодуванні KOI8-R, повинен мати в першій або другому рядку наступну специфікацію:
# -*- Coding: koi8-r -*-
Завдяки цій специфікації інтерпретатор Python буде знати, як коректно переводити символи літералів Unicode-рядків в Unicode. Без цього рядка нові версії Python будуть видавати попередження на кожен модуль, в якому зустрічаються коди з встановленим восьмим бітом.
Про те, як робити програму модульної, стане відомо в наступних лекціях. У прикладах нижче використовуються як фрагменти модулів, записаних у файл, так і фрагменти діалогу з інтерпретатором Python. Останні відрізняються характерним запрошенням >>>. Символ грати (#) відзначає коментар до кінця рядка.
Програма на Python, з точки зору інтерпретатора, складається з логічних рядків. Одна логічна рядок, як правило, розташовується в одному фізичному, але довгі логічні рядки можна явно (за допомогою зворотної косої риси) або неявно (всередині дужок) розбити на кілька фізичних:
print a, "- дуже довгий рядок, який не поміщається в", \
80, "знакомісцях"
1.4. Основні алгоритмічні конструкції
1.4.1. Послідовність операторів
Послідовні дії описуються послідовними рядками програми. Варто, щоправда, додати, що в програмах важливі відступи, тому всі оператори, що входять в послідовність дій, повинні мати один і той же відступ:
a = 1
b = 2
a = a + b
b = a - b
a = a - b
print a, b
Що робить цей приклад? Перевірити свою здогадку можна за допомогою інтерактивного режиму інтерпретатора Python.
Мал 1.5. Програма в інтерактивному режимі
При роботі з Python в інтерактивному режимі як би вводиться одна велика програма, що складається з послідовних дій. В наведеному вище прикладі використані оператори присвоювання і оператор print.
1.4.2. Оператор умови і вибору
Зрозуміло, одними лише послідовними діями в програмуванні не обійтися, тому при написанні алгоритмів використовується ще й розгалуження:
if a> b:
c = a
else:
c = b
Цей шматок коду на Python інтуїтивно зрозумілий кожному, хто пам'ятає, що if по-англійськи значить "якщо", а else - "інакше". Оператор розгалуження має в даному випадку дві частини, оператори кожної з яких записуються з відступом вправо відносно оператора розгалуження. Більш загальний випадок - оператор вибору - можна записати за допомогою наступного синтаксису (приклад обчислення знака числа):
if a <0:
s = -1
elif a == 0:
s = 0
else:
s = 1
Варто зауважити, що elif - це скорочений else if. Без скорочення довелося б застосовувати вкладений оператор розгалуження:
if a <0:
s = -1
else:
if a == 0:
s = 0
else:
s = 1
На відміну від оператора print, оператор if-else - складений оператор.
1.4.3. Цикли
Третьою необхідною алгоритмічної конструкцією є цикл. За допомогою циклу можна описати повторювані дії. У Python є два види циклів: цикл ПОКИ (виконується деяка умова) і цикл ДЛЯ (всіх значень послідовності). Наступний приклад ілюструє цикл ПОКИ на Python:
s = "abcdefghijklmnop"
while s! = "":
print s
s = s [1: -1]
Оператор while говорить інтерпретатору Python: "поки вірно умова циклу, виконувати тіло циклу". У мові Python тіло циклу виділяється відступом. Кожне виконання тіла циклу буде називатися итерацией. У наведеному прикладі забирається перший і останній символ рядки до того часу, поки не залишиться порожній рядок.
Для більшої гнучкості при організації циклів застосовуються оператори break (перервати) і continue (продовжити). Перший дозволяє перервати цикл, а другий - продовжити цикл, перейшовши до наступної ітерації (якщо, звичайно, виконується умова циклу).
Наступний приклад читає рядки з файлу і виводить ті, у яких довжина більше 5:
f = open ("file.txt", "r")
while 1:
l = f.readline ()
if not l:
break
if len (l)> 5:
print l,
f.close ()
У цьому прикладі організований нескінченний цикл, який переривається лише при отриманні з файлу порожнього рядка (l), що позначає кінець файлу.
У мові Python логічне значення несе кожен об'єкт: нулі, порожні рядки і послідовності, спеціальний об'єкт None і логічний літерал False мають значення "брехня", а інші об'єкти значення "істина". Для позначення істини зазвичай використовується 1 або True.
Примітка:
Літерали True і False для позначення логічних значень з'явилися в Python 2.3.
Цикл ДЛЯ виконує тіло циклу для кожного елемента послідовності. У наступному прикладі виводиться таблиця множення:
for i in range (1, 10):
for j in range (1, 10):
print "% 2i"% (i * j),
print
Тут цикли for є вкладеними. Функція range () породжує список цілих чисел з напіввідкритого інтервалу [1, 10). Перед кожною итерацией лічильник циклу одержує чергове значення з цього списку. Напіввідкриті діапазони загальноприйняті в Python. Вважається, що їх використання більш зручно і викликає менше програмістських помилок. Наприклад, range (len (s)) породжує список індексів для списку s (у Python-послідовності перший елемент має індекс 0). Для красивого виведення таблиці множення застосована операція форматування% (для цілих чисел той же символ використовується для позначення операції взяття залишку від ділення). Рядок форматування (задається ліворуч) будується майже як рядок форматування для printf з C.
1.4.4. Функції
Програміст може визначати власні функції двома способами: за допомогою оператора def або прямо в вираженні, за допомогою lambda. Другий спосіб (та й взагалі робота з функціями) буде розглянуто докладніше в лекції по функціональному програмуванню на Python, а тут слід навести приклад визначення і виклику функції:
def cina (grn, kop = 0):
return "% i грн.% i коп." % (grn, kop)
print cina (8, 50)
print cina (7)
print cina (grn = 23, kop = 70)
У цьому прикладі визначена функція двох аргументів (з яких другий має значення за замовчуванням - 0). Варіантів виклику цієї функції з конкретними параметрами також декілька. Варто лише зауважити, що при виконанні функції спочатку повинні йти позиційні параметри, а потім, іменовані. Аргументи зі значеннями за замовчуванням повинні слідувати після звичайних аргументів. Оператор return повертає значення функції. З функції можна повернути тільки один об'єкт, але він може бути кортежем з декількох об'єктів.
Після оператора def ім'я cіna виявляється пов'язаним з функціональним об'єктом.
1.4.5. Винятки
У сучасних програмах передача управління відбувається не завжди так гладко, як в описаних вище конструкціях. Для обробки особливих ситуацій (таких як розподіл на нуль або читання з неіснуючого файлу) застосовується механізм винятків. Краще всього пояснити синтаксис оператора try-except таким прикладом:
try:
res = int (open ('a.txt'). read ()) / int (open ('c.txt'). read ())
print res
except IOError:
print "Помилка вводу-виводу"
except ZeroDivisionError:
print "Ділення на 0"
except KeyboardInterrupt:
print "Переривання з клавіатури"
except:
print "Помилка"
У цьому прикладі беруться числа з двох файлів і діляться одне на інше. У результаті цих нехитрих дій може виникнути кілька виняткових ситуацій, деякі з них відзначені у частинах except (тут використані стандартні вбудовані виключення Python). Остання частина except в цьому прикладі вловлює всі інші винятки, які не були спіймані вище. Наприклад, якщо хоча б в одному з файлів знаходиться нечислове значення, функція int () порушить виняток ValueError. Його-то і зможе відловити остання частина except. Зрозуміло, виконання частини try у разі виникнення помилки вже не продовжується після виконання однієї з частин except.
На відміну від інших мов програмування, в Python виключення нерідко служать для спрощення алгоритмів. Записуючи оператор try-except, програміст може думати так: "спробую, а якщо зірветься - виконається код в except". Особливо часто це використовується для виразів, в яких значення виходить за словом, з відображення:
try:
value = dict [key]
except:
value = default_value
Замість
if dict.has_key (key):
value = dict [key]
else:
value = default_value
Примітка:
Приклад вже кілька застарілої ідіоми мови Python ілюструє тільки дух цього підходу: у сучасному Python краще записати так :
value = dict.get (key, default_value).
Винятки можна порушувати і з програми. Для цього служить оператор raise. Заодно наступний приклад показує канонічний спосіб визначення власного виключення:
class MyError (Exception):
pass
try:
...
raise MyError, "my error 1"
...
except MyError, x:
print "Помилка:", x
До речі, всі винятки збудовані в ієрархію класів, тому ZeroDivisionError може бути піймана як ArithmeticError, якщо відповідна частина except буде йти раніше.
Для тверджень застосовується спеціальний оператор assert. Він збуджує AssertionError, якщо вказана в ньому умову невірно. Цей оператор використовують для самоперевірки програми. У оптимізованому коді він не виконується, тому будувати на ньому логіку алгоритму не можна. Приклад:
c = a + b
assert c == a + b
Крім описаної форми оператора, є ще форма try-finally для гарантованого виконання деяких дій при передачі управління зсередини оператора try-finally зовні. Він може застосовуватися для звільнення зайнятих ресурсів, що вимагає обов'язкового виконання, незалежно від відбулися всередині катаклізмів:
try:
...
finally:
print "Обробка гарантовано завершена"
1.5. Вбудовані типи даних
Як вже говорилося, всі дані в Python представлені об'єктами. Імена є лише посиланнями на ці об'єкти і не несуть навантаження по декларації типу. Значення вбудованих типів мають спеціальну підтримку в синтаксисі мови: можна записати літерал рядки, числа, списку, кортежу, словника (і їх різновидів). Синтаксичну ж підтримку операцій над вбудованими типами можна легко зробити доступною і для об'єктів визначаються користувачами класів.
Слід також зазначити, що об'єкти можуть бути незмінність і мінливими. Наприклад, рядки в Python є незмінність, тому операції над рядками створюють нові рядки.
Карта вбудованих типів (з іменами функцій для приведення до потрібного типу та іменами класів для наслідування від цих типів):
спеціальні типи: None, NotImplemented і Ellipsis;
числа;
цілі
звичайне ціле int
ціле довільної точності long
логічний bool
число з плаваючою точкою float
комплексне число complex
послідовності;
незмінні:
рядок str;
Unicode-рядок unicode;
кортеж tuple;
мінливі:
список list;
відображення:
словник dict;
об'єкти, які можна викликати:
функції (призначені для користувача і вбудовані);
функції-генератори;
методи (призначені для користувача і вбудовані);
класи (нові та "класичні");
екземпляри класів (якщо мають метод __call__);
модулі;
класи (див. вище);
екземпляри класів (див. вище);
файли file;
допоміжні типи buffer, slice.
Дізнатися тип будь-якого об'єкта можна за допомогою вбудованої функції type ().
Тип int і long
Два типи: int (цілі числа) і long (цілі довільної точності) служать моделлю для представлення цілих чисел. Перший відповідає типу long в компіляторі C для використовуваної архітектури. Числові літерали можна записати в системах числення з основою 8, 10 або 16:
# У цих літерали записано число 10
print 10, 012, 0xA, 10L
Набір операцій над числами - досить стандартний як за семантикою, так і за позначенням:
>>> Print 1 + 1, 3 - 2, 2 * 2, 7 / 4, 5% 3
2 1 4 1 2
>>> Print 2L ** 1000
107150860718626732094842504906000181056140481170553360744375038
837035105112493612249319837881569585812759467291755314682518714
528569231404359845775746985748039345677748242309854210746050623
711418779541821530464749835819412673987675591655439460770629145
71196477686542167660429831652624386837205668069376
>>> Print 3 <4 <6, 3> = 5, 4 == 4, 4! = 4 # порівняння
True False True False
>>> Print 1 <<8, 4>> 2, ~ 4 # побітові зрушення та інверсія
256 1 -5
>>> For i, j in (0, 0), (0, 1), (1, 0), (1, 1):
... print i, j, ":", i & j, i | j, i ^ j # побітові операції
...
0 0: 0 0 0
0 1: 0 1 1
1 0: 0 1 1
1 1: 1 1 0
Значення типу int повинні покривати діапазон від -2147483648 до 2147483647, а точність цілих довільної точності залежить від обсягу пам'яті.
Варто зауважити, що якщо в результаті операції виходить значення, що виходить за рамки допустимого, тип int може бути неявно перетворений в long:
>>> Type (-2147483648)
<type'int'>
>>> Type (-2147483649)
<type'long'>
Також потрібно бути обережним при записі констант. Нулі на початку числа - ознака вісімковій системи числення, в якій немає цифри 8:
>>> 008
File "<stdin>", line 1
008
^
SyntaxError: invalid token
Тип float
Відповідає C-типу double для використовуваної архітектури. Записується цілком традиційним способом або через крапку, або в нотації з експонентою:
>>> Pi = 3.1415926535897931
>>> Pi ** 40
7.6912142205156999e +19
Крім арифметичних операцій, можна використовувати операції з модуля math.
Примітка:
Для фінансових розрахунків краще застосовувати більш відповідний тип.
З корисних вбудованих функцій можна згадати round (), abs ().
Тип complex
Літерал уявної частини задається додаванням j в якості суфікса (перемножуються уявні одиниці):
>>>-1j *-1j
(-1-0j)
Тип реалізований на базі речовинного. Крім арифметичних операцій, можна використовувати операції з модуля cmath.
Тип bool
Підтип цілочисельного типу для "канонічного" позначення логічних величин. Два значення: True (істина) і False (брехня) - ось і все, що належить цим типом. Як вже говорилося, будь-який об'єкт Python має істиннісне значення, логічні операції можна проілюструвати за допомогою логічного типу:
>>> For i in (False, True):
... for j in (False, True):
... print i, j, ":", i and j, i or j, not i
...
...
False False: False False True
False True: False True True
True False: False True False
True True: True True False
Слід зазначити, що Python навіть не обчислює другий операнд операції and або or, якщо її результат ясний по першому операнд. Таким чином, якщо перший операнд правдивий, він і повертається як результат or, в іншому випадку повертається другий операнд. Для операції and все аналогічно.
Тип string і тип unicode
У Python рядка бувають двох типів: звичайні і Unicode-рядки. Фактично рядок - це послідовність символів (у випадку звичайних рядків можна сказати "послідовність байтів"). Рядки-константи можна задати у програмі за допомогою строкових літералів. Для літералів нарівні використовуються як апострофи ('), так і звичайні подвійні лапки ("). Для багаторядкових літералів можна використовувати утроенное апострофи або потроєння лапки. Керуючі послідовності всередині строкових літералів задаються зворотної косою рисою (\). Приклади написання рядкових літералів:
s1 = "рядок1"
s2 = 'рядок2 \ nс перекладом рядка всередині'
s3 = "" "строка3
з переведенням рядка всередині "" "
u1 = u '\ u043f \ u0440 \ u0438 \ u0432 \ u0435 \ u0442' # привіт
u2 = u'Ще приклад '# не забудьте про coding!
Для рядків є ще один різновид: необроблені рядкові літерали. У цих літерали зворотна коса риска та наступні за нею символи не інтерпретуються як спецсимволи, а вставляються в рядок "як є":
my_re = r "(\ d) = \ 1"
Зазвичай такі рядки потрібні для запису регулярних виразів.
Набір операцій над рядками включає конкатенацію "+", повтор "*", форматування "%". Також рядки мають велику кількість методів, деякі з яких наведено нижче. Повний набір методів (і їх необов'язкових аргументів) можна отримати в документації по Python.
>>> "A" + "B"
'AB'
>>> "A" * 10
'AAAAAAAAAA'
>>> "% S% i"% ("abc", 12)
'Abc 12'
Деякі методи строкових об'єктів будуть розглянуті в лекції, присвяченій обробці текстів.
Тип tuple
Для представлення константної послідовності (різнорідних) об'єктів використовується тип кортеж. Літерал кортежу зазвичай записується в круглих дужках, але можна, якщо не виникають неоднозначності, писати і без них. Приклади запису кортежів:
p = (1.2, 3.4, 0.9) # крапка в тривимірному просторі
for s in "one", "two", "three": # цикл за значеннями кортежу
print s
one_item = (1,)
empty = ()
p1 = 1, 3, 9 # без дужок
p2 = 3, 8, 5, # кома в кінці ігнорується
Використовувати синтаксис кортежів можна і в лівій частині оператора присвоювання. У цьому випадку на основі обчислених праворуч значень формується кортеж і зв'язується один в один з іменами в лівій частині. Тому обмін значеннями записується дуже витончено:
a, b = b, a
Тип list
В "чистому" Python немає масивів з довільним типом елемента. Замість них використовуються списки. Їх можна задати за допомогою літералів, записуваних в квадратних дужках, або за допомогою списковий включень. Варіанти завдання списку наведено нижче:
lst1 = [1, 2, 3,]
lst2 = [x ** 2 for x in range (10) if x% 2 == 1]
lst3 = list ("abcde")
Для роботи зі списками існує кілька методів, додаткових до тих, що мають безперервний послідовності. Всі вони пов'язані зі зміною списку.
Послідовності
Нижче узагальнено основні методи послідовностей. Слід нагадати, що послідовності бувають незмінність і мінливими. У останніх методів трохи більше.
Синтаксис
Семантика
len(s)
Довжина послідовності s
x in s
Перевірка приналежності елемента послідовності. У нових версіях Python можна перевіряти приналежність підрядка рядку. Повертає True або False
x not in s
not x in s
s + s1
Конкатенація послідовностей
s*n або n*s
Послідовність з n раз повтореної s. Якщо n <0, повертається порожня послідовність.
s[i]
Повертає i-й елемент s або len (s)-i-й, якщо i <0
s[i:j:d]
Зріз з послідовності s від i до j з кроком d
min(s)
Найменший елемент s
max(s)
Найбільший елемент s
Додаткові конструкції для мінливих послідовностей:
s[i] = x
i-й елемент списку s замінюється на x
s[i:j:d] = t
Зріз від i до j (з кроком d) замінюється на (список) t
del s[i:j:d]
Видалення елементів зрізу з послідовності
Деякі методи для роботи з послідовностями
У таблиці наведено ряд методів мінливих послідовностей (наприклад, списків).
Метод
Опис
append(x)
Додає елемент в кінець послідовності
count(x)
Підраховує кількість елементів, рівних x
extend(s)
Додає до кінця послідовності послідовність s
index(x)
Повертає найменше i, таке, що s [i] == x. Збуджує виняток ValueError, якщо x не знайдений в s
insert(i, x)
Вставляє елемент x в i-й проміжок
pop(i)
Повертає i-й елемент, видаляючи його з послідовності
reverse(s)
Змінює порядок елементів s на зворотний
sort([cmpfunc])
Сортує елементи s. Може бути вказана своя функція порівняння cmpfunc
Взяття елементу по індексу і зрізи
Тут же слід сказати кілька слів про індексуванні послідовностей та виділення підрядків (і взагалі - підпослідовностей) за індексами. Для отримання окремого елемента послідовності використовуються квадратні дужки, в яких стоїть вираз, що дає індекс. Індекси послідовностей в Python починаються з нуля. Негативні індекси служать для відліку елементів з кінця послідовності (-1 - останній елемент). Приклад прояснює справу:
>>> S = [0, 1, 2, 3, 4]
>>> Print s [0], s [-1], s [3]
0 4 3
>>> S [2] = -2
>>> Print s
[0, 1, -2, 3, 4]
>>> Del s [2]
>>> Print s
[0, 1, 3, 4]
Примітка: Видаляти елементи можна тільки з мінливих послідовностей і бажано не робити цього усередині циклу по послідовності.
Кілька цікавіший стан справ зі зрізами. Справа в тому, що в Python при взятті зрізу послідовності прийнято нумерувати не елементи, а проміжки між ними. Спочатку це здається незвичним, тим не менш, дуже зручно для вказівки довільних зрізів. Перед нульовим (за індексом) елементом послідовності проміжок має номер 0, після нього - 1 тощо. Негативні значення відраховують проміжки з кінця стрічки. Для запису зрізів використовується наступний синтаксис:
послідовність [поч: кон: крок]
де поч - проміжок початку зрізу, кон - кінця зрізу, крок - крок. За замовчуванням поч = 0, кон = len (послідовність), крок = 1, якщо крок не вказаний, друге двокрапку можна опустити.
А тепер приклад роботи зі зрізами:
>>> S = range (10)
>>> S
[0, 1, 2, 3, 4, 5, 6, 7, 8, 9]
>>> S [0:3]
[0, 1, 2]
>>> S [-1:]
[9]
>>> S [:: 3]
[0, 3, 6, 9]
>>> S [0:0] = [-1, -1, -1]
>>> S
[-1, -1, -1, 0, 1, 2, 3, 4, 5, 6, 7, 8, 9]
>>> Del s [: 3]
>>> S
[0, 1, 2, 3, 4, 5, 6, 7, 8, 9]
Як видно з цього прикладу, за допомогою зрізів зручно задавати будь-який підрядок, навіть якщо він нульової довжини, як для видалення елементів, так і для вставки у певне місце.
Тип dict
Словник (хеш, асоціативний масив) - це змінна структура даних для зберігання пар “ключ-значення”, де значення однозначно визначається ключем. Як ключ може виступати безперервний тип даних (число, рядок, кортеж і т.п.). Порядок пар “ключ-значення” довільний. Нижче наведено літерал для словника й приклад роботи зі словником:
d = {1: 'one', 2: 'two', 3: 'three', 4: 'four'}
d0 = {0: 'zero'}
print d [1] # береться значення по ключу
d [0] = 0 # присвоюється значення по ключу
del d [0] # видаляється пара ключ-значення з даними ключем
print d
for key, val in d.items (): # цикл по всьому словником
print key, val
for key in d.keys (): # цикл по ключах словника
print key, d [key]
for val in d.values (): # цикл за значеннями словника
print val
d.update (d0) # поповнюється словник з іншого
print len (d) # кількість пар у словнику
Тип file
Об'єкти цього типу призначені для роботи із зовнішніми даними. У простому випадку - це файл на диску. Файлові об'єкти повинні підтримувати основні методи: read (), write (), readline (), readlines (), seek (), tell (), close () і т.п.
Наступний приклад показує копіювання файлу:
f1 = open ("file1.txt", "r")
f2 = open ("file2.txt", "w")
for line in f1.readlines ():
f2.write (line)
f2.close ()
f1.close ()
Варто зауважити, що крім власне файлів в Python використовуються і файлоподобні об'єкти. У дуже багатьох функціях просто неважливо , переданий їй об'єкт типу file або іншого типу, якщо він має всі ті ж методи (і в тому ж сенсі). Наприклад, копіювання вмісту по посиланню (URL) у файл file2.txt можна досягти, якщо замінити перший рядок на:
import urllib
f1 = urllib.urlopen ("http://python.org")
1.6. Вирази
У сучасних мовах програмування прийнято проводити більшу частину обробки даних у виразах. Синтаксис виразів у багатьох мов програмування приблизно однаковий. Синтаксис виразів Python не здивує програміста чимось новим. (Хіба що цепочечниє порівняння можуть приємно порадувати.)
Пріоритет операцій показаний в таблиці, що (у порядку зменшення). Для унарних операцій x позначає операнд. Асоціативність операцій в Python - зліва-направо, за винятком операції піднесення до степеня (**), яка асоціативна справа наліво.
Операція
Назва
lambda
лямбда-вираз
or
логічне АБО
and
логічне І
not x
логічне НЕ
in, not in
перевірка приналежності
is, is not
перевірка ідентичності
<,<=,>,>=,!=,==
Порівняння
|
Побітове АБО
^
Побітове виключає АБО
&
Побітове І
<<,>>
Побітові зрушення
+, -
Додавання і віднімання
*, /,%
Множення, ділення, залишок
+ X,-x
унарний плюс і зміна знака
~ X
побітове НЕ
**
Зведення в ступінь
x.
атрібут посилання на атрибут
x [індекс]
взяття елемента за індексом
x [від: до]
виділення зрізу (від і до)
f (аргумент ,...)
виклик функції
(...)
Дужки або кортеж
[... ]
Список або списковому включення
{Кл: зн, ...}
словник пар ключ-значення
`Вираз`
перетворення до рядка (repr)
Таким чином, порядок обчислень операндів визначається такими правилами:
Операнд зліва обчислюється раніше операнда праворуч у всіх бінарних операціях, крім зведення в ступінь.
Ланцюжок порівнянь виду a <b <c ... y <z фактично рівносильний: (а <b) and (b <c) and ... and (y <z).
Перед фактичним виконанням операції обчислюються потрібні для неї операнди. У більшості бінарних операцій попередньо обчислюються обидва операнда (спочатку лівий), але операції or і and, а також ланцюжки порівнянь обчислюють таку кількість операндів, яке достатньо для отримання результату. У невичісленной частині виразу в такому випадку можуть навіть бути невизначені імена. Це важливо враховувати, якщо використовуються функції з побічними ефектами.
Аргументи функцій, вирази для списків, кортежів, словників тощо обчислюються зліва-направо, в порядку проходження у виразі.
У разі неясності пріоритетів бажано застосовувати дужки. Незважаючи на те, що одні й ті ж символи можуть використовуватися для різних операцій, пріоритети операцій не змінюються. Так,% має той же пріоритет, що і *, а тому в наступному прикладі дужки просто необхідні, щоб операція множення сталася перед операцією форматування:
print "% i"% (i * j)
Вирази можуть фігурувати в багатьох операторах Python і навіть як самостійний оператор. У висловлювання завжди є результат, хоча в деяких випадках (коли вираз обчислюється заради побічних ефектів) цей результат може бути "нічим" - None.
Дуже часто вираження стоять у правій частині оператора присвоювання чи розширеного присвоєння. У Python (на відміну, скажімо, від C) немає операції присвоюння, тому синтаксично перед знаком = можуть стояти тільки ідентифікатор, індекс, зріз, доступ до атрибуту або кортеж (список) з перерахованого. (Подробиці в документації).
1.7. Імена
Про імена (ідентифікатори) говорилося вже не раз, тим не менш, необхідно сказати кілька слів про їх застосування в мові Python.
Ім'я може починатися з латинської літери (будь-якого регістра) або підкреслення, а далі допустимо використання цифр. В якості ідентифікаторів не можна застосовувати ключові слова мови і небажано перевизначати вбудовані назви. Список ключових слів можна дізнатися так:
>>> Import keyword
>>> Keyword.kwlist
['And', 'assert', 'break', 'class', 'continue', 'def', 'del',
'Elif', 'else', 'except', 'exec', 'finally', 'for', 'from',
'Global', 'if', 'import', 'in', 'is', 'lambda', 'not', 'or',
'Pass', 'print', 'raise', 'return', 'try', 'while', 'yield']
Імена, що починаються з підкреслення або двох підкреслень, мають особливий сенс. Одиночне підкреслення говорить програмісту про те, що ім'я має місцеве застосування, і не повинно використовуватися за межами модуля. Подвійним підкресленням на початку і в кінці зазвичай наділяються спеціальні імена атрибутів - про це йтиметься у лекції з об'єктно-орієнтованого програмування.
У кожній точці програми інтерпретатор "бачить" три простори імен: локальне, глобальне та вбудоване. Простір імен - відображення з імен в об'єкти.
Для розуміння того, як Python знаходить значення деякої змінної, необхідно ввести поняття блоку коду. У Python блоком коду є те, що виконується як єдине ціле, наприклад, тіло визначення функції, класу або модуля.
Локальні імена - імена, яким присвоєно значення в даному блоці коду. Глобальні імена - імена, які визначають на рівні блоку коду визначення модуля або ті, які явно задані в операторі global. Вбудовані імена - імена із спеціального словника __builtins__.
Області видимості імен можуть бути вкладеними один в одного, наприклад, всередині викликаної функції видно імена, визначені в зухвалій коді. Змінні, які використовуються в блоці коду, але пов'язані зі значенням поза коду, називаються вільними змінними.
Так як змінну можна пов'язати з об'єктом у будь-якому місці блоку, важливо, щоб це відбулося до її використання, інакше буде порушено виняток NameError. Зв'язування імен зі значеннями відбувається в операторах присвоювання, for, import, у формальних аргументах функцій, при визначенні функції або класу, в другому параметрі частини except оператора try-except.
З областями видимості і зв'язуванням імен є багато нюансів, які добре описані в документації. Бажано, щоб програми не залежали від таких нюансів, а для цього досить дотримуватися наступних правил:
Завжди слід пов'язувати змінну зі значенням (текстуально) до її використання.
Необхідно уникати глобальних змінних і передавати всі як параметри. Глобальними на рівні модуля повинні залишитися тільки імена-константи, імена класів і функцій.
Ніколи не слід використовувати from модуль import * - це може призвести до затінення імен з інших модулів, а всередині визначення функції просто заборонено.
Переважно переробити код, ніж використовувати глобальну змінну. Звичайно, для програм, що складаються з одного модуля, це не так важливо: адже всі визначені на рівні модуля змінні глобальні.
Прибрати зв'язок імені з об'єктом можна за допомогою оператора del. У цьому випадку, якщо об'єкт не має інших посилань на нього, він буде вилучений. Для керування пам'яттю в Python використовується підрахунок посилань (reference counting), для видалення наборів об'єктів з зацикленими посиланнями - збірка сміття (garbage collection).
2. Основні стандартні модулі Python
Одним з важливих переваг мови Python є наявність великої бібліотеки модулів і пакетів, що входять в стандартну поставку. Як кажуть, до Python "включені батарейки".
2.1. Поняття модуля
Перед тим як приступити до вивчення модулів стандартної бібліотеки, необхідно визначити те, що в Python називається модулем.
Відповідно до модульного підходу до програмування велике завдання розбивається на декілька більш дрібних, кожну з яких (в ідеалі) вирішує окремий модуль. У різних методологіях даються різні обмеження на розмір модулів, однак при побудові модульної структури програми важливіше скласти таку композицію модулів, яка дозволила б звести до мінімуму зв'язки між ними. Набір класів і функцій, що має безліч зв'язків між своїми елементами, було б логічно розташувати в одному модулі. Є й ще одна корисне зауваження: модулі має бути легше використовувати, ніж написати заново. Це означає, що модуль повинен мати зручний інтерфейс: набір функцій, класів і констант, який він пропонує своїм користувачам.
У мові Python набір модулів, присвячених одній проблемі, можна помістити в пакет. Гарним прикладом такого пакету є пакет xml, в якому зібрані модулі для різних аспектів обробки XML.
У програмі...
Ділись своїми роботами та отримуй миттєві бонуси!
0%
Оголошення від адміністратора