Числа

Числа в Python бывают трёх типов:

• целые, например,  4
• вещественные, например,  5.02
• комплексные

Кавычки

Одинарные кавычки

Строку можно указать, используя одинарные кавычки, как например, 'Это строка'.  Любой одиночный символ в кавычках, например,  'ю'  — это строка. Пустая строка '' — это тоже строка. То есть строкой мы считаем всё, что находится внутри кавычек.

Двойные кавычки

Запись строки в одинарных кавычках  это не единственный способ. Можно использовать и двойные кавычки, как например, ''Это строка''.  Для интерпретатора разницы между записями строки в одинарных и двойных кавычках нет.   

Внимание:

Если  строка началась с двойной кавычки — значит и закончиться должна на двойной кавычке. Если внутри строки мы хотим использовать двойные кавычки, то саму строку надо делать в одинарных кавычках. 

Театр ''Современник''
print('Театр ''Современник''') 

Тройные кавычки

Строка, занимающая несколько строк,  должна быть обрамлена тройными кавычками ('' '' ''  или ''').  Например:

'''В Python можно использовать одинарные,
    двойные и тройные кавычки,
    чтобы обозначить строку'''

Отступы

Сдвиг строки с помощью пробелов называется отступами.

• Для выделения блоков программного кода используются отступы.

• В одном и том же блоке кода должно быть одинаковое количество пробелов.

• Количество пробелов в отступах произвольно.  Общепринято использовать четыре пробела.  

Основные операторы

В арифметических выражениях используются следующие операции и соответствующие знаки:

Пояснения:

Операции +, -, * имеют очевидный смысл.

Операция деления /. Если x и y целые, то результат деления всегда будет вещественным числом!

Пример:
40/5, даст вещественное число, равное 8.0.
40/5.0 даст вещественное число 8.0.

Операция деления целых чисел // - это деление, в котором возвращается целая часть результата. Часть цифр после запятой отбрасывается.

Пример.
4//3 в результате будет 1,
25//6 в результате будет 4

Деление по модулю - деление, в котором возвращается остаток. Ррезультатом операции % будет целое значение, равное остатку от деления (но не дробной части).

Пример.
4 % 2 в результате будет 0
5 % 2 в результате будет 1

 Для выполнения арифметических, логических и других действий часто используются следующие операторы:

Пример.

 a = 10
    b = 3  
    b = a + b   # теперь b равно числу 13
    c = a % b   # с равно 1, равно остатку, но не дробной части
    c = a // b # с равно 3, равно целой части

Оператор присваивания

Переменная – это именованная область памяти, в которой хранятся данные.

Данные помещаются в эту область памяти, как в ящик, с помощью оператора присваивания. Общая форма  записи операции присваивания:

имя = значение

Знакомый нам знак  равно (=) в программирование это знак операции присваивания. Различие между  знаками равно и присваивания в следующем.
Например:

b = 4
b = b + 2 # переменная  будет иметь значение 6

В обычной математической записи  выражение  b (рано) = b + 2 является не верным. Однако запись оператора присваивания b (присвоить) = b + 2 правильная и означает следующее: к текущему значению переменной b, например, оно было равно 4, прибавляется число 2 , и после  выполнения данного оператора, значение переменной будет равно 6.

Основные типы данных

СИМВОЛЫ

В классических языках программирования для работы с символами предназначен тип char. В языке Python нет специального типа для символов. Для работы с символами используется строковый тип – это тип str. Строковый тип предоставляет программисту весь нужный функционал для работы, как со строками, так и с символами.

Некоторые функции для работы с символами

• chr(s) – получение символа по его коду ASCII

print(chr(48))       # 0
print(chr(49))       # 1
print(chr(65))       # A

• ord(s) – получение кода ASCII по символу

print(ord('0'))     # код 48
print(ord('1'))     # код 49
print(ord('A'))     # код 65

• свойства непрерывности кодов символов.
  Пример.

ch1 ='A'
ch2 ='z'
ch3 ='д'
ch4 ='6'
if 'A'<= ch1 <='Z':
       print("Заглавная английская буква",ch1)
if 'a'<= ch2 <='z':
       print("строчная английская буква",ch2)
if 'а' <= ch3 <= 'я':
       print("строчная русская буква",ch3)
if '0'<= ch4 <='9':
       print("цифра",ch4)

Будет выведено:

Заглавная английская буква A
строчная английская буква z
строчная русская буква д
цифра 6

• Создать список строчный букв английского алфавита.
  Пример.

Код символа 'a' – 97, код символа 'z' – 122.
Функция chr(i) – по числовому коду символа возвращает сам символ.
Поскольку символы идут подряд, то возможно использовать генератор.

# вариант 1

# используем коды символов
list_char = [chr(i) for i in range(97, 123)]
print(*list_char)

Будет выведено:

a b c d e f g h i j k l m n o p q r s t u v w x y z

# вариант 2

# получаем код ASCII по символу
list_char = [chr(i) for i in range(ord('a'), ord('z')+1)]
print(*list_char)

Будет выведено:

a b c d e f g h i j k l m n o p q r s t u v w x y z

Последовательности

Последовательность (Sequences) – это упорядоченный набор данных. Каждому элементу в последовательности  присвоен номер – его позиция в последовательности или индекс (index).

Последовательности могут быть как изменяемыми, так и неизменяемыми. Размерность и состав созданной однажды неизменяемой последовательности не может меняться. При изменении последовательности создаётся новая последовательность, старая удаляется. 

Наиболее часто используются следующие типы последовательностей

 Сейчас нам важно отметить, что последовательности имеют общие методы и функции. На практике этот факт позволяет писать универсальные алгоритмы обработки последовательностей.

Общие методы, функции и операторы для любого типа последовательностей

• len(s): возвращает длину последовательности

len('12345')       # 5 длина строки
len([1,2,4])       # 3 длина списка

• Конкатенация (сложение) s1 + s2

Возвращает новый объект - «склейку» s1 и s2.
'abc'+'123'      # 'abc123'
[1,2]+[1,3]         # [1,2,1,3]

• Повторение N раз s*N

Возвращает последовательность, повторяющуюся n раз.
'a'*4           # 'aaaa'
[1, 2]*3         # [1, 2, 1, 2, 1, 2]

•  Проверка вхождения x in s

Возвращает True, если x входит в последовательность s и False в противном случае.
'2' in '123456'     # True
'0' in '123456'     # False

•  Проверка НЕвхождения x not in s

Возвращает True, если x не входит в последовательность s и False в противном случае.
'0' not in '123' #True
'2' not in '123' #False

• Количество вхождений x в s: s.count(x)

Возвращает количество вхождений элементов x в последовательность s.
'abcaa'.count('a')   #3

•  Индекс первого (левого) элемента x в s: s.index(x)

Возвращает первое вхождение элемента x в последовательность s
'123456123'.index('2') # 1

Вариант
s.index(x,start, end) –
start (необязательно) – начать поиск с этого индекса;
end (необязательно) – искать элемент до этого индекса.

• Возвращает максимальный элемент последовательности s

max([1,1,9,2])    # 9
max('12345abcdef') #'f'

• Возвращает минимальный элемент последовательности s
        min([1,2,9,2])      # 1
        min('12345abcdef')   #'1'

• Сортировка элементов sorted(s, key=None, reverse=False)
  Возвращает отсортированный объект в виде списка. Исходный объект при этом не изменяется.
  Параметры
  key– функция сортировки (по умолчанию не учитывается, сортировка осуществляется поэлементно)
  reverse– если равен True, сортировка осуществляется в обратном порядке. 

sorted('bac')                   # ['a', 'b', 'c']
sorted('bac', reverse= True)) # ['c', 'b', 'a']

Срез

Срез (slice) — извлечение из последовательности фрагмента последовательности от элемента с индексом n до элемента с индексом m, не включая его. 

Формат среза

s[n:m:k]

n – начальный индекс фрагмента последовательности
m - конечный индекс фрагмента, причем в состав фрагмента не включается!!!
k – шаг выборки элементов. По умолчанию равен 1.
k < 0 – последовательность обрабатывается от конца к началу

Примеры

• [n:m]– срез от n до m-1 
• [:m] – срез от 0 до m-1 
• [n:] – срез от n до конца
• [:] – вся последовательность
• [::]  – вся последовательность

• [n:m:k]– срез от n до m-1 c шагом k
• [n:m:-1]– срез от m до n+1 c шагом 1
• [n:m:-k]– срез от m до n+1 c шагом k

• [-1:] - последний элемент
• [-2:] - два последних элемента
• [::-1] – реверс массива

 Строки

Строка – это последовательность символов. Чаще всего строки – это просто некоторые наборы слов. Слова могут быть как на английском языке, так и почти на любом языке мира.

Любой одиночный символ в кавычках, например, 'a' — это строка. Пустая строка '' — это тоже строка. То есть строкой мы считаем всё, что находится внутри кавычек.

Строка является неизменной последовательностью, поэтому можно обратиться к любому символу строки используя индекс. Например,

str = "Python"

str = "Python"
print(str)                               # Python
print(str[0])                          # P
print(str[2])                          # t
for i in range (len(str)):
   print(str[i], end = " ")      # P y t h o n

Строки неизменяемы

str[0] = 'p'         # операция не допустима

Это означает, что после создания строки её больше нельзя изменять. Это позволяет ускорить обработку строк. При каждом изменении строки создается новая строка, а прежняя удаляется.

Заменить в строке символ можно так

str = "Python"
s = ""                         # здесь будет результат – новая строка
for x in str:
    if x == "P":
        x = "p"
     s = s +  x
print (s)                   # python    

Операции со строками

s[i]   извлекает из строки s символ в позиции i
s[-1]   извлекает из строки s последний символ
s[i:j]   извлекает из строки s символы в диапазоне от i до j

Некоторые функции работы со строками

Списки

Список (обозначается словом list) представляет тип данных, который хранит последовательность элементов. Тип элементов может быть любой.

В Python в отличие от обычных списков список – динамическая структура, его размер можно изменять во время выполнения программы(удалять, добавлять элементы).

Создание списка

 Создать список можно различными способами. Для создания списка в квадратных скобках [ ] через запятую перечисляются все его элементы.

Примеры создания списков

Создание пустого списка

     lst = [ ]

Создание списка чисел:

         numbers = [1, 2, 3, 4, 5]  

Создание списка слов:

     words = ["C", "C++", "Java", "Python"]

Создание списка из элементов разного типа

     lstNum = [1,2,3,4, "один", "два", "три", "четыре"]

Сложение списков

    numbers  = [1,2] + [3,4] + [5]   # [1, 2, 3, 4, 5

 Сложение одинаковых списков заменяется умножением «*».

numbers  = [0]*10     # [0, 0, 0, 0, 0, 0, 0, 0, 0, 0]

Использовать функцию list для того, чтобы создать список из последовательности

s = '123456'
lst =list(s)
print(lst)         #['1', '2', '3', '4', '5', '6']

!!!  Признаком того, что последовательность является списком, является наличие квадратных скобок.

Методы работы со списками

При работе со списками наиболее часто используют следующие методы:

append(x): добавляет элемент x в конец списка

insert(index, x): добавляет элемент x в список по индексу index

pop([index]): удаляет и возвращает элемент по индексу index. Если

индекс не передан, то просто удаляет последний элемент.

remove(x): удаляет первое вхождение элемента x. Если элемент не найден,

  генерирует исключение ValueError

clear(): удаление всех элементов из списка

s.count(x): количество вхождений элемента x в последовательность s

s.index(x): индекс элемента x  в последовательности s

sort():  сортировка последовательности(сортирует его на месте)

а также общие функции и операторы работы с последовательностями

x in s – проверка вхождения элемента x в последовательность s

sum(s) – сумма элементов списка c именем s

max(s)/min(s) – максимальный / минимальный элемент последовательности

sorted(s) – сортировка последовательности

len(s) – длина последовательности

Внимание!

Метод списка list.sort() сортирует его на месте (т.е. изменяет). Если необходимо сохранить начальную сортировку списков, то для сортировки используйте функцию sorted(), она создаст новый отсортированный список, который можно сравнивать.

Примеры.

Методы работы со списком

lst = [1,2,3,4,5]
lst.append(6)                     #  [1, 2, 3, 4, 5, 6]
lst.insert(0,7)                   #  [7, 1, 2, 3, 4, 5, 6]
lst.pop()                         #  [7, 1, 2, 3, 4, 5]
lst.pop(1)                        #  [7, 2, 3, 4, 5]
lst.remove(2)                     #  [7, 3, 4, 5]
lst.append(3)                     #  [7, 3, 4, 5, 3]

Общие функции, методы и операторы

print(lst)                          # [7, 3, 4, 5, 3]
print(len(lst))                     #  5
print(max(lst))                     #  7
print(min(lst))                     #  3
print(sum(lst))                     #  22
print(2 in lst)                     # False
print(lst.count(3))                 #  2
print(lst.index(3))                 #  1
print(sorted(lst))                  # [3, 3, 4, 5, 7]
print(sorted(lst, reverse=True))    # [7, 5, 4, 3, 3]

Кортежи

Кортеж (tuple) — это последовательность неизменяемых объектов. Кортежи очень схожи со списками, с той разницей — что элементы кортежа не могут быть изменены и используют обычные скобки, вместо квадратных, как в списках.

Создание кортежа

Для создания кортежа в круглых скобках () через запятую перечисляются все его элементы.

Примеры создания кортежей

• Создание кортежа чисел:

a = (1, 2, 3)

• Создание кортежа слов:

words = ("C", "C++", "Java")

Основные свойства кортежей

• Неизменяемость — именно это свойство кортежей отличает их от списков
• Скорость — неизменяемость кортежей обеспечивает  выполнение операций с ними  быстрее, чем со  списками
• Безопасность — неизменяемость позволяет использовать кортежи как константы, что позволяют сделать код более читаемым и безопасным

Кортежи  не имеют  методов для добавления и удаления элементов.

Упаковка  кортежа

Упаковкой кортежа называют присваивание кортежа некоторой переменной. Здесь имеется 2 особенности:

1. Объявления кортежа со скобками и без скобок тождественны

tup = (1, 2, 3)  и  tup = 1, 2, 3

2.  Для объявления кортежа, включающего один единственный элемент, нужно использовать завершающую запятую:

           tup = (1,) или  tup = 1,

Распаковка кортежа

Распаковка кортежа  - это присвоение значения элементов кортежа отдельным переменным

x,y,z =(1, 2, 3)   #x=1 y=2 z=3

Преобразование

tuple → str

Преобразовать кортеж в строку выполняется при помощи метода join():

tup = ("C", "C++", "Java")
str = ''.join(tup)
print(str)          #  CC++Java

tuple → list

Преобразовать кортеж в список выполняется при помощи функции list():

tup = (1, 2, 3)
lst = list(tup)
print(lst)            # [1, 2, 3]

Кортежи поддерживают методы, операции и функции последовательностей

tup = (1, 4, 2, 3,5)
print(tup)                        # (1, 4, 2, 3, 5)
print(len(tup))                   # 5
print(max(tup))                   # 5
print(min(tup))                   # 1
print(2 in tup)                   # True
print(tup.count(3))               # 1
print(tup.index(3))               # 3
print(sorted(tup))                # [1, 2, 3, 4, 5]
print(sorted(tup, reverse=True))  # [5, 4, 3, 2, 1]

Внимание! Функция sorted() для кортежа возвращает отсортированный список, состоящий из элементов кортежа

Пример использования кортежей

Дан целочисленный массив A размерностью n. Найдите номера всех элементов массива с максимальным значением.

a  = [1, 8, 8, 10, 5, 0, 2, 8, 6, 0, 2, 2, 10, 1, 0]

mx = max(a)
b = [(a[i], i) for i in range(len(a)) if a[i] == mx]
print(b)

будет выведено

[(10, 3), (10, 12)]

Генераторы

Для создания списков, заполненных по более сложным формулам можно использовать генераторы: это выражения, позволяющие заполнить список значениями, вычисленными по некоторым формулам. 

Общий вид генератора следующий:

[выражение for переменная in последовательность]

Пример. Создать список чисел от 0 до 10. Записываем генератор 

             [i for i in range(0, 10)]  

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

1) что делаем с элементом i:   просто   добавляем значение i в список
2) что берем: берем i
3) откуда берем:  из объекта range.

Части отделены друг от друга ключевыми словами  for и in.  

list_of_numbers = []             #создаем пустой список
list_of_numbers = [i for i in range(0, 10)]
print(list_of_numbers)

Результат работы программы 
[0, 1, 2, 3, 4, 5, 6, 7, 8, 9]

Пример. Создать список заглавных букв английского алфавита.
Код символа 'A' – 65, код символа 'Z' – 91.
Поскольку символы идут подряд, то возможно использовать генератор.

что делаем: к значению элемента i применяем функцию chr(i).
Внимание.Функция  chr(i) – по числовому коду символа возвращает сам символ.  Пример. chr(65)  даст символ 'A'.

list_of_char = []                   #создаем пустой список
list_of_char = [chr(i) for i in range(65, 91)]
print(list_of_char)

 Результат работы программы

['A', 'B', 'C', 'D', 'E', 'F', 'G', 'H', 'I', 'J', 'K', 'L', 'M', 'N', 'O', 'P', 'Q', 'R', 'S', 'T', 'U', 'V', 'W', 'X', 'Y', 'Z']

Пример.  Создать список строчный букв английского алфавита.
Код символа 'a' – 97, код символа 'z' – 123.
Поскольку символы идут подряд, то возможно использовать генератор. 

list_of_char = []                    #создаем пустой список   
list_of_char = [chr(i) for i in range(97, 123)]
print(list_of_char)

 Результат работы программы 

['a', 'b', 'c', 'd', 'e', 'f', 'g', 'h', 'i', 'j', 'k', 'l', 'm', 'n', 'o', 'p', 'q', 'r', 's', 't', 'u', 'v', 'w', 'x', 'y', 'z']

Библиотека math

Для проведения вычислений с действительными числами язык Python содержит много дополнительных функций, собранных в библиотеку, которая называется math. Для использования этих функций в начале программы необходимо подключить библиотеку, что делается командой

import math           # подключение модуля библиотеки

После подключения программа получает доступ ко всем функциям, методам и классам, содержащимся в нём. После подключения можно вызвать любую функцию из подключенной библиотеки по следующему правилу: указывается имя модуля и через точку имя функции

имя_модуля.имя_функции

Например, пусть мы хотим вызвать функцию вычисления Синус угла, задаваемого в радианах
import math
y = sin(5)         # ошибка не подключен модуль math
x = math.sin(5)    # записываем имя модуля и через точку имя функции

Можно подключать не весь модуль, а какую-то его часть. Например, программист хочет использовать только одну функцию из математической библиотеки math. Если он подключит всю библиотеку, то будет добавлено более 40 функций, которые будут занимать место. Чтобы добавить в проект какую-то часть, используют ключевое слово from:

from <имя подключаемого модуля> import <название функции>

Например.

from math import sin       # подключена только одна функция sin
y = sin(5)                 # операция выполнена
x = cos(5)                # ошибка функция cos не подключена

Ниже приведен список основных функций модуля math. Некоторые из перечисленных функций (int, round, abs) являются стандартными и не требуют подключения модуля math для использования.

Генерация случайных чисел (модуль random)

Python порождает случайные числа на основе формулы, так что они на самом деле не случайные, а, как говорят, псевдослучайные.

Модуль random позволяет генерировать случайные числа и  имеет большое множество важных для практики функций. Рассмотрим  основные функции:

random.random() - случайное число от 0 до 1.

random.randint(A, B) - случайное целое число N, A ≤ N ≤ B.

random.shuffle(list) перемешивает список случайным образом

random.choice(list) возвращает один случайный элемент из списка

Примеры

Функция  random.random()случайное число от 0 до 1.

import random
number = random.random()  # значение от 0.0 до 1.0
print(number)
number = random.random() * 100  # значение от 0.0 до 100.0
print(number)

Функция    random.randint(A, B) - случайное целое число N, A ≤ N ≤ B

import random
number = random.randint(20, 35)  # значение от 20 до 35
print(number)

функция random.shuffle(list) перемешивает список случайным образом

import random
numbers = [1, 2, 3, 4, 5, 6, 7, 8]   # список
random.shuffle(numbers)
print('numbers shuffle:',numbers)

Результат работы программы:

numbers shuffle: [6, 8, 1, 4, 7, 5, 2, 3]

функция  random.choice(list) возвращает один случайный элемент из списка

numbers = [1, 2, 3, 4, 5, 6, 7, 8]
 random_number = random.choice(numbers)
 print('random_number:', random_number)

random_number: 4

Преобразование типов данных

Встроенные функции

print (x, sep = 'y') печатает x объектов, разделенных y

len (x) возвращает длину x (s, L или D)

min (L ) возвращает минимальное значение в L

max (L) возвращает максимальное значение в L

sum (L) возвращает сумму значений в L

range(n1,n2,n) возвращает последовательность чисел от n1 до n2 с шагом n

abs (n) возвращает абсолютное значение n

round (n1, n) возвращает число n1, округленное до n цифр

type (x) возвращает тип x (string, float, list, dict…)

str (x) преобразует x в string 

list (x) преобразует x в список

int (x) преобразует x в целое число

float (x) преобразует x в число с плавающей запятой

help (s) печатает справку о x

map (function, L) Применяет функцию  function к значениям в L

Принятые обозначения:
x, y обозначают любые значения данных,
s - строку, n - число, L - список,
где i, j - индексы списка,
D - словарь, а k - ключ словаря

Чтение и запись данных в файл

Открытие файла

Вариант 1

Конструкция with ... as открывает файл и закрывает его автоматически

with open ( "input.txt" ) as f:
           # здесь работаем с файлом

Закрывать файл с помощью  метода close() не нужно, он закроется автоматически после окончания цикла.

Вариант 2

Конструкция for ... in open открывает файл и закрывает его автоматически

for s in open ( "input.txt" ):
   # здесь работаем с файлом

Закрывать файл с помощью  метода close() не нужно, он закроется автоматически после окончания цикла.

Чтение чисел

Чтение отдельных чисел

Если в текущей строке файла одно число, читаем так:

with open ( "input.txt" ) as f:
          x = int( f.readline() )

В текущей строке файла два числа, читаем так:

with open ( "input.txt" ) as f:
      x, y = map( int, f.readline().split() )

Чтение массива чисел

В файле один столбец данных

with open ( "input.txt" ) as f:
              a = [int (x)  for x in f]

здесь a – массив данных, прочитанных из файла

Чтение чисел из файла, заданного несколькими столбцами

Структура файла

with open ( "input.txt" ) as f:
    n = int(f.readline())
    a = []
    for i in range(n):
       p = list(map(int,f.readline().split()))             
        a.append(p)

Чтение чисел из файла, заданного несколькими столбцами, разного типа

with open ( "input.txt" ) as f:
       n = int(f.readline())
       a = []
       for i in range(n):  
           x, y  = f.readline().split()
           p = list(int(x),y)
           a.append(p)

Файлы.  Обработка смешанных данных

Рассмотрим обработку смешанных данных. Предположим,  что в текстовом файле записаны данные  о  результатах сдачи экзамена. Каждая строка содержит фамилию, имя,  количество баллов и класс, которые разделены пробелами:

Иванов Иван 78  класс 11Б

Петров Петр 67  класс 11A

Сидоров Сидор 88  класс 11Б

Степанов Степан 70  класс 11A

Кузнецов Алексей 99  класс 11Б

Попов Николай 85  класс 11Б

Смирнов Василий 91  класс 11A

Соколов Евгений 55  класс 11Б

Козлов Дмитрий 81  класс 11A

Никитин Сергей 66  класс 11A

Васильев Юрий 58  класс 11A

При обработке этих данных могут быть разные постановки задач, но с  точки зрения программирования все они сводятся к задачам двух типов.

Задача 1 типа.  В этом типе задач  данные можно обрабатывать по одной строке (не нужно загружать все строки в оперативную память). Примеры таких задач:

• вывести в другой файл фамилии и имена тех учеников, которые получили больше 80 баллов.
• вывести фамилии и имена учеников в файлы по классам

Задача 2. Для решения задач этого  типа данные  - это  все строки сначала нужно загрузить в оперативную память и только после этого выполнять их обработку.  Примеры  таких задач:

• Отсортировать список учащихся по алфавиту, например, по фамилии
• Отсортировать список учащихся по убыванию/возрастанию полученного балла

Рассмотрим методы решения  этих задач.

Задача 1 типа.   Данные обрабатываются  по одной строке. 

Задача. Вывести в другой файл  фамилии, имена и класс тех учеников, которые получили больше 80 баллов.

Вот данные

Иванов Иван 78  класс 11Б

Петров Петр 67  класс 11A

              и далее . . .

Запишем развернутый код и обработки  одной  строки:

with open('ekzam.txt') as fr:

while True:
  s = fr.readline()  # читаем строку
  if not s: break
  print(s,end='')   # Иванов Иван 78 класс 11Б
  ball = s.split()  # из строки получаем список
  print(ball)       # ['Иванов', 'Иван', '78', 'класс', '11Б']
  print(ball[2])    # 78, элемент списка с индексом 2

Будет напечатано
Иванов Иван 78 класс 11Б
['Иванов', 'Иван', '78', 'класс', '11Б']
78

Этот код можно записать в краткой форме:

with open('ekzam.txt') as fr:
    while True:
      s = fr.readline()         # читаем строку
      if not s: break
      ball = int(s.split()[2])  # выделяем балл
      if ball  > 80:
          print(s, end='')

Полный код программы  выглядит так:

with open('80ball.txt', "w") as fw:
  with open('ekzam.txt') as fr:
      while True:
        s = fr.readline()
        if not s: break
        print(s,end='')
        ball = s.split()
        print(ball)
        print(ball[2])
        if int(ball[2])  > 80:
            print(s, end='')
            fw.write(s)

Будет записано в файл
Сидоров Сидор 88 класс 11Б
Кузнецов Алексей 99 класс 11Б
Попов Николай 85 класс 11Б
Смирнов Василий 91 класс 11A
Козлов Дмитрий 81 класс 11A

Задача 2 типа.  Все данные загружаются в оперативную память и  только потом обрабатываются .

Задача. Отсортировать список  учащихся  по возрастанию полученного балла и записать в другой файл . Формат выходных данных:
И. Иванов  78
П. Петров   67
. . .

 Этап 1. Выполняем чтение всех данных и готовим к сортировке данных

with open('ekzam.txt') as f:
    st  = f.readlines()
    a = []
for line in st:
     line = line.strip().split()
     a.append(line)

Пояснения.

Оператором  f.readlines() читаем весь список и получаем список строк. 

with open('ekzam.txt') as f:
    st  = f.readlines()

Проходим по списку строк и формируем  массив строк

a = []
for line in st:
     line = line.strip().split()
     a.append(line)

Вот так выглядит массив (список) строк

[['Иванов', 'Иван', '78', 'класс', '11Б'], ['Петров', 'Петр', '67', 'класс', '11A'], ['Сидоров', 'Сидор', '88', 'класс', '11Б'],  и т.д.

Выполняем сортировку массива по третьему столбцу (индекс 2)

a.sort(key=lambda x: x[2])

Этап 2.  Приводим  данные к требуемому формату и выполняем запись в файл

with open('ekzam_sort.txt',"w") as fw:
   n=1
   for i in a:
       fam = i[0][0:]                               

       name = i[1][:1]
       fio = str(n) + ') ' + name + '.' + fam
       # так выглядит  fio
        # 1) Е.Соколов
        # 2) Ю.Васильев

       fw.write(fio + " " + i[2]+ '\n')
       n+=1

Будет записано в файл

1. Е.Соколов 55
2. Ю.Васильев 58
3. С.Никитин 66
4. П.Петров 67
5. С.Степанов 70
6. ...

Полный код программы

with open('ekzam.txt') as f:
    st  = f.readlines()
    a = []
for line in st:
     line = line.strip().split()
     a.append(line)

a.sort(key=lambda x: x[2])

with open('ekzam_sort.txt',"w") as fw:
   n=1
   for i in a:
       fam = i[0][0:]
       name = i[1][:1]
       fio = str(n) + ') ' + name + '.' + fam
       fw.write(fio + " " + i[2]+ '\n')
       n+=1

Пояснения.

Lambda-фунция

Лямбда-функция — это небольшая анонимная функция – то есть функция без имени. Такие функции можно назвать одноразовыми, они используются только при создании.Анонимная функция описывается с помощью ключевого слова lambda в следующем формате:

lambda аргументы : <выражение>

<выражение>  является возвращаемым значением, т.е.  результат выполнения которого будет возвращен функцией.

Лямбда-функции могут принимать любое количество аргументов

Пример

f1 = lambda: 1 + 2               # Функция без параметров
f2 = lambda х, у : х + у         # Функция с двумя параметрами
f3 = lambda x, y, z : x+y+z      # Функция с тремя параметрами
print (f1())                     # Выведет: 3
print(f2(2,3))                   # Выведет: 5
print(f3(2,3,4))                 # Выведет: 9

Цикл for

Цикл for в Python предназначен для перебора элементов последовательности. Это не цикл со счетчиком, как цикл  for в  других языках программирования.

Здесь следует выделить два способа использования цикла for

1.  Просмотр списка

a = [1, 4, 2, 3]
for x in a:
    print(x, end = ' ' )     #1 4 2 3

Здесь переменная x поочередно принимает значения элементов списка, а цикл  for сам выбирает элементы списка и определит его конец.

2. Изменение значений элементов списка.

 Для решения этой задачи используется индекс элементов списка

a = [1, 4, 2, 3]
for i in  range(len(a)):
    print(a[i], end = ' ' )     #1 4 2 3

Функция range()

Функция range(), создает последовательность чисел, которая определяется количеством переданных в неё аргументов. Их может быть 1, 2 или 3:

• range(n)- вернет последовательность от 0 до n - 1
• range(n, m) - вернет последовательность от n до m - 1
• range(n, m, step)- вернет последовательность от n до m – 1 с шагом step

Примеры

range(4)              # значения: 0  1  2  3
range(5, 10)          # значения: 5  6  7  8  9
range(0, 10, 2)       # значения:0 2 4 6 8, наибольшее значение-9 (10-)
                      # последнее 8, следующее 10 не допустимо, т.к. больше 9
range(1, 10, 2)       # значения:  1 3 5 7 9. наибольшее значение 9,8+2=10 
range(0, 10, -2)      #   нет значений
range(10, 0, -1)      # значения:  10 9 8 7 6 5 4 3 2 1
range(10, 1, -1)      # значения:  10 9 8 7 6 5 4 3 2

 Цикл for и функция range()

Цикл for  и  функция range()  образуют прекрасное сочетание:

• функция range() создает последовательность
• цикл for  перебирает  элементы последовательности

Условный оператор if

Оператор if позволяет изменить порядок выполнения операторов в зависимости от истинности или ложности некоторого условия. Формат оператора может быть записан в двух формах: полной и неполной форме.

if  условие:
    # блок if
    <операторы>
else:
    # блок else
    <операторы>  

Блок инструкций if будет выполнен, если условие истинно. Если условие ложно, будет выполнен блок инструкций else.

В условном операторе  может отсутствовать слово else и последующий блок. Такая инструкция называется неполным ветвлением.

Пример 5.  Записать следующее   выражение  на языке Python.
Если a  >  0,  то  b  =  1,   иначе  a  =  0. 

print ("Введите значение a: ")
a = int(input())
if a > 0:
    b = 1      
else:
    b = 0
print("b = ", b)

 Условный оператор  elif

if условие_1:
   # блок if
   <операторы>
elif условие_2:
   # первый блок elif
   <операторы>
elif условие_3:
   <операторы>
...
else
   # блок else
   <операторы>   

Ключевое слово elif  расшифровывается, как else + if. Это конструкция позволяет  реализовать алгоритм  выбора   необходимого варианта из нескольких альтернативных вариантов.  Оператор elif позволяет упростить код. Сделать его легче читаемым и позволяет избежать написание несколько условий  if.

Когда исполняется инструкция if-elif-else, в первую очередь  проверяется условие_1.  Если условие истинно, тогда исполняется блок инструкций if .  Следующие условия и операторы пропускаются, и управление переходит к оператору  за  условным оператором if-elif-else.

Если условие_1 оказывается ложным, тогда управление переходит к следующему условию elif,  и проверяется условие_2.  Если оно истинно, тогда исполняются инструкции внутри первого блока elif. Последующие инструкции внутри этого блока пропускаются. Этот процесс повторяется, пока не находится условие elif, которое оказывается истинным. Если такого нет, тогда исполняется блок операторов else

 Пример.  

x = int(input())
y = int(input())
if x > 0 and y > 0:
    print("Первая четверть")
elif x > 0 and y < 0:
    print("Четвертая четверть")
elif y > 0:
    print("Вторая четверть")
else:
   print("Третья четверть")

 Функции

Определение функции начинается с выражения def, которое состоит из имени функции, набора скобок с параметрами и двоеточия. Параметры в скобках необязательны.

def function(<параметры>):
     <code>
    return <данные>

Пример.

def max(a, b):
     if a > b:
        return a
     else:
        return b
  

Выражение return прекращает выполнение функции и возвращает заданное  значение (называется возвращаемое значение). Ключевое слово не обязательно.

Аргументы - ключевые слова

Основные правила:

1. Ключевые аргументы указываются перечислением ключ=значение
2. При вызове функции,  аргументы определяются  по имени.
3. Это позволяет пропускать аргументы или размещать их не по порядку, поскольку интерпретатор Python может использовать предоставленные ключевые слова (ключи) для сопоставления значений с параметрами.

Пример. Используем ключевые слова  name (имя), age (возраст) для функции person():

# Определение функции

def person( name, age ):
    print("Name: " + name + " age: " + str(age))

# Вызов функции person

person( age = 24,   name = "Никита" )
person( name = "Мария",  age = 22 )

Результат:

Name: Никита age: 24
Name: Мария age: 22

Словарь. Dict()

Словарь – это неупорядоченный набор элементов, в котором доступ к элементу выполняется по ключу.

Здесь два ключевых слова:

• неупорядоченный набор элементов
• доступ к элементу выполняется по ключу

В Python тип данных «словарь» называется dict ( от «dictionary»)

Словарь хранит пары «ключ-значение».

• Ключом элемента может быть любой неизменяемый тип данных, например, число, символьная строка или кортеж.
• Значение элемента может быть любого типа данных.

Основные свойства словаря:

• Основное преимущество использования словарей – возможность обратиться к значению по ключу за одно обращение к массиву данных. Сложность  поиска значения O(1). Для сравнения сложность поиска в списке О(n).
• Другая важная операция словаря –  in проверка наличия ключа в словаре. Операция in также работает за O(1) , для списка это значение рано O(N).
• Элементы словаря не упорядочены, поэтому невозможно указать для какого-то элемента его соседей - предыдущий или следующий элементы.
• Можно выполнить сортировку  словаря по ключу или по значению.
• Ключом может быть произвольный неизменяемый тип данных: целые и действительные числа, строки, кортежи.
• Значением элемента словаря может быть любой тип данных.

Словарь поддерживает три операции:

• Добавление пары
• Поиск значения по ключу
• Удаление пары по ключу

Основные операции

Перебор элементов словаря

Перебор по ключу

     for key in d:       print(key, end=' ')                # a b c e

  вариант

     for key in d.keys:       print(key, end=' ')                # a b c e

Перебор значений словаря

     for v in d.values():
        print(v, end=' ')                  # 1 2 3 4

Перебор в виде кортежа («ключ:значение»):

    for x in d.items():
    print(x, end=' ')        # {'a': 1, 'b': 2, 'c': 3, 'd': 4}         

Замечание.

Более точно, здесь используется представления словаря. Представления во многом похожи на списки, но они остаются связанными со своим исходным словарём и изменяются, если менять значения элементов словаря.  Для представлений:

• метод keys возвращает представление ключей всех элементов.
• метод values возвращает представление всех значений.
• метод items возвращает представление всех пар (кортежей) из ключей и значений.

Проверка на наличие ключа в словаре Python

if 'e' in d:
    print ("True")
else:
  print("False")

Длина словаря в Python

d = {'a': 1, 'b': 2, 'c': 3, 'd': 4}
print(len(d))    # 4 пары

Преобразование в список

list(d)
print(list(d))             # ['a', 'b', 'c', 'd']

Сортировка словаря

Сортировка словаря выполняется с использованием функции sorted().

Сортировка по ключам

for key in sorted(d):
    print(key, end=' ')        # a b c e

Сортировка по значениям

for key, val in sorted(d.items(), key= lambda x: x[0]):
    print(val, end=' ')          # 1 2 3 4

здесь x[0]-сортировка по параметру key, x[1]-сортировка по параметру val

Вывод результатов сортировки в новый (другой) словарь

d_sort = {k: val for k, val in sorted(d.items(), key = lambda x: x[0])}

Примеры

Сортировка по возрастанию ключей

d = {'a':10,'b':0, 'c':1,'d':4}
d1 = {key:val for  key, val in  sorted(d.items(), key = lambda x: x[0] )}
print(d1)               # {'a': 10, 'b': 0, 'c': 1, 'd': 4

Сортировка по возрастанию значений

d1 = {key:val for  key, val in  sorted(d.items(), key = lambda x: x[1] )}
print(d1)               # {'b': 0, 'c': 1, 'd': 4, 'a': 10}

Сортировка по убыванию значений

d1 = {k: val for k,val in sorted(d.items(), key = lambda x: x[1], reverse=1)}
print(d1)               # {'a': 10, 'd': 4, 'c': 1, 'b': 0}       

 Исключения

 Исключения - это ошибки, которые приводят к сбою программ. Они часто происходят из-за плохого ввода или ошибок программирования. Наша задача-предвидеть и обрабатывать эти исключения, чтобы предотвратить сбои в наших программах.

try:

    <code>

except <error>:

    <code>

else:

    <code>

Множества. set()

Множества   set{} – последовательность уникальных объектов.

Свойства:

• Множество не содержит дубликаты элементов
• Элементы не индексируются, поэтому множества не поддерживают никаких операций среза и индексирования.
• Элементами множества может быть любой неизменяемый тип данных: числа, строки, кортежи.
• Порядок элементов не определён

Действия, которые можно выполнять с множеством:

• добавлять и удалять элементы
• проверять принадлежность элемента множествуперебирать его элементы
• выполнять операции над множествами (объединение, пересечение, разность).

  Основные операции

Создание множества

Множество создается  перечислением в фигурных скобках. Например:

a = {1, 2, 3}

Исключением является пустое множество:

a = set()   # a -- множество

a = {}      # a -- не пустое множество, а пустой словарь!

Если функции set() передать в качестве параметра список, строку или кортеж, то она вернет множество, составленное из элементов списка, строки, кортежа. Примеры создания множества:

a  = {1, 2, 3, 4, 5}
a  = set(range(1, 6))
a  = set([1,2,3,4,5])

Обратите внимание! Функция set() может принимать только один параметр – один список, одну строку, один кортеж, поэтому вот передача нескольких параметров приведет к ошибке

     a  = set(1,2,3,4,5) <- TypeError: set expected at most 1 argument, got 5

Можно создать множество из последовательности, записав последовательность в фигурных скобках

a  = {1, 2, 3, 4, 5}

Доступ к элементам множества

При помощи цикла for можно перебрать все элементы множества:

a = {2, 3, 5, 7, 11}
for x in a:
    print(x)

Из множества можно сделать список при помощи функции list:

a = {1, 2, 3, 4, 5}
b = list(a)
print(b)             #[1, 2, 3, 4, 5]

Добавление элементов во множество.  Функция add()

a.add(6)
 print(a, end=" ")    #{1, 2, 3, 4, 5, 6}

Удаление элемента из множеств.  Метод  discard()

a.discard(6)        #{1, 2, 3, 4, 5}

Объединение множеств

Объединение этих двух множеств — это множество со всеми элементами обеих множеств. При выполнении операции объединения, дубликаты игнорируются.

Метод union() позволяет:

• объединить несколько множеств
• объединить множества, списки и кортежи

Метод union()  

set_x = {1, 2, 3}
set_y = {4, 1, 2}
set_z = set_x.union(set_y)
print(set_z)                    #{1, 2, 3, 4}

    Объединение множества, списков и кортежей

sets = {0, 1, 2, 3}
lists = [5, 6, 7]
tuples = (7, 8, 9)

z = sets.union(lists, tuples)
print(z)                       #{0, 1, 2, 3, 5, 6, 7, 8, 9}

Бинарный оператор |

Все объекты должны быть множествами

set_z = set_x | set_y

print(set_z)           #{1, 2, 3, 4}

Пересечение множеств. Оператор &

Пересечение представляет собой множество элементов, которые являются общими для А и для В.

set_x = {1, 2, 3}
set_y = {4, 1, 2}

set_z = set_x & set_y
print(set_z)              # {1, 2}

Разность множеств. Оператор –

Разность множеств элементы множества, которых нет в одной или более последовательности 

set_x = {1, 2, 3}
set_y = {4, 1, 2}
set_z = set_x - set_y
print(set_z)                # {3}

Краткое введение в ООП

Объектно-ориентированное программирование (ООП) – технология разработки сложного программного обеспечения, в которой программа строится в виде совокупности объектов и их взаимосвязей.

Объединение данных и действий, производимых над этими данными, в единое целое, которое называется объектом – является одним из основных принципов ООП.

Основными понятиями являются понятие класса и объекта.

Класс является типом данных, определяемым пользователем и представляет собой структуру в виде данных и методов для работы с данными.

Формально Класс — это шаблон, по которому будет сделан объект.

Объект является экземпляром класса. Объект  и экземпляр - это одно и то же.

Вот пример. Форма для изготовления печенья – это класс, а само печенье это объект или экземпляр класса, т.е. это конкретное изделие. Печенье имеет размеры, цвет, состав – это атрибуты класса. Также в классе описываются методы, которые предназначены для чтения или изменения данных объекта.

В Python характеристики  объекта, называются атрибутами, а действия, которые мы можем проделывать с объектами, — методами. Методами в Python  называют функции, которые определяются внутри класса.

Объект = атрибуты + методы 

self

 Рассотрим  пример. Пусть у нас есть объект  мяч  - ball , обладающий атрибутами и методами.

Атрибуты мяча  могут быть:

ball.color  - цвет, например, красный
ball.size  -  размер, например, маленький
ball.price – стоимость мяча

Методы нашего объекта  могут выглядеть следующим образом:

ball.Move( )  - перемещение мяча
ball.Show( ) – вывести характеристики (атрибуты) мяча  на экран 

Переменная  self  указывает на конкретный объект экземпляра класса. Доступ к атрибутам   и методам  осуществляется через переменную self.  Это главное назначение переменной self.

Предположим мы создали три мяча - экземпляры класса Ball: ball1, ball2, ball3.  Мячи могут иметь разные характеристики, например, как в таблице.

Переменная  self  представляет ссылку на экземпляр класса, т.е. содержит адрес объекта. Всем методам класса  автоматически передается эта ссылка.

Предположим в классе Ball  имеется  метод  Show( ) – вывести характеристики мяча.

При создании трех мячей – трех экземпляров  класса Ball, каждый мяч имеет свои значения атрибутов – свои характеристики, а вот метод    Show( ) будет только в единственном экземпляре - один для всех трех мячей. Спрашивается как метод Show() может определить  характеристики какого мяча  выводить  на экран? На помощь приходит переменная self, которая знает адрес каждого из трех  экземпляров  класса.  Метод получает  доступ к атрибутам требуемого  объекта с помощью переменной  self. Как это делается рассмотрим несколько позже.

Что такое точка?

 В приведенных примерах между именем объекта и именем атрибута или метода стоит точка. Это обозначение, которое применяется, когда нужно обратиться к атрибутам или методами объекта      

объект.атрибут, например, так можно изменить цвет мяча  ball.color = «зеленый»

объект.метод()  например,  так можно переместить мяч      ball. Move( )

 Создание класса в Python:

 Определение класса начинается с ключевого слова class, после него следует имя класса и двоеточие.

class имя_класса:
           # тело класса 
          # объявление конструктора
          # объявление атрибутов
          # объявление методов 

Основные определения 

Метод __init__  или Конструктор

 В процессе создания объекта  атрибутам класса необходимо задать начальные значения. Это действие  называется инициализацией.  Для этой цели используется   специальный метод __init__(), который  называется методом инициализации или  конструктором.    Метод __init__ запускается при создании экземпляра класса - один раз. Обратите внимание на двойные подчёркивания в начале и в конце имени.
Синтаксис метода следующий:

def __init__(self, параметр1, параметр2):
              self.атрибут1 = параметр1
             self.атрибут2 = параметр2

Два символа подчеркивания в начале  __init__ и  два символа подчеркивания в конце обязательны. Параметров у конструктора  параметр1, параметр2 может быть сколько угодно, но первым дожен быть параметр  self.

 Атрибуты и методы класса

 Атрибуты класса

Характеристики  объекта, называются атрибутами и записываются в внутри конструктора с помощью переменной self.   Доступ к атрибутам осуществляется через переменную self.

Например, класс имеет атрибут  цвет – color, он должен быть записан как

     self.color  

Методы  класса

Методы класса создаются посредством ключевого слова def , имени метода , слова self, которое всегда указывается как первый параметр метода

def имя метода(self, передаваемые параметры):
       # тело метода

Пример. Создаем метод, который выводит на печать характеристики мяча

 def Show(self):
       print("Мяч: ", self.color, self.size )

 Мы определили атрибуты класса и методы. Таким образом,  класс  для нашего мяча будет выглядеть так:

class Ball:
    def __init__(self, color, size):
         self.color =  color
         self.size = size
    def Show(self):
       print("Мяч: ", self.color, self.size )

 Создание экземпляра

 Для создания объекта — экземпляра класса достаточно вызвать класс по имени и задать параметры конструктора. Пример. Предположим у нас есть конструктор

              def __init__(self, color, size): 

Подставляем на место формальных параметров, которые указаны  в конструкторе

def __init__(self, color, size)  фактические, например,  для параметра color указываем "красный,",   а для  size задаем зачение "маленький".

Создание экземпларя будет выглядеть следующим образом.

ball = Ball("красный,","маленький")

 Переменная self автоматически примет значение ссылки при создании экземпляра класса.Обратиться к методу Show() можно так:

 ball.Show()

Будет выведено:

Мяч:  красный, маленький