AYaPT 2209АЛГОРИТМИЧЕСКИЕ ЯЗЫКИ
ПРОГРАММИРОВАНИЯ В ТЕЛЕКОММУНИКАЦИЯХ Конспект лекций по дисциплине для специальности
6В06201 – «Радиотехника, электроника и телекоммуникации» (бакалавриат)
Алматы 2022
Некоммерческое акционерное общество
АЛМАТИНСКИЙ УНИВЕРСИТЕТ ЭНЕРГЕТИКИ И СВЯЗИ ИМЕНИ ГУМАРБЕКА ДАУКЕЕВА
Кафедра
Телекоммуникаций и иннофационных
2
СОСТАВИТЕЛИ: PhD, доцент Қадылбекқызы Эльвира, ст.
преподаватель Касымова Г.К., преподаватель Шенер А. Алгоритмические языки программирования в телекоммуникациях Конспект лекций для студентов специальности 6В06201 – «Радиотехника, электроника и телекоммуникации». – Алматы: АУЭС, 2022 – 65 с.
В конспекте лекций рассматриваются теоретические основы современных технологий и методов программирования, практические вопросы создания программ, а также основные алгоритмические конструкции и их реализация на языке высокого уровня Python. Рассмотрение теоретических основ программирования сопровождается примерами, иллюстрирующими приемы создания программ, а также заданиями для самостоятельного выполнения, позволяющими сформировать у студентов практические навыки программирования.
Рецензент: Тусупова Б.Б.
Печатается по плану издания некоммерческого акционерного общества
«Алматинский университет энергетики и связи имени Г. Даукеева» на 2022 г.
© НАО «Алматинский университет энергетики и связи имени Гумарбека Даукеева», 2022 г.
3
Введение
Конспект лекций посвящен изучению алгоритмического языка программирования Python по дисциплине «Алгоритмические языки программирования в телекоммуникациях» (15 час.) для бакалавров первого курса для специальности 6В06201 – «Радиотехника, электроника и телекоммуникации»
В конспекте лекций рассматриваются теоретические основы современных технологий и методов программирования, практические вопросы создания программ, а также основные алгоритмические конструкции и их реализация на языке высокого уровня Python. Рассмотрение теоретических основ программирования сопровождается примерами, иллюстрирующими приемы создания программ, а также заданиями для самостоятельного выполнения, позволяющими сформировать у студентов практические навыки программирования.
В результате изучения материалов пособия обущающиеся должны:
Знать:
- структуру программы,
- основные типы данных и их особенности, - стандартные модули языка.
Уметь:
- выполнять стандартные операции над данными различного типа,
- применять стандартные алгоритмические структуры для обработки данных.
Владеть:
- принципами объектно-ориентированного подхода при составлении программ,
- спецификой работы с переменными различных типов данных.
4
Лекция1. Основные понятия алгоритмизации
Алгоритм – это точный рецепт, предписание, определяющее логический и вычислительный процесс, ведущий от варьируемых начальных данных к искомому результату.
Процессы управления не только компьютерами, но всеми другими техническими устройствами и системами сводятся к реализации определенных
алгоритмов, что показывает принадлежность алгоритмизации и понятия алгоритма к их родовой дисциплине – кибернетике.
Свойства алгоритма
1. Детерминированность – точность указаний, исключающая их произвольное толкование.
2. Дискретность – возможность расчленения вычислительного процесса на отдельные элементарные операции, возможность выполнения которых не вызывает сомнений.
5
3. Результативность – прекращение процесса через определенное число шагов с выдачей искомых результатов или сообщения о невозможности продолжения вычислительного процесса.
4. Массовость – пригодность алгоритма для решения всех задач заданного класса.
Процесс алгоритмизации переходит общего к частному, используя сначала общую форму – алгоритмический язык, завершается в форме языка программирования, понятного компьютеру, который будет исполнять запланированные действия в виде компьютерной программы.
Алгоритмический язык – набор символов и правил образования и истолкования конструкций их этих символов для записи алгоритмов.
Язык программирования – формальная знаковая система, предназначенная для записи компьютерных программ. Язык программирования определяет набор лексических, синтаксических и семантических правил, определяющих внешний вид программы и действия, которые выполнит исполнитель (обычно — ЭВМ) под её управлением.
Компьютерный язык – понятие, близкое к языку программирования, но ориентированное не на человека, а на компьютер, предназначен для реализации программ на ЭВМ. Фактически, компьютерный язык – это протокол, правила обмена информацией человека с компьютером и компьютера с компьютером, компьютерной программы с другой компьютерной программой.
Компьютерная программа — это алгоритм, записанный в форме, воспринимаемой машиной. Программа содержит наряду с описанием данных команды, в какой последовательности, над какими данными и какие операции должна выполнять машина, а также в какой форме следует получить результат.
Это обеспечивают различные операторы.
Оператор – одно простое выражение компьютерного языка, представляющее указание на определенное действие программы, обычно, выполнить что-то.
Данная дисциплина предназначена для того, чтобы студент овладел основными знаниями и навыками программирования компьютеров – электронных вычислительных машин (ЭВМ). Основой программирования являются процесс алгоритмизации и владение языками программирования ЭВМ.
В развитии инструментального программного обеспечения рассматривают пять поколений языков программирования (ЯП).
1. Машинные: ориентированые, сложные в освоении, требуют хорошего знания архитектуры ЭВМ.
2. Ассемблер, Макроассемблер – тоже машинно-зависимы.
3. Языки высокого уровня: мобильные, человеко- ориентированные, более простые в освоении. В 1956 году был разработан язык Fortran под руководством Дж. Бэкуса в фирме IBM. За короткое время Fortran становится основным ЯП при решении инженерно-технических и научных задач.
6
Первоначально Fortran обладал весьма ограниченными средствами обеспечения работы с символьной информацией и с системой ввода-вывода.
4. Непроцедурные, объектноориентированные, языки запросов, параллельные ориентированы на непрофессионального пользователя и на ЭВМ с параллельной архитектурой. Широко известные языки: Algol, Cobol, Basic, PL/1, Pascal, APL, ADA, C, Forth, Lisp, Modula и др. В настоящее время насчитывается свыше 2000 различных языков высокого уровня.
5. Языки искусственного интеллекта, экспертных систем и баз знаний, естественные языки ориентированы на повышение интеллектуального уровня ЭВМ и интерфейса с языками. Языки искусственного интеллекта, экспертных систем, баз знаний (InterLisp, ExpertLisp, IQLisp, SAIL и др.), а также естественные языки, не требующие освоения какого-либо специального синтаксиса (в настоящее время успешно используются естественные ЯП с ограниченными возможностями — Clout, Q&A, HAL и др.).
Языки четвертого поколения носят ярко выраженный непроцедурный характер, определяемый тем, что программы на таких языках описывают только «что», а не «как» надо сделать. В программах формируются скорее соотношения, а не последовательности шагов выполнения алгоритмов.
Примерами непроцедурных языков являются языки, используемые для задач искусственного интеллекта (например, Prolog, Langin). Так как непроцедурные языки имеют минимальное число синтаксических правил, они значительно более пригодны для применения непрофессионалами в области программирования. Второй тенденцией развития ЯП четвертого поколения являются объектно-ориентированные языки, базирующиеся на понятии программного объекта, впервые использованного в языке Simula-67 и составившего впоследствии основу известного языка SmallTalk. Программный объект состоит из структур данных и алгоритмов, при этом каждый объект знает, как выполнять операции со своими собственными данными. На самом деле, различные объекты могут пользоваться совершенно разными алгоритмами при выполнении действий, определенных одним и тем же ключевым словом 3 (так называемое свойство полиморфизма). Например, объект с комплексными числами и массивами в качестве данных будет использовать различные алгоритмы для выполнения операции умножения.
Такими свойствами обладают объектно-ориентированные Pascal, Basic, С++, SmallTalk, Simula, Actor и ряд других языков программирования. Третьим направлением развития языков четвертого поколения можно считать языки запросов, позволяющих пользователю получать информацию из баз данных.
Языки запросов имеют свой особый синтаксис, который должен соблюдаться, как и в традиционных ЯП третьего поколения, но при этом проще в использовании. Среди языков запросов фактическим стандартом стал язык SQL (StructuredQueryLanguage). И, наконец, четвертым направлением развития являются языки параллельного программирования (модификация ЯВУ Fortran, языки Occam, SISAL, FP и др.), которые ориентированы на создание программного обеспечения для вычислительных средств параллельной
7
архитектуры (многомашинные, мультипроцессорные среды и др.), в отличие от языков третьего поколения, ориентированных на традиционную однопроцессорную архитектуру.
Элементы языков программирования
Элементы языков программирования могут рассматриваться на следующих уровнях: алфавит — совокупность символов, отображаемых на устройствах печати и экранах и/или вводимых с клавиатуры терминала;
лексика — совокупность правил образования цепочек символов (лексем), образующих идентификаторы (переменные и метки), операторы, операции и другие лексические компоненты языка. Сюда же включаются зарезервированные (запрещенные, ключевые) слова ЯП, предназначенные для обозначения операторов, встроенных функций и пр.;
синтаксис — совокупность правил образования языковых конструкций или предложений ЯП — блоков, процедур, составных операторов, условных операторов, операторов цикла и пр.
Объектно-ориентированное программирование (ООП)
Объектно-ориентированное программирование (ООП) — это метод программирования, при использовании которого главными элементами программ являются объекты. В языках программирования понятие объекта реализовано как совокупность свойств (структур данных, характерных для данного объекта), методов их обработки (подпрограмм изменения их свойств) и событий, на которые данный объект может реагировать, и которые приводят, как правило, к изменению свойств объекта. Объединение данных и свойственных им процедур обработки в одном объекте называется инкапсуляцией и является одним из важнейших принципов ООП.
Другим фундаментальным понятием является класс.
Класс – это шаблон, на основе которого может быть создан конкретный программный объект, он описывает свойства и методы, определяющие поведение объектов этого класса. Каждый конкретный объект, имеющий структуру этого класса, называется экземпляром класса.
Следующими важнейшими принципами ООП являются наследование и полиморфизм.
Наследование – предусматривает создание новых классов на базе существующих и позволяет классу – потомку иметь (наследовать) все свойства класса – родителя.
Полиморфизм – означает, что рожденные объекты обладают информацией о том, какие методы они должны использовать в зависимости от того, в каком месте цепочки они находятся.
Модульность – свойство программ, при котором объекты заключают в себе полное определение их характеристик, никакие определения методов и свойств не должны располагаться вне его; это делает возможным свободное копирование и внедрение одного объекта в другие.
8
Современными языками объектно-ориентированного программирования являются С++ и Java. К объектно-ориентированным системам визуального проектирования относятся Visual Basic, Delphi, C++ Builder, Visual C++. Язык VBA (Visual Basic for Applications) – язык приложений Microsoft Office (Excel, Word, Access, Power Point и др). VBA соблюдает основной синтаксис языка и правила программирования языков Basic – диалектов, позволяет создавать макросы для автоматизации выполнения некоторых операций и графический интерфейс пользователя, интеграцию между различными программными продуктами.
Лекция 2. Основные элементы языка. Переменные Основные типы:
char short int long float double Операции:
~ (дополнение)
& (И)
^ (исключающее ИЛИ)
| (включающее ИЛИ)
<< (логический сдвиг влево)
>> (логический сдвиг вправо)
Переменная в языке программирования – это название для зарезервированного места в памяти компьютера, предназначенного для хранения значений. Это означает, что, когда вы создаете переменную, вы на самом деле резервируете определенное место в памяти компьютера.
Основываясь на типе данных переменной, интерпретатор выделяет необходимое количество памяти и решает, что может находиться в зарезервированной области памяти. Можете думать о переменной, как о коробке, в которую можно положить любую вещь, но только определенного размера. Размер в данном примере будет типом переменной. Присвоение значения переменной: В Python вам не нужно объявлять тип переменной вручную, как, например, в С++. Объявление происходит автоматически, когда вы присваиваете значение переменной. Знак равенства ( = ) используется для присвоения значения переменной. Операнд по левую сторону от знака равно (
= ) – это имя переменной, операнд по правую сторону – значение присвоенное этой переменной.
Например:
country = "Klad" # Присвоить значение Klad переменной под названием country
age = 55 # Присвоение значения 55 переменной age print country
print age
При выполнении данный код выведет: Klad 55.
9
Множественное присвоение значений: В Pyth on возможно присваивать одно значение нескольким переменным сразу.
Например: a = b = c = 88
К стандартным типам данных относят:
- Числа (Numbers) - Строка (String) - Список (List) - Кортеж (Tuple) - Словарь (Dictionary) - Сет (Set)
Числовые объекты создаются, когда вы присваиваете им значение.
Например:
n1 = 23 n2 = 42
Также вы можете удалять числовой объект при помощи ключевого слова del.
del n1 # удаляет переменную n1
del n2, n3 # удаляет обе переменные n2, n3 за раз.
В Python есть четыре вида числового типа данных:
- int (целое число)
- long (длинное целое число [может быть представлено в восьмеричной или шестнадцатеричной системе исчисления])
- float (число с плавающей точкой: -0.2, 0.0, 3.14159265 и т.д.)
- complex (комплексное число). Примеры видов числового типа данных:
int long float complex 1 51924361L 0.0 3.14j 102 -0x19323L 15.20 45.j -786 0122L -21.9 9.322e-36j 0 0xDEFABCECBDAECBFBAEl 32.3+e18 .876j 0b10 535633629843L -90. -.6545+0J -0x260 -052318172735L -32.54e100 3e+26J 0x69 - 4721885298529L 70.2-E12 4.53e-7j
Лекция 3. Условный оператор if else в языке python
Простой пример (напечатает 'true', так как 1 – истина):
>>> if 1:
... print('true') ... else:
... print('false') ...
true
Сложный пример:
a = int(input())
10
if a < -5:
print('Low') elif -5 <= a <= 5:
print('Mid') else:
print('High')
Проверка истинности в Python Логические операторы:
X and Y
Истина, если оба значения X и Y истинны.
X or Y
Истина, если хотя бы одно из значений X или Y истинно.
not X
Истина, если X ложно.
Лекция 4. Оператор while в языке Python
While условие:
Инструкции.
Здесь:
• условие – условие выполнения строки (строк) инструкции;
• инструкции – один оператор или набор операторов, которые выполняются, если значение Условие=True. Если значение Условие становится равным False, то происходит завершение выполнения оператора цикла while.
Вычисление суммы элементов списка:
# сформировать список и инициализировать значениями переменные A=[1,3,5,8,-3,10]
i=0
summ=0 # искомая сумма
while i<len(A): # цикл вычисления суммы summ=summ+A[i]
i=i+1
print("summ = ", summ) # summ = 24 Оператор for в языке Python
for <variable> in <object>:
<statements1>
11
if <condition1>: break if <condition2>: continue else:
<statements2>
Здесь:
• variable – переменная цикла, которая поочередно принимает значение элементов из объекта object;
• object – некоторый список, кортеж, строка или другой объект, который содержит множество элементов для обхода;
• statements1 – один или несколько операторов (инструкций), которые выполняются для заданного значения variable;
• statements2 – один или несколько операторов (инструкций), которые выполняются в случае, если инструкция break не выполнилась ни разу в теле цикла for.
Оператор for может быть применен в сокращенной форме без использования блока else. В этом случае сокращенная форма оператора for имеет вид:
for <variable> in <object>:
<statements>
Здесь:
• variable – переменная цикла, которая поочередно принимает значение элементов из объекта object;
• statements – один или несколько операторов (инструкций), которые выполняются для заданного значения variable.
Пример вычисления суммы элементов списка:
# вычисление суммы элементов списка
# Заданный список
T = [2.8, 3.5, 4.9, 0.01, 2.34]
s=0 for t in T:
s = s + t
print("s = ", s) # s = 13.549999999999999
В результате выполнения вышеприведенного кода будет отображен следующий результат:
s = 13.549999999999999
Лекция 5. Строковые операторы в python
Оператор сложения строк + — оператор конкатенации строк.
Оператор умножения строк * s * n
12
n * s
Вот примеры умножения строк:
>>> s = 'py.'
>>> s * 4 'py.py.py.py.'
Оператор принадлежности подстроки in
Python также предоставляет оператор принадлежности, который можно использоваться для манипуляций со строками. Оператор in возвращает True, если подстрока входит в строку, и False, если нет:
>>> s = 'Python'
>>> s in 'I love Python.' True
>>> s in 'I love Java.' False
Python предоставляет множество функций, которые встроены в интерпретатор.
Функция Описание
chr() Преобразует целое число в символ ord() Преобразует символ в целое число len() Возвращает длину строки
str() Изменяет тип объекта на string
>>> ord('a') 97
>>> ord('#') 35
•
Функция ord() также возвращает числовые значения для символов Юникода:
>>> ord('€') 8364
>>> ord('∑') 8721
>>> chr(97) 'a'
chr() также обрабатывает символы Юникода:
>>> chr(8364) '€'
>>> chr(8721) '∑'
>>> s = 'Простоя строка.'
>>> len(s)
13
15
>>> str(49.2) '49.2'
>>> str(3+4j) '(3+4j)'
>>> str(3 + 29) '32'
>>> str('py') 'py'
Индексация строк
Часто в языках программирования, отдельные элементы в упорядоченном наборе данных могут быть доступны с помощью числового индекса или ключа. Этот процесс называется индексацией.
Отдельные символы доступны по индексу следующим образом:
>>> s = 'foobar'
>>> s[0]
'f'
>>> s[1]
'o'
>>> s[3]
'b'
>>> s[5]
'r'
Вот несколько примеров отрицательного индексирования:
>>> s = 'foobar'
>>> s[-1]
'r'
>>> s[-2]
'a'
>>> len(s) 6
>>> s[-len(s)] # отрицательная индексация начинается с -1 'f'
Срезы строк
Извлечение подстроки из строки, известное как ‘‘string slice’’. Если s – это строка, выражение формы s[m:n] возвращает часть s, начинающуюся с позиции m, и до позиции n, но не включая позицию:
>>> s = 'python'
14
>>> s[2:5]
'tho'
Аналогично, если опустить второй индекс s[n:], срез длится от первого индекса до конца строки. Это хорошая, лаконичная альтернатива более громоздкой s[n:len(s)]:
>>> s = 'python'
>>> s[2:]
'thon'
>>> s[2:len(s)]
'thon'
Отрицательные индексы можно использовать и со срезами.
>>> s = 'python'
>>> s[-5:-2]
'yth'
>>> s[1:4]
'yth'
>>> s[-5:-2] == s[1:4] True
Встроенные методы строк в python
№
Метод и описание
Пример 1. string.capitalize() приводит первую букву в
верхний регистр, остальные –в нижний.
>>> s = 'everyTHing yoU Can IMaGine is rEAl'
>>> s.capitalize() 'Everything you can imagine is real'
2.
string.lower() . преобразует все буквенные символы в строчные
'everyTHing yoU Can IMaGine is rEAl'.lower()
'everything you can imagine is real'
3. string.swapcase() меняет регистр буквенных символов на противоположный
>> 'everyTHing yoU
Can IMaGine is
rEAl'.swapcase()
'EVERYthING YOu cAN imAgINE IS ReaL' 4.
string.title() преобразует первые буквы всех слов в заглавные
>>> 'follow us
@PYTHON'.title()
'Follow Us @Python' 5.
string.upper(). преобразует все буквенные символы в заглавные
'follow us
@PYTHON'.upper()
'FOLLOW US
@PYTHON' 6. string.count(<sub
>[, <start>[,
<end>]])
подсчитывает
количество вхождений подстроки в строку
>>> 'foo goo moo'.count('oo') 3
15
7. string.endswith(
<suffix>[,
<start>[,
<end>]]) .
определяет,
заканчивается ли строка заданной подстрокой
>> 'python'.endswith('on') True
>>> 'python'.endswith('or') False
8.
string.find(<sub
>[, <start>[,
<end>]])
ищет в строке заданную подстроку
'Follow Us
@Python'.find('Us') 7
9. string.index(<sub
>[, <start>[,
<end>]]).
ищет в строке заданную
подстроку 'Follow Us
@Python'.index('you')
Traceback (most recent call last):
File "<pyshell#0>", line 1, in <module>
'Follow Us
@Python'.index('you')
ValueError: substring not found
10. string.isalnum() определяет, состоит ли строка из букв и цифр
'abc123'.isalnum() True
>>> ''.isalnum() False
11.
string.isalpha() . определяет, состоит ли строка только из букв
>>> 'ABCabc'.isalpha() True
>>> 'abc123'.isalpha() False
12. string.isdigit() определяет, состоит ли строка из цифр (проверка на число)
>>> '123'.isdigit() True
>>> '123abc'.isdigit() False
13. string.isidentifie r() идентификат ором Python.
определяет,
является ли строка допустимой
'foo32'.isidentifier() True
>>> '32foo'.isidentifier() False
14.
string.islower(). определяет,
являются ли буквенные
символы строки
строчными
>>> 'abc'.islower() True
>>> 'Abc1$D'.islower() False
15. string.isprintable(
)
определяет, состоит ли строка только из печатаемых символов
>>> 'a\tb'.isprintable() # \t - символ табуляции
False
>>> 'a b'.isprintable() True
16
16. string.isspace() определяет, состоит ли строка только из пробельных символов
>>> ' \t \n '.isspace() True
>>> ' a '.isspace() False
17.
string.istitle(). определяет, начинаются ли слова строки с заглавной буквы
'This Is A Title'.istitle() True
>>> 'This is a title'.istitle()
False 18. string.isupper() определяет, являются ли
буквенные символы строки заглавными
>> 'ABC'.isupper() True
>>> 'Abc1$D'.isupper() False
19.
string.center(<w idth>[, <fill>])
выравнивает строку по центру
>>> 'py'.center(10) ' py ' 20. tring.expan
dtabs(tabsize=8)
заменяет табуляции на пробелы
>>> 'a\tb\tc'.expandtabs() 'a b c'
>>>
'aaa\tbbb\tc'.expandtabs() 'aaa bbb c' 21. string.ljust(<widt
h>[, <fill>])
выравнивание по левому краю строки в поле
>> 'python'.ljust(10) 'python ' 22. string.lstrip([<cha
rs>])
обрезает пробельные символы слева
foo bar baz '.lstrip()
'foo bar baz ''\t\nfoo\t\nbar\t\nbaz'.lstrip()
'foo\t\nbar\t\nbaz' 23.
string.replace(<o ld>, <new>[,
<count>])
заменяет вхождения подстроки в строке
>>> 'I hate python! I hate python!
24. string.rjust(<widt h>[, <fill>])
выравнивание по правому краю строки в поле
>>> 'python'.rjust(10) ' python' 25. string.rstrip([<cha
rs>])
обрезает пробельные символы справа
' foo bar baz '.rstrip() ' foo bar baz'
>>>
'foo\t\nbar\t\nbaz\t\n'.rstrip() 'foo\t\nbar\t\nbaz' 26.
string.strip([<char s>])
удаляет символы с левого и правого края строки.
>>> s = ' foo bar baz\t\t\t'
>>> s = s.lstrip()
>>> s = s.rstrip()
>>> s
'foo bar baz'
17
27. string.zfill(<widt h>)
дополняет строку нулями слева
>>> '42'.zfill(5) '00042' 28. string.join(<iterab
le>)
объединяет список в строку
>>> ', '.join(['foo', 'bar', 'baz', 'qux'])
'foo, bar, baz, qux' 29.
string.partition(<s ep>)
делит строку на основе разделителя
>> 'foo.bar'.partition('.') ('foo', '.', 'bar') 30.
string.rsplit(sep
=None,
maxsplit=-1)
делит строку на список из подстрок
> 'foo bar baz qux'.rsplit() ['foo', 'bar', 'baz', 'qux']
31. string.splitlines([
<keepends>])
делит текст на список
строк s.splitlines()
Разделитель Значение
\n Новая строка
\r Возврат каретки
\r\n Возврат каретки + перевод строки
\v или же \x0b Таблицы строк
\f или же \x0c Подача формы
\x1c Разделитель файлов
\x1d Разделитель групп
\x1e Разделитель записей
\x85 Следующая строка
\u2028 Новая строка (Unicode)
\u2029 Новый абзац (Unicode) Лекция 6. Массивы в языке Python
Для использования массивов в языке Python вам нужно импортировать стандартный array модуль. Это потому, что массив не является основным типом данных, как строки, целое число и т.д.
from array import *
arrayIdentifierName = array(typecode, [Initializers]) – объявление массива Пример объявления массива python:
my_array = array('i',[1,2,3,4])
Пример массива, содержащего 5 целых чисел:
from array import *
my_array = array('i', [1,2,3,4,5]) for i in my_array:
print(i)
# 1
18
# 2
# 3
# 4
# 5
Массивы Python индексируются нулем: my_array = array('i', [1,2,3,4,5]) print(my_array[1])
# 2
print(my_array[2])
# 3
print(my_array[0])
# 1
Добавить любое значение в массив с помощью метода append ():
my_array = array('i', [1,2,3,4,5]) my_array.append(6)
# array('i', [1, 2, 3, 4, 5, 6]) Заметим, что значение 6 было приложено к существующим значениям массива.
insert() – метод по которому можно вставить значение по индексу массива.
my_array = array('i', [1,2,3,4,5]) my_array.insert(0,0)
#array('i', [0, 1, 2, 3, 4, 5]) – значение 0 было вставлено в индекс 0.
Массив Python может быть расширен на более чем одно значение с помощью extend() метод.
my_array = array('i', [1,2,3,4,5]) my_extnd_array = array('i', [7,8,9,10]) my_array.extend(my_extnd_array)
# array('i', [1, 2, 3, 4, 5, 7, 8, 9, 10])
Добавить элементы из списка в массив, используя метод fromlist () my_array = array('i', [1,2,3,4,5])
c=[11,12,13]
my_array.fromlist(c)
# array('i', [1, 2, 3, 4, 5, 11, 12, 13]) 11,12 и 13 были добавлены из списка c к my_array.
Удалите любой элемент массива, используя метод remove () my_array = array('i', [1,2,3,4,5])
my_array.remove(4)
# array('i', [1, 2, 3, 5]) Метод pop ()
pop удаляет последний элемент из массива.
19
my_array = array('i', [1,2,3,4,5]) my_array.pop()
# array('i', [1, 2, 3, 4]) Метода index ()
index() возвращает первый индекс значения соответствия. my_array = array('i', [1,2,3,4,5])
print(my_array.index(5))
# 5
my_array = array('i', [1,2,3,3,5]) print(my_array.index(3))
# 3
Метод reverse ()
reverse() метод изменяет массив.
my_array = array('i', [1,2,3,4,5]) my_array.reverse()
# array('i', [5, 4, 3, 2, 1]) Метода buffer_info ()
Предоставляет начальный адрес буфера массива в памяти и количество элементов в массиве.
my_array = array('i', [1,2,3,4,5]) my_array.buffer_info()
(33881712, 5) Метод count ()
count() возвращает число вхождений элемента в массиве.
my_array = array('i', [1,2,3,3,5]) my_array.count(3)
# 2
Метод tostring ()
tostring() преобразует массив в строку.
my_char_array = array('c', ['g','e','e','k'])
# array('c', 'geek')
print(my_char_array.tostring())
# geek
Метод tolist () преобразует массив в список.
my_array = array('i', [1,2,3,4,5]) c = my_array.tolist()
# [1, 2, 3, 4, 5]
Метод fromstring ()
Вы можете добавить строку в массив символов, используя fromstring()
20
my_char_array = array('c', ['g','e','e','k']) my_char_array.fromstring("stuff") print(my_char_array)
#array('c', 'geekstuff') Лекция 7. Словари в Пайтон
Словари — еще один встроенный тип данных для хранения объектов.
Они используются для связывания объекта «ключ» с объектом значения. Такое связывание называется отображением. Результатом отображения будет пара ключ – значение. Пары ключ – значение добавляются в словарь. Затем вы можете найти в словаре ключ и получить соответствующее ему значение.
Однако нельзя, наоборот, использовать значение для нахождения ключа.
Словари, как и списки, изменяемы. То есть в них можно добавлять новые пары ключ – значение. Их полезность заключается в связях между ключами и значениями — существует множество ситуаций, в которых вам потребуется сохранять данные попарно. Например, в словаре можно сохранить информацию о телефонных номерах ваших друзей:
phones = {
"Айнур": "+7123456789", "Габит": "+37520123456"
}
print(phones)
При создании словаря нужно использовать фигурные скобки, отделять ключ от значения двоеточием, а пары ключ – значение разделять запятыми.
В отличие от кортежей, если у вас есть только одна пара ключ – значение, запятая после нее не нужна.
Как только вы создали словарь, можете добавлять в него пары ключ – значение, используя синтаксис имя_словаря [ключ] = значение, а также искать значение при помощи ключа, используя синтаксис имя_словаря [ключ].
phones = {
"Айнур": "+7123456789", "Габит": "+37520123456"
}
phones['Галым'] = 1234567890 print(phones['Малик'])
Значением в словаре может быть любой объект. В предыдущем примере первые два значения были строками, а последнее значение, 1234567890, — целым числом.
В отличие от значения словаря, ключ словаря должен быть неизменяемым. Ключом словаря может быть строка или кортеж, но не список или словарь. Для определения того, есть ли ключ в словаре, используйте ключевое слово in, а not in — для проверки отсутствия ключа.
21
phones = {
" Малик ": "+7123456789", "Надир": "+37520123456"
}
print("Надир " in phones) # True
Из словаря можно удалить пару ключ – значение с помощью ключевого слова del.
phones = {
"Малик": "+7123456789", " Надир ": "+37520123456"
}
del phones["Надир "]
Вы можете сохранять контейнеры в других контейнерах. Например, можно хранить списки внутри списка.
music = {
"rap": ["Бакыт", "Кут", "Береке"], "rock": ["Нур", "Казына", "Адам"],
В этом примере словарь music имеет три ключа, каждый из которых является списком: К этим спискам можно получить доступ с помощью соответствующих ключей:
music = {
"rap": ["Бакыт", "Кут", "Береке"], "rock": ["Нур", "Казына", "Адам"], }
print(music['rap']) # ["Бакыт", "Кут", "Береке"]
print(music['rock'][-1]) # ["Нур", "Казына", "Адам"]
Лекция 8. Обработка исключений Оператор try-except
Когда ошибки в программе возникают в процессе написания кода или его тестирования, то код исправляется программистом так, чтобы ошибок не возникало. Однако нередко действия пользователя приводят к тому, что в программе возникает исключение. Например, программа ожидает ввод числа, но человек ввел букву. Попытка преобразовать ее к числу приведет к возбуждению исключения ValueError, и программа аварийно завершится.
На этот случай в языках программирования, в том числе Python, существует специальный оператор, позволяющий перехватывать возникающие исключения и обрабатывать их так, чтобы программа продолжала работать или корректно завершала свою работу.
В Питоне такой перехват выполняет оператор try-except. "Try"
переводится как "попытаться", "except" – как исключение. Словами описать его работу можно так: "Попытаться сделать то-то и то-то, если при этом возникло
22
исключение, то сделать вот это и это." Его конструкция похожа на условный оператор с веткой else.
Рассмотрим пример:
n = input ("Введите целое число: ") try:
n = int(n)
print ("Удачно") except:
print ("Что-то пошло не так")
Исключительная ситуация может возникнуть в третьей строчке кода, когда значение переменной n преобразуется к целому числу. Если это невозможно, то дальнейшее выполнение выражений в теле try прекращается. В данном случае выражение print ("Удачно") выполнено не будет. При этом поток выполнения программы перейдет на ветку except и выполнит ее тело.
Если в теле try исключения не возникает, то тело ветки except не выполняется.
Вот пример вывода программы, когда пользователь вводит целое число:
Введите целое число: 100 Удачно
А здесь – когда вводит не то, что ожидалось:
Введите целое число: AA Что-то пошло не так
Есть одна проблема. Код выше обработает любое исключение. Однако в теле try могут возникать разные исключения, и у каждого из них должен быть свой обработчик. Поэтому более правильным является указание типа исключения после ключевого слова except.
try:
n = input ('Введите целое число: ') n = int(n)
print ("Вы ввели число ", n) except ValueError:
print ("Вы ввели не целое число")
Теперь, если сработает тело except, мы точно знаем, из-за чего возникла ошибка. Но если в теле try возникнет еще какое-нибудь исключение, то оно не будет обработано. Для него надо написать отдельную ветку except. Рассмотрим программу:
try:
a = float(input ("Введите делимое: ")) b = float(input ("Введите делитель: ")) c = a / b
print ("Частное: %.2f" % c) except ValueError:
print ("Нельзя вводить строки") except ZeroDivisionError:
23
print ("Нельзя делить на ноль")
При ее выполнении исключения могут возникнуть в трех строчках кода:
где происходит преобразование введенных значений к вещественным числам, и в месте, где происходит деление. В первом случае может возникнуть ValueError, во втором – ZeroDivisionError. Каждый тип исключения обрабатывается своей веткой except.
Несколько исключений можно сгруппировать в одну ветку и обработать совместно:
try:
a = float(input ("Введите делимое: ")) b = float(input ("Введите делитель: ")) c = a / b
print ("Частное: %.2f" % c)
except (ValueError, ZeroDivisionError):
print ("Нельзя вводить строки или делить на ноль")
У оператора обработки исключений, кроме except, могут быть еще ветки finally и else (не обязательно обе сразу). Тело finally выполняется всегда, независимо от того, выполнялись ли блоки except в ответ на возникшие исключения или нет. Тело else сработает, если исключений в try не было, т. е.
не было переходов на блоки except.
try:
n = input ('Введите целое число: ') n = int(n)
except ValueError:
print ("Вы что-то попутали с вводом")
else: # когда в блоке try не возникло исключения print ("Все нормально. Вы ввели число", n) finally: # выполняется в любом случае
print ("Конец программы")
В данном коде используются комментарии. В языке Python перед ними ставится знак решетки.
Также исключение может возникнуть в блоках except, else или finally, и тогда им нужен собственный обработчик. Модифицируем немного предыдущую программу и специально сгенерируем исключение в теле except:
try:
n = input ('Введите целое число: ') n = int(n)
except ValueError:
print ("Вы что-то попутали с вводом") 3 / 0
except ZeroDivisionError:
print ("Деление на ноль") else:
print ("Все нормально. Вы ввели число", n)
24
finally:
print ("Конец программы") Лекция 9. Методы сортировки
Метод сортировки Bubble sort / пузырьковая сортировка/, постепенно перемещает элементы таким образом, что наименьший оказывается в самом начале, так же, как пузырек воздуха всплывает в воде наверх. А самый большой элемент, наоборот, опускается вниз – то есть в конец массива.
Этот метод по очереди сравнивает каждые два соседних элемента и переставляет их местами, если порядок неправильный. Возьмем следующий ряд чисел: 57380. Сначала алгоритм сравнит первые два соседних числа: 5 меньше 7, значит порядок правильный, они остаются на своих местах. Затем следующие два числа – 7 больше 3, значит они меняются местами. Затем он сравнит 7 и 8, и тоже переставит их местами и так далее. После первого прохода по ряду чисел в конце окажется самое большое число – 8. И дальше алгоритм проходит по всем числам снова и будет проходить столько раз, пока каждое число не встанет на свое место – от меньшего к большему.
my_list=[5,7,3,8,0]
if my_list[0]>my_list[1]:
my_list[0],my_list[1]=my_list[1],my_list[0]
print(my_list) [5, 7, 3, 8, 0]
Этот код сравнил 5 с 7, и оставил их на своих местах. Теперь сравним следующие два числа: меняем в коде индексы на 0 и 2. И видим, что он сравнил 3 и 7 и поменял их местами.
if my_list[1]>my_list[2]:
my_list[1],my_list[2]=my_list[2],my_list[1]
print(my_list) [5, 3, 7, 8, 0]
Эту операцию нам надо выполнять столько раз, сколько у нас в списке чисел, чтобы каждое из них нашло свое место. Поэтому, чтобы не прописывать для каждой пары одну и ту же операцию, мы создаем цикл, равный длине нашего массива минус 1, потому что последнее число в списке не имеет соседа справа, и значит эту операцию сравнения производить не нужно. И просим распечатать получившийся список внутри цикла, чтобы видеть каждый шаг кода. my_list=[5,7,3,8,0]
for i in range(len(my_list)-1):
print (f"сравниваем {my_list[i]} c {my_list[i+1]}") if my_list[i]>my_list[i+1]:
my_list[i],my_list[i+1]=my_list[i+1],my_list[i]
print(my_list)
25
сравниваем 5 c 7 [5, 7, 3, 8, 0]
сравниваем 7 c 3 [5, 3, 7, 8, 0]
сравниваем 7 c 8 [5, 3, 7, 8, 0]
сравниваем 8 c 0 [5, 3, 7, 0, 8]
Этот код постепенно переместил 8 в конец, после одного обхода одно число нашло свое правильное место. Но на этом сортировка не заканчивается.
Нам нужно, чтобы каждый элемент массива переместился на свое место – значит нужно сделать столько обходов, сколько у нас чисел. Поэтому мы создаем новый цикл с количеством итераций, равным длине списка. Но здесь мы увидим, что на последнем обходе ничего не поменяется, потому что, когда 3 нашла свое место, самый минимальный элемент 0 тоже встал на свое место, значит мы можем отнять 1, чтобы не делать последний обход. Как еще можно оптимизировать этот код? После каждого обхода в конце списка оказывается наибольшее число, и сравнение тех чисел, которые уже нашли свое место, производить не надо. Поэтому мы можем отнять внутри цикла количество обходов, соответствующее итерации цикла – run. Тогда код не будет выполнять лишних операций сравнения.
my_list=[5,7,3,8,0]
for run in range (len(my_list)-1):
for i in range(len(my_list)-1-run):
print (f"сравниваем {my_list[i]} c {my_list[i+1]}") if my_list[i]>my_list[i+1]:
my_list[i],my_list[i+1]=my_list[i+1],my_list[i]
print(my_list) сравниваем 5 c 7 сравниваем 7 c 3 сравниваем 7 c 8 сравниваем 8 c 0 [5, 3, 7, 0, 8]
сравниваем 5 c 3 сравниваем 5 c 7 сравниваем 7 c 0 [3, 5, 0, 7, 8]
сравниваем 3 c 5 сравниваем 5 c 0 [3, 0, 5, 7, 8]
сравниваем 3 c 0 [0, 3, 5, 7, 8]
26
Расмотрим алгоритм с функцей, которой можно будет передавать любые другие массивы и протестируем ее на новом списке.
def bubble_sort(my_list):
for run in range (len(my_list)-1):
for i in range(len(my_list)-1-run):
#print (f"сравниваем {my_list[i]} c {my_list[i+1]}") if my_list[i]>my_list[i+1]:
my_list[i],my_list[i+1]=my_list[i+1],my_list[i]
return my_list
my_list=[0,6,8,3,2,57,76,35,0]
bubble_sort(my_list)
[0, 0, 2, 3, 6, 8, 35, 57, 76]
Встроенные методы и функции сортировки
В языке Python есть встроенные функции и методы сортировки, которые позволяют проделать те же операции одной строчкой кода.
Метод .sort() сортирует список и сохраняет его в отсортированном виде.
А функция sorted() создает новый отсортированный список без изменения исходного.
my_list=[0,6,8,3,2,57,96,45]
my_list.sort() my_list
[0, 2, 3, 6, 8, 45, 57, 96]
Еще одно их отличие в том, что функция sorted работает не только со списками, но и другими объектами. Например, вот что получится, если мы отсортируем строку.
tring='Важные истории' sorted(string)
[' ', 'В', 'а', 'е', 'ж', 'и', 'и', 'и', 'н', 'о', 'р', 'с', 'т', 'ы']
Эта функция возвращает список каждый раз, несмотря на то, какой тип данных был ей передан. В случае со словарями, она возвращает отсортированный список словарных ключей.
fsb_dict={'na':'Бактияров А.В.','inc':15879555.13,'wi_income':261956.95}
sorted(fsb_dict)
['inc', 'na', 'wi_income']
По умолчанию сортировка будет происходить по возрастанию, но мы можем передавать функции и методу параметры. За это отвечает параметр reverse. Если мы передадим ему параметр True, сортировка будет происходить по убыванию.
my_list=[1,6,8,3,2,57,76,35,0]
sorted(my_list,reverse=True)
27
[76, 57, 35, 8, 6, 3, 2, 1, 0
Кроме этого, у sort и sorted есть параметр key, который указывает на функцию сравнения. Например, если мы хотим отсортировать значения без учета регистра текста, можно сделать так:
string='Важные истории' sorted(string,key=str.lower)
[' ', 'а', 'В', 'е', 'ж', 'и', 'и', 'и', 'н', 'о', 'р', 'с', 'т', 'ы']
Внутри параметра key могут находиться не только встроенные функции, но и написанные нами. Они обычно нужны, когда мы хотим отсортировать сложный объект. Например, есть такая проблема: если попытаться отсортировать сложный объект (который состоит, например, из списка списков), сортировка будет выполняться по первому элементу.
fsb_list=[['Бактияров А.В.',15879555.13,261956.95],['Сачков С.М.',11882496.91,593918.65],['Кулманов В.Г.',6795228.14,861350.27]]
sorted(fsb_list)
[[' Бактияров А.В.', 15879555.13, 261956.95], [' Кулманов В.Г.', 6795228.14, 861350.27], [' Сачков С.М.', 11882496.91, 593918.65]]
Если мы хотим, чтобы сортировка происходила не по первому элементу, мы можем сами создать специальную функцию.
def fsb_income(i):
return i[1]
sorted(fsb_list,key=fsb_income)
[['КулмановВ.Г.', 6795228.14, 861350.27], ['Сачков С.М.', 11882496.91, 593918.65], ['Бактияров А.В.', 15879555.13, 261956.95]]
Лекция 10. Функции
Функция в программировании представляет собой обособленный участок кода, который можно вызывать, обратившись к нему по имени, которым он был назван. При вызове происходит выполнение команд тела функции.
Функции можно сравнить с небольшими программками, которые сами по себе, т. е. автономно, не исполняются, а встраиваются в обычную программу.
Нередко их так и называют – подпрограммы. Других ключевых отличий функций от программ нет. Функции также при необходимости могут получать и возвращать данные из вызывающей программы. И они возвращают результат своей работы.
Существует множество встроенных функций в язык программирования Python. Это print(), input(), int(), float(), str(), type(). Код их тела нам не виден, он
