ИВАЙЛО СИМЕОНОВ ЧЕНЧЕВ
Учебно пособие по
ОСНОВИ НА ПРОГРАМИРАНЕТО
(лекции и упражнения по Python)
Версия: 1.0
Формат: електронен, pdf
ИЗДАТЕЛСТВО ®
^ГЛАС-И
София, 2023
Съдържание
1.	Въведение в курса.................................................................7
1.1.	История на компютърното програмиране.........................................8
1.2.	Компютърни архитектури......................................................11
1.2.1.	Според дължината на думата...............................................11
1.2.2.	Според архитектурата на процесора........................................11
1.2.3.	Според организацията на паметта..........................................14
1.3.	Транслатори.................................................................16
1.4.	Последователно и паралелно изпълнение.......................................17
1.5.	Типове езици за програмиране................................................20
1.6.	Алгоритми...................................................................20
1.6.1.	Понятие за алгоритъм.....................................................21
1.6.2.	Блок-схеми...............................................................21
1.6.3.	Сложност на алгоритмите..................................................24
1.7.	Процес на разработване на програми..........................................25
1.8.	Работна среда...............................................................26
1.8.1.	Изпълнение на кода on-line...............................................26
1.8.2.	Изпълнение на кода локално...............................................Т1
1.9.	Допълнителна терминология...................................................27
2.	Езика Python.....................................................................28
2.1.	Синтаксис...................................................................28
2.2.	Ключови думи................................................................31
2.3.	Операции и оператори........................................................32
2.4.	Променливи..................................................................35
2.5.	Видимост на имената.........................................................36
2.6.	Конвенция на имената........................................................38
2.7.	Символът двоеточие..........................................................39
3.	Типове дан ни в Python...........................................................40
3.1.	Текстов тип - str...........................................................40
3.2.	Цифров тип - int, float, complex............................................42
3.3.	Булев тип - boolean.........................................................44
3.4.	Тип речник - diet...........................................................45
3.5.	Типове „последователности" - list, tuple, range.............................46
3.5.1.	Тип list.................................................................46
3.5.2.	Тип tuple................................................................48
3.5.3.	Тип range................................................................50
3.6.	Тип множество - set.........................................................51
3.7.	Двоичен тип - byte, bytearray, memoryview...................................51
3.8.	Тип NoneType................................................................52
3.9.	Проверка на типа на данните.................................................52
Учебно пособие по ОП, ас. д-р инж. Ивайло Симеонов Ченчев
2
4.	Операторы за разклонение..................................................52
4.1.	Оператор if-elif-else.................................................52
4.2.	Оператор switch.......................................................54
5.	Оператора за цикъл........................................................55
5.1.	Оператор for..........................................................56
5.2.	Оператор while........................................................57
6.	Оператора break, continue, pass...........................................58
6.1.	Оператор break........................................................58
6.2.	Оператор continue.....................................................59
6.3.	Оператор pass.........................................................60
7.	Методът slice()...........................................................60
8.	Методът range()...........................................................62
9.	Вложена цикли.............................................................63
10.	Масиви....................................................................65
10.1.	Едномерен масив.......................................................65
10.2.	Двумерен масив........................................................66
11.	Работа със списъци........................................................67
11.1.	Създаване.............................................................67
11.1.1.	Чрез използване на квадратни скоби [].............................67
11.1.2.	Чрез метод на обхващането.........................................68
11.1.3.	Чрез използване на конструктор метод..............................68
11.1.4.	Обобщение.........................................................68
11.2.	Достъпване............................................................69
11.3.	Промяна...............................................................70
11.4.	Изтриване.............................................................72
11.5.	Обхождане на елементите...............................................73
11.6.	Обхващане на списък...................................................75
11.7.	Сортиране.............................................................78
11.8.	Копиране..............................................................80
11.9.	Свързване.............................................................81
11.10.	Допълнителни методи за работа със списъци.............................82
12.	Работа с данни от тип String..............................................86
12.1.	Методи за работа със стрингове........................................90
13.	Работа с данни от тип Tuple...............................................94
14.	Работа с данни от тип речник (Diet).......................................99
15.	Сложна типове данни......................................................106
15.1.	Списък от списъци (List of lists)....................................106
Учебно пособие по ОП, ас. д-р инж. Ивайло Симеонов Ченчев	3
15.2.	Превръщане на diet в list of tuples..................................108
15.3.	Превръщане на list of tuples в diet..................................108
16.	Функции..................................................................109
16.1.	Вградени функции.....................................................115
16.2.	Ламбда функции.......................................................116
16.3.	Рекурсивни функции...................................................117
17.	Работа с файлове.........................................................119
18.	Модули и Пакети..........................................................124
18.1.	Модули...............................................................124
18.2.	Пакети...............................................................126
19.	Документиране (Docstring)................................................127
20.	Взаимодействие с ОС......................................................130
20.1.	Модул os.............................................................133
20.2.	Модул shutil.........................................................134
21.	Методи за сортиране......................................................135
21.1.	Метод на мехурчето...................................................136
21.2.	Оптимизиран метод на мехурчето.......................................139
22.	Обработка на неочаквани грешки...........................................139
22.1.	Обработка на изключения..............................................140
22.2.	Assertions...........................................................142
23.	Аргументи от командния ред...............................................144
23.1.	Модул sys............................................................144
23.2.	Модул getopt.........................................................144
23.3.	Модул argparse.......................................................146
24.	Допълнителна информация..................................................146
24.1.	Кодиране и кодови таблици............................................146
24.1.1.	Формат UTF-8.....................................................146
24.2.	Вградена променлива__name............................................148
24.3.	Форматиране на стринг................................................149
24.4.	Работа с дати........................................................151
24.5.	Регулярни изрази.....................................................152
25.	Задачи за самоподготовка.................................................162
26.	Речник...................................................................169
27.	Използвани съкращения....................................................170
28.	Литература...............................................................170
Учебно пособие по ОП, ас. д-р инж. Ивайло Симеонов Ченчев
4
Списък на фигурите
Фигура 1: Типове процесорни (CPU) архитектури....................................................12
Фигура 2: CISC архитектура и нейни представители.................................................12
Фигура 3: RISC архитектура и нейни представители.................................................13
Фигура 4: ARM архитектура........................................................................14
Фигура 5: Организация на паметта (RAM Memory)....................................................14
Фигура 6: Шестнадесетичното число - байтова последователност.....................................15
Фигура 7: Big Endian записване на дума в паметта.................................................15
Фигура 8: Little Endian записване на дума в паметта..............................................16
Фигура 9: Видове Транслатори.....................................................................17
Фигура 10: Последователно изпълнение с една нишка................................................18
Фигура 11: Последователно изпълнение с много нишки...............................................18
Фигура 12: Псевдо-паралелно изпълнение с една нишка..............................................19
Фигура 13: Псевдо-паралелно изпълнение с няколко нишки, но при процесор с едно ядро..............19
Фигура 14: Паралелно изпълнение с няколко нишки, при процесор с четири ядра......................19
Фигура 15: Типове езици за програмиране..........................................................20
Фигура 16: Блок-схема - начален блок.............................................................21
Фигура 17: Блок-схема - краен блок...............................................................21
Фигура 18: Блок-схема - разклонение..............................................................22
Фигура 19: Блок-схема - блок действие............................................................22
Фигура 20: Блок-схема - блок за въвеждане на данни...............................................22
Фигура 21: Блок-схема - блок за извеждане/отпечатване............................................23
Фигура 22: Блок-схема на алгоритъм - сума на четните естествени числа............................23
Фигура 23: Пример за отместване на блок (indentation)............................................28
Фигура 24: Произволно отместване, но в два различии блока........................................28
Фигура 25: Пример за грешно отместване...........................................................29
Фигура 26: Индексиране на tuple*.................................................................49
Фигура 27: Блок-схема на оператор за цикъл for...................................................56
Фигура 28: Блок-схема на оператор за цикъл while.................................................57
Фигура 29: List comprehension - използване на условие и филтрране................................77
Учебно пособие по ОП, ас. д-р инж. Ивайло Симеонов Ченчев	5
Списък на таблиците
Таблица 1:	Аритметични оператори...........................................................32
Таблица 2:	Оператори за присвояване на стойност............................................33
Таблица 3:	Оператори за сравнение..........................................................33
Таблица 4:	Логически оператори.............................................................33
Таблица 5:	Оператори за идентичност........................................................34
Таблица 6:	Оператори за членство...........................................................34
Таблица 7:	Побитови оператори..............................................................34
Таблица 8:	UTF-8 кодова таблица*..........................................................147
Учебно пособие по ОП, ас. д-р инж. Ивайло Симеонов Ченчев
6
1.	Въведение в курса
Учебното пособие по „Основи на програмирането" е електронно издание,
предназначено за студентите от първи курс на Висше училище по телекомуникации и
пощи (ВУТП) и съдържа лекции и задачи за упражнения по програмиране на езика
Python. Базирано е на задължителната дисциплина Основи на програмирането, която
студентите от всички специалности в първи курс на ВУТП минават. Дисциплината
предвижда лекции и лаборатории упражнения.
Целта на курса е да се дадат основни понятия по програмиране, да се
представят средствата за писане на програми на езика Python - типове данни, езикови
конструкции и правила за прилагането им. Казано по друг начин - да се добият
първоначални знания и умения за работа със съвременния език от високо ниво -
Python.
Целевата аудитория на курса са студентите от първи и трети курс на ВУТП от
всички специалности. Естествено, пособието може да бъде използвано свободно от
всеки, конто прохожда в програмирането на езика Python.
Целта на тази глава е да се направи кратък обзор на компютърните
архитектури, видовете транслатори, начините на изпълнение на кода
(последователно и паралелно), типовете езици за програмиране, схематичното
представяне алгоритми и тяхната сложност, съвременната методология за
разработване на софтуер (DevOps), както и на средствата/средите за писане на
код. Това въведение също така представя и обяснява основни понятия от
Информационните Технологии (ИТ). Част от тях нарочно са представени на
английски език, поради факта, че огромна част от съществуващата информация
по темата е на английски език и е добре читателите да свикнат да работят с
терминологията. Всички английски термини са детайлно описани и обяснени.
Еднократното прочитане на материала не е достатъчно за неговото
усвояване на необходимото ниво за свободно четене и писане на програми.
Програмиране се учи с постоянство и много решаване на задачи (писане на
програми).
Учебно пособие по ОП, ас. д-р инж. Ивайло Симеонов Ченчев
7
1.1.	История на компютърното програмиране
Хората и машините обработват информацията по различен начин и
езиците за програмиране са ключът към преодоляването на дистанцията между
хората и компютрите. Развитието на съвременната изчислителна техника
започва през ранните години на XVIII-ти век. Първите изчислителни устройства
имат специализирано приложение.
За целите на курса ще бъдат описани хронологично само някои от
важните дати за развитието на програмирането.
1820 г. Difference engine (Charles Babbage / Чарлс Бабидж)
За създател на първия автоматичен цифров компютър (т.нар.
Difference engine) се смята английския математик и изобретател
Чарлз Бабич (Charles Babbage), който работи по неговото създаване
в периода 1820-1830 година.
1823 г. Analytical engine (Charles Babbage, Ada Byron / Ада Байрон)
(Някои автори говорят за датата 1837 г.)
Създаване на примитивен механичен калкулатор.
Ада написва алгоритъм, за изчисление на числата на Вернули. Счита
се, че това е първата компютърна програма.
1936 г. Turing machine - Машина на Тюринг (Alan Turing / Алън Тюринг)
Алън Тюринг - английски математик, компютърен учен, логик,
крипто-аналитик, философ и теоретичен биолог.
Машината на Тюринг представлява теоретично устройство, което
може да моделира всяко изчисление. Казано по друг начин, това е
математически модел на изчисление, описващ абстрактна машина,
която манипулира символи върху лента, съгласно таблица с правила.
Тази машина (или устройство) може да реализира всеки компютърен
алгоритъм. Съществува понятието „Универсална машина на
Тюринг", която може да симулира произволна машина на Тюринг на
произволен вход. Тази машина представлява устройство, което
може да моделира всяко изчисление.
Учебно пособие по ОП, ас. д-р инж. Ивайло Симеонов Ченчев
8
1942 г. ENIAC (Electronic Numerical Integrator and Computer)
Започва работата по устройството, което е първият программруем
електронен цифров компютър с общо предназначение. Завършен е
през 1945 г. При тази машина, физическою движение е заменено от
електрически сигнали. Устройството е заемало площ от 167 т2 и е
тежало 30 тона.
ENIAC изчислява траектория за 30 секунди, която отнема на човек 20
часа.
1945 г. John Von Neumann (Джон фон Нойман)
Въвежда две важни концепции - пътя на компютърните програмни
езици [11:
Концепция 1: “техника на споделена програма"- HW на компютъра
трябва да е прост и да не е необходимо да се създава/свързва
ръчно за всяка програма. Трябва да се използват сложни
инструкции за управление на простия хардуер, което позволява
много по-бързото му препрограмиране.
Концепция 2: “условен контролен трансфер":
Подпрограми или малки блокове код към конто може да се
прескача в произволен ред, вместо един набор от
хронологично подредени стъпки, конто компютърът да
предприема.
Компютърния код трябва да може да се разклонява въз
основа на логически твърдения, такива като IF (израз) THEN
и цикличен, като например с оператор FOR
Поражда идеята за „библиотеки", конто са блокове от код,
конто могатда се използват отново и отново.
1957 г. FORTRAN (FORmula TRANslation)
Компанията IBM създава езика FORTRAN за научни изчисления.
Езикът включва IF, DO и GOTO оператори.
1957 г. COBOL (Common Business-Oriented Language)
Този език е подобен на Англ. ез. (english-like) и е предназначен за
бизнес употреба. По тип е процедурен, императивен (операциите се
Учебно пособие по ОП, ас. д-р инж. Ивайло Симеонов Ченчев
9
	извършват стъпка по стъпка). Използва се главно в т.нар. мейнфрейм компютърните архитектури (mainframe).
1958 г.	LISP (List Processing) Този езике създаден от John McCarthy. Предназначен за изследване в Изкуствен Интелект (Artificial Intelligence - Al).
1958 г.	ALGOL (ALGOrithmic Language) Този език поставя основите на езици като Pascal, С, C++, and Java. Следващата версия на езика, Algol 68 е много трудна за използване.
1968 г.	Езикът Pascal Създател е Niklaus Wirth (Никлаус Вирт) - швейцарски компютърен учен, който проектира и няколко други езика за програмиране. През 1975 г. издава книгата „Алгоритми + Структури от Данни = Програми"( Algorithms + Data Structures = Programs), на която е автор.
1972 г.	Езикът С Dennis Ritchie (Денис Ричи) създава езика „С" в лабораториите Bell (Ню Джърси). Основното предназначение на езика е за използване в операционната система Unix. През 1978, Brian Kernighan (Брайън Кърниган) и Denis Ritchie (Денис Ричи) издават книгата "Езикът за програмиране С".
1972 г.	SQL (Structured Query Language) SQL e език за програмиране. Създаден от изследователите Raymond Воусе и Donald Chamberlain в IBM.
1970's - 1980's OOP (Object-Oriented Programming - Обектно-Ориентирано
	Програмиране) Основите на ООП - това е езика "С" с класове.
1983 г.	Езикът C++ Създаден е от Bjarne Stroustrup.
1987 г.	Езикът Perl
Учебно пособие по ОП, ас. д-р инж. Ивайло Симеонов Ченчев
10
Създател на езика Perl е Larry Wall (Лари Уол)
1991 г. Езикът Python
Създаден от Guido Van Rossum (холандски програмист). Python е
език от високо ниво с общо предназначение. Това е един от най-
популярните езици в света. URL: https://www.python.org/
1995 г. Създаване на езиците за програмиране: Java, PHP, JavaScript
2000 г. Създаване на C#
1.2.	Компютърни архитектури
Направената класификация на компютърните архитектури е според трите
основни критерия - дължина на думата, тип на процесора (CPU - Central
Processing Unit- на български: централен процесор или само процесор) и според
организацията на паметта.
1.2.1.	Според дължината на думата
Понятието „дума" (word) като термин от микропроцесорната техника
представлява количеството информация, която регистър за данни на даден
процесор може да обработи едновременно. Измерва се в битове. Ако процесор
може да обработи 8-бита едновременно, то той има 8-битова дума (за данни) и
се казва, че процесора е 8-битов. Ако може да обработи 16 бита едновременно,
то неговата дума е 16-битова и следователно този процесор е 16-битов.
Аналогично - при едновременна обработка на 32 бита, думата е с дължина 32
бита, процесора е 32-битов и т.н.
1.2.2.	Според архитектурата на процесора
Съвкупността от инструкции, конто даден процесор може да изпълнява
се нарича „множество инструкции" или „набор от инструкции". Те са
специфични за всеки процесор и зависят от неговата архитектура.
Съществуват три основни типа архитектури според вида на процесора.
Показани са на Фиг.1:
Учебно пособие по ОП, ас. д-р инж. Ивайло Симеонов Ченчев
11
Фигура 1: Типове процесорни (CPU) архитектура
•	CISC (Complex Instruction Set Computer) - Времето за изпълнение на
инструкциите на процесорите варира в голям диапазон. Инструкциите
са с различна дължина. Някои от тях изискват много време за
изпълнение, в резултат на изпълнението на повече действия. Докато
други инструкции се изпълняват много по-бързо. На Фиг.2 са
представени двете големи фирми, производители на процесори от тип
CISC - Intel и AMD. Схематично са представени няколко типа Intel
процесори според дължината на думата, както и няколко реални
представителя в лицето на Хеоп процесора (х86-64 архитектура),
Pentium процесора, базиран на 32-битова архитектура и т.н.
Фигура 2: CISC архитектура и нейни представители
•	RISC (Reduced Instruction Set Computer) - Времената за изпълнение на
инструкциите на процесорите от този тип архитектура са сравнително
близки. Множествата от инструкциите са малки и силно-
Учебно пособие по ОП, ос. д-р инж. Ивойло Симеонов Ченчев
12
специализирани. Инструкциите извършват малко на брой действия, но
за сметка на това се изпълняват бързо. Това се постига чрез увеличен
брой регистри и инструкции с еднаква дължина. Следователно,
необходимостта от зареждане и съхранение на данни в паметта е
малка. На лице е възможност за паралелизъм на задачите. На Фиг.З са
представени няколко от най-големите производители на RISC
процесори, както и конкретни представители. Например RISC
процесора на фирмата HP (Hewlett-Packard) е РА-RISC; RISC процесора
на фирмата IBM е RS/6000 и т.н.
Фигура 3: RISC архитектура и нейни представители
•	ARM (Advanced RISC Machine) - В сравнение с останалите два типа
архитектури, ARM процесорите са по-евтини, имат по-малка
консумация на ток и респективно генерират по-малко топлина. Този
тип архитектура на процесори се притежава от компанията "ARM
Holding". Т.е. всеки, конто иска да използва ARM процесори в своите
устройства, трябва да плаща авторски права на компанията ARM
Holding. Нейната мисия е да внедри енергийно ефективна технология,
базирана на ARM, навсякъде, където се случват изчисления. ARM има
голяма поддръжка от онлайн общности (online communities), конто
подпомагат дизайнерите при разработването на широк диапазон от
устройства като микроконтролери, сървъри и др. Важна особеност на
ARM архитектурите е адресирането на паметта, която е "bi-endian" (за
видовете организация и адресиране на паметта - виж следващите
теми). На Фиг.4 е показана схематично ARM архитектурата от гледна
точка на фирми производители. Като под "third-party" са компании,
Учебно пособие по ОП, ос. д-р инж. Ивайло Симеонов Ченчев
13
които плащат авторски права на компанията ARM Holding за това, че
използватАВМ архитектурата втехните процесори.
Фигура 4: ARM архитектура
1.2.3. Според организацията на паметта
Съществуват три главни типа архитектури, в зависимост от това как се
разполага последователността от байтове на думата в паметта (и съответно как
е реализирано тяхното адресиране). Това са т.нар. „Big Endian", „Little Endian",
,,Bi-endianness" и са показани на Фиг.5.
Фигура 5: Организация на паметта (RAM Memory)
За онагледяване на разположението на данни в паметта ще бъде
разгледан един пример. Нека имаме една 32-битова дума - шестнадесетичното
число A842503F(i6). За да го запишем в паметта, ще са необходими четири байта.
Байтовото представяне е показано на Фиг.6, където най-значимия (най-старшия)
байт е първия (А8), последван съответно от 48, 50 и най-накрая е четвъртия байт,
който съдържа стойността 3F. Съответно байт 4 е най-младшия.
Учебно пособие по ОП, ос. д-р инж. Ивойло Симеонов Ченчев
14
Най-старшия
байт (MSB)
Най-младшия
байт (LSB)
А8	42	50	3F
байт 1	байт 2
байт 3	байт 4
Фигура 6: Шестнадесетичното число - байтова последователност
За да бъде записано това число в паметта, трябва да бъдат използвани
четири байта. Записването в паметта се определя според следните три типа
архитектури:
•	Big Endian - Записването в паметта става по следния начин: най-
старшия байт (MSB) се записва на даден адрес; след него, на следващия
по големина адрес се записва следващия по значимост байт и т.н.
докато се запише цялото число. На най-големия адрес се записва най-
младшия байт (LSB). Числото от примера, който се разглежда,
представено в Big Endian архитектура е показано на Фиг.7:
адрес: п	адрес: п+1	адрес: п+2	адрес: п+3
А8	42	50	3F
Най-старшия			Най-младшия
байт (MSB)			байт (LSB)
Фигура 7: Big Endian записване на дума в паметта
•	Little Endian - Записването в паметта става по следния начин: най-
младшия байт (LSB) се записва на даден адрес; по-старшия байт се
записва на следващия адрес и т.н. докато се запише цялото число. На
най-големия адрес се записва най-старшия байт (MSB). Числото от
примера, който се разглежда, представено в Little Endian архитектура е
показано на Фиг.8:
адрес: п	адрес: п+1 адрес: п+2 адрес: п+3
3F	50	42	А8
Най-младшия	Най-старшия
байт (LSB)	байт (MSB)
Учебно пособие по ОП, ас. д-р инж. Ивайло Симеонов Ченчев
15
Фигура 8: Little Endian записване на дума в паметта
•	Bi-endianness - Процесорите (ARM, PowerPC, Itanium), реализиращи
тази архитектура предоставят възможността да се избира по какъв
начин да се записват думите в паметта - в Big Endian или в Little Endian.
1.3.	Транслатори
Транслаторът е програма, която конвертира програмата (сорс-кода) в
обектен код. На Фиг.9 са показани видовете транслатори, видовете програмни
езици с конто работят, както и имената на действията, конто извършват по време
на транслирането на програмите.
Асемблерът транслира асемблерен език в обектен код. Асемблерния
език е език от ниско ниво. Командите му всъщност представляват набора от
инструкции на даден процесор. Т.е. при асемблерния език командите и начина
на тяхното използване са специфични за всеки процесор.
Интерпретаторът транслира програмата (сорс-кода) в обектен код, но по
една инструкция в даден момент. Изпълнението на програмата става ред по
ред последователно. Това изпълнение се извършва (управлява) от
интерпретаторът.
Компилаторът взема програмата (сорс-кода) като едно цяло и я
превежда в обектен код наведнъж. Този процес се нарича компилация. Веднъж
преобразуван, обектният код може да бъде стартиран по всяко време.
Действието, което извършва за създаване на изпълним файл от обектния файл
се нарича свързване (link), а програмата, която извършва това действие се
нарича линкер (linker). За да бъде изпълнена компилирана програма и вече
свързана програма, не е необходимо да разполагаме с компилатор по време на
изпълнението.
Интерпретаторът и компилаторът обработват програми, конто са
написани на език от високо ниво. Езиците от високо ниво са програмни езици,
много близки по начин на изписване на командите и правилата за тяхното
използване (синтаксис) на човешките езици.
Учебно пособие по ОП, ас. д-р инж. Ивайло Симеонов Ченчев
16
Фигура 9: Видове Транслатори
1.4.	Последователно и паралелно изпълнение
При извършване на дадена обработка, програмата, която изпълнява
алгоритъма може да работи последователно или паралелно. Какво означава
това? При последователната работа, следваща инструкция се подава за
изпълнение само тогава, когато текущата инструкция свърши своята работа (или
бъде спряна от ОС-a, изчаквайки някакъв ресурс, но това е малко по специфичен
случай, защото при това положение може и да не може да продължи работата
на програмата, докато не получи ресурса, който чака). При паралелното
изпълнение, програмата има (в общия случай) предварително дефинирани
участъци от код, конто са независими един от друг и може да работят
едновременно. Например при работа с различии сегменти от данните - прави се
обобщаваща отчетна справка по години, като данните за съответните години са
независими едни от други - при това положение, може да се стартират
едновременни (паралелни) обработки. Като цяло, при паралелните обработки
времето за изпълнение е по-кратко от необходимото такова при последователно
изпълнение.
Учебно пособие по ОП, ос. д-р инж. Ивойло Симеонов Ченчев
17
Осем-битовите процесори представляват един CPU. При тях, за да се
постигне ефект на паралелна обработка, процесора използва механизъм на
време деление. Стартира се за изпълнение една част от кода, след едно малко
количество време се спира и ОС-a стартира друга част от кода и т.н. докато
свършат всички „едновременни" обработки. Съвременните процесори, освен,
че имат много ядра, използват и т.нар. „нишки" (threads) за постигане на реално
паралелно изпълнение.
На Фиг.10 е показано последователно изпълнение на задачи, при
използване на една нишка. При този вид изпълнение, след като свърши работа
задача 1, започва да работи задача 2. След като свърши работа задача 2, започва
работа задача 3 и т.н.
време
една нишка
(one thread)
задача 1 задача 2 задача 3 задача 4
Фигура 10: Последователно изпълнение с една нишка
На Фиг.11 е показано последователно изпълнение на задачи, при
използване на повече нишки. При този вид изпълнение все още имаме
последователност при работата, но управлението е малко по-сложно, заради по-
големия брой нишки.
време
нишка 1
(thread 1)
задача 1
нишка 2
(thread 3)
нишка 3
(thread 3)
нишка 4
(thread 4)
задача 2
задача 3
задача
4
Фигура 11: Последователно изпълнение с много нишки
На Фиг.12 е показано псевдо-паралелно изпълнение на задачи, при
използване на една нишка. Всяка задача получава процесорно време за точно
Учебно пособие по ОП, ас. д-р инж. Ивайло Симеонов Ченчев
18
определен интервал. Създава се илюзията, че работят всички задачи
одновременно и от там идва термина: „псевдо-паралелно".
време
една нишка
(one thread)
зад. 1	зад. 2	зад. 3	зад. 1	зад. 4	зад. 2	зад. 1	зад. 3	зад. 4
Фигура 12: Псевдо-паралелно изпълнение с една нишка
На Фиг.13 е показано едновременно (псевдо-паралелно) изпълнение на
задачи, при използване на няколко нишки, но при процесор с едно ядро.
Управлението е на ниво нишки, а не на времеделение.
време
Процесор с
едно ядро
нишка 1	нишка 2	нишка 3	нишка 1
зад. 1	зад. 2	зад. 3	зад. 1
Фигура 13: Псевдо-паралелно изпълнение с няколко нишки, но при процесор с едно ядро
На Фиг.14 е показано едновременно (паралелно) изпълнение на задачи,
при използване на няколко нишки, и при процесор с четири ядра. Това е
истинското паралелно изпълнение, защото всички ядра работят едновременно
по съответните, зададени към всяко от тях задачи.
време
Фигура 14: Паралелно изпълнение с няколко нишки, при процесор с четири ядра
Учебно пособие по ОП, ас. д-р инж. Ивайло Симеонов Ченчев
19
1.5.	Типове езици за програмиране
Езиците за програмиране се делят най-общо на два големи класа -
императивни (от англ. ез. imperative - безусловен, заповеден) и декларативни.
При императивните програмни езици фокуса е върху описанието на това как
програмата работи стъпка по стъпка, отколкото повърхностно (на англ. ез. high-
level) описание на очакваните резултати.
Процедурните програмни езици за програмиране се използват за
изпълнение на поредица от изрази, конто водят да някакъв резултат. Този тип
език използва множество променливи, цикли и др. елементи. При
функционалните програмни езици, програмите се конструират чрез
композиране и прилагане на функции. Като основен фокус тук е върху върнатите
стойности на функциите. При логическите програмни езици се използват набори
от изречения в логическа форма, конто изразяват факти и правила относно
проблемна облает. Примери за такива езици са: Prolog, Datadog, ASP(Answer Set
Programming). На Фиг.15 са показани схематично видовете езици за
програмиране от гледна точка на правилата за създаване на програми.
Фигура 15: Типове езици за програмиране
1.6.	Ал го ритм и
Учебно пособие по ОП, ос. д-р инж. Ивойло Симеонов Ченчев
20
1.6.1.
Понятие за алгоритъм
В компютърните науки, алгоритъмът е списък от инструкции, конто се
прилагат за решаване на проблеми или на различии задачи. Т.е. ако ни е
известен алгоритъм за решаване на дадена задача, то може да се използва
програмен език за неговото реализиране. Алгоритмите по сыцество
представляват програми. И обратното - всяка програма е и алгоритъм.
Съществуват различии начини за описание на алгоритъм - словесно с
текстово съдържание, чрез блок-схема и др.
1.6.2.	Блок-схеми
Блок-схемите имат няколко типа компоненти:
•	Начален блок (Фиг.16 ) - нарича се още „начален терминиращ символ"
НАЧАЛО
Фигура 16: Блок-схема - начален блок
•	Краен блок (Фиг.17) - нарича се още „краен терминиращ символ"
Фигура 17: Блок-схема - краен блок
•	Разклонение (Фиг.18) - При този блок се проверява дали условието
„test" е изпълнено. Ако условието е изпълнено, т.е. връща „истинност",
то се придвижваме по стрелката, имаща „TRUE" като надпис по нея. В
противен случай - алгоритъма се разклонява по другата стрелка - тази
с надпис „FALSE".
Учебно пособие по ОП, ос. д-р инж. Ивойло Симеонов Ченчев
21
Фигура 18: Блок-схема - разклонение
•	Блок за действие (Фиг. 19)
Фигура 19: Блок-схема - блок действие
•	Блок за въвеждане на данни (Фиг.20) - вход на данни
Фигура 20: Блок-схема - блок за въвеждане на данни
•	Блок за извеждане на резултат (Фиг.21) - може да е отпечатване, може
да е показване на екран и т.н.
Учебно пособие по ОП, ос. д-р инж. Ивойло Симеонов Ченчев
22
Фигура 21: Блок-схема - блок за извеждане/отпечатване
Използването на видовете блокове ще бъде демонстрирано с реализирането на
следната задача: Да се направи блок-схема на алгоритъм за пресмятане на сбора
на четните естествени числа до зададено естествено число п (включително).
No
I_______
отпечатване на
SUMA
Фигура 22: Блок-схема на алгоритъм - сума на четните естествени числа
Учебно пособие по ОП, ос. д-р инж. Ивойло Симеонов Ченчев
23
1.6.3.	Сложност на алгоритмите
Два фактора определят сложността за изпълнението на даден алгоритъм
- време и обем памет. Времевата сложност (time complexity) на алгоритъма
описва времето, необходимо за неговото изпълнение по отношение на
характеристиките на входа (обема и вида на данните). Сложността от гледна
точка на необходимия обем памет (space complexity) или още „пространствена
сложност" описва количеството памет необходимо за неговото изпълнение по
отношение на характеристиките на входа (обема и вида на данните). С други
думи, можем да кажем, че пространствената сложност е приблизителното общо
допълнително пространство, необходимо на програмата, за да работи.
В компютърните науки е прието сложността на даден алгоритъм да се
отбелязва ст.нар. „голямо O''-нотация (система от графики или символи). Голямо
О нотация е математическа нотация, описваща ограничаващото поведение на
функция, когато аргументът клони към определена стойност или безкрайност.
Буквата О идва от "Ordnung" - ред на приближение.
Нотацията голямо О се използва за класифициране на алгоритми според
това как тяхното време за изпълнение или изискванията за пространство
нарастват с нарастването на входния аргумент. Отбелязва се по следния начин:
О(п) - е голямо О нотация и се отнася до сложността на даден алгоритъм,
където п е размера на входните данни
0(1) - означава, че алгоритъмът се изпълнява за константно време -
независим е от размера на входните данни
0(п2) - за всеки вход от п елемента, алгоритъмът се изпълнява за п*п
операции
0(п) и 0(п/2) се считат за еднакви, тъй като и двете растат със същата
скорост като п
При указване на времевата сложност на алгоритъм, нотацията 0(п) се
използва за изразяване на горната граница на необходимото време за неговото
изпълнение.
При някои алгоритмите, в зависимост от вида на входните данни, може
да бъдат указвани няколко 0-нотации - например 0-нотация в най-добрия
случай, средна сложност и в най-лошия вариант.
Учебно пособие по ОП, ас. д-р инж. Ивайло Симеонов Ченчев
24
1.7.	Процес на разработване на программ
Всяка програма има собствен „цикъл на живот" (lifecycle). Ясно
изразените етапи са следните:
	Събиране на изисквания - целта на този етап е да се съберат колкото
се може повече артефакти, бележки, мнения, идеи, описващи
дадената възможност, казус, задача, проблем
	Дефиниране на проблема/задачата - на този етап трябва ясно да се
определи каква е основната задача, която трябва да бъде решена
	Изследване - прави се изследване (research) на съответната облает -
съществуващи решения, аналогични проекти, доставчици
	Проектиране на решението - на базата на събраните и описани до
този момент изисквания, и обобщената информация от
изеледването се изгражда на няколко нива архитектурата на
решението - връзка между отделни обобщени блокове (high-level),
детайлно описание на модули, обекти, функции, входно/изходни
данни и т.н.
	Планиране - съставяне на проектен план, базиран на времеви и
ценови параметри; необходими знания и умения за писането и
тестването на кода; събиране на екип от архитекти, програмисти,
тестери
	Писане на код-този етап обобщава изграждането на програмното
решение
	Тестване/Отстраняване на грешки - тестване на отделни
компоненти, модули, функционалност и т.н.
	Документиране - създаване на документация - различии
ръководства, описание на реализацията, методи за архивиране и
съхранение на конфигурации, на данните, поддръжка;
спецификации (технически изисквания за инсталация, необходими
права за инсталация, права/роли за нормалната работа; изисквания
за базата/базите и т.н.)
	Поддръжка - в зависимост от това за какво е предвиден дадения
продукт (софтуер), колко време се очаква да работи (5x8, или 24x7,
Учебно пособие по ОП, ас. д-р инж. Ивайло Симеонов Ченчев
25
или в някакъв друг режим), колко е критичен за бизнеса и т.н. се
определя и нивото на поддръжка (support)
При съвременните методологии за работата по създаване, тестване,
модифициране, пускане на нова функционалност, поддръжка и т.н. тези етапи
са свързани и по възможност автоматизирани. Това е основата на т.нар. DevOps
(Development and Operations) методология за разработка на софтуер.
Следват няколко важни техники за програмиране на езика Python:
•	"KISS" - Keep It Simple, Stupid - кода, трябва да бъде разбираем, по
възможност написан без излишна сложност.
•	Конвенция на имената (naming convention)
•	Самоописателни (self-documenting)
•	Подредени - правилно отстояние при блоковете (indentation)
•	Коментари (comments) - коментарите трябва да дават необходимата
яснота за работата на конкретен фрагмент от кода
1.8.	Работна среда
За да бъдат изпълнявани програми на езика Python е необходим
интерпретатор на езика. Има няколко варианта:
1.8.1.	Изпълнение на кода on-line
Няколко примера за подобии среди:
https://www.online-python.com/7utm content=cmp-true
https://www.programiz.com/python-programming/online-compiler/
Предимство на това използване е, че няма локална инсталация.
Подходящ е за тестване на малки програми и то основно за правилен синтаксис.
Недостатъци:
•	За да бъде изпълнен даден код е необходим достъп до съответната
уеб-страница
•	Използва се само определена версия на Python, която не може да бъде
променяна;
•	Не може да се инсталират допълнителни модули;
Учебно пособие по ОП, ас. д-р инж. Ивайло Симеонов Ченчев
26
•	Входно-изходните операции са доста ограничени;
1.8.2.	Изпълнение на кода локално
Предимства:
•	Може да се инсталират и поддържат различии версии;
•	Може да се инсталират различии модули;
•	Може да се използват различии IDE среди за по-лесно и удобно писане
на програми (примери за безплатни среди: PyCharm Community Edition,
MS Visio Studio Code);
Недостатъци:
•	Наличие на лаптоп, десктоп или друг вид хост с ОС
•	Изисква се локална инсталация
1.9.	Допълнителна терминология
Литерал (literal)-данни, конто са записани в променлива или константа:
п = 99	# 99 е числов литерал
s = "Python is my name" # "Python is my name" - стрингов литерал
PI = 3.14	# 3.14 e литерал реално число
flag = True	# True e булев литерал
fruits = ["apple", "orange"] # литерал списък
numbers = (1, 2, 3)	# литерал tuple
Литерални колекции в Python-> list, tuple, diet, set.
Скрипт - програма с някакъв код, който може да бъде „подаден" на
интерпретатор за изпълнение.
Голям скрипт може да бъде разделен на по-малки части, конто може да
бъдат използвани от други скриптове (програми). Python предлага начин да се
поставят дефи ни циите във файл и да бъдат използвани в скриптове. Такъв файл
се нарича модул.
Модул - Python файл, съдържащ, дефиниции и оператори. Това е просто
един файл на Python.
Учебно пособие по ОП, ас. д-р инж. Ивайло Симеонов Ченчев
Т1
2. Езика Python
2.1.	Синтаксис
Езикът Python спада към езиците, при конто писането (или по-точно
подреждането/оформянето) на кода се подчинява на правилото за отместване
спрямо началото на даден блок (на англ. ез. indentation - още вдлъбнатина).
Т.нар. отместване са интервалите и/или табулациите в началото на редовете с
код. При други езици, отместването се използва за да се направи кода по-четлив,
но при Python е част от синтаксиса. Чрез отместването се указва блок от код.
Ето няколко примера за отместване:
На Фиг.23 е оператора за присвояване ,,j=j+l" е отместен навътре спрямо
"if", защото трябва да се изпълни, когато е изпълнено условието к<10, т.е. явява
се тяло на "if".
if к < 10:
indentation (отместване)
Фигура 23: Пример за отместване на блок (indentation)
На Фиг.24 е показано различно отместване, но тъй като то е в два
различии блока и е допустимо.
if к < 10:
j = j + 1
।_ j
if m > x:
. Л = 10
Фигура 24: Произволно отместване, но в два различна блока
На Фиг.25 е показан пример за грешно отместване на втория оператор за
присвояване (т=10). И двата са част от тялото на "if" и следователно трябва да
са подравнени отляво.
Учебно пособие по ОП, ас. д-р инж. Ивайло Симеонов Ченчев
28
if к < 10:
j = j + 1
T m = 10
I___________I
1
ERROR
Фигура 25: Пример за грешно отместване
Програмата на Python се състои от блокове код. Блокове код са:
•	модул
•	тяло на функция
•	дефиниция на клас
•	всяка команда, написана интерактивно е блок
•	файл със скрипт
•	Команда, изпълнена от командния ред на интерпретатора с ,,-с" опция
•	Модул, стартиран на първо място от командния ред с ,,-т" аргумент е
блок код
Основното правило, което трябва да се спазва е отместването в даден
блок да е едно и също (ако се използват четири интервала за първото
отместване, то трябва да се използват четири интервала за отместване на всички
редове до края на дадения блок). Възможно и синтактично правилно е в
отделните блокове да има различно отместване, но не е желателно. Добра
практика при писане е да се използва едно и също отместване в блоковете - като
например четири интервала за отместване в даден блок.
Езикът Python е чувствителен към малки и големи букви (case sensitive).
Това означава, че има значение как се изписват имената на променливите и
ключовите думи.
Променливи със следните имена:
user_name
User_name
user_NAME
са различии!
Учебно пособие по ОП, ас. д-р инж. Ивайло Симеонов Ченчев
29
Коментари в Python може да се пишат на един или на няколко реда.
Символът указва, че след него текста е коментар и не трябва да се
интерпретира.
Пример 1:
#	порта на TCP връзката е сменен
port = 8900
Пример 2:
port = 8900 # порта на TCP връзката е сменен
Коментарите на няколко реда служат като средство за вградена
документация за другите, конто четат вашия код и обясняват нещата по-
подробно. Технически Python няма изрична поддръжка за многоредови
коментари, но има няколко възможности.
Вариант 1: чрез използването на символа на няколко реда:
#	
#	created by: Ivan Ivanov
#	on date: 05.10.2023 10:25 am, EEST
#	added function for time conversion ...
#	..
#	
Вариант 2: чрез използването на три двойни кавички (първоначално
предназначени за създаване на документация):
II II II
created by: Ivan Ivanov
on date: 05.10.2022 10:25 am, EEST
added function for time conversion ...
II II II
Вариант 2 се използва e т.нар. docstring (Documentation STRING) формат
за създаване на коментари и документация. Официалната Python документация
използва преструктуриран текстов формат (rST/Sphinx). Има няколко правила,
конто трябва да бъдат следвани за по-точна и добре организирана
документация.
Учебно пособие по ОП, ас. д-р инж. Ивайло Симеонов Ченчев
30
Следния пример демонстрира използването на docstring формата за
създаване на документация - по този начин, много лесно може да се
провери/разпечата допълнителна информация за функцията add():
»> def add (a, b) :
... """Calculate the sum of argl and arg2."""
... return a + b
»> print (add. doc )
Calculate the sum of argl and arg2.
2.2.	Ключови дум и
Ключовите думи в даден език още се наричат служебни думи. Това са
имена на оператори, конто имена са запазени, т.е. не може да се използват като
имена на променливи.
В средата на интерпретатора може да се изведе списъка със служебните
думи по следния начин:
»> help (" keywords ")
Във версия 3.11.3 на Python (това е версията, която е използвана при
създаването на пособието) има 35 ключови думи и това са:
False	class	from	or
None	continue	global	pass
True	def	if	raise
and	del	import	return
as	elif	in	try
assert	else	is	while
async	except	lambda	with
await	finally	nonlocal	yield
break	for	not	
Учебно пособие по ОП, ас. д-р инж. Ивайло Симеонов Ченчев
31
2.3.	Операции и оператори
За превод на англ, дума "statement" ще се използва термина „оператор",
когато се говори за някои синтактични конструкции. Това е най-близкия превод.
Например: „оператор за цикъл for", "оператор за цикъл while" и т.н.
Когато се говори за различии операции имаме оператори като +
(събиране), - (изваждане), / (деление) и т.н.
Значението на думата „оператор" ще се тълкува в зависимост от
контекста в изречението.
Операторите се използват за извършване на операции с променливи и
стойности.
•	Аритметични оператори (Arithmetic Operators)
#	Оператор	Описание	Пример
1	+	Събиране	4 + 5 = 9
2	-	Изваждане	10 - 2 = 8
3	*	Умножение	10 * 50 = 500
4	/	Деление	34/10 = 3.4
5	%	Остатък при деление	34 % 10 = 4
6	**	Степенуване	5**2 = 25
7	//	Целочислено деление	34//10 = 3
Таблица 1: Аритметични оператори
• Оператори за присвояване на стойност (Assignment Operators)
#	Оператор	Описание	Пример	Еквивалентно на
1	=	присвояване (assignment)	х = 4	х = 4
2	+=	събиране и присвояване	х += 3	х = х + 3
3	_=	изваждане и присвояване	х -= 3	х = х-3
4	*_	умножение и присвояване	х *= 3	х = х * 3
5	/=	деление и присвояване	х/= 3	х = х / 3
6	°/о=	остатък при деление и присвояване	х %= 3	х = х % 3
7	**_	степенуване и присвояване	х **= 3	х = х**3
Учебно пособие по ОП, ас. д-р инж. Ивайло Симеонов Ченчев
32
#	Оператор	Описание	Пример	Еквивалентно на
8	//=	целочислено деление и присвояване	х//=2	х = х // 2
Таблица 2: Оператора за присвояване на стойност
• Оператори за сравнение (Comparison Operators)
#	Оператор	Описание	Пример
1	==	равно	1 == 2 (не е вярно)
2	!=	различно	1 != 2 (вярно)
3	>	по-голямо	1 > 2 (не е вярно)
4	<	по-малко	1 < 2 (вярно)
5	>=	по-голямо или равно	1 >= 2 (не е вярно)
6	<=	по-малко или равно	1 <= 2 (вярно)
Таблица 3: Оператори за сравнение
• Логически оператори (Logical Operators)
#	Оператор	Описание	Пример
1	and	логическо И (ако и двата операнда са верни, тогава условието става истина)	(х and у) е вярно (True)
2	or	логическо ИЛИ (ако някой от двата операнда е различен от нула, тогава условието става вярно)	(0 or 1) е вярно (True)
3	not	логическо НЕ (обръщане/инветиране на логическото състояние на операнда)	(not 1) е лъжа (False)
Таблица 4: Логически оператори
•	Оператори за идентичност (Identity Operators)
Учебно пособие по ОП, ас. д-р инж. Ивайло Симеонов Ченчев
33
#	Оператор	Описание	Пример
1	is	Връща true, ако променливите от двете страни на оператора сочат към един и същ обект и false в противен случай	а = 1 Ь = 1 a is b ->(True)
2	is not	Връща false, ако променливите от двете страни на оператора сочат към един и същ обект и true в противен случай	а = 1 Ь = 1 a is not b -> (False)
Таблица 5: Оператора за идентичност
• Оператори за членство (Membership Operators)
#	Оператор	Описание	Пример
1	in	Връща true, ако намери променлива в указаната последователност, и false в противен случай	х in у връща True, ако х се среща в у
2	not in	Връща true, ако не намери променлива в указаната последователност, и false в противен случай	х not in у връща True, ако х не се среща в у
Таблица 6: Оператори за членство
• Побитови оператори (Bitwise Operators)
#	Оператор	Описание	Пример
1	&	побитово AND	Sets each bit to 1 if both bits are 1
2	1	побитово OR	Sets each bit to 1 if one of two bits is 1
3	А	побитово XOR	Sets each bit to 1 if only one of two bits is 1
4		побитово инвертиране	инвертира всички битове
5	«	побитово изместваня наляво	отмества битовете наляво с един бит като отдясно записва 0, а най-левия бит отпада
6	»	побитово изместваня надясно	отмества битовете надясно с един бит като отляво записва 0, а най-десния бит отпада
Таблица 7: Побитови оператори
Учебно пособие по ОП, ас. д-р инж. Ивайло Симеонов Ченчев
34
2.4.	Променливи
Променливите са контейнери за съхранение на стойностите на данните.
Как се създава променлива в Python?
•	Python няма команда за деклариране на променлива.
•	Променлива се създава в момента, в който за първи път и се присвой
стойност.
»> а = 54
»> fname = "Ivan"
•	Не е необходимо променливите да бъдат декларирани с който и да е
тип. Веднъж зададен даден тип на променлива, може да бъде сменен
след това.
»> а = 80	#аецяло число
»> а = "this is a text" #аестринг
Python е
•	Строго типизиран език
Променливите иматтип и този тип има значение, когато се извършват
операции с променливата.
•	Динамично типизиран език
Типа на променливата се определя само по време на изпълнение.
Разликата между:
Деклариране
Чрез декларирането се указва, че има „нещо" с това име и то има
този тип.
Позволява да се пише код, който компилатора разбира без да
трябва да се опишат всички детайли.
При работа с множество соре файлове се налага дадена функция
да бъде използвана многократно в много файлове. Тялото на
функцията не се поставя в множество файлове, а е достатъчно да
се предостави декларация за нея.
Дефиниране
Учебно пособие по ОП, ас. д-р инж. Ивайло Симеонов Ченчев
35
Предоставяне на цялата необходима информация за създаването
на даденото нещо в неговата цялост.
Дефинирането на функция означава предоставяне на тялото на
функцията.
Дефинирането на клас означава описването на всички методи на
класа и полетата.
След като дадено нещо е дефинирано, то това се счита и за
неговото деклариране.
2.5.	Видимост на имената
Променлива в Python е видима само вътре в блока, в който е създадена!
-това се нарича SCOPE (обхват)
Локален обхват (Local Scope)
Променлива, създадена вътре в тялото на функция принадлежи към
локалната видимост (local scope) на тази функция и може да бъде
използвана вътре в тази функция.
Глобален обхват (Global Scope)
Променлива, създадена в основното тяло на кода (на Python), е
глобална променлива и принадлежи към глобалния обхват.
Глобалните променливи са достъпни от всеки обхват, глобален и
локален.
При еднакви имена вътре и извън дадена функция, Python ще ги третира
като две различии променливи:
у = 500
def showfunc():
у = 10
print(у)
showfunc()
print(у)
За да бъде използвана променлива от глобалния контекст се използва
global. Ключовата дума global "казва" на Python да използва променливата от
глобалния контекст:
Учебно пособие по ОП, ас. д-р инж. Ивайло Симеонов Ченчев
36
у = 22
def showfunc():
global у
у = 44
showfunc()
print(y)
Веднъж използван глобалния scope за променлива, няма начин да бъде
превключен обратно на локален.
Функцията globals() е вградена функция, използвана за промяна (update)
и връща dictionary, използвано за актуализиране и връщане на речник,
съдържащтекущата глобална таблица със символи.
Достъпване на променливи от глобалния scope:
•	Използване на техните стойности
•	Промяна на техните стойности
За да бъде използвана глобалната стойност на променлива:
»> у = 44
»> def showf unc () :
у = 66
print (globals () ['у' ]) # Използване на стойност
return
»> print (у)
44
»> showf unc ()
44
За да бъде променена стойността на глобална променлива: =
»> у = 44
»> def showf unc () :
у = 66
globals () ['у' ] = 99 # Промяна на стойност
print(у)
Учебно пособие по ОП, ас. д-р инж. Ивайло Симеонов Ченчев
37
return
»> print (у)
44
»> showf unc ()
66
»> print (y)
99
2.6.	Конвенция на имената
Правила за имената на променливите в Python:
•	Името на променлива трябва да започва с буква или със символа
(underscore - символ „долна черта")
•	Името на променлива не може да започва с цифра
•	Името на променлива може да съдържа само: A-z, 0-9, _
•	Имената на променливите са чувствителни към главни и малки букви
(case-sensitive) - (age, Age и AGE са три различии имена)
Променливата може да има кратко име (х, у, а, т, ...) или по-описателно
име (firstname, family_name, total_volume).
Създателят на езика Python Guido van Rossum, създава и ръководство за
писане на код на езика. То може да бъде намерено на следния URL:
PEP 8 - Style Guide for Python Code:
https://peps.python.org/pep-0008/
Следва малък фрагмент от ръководството на Гуидо:
Кодът трябва да бъде описателен и нагледен:
•	b (единична малка буква)
•	В (единична голяма буква)
•	малкибукви
•	малки_букви_с_подчертавка
Учебно пособие по ОП, ас. д-р инж. Ивайло Симеонов Ченчев
38
•	ГЛАВНИБУКВИ
•	ГЛАВНИ_БУКВИ_С_ПОДЧЕРТАВКА
•	ДумиСГлавниБукви (или CapWords, или CamelCase - така се наричат
заради главните букви. Когато се използват съкращения, всички букви
от съкращението се изписват като главни - HTTPServerError е по-добре
от HttpServerError.
•	смесен Варна нт (първия символ е малка буква)
•	Думи_С_Главни_Букви_И_Подчертавка (не изглежда добре!)
Да се избягват имена с единични символи като:
•	'Г - малка буква „л" на англ.ез.
•	'О'	- голяма буква „О" на англ. ез.
•	'Г	- голяма буква „И" на англ ез.
Имената на променливите трябва да бъдат:
•	малки букви (lowercase)
•	Думи разделен и с underscore ('_') където е необходимо
Примери: х, у, position, my_sum, local_avg, tmp_average_time
Константи:
•	Само с главни букви (uppercase)
•	Думи разделен и с underscore ('_') където е необходимо
Примери: TOTAL, MAX_GRAVITY, MIN_LEVEL, SPEEDJJMIT,...
2.7.	Символът двоеточие
•	За указване на блок с отместване/отстъп (indented block)
if num > 0:
print (’’Positive number”)
•	За извличане на данни и индексни диапазони или масиви
»> агг= [1,2,3,4,5,6,7]
»> print (arr [0 : 3] )
[1, 2, 3]
Учебно пособие по ОП, ас. д-р инж. Ивайло Симеонов Ченчев
39
•	„отрязване на част от нещо" (slicing)
»> a="test"
»> print (а [1: 4] )
est
3. Типове данни в Python
Езикът Python е строго типизиран език.
Детайлно описание на типовете данни в езика Python може да бъде
намерено : https://docs.python.Org/3/library/stdtypes.html#textseq
Езикът Python има следните типове данни:
Text type:	str
Numeric types:	int, float, complex
Boolean type:	bool
Mapping type:	diet
Sequence types:	list, tuple, range
Set types:	set, frozenset
Binary types:	bytes, bytearray, memoryview
None type:	NoneType
Има четири типа данни колекции в Python:
•	List (списък) е колекция, която е последователна и може да бъде
променяна. Може да има дублирани елементи.
•	Tuple е колекция, която е последователна; не може да бъде
променяна. Може да има дублирани елементи.
•	Set (множество) е колекция, която е непоследователна, не може да се
променя, не е индексирана. Не може да има дублирани елементи.
•	Dictionary (речник) е колекция, която е последователна и може да
бъде променяна. Не може да има дублирани елементи.
3	.1. Текстов тип - str
Текстовите данни в Python се управляват със str обекти, или стрингове.
• Единични кавички: 'allows embedded "double" quotes'
Учебно пособие по ОП, ас. д-р инж. Ивайло Симеонов Ченчев
40
•	Двойни кавички: "allows embedded 'single' quotes"
•	Тройни единични кавички: '"Three single quotes'", """Three double
quotes"""
Стрингове, заградени от тройни кавички могат да обхващат няколко реда
- всички свързани интервали (табулации и нови редове) ще бъдат включени в
литерала на низа.
В Python, типът на данните се задава (определя), когато се присвой
стойност на променлива.
Задаване на данните от тип str, чрез присвояване на стойност:
city = "Sofia"
name = 'ivan'
alphabet = '''abcdefghijklmnopqrstuvwxyz'''
street = """Tsar Boris III"""
h = "g "
Създаване на обект от тип str става чрез използването на класа
(instantiation):
class str(object=")
Връща стринг версия на object.
В Python, типът на данните може да се задава (определя) и чрез
използването на конструктора на класа.
Задаване на данните от тип str, чрез използване на конструктора на класа:
city = str("Sofia")
name = str("ivan")
alphabet = str("abcdefghijklmnopqrstuvwxyz")
street = str("Tsar Boris III")
h = str("g")
Стринг методите са 47:
str.capitalize()
str.casefold()
str.isalnum ()
str.isalpha()
str.isdecimal()
str.isspace()
str.lower()
str.upper()
Учебно пособие по ОП, ас. д-р инж. Ивайло Симеонов Ченчев
41
str.zfill()
Следват няколко примера за извикването на част от тях:
»> name = "Petko"
»> print (name. lower () )
Petko
»> print (name. upper () )
PETKO
»> print (name. isalpha () )
True
»> print (name. isnumeric () )
False
»> name = "Petko"
»> print (name. upper () . zfill(8))
OOOPETKO
»> x = "iVo"
»> print (x. replace ('V , 'm'))
imo
3.2.	Цифров тип - int, float, complex
Задаване на int тип на данните чрез присвояване:
п = 12
total = 378
у = 9
К = 1024
М = 1048576
Създаване на обект от тип int става чрез използването на класа
(instantiation):
class int([x])
Учебно пособие по ОП, ас. д-р инж. Ивайло Симеонов Ченчев
42
class int(x, [base])
#	base - незадължителен. Ако e използван, числото трябва да е в
интервала 0, 2-36. Това е основата на бройната система.
#	Основа 0 означава, че числото се интерпретира като числов
литерал, така че, действителната основа е 2, 8,10, или 16.
Задаване на int тип на данните чрез използване на конструктора на класа:
n = int(12)
total = int(378)
у = int(9)
К = int(1024)
К = int( "1111", base=2)
M = int(”0xFF", base=0)
M = int("OxFF", 0)
Задаване на float тип на данните чрез присвояване:
п = 12.1
total = 99.67
у = 0.123
pi = 3.1415
М = 8
Създаване на обект от тип float става чрез използването на класа
(instantiation):
class float([x])
Задаване на float тип на данните чрез използване на конструктора на
класа:
n = float(0.0019)
total = float(8.44)
pi = float(3.1415)
К = float(9.9)
M = float(156.78)
»> x = float (1.489)
»> print (x)
1.489
Учебно пособие по ОП, ас. д-р инж. Ивайло Симеонов Ченчев
43
»> х = float (9)
»> print (x)
9.0
Задаване на complex тип на данните чрез присвояване:
п = lj
total = 99j
у = 123j
pi = 11.2j
x = 0.08j
Създаване на обект от тип complex става чрез използването на класа
(instantiation):
class complex([real[, imag]])
Задаване на complex тип на данните чрез използване на конструктора на
класа:
n = complex(lj)
total = complex(99j)
у = complex(123j)
pi = complex(11.2j)
x = complex(0.08j)
»> x = complex (48 j)
»> print (x)
48j
»> x = complex (0.89 j)
»> print (x)
0.89j
3.3.	Булев тип - boolean
Създаване на обект от тип boolean става чрез използването на класа
(instantiation):
class booltfx])
Учебно пособие по ОП, ас. д-р инж. Ивайло Симеонов Ченчев
44
Тестване на истинност:
Счита се за False, ако:
•	ако х е false или е пропуснато
•	константи, конто са дефинирани да бъдат false: None и False.
•	нула, при който и да е цифров тип: 0, 0.0, 0j, Decimal(O), Fraction(0,1)
•	празни последователи ости и колекции: ", О, [], {}, set(), range(O)
Задаване на bool тип на данните чрез присвояване:
m = True
flag = False
Задаване на bool тип на данните чрез използване на конструктора на
класа:
n = Ьоо1(1)
m = bool(28)
у = bool(0)
g = bool(0.0)
»> x = bool (True)
»> print (x)
True
»> x = False
»> print (x)
False
»> x = bool (124)
»> print (x)
True
3.4.	Тип речник - diet
Създаване на обект от тип diet става чрез използването на класа
(instantiation):
Учебно пособие по ОП, ас. д-р инж. Ивайло Симеонов Ченчев
45
class dict(**kwargs)
class d\ct(mapping, **kwargs)
class dict(/terab/e, **kwargs)
Връща нов diet (от англ. ез. dictionary - речник) инициализиран от
незадължителен позиционен аргумент и по възможност празно множество от
аргументи ключови думи.
От версия 3.7 на Python, типът diet е подреден (ordered)!
Данните от този тип могат да бъдат създадени по няколко начина:
•	Чрез използване на списък във фигурни скоби {} от двойки
ключ:стойност разделени със запетайки :
{'1К':1024, '2К':2048}
{10:'table', 49:'chair'}
{firstname: 'Petar', familyname: 'Petrov'}
•	Чрез използване на diet comprehension (diet обхващане):
{},
{x: x ★★ 2 for x in range(10)}
»> p={x: x ★★ 2 for x in range (10) }
»> print (p)
{0: 0, 1: 1, 2: 4, 3: 9, 4: 16, 5: 25, 6: 36, 7:
49, 8: 64, 9: 81}
3.5.	Типове „последователности" - list, tuple,
range
3.5.1.	Тип list
Създаване на обект от тип list става чрез използването на класа
(instantiation):
class \\st([iterable])
Списък може да бъде създаден по няколко начина:
•	Празен списък - използване на квадратни скоби: []
Учебно пособие по ОП, ас. д-р инж. Ивайло Симеонов Ченчев
46
•	С квадратни скоби, разделяйки елементите със запетайки : ['а', *Ь', 'с']
•	С използване на list comprehension: [х for х in iterable]
•	С използване на конструктор метода: list() or list(iterable)
»> b = [ 'a' , 'b' , 'c' , 'd' , 'e' , 'f' ]
»> print (b)
['a', 'b', 'o', 'd', 'e', 'f']
»> print (b[3])
d
»> a = [x for x in [2,4,100,6,14,9]]
»> print (a)
[2,4,100,6,14,9]
»> print (a [2])
100
»> a=list (range (0,10,2) )
»> print (a)
[0, 2, 4, 6, 8]
»> b=list[ 'a' , 'b' , 'c' ,'d' , 'e' , 'f' ]
»> print (b)
list['a', 'b', 'c', 'd', 'e', 'f']
»> a=list([x for x in [2,4,100,6,14,9]])
»> print (a)
[2, 4, 5, 6, 8, 9]
»> print (a [4])
14
ЗАБЕЛЕЖКА: Индексирането на списък започва от 0 (нула).
Учебно пособие по ОП, ас. д-р инж. Ивайло Симеонов Ченчев
47
3.5.2.	Тип tuple
Създаване на обект от тип tuple става чрез използването на класа
(instantiation):
class twp\e([iterable])
Типът Tuple в Python е колекция отобекти, разделени със запетайки.
Типът Tuple е един от четирите вградени типове данни в Python, конто се
използват за съхранение на колекции от данни. Останалите 3 типа са Списъци
(list), Множество (set), и Речник (dictionary) - всички с различии качества и
начини на използване.
Tuple е колекция от подредени и неизменни обекти.
Tuple е неизменен (непроменяем, не може да се променя).
Веднъж създадена променлива от тип tuple, не може да бъде променяна
(не може да се добавят или изтриват елементи).
Tuple може да бъде използван за създаване на вложени tuples.
Задаване на tuple тип на данните чрез присвояване:
tup = ("Sofia", "Varna", "Ruse")
tup = ('Sofia', 'Varna', 'Ruse')
tup = 'Sofia', 'Varna', 'Ruse'
Ako tuple e с 1 елемент:
tupl = ("edin", )
tupl = "edin",
Задаване на tuple тип на данните чрез използване на конструктора на
класа:
tup = tuple(("Sofia", "Varna", "Ruse"))
tup = tuple(('Sofia', 'Varna', 'Ruse'))
Ako tuple e с 1 елемент:
Учебно пособие по ОП, ас. д-р инж. Ивайло Симеонов Ченчев
48
tupl = tuple(("edin", ))
Достъпване на елементите с положителен индекс:
»> tup = ("Hello", "there", ".")
»> print ("Value in tup[O] = ", tup[O])
Hello
»> print ("Value in tup[l] = ", tup[l])
there
»> print ("Value in tup [2] = ", tup [2])
Достъпване на елементите с отрицателен индекс :
»> tup = ("Hello", "there", ".")
»> print ("Value in tup[-3] = ", tup[-3])
Hello
»> print ("Value in tup [-2] = ", tup [-2])
there
»> print ("Value in tup[-l] = ", tup[-l])
Индексиране на елементите на данни от тип tuple:
Start:End with Indexes to print Range
Slicing from here till end
l
Фигура 26: Индексиране на tuple*
Учебно пособие по ОП, ас. д-р инж. Ивайло Симеонов Ченчев
49
източник: https://www.geeksforgeeks.org/python-tuples/
Отрязване на част от tuple:
tuple[Start: Stop : Step]
tup = (2, 3, 5, 7, 11,
tup[0]	->	2
tup[-4]	->	11
tup[2:]	->	(5,	7,
tup[:4]	->	(2,	3,
tup[2:4]	->	(5,	7)
tup[l::2]	->	(3,	7,
13, 17, 19)
11, 13, 17, 19)
5, 7)
13, 19)
3.5.3.	Тип range
Създаване на обект от тип range става чрез използването на класа
(instantiation):
rangefstart, stop, step)
start - Незадължителен параметър. Цяло число, указващо от коя
позиция да започне. Стойността по подразбиране е 0.
stop - Задължителен. Цяло число, указващо на коя позиция да
спре (тази позиция не се включва).
step - Незадължителен параметър. Цяло число, указващо
увеличителната стъпка. Стойността по подразбиране е 1.
х = range(3)	-> х[0]=1, х[1]=2, х[2]=3,
х = range(2, 10, 2)	->	х[0]=2,	х[1]=4,	х[2]=6,
х[3]=8
»> а = range (0,10,3)
»> print (а)
range(0, 10, 3)	# 0,3,6,9
»> print (а [2])
6
Учебно пособие по ОП, ас. д-р инж. Ивайло Симеонов Ченчев
50
3.6.	Тип множество - set
Създаване на обект от тип set става чрез използването на класа
(instantiation):
class set([iterable])
class frozenset([/terab/e])
set - В типа set (множество), елементи могат да бъдат
добавяни/изтривани по всяко време.
frozenset - Елементите от този тип (frozen set) остават едни и същи
след създаването (непроменяеми - immutable).
Множествата се използват за съхраняване на множество елементи в една
променлива.
Множеството (set) е колекция, която не е подредена, непроменяема
(съществуващ даден елемент не може да бъде променян, но може да бъде
изтрит; може да бъде добавен нов елемент) и неиндексирана.
set = {"pencil", "rubber", "ballpen", 106, 22}
mysetvarl = {"pencil", "rubber", "ballpen", 106, 22}
mysetvar2 = set( ("pencil", "rubber", "ballpen", 106,
22) )
»> print (22 in mysetvar2)
True
3.7.	Двоичен тип - byte, bytearray, memoryview
Основните вградени типове за манипулиране на двоични данни са
байтове и байтови масиви. Те се поддържат от memoryview, който използва
буферния протокол за достъп до паметта на други двоични обекти, без да е
необходимо да се прави копие.
Модулът за масиви поддържа ефективно съхранение на основни типове
данни като 32-битови цели числа и IEEE754 плаващи стойности с двойна точност.
Учебно пособие по ОП, ас. д-р инж. Ивайло Симеонов Ченчев
51
3.8.	Тип NoneType
Ключовата дума None се използва за дефиниране на нулева променлива
или обект. В Python ключовата дума None е обект и е тип данни от класа
NoneType.
•	None не е същото като False.
•	None не е 0.
•	None не е празен стринг.
•	При сравнение на None с всичко, винаги ще върне Fals, с изключение
на None.
3.9.	Проверка на типа на данните
Функцията type() е вградена функция и връща типа на
обектите/елементите от данни, съхранени във всеки тип данни, или връща нов
тип обект в зависимост от аргументите, предадени на функцията:
»> х = 29
»> print (type (х) )
<class 'int'>
»> name = "Stefan ”
»> print (type (name) )
<class 'str’>
4.	Оператори за разклонение
4.1.	Оператор if-elif-else
Синтаксис:
if test expression:
statement(s)
Пример за използване:
»> a = 28
»> b = 500
»> if b > a:
Учебно пособие по ОП, ас. д-р инж. Ивайло Симеонов Ченчев
52
print("b is greater than a")
b is greater than a
Синтаксис:
if test expression:
body of if
statement(s)
else:
body of else
statement(s)
Пример за използване:
»> a = 28
»> b = 500
»> if b > a:
print("b is greater than a")
else:
print("b is not greater than a")
Синтаксис:
if test expressionl:
body of if
statement(s)
elif test expression:
body of elif
statement(s)
else:
body of else
statement(s)
Пример за използване:
num = 3.1415
if num > 0:
print("Positive number")
elif num == 0:
print("Zero")
Учебно пособие по ОП, ас. д-р инж. Ивайло Симеонов Ченчев
53
else:
print("Negative number")
Пример за два вложени if оператора:
num = 3.14
if num >= 0:
if num == 0:
print("Zero")
else:
print("Positive number")
else:
print("Negative number")
4.2.	Оператор switch
Симулиране с множество условии изрази (чрез if-elif-else):
age = 120
if age > 90:
print("You are too old to party, granny.")
elif age < 0:
print("You're yet to be born")
elif age >= 18:
print("You are allowed to party")
else:
"You're too young to party"
# Output: You are too old to party, granny.
Симулиране с функция:
def switchfunction(lang):
if lang == "JavaScript":
return "You can become a web developer."
elif lang == "PHP":
return "You can become a backend developer."
elif lang == "Python":
return "You can become a Data Scientist"
elif lang == "Solidity":
return "You can become a Blockchain developer."
elif lang == "Java":
return "You can become a mobile app developer"
Учебно пособие по ОП, ас. д-р инж. Ивайло Симеонов Ченчев
54
print(switchfunction("Python"))
Output:
You can become a Data Scientist
Оператор: match-case (в Python 3.10):
Синтаксис:
match term:
case pattern-1:
action-1
case pattern-2:
action-2
case pattern-3:
action-3
case _:
action-default
Пример:
lang = "Python"
match lang:
case "JavaScript":
print("You can become a web developer.")
case "Python":
print("You can become a Data Scientist")
case "PHP":
print("You can become a backend developer")
case _:
print("The language doesn't matter, what matters is
solving problems.")
5.	Оператори за цикъл
Операторите за цикъл предоставят възможност за многократно
повторение на даден код - т.нар. в Python - блок от код или още тяло на
оператора за цикъл. За да бъде изпълнен блока от код, трябва да е изпълнено
определено условие. Условието за влизане в тялото на оператор for е докато има
входни елементи, а условието за влизане в тялото на оператор while е тестване
на логически израз - ако е True, то тялото се изпълнява.
Учебно пособие по ОП, ас. д-р инж. Ивайло Симеонов Ченчев
55
5.1.	Оператор for
Синтаксис:
for val in sequence:
body of for loop
където val e броячна променлива
Тялото на цикъла for се изпълнява, само ако не е достигнат последния
елемент на sequence. На Фиг.27 е показана блок-схема на оператор за цикъл for.
Фигура 27: Блок-схема на оператор за цикъл for
Следват два примера за използването на for.
Пример 1:
# първите десет прости числа
pnumbers = [2,3,5,7,11,13,17,19,23,29]
sum = О
for k in pnumbers:
sum = sum + k
print("The sum is", sum)
The sum is 129
Пример 2:
Учебно пособие по ОП, ос. д-р инж. Ивойло Симеонов Ченчев
56
floatval
[1.4,5.67,9.08,16.01,6.88]
sum = 0
for к in floatval:
sum = sum + к
print("The sum is", sum)
The sum is 39.04
5.2.	Оператор while
Синтаксис:
while test_expression:
body of while loop
Тялото на цикъла се изпълнява, само ако test_expression е True.
На Фиг.28 е показана блок-схема на оператор за цикъл while.
Фигура 28: Блок-схема на оператор за цикъл while
Пример за използване:
п = 100
# инициализиране на sum и на counter
sum = 0
i = 1
while i <= n:
Учебно пособие по ОП, ос. д-р инж. Ивойло Симеонов Ченчев
57
sum = sum + i
i = i + 1	# промяна на броячната променлива
print("The sum is", sum)
The sum is 5050
6.	Оператори break, continue, pass
6.1.	Оператор break
Операторът break може да промени потока на изпълнение при нормален
ци къл:
•	да прекъсне текущата итерация
•	прекъсване на целия цикъл, без да проверява условието на цикъла (test
израза)
Следват два примера за използването на оператор break във for и в while:
Оператор for и използване на оператор break:
for х in sequence:
#	тяло на цикъла for
if condition:
#	тяло на цикъла for
—► # извън тялото на цикъла for
Оператор while и използване на оператор break:
while test expression:
# тяло на цикъла while
if condition:
------------ break
#	тяло на цикъла while
—►# извън тялото на цикъла while
Учебно пособие по ОП, ос. д-р инж. Ивойло Симеонов Ченчев
58
6.2. Оператор continue
Операторы continue се използва за да пропуске оставащата част от кода
в тялото на оператор за цикъл само за текущата итерация.
При използването на оператор continue, изпълнението на блока от код на
тялото на цикъла спира в мястото на извикване на continue и продължава с
проверка дали може да се изпълни тялото на цикъла още веднъж. Казано по друг
начин - цикъла не се прекъсва, а след continue се продължава със следващата
итерация. Това е в сила и за двата оператора за цикъл.
Оператор for и използване на оператор continue:
for х in sequence:
#	тяло на цикъла for
if condition:
continue ----------
#	тяло на цикъла for
# извън тялото на цикъла for
Оператор while и използване на оператор continue:
while test expression:
#	тяло на цикъла while
if condition:
continue ------------
#	тяло на цикъла while
# извън тялото на цикъла while
Учебно пособие по ОП, ос. д-р инж. Ивойло Симеонов Ченчев
59
6.3.	Оператор pass
Операторът pass е т.нар. null-оператор.
Разликата между коментар и оператора pass в Python е, че
интерпретаторът игнорира коментара изцяло, pass не се игнорира.
Когато се изпълни pass, нищо не се случва. Резултатът е (NOP - No
Operation).
Пример:
'''pass е само "контейнер"
За някаква функционалност, конто ще бъде
добавена по-късно.'''
sequence = ['р', 'a', 's', 's']
for val in sequence:
pass
# по този начин се запазва блока
# тялото на цикъла е празно, но е
# синтактично вярно
7.	Методы slice()
Нарязването (slice от англ. ез. - нарязване, разрязване) е извличане на
част от string, tuple, list, range или bytes. To дава възможност да се получи като
резултат специфичен диапазон от елементи, в зависимост от използваното
индексиране. Сыцествуват два варианта на използване на slice. Единият е, когато
се създаде обект от клас slice, а вторият е когато се използва метода slice(), който
връща обект от съответнияттип, използван за „нарязването". Или казано по друг
начин - методът slice() връща част от iterable тип като обект от класа slice въз
основа на посочения диапазон.
Синтаксис 1 - използване на класа:
class slice(stop)
class slice(start, stopl, step])
Учебно пособие по ОП, ас. д-р инж. Ивайло Симеонов Ченчев
60
•	start - незадължителен параметър. Цяло число, указващо от коя
позиция да започне отрязване. Стойността по подразбиране е 0.
•	stop - Цяло число, указващо на коя позиция да спре отрязването.
•	step - незадължителен параметър. Цяло число, указващо с каква
стъпка да стане отрязването (slicing). Стойността по подразбиране
е 1.
Връща обект slice, който се използва да „разреже" някаква
последователност (string, tuple, list, range, или bytes).
Синтаксис 2 - чрез индексиране:
obj [start: stop: step]
Стойността :stop указва първата стойност, която не е избрана при
отрязването.
a [start:stop]
a [start:]
a [:stop]
а[:]
#	елементите от start до stop-1 (включително)
#	от start до края на масива
#	елементите от началото до stop-1
#	копие на целия масив
Обекта slice може да представлява операция за нарязване, т.е.:
a [start: stop: step]
e еквивалентно на:
a[slice(start, stop, step)]
Ето няколко примера:
py_str = 'Python'
# съдържа индекса О, 1 и 2
print (py_str [0:3] )
It Pyt
ft съдържа индекса 1 и 3
if yh
print (py_str [1:5:2] )
а[-1] а[-2:] а[:-2] а[::-1]	#	последен елемент в масив #	последните два елемента в масив #	всичко без последните два елемента #	всички елементи в масив в обратен ред
Учебно пособие по ОП, ас. д-р инж. Ивайло Симеонов Ченчев
61
a[1::-1]	# първите два елемента в обратен ред
а[:-3:-1]	# последимте два елемента в обратен ред
а[-3::-1]	# всичко без последимте два елемента в обратен ред
8.	Методы range()
Синтаксис:
class range(stop)
class range(start, stop[, step])
•	start - стойността на параметъра start (по подразбиране: 0)
•	stop - стойността на параметъра stop
•	step - стойността на параметъра step (по подразбиране: 1)
Създава се обект от тип range, който представлява непроменяем тип.
Типът range представлява неизменна последователност от числа и
обикновено се използва за определен брой пъти обхождане във for цикли.
Примери:
»> range (10)	# [0;10)
range(0, 10)
»> list (range (10) )
[0, 1, 2, 3, 4, 5, 6, 7, 8, 9]
»> list (range (12, 20))	# [12;20)
[12, 13, 14, 15, 16, 17, 18, 19]
»> list (range (10, 20, 2))	# [10;20)
[10, 12, 14, 16, 18]
»> list (range (0, 10, 3))	# [0;10)
[0, 3, 6, 9]
Проверка за това дали даден елемент присъства в range-a:
»> г = range (0 , 20, 2)
Учебно пособие по ОП, ас. д-р инж. Ивайло Симеонов Ченчев
62
»> 8 in г
True
Проверка за използване на част от създаден range:
»> г = range (0, 20, 2)
»> for i in r[:5] :
print(i)
0
2
4
6
8
9.	Вложени цикли
Вложеният цикъл (на англ. ез. nested loop) е цикъл в тялото на друг цикъл
(т.нар. външен цикъл). Вътрешният цикъл ще бъде изпълнен веднъж за всяка
итерация на външния цикъл.
Вътрешния и външния цикъл могатда бъдат от всякакъв вид-while цикъл
или for цикъл.
Пример с два вложени цикъла:
for i in range(2):
#i - броячна променлива за външния цикъл
for j in range(2):
#j - броячна променлива за вътрешния цикъл
print("[%d,%d]" % (i, j))
[0,0]
[0,1]
[1,0]
[1,1]
Пример с три вложени цикъла:
for х in range(1,9):
for у in range(1,9):
for z in range(1,9):
Учебно пособие по ОП, ас. д-р инж. Ивайло Симеонов Ченчев
63
pass
Пример за два вложени цикъла с for и с while:
names = ['one', 'two', 'three']
for name in names:
count = 0
while count < 5:
print(name, end=' ')
count = count + 1
print ()
one one one one one
two two two two two
three three three three three
Прекъсване на вложени цикли с break:
for i in range(4):	# 0, 1, 2, 3
for j in range(4):	# 0, 1, 2, 3
if j == i:
break
print(i, j)
1 0
2 0
2 1
3 0
3 1
3 2
Прекъсване на вложени цикли с continue:
for i in range(3):
for j in range(3):
if j == i:
continue
print(i, j)
0 1
Учебно пособие по ОП, ас. д-р инж. Ивайло Симеонов Ченчев
64
О 2
1 О
1 2
2 О
2 1
10.	Масиви
Python няма вградена поддръжка за работа с масиви.
За да се работи с масиви в Python, трябва да се използва библиотеката
NumPy (Numerical Python):
https://www.w3schools.com/python/numpy/default.asp
10.1.	Едномерен масив
Дефиниция: Едномерен масив е структура отдании, която представлява
група от елементи от един и същи тип, подредени в линейна структура под едно
име на променлива. За да бъде използван даден елемент от масива, трябва да
се използва неговия индекс, т.е. позицията му в масива.
Python няма вградена поддръжка за работа с масиви, но може да се
използва типа List (списък). Създава се списък и неговите елементи се достъпват
чрез индексиране - т.е. тяхното обхождане.
Пример:
arr_odd = [1, 3, 5, 7, 9]
for i in range(5):
print("%d element is =	%d\n"	%	(i,
arr_odd[i]), end="")
print ()
0	element	is	=	1
1	element	is	=	3
2	element	is	=	5
3	element	is	=	7
4	element	is	=	9
Учебно пособие по ОП, ас. д-р инж. Ивайло Симеонов Ченчев
65
10.2.	Двумерен масив
Дефиниция: Двумерен масив е структура от данни, която представлява
група от елементи от един и същи тип, подредени в мрежова структура с редове
и колони (по аналогия с таблица) под едно име на променлива. За да бъде
използван даден елемент от масива, трябва да се използват неговите позиции
по колона и по ред.
Пример за симулиране на двумерен масив:
Дефиниране на четири списъка с по четири елемента:
arrl = [11, 12, 13, 14]
arr2 = [2, 4, 6, 8]
аггЗ = [3, 5, 7, 9]
агг4 = [22, 33, 44, 55]
Дефиниране на списък matrixl като списък от списъци:
matrixl = [arrl, arr2, аггЗ, агг4]
matrix2 = [[11,12,13,14],	[2,4,б,8],	[3,5,7,9],
[22,33,44,55]]
Използване на елементите на matrixl чрез индексиране:
»> print (matrixl [0] )
[11, 12, 13, 14]
»> matrixl [0] [0]
11
»> matrixl [1] [0]
2
»> matrixl [2] [0]
3
»> matrixl [3] [0]
22
Метод 1 за създаване на двумерен масив - чрез празен списък:
агг = []
rows = 4
cols = 4
for i in range(rows):
col = []
Учебно пособие по ОП, ас. д-р инж. Ивайло Симеонов Ченчев
66
for j in range(cols):
col.append(0)
arr.append(col)
print(arr)
Метод 2 за създаване на двумерен масив - чрез методът на обхващането
(comprehension):
nrows = 8
ncols = 8
chess_board = [[0 for i in range(ncols)] for j in
range(nrows)]
print(chess_board)
Повече информация за работа със списъци - виж. Глава „Работа със
списъци".
11.	Работа със списъци
11.1.	Създаване
Списъкът може да бъде създаден по няколко начина.
11.1.1.	Чрез използване на квадратни скоби []
• Празен списък се създава с двойката квадратни скоби: []
var_empty_list = []
• Чрез използване на квадратни скоби, елементите се разделят със
запетайки: ['а', *Ь',' с']
var_list_letters = ['а', 'b', 'с', 'd', ’e’J
var_list_numbers = [1, 2, 3, 4]
var_list_mix = ['F', 0, "text", 9.81, '''list''']
var_list_one = [0]
var_list_one = [0,]
Учебно пособие по ОП, ас. д-р инж. Ивайло Симеонов Ченчев
67
11.1.2.	Чрез метод на обхващането
Използва се т.нар обхващане („list comprehension"):
[х for х in iterable]
Следват два примера за използването на comprehension метода за
създаване на списъци:
var_list_numb = [х for х in range(0,10)]
=> var list numb = [0,1,2,3,4,5,6,7,8,9]
a = [chr(x) for x in range(ord('a'),ord('z'))]
a[0] -> 'a'
11.1.3.	Чрез използване на конструктор метод
Създава се списък чрез използване на конструктор методът list() или
list(iterable).
а = list([x for х in range(0,10)])
=> a = [0,1,2,3,4,5,6,7,8,9]
=> a[0] -> 0
a = list([chr(x) for x in range(ord('a'),ord('z'))])
=> a[0] -> 'a'
11.1.4.	Обобщение
(1)	Списъците са подредени типове от данни
(2)	Може да бъдат променяни
(3)	Може да има дублирани елементи
(4)	а = []	# празен списък
(5)	а = list([])
(6)	а = [1,2]	# индексирането започва от нула (а[0], а[1])
(7)	а = list([l,2,3,4])	# а = list(range(0,5))
(8)	а = [ х for х in	range(0,5) ]
(9)	а=[1,2,3]
len(a)	# бр. на елементите в списъка
(10)	В Python, списъците са дефинирани като обекти с тип данни 'list:
Учебно пособие по ОП, ас. д-р инж. Ивайло Симеонов Ченчев
68
а=[1,2,3]
type(a)
<class 'list'>
(11)	Конструкторы list()
flist = list(("apple", "banana", "cherry"))
# обърнете внимание на двойните крыли скоби
11.2.	Достъпване
Елементите на списъка са индексирани и може да бъдат достъпвани чрез
използване на индекса:
flist = ["apple", "banana", "cherry"]
print(flist[1])
•	Първия елемент има индекс О
•	Отрицателно индексиране означава, че номерирането започва от края
към началото:
-1 се отнася за последния елемент
flist[-1] = "cherry"
-2 се отнася за втория отзад напред елемент
flist[-2] = "banana"
•	Диапазон на индексирането:
flist = ["apple", "banana", "cherry", "orange"]
print(flist[1:3])
Елементът с индекс 1 - включен
Елементът с индекс 3 - НЕ Е включен
•	Ако началната стойност е празна [:3] - диапазоны започва с първия
елемент:
flist = ["apple", "banana", "cherry", "orange"]
print(flist[:3])
["apple", "banana", "cherry"]
Учебно пособие по ОП, ас. д-р инж. Ивайло Симеонов Ченчев
69
•	Ако крайната стойност е празна [2:] - диапазонът ще продължи до
края:
flist = ["apple", "banana", "cherry", "orange"]
print(flist[2:])
["cherry", "orange"]
•	Отрицателно индексиране - от "banana" (-3) до, но НЕ включва
"orange" (-1):
flist = ["apple", "banana", "cherry", "orange"]
print(flist[-3:-1])
["banana", "cherry"]
•	Проверка дали елемент съществува в списъка:
flist = ["apple", "banana", "cherry"]
if "apple" in flist :
print("Yes, 'apple' is in the fruits list")
11.3. Промяна
•	Промяна на 1 елемент:
flist = ["apple", "banana", "cherry", "orange"]
flist[0] = "strawberry"
print(flist[0])
strawberry
•	Промяна на диапазон от елементи:
flist = ["apple", "banana", "cherry", "orange"]
flist[0:2] = ["strawberry","pear"]
print(flist)
['strawberry', 'pear', 'cherry', 'orange']
•	Промяна на диапазон от елементи и вмъкване:
flist = ["apple", "banana", "cherry", "orange"]
flist[0:1] = ["strawberry","pear"]
Учебно пособие по ОП, ас. д-р инж. Ивайло Симеонов Ченчев
70
print(flist)
['strawberry', 'pear', 'banana', 'cherry',
'orange']
•	Промяна на диапазон от елементи и изтриване:
flist = ["apple", "banana", "cherry", "orange"]
flist[0:3] = ["strawberry"]
print(flist)
['strawberry', 'orange']
•	За да се добави елемент в края на списък - използвайте метода
append():
flist = ["apple", "banana", "cherry", "orange"]
flist.append("strawberry")
print(flist)
['apple',	'banana',	'cherry',	'orange',
'strawberry']
Пример за добавяне на списък като последен елемент в друг списък:
flist = ["apple", "banana", "cherry", "orange"]
nlist = [2, 4, 6, 8]
flist.append(nlist)
print(flist)
['apple', 'banana', 'cherry', 'orange', [2, 4, 6,
8]]
len(flist)
flist[-l]
flist[-l][0]
-> 5
-> [2, 4, 6, 8]
-> 2
flist[-l][-1]	-> 8
•	За да се вмъкне елемент на определена позиция - използвайте
метода insert():
flist = ["apple", "banana", "cherry", "orange"]
Учебно пособие по ОП, ас. д-р инж. Ивайло Симеонов Ченчев
71
flist.insert(1,"strawberry")
print(flist)
['apple',	'strawberry',	'banana',	'cherry',
'orange']
•	За да се добави списък в края на друг - използвайте метода extend():
flist = ["apple", "banana", "cherry", "orange"]
glist = ["tomato", "pumpkin"]
flist.extend(glist)
print(flist)
['apple', 'banana', 'cherry', 'orange', 'tomato',
'pumpkin']
•	За да добавите iterable обект от тип tuple - използвайте метода
extend():
flist = ["apple", "banana", "cherry", "orange"]
tup = ("tomato", "pumpkin")
flist.extend(tup)
print(flist)
['apple', 'banana', 'cherry', 'orange', 'tomato',
'pumpkin']
11.4.	Изтриване
•	За да изтриете елемент - използвайте метода removed:
flist = ["apple", "banana", "cherry", "orange"]
flist.remove("cherry")
print(flist)
['apple', 'banana', 'orange']
•	За да изтриете елемента от определена позиция - използвайте
метода рор():
flist = ["apple", "banana", "cherry", "orange"]
Учебно пособие по ОП, ас. д-р инж. Ивайло Симеонов Ченчев
72
flist.pop(1)
'banana'
print(flist)
['apple', 'cherry', 'orange']
•	За да изтриете елемента от определена позиция - използвайте
ключовата дума del:
flist = ["apple", "banana", "cherry", "orange"]
del flist[1]
print(flist)
['apple', 'cherry', 'orange']
•	За да изтриете целия списък - използвайте метода - използвайте
ключовата дума del:
flist = ["apple", "banana", "cherry", "orange"]
del flist
type(flist)
Traceback (most recent call last):
File "<stdin>", line 1, in <module>
NameError: name 'flist' is not defined. Did you
mean: 'glist'?
•	За изтриване на всички елементи - използвайте метода clear():
flist = ["apple", "banana", "cherry", "orange"]
flist.clear()
print(flist)
[]	# празен списък
11.5.	Обхождане на елементите
•	Обхождане на списък чрез оператор за цикъл for:
Учебно пособие по ОП, ас. д-р инж. Ивайло Симеонов Ченчев
73
flist = ["apple", "banana", "cherry", "orange"]
for x in flist:
print(x)
apple
banana
cherry
orange
•	Обхождане чрез индексите - с функциите range(), len():
flist = ["apple", "banana", "cherry", "orange"]
for i in range(len(flist)):
print(flist[i] )
apple
banana
cherry
orange
•	Обхождане на списък чрез оператор за цикъл while:
flist = ["apple", "banana", "cherry", "orange"]
i = 0
while i < len(flist):
apple
banana
cherry
orange
•	Обхождане чрез list comprehension:
flist = ["apple", "banana", "cherry", "orange"]
[print(x) for x in flist]
apple
banana
cherry
Учебно пособие по ОП, ас. д-р инж. Ивайло Симеонов Ченчев
74
orange
[None, None, None, None]
print() e функция, която връща стойност None
Функцията print() отпечатва съответния елемент, но връща None,
затова в края на изпълнението и се създава списък от четирите върнати
от функцията print() стойности: [None, None, None, None]
Още един пример за използването на comprehension при създаване на
списък:
flist = ["apple", "banana"]
х = [print(х) for x in flist]
#	двете стойности се отпечатват на екрана
apple
banana
type (х)
<class 'list’>
#	x e от тип списък, но стойностите му са:
print(х)
[None, None]
11.6.	Обхващане на списък
Обхващане на списък в превод от англ. ез. - „list comprehension".
При създаване на списък без comprehension се използва методът
append():
flist = ["apple", "banana", "cherry", "mango"]
newlist = []
for x in flist:
if "a" in x:
newlist.append(x)
Учебно пособие по ОП, ас. д-р инж. Ивайло Симеонов Ченчев
75
print(newlist)
['apple', 'banana', 'mango']
Чрез List comprehension се създава нов списък (това е по-краткия
синтаксис), базиран на елементите на съществуващ списък.
Синтаксис:
newlist = [expression for item in iterable]
newlist = [expression for item in iterable if condition == True]
Връща стойност -> нов списък
Стария списък -> непременен
Условието condition е като филтър.
Примери с comprehension:
nlist = [х for х in range(10)]
# [0,1,2,3,4,5, 6, 7,8,9]
print(newlist)
['apple', 'banana', 'mango']
flist = ["apple", "banana", "cherry", "mango"]
newlist = [x.upper() for x in flist]
#	['APPLE', 'BANANA', 'CHERRY', 'MANGO']
flist = ["Apple", "Banana", "CHERRY", "mango"]
newlist = [x.lower() for x in flist]
#	["apple", "banana", "cherry", "mango"]
flist = ["apple", "banana", "cherry", "mango"]
newlist = ["kiwi" for x in flist]
print(newlist)
['kiwi', 'kiwi', 'kiwi', 'kiwi']
Учебно пособие по ОП, ас. д-р инж. Ивайло Симеонов Ченчев
76
nlist = [x for x in range(10) if x < 5]
# [0,1,2,3,4]
flist = ["apple", "banana", "cherry", "mango"]
newlist = []
newlist = [x for x in flist if "a" in x]
print(newlist)
['apple', 'banana', 'mango']
flist = ["apple", "banana", "cherry", "mango"]
newlist = [x if x != "banana" else "orange" for x
in flist]
print(newlist)
['apple', 'orange', 'cherry', 'mango']
Следва пример за използване на comprehension метода, но с
използването на два оператора "if" - в мястото на expression, и в мястото на
condition. На Фиг.29 е използвано филтриране - ако даден елемент във входния
списък съдържа буквата „а", то той се взема и участва при създаването на новия
списък. Но тук в израза има още един „if", който проверява дали дадения
елемент съвпада с „banana" - ако съвпада, го замества с „orange"; не променя
останалите подадени елементи.
flist = ["apple", "banana", "cherry", "mango"]
newlist = [x if x != "banana" else "orange
for x in flist if "a" in x
print(newlist)
# ['apple', 'orange', 'mango']
newlist = [expression for item in iterable if condition == True]
Фигура 29: List comprehension - използване на условие и филтриране
Учебно пособие по ОП, ас. д-р инж. Ивайло Симеонов Ченчев
77
11.7.	Сортиране
Синтаксис на метода list.sort():
list.sort(key=..., reverses..)
По подразбиране, sort() не изисква допълнителни параметри.
Но има два опционални параметъра:
•	reverse - Ако е True, сортирания списък е в обратен ред (намаляващ
ред)
•	key - функция, която служи като ключ за сравнение при сортиране
Методът sort() не връща стойност - променя оригиналния списък.
Синтаксис на вградената функция sorted():
sorted(iterable, key=None, reverse=False)
•	iterable - Последователност (string, tuple, list) или колекция (set,
dictionary, frozenset) или какъвто и да e друг „итератор" (iterator).
•	reverse (незадължителен) - Ако е True, списъкът е сортиран в
обратен ред. Ако не е подаден параметъра - стойността по
подразбиране е False.
•	key (незадължителен) - Функция, която служи като ключ за
сравнение при сортиране. Стойността по подразбиране е None.
Функцията sorted() връща сортиран списък.
Буквено-цифрово сортиране (в азбучен ред) на списък чрез метод sort():
Пример 1:
flist = ["banana", "cherry", "apple"
flist.sort()
print(flist)
['apple', 'banana', 'cherry', 'mango
"mango"]
Пример 2:
Учебно пособие по ОП, ас. д-р инж. Ивайло Симеонов Ченчев
78
flist = ["banana", "Banana", "aaa", "AAA", "Oa",
"000a"]
flist.sort()
print(flist)
['000a', '0a', 'AAA', 'Banana', 'aaa', 'banana']
Буквено-цифрово сортиране (в цифров ред) на списък чрез метод sort():
flist = [99, 28, 1, 0, 14, 4]
flist.sort()
print(flist)
[0, 1, 4, 14, 28, 99]
Буквено-цифрово сортиране (в азбучен намаляващ ред) на списък чрез
метод sort():
flist = ["banana", "cherry", "apple", "mango"]
flist.sort(reverse = True)
print(flist)
['mango', 'cherry', 'banana', 'apple']
Буквено-цифрово сортиране (в цифров намаляващ ред) на списък чрез
метод sort():
flist = [99, 28, 1, 0, 14, 4]
flist.sort(reverse = True)
print(flist)
[99, 28, 14, 4, 1, 0]
Методът sort() по подразбиране различава главни от малки букви - „case
sensitive".
За да не бъде чувствителен към малки-главни букви може да се използва
str.lower като ключова функция:
flist = ["banana", "Orange", "Kiwi", "cherry"]
flist.sort(key = str.lower)
print(flist)
Учебно пособие по ОП, ас. д-р инж. Ивайло Симеонов Ченчев
79
['banana', 'cherry', 'Kiwi', 'Orange']
Методът reversed обръща текущия ред на сортиране на елементите.
Пример 1:
flist = ["banana", "Orange", "Kiwi", "cherry"]
flist.sort()
print(flist)
['Kiwi', 'Orange', 'banana', 'cherry']
flist.reverse()
print(flist)
['cherry', 'banana', 'Orange', 'Kiwi']
Пример 2:
flist = ["banana", "Orange", "Kiwi", "cherry"]
flist.sort(key = str.lower)
print(flist)
['banana', 'cherry', 'Kiwi', 'Orange']
flist.reverse()
print(flist)
['Orange', 'Kiwi', 'cherry', 'banana']
11.8.	Копиране
Какво HE E копиране на списък:
flist = ["apple", "banana", "cherry"]
mynewlist = flist
!!! Тук променливата „mynewlist" e референция/връзка към flist.
Използване на вградения List метод сору()
flist = ["apple", "banana", "cherry"]
mynewlist = flist.copy()
print(mynewlist)
["apple", "banana", "cherry"]
Учебно пособие по ОП, ас. д-р инж. Ивайло Симеонов Ченчев
80
#	mynewlist e нов списък
#	flist = ["apple", "banana", "cherry"]
#	mynewlist = ["apple", "banana", "cherry"]
Използване на вградения List метод list()
flist = ["apple", "banana", "cherry"]
mynewlist = list(flist)
print(mynewlist)
["apple", "banana", "cherry"]
#	mynewlist is a new list
11.9.	Свързване
Съществуват три начина за свързване на списъци:
Свързване на два списъка с използването на оператор +
listl = ["а", "Ь", "с"]
list2 = [1, 2, 3]
list3 = listl + list2
print(list3)
['a', -b’, 'c', 1, 2, 3]
Свързване на два списъка с добавяне на всички елементи от единия
списък в края на другия списък:
listl = ["а", "Ь", "с"]
list2 = [1, 2, 3]
for х in list2:
listl.append(x)
print(listl)
['a', -b’, 'c', 1, 2, 3]
Свързване на два списъка, чрез използване на метода extend():
Учебно пособие по ОП, ас. д-р инж. Ивайло Симеонов Ченчев
81
listl = ["a", "b", "c"]
list2 = [1, 2, 3]
listl.extend(list2)
print(listl)
['a', -b’, 'c', 1, 2, 3]
11.10.	Допълнителни методи за работа със списъци
Премахване на дублирани елементи от списък:
Начин 1:
mylist =	["а",	"Ь",	"Ь",	"а",	"Ь",	"с",	"с",
"с","а"]
mylist = list(diet.fromkeys(mylist))
print(mylist)
['a', 'b', 'c']
Начин 2 - чрез дефиниране на функция:
def remove_dupl(local_list):
return list(diet.fromkeys(local_list) )
mylist = remove_dupl(["a", "b", "a", "c", "c"])
print(mylist)
['a', 'b', 'c']
•	Добавяне на елемент в края на списък
list, append(elmnt)
Добавя елемента elmnt в края на списък.
Elfnnt- Задължителен параметър - елемент от всякакъвтип (string,
number, object и т.н.)
•	Премахва всички елементи от списък
list.clear()
Учебно пособие по ОП, ас. д-р инж. Ивайло Симеонов Ченчев
82
•	Връща копие на указания списък.
List.copyO
•	Брой срещания в списък
list.count(value)
Връща броя на срещанията на параметъра value в списъка.
Value - Задължителен параметър - елемент от всякакъв тип (string,
number, list, tuple, и т.н.). Това е стойността, която се търси.
Flist = ['apple', 'banana', 'cherry']
n = flist.count('cherry')
print(n)
1
Следватдва примера:
nlist = [0, 54, 93, 4, 0, 0, 6, 1, 93, 0]
x = nlist.count(0)
print(x)
4
flist = ['apple', 'banana', 'cherry']
n = flist.count('che')
print(n)
0
•	Добавяне на елемент в края на списък
list, extend(iterable)
Добавя указаните елементи от списък (или какъвто и да е iterable
елемент) в края на текущия списък.
Iterable - Задължителен параметър - елемент от всякакъв тип (list,
set, tuple, и т.н.)
•	Позицията на първо срещане в списък
list, index(elmnt)
Учебно пособие по ОП, ас. д-р инж. Ивайло Симеонов Ченчев
83
Връща само позицията на първото появяване на указания елемент.
elmnt - Задължителен параметър - елемент от всякакъв тип (string,
number, list, и т.н..). Това е стойността, която се търси.
flist = ['apple', 'banana', 'cherry']
n = flist.index('cherry')
print(n)
2
Следватдва примера:
nlist = [54, 93, 4, 0, 0, 6, 1, 93, 0]
x = nlist.index(0)
print(x)
3
x = nlist.index(93)
print(x)
1
•	Вмъкване на елемент на зададена позиция
list.indexfpos, elmnt)
Вмъква зададената стойност на зададената позиция.
pos - Задължителен параметър. Число, указващо на коя позиция да
бъде вмъкнат елемента.
elmnt - Задължителен параметър. Елемент от всякакъв тип (string,
number, object и т.н.)
•	Премахване на елемент от указана позиция
list.pop(pos)
Премахва елемент от указаната позиция - изтрива го списъка и го
връща в мястото на извикването.
pos - Незадължителен параметър. Число, указващо позицията на
елемент, който ще бъде премахнат. Стойността по подразбиране е
-1, която връща последния елемент.
Следватдва примера:
Учебно пособие по ОП, ас. д-р инж. Ивайло Симеонов Ченчев
84
flist = ['apple', 'banana', 'cherry']
x = flist.pop(l)
print(x)
'banana'
print(flist)
['apple', 'cherry']
flist = ['apple', 'banana', 'cherry']
x = flist.pop()
print(x)
'cherry'
print(flist)
['apple', 'banana']
•	Премахва първия срещнат елемент
list, remove(elmnt)
Премахва първия срещнат елемент, който съвпада със зададената
стойност.
elmnt - Задължителен параметър. Елемент от всякакъв тип (string,
number, list и т.н.). Това е елемента, който ще бъде премахнат.
•	Обръща ред на сортиране на елементите
list.reversef)
Обръща ред на сортиране на елементите.
fruits = ['apple', 'banana', 'cherry']
fruits.reverse()
print(fruits)
['cherry', 'banana', 'apple']
•	Сортиране на списък
//st.sort(reverse=True | False, key=myFunc)
Сортира списък в нарастващ ред - по подразбиране.
Учебно пособие по ОП, ас. д-р инж. Ивайло Симеонов Ченчев
85
reverse - Незадължителен параметър. reverse=True ще сортира
списъка в намаляващ ред. Стойността по подразбиране е
reverse=False
key - Незадължителен параметър. Функция за указване на
критериите за сортиране.
12.	Работа с данни от тип String
Стрингове в Python - задаване с единични кавички, с двойни кавички, с
три единични кавички:
'This is an example of string.'
"This is an example of string."
'''This is an example of string.'''
•	Записване на стринг в променлива:
»> first_name = "Hello"
»> print (first_name)
Hello
»> mystr = "Python is here."
»> print (mystr)
Python is here.
•	Стринг на няколко реда:
»> description = ' ' ' This is a
... multi-line string
... in Python variable.'''
»> print (description)
This is a
multi-line string
in Python variable.
Забележка: Прекъсванията на редовете са на същите позиции като в
кода по-горе.
Учебно пособие по ОП, ас. д-р инж. Ивайло Симеонов Ченчев
86
•	Стрингове като масиви
Стринговете в Python са масиви от байтове, представляващи unicode
символи.
Python няма символен тип данни.
Единичния символ е стринг с дължина 1.
Квадратните скоби [] се използват за да се достъпват елементите в
стринга. Първият елемент има позиция 0.
Пример:
»> text_var = "This is a string"
»> print ( text_var[0] )
T
»> text_var = "This is a string"
»> print ( text_var[l] )
h
•	Обхождане на стринг
Стринговете са масиви -> елементите на стринг може да бъдат обхождани
с цикъл for.
»> for х in "banana" :
... print(x)
b
a
n
a
n
a
•	Дължина на стринг
1)	Използване на функцията 1еп():
»> text_var = "This is a string"
»> print ( len (text_var) )
16
»> print ( len ( "This is a string" ) )
16
Учебно пособие по ОП, ас. д-р инж. Ивайло Симеонов Ченчев
87
n = len( "This is a string" ) #len() e функция
»> print (n)
16
2)	Използване на оператор за цикъл for:
»> text_var = "This is a string"
»> count = 0
»> for x in text_var:
»> count = count + 1
»> print (count)
16
• Проверка за присъствие в стринг
1) С използването на ключовата дума in:
»> tvar = "This is a string"
»> print ( "ing" in tvar )
True
»> tvar = "This is a string"
»> tosearch = "ing"
»> print ( tosearch in tvar )
True
»> tvar = "This is a string"
»> tosearch = "ing"
»> result = tosearch in tvar
»> print ( result )
True
2) С използването на ключовата дума if:
»> svar = "This is a string"
»> if "ing" in svar:
»> print ("Yes. There is a match.")
Yes. There is a match.
»> svar = "This is a string"
Учебно пособие по ОП, ас. д-р инж. Ивайло Симеонов Ченчев
88
»> result = "ing" in svar
»> if result:
»> print ("Yes. There is a match.")
Yes. There is a match.
• Проверка за НЕ-присъствие в стринг
1)	С използването на ключовите думи in и not:
»> tvar = "This is a string"
»> print ( "ing" not in tvar )
False
2)	С използването на ключовите думи if, in и not:
»> tvar = "This is a string"
»> if "integ" not in tvar:
»> print ("Doesn't match.")
Doesn't match.
• Нарязване на стрингове
Извличане на диапазон от символи чрез използването на „slice"
синтаксиса.
Пример:
»> tvar = "This is a string"
»> print (tvar [5 :12])
is a st
1)	Изрязване от начало
Вземане на символи от началото на стринг до позиция 4
(четвъртия елемент не се включва):
»> svar = "This is a string"
»> print (svar [: 4 ] )
This
2)	Изрязване до края
Вземане на символи от позиция 10 (и всички след това до края на
стринга):
»> svar = "This is a string"
»> print (svar [10 :] )
Учебно пособие по ОП, ас. д-р инж. Ивайло Симеонов Ченчев
89
string
3)	Отрицателно индексиране
Изрязване от края на стринга:
»> svar = "This is a string"
»> print (svar [ - 6 : ] )
string
»> svar = "This is a string"
»> print (svar [-6 :-2] )
stri
1	2.1. Методи за работа със стрингове
•	Превръщане в главни букви
»> svar = "This is a string"
»> print (svar. upper () )
THIS IS A STRING
•	Превръщане в малки букви
»> svar = "This is a string"
»> print (svar. lower () )
this is a string
•	Премахване на интервали (whitespace):
"Whitespace" (интервали, табулации) e празното пространство преди
и/или след реалния текст, и обикновено се премахва.
»> svar = ” This is a string. ”
»> print (svar. strip () )
This is a string.
»> print (svar. strip () . upper () )
THIS IS A STRING.
Учебно пособие по ОП, ас. д-р инж. Ивайло Симеонов Ченчев
90
•	Замяна на символи в стринг
Методы replace() замества стринг с друг стринг:
»> svar = "This is a string."
»> print(svar.replace("s", "S"))
This iS a String.
»> print(svar.replace("is", "IS"))
This IS a string.
»> print(svar.replace("is", ""))
Th a string.
Пример:
-	Премахване на интервали (и табулации)
-	Превръщане в главни букви
-	Замяна на символи
»> svar = " This is a string. "
»> print(svar.strip().upper().replace(".",""))
THIS IS A STRING
•	Разделяне на стринг
Методы split() връща списък, в който отделните елементи са частите
от стринга, разделени с указания разделителен символ.
»> svar = "Hello brother. This is a string."
»> print (svar. split ("."))
['Hello brother', ' This is a string', '']
•	Събиране на стрингове
За да се съберат (комбинират) два стринга, може да се използва
оператор +
»> svarl = "Hello"
»> svar2 = "brother"
»> print (svarl + " " + svar2)
Hello brother
Учебно пособие по ОП, ас. д-р инж. Ивайло Симеонов Ченчев
91
He e позволено да се комбинират стрингове с числа като:
»> tvarl2 = "Hello" + 22
Traceback (most recent call last):
File "<stdin>", line 1, in <module>
TypeError: can only concatenate str (not
"int") to str
•	Форматиране на стрингове
Може да се комбинират стрингове с числа, но чрез използване на
метода format()!
Методът format() приема подадените аргументи, форматира ги, и ги
поставя в стринговете на мястото на заместителите (placeholders) {}:
»> tvarl = "Hello {}. AMG the team."
»> tvar2 = 63
»> print (tvarl. format (tvar2) )
Hello 63. AMG the team.
Методът format() приема неограничен брой аргументи и ги поставя
на съответните заместители {}:
quantity = 3
itemno = 567
price = 49.95
neworder = "I want {} pieces of item {} for
$ { } • ”
print(neworder.format(quantity,	itemno,
price))
I want 3 pieces of item 567 for $49.95.
Може да се използва индексиране {0} при форматирането за по-
сигурно, че аргументите ще бъдат поставени на правилните места:
quantity = 3
itemno = 567
price = 49.95
neworder = "I want to pay ${2} for {0} pieces
of item {1}."
Учебно пособие по ОП, ас. д-р инж. Ивайло Симеонов Ченчев
92
print(neworder.format(quantity,
price))
itemno,
I want to pay $49.95 for 3 pieces of item 567.
•	Отмяна на действието на специални символи
За да бъде променено значението на даден специален символ, той
трябва да бъде „освободен от специалното му значение" -
„ескейпнат" (escaped).
Това се прави с използването на символа \ (обратна наклонена черта
- backslash)
Грешно е да се използват двойни кавички в стринг, който е заграден
с двойни кавички:
text = ’’string with "some numbers" in the line"
За да бъде коригиран проблема, трябва да се използва
комбинацията \":
text = "string with \"some numbers\" in the line"
Примери на escape-нати символи:
V	- единична кавичка
\\	- обратна наклонена черта
\п	- нов ред
\t	-табулация
Python има набор от вградени методи, конто може да се използват върху
стрингове.
Забележка: Всички методи за работа със стрингове връщат нови
стойности. Те не променят оригиналния стринг.
В Python има 47 метода за работа със стрингове. Ето някои оттях:
center()
count()
find()
Учебно пособие по ОП, ас. д-р инж. Ивайло Симеонов Ченчев
93
index()
format()
13.	Работа с данни от тип Tuple
Данните от тип tuple се използват за съхранение на много елементи в
една променлива.
Tuple е единият от 4-те типове данни на Python, конто се използват за
съхранение на колекции отдании. Другите 3 са списък (List), множество (Set), и
речник (Dictionary), всички с различии качества и употреба.
Данните от тип tuple се записват между кръгли скоби ().
Типът данни tuple е колекция, която е :
о подредена
х = (False, 1, "АВС")
х[0]
о непроменяема
х = (False, 1, "АВС")
х[0] =34	# не може да се променя
Traceback (most recent call last):
File "<stdin>", line 1, in <module>
TypeError: 'tuple' object does not support item
assignment
о позволява дублирани елементи
х = (False, 1, "ABC", 1, 1, "xy")
• Създаване на tuple с един елемент
»> my tuple = ("tuk", )
»> type (mytuple)
<class 'tuple'>
# забележете ,
Учебно пособие по ОП, ас. д-р инж. Ивайло Симеонов Ченчев
94
# това НЕ е tuple
netuple = ("table")
»> type (netuple)
<class 'str’>
• Създаване на tuple с един елемент, с помощта на конструктор метода
tuple():
»> my tuple = tuple ( ("tuk") )
#	забележете двойните
#	кръгли скоби
»> type (mytuple)
<class 'tuple'>
•	Достъпване на данни от тип Tuple
Чрез индексиране:
о Номер на индекс между [] -> mytuple[O]
о Индексирането започва с О
о Отрицателно индексиране -> mytuple[-l], mytuple[-2]
о Диапазон от индекси -> mytuple[2:6] (6-тия ел. не е вкл.)
•	Промяна на елементите в данни от тип Tuple
Веднъж създаден, tuple не може да бъде променен (неизменен).
Но има заобикалящ начин - чрез превръщане на Tuple в списък,
промяна на списъка, обратно конвертиране на списъка в tuple:
х = ("apple", False, "cherry")
#	x e tuple
у = list(x)
#	у e списък: ["apple", False, "cherry"]
y[l] = "kiwi"
x = tuple(y)
Учебно пособие по ОП, ас. д-р инж. Ивайло Симеонов Ченчев
95
print(x)
('apple', 'kiwi', 'cherry')
type (x)
<class 'tuple'>
•	Добавяне на елементи
Веднъж създаден, tuple не може да бъде променен (неизменен).
Метод 1) Конвертиране в списък (list) и после обратно в tuple.
х = ("apple", False, "cherry")
у = list(x)
у.append("melon")
x = tuple(y)
print(x)
('apple', False, 'cherry', 'melon')
Метод 2) Добавяне на един tuple към друг tuple.
mytuple = ("apple", False, "cherry")
othertuple = (63, )
mytuple += othertuple
print(mytuple)
('apple', False, 'cherry', 63)
type(mytuple)
<class 'tuple'>
•	Премахване на елементи
Веднъж създаден, tuple не може да бъде променен (неизменен).
Решението е -> превръщане в списък (list).
х = ("apple", False, "cherry", False)
у = list(x)
Учебно пособие по ОП, ас. д-р инж. Ивайло Симеонов Ченчев
96
у.remove(False)
x = tuple(у)
print(x)
('apple', 'cherry', False)
•	Премахване на целия tuple
С ключовата дума del може да се изтрие tuple-a изцяло:
mt = ("apple", False, "cherry", False)
del mt
print(mt)
Traceback (most recent call last):
File "<stdin>", line 1, in <module>
NameError: name 'mt' is not defined
•	Опаковане/Разопаковане на tuples
Когато се създава tuple, обикновено към него се присвояват
стойности. Това се нарича „опаковане" на tuple:
mytup = ("apple", False, "cherry", False)
Прехвърлянето на стойностите обратно в променливи се нарича
„разопаковане":
mytup = ("apple", False, "cherry", False)
(fruit, flag_GR, extra, theyhave) = mytup
Използване на символа * (звезда):
Забележка: Броя на променливите трябва да съвпада с броя на
елементите в tuple. Ако това не е изпълнено, то трябва да се
използва символ звезда * за да се съберат останалите стойности в
списък.
ftuple	= ("apple", "banana", "cherry",
"strawberry", "raspberry")
Учебно пособие по ОП, ас. д-р инж. Ивайло Симеонов Ченчев
97
(green, yellow, *red) = ftuple
print(red)
['cherry', 'strawberry', 'raspberry']
ftuple	= ("apple", "mango", "papaya",
"pineapple", "cherry")
(green, *tropic, red) = ftuple
•	Обхождане на елементите в tuple
Обхождане на tuple елементите с оператор за цикъл for:
mytup = ("apple", "banana", "cherry")
for x in mytup:
print(x)
Обхождане на tuple елементите с оператор за цикъл while:
mytup = ("apple", "banana", "cherry")
i = 0
while i < len(mytup):
print(mytup[i])
i = i + 1
Обхождане на tuple елементите с позоваване на техния индексен
номер:
mytup = ("apple", "banana", "cherry")
for i in range(len(mytup)):
print(mytup[i])
• Свързване на tuples
За свързване на два или повече tuples може да се използва
оператора +
mytup = ("apple", "banana", "cherry")
ntup = (1, 3, 5, 7)
restup = mytup + ntup
print(restup)
('apple', 'banana', 'cherry', 1, 3, 5, 7)
Учебно пособие по ОП, ас. д-р инж. Ивайло Симеонов Ченчев
98
Ако трябва да се размножи съдържанието на tuple определен брой
пъти, трябва да се използва оператор * :
mytup = ("apple", "banana", "cherry")
newtup = mytup * 2
print(newtup)
('apple',	'banana',	'cherry',	'apple',
'banana', 'cherry')
•	Метод count()
Връща броя на указаните елементите в tuple
mytup = (1, 3, 7, 8, 7, 5, 4, 6, 8, 5)
х = mytup.count(5)
# x = 2
•	Метод index()
Търси в tuple за зададена стойност и връща позицията, в която е
намерена
mytup = (1, 3, 7, 8, 7, 5, 4, 6, 8, 5)
х = mytup.index(8)
# х = 3
14. Работа с данни от тип речник (Diet)
Речниците се записват с къдрави скоби {}, имат ключове и стойности (key:
value):
demodict = {
"brand": "BMW",
"model": "325",
"year": 2019
}
print(demodict)
• Елементите са последователни - може да бъдат посочвани с техния
индекс.
• Променяеми
Учебно пособие по ОП, ас. д-р инж. Ивайло Симеонов Ченчев
99
•	Не може да има дублирани елементи
•	Елементите могат да бъдат посочени чрез използване на името на
ключа.
Елементите на речника представляват key:value двойки и могат да бъдат
посочвани, чрез използването на техния ключ (key),
demodict = {
"brand": "BMW",
"model": "325",
"year": 2019
}
print(demodict["brand"])
BMW
Речниците не могат да имат два елемента с еднакъв ключ.
Дублираните стойности ще препокрият съществуващите стойности:
demodict = {
"brand": "BMW",
"model": "325",
"year": 2019,
"year": 2022
}
print(demodict)
{'brand': 'BMW', 'model': '325', 'year': 2022}
Дължина на речник:
demodict = {
"brand": "BMW",
"model": "325",
"year": 2022
}
print(len(demodict) )
3
Типове данни в Речник - могат да бъдат от всякакъв тип:
demodict = {
"brand": "BMW",
"electric": False,
Учебно пособие по ОП, ас. д-р инж. Ивайло Симеонов Ченчев
100
"model": "325",
"engine":	["petrol", "diesel", "hybrid",
"electric"]
"year": 2022
}
# string, Boolean, list, integer
Речниците (diet) са дефинирани като обекти с тип данни 'diet':
demodiсt = {
"brand": "BMW",
"electric": False,
"model": "325",
"engine": ["petrol", "hybrid", "electric"],
"year": 2022
}
print(type(demodict) )
<class 'dict’>
Извличане на ключовете:
Методът keys() ще върне списък на всички ключове в речника.
demodict = {
"brand": "BMW",
"electric": False,
"model": "325",
"engine": ["petrol", "hybrid", "electric"],
"year": 2022
}
print(demodict.keys() )
dict_keys	(['brand',	'electric',	'model',
'engine', 'year'])
Извличане на данни:
demodict = {
"brand": "BMW",
"model": "325",
"year": 2022
}
Учебно пособие по ОП, ас. д-р инж. Ивайло Симеонов Ченчев
101
х = demodict.values()
print(x)
dict_values (['BMW', '325', 2022])
Проверка дали даден ключ (key) съществува:
demodict = {
"brand": "BMW",
"model": "325",
"year": 2022
}
if "model" in demodict:
print("Yes - it exists")
Yes - it exists
Промяна на елемент - промяна на стойността на всеки елемент чрез
посочване на неговия ключ (името на ключа):
demodict = {
"brand": "BMW",
"model": "325",
"year": 2022
}
demodict["year"] = 2019
print(demodict["year"])
2019
Добавяне на ключ (key):
demodict = {
"brand": "BMW",
"model": "325",
"year": 2022
}
print(demodict.keys())
dict_keys (['brand', 'model', 'year'])
demodict["color"] = "black"
Учебно пособие по ОП, ас. д-р инж. Ивайло Симеонов Ченчев
102
print(demodict.keys())
dict_keys (['brand', 'model', 'year', 'color'])
Актуализиране на речник - методът update() ще промен и речника с
елементите със стойностите от подадения аргумент:
Аргументът задължително трябва да бъде речник, или iterable-обект с
ключ:стойност (key:value) двойки,
demodict = {
"brand": "BMW",
"model": "325",
"year": 2015
}
demodict.update({"year": 2020})
print(demodict["year"])
2020
Има няколко метода за изтриване на елемент от речник:
1)	Премахване на определен елемент:
demodict = {
"brand": "BMW",
"model": "325",
"year": 2020
}
demodict.pop("model")
'325'
print(demodict)
{'brand': 'BMW', 'year': 2020}
2)	Премахване на последния вмъкнат елемент:
Методът popitem() премахва последния вмъкнат елемент.
demodict = {
"brand": "BMW",
"model": "325",
"year": 2020
}
Учебно пособие по ОП, ас. д-р инж. Ивайло Симеонов Ченчев
103
demodict.popitem()
('year', 2020)
print(demodict)
{'brand': 'BMW', 'model': '325'}
3)	Чрез използване на ключовата дума del:
demodict = {
"brand": "BMW",
"model": "325",
"year": 2020
}
del demodict["year"]
print(demodict)
{'brand': 'BMW', 'model': '325'}
Забележка: С ключовата дума del може да бъде изтрит целия
речник:
demodict = {
"brand": "BMW",
"model": "325",
"year": 2020
}
del demodict
print(demodict)
Traceback (most recent call last):
File "<stdin>", line 1, in <module>
NameError: name 'demodict' is not defined
Методът clear() изчиства съдържанието на речник:
demodict = {
"brand": "BMW",
"model": "325",
"year": 2020
}
demodict.clear()
Учебно пособие по ОП, ас. д-р инж. Ивайло Симеонов Ченчев
104
print(demodict)
{}
Речник може да се обходи с помощта на for цикъл:
Отпечатване на всички имена на ключове в речник, един по един:
for х in demodict:
print(x)
Отпечатване на всички стойности в речник, един по един:
for х in demodict:
print(demodict [x] )
Може да се използва метода values() за връщане на стойности от речник:
for х in demodict.values():
print(x)
Може да се използва метода keys() за връщане на ключове от речник:
for х in demodict.keys():
print(x)
Обхождане на двойките ключ и стойност, чрез използване на метод
items():
for х, у in thisdict.items():
print(x, y)
Това HE E КОПИРАНЕ: dict2 = dictl
dict2 само ще бъде рефериран от dictl, като промен и върху dictl,
автоматично ще се отразят на dict2.
1)	За копиране на цял речник - използвайте метода сору():
demodict = {
"brand": "BMW",
"model": "325",
"year": 2020
}
newcar = demodict.copy()
Учебно пособие по ОП, ас. д-р инж. Ивайло Симеонов Ченчев
105
2)	Копиране на цял речник-да се използва функцията dict():
demodict = {
"brand": "BMW",
"model": "325",
"year": 2020
}
newcar = diet(demodict)
Речник може да съдържа речник/речници - това се нарива A dictionary
can contain dictionaries - this is called вложени речници.
childl = {
"name" : "Misho",
"year" : 2001
}
child2 = {
"name" : "Ivan",
"year" : 2004
}
kids = {
"childl" : childl,
"child2" : child2
15.	Сложим типове данни
15.1.	Списък от списъци (List of lists)
Имената в Python и съдържанието на списък са референции (references),
и ако не е документирано нещо друго, не се създават копия, когато се подава
име към метод.
Това се отнася точно толкова за list.append(), колкото и за всички други
извиквания;
list.append() добавя референция (reference) към списък, а не копие.
Създаване на списък от списъци с помощта на метода append()
Учебно пособие по ОП, ас. д-р инж. Ивайло Симеонов Ченчев
106
listl = [1,2,3]
list2 = []
list2.append(listl)
print(listl)
[1, 2, 3]
print(list2)
[[1, 2, 3]]
Изтриване на всички елементи
listl = [1,2,3]
list2 = []
list2.append(listl)
listl.clear()
# clear() изтрива всички елементи
print(listl)
[]
print(list2)
[[]]
Създаване на списък от списъци с помощта на метода аррепсЦ), но
аргумента не референция а е копие на списъка:
listl = [1,2,3]
list2 = []
list2.append(listl.copy())
listl.clear()
print(listl)
[]
print(list2)
[[1, 2, 3]]
Учебно пособие по ОП, ас. д-р инж. Ивайло Симеонов Ченчев
107
15.2.	Превръщане на diet в list of tuples
phones_dict = {'Bulgaria': 359,	'UK':	44,
'Germany': 49}
new_tuple =	[(key, value) for key, value in
phones_dict.items()]
print(new_tuple)
[('Bulgaria', 359), ('UK', 44), ('Germany', 49)]
type(new_tuple)
<class 'list'>
type(new_tuple[0])
<class 'tuple'>
15.3.	Превръщане на list of tuples в diet
alpha_list_tuples = [(65, "A"),	(66, "B") ,	(67,
"C") ]
alpha_dict = dict((j, k) for k, j in
alpha_li s t_tuples)
print(alpha_dict)
{'A': 65, 'B': 66, 'C: 67}
type(alpha_dict)
<class 'dict'>
Учебно пособие по ОП, ас. д-р инж. Ивайло Симеонов Ченчев
108
16.	Функции
Дефиниция на функция:
•	Функцията е блок от код, който се изпълнява само когато е извикан
(чрез името на функцията).
•	Може да се подават данни към функция, известии като параметри
(аргументи, args).
•	Функцията може да връща стойност като резултат от нейната работа.
Създаване на функция:
Дефиницията на функция не може да е с празно тяло. Но може да се
използва оператора pass за да бъдат избегнати грешки.
Функция в Python се дефинира чрез използването на ключовата дума def:
def my_f unction() :
pass
Извикване на функция става чрез нейното име, последвано от кръгли
скоби:
my_f unction()
Пример за извикване на функция:
def my_function() :
print("Hello World — from function.")
my_function()	# извикване на функцията
Hello World — from function.
Подаване на аргументи:
Данни се подават към функция като аргументи
my_function (paraml, param2 , ...)
Аргументите се изписват след името на функцията между кръгли скоби
my_function (paraml, param2 , ...)
Учебно пособие по ОП, ас. д-р инж. Ивайло Симеонов Ченчев
109
Отделимте аргументи се разделят със символ запетайка,
my_f unction(paraml, param2 , ...)
Разлика между Параметри и Аргументи:
Термините параметър и аргумент може да бъдат използвани за едно и
също нещо: данните, който се подават към функция.
От гледна точка на функция:
•	Параметърът е променливата, която е указана между кръглите скоби
при дефинирането на функцията.
def my_function ( х, у, z ) :	#х е параметгьр
if х >= ...
•	Аргументы е стойността, която се изпраща към функцията в момента
на извикването и.
my_function( 3, 4, 11)	#3,4,11- аргументи
Брой на аргументите:
По подразбиране, функциите трябва да бъдат извиквани с коректен брой
аргументи.
Това означава, че ако функция очаква 2 аргумента, то тя трябва да бъде
извикана с точно 2 аргумента - нито повече, нито по-малко.
Пример:
#	функцията очаква 2 аргумента, и получава 2 аргумента
def my_function(fname, Iname):
print(fname + ” ” + Iname)
my_function(”Ivan", ”Ivanov")
При опит да бъде извикана функцията (от предходния слайд) с 1 или с 3
аргумента, ще се получи съобщение за грешка:
#	функцията очаква 2 аргумента, а получава 1
def my_function(fname, Iname):
Учебно пособие по ОП, ас. д-р инж. Ивайло Симеонов Ченчев
110
print(fname + ” ” + Iname)
my_f unction(”Ivan")
Traceback (most recent call last):
File "<stdin>", line 1, in <module>
TypeError:	my_function() missing 1 required
positional argument: 'Iname'
Пример на функция с 1 аргумент:
def my_function(progname):
print(progname + " Programming.")
my_f unction("Python")
Python Programming.
my_function("JavaScript")
JavaScript Programming.
Пример 1 - функция с 2 аргумента:
def my_function(progl, prog2):
print (progl +	" and "	+ prog2 +	"
Programming. ")
my_function("Python", "JavaScript")
Python and JavaScript Programming.
Пример 2 - функция с 2 аргумента:
def add_numbers(х, у):
print("х + у = " + str(x+y))
# използва се функция
# str() за да се
# промени типа на
# данните: int -> str
add_numbers(7,8)
x + у = 15
Учебно пособие по ОП, ас. д-р инж. Ивайло Симеонов Ченчев
111
Произволни аргументи, *args:
Произволния брой аргументи место за кратко се записва с *args в
документацията на Python.
Ако не е известен броя на аргументите, конто ще бъдат подадени към
функция, пред името на параметър може да се постави символа * (звезда) при
дефинирането на функцията.
По този начин, функцията ще получи tuple от аргументи, и съответно ще
може да ги достъпва.
Пример:
def my_f unction(*toys) :
print("The favourite toy is ” + toys[2])
my_function("playstation", "bicycle", "ball")
The favourite toy is ball
Аргументи като ключови думи:
Може аргументите да бъдат подавани с key = value синтаксис.
По този начин, няма значение редът на подаване на аргументите.
def my_function(child3, child2, childl):
print("The youngest child is " + child3)
my_f unction(childl = "Ivan", child2 = "Asen" , \
child3 = "Petar")
В Python документацията, фразата „Keyword Arguments" место ce
съкращава като kwargs.
Аргументи за произволни ключови думи, **kwargs:
Ако броя на аргументите, подавани като ключови думи не е известен,
трябва да се използват две звездички ** пред името на параметъра при
дефинирането на функцията.
Учебно пособие по ОП, ас. д-р инж. Ивайло Симеонов Ченчев
112
По този начин във функцията се получава речник с аргументи (dictionary
of arguments), и съответно може да бъдат достъпвани.
Аргументи за произволни ключови думи (Arbitrary Kword Arguments)
обикновено се съкращават с **kwargs в документацията на Python.
Пример:
def my_f unction(**kid) :
print("Last name is " + kid["Iname"])
my_f unction(fname = "Ivan", Iname = "Petrov")
Last name is Petrov
Стойност по подразбиране за параметър:
Това е начин за задаване на стойност по подразбиране и функция може
да бъде извикана без аргумент:
def my_function(country = "Bulgaria"):
print("I am from " + country)
my_function("USA")
I am from USA
my_f unction()
I am from Bulgaria
Подаване на параметри от всякакъв тип:
Може да бъде подаден всякакъв тип данни като аргументи при
извикване на функция (string, number, list, dictionary и т.н.), и ще бъде третиран
от същия тип в тялото на функцията.
Ако се подаде списък (List) като аргумент, то той ще бъде списък и при
достигането на функцията - по-точно тялото на функцията.
Пример:
def my_function(food) :
Учебно пособие по ОП, ас. д-р инж. Ивайло Симеонов Ченчев
113
for x in food:
print(x)
fruits = ["apple", "banana", "cherry"]
my_f unction(fruits)
Връщане на стойност:
Връщаната стойност от функция в Python може да бъде всякакъв Python
обект.
Връщаната стойност от функция може да бъде пропускана.
Може да бъде пропускай изцяло оператора „return".
И в двата случая, върнатата стойност ще бъде None.
При изричното използване на return, функцията прекъсва изпълнението
си и изпраща връщаната стойност обратно в мястото на извикването и.
За да има изрично връщане на стойност от функция в Python, трябва да се
използва оператора return последван от незадължителна стойност.:
Пример 1:
def amg():
#	Изрично използване на оператор return
return 63
if amg() == 63:
#	В мястото на извикване се връща 63
print("YESS")
YESS
Пример 2:
def amg():
#	Изрично използване на
#	оператор return
return 63
res = amg ()
#	В мястото на извикване се връща
Учебно пособие по ОП, ас. д-р инж. Ивайло Симеонов Ченчев
114
#	стойност 63
type(res)
<class 'int'>
print(res)
63
Python функция винаги ще има връщана стойност.
Ако не е явно указано каква стойност да бъде върната в мястото на
извикването, или въобщее пропуснат оператора return, то тогава Python косвено
ще върне стойност по подразбиране - и това е None.
Връщана стойност и print():
»> def print_63() :
... print(63)
»> print_63()
63
»> def return_63() :
... return 63
»> return_63()
63
При това използване няма видима разлика между двете. Но в първия
случай на екрана се отпечатва числото 63, а във втория се отпечатва върнатата
стойност.
16.1.	Вградени функции
Интерпретаторът на Python има няколко вградени функции и типове,
конто винаги са наличии.
Има 68 вградени функции в Python:
https://docs.python.Org/3/library/functions.html
Учебно пособие по ОП, ас. д-р инж. Ивайло Симеонов Ченчев
115
Всяка една от тях изпълнява определена задача и може да бъдат
използвани от всяка програма.
Built-in Functions
А	E	L	R
abs()	enumerate()	len()	range()
aiter()	eval()	listO	repr()
all()	exec()	localsO	reversed()
any()			round()
anext()	F	M	
ascii()	filter()	map()	S
	float()	max()	setO
В	format()	memoryview()	setattr()
bin()	frozenset()	min()	slice()
bool()			sorted()
breakpoint()	G	N	staticmethod()
bytearray()	getattr()	nextO	str()
bytes()	globals()		sum()
		0	super()
C	H	objectO	
callable()	hasattr()	octO	т
chr()	hash()	open()	tuple()
classmethodO	help()	ordO	type()
compile{)	hex()		
complex()		P	V
	1	pow()	varsO
D	id()	print()	
delattr()	input()	property()	Z
dict()	int()		zipO
dir()	isinstance()		
divmod()	issubclassO		
	iterO			import	()
16.2.	Ламбда функции
Ламбда функцията е малка анонимна (без име) функция.
Ламбда функцията може да получава произволен брой аргументи, но
може да има само един израз (expression).
Синтаксис:
lambda arguments: expression
Учебно пособие по ОП, ас. д-р инж. Ивайло Симеонов Ченчев
116
Пример:
#	Изразът се изпълнява и се връща резултат
#	Добавяне на 10 към аргумента а, и резултатът се връща:
х = lambda а : а + 10
print(х(5) )
15
Пример:
#	Ламбда функциите може да приемат произволен брой аргументи:
х = lambda a, b : а * b
print(х(5, 6) )
30
х = lambda а, Ь, с : а+Ь+с
print(x(5, 6, 2))
13
Силата на ламбда функцията е добре изразена, когато се използва една
анонимна функция в друга анонимна функция.
Да кажем, че има дефиниция на функция, която приема един аргумент и
този аргумент ще бъде умножен с неизвестно число :
Пример:
def myfunc(n):
return lambda a : a * n
mydoubler = myfunc(2)
print(mydoubler(11))
16.3.	Рекурсивни функции
Рекурсията e обща математическа и програмна концепция.
Рекурсивна функция - функция, която извиква сама себе си.
Пример в математиката:
Учебно пособие по ОП, ас. д-р инж. Ивайло Симеонов Ченчев
117
n! = n . (n-1). (n-2).... 1
n! -> чете се „ен факториел"- произведението на числата от 1 до п
Пресмятане на факториел с рекурсивна функция:
п! = 1.2.3.4.5.6.7.8.9.10
def factorial(х):
’’’’’’This is a recursive function
to calculate the factorial of
an integer’””’
if x == 1:
return 1
else:
# recursive call to the function
return (x * factorial(x-1))
n = 10
result = factorial(n)
print("The factorial of", n, "is", result)
The factorial of 10 is 3628800
Извиквания на функцията:
factorial(lO)
return (10 * factorial(9)
factorial(9)
return (9 * factorial(8)
factorials)
factorial(3)
return (3 * factorial(2)
factorial(2)
return (2 * factorial(l)
factorial(l)
return 1
(10*(9*(8*(7*(6*(5*(4*(3*(2*(l)))))))))|
Учебно пособие по ОП, ас. д-р инж. Ивайло Симеонов Ченчев
118
Y1. Работа с файлове
Съществуват четири режима за отваряне на файл:
"г" - четене (по подразбиране) - отваря файл за четене. Ако файлы
не съществува - връща грешка.
"а"	- добавяне - отваря файл за добавяне. Ако файлы не съществува
- създава го.
"w"	- писане - отваря файл за писане. Ако файлы не съществува -
създава го.
"х"	- създава - създава файл. Ако файлы съществува - връща грешка.
Допълнителни режими:
"t"	- текст (стойност по подразбиране) - текстов файл
"Ь" - бинарен (например - файлове с изображения)
"г+" - чете отначало, пише в края. Указателя е позициониран в
началото на файла. Ако файлы не съществува - връща грешка.
"w+" - отваря файл за четене и писане. Ако файлы съществува -
съдържанието му се изтрива. Указателя е позициониран в
началото на файла.
"а+" - отваря файл за четене и писане. Ако няма такъв файл - създава
се нов. Указателя е позициониран в края на файла. Новите
данни се записват е края на файла.
Отваряне на файл
Синтаксис:
fileObject.open(//7e/ mode)
file - пътя и името на файла
mode - стринг, който указва режима на отваряне на файла
Връща файлов обект.
f = open("my_data.txt", "rt")
Ако файлы се намира в текущата директория:
f = open("demo_file.txt", "rt")
Учебно пособие по ОП, ас. д-р инж. Ивайло Симеонов Ченчев
119
Ако файлът се намира в друга директория:
f = open(”/fswork/students/usr4/demo_file.txt","rt")
Функция read()
Функцията open() връща файлов обект, който има метод read() за четене
на съдържание на файл:
f = open( "demo_file.txt", "rt" )
#	чете и отпечатва целия файл
print(f.read())
#	чете 100 байта от файла и ги отпечатва
print(f.read(100))
f = open( "demo_file.txt", "rt" )
read_text = f.read(100)
#	опитва да прочете 100 байта;
#	Позицията на указателят във файла е на 101-
вия байт
#	следващото извикване на read() ще продължи
да чете от текущата позиция
print(read—text)
read—text = f.read(100)
#	опитва да прочете нови 100 байта
print(f.read(100))
Променливи на класа File Open в Python:
Няколко променливи във файл-клас:
f = open( "demo_file.txt", "rt" )
# f е fileObject обект
print("The filename is: " + f.name)
The filename is: demo_file.txt
Учебно пособие по ОП, ас. д-р инж. Ивайло Симеонов Ченчев
120
print("The file encoding is: ” + f.encoding)
The file encoding is: UTF-8
print("The file is: " + str(f.closed))
The file is closed: False
print("The file is open in mode: " + f.mode)
The file is open in mode: rt
Функция readline()
Синтаксис:
fileObject.readline( size)
size - брой байтове, конто да бъдат прочетени от файла
По подразбиране, стойността на size е -1, и следователно се
прочита целия ред.
Връща прочетен ред от файл (или size байта).
f = open("my_data.txt", "rt")
f.readline()
print(f.readline())
f = open( "demo_file.txt", "rt"		)	
print(f.readline())	#четене	на	ред
print(f.readline())	#четене	на	ред
print(f.readline(100))	#четене	на	100 байта
Прочитане на целия файл ред по ред:
f = open( "demo_file.txt", "rt" )
for one_line in f:
print(one_line)
Функция seek()
Синтаксис:
fileObject.seek( offset [, whence])
Учебно пособие по ОП, ас. д-р инж. Ивайло Симеонов Ченчев
121
offset - позицията на указателя (за четене/писане) вътре във
файла.
whence - незадължителен
О - стойност по подразбиране - абсолютно позициониране
1	- относително от текущата позиция
2	- относително от края на файла
Връща новата абсолютна позиция на вътрешния указател.
Пример 1:
test.txt
1: 123456
2:1234567
3:12345678
4:123456789
5:1234567890
f = open( "test.txt", "rt" )
print(f.readline())
1: 123456
print(f.readline())
2: 1234567
f.seek(0, 0)
0
print(f.readline())
1: 123456
Пример 2:
012345
1: 123456
print(f.readline() )
1: 123456
f.seek(5, 0)
5
Учебно пособие по ОП, ас. д-р инж. Ивайло Симеонов Ченчев
122
print(f.readline())
3456
f.close ()
Функция close()
БЕЛЕЖКА: Добра практика e винаги да се затваря файл, когато е
приключила работата с него.
f = open( "demo_file.txt", "rt" )
print(f.readline() )
f.close()
Всички стъпки
#	отваряне на файл
f = open( "demo_file.txt", "rt" )
#	четене на ред
print(f.readline())
print(f.readline())
#	четене на 100 байта
print(f.readline(100))
#	затваряне на файл
#	освобождава fileObject
f.close()
Писане в края на файл - append:
За да се записва в края на файл, трябва да се използва режим „а" (append)
при извикването на функцията ореп():
f = open("demo_file.txt", "a")
f.write("Some more text at the end.")
f.close()
Учебно пособие по ОП, ас. д-р инж. Ивайло Симеонов Ченчев
123
Писане във файл - презаписване:
За да бъде презаписан файл, трябва да се използва режим "w" (write) при
извикването на функцията ореп():
f = open("demo_file.txt", "w")
f.write ("Delete content. Add new text in the
file.")
f.close ()
Създаване на нов файл:
За да бъде създаден нов файл в Python, трябва да се използва някой от
следните параметри:
"х" - създаване - ще създаде файл; връща грешка, ако файлът съществува
"а" - добавяне - ще създаде файл, ако не съществува
"w" - писане - ще създаде файл, ако не съществува
18. Модули и Пакети
18.1.	Модули
Модулът е файл с Python код (дефиниции и оператори).
В един модул може да се дефинират класове, функции и променливи.
Дефинициите от даден модул може да бъдат импортирани (imported) в
други модули или в главния модул (main).
Името на файла (с разширение .ру), е име на модула.
Example: my_module.py
За да бъде използван даден модул, той трябва да бъде импортиран:
import hashlib
import sys
import NumPy
Даден модул може да импортира други модули.
Учебно пособие по ОП, ас. д-р инж. Ивайло Симеонов Ченчев
124
Обичайно е, но не е задължително, всички оператори за импортиране да
се поставят в началото на модула (или скрипта).
Ако след името на модула следва ключовата дума as, то името, което
следва е директно свързано с импортирания модул:
import hashlib as hlib
# от този момент нататък се използва името "hlib"
Получаване на информация за импортиран модул:
»> import hashlib
За показване на въведена документация за всички функции в модул
наведнъж:
»> help (hashlib)
За да бъде изведен списък на всички имена на функции и променливи,
дефинирани в даден модул:
»> dir (hashlib)
Извикана функцията dir() без аргументи, показва всички текущо
дефинирани имена:
»> dir ()
Функцията dir() не показва имената на вградени функции и променливи.
Тези имена с дефинирани в стандартния модул builtins:
»> import builtins
»> dir (builtins)
Някои допълнителни модули са вградени в интерпретатора на Python.
Те осигуряват достъп до операции, конто не са част от ядрото на езика, но
въпреки това са вградени, или за ефективност, или за осигуряване на достъп до
примитиви на операционната система, като системни повиквания.
»> import sys
»> sys.psi	# задава основния промпт
'»> '
»> sys.psi = "python3 prompt > ’’
python3 prompt >
Учебно пособие по ОП, ас. д-р инж. Ивайло Симеонов Ченчев
125
18.2.	Пакети
Пакеты представлява организирана колекция от Python модули.
Казано по друг начин, пакетите предоставят възможност за
структуриране на Python модули чрез използване на имената им, свързани с
точки.
Например, името на модул bar.ml обозначава модул с име ml в пакет с
име bar.
От гледна точка на разположение на файловете върху диск/директории:
../research/mymath/_init_.ру	# файл със специално име
../research/mymath/algebra.py
Ако директорията "../research" е описана в променливата на
обкръжението(средата) PATH, то тогава модула algebra може да бъде
импортиран по следния начин:
»> import mymath. algebra
или
»> from тута th import algebra
Файлы___init_.ру
Обикновено е празен файл, но може да бъде използван за:
•	Импорт на допълнителни модули
•	Инициализиране на най-високо ниво на обекти/променливи
Файловете ___init_.ру са необходими за да може Python да третира
директориите, съдържащи ру файл като пакети.
from package import item
# item -> друг подмодул от пакета, функция, клас, променлива
Ако имаме следната файлова структура:
Учебно пособие по ОП, ас. д-р инж. Ивайло Симеонов Ченчев
126
research
—_____init_. py
— mymath
—_____init__.py
— algebra.py
— myphys
1— init .py
#	research -> име на пакета
#	mymath - под-пакет за специфични раздели
#	myphys - под-пакет за специфични раздели
Може да импортираме модули с:
from research import mymath
from research.mymath import algebra
19.	Документиране (Docstring)
Коментиране срещу Документиране на Кода:
Коментирането е описване на кода за други разработчици.
Трябва да бъдат кратки и фокусирани.
# линия с коментар
Документирането на кода описание на неговото използване и
функционалност за потребителите.
""" Document the functionalities..."""
Коментиране - различии цели:
• Планиране и преглеждане
#	First step
#	Second step
• Описание на кода
# If not successful -> prompt user for new settings.
• Описание на алгоритми
# Using bubble sort algorithm
Учебно пособие по ОП, ас. д-р инж. Ивайло Симеонов Ченчев
127
• Маркиране (Tagging)
# TODO: Add check for False value of the expression
Документирането на код на Python е съсредоточено върху docstrings.
docstring е стрингов литерал, който се появява като първи оператор в
модул, функция, клас или дефиниция на метод. Такъв docstring става _doc_
(два символав началото и два в края) специален атрибут на този обект.
Docstrings се съхраняват в обектите!
Това означава, че това свойство (property) може да бъде обработвано
директно.
Docstrings с единични линии:
»> def bar () :
""" A single-line docstring."""
»> print (bar._____doc___)
A single-line docstring.
Docstrings с многоредови линии:
»> def bar () :
II II II
A multi-line docstring.
II II II
»> print (bar._____doc___)
A multi-line docstring.
Docstrings за функции на Python.
•	docstring за функция или метод трябва да обобщава нейното
поведение и да документира нейните аргументи, и връща ни
стоимости.
•	Също така, трябва да описва всички изключения (exceptions), конто
може да произтекат, както и другите опционни аргументи.
Пример:
def add_binary(а, b):
I I I
Учебно пособие по ОП, ас. д-р инж. Ивайло Симеонов Ченчев
128
Returns the sum of two decimal numbers in
binary digits.
Parameters:
a (int): A decimal integer
b (int): Another decimal integer
Returns:
binary_sum (str) : Binary string of the
sum of a and b
I I I
binary_sum = bin(a+b)
return binary_sum
print (add_binary.___doc__)
Python има вградена функция help(), която извежда обектния docstring
на конзолата.
»> help (str)
class str(object)
| str(object='') -> str
| str(bytes_or_buffer[, encoding[, errors]]) ->
str
I
| Create a new string object from the given
object. If encoding or
| errors is specified, then the object must
Docstrings за вградената функция print():
»> print (print. doc______)
print(value, . .., sep=' ',	end='\n', file=sys.stdout,
flush=False)
Prints the values to a stream, or to sys. stdout by default.
Optional keyword arguments:
file: a file-like object (stream); defaults to the current
sys.stdout.
sep:	string inserted between values, default a space.
Учебно пособие по ОП, ас. д-р инж. Ивайло Симеонов Ченчев
129
end:	string appended after the last value, default a
newline.
flush: whether to forcibly flush the stream.
Документацията за функцията print() e представена като_doc_атрибут
за тази функция.
20. Взаимодействие с ОС
Права за достъп до файлове - в Linux
-rw-r--r--	1	usr479901	students	184	Oct	24	11:18	test.txt
-rwxr-xr-x	1	usr479901	students	136	Oct	24	00:47	import_data.sh
drwx		10	usr479901	students	320	Oct	13	23:21	arch
-rw-r—Г--	1	usr479901	students	116	Oct	11	23:31	my_work_04.py
- rw		1	usr479901	students	965	Oct	9	00:28	my_work_01. py
drwxr-xr-x	6	usr479901	students	192	Oct	9	00:27	meetings
Правата за достъп до файловете може да бъдат описани и с цифри (rwxr-
хг— -> цифрово това е 754 )
- rwx
User permissions:
r (read)
w (write)
x (execute)
file type:
- (regular file)
d (directory)
I (link)
Group permissions:
r (read)
w (write)
x (execute)
Others permissions:
r (read)
w (write)
x (execute)
Специални имена на директории:
в Linux:	.	- текущата директория
Учебно пособие по ОП, ас. д-р инж. Ивайло Симеонов Ченчев
130
в Linux:	..	- родителската директория (едно ниво
нагоре)
Абсолютен път:
в Linux:	/var/log/apache2/
в Windows:	C:\Windows\System32\>
Относителен път (относителен от текущото място):
в Linux:	./apache2/
../userl/arch/
в Windows:	..\	# една директория нагоре
..\Public\Downloads
Имена на файлове с абсолютен път:
в Linux: /var/log/apache2/error.log
в Windows:
C:\Users\ivaylochenchev\Downloads\OfficeSetup.exe
Имена на файлове с относителен път:
в Linux:	./etc/apache2/httpd.conf
../userl/arch/sqldb_arch_2022-ll-03.sql
в Windows:	.\dotNetFx40_Full_x86_x64.exe
..\Public\Downloads\Teams_windows_x64.exe
Ред „Shebang" (https://en.wikipedia.org/wiki/Shebang (Unix)
В компютрите, shebang е символна последователност от два символа
диез и удивителен знак (#!) в началото на скрипт. Още бива наричана sharp-
exclamation, sha-bang, hashbang, pound-bang, или hash-pling.
#!interpreter [optional-arg]
interpreter - обикновено e абсолютен път към интерпретатора
Първия ред на всички Python програми трябва да бъде shebang ред -
„казва" на компютъра кой интерпретатор да използва за изпълнението на
програмата (скрипта).
Учебно пособие по ОП, ас. д-р инж. Ивайло Симеонов Ченчев
131
Редът shebang започва с #!, но останалата част зависи от операционната
система.
• В Windows свързването на даден тип файл с програма е малко по-
специфично, но. Редът shebang не се използва за да се прочете името
на интерпретатор, но може да бъде:
#!руthon3
• В OS X, редът shebang е
#!/usr/bin/env руthon3
• В Linux, редът shebang е
#!/usr/bin/руthon3
Бележка: Пътя до Python интерпретатора може и да е различен.
Стартиране на скрипт (файл с команди):
Стартиране през интерпретатор:
# python3 first_python_script.ру
Самостоятелно като скрипт:
Скрипта трябва да има:
-> shebang line (first line) similar to:
#!/usr/local/bin/python3
-> execute permission
chmod +x first_python_script.py
./first_python_script.py
Също e възможно:
python3 ./first_python_script.py
# vi first_python_script.py
#!/usr/local/bin/python3
print("Hello World from first Python script!")
# Is -It first_python_script.py
-rw-r--r--	1 ivaylochenchev
staff
67 Nov
1	23:36
first_python_script.py
# chmod +x first_python_script.py
Учебно пособие по ОП, ас. д-р инж. Ивайло Симеонов Ченчев
132
# Is -It first_python_script.py
-rwxr-xr-x 1 ivaylochenchev staff 67 Nov 1	23:36
firs t_python_s cript.py
# ./first_python_script.py
Hello World from first Python script?
# python3 ./first_python_script.py
Hello World from first Python script?
20.1	. Модул os
Python модулът os осигурява голям набор от полезни методи за работа с
файлове и директории.
Модулът os е част отстандартните Python модули. Този модул предоставя
преносим начин за използване на функционалност, зависеща от операционната
система.
#	Linux
»> import os
»> print (os.getcwd() ) # cwd - current working dir
/Users/usr470099
#	Windows
»> import os
»> print (os . getcwd () )
C:\Users\usr470099\Downloads
Изтриване на файл от директория:
»> import os
»> оs . remove (’’ demo_f ile. py ’’)
Проверка дали файлът съществува:
import os
if os.path.exists("demo_file.txt"):
os . remove ("demo_f ile. txt")
else:
Учебно пособие по ОП, ас. д-р инж. Ивайло Симеонов Ченчев
133
print("The file does not exist")
Изтриване на директория (папка):
»> import os
»> os . rmdir ("working")
# само празни директории може да бъдат изтрити
20.2	. Модул shutil
Модул shutil - файлови операции на високо ниво.
Копиране на файл от едно място на друго:
import shutil
shutil.copy("file_path",
"path_to_directory_where_to_copy_to ")
Изтриване на съдържанието на директория (и самата директория):
import shutil
shutil.rmtree("file_path")
Преместване на файл от едно място на друго :
import shutil
shutil.move("demo_file.py", "new_dir/")
Информация за използването на диск (капацитет, използвано, свободно):
import shutil
total_mem,	used_mem,	free_mem	=
shutil.disk_usage('. ')
gb = 10**9
print('Total: {:6.2f} GB'.format(total_mem/gb))
print('Used : {:6.2f} GB'.format(used_mem/gb))
print('Free : {:6.2f} GBformat(free_mem/gb))
Учебно пособие по ОП, ас. д-р инж. Ивайло Симеонов Ченчев
134
21.	Методи за сортиране
Дефиниция в Collins Речник:
Процес на работа на подреждане на компоненти и данни според
специфични критерии.
Дефиниция във vocabulary.com:
Групиране по клас или вид, или размер.
В ИТ:
Сортиране -> Подреждане на данни или трупа от записи по
определен начин, хронологично или азбучно, за по-ефективен
достъп.
Друга дефиниция:
Алгоритмите за сортиране са набор от инструкции, конто приемат
масив или списък като вход и подреждат елементите в определен
ред.
Няколко примера за сортиране от реалния живот:
•	Телефонен справочник
•	Речници
•	Списъци от контакти
Важност:
•	Може да намали сложността на проблема
•	Директно приложение в алгоритми за търсене, алгоритми за бази
данни, структури отдании и др.
Базирани на техника:
•	Рекурсивни алгоритми.
•	Не-рекурсивни алгоритми.
Въз основа на реда на подреждане:
•	Подреждане на данните в нарастващ ред.
•	Подреждане на данните в намаляващ ред.
Учебно пособие по ОП, ас. д-р инж. Ивайло Симеонов Ченчев
135
Съществуват различии методи за сортиране - метод на мехурчето,
оптимизиран метод на мехурчето, бързо сортиране, сортиране чрез вмъкване,
сортиране чрез сливане, сортиране чрез избиране и т.н.
Един от най-известните (и най-лесни) методи за сортиране в
програмирането е т.нар. „метод на мехурчето" (на англ. ез. bubble sort) и
оптимизирания метод на мехурчето. Ще бъдат разгледани малко по-детайлно.
2	1.1. Метод на мехурчето
Този метод се използва за сортиране на линеен списък (едномерен
масив) в определен ред - намаляващ или нарастващ. Нарича се метод на
мехурчето, защото при всяка итерация се получава едно„изплуване" на елемент
в края на масива. Ако сортирането е в нарастващ ред, то след обхождане на
масива, в края се получава най-големия елемент. След като в края се получава
най-големия елемент, то на следващото обхождане, сравненията се правят до
един елемент преди края и т.н.
Методът ще бъде демонстриран със следния пример:
Задача: Да се сортира списъка [9, 14, 1, 6, 20, 4] цифрово и в нарастващ
ред.
1	2	3	4	5	6
9	14	1	6	20	4
Започва сравнението на първия и втория елемент - 9>14 - не ->
следователно няма размяна на елементите:
9 >14	9	14	1	6	20	4	без размяна
При следващото сравнение 14>1 - да -> елементите трябва да бъдат
разменени:
Учебно пособие по ОП, ас. д-р инж. Ивайло Симеонов Ченчев
136
14 >1
9	14	1	6	20	4
размяна
Следват останалите сравнения:
14 >6
20
4
размяна
14 >20
без
размяна
20 >4
9>1
9>6
9 >14
размяна
размяна
размяна
без
размяна
6>9
размяна
Без
размяна
6	9	4	14	20
Без
размяна
Учебно пособие по ОП, ас. д-р инж. Ивайло Симеонов Ченчев
137
9>4
1>6
6>4
1>4
Сортиран:
размяна
без
размяна
размяна
без
размяна
Реализация на алгоритъма на Python:
def bubbleSort(array):
n = len(array)
for i in range(n):
for j in range(0, n - i - 1):
if array[j] > array[j + 1]:
temp = array[j]
array[j] = array[j + 1]
array[j + 1] = temp
data = [-2, 45, 0, 11, -9]
bubbleSort(data)
print(' Bubble Sort -> Sorted Array in
Order: ')
print(data)
Ascending
Учебно пособие по ОП, ас. д-р инж. Ивайло Симеонов Ченчев
138
2	1.2. Оптимизиран метод на мехурчето
Този метод е аналогичен на класическото сортиране по метода на
мехурчето, но при всяка итерация се прави проверка дали е направена размяна
на елементи. Ако не е направена размяна, то това означава, че елементите са
подредени и алгоритъма приключва. Това се прави с цел подобряване на
времето за изпълнение на алгоритъма.
Реализация на оптимизирания метод на мехурчето на Python:
def bubbleSortOptimized(array):
n = len(array)
for i in range(n):
swapped = False
for j in range(0, n - i - 1):
if array[j] > array[j + 1]:
temp = array[j]
array[j] = array[j + 1]
array[j + 1] = temp
swapped = True
if swapped == False:
break
data = [45]
bubbleSortOptimized(data)
print(' Optimized Bubble Sort -> Sorted Array in
Ascending Order: ')
print(data)
[45]
22.	Обработка на неочаквани грешки
Python има много вградени изключения, конто биват извеждани, когато
програмата срещне грешка (нещо в програмата се обърква).
Когато възникнат тези изключения, интерпретаторът на Python спира
текущия процес и го предава на извикващия процес, докато не бъде обработен.
Учебно пособие по ОП, ас. д-р инж. Ивайло Симеонов Ченчев
139
Ако не бъде обработено дадено изключение, то изпълнението на програмата ще
се прекъсне.
22.1.	Обработка на изключения
Прихващане на изключения в Python:
В Python, изключенията могат да се обработват с помощта на оператор
try.
Критичната операция, която може да предизвика изключение, се поставя
в клаузата try. Кодът, който обработва изключенията, е написан в клаузата за
изключение.
Пример: изчисляване на реципрочната стойност
# import module sys to get the type of exception
import sys
randomList = ['a', 0, 2]
for entry in randomList:
try:
print("The entry is", entry)
r = 1/int(entry)
break
except:
print("Attention!	", sys.exc_info()[0],
"occurred.")
print("Another entry.")
print ()
print("The reciprocal of", entry, "is", r)
The entry is a
Attention! <class 'ValueError'> occurred.
Next entry.
The entry is 0
Attention! <class 'ZeroDivisionError'> occured.
Учебно пособие по ОП, ас. д-р инж. Ивайло Симеонов Ченчев
140
Next entry.
The entry is 2
The reciprocal of 2 is 0.5
Прихващане на специфични изключения в Python:
В горния пример не се спомена конкретно изключение в клаузата за
изключение.
Това не е добра практика за програмиране, тъй като ще улови всички
изключения и ще обработва всеки случай по един и същи начин. Може да се
посочи кои изключения трябва да улавя клауза за изключение.
Клаузата try може да има произволен брой клаузи за изключение за
обработка на различии изключения, но само една ще бъде изпълнена в случай,
че възникне изключение.
try:
#	do something
pass
except ValueError:
#	handle ValueError exception
Pass
except (TypeError, ZeroDivisionError):
#	handle multiple exceptions
# TypeError and ZeroDivisionError
Pass
except:
# handle all other exceptions
pass
Пораждане на изключения в Python:
Учебно пособие по ОП, ас. д-р инж. Ивайло Симеонов Ченчев
141
При програмирането на Python, се повдигат изключения, когато
възникнат грешки по време на изпълнение.
Можем също ръчно да повдигаме изключения като използваме
ключовата дума raise.
»> raise Keyboardinterrupt
Traceback (most recent call last):
Keyboardinterrupt
»> raise MemoryError("This is an argument")
Traceback (most recent call last):
MemoryError: This is an argument
Пример:
»> try:
...	a = int(input("Enter a positive integer:
"))
... if a <= 0:
. . .	raise ValueError ("That is not a positive
number!")
... except ValueError as ve:
... print(ve)
Enter a positive integer: -2
That is not a positive number!
22.2.	Assertions
Python ключовата дума assert:
С използването на:
assert condition
програмата тества условието и ако то е False - веднага генерира
изключение AssertionError.
Тества дали условие връща True:
х = "hello"
Учебно пособие по ОП, ас. д-р инж. Ивайло Симеонов Ченчев
142
#if True -> nothing happens:
assert x == "hello"
#if False -> AssertionError is raised:
assert x == "goodbye"
Ключовата дума assert се използва, когато се дебъгва код (debugging).
Може да се каже, че е почти еднаква на следната конструкция:
if not condition:
raise AssertionError()
assert може да включва и съобщение, което ще се отпечата, ако
условието е False:
assert х == "goodbye", "х should be 'hello'"
Traceback (most recent call last):
File "<stdin>", line 1, in <module>
AssertionError: x should be 'hello'
Оператор try c else клауза:
try:
num = int(input("Enter a number: "))
assert num % 2 == 0
except:
print("Not an even number!")
else:
reciprocal = 1/num
print(reciprocal)
Учебно пособие по ОП, ас. д-р инж. Ивайло Симеонов Ченчев
143
23.	Аргументи от командния ред
Илла няколко ллодула, който лложе да се използват за обработка на
аргулленти от колландния ред: sys, getopt, argparse.
23.1.	Модул sys
Пролленливата sys.argv е списъчна структура:
Представлява списък от аргулленти, подадени от колландния ред.
len(sys.argv) - връща броя на подадените аргулленти.
sys.argv[O] - иллето на текущия Python скрипт.
Използване на ллодул sys:
import sys
#	total arguments
n = len(sys.argv)
print("Total arguments passed:", n)
#	Arguments passed
print("\nName of Python script: ", sys.argv[O])
print("\nArguments passed:", end = " ")
for i in range(1, n):
print(sys.argv[i], end = " ")
23.2.	Модул getopt
Използване на ллодул getopt:
Модулът getopt разширява разделянето на входния стринг чрез
валидиране на параллетрите.
Позволява използването на кратки и на дълги параллетри, включително и
приеллане на стойности (value assignment).
Учебно пособие по ОП, ас. д-р инж. Ивайло Симеонов Ченчев
144
Обаче, този модул изисква използването на модул sys за да обработва
правилно входните данни.
ВНИМАНИЕ: За да бъде използван модула getopt, първото нещо, което
трябва да бъде направено е от списъка с входните аргументи да бъде премахнат
първия елемент (референция към изпълняваната програма).
Синтаксис:
getopt.getopt(args, options[, long_options])
args e списъкът с аргументи, който трябва да бъде анализиран, без
референцията към изпълняваната програма.
Iong_options - незадължителен аргумент - трябва да бъде списък
от низове с имената на дългите опции, конто трябва да се
поддържат. Водещите знаци не трябва да се включват в името
на опцията. Дългите опции, конто изискват аргумент, трябва да
бъдат последвани от знак за равенство (-') Не се поддържат
незадължителни аргументи. За да приемате само дълги опции,
опциите трябва да са празен низ. Дългите опции на командния ред
могат да бъдат разпознати, стига да предоставят префикс на името
на опцията, който съвпада точно с една от приетите опции.
Например:
"first_name ="	- съответства на "--first_name"
"last_name ="	- съответства на "--last_name"
opts, args = getopt.getopt(argv,	”f:1:”,
["first_name =" , "last_name =’’])
for opt, arg in opts:
if opt in ['-f', '--first_name']:
first_name = arg
elif opt in ['-1', '—last_name']:
last_name = arg
Учебно пособие по ОП, ас. д-р инж. Ивайло Симеонов Ченчев
145
23.3.	Модул argparse
Използването на модул argparse е по-добрата опция, защото предлага
много варианти като позиционни аргументи, стойности по подразбиране на
аргументите, помощни съобщения, типове на аргументите и т.н.
Забележка: Като незадължителен аргумент по подразбиране той
включва -h, заедно с неговата дълга версия -help.
https://docs.python.Org/3/library/argparse.html
24.	Допълнителна информация
24.1.	Кодиране и кодови таблици
Unicode е спецификация, която има за цел да изброи всеки знак,
използван от човешките езици, и да даде на всеки знак свой собствен уникален
код.
https://www.unicode.org/
https://www.unicode.Org/versions/Unicodel5.0.0/
https://docs.python.Org/3/howto/unicode.html
Диапазон от символи: \OxOOOO - \OxlOFFFF
(0-1114 111 символа)
Текущата версия (15.0) определя 149 186 символа.
Обхваща 161 скрипта (колекции от букви), символи, емоджита (emojis),
специални символи, символи за форматиране:
https://unicode.Org/versions/Unicodel5.0.0/
Целият диапазон е разделен на блокове - Unicode блокове.
2	4.1.1. Формат UTF-8
Съкращението UTF-8 означава - Unicode Transformation Format, а цифрата
8 определя 8-битови стойности за кодиранията - обикновено е 1 байт - заради
най-често използваните символи - за съвместимост с ACII кодовата таблица.
Учебно пособие по ОП, ас. д-р инж. Ивайло Симеонов Ченчев
146
UTF-8 e предпочитаното кодиране при HTML
Най-често срещаното кодиране на данни във World Wide Web (WWW)
Илла и други форллати на кодиране: UTF-16, UTF-32.
Наприллер в кодовата таблица UTF-8, английската буква А („А" голялло) се
кодира по следния начин:
'А': 41(16) -> ' \х4Г -> 65(ю) -> 65
Шестнадесетичния код е 41, а в десетична бройна систелла е 65.
UTF-8																
	0	1	2	3	4	5	6	7	8	9	A	в	c	D	E	F
Ох	:nul:	рой	ртх;	:етх:	рот	pNQ!	ACK	BEU	₽s:	•нт	g	ivr	:ff	СЙ	pO	pi:
1х	pLE!	pci:	pea	рсз:	рС4	:nak;	:syn:	ртв:	:can:	рм:	:sub:	psc	ps:	рй	pS	рй
2х	;SP;	!	w	#	$	%	&	t	(	)	*	+		-	•	/
Зх	0	1	2	3	4	5	6	7	8	9	•		<	=	>	?
4х	@	А	в	с	D	E	F	G	H	I	J	к	L	M	N	0
5х	р	Q	R	S	Т	U	V	W	X	Y	z	[	\	]	A	—
6х	X	а	b	с	d	e	f	g	h	i	j	k	1	m	n	0
7х	р	q	Г	S	t	u	V	w	X	У	z	{	1	}		PEU
1 I	I
Таблица 8: UTF-8 кодова таблица*
* Източник: https://en.wikipedia.org/wiki/UTF-8
Кодирането по подразбиране (default) в Python сорс-кода е UTF-8.
Python 3 също поддържа използването на Unicode силлволи в идентификаторите:
»> гёрег = "/var/log/events.log"
»> земно_ускорение = 9.81
»> print(Земно_ускорение)
9.81
»> ЯЕ = 2.8935
»> print (5Е)
Учебно пособие по ОП, ас. д-р инж. Ивайло Симеонов Ченчев
147
2.8935
Преминаването от символ към Unicode код става с помощта на двете
функции ord() и chr():
•	Функцията ord(c)
»> ord (' А' )
65
»> ord (' а' )
97
•	Функцията chr(i)
»> chr(65)
'А'
»> chr(66)
'В'
Пример за използване на емоджи символ в Python:
Unicode "U+1F600" -> е емоджи символа ©
»> chr(0xlF600)
# Ох - шестнадесетично
»> a=ord (' ^? ’)
»> print (а)
128512
»> print (hex (а) )
0xlf600
24.2.	Вградена променлива____________name__
В Python няма main() функция.
Как може да се провери дали кода е стартиран като самостоятелен скрипт
или като модул?
-> с помощта на вградената променлива_name_- съдържа името на
текущия модул
if ___name == ”_____main___" :
print ("The file is being run directly.")
else:
Учебно пособие по ОП, ос. д-р инж. Ивойло Симеонов Ченчев
148
print ("The file is being imported.")
Пример 1:
Scriptl.py:
print ("Scriptl ___name = ", ____name )
if __name == "_____main__" :
print ("The Scriptl is being run directly.")
else:
print ("The Scriptl is being imported.")
Scriptl __name = _____main__
The Scriptl is being run directly.
Пример 2:
Script2.py:
import Scriptl
print ("Script2 ___name = ", ____name )
if __name == "_____main__" :
print ("The Script2 is being run directly.")
else:
print ("The Script2 is being imported.")
Scriptl  name	= Scriptl
Scriptl is being imported
Script2  name	=  main 
Script2 is being run directly
24.3.	Форматиране на стринг
Пример 1 - без форматиране на стринга:
first_name = "Ivan"
print("Hello {}, hope you're well!")
Hello {}, hope you're well!
Пример 2 - форматиране с използване на една стойност:
first_name = "Ivan"
Учебно пособие по ОП, ас. д-р инж. Ивайло Симеонов Ченчев
149
print("Hello	{},	hope	you're
well!".format(first_name))
Hello Ivan, hope you're well!
Пример 3 - с използване на множество стойности:
first_name = "Ivan"
last_name = "Ivanov"
hello_str = "Hello {} {}, hope you're well!"
print(hello_str.format(first_name,last_name))
Hello Ivan Ivanov, hope you're well!
Пример 4 - с използване на множество стойности:
quantity = 3
itemno = 567
price = 49
myorder = "I want {} pieces of item number {} for
{:.2f} dollars."
print(myorder.format(quantity, itemno, price))
I want 3 pieces of item number 567 for 49.00
dollars.
Пример 5 - с използване на индексни номера:
quantity = 3
itemno = 567
price = 49
myorder = "I want {0} pieces of item number {1}
for {2:.2f} dollars."
print(myorder.format(quantity, itemno, price))
#0,	1,	2
I want 3 pieces of item number 567 for 49.00
dollars.
Пример 6 - с използване на именувани индексни:
myorder = "I want {quantity} pieces of item number
{item} for {price:.2f} dollars."
Учебно пособие по ОП, ас. д-р инж. Ивайло Симеонов Ченчев
150
print(myorder.format(price=45.95, quantity=5,
item=892))
I want 5 pieces of item number 892 for 45.95
dollars.
Чрез използване на f-string - по-добър, по-четлив и кратък начин за
форматиране на низове:
first_name = "Ivan"
print(f"Hello, {first_name}!")
Hello, Ivan!
first_name = "Ivan"
last_name = "Ivanov"
print(f"Hello, {first_name} {last_name}!")
Hello, Ivan Ivanov!
24.4.	Работа с дати
В Python няма тип данни Дата.
Трябва да се импортира модул с име datetime, за да се работи с дати като
обекти за дата.
import datetime
х = datetime.datetime.now()
print(x)
2022-11-21 23:14:10.264986
# year, month, day, hour, minute, second, and
microsecond
Модулът datetime има множество методи, конто връщат информация за
обекта date.
Създаване на datetime обект:
За да се създаде дата, използвайте клас конструктора datetime() от
модула datetime.
import datetime
х = datetime.datetime(2020, 5, 24)
print(x)
2020-05-24 00:00:00
Учебно пособие по ОП, ас. д-р инж. Ивайло Симеонов Ченчев
151
Методът datetime() може също така да приема параметри за време и
времева-зона (hour, minute, second, microsecond, tzone), но те са опционални и
имат 0 като стойност по подразбиране, (None за времевата зона - timezone).
Методът strftime():
Обектът datetime има метод за форматиране на обект дата като четими
стрингове.
import datetime
х = datetime.datetime(2020, 8, 6)
print(x.strftime("%B") )
August
24.5.	Регулярни изрази
Регулярният израз (на англ. ез. regular expression или накратко: regex или
regexp; понякога се нарича рационално изразяване) е последователност от
символи, конто определят модели за търсене в текст, (wiki pages)
Обикновено такива модели се използват в алгоритмите за търсене на
стринг при действията „търсене" или „търсене и заместване", или при
валидиране въвеждането на данни.
Регулярните изрази може да бъдат използвани за да се провери дали
стринг съдържа определен модел (последователност от символи).
Python има вграден модул с име ге, който се използва при работа с
регулярни изрази.
»> import re
»> stext = ’’Му name is Python. Nice to meet you.’’
»> res = re. search (’’ice” , stext)
Метасимволи - символи със специално значение
[]	- Множество от символи
"[p-z]"
Учебно пособие по ОП, ас. д-р инж. Ивайло Симеонов Ченчев
152
\	- задава символ с специално действие (може да бъде
използван за "escape''-ване (промяна на значението) на
символи)
11^ II
.	- Всеки символ (с изключение на символа за нов ред)
"fo..ow" ( follow, forrow, foABow, foxYow,...)
л	-започвас
"лМу name"
$	-завършвас
"Му name is lvaylo\.$"
*	- нула или повече срещания
"fol*ow" (foow, folow, follow, folllow,...)
+	- едно или повече срещания
"fol+ow" ( folow, follow, folllow, follllow,....)
?	- нула или едно срещания
"follo?w" ( follw, follow )
{}	- определен брой срещания
"fol{2}ow"
"fol{0,2}ow"	- foow, folow, follow
I	- или
"start | begin"
()	- хващане и групиране (capture and group)
Специални последователности - това e символа \ (обратна наклонена
черта) следван от определен символ и по този начин се получава специално
значение:
\d	- връща съвпадение, когато стринга съдържа цифри (0-9)
\D	- връща съвпадение, когато стринга НЕ СЪДЪРЖА цифри
\s	- връща съвпадение, когато стринга съдържа (интервал,
табулация) -> „white space character"
\S - връща съвпадение, когато стринга НЕ СЪДЪРЖА „white space
character"
\w - връща съвпадение, когато стринга съдържа всякакви
символи
от: a-z, A-Z, 0-9, и символа "порчертавка" (underscore) _
Учебно пособие по ОП, ас. д-р инж. Ивайло Симеонов Ченчев
153
\w
# това са т.нар. word символи
- връща съвпадение, когато стринга НЕ съдържа „word"
символи
\Ь
\B
- указва граница на дума в стринг
Моделът r'\bword\b' използва \Ь за да укаже, че се търси
съвпадение на цялата дума word
identity, Polaroid,
r'\bid*
r'id\b*
r'\bpolaroid\b'
- указва HE граница на дума в стринг
"IAM - Identity and Access Management"
r'\Bdent'
"My polaroid glasses."
r'polar\B'
"My polaroid glasses."
r'\Bola\B'
Python необработен стринг
»> normal_str = 'Hi\nHello'
»> print (normal_str)
Hi
Hello
raw_str = r'Hi\nHello'	# prefix r or R
print(raw_str)
Hi\nHello
Учебно пособие по ОП, ас. д-р инж. Ивайло Симеонов Ченчев
154
Множества (set) - това са изброени символи, заградени с квадратни
скоби [] :
[abc] - връща съвпадение, когато един от указаните символи (а, Ь,
или с) е наличен
[a-z]	-	връща	съвпадение	за всеки	символ малка буква от а до z
[лаЬс]	- връща съвпадение	за всеки	символ с изключение на а, Ь, и с
[0123]	-	връща	съвпадение	за всяка	цифра от изброените (0,1, 2, или
3)
[0-9]	- връща съвпадение за всяка цифра от изброените (от 0 до 9)
[0-5][0-9] - връща съвпадение за всеки двойка цифри в интервала от 00
ДО 59
[+]	- връща съвпадение за всеки символ + от стринга.
Символите +, *,	|, (), $, {} нямат специално значение, когато са
използвани в множества.
Функции от модула ге:
findall() - връща списък, съдържащ всички съвпадения
search() - връща обект Match, ако има съвпадение някъде в стринга
split() - връща списък с елементи, където стринга е бил разделен на
всяко съвпадение
sub() - заменя едно или много съвпадения със стринг
Функция findall():
Синтаксис:
re .fi nda 11 (pattern, string, flags=O)
pattern - регулярен израз, за който ще се търси съвпадение
string - входния стринг
flag - флагове, конто променят поведението на търсене:
re.IGNORECASE, re.DOTALL,...
Връща всички неприпокриващи се съвпадения на шаблон в стринга като
списък от стрингове или tuples. Стрингът се сканира отляво надясно и
съвпаденията се връщат в намерения ред. Празните съвпадения се включват в
резултата.
Учебно пособие по ОП, ас. д-р инж. Ивайло Симеонов Ченчев
155
Ако няма групп (съвпадения между фигурни () скоби) - връща списък от
стрингове, конто съвпадат с целия модел.
Ако е използвана точно една трупа - връща списък от стрингове, конто
съвпадат с групата.
Ако са използвани много групп - връща списък от tuples, от стрингове,
конто съвпадат с групите.
Пример 1 - получаване на списък със съвпадащи стрингове
import re
my_str = "black, blue and brown"
pattern = r'bl\w+'
matches = re.findall(pattern, my_str)
print(matches)
['black', 'blue']
#	връща списък от съвпадения
Пример 2 - модел, конто има една трупа
import re
my_str = "black, blue and brown"
pattern = r'bl(\w+)'	# () -> трупа
matches = re.findall(pattern, my_str)
print(matches)
['ack', 'ue']
#	връща списък от съвпадения в групата
Пример 3 - модел, конто има много групп
import re
my_str = "black, blue and brown"
pattern = r'(bl(\w+))'
matches = re.findall(pattern, my_str)
print(matches)
[('black', 'ack'), ('blue', 'ue')]
Учебно пособие по ОП, ас. д-р инж. Ивайло Симеонов Ченчев
156
#	връща списък от tuples (всички групп)
Пример 4 - модел, който има много групи (друг вариант)
import re
my_str = "black, blue and brown"
pattern = r'(bl(\w))([ce]\w*)'
matches = re.findall(pattern, my_str)
print(matches)
[('bla', 'a', 'ck'), ('blu', 'u', 'e')l
#	връща списък от tuples (всички групи)
Пример 5 - използване на флаг
import re
my_str = "Black, BLUE and brown"
pattern = r'(bl(\w+))'
matches = re.findall(pattern, my_str,
re.IGNORECASE)
print(matches)
[('Black', 'ack'), ('BLUE', 'UE')]
#	игнорира главни букви
Функция search():
Синтаксис:
re.search(pattern, string, flags=O)
pattern string flag	-	регулярен израз, за който ще се търси съвпадение -	входния стринг -	флагове, конто променят поведението на търсене: re.IGNORECASE, re.DOTALL,...
Функцията search() сканира стринга от ляво надясно и търси първото
място, където има съвпадение с модела. Връща обект Match, ако търсенето е
било успешно, иначе връща None.
Учебно пособие по ОП, ас. д-р инж. Ивайло Симеонов Ченчев
157
Пример 1 - намиране на първото съвпадение
import re
my_str = 'Python 3 was released on Dec 3, 2008'
pattern = '\d+'
match = re.search(pattern, my_str)
if match:	# if match is not None:
print(match.group())
else:
print('No match found')
3
Пример 2 - намиране на първата дума, която съвпада с модела
import re
my_str = 'Python or python'
pattern = r'\bpython\b'
match = re.search(pattern, my_str)
print(match.group())
python
Пример 3 - намиране на първата дума, която съвпада с модела,
използване на групп
import re
my_str = 'CPython, IronPython, or Cython'
pattern = r'\b((\w+)thon)\b'
match = re.search(pattern, my_str)
if match is not None:
print(match.groups())
else:
print('No match found')
('CPython', 'CPy')
#	Match.groups() - връща tuple
print(match.groups()[0])
CPython
Учебно пособие по ОП, ас. д-р инж. Ивайло Симеонов Ченчев
158
Пример 4 - намиране на първата дума, която съвпада с модела,
използване на флаг
import re
my_str = 'Python or python'
pattern = r'\bpython\b'
match = re.search(pattern, my_str, re.IGNORECASE)
print(match.group())
Python
Функция split():
Синтаксис:
re.search(pattern, string, maxsplit=O, flags=O)
Pattern - регулярен израз, чиито съвпадения се използват като
разделители при разделянето
string - входния стринг
maxsplit - ако maxsplit=l - резултатния списък ще има два
елемента.
Ако maxsplit=2 - резултатния списък ще има три
елемента и т.н.
flag
- флагове, конто променят поведението на търсене:
re.IGNORECASE, re.DOTALL,...
Функцията search() проверява стринг от ляво надясно и търси първото
място, където има съвпадение. Ако е намерено съвпадение - връща обект
Match, иначе връща None.
Пример 1 - за разделяне на думи в изречение
import re
my_str = 'А! В. CD'
pattern = г'\W+'
spl = re.split(pattern, my_str)
print(spl)
Учебно пособие по ОП, ас. д-р инж. Ивайло Симеонов Ченчев
159
['A', 'В', 'C, *D’]
Пример 2 - с използване на аргумента maxs
import re
my_str = 'А! В. C D E.. F'
pattern = r'\W+ '
spl = re.split(pattern, my_str, 0)
print(spl)
['А', 'В', 'C, 'D', 'E', 'F']
spl = re.split(pattern, my_str, 1)
print(spl)
['A', 'В. C D E.. F']
spl = re.split(pattern, my_str, 2)
print(spl)
[ 'A' , 'В' , 'C D E. . F']
Пример 3 - с използване на трупа
import re
my_str = 'А! В. C D E.. F'
pattern = r'(\W+)'
spl = re.split(pattern, my_str, 2)
print(spl)
[ 'A' , ' ! ', 'B', ' . ', 'C D E. . F']
#	в резултатния списък връща също и текста от
групата
Пример 4 - с използване на трупа (друго използване)
import re
my_str = 'А! В. С D Е.. F'
pattern = г'(\W+)'
spl = re.split(pattern, my_str, 0)
print(spl)
[ 'A' , ' ! ' , 'B' , ' . ' , 'C , ' ' , 'D' , ' ' , 'E' ,
'.. ', 'F']
#	в резултатния списък връща също и текста от
групата
Учебно пособие по ОП, ас. д-р инж. Ивайло Симеонов Ченчев
160
Пример 5 - разделителя! съвпада с началото на стринга:
import re
my_str = '...А! В. CD'
pattern = г'\W+ '
spl = re.split(pattern, my_str)
print(spl)
[' ' , 'A' , 'В' , 'C , 'D' ]
Пример 6 - разделителят съвпада с края на стринга:
import re
my_str = 'А! В. CD...'
pattern = г'\W+'
spl = re.split(pattern, my_str)
print(spl)
[ 'A' , 'В' , 'C , 'D' , ' ' ]
Функция sub():
Синтаксис:
re.sub(pattern, repl, string, count=0, flags=O)
pattern - регулярен израз, по който ще търсим съвпадение
repl - стринга, с който ще се направи замяната
string - входния стринг
count - максималния брой съвпадения, конто функцията sub()
ще замени. При 0 - всички съвпадения биват заместени.
flag - флагове, конто променят поведението на търсене:
re.IGNORECASE, re.DOTALL,...
Функцията връща списък, който съдържа всички съвпадения.
Пример 1 - при телефонен номер - връщане само на числа:
phone_no = '(359)-88-4567-890'
pattern = '\D'	# \D - нечислов символ
result = re.sub(pattern, '',phone_no)
print(result)
359884567890
Учебно пособие по ОП, ас. д-р инж. Ивайло Симеонов Ченчев
161
25. Задачи за самоподготовка
Задача 1: Създайте два обекта - tuple и slice. Задайте начало на slice обекта от
позиция 3 до позиция 5 и върнете резултата.
Решение на Задача 1:
а = ("а", "Ь", "с", "d", "е", "f", "g")
х = slice(3, 5)
print(a[x])
('d', 'e')
Задача 2: Да се направи програма на Python, която да отпечатва на екрана
следния триъгълник от звездички:
*
* *
* * *
* * * *
Решение на Задача 2:
rows = 5
# outer loop
for i in range(1, rows + 1):
# inner loop
for j in range(1, i + 1):
print	end=" ")
print(' ')
По подразбиране, функцията print() завършва с нов ред.
Функцията print() може да завършва с друг символ - да се използва
параметъра 'end='
Задача 3: Да се разменят местата на колоните и редовете в двумерен масив (в
мат. - транспониране на матрица)
Учебно пособие по ОП, ас. д-р инж. Ивайло Симеонов Ченчев
162
2 4 19
2 3 4 5
3 9 5 6
7 5 6 8
AT
2 2 3 7
4 3 9 5
14 5 6
9 5 6 8
Решение 1 на Задача 3:
Работи за текущата задача, но по принцип не е толкова приложимо.
а= [[2,2,3,7], [4,3,9,5], [1,4,5,б], [9,5,б,8]]
Ь = [[] , [1 , [] , []]
for i in range(4):
for j in range(4):
b[i].append(a[j][i])
print(b)
[[2, 4, 1, 9], [2, 3, 4, 5], [3, 9, 5, 6], [7, 5,
6, 8Ц
Решение 2 на Задача 3:
a= [[2,2,3,7], [4,3,9,5], [1,4,5,б], [9,5,б,8]]
at = []
for i in range(4):
one_row = []
for j in range(4):
one_row.append(a[j][i])
at.append(one_row)
print(at)
[[2, 4, 1, 9], [2, 3, 4, 5], [3, 9, 5, 6], [7, 5,
б, 8Ц
Решение 3 на Задача 3:
a= [[2,2,3,7], [4,3,9,51, [1,4,5,б], [9,5,б,8]]
at = []
one_row = [1
Учебно пособие по ОП, ос. д-р инж. Ивойло Симеонов Ченчев
163
for i in range(4):
for j in range(4):
one_row.append(a[j][i])
at.append(one_row.copy())
one_row.clear()
print(at)
[[2, 4, 1, 9], [2, 3, 4, 5], [3, 9, 5, 6], [7, 5,
6, 8]]
Задача 4: По колко начина може да се разпечата цял стринг, чрез използване на
slicing?
svar= "ABCDEFGH"
Решение на Задача 4:
1)	print(svar[:])
2)	print(svar[::])
3)	print(svar[::1])
4)	print(svar[0:])
5)	print(svar[0::])
6)	print(svar[0::1])
7)	print(svar[:len(svar)])
8)	print(svar[:len(svar)]:)
9)	print(svar[:len(svar)]:1)
10)	print(svar[0:len(svar)])
11)	print(svar[0:len(svar):])
12)	print(svar[0:len(svar):1])
Задача 5: Напишете функция за изчисление на мат. функция факториел (без
рекурсия)?
п! = п.(п-1)...3.2.1,
0!=1
Решение на Задача 5:
def factoriel_with_loop(х):
result = 1
factor = 2
while factor <= x:
result *= factor
Учебно пособие по ОП, ас. д-р инж. Ивайло Симеонов Ченчев
164
factor += 1
return result
print(factoriel_with_loop(10))
3628800
Задача 6: На всеки ред във файл е записано едно произволно цяло число в
интервала [0; 10000]. Създайте нов файл като пред всяко число добавите нули,
така, че дължината на получената последователност да е = на броя на цифрите
на най-голямото число от файла.
Пример:
input_data.txt
2
34
1
987
123
9
-> result_data.txt
-	> 002
-	> 034
-	> 001
-	> 987
-	> 123
-	> 009
Помощ:
1) едно прочитане на целия файл -> макс, дължина на число
1.1) позициониране в началото
2) отваряне на нов файл
четене от input файла
запис в output файла
str.zfill()
Задача 7: Да се напише функция на Python, която връща име на файл със
следната конвенция на името:
I ogf i I e-YYYY- М M - D D- h h m m ss-ff. I og
Решение на Задача 7:
import datetime as dt
def logfile_name(preffix):
ct = dt.datetime.now()
local_time = ct. strftime ("%Y-%m-%d--%H%M%S-%f’’)
Учебно пособие по ОП, ас. д-р инж. Ивайло Симеонов Ченчев
165
return (pref fix + local_time + ’’.log")
Задача 8: Да се напише функция на Python, която записва данни в лог-файл при
следния формат на ред:
YYYY-MM-DD hh:mm:ss.ff | <data>
Примерен ред от файла:
2022-11-22 00:14:33.215813 | Sample text
Решение на Задача 8:
def logdata(fi, s):
ct = dt.datetime.now()
fi.write(ct.strftime("%Y-%m-%d %H:%M:%S.%f”) +
" | " + s + "\n")
logdata(fp, "some text")
Задача 9: Превръщане на градуси в радиани
Да се напише функция на Python, която приема един параметър - число. Този
параметър представлява измерен ъгъл в градуси. Функцията трябва да превърне
градусите в радиани и да върне стойността.
Да се работи с до пет цифри след десетичната запетая.
Hint:
360 degrees = 2тт radians
тт = 3.14159
ftaskl401(19)	->0.33155
Задача 10: Превръщане на градуси в градиани
Да се напише функция на Python, която приема един параметър - число. Този
параметър представлява измерен ъгъл в градуси. Функцията трябва да превърне
градусите в градиани и да върне стойността.
Да се работи с до пет цифри след десетичната запетая.
Hint:
90 degrees = 100 gradians
ftaskl402(19)	->2.11111
Задача 11: Превръщане на радиани в градиани
Учебно пособие по ОП, ас. д-р инж. Ивайло Симеонов Ченчев
166
Да се напише функция на Python, която приема един параметър - число. Този
параметър представлява измерен ъгъл в радиани. Функцията трябва да
превърне градусите в градиани и да върне стойността.
Да се работи с до пет цифри след десетичната запетая.
Hint:
400 gradians = 2п radians
тт = 3.14159
ftaskl403(19)	->0.29849
Задача 12: Да се преброят гласните звуци в стринг
Да се напише функция на Python, която приема един входен параметър - стринг.
01) Да се намери общия брой гласни звуци
02) Да се намери броя на срещанията на всеки гласен звук поотделно
Hint:
vowels: а, е, i, о, и,
ftaskl404("Hello World") -> 01: Total vowels: 3
-> 02: a(0), e(l), i(0), o(2), u(0)
Задача 13: Да се превърне десетично число в двоично
Да се напише функция на Python, която приема един параметър- цяло число в
интервала [0;255]. Да се превърне числото в двоичен формат.
Hint:
ftaskl405( 0)	->	0000 0000
ftaskl405( 192)	->	1100 0000
Задача 14: Мин., макс, и avg
Да се напише функция на Python, която намира минималното, максималното и
средно-аритметичното (по абсолютна стойност) число от зададен списък
съдържащ само цели числа.
Hint:
ftaskl406( [0, 9, -3, 243, 11, -100] )
-	>	min.: -100
-	>	max.: 243
-	> avg.: 61
Задача 15: Минимално число във всеки ред от текстов файл
Учебно пособие по ОП, ас. д-р инж. Ивайло Симеонов Ченчев
167
Да се напише функция на Python, която приема един параметър - пътя и името
до текстов файл. В този файл на всеки ред има записани числа, разделени с поне
един интервал. Функцията да връща списък с всички минимални числа по
редове.
9 2 89 56 6
1
43 19
Hint:
ftaskl407( "./input_data.txt")
-	>	[2,1,19]
Задача 16: Премахване на празни редове от файл
Да се напише функция на Python, която приема два параметъра - пътя и името
до входен текстов файл, пътя и името до резултатния файл.
Във входния файл има и празни редове (с интервали, с табулации, само символ
за нов ред).
Във входния файл има и редове, в конто първия значещ символ е #.
Да се прехвърли съдържанието от входния файл в резултатния файл, но без
празните редове и без редовете с коментари.
# comment line
## 9 2 89 56 6
# 1
sys.logjevel = info
Задача 17: Преброяване на символи, думи и редове
Да се напише функция на Python, която приема един параметър - пътя и името
до входен текстов файл.
Да се преброят и отпечатат всички символи, думи и редове във формат:
редове думи символи
input_data.ру:
Му name is Python.
Your name is Python.
His name is Python.
Hint:
ftaskl409( "./input_data.txt")
-> 3 12	60
Учебно пособие по ОП, ас. д-р инж. Ивайло Симеонов Ченчев
168
Задача 18: Преброяване на символи, думи и редове - параметри
Да се напише програма на Python, която приема два параметъра:
paraml: -с | -w | -I	#characters, words, lines
pa га m2 - пътя и името до входе н текстов файл.
Да се преброят символи, думи и редове.
Изход -> да се отпечатат: редове думи символи
input_data.py:
Му name is Python.
Your name is Python.
His name is Python.
Hint:
ftaskl410( "./input_data.txt")
-> 3 12	60
26. Речник
Речник на използваните английски думи и ИТ терминология.
Английски език	Български език
Access	Достъп
Comprehension	Обхващане
Lifecycle	Цикъл на живот
Memory	Памет
Nested Loop	Вложен цикъл
Programming Language	Език за програмиране
Random	Случаен
Research	Изследване
Time complexity	Времева сложност
Учебно пособие по ОП, ас. д-р инж. Ивайло Симеонов Ченчев
169
Т1. Използвани сокращения
Съкращение	Описание (български ез./англ. Ез.)
ИТ	Информационни Технологии
AMD	Advanced Micro Devices
ARM	Advanced RISC Machine
CISC	Complex Instruction Set Computer
CPU	Central Processing Unit
DevOps	Development and Operations
GPR	General Purpose Register (Регистьр с общо предназначение)
HP	Hewlett-Packard
IA-32	Intel Architecture, 32-bit
IBM	International Business Machines
IDE	Integrated Development Environment
Intel MCS	Intel Micro-Control System
LSB	Least Significant Byte
MSB	Most Significant Byte
PA-RISC	Precision Architecture RISC (developed by HP)
PEP	Python Enhancement Proposals
RAM	Random Access Memory
PC	Personal Computer
RS/6000	RISC System/6000 (by IBM)
RISC	Reduced Instruction Set Computer
UTF	Unicode Transformation Format
VLIW	Very Long Instruction Word
28. Литература
[1]	Andrew D. Ferguson, A History of Computer Programming Languages,
Web-страница: https://cs.brown.edu/~adf/programming languages.html
Последно достъпвана: 27.04.2023
[2]	Официална Web-страница на Python
Учебно пособие по ОП, ас. д-р инж. Ивайло Симеонов Ченчев
170
https://www.python.org/
Последно достъпвана: 03.05.2023
[3]	Fabrizio Romano, Benjamin Вака, Dusty Phillips, Getting Started with Python,
Packt Publishing, 2019, ISBN 978-1-83855-191-9
Учебно пособие по ОП, ас. д-р инж. Ивайло Симеонов Ченчев
171
Учебно пособие по
ОСНОВИ НА ПРОГРАМИРАНЕТО
(лекции и упражнения по Python)
Автор:
Рецензент:
ас. д-р инж. Ивайло Симеонов Ченчев
доц. д-р Егнар Иоздикилилер
Народност българска
Първо издание
Формат: електронен, pdf
ISBN: 978-619-238-228-5
Издателство АТ ЛАСИ ®
София 1000, ул. Иван Вазов 12, ет. 3
https://atlasi.bg/
Учебно пособие по ОП, ас. д-р инж. Ивайло Симеонов Ченчев
172