Содержание лекции:

1. Типы данных, типы коллекций

2. Операторы

3. Числа и действия с ними

4. Строки и действия с ними

5. Списки и действия с ними 

6. Словари и действия с ними 

7. Множества и действия с ними 

Запись второго занятия вы можете посмотреть по этой ссылке.

1. Типы данных, типы коллекций

Типы данных

Язык Python характерен своей неявной динамической типизацией. Это означает, что при задании какой-либо переменной, нам не надо объявлять ее тип (число, строка, и т.д.), как это сделано в языке С. То есть достаточно просто присвоить ей значение и в зависимости от того, какое это значение, Python сам определит тип переменной.

Говоря о присвоении значения переменной, стоит отметить, что в реальности происходит процесс связывания ссылки на объект с объектом, находящемся в памяти посредством оператора = . Таким образом в инструкции типа var = 12, "var" - ссылка на объект, а "12" - объект целочисленного типа. Каждый раз, когда в тексте будет упоминаться процесс присвоения значения - помните, что в этот момент происходит процесс связывания ссылок с объектами.

None type - тип, представляющий отсутствие значения.

• None - неопределенное значение переменной.

Зачастую, чтобы отловить какую-то ошибку записи значения куда-либо, мы применяем проверку на отсутствие значения в переменной, ячейке базы данных, таблицы и т.д. или используем в качестве значения по умолчанию. 

null_variable = None

not_null_variable = 'something'

if null_variable == None:

    print('null_variable is None')

else:

    print('null_variable is not None')

if not_null_variable == None:

    print('not_null_variable is None')

else:

    print('not_null_variable is not None')

Логический тип данных (bool) удобно использовать, когда результатом условия может быть только "да" или "нет". В математическом представлении True = 1, False = 0.

• True - логическая переменная, истина
• False - логическая переменная, ложь

a = 0

b = 0

print(a < b)

print(a > b)

print(a == b)

Целые числа используются для стандартных арифметических операций, когда нас не интересует точность, до n-го знака.

• int - целое число

Числа, применяющиеся для точных вычислений до n-го знака после запятой - числа с плавающей точкой. При арифметическом взаимодействии двух типов (int и float), результат всегда будет иметь тип float.

• float - число с плавающей точкой

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

• complex - комплексное число

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

• str - строка

Типы коллекций

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

• list - список

Кортеж - это список, который после создания нельзя изменить, очень полезно его использовать для защиты "от дурака", чтобы по ошибке данные не были изменены.

• tuple - кортеж

Множества - коллекции для неповторяющихся данных, хранящие эти данные в случайном порядке.

• set - множество
• frozenset - неизменяемое множество

Словари - являются набором пар "ключ"-"значение", довольно удобный тип данных для формирований структур. 

• dict - словарь

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

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

• bytes - байты

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

• bytearray - массивы байт

2. Операторы

Арифметические операторы

Оператором является элемент выражения, который указывает на то, какое действие необходимо произвести между элементами. То есть, в выражении "21 - 4" символ "-" является оператором, указывающим на то, что нужно произвести вычитание. "21" и "4" при этом называются операндами.

Операторы сравнения (реляционные)

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

Побитовые операторы

Данные операторы работают с данными в двоичной системе счисления. Например число 13 в двоичной системе будет равно 1101

Логические операторы

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

Данные операторы участвуют в поиске данных в некоторой последовательности.

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

Данные операторы помогают сравнить размещение двух объектов в памяти компьютера

Приоритет операторов

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

Например арифметическое выражение 2 + 2 * 2, как известно из курса математики, будет выполняться начиная с умножения. Тем самым умножение имеет более высокий приоритет, чем сложение. 

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

Как видно из рисунка, некоторые операторы размещены в одной общей ячейке. Это значит, что их приоритет находится на одном уровне. Также стоит добавить, что операторы присваивания обладают наименьшим приоритетом. 

3. Числа и действия с ними

Целочисленная арифметика

Для целых чисел определены операции +, -, * и **. Операция деления / для целых чисел возвращает вещественное число (значение типа float). Также функция возведения в степень возвращает значение типа float, если показатель степени — отрицательное число.

Но есть и специальная операция целочисленного деления, выполняющегося с отбрасыванием дробной части, которая обозначается // (она соответствует операции div в Паскале). Она возвращает целое число: целую часть частного. Другая близкая ей операция − это операция взятия остатка от деления, обозначаемая % (она соответствует операции mod в Паскале).

print(17 / 3)   # выведет 5.66666666667

print(17 // 3)  # выведет 5

print(17 % 3)   # выведет 2

Действительные числа

В этом разделе речь пойдет о действительных числах, имеющих тип float.

Обратите внимание, что если вы хотите считать с клавиатуры действительное число, то результат, возвращаемый функцией input() необходимо преобразовывать к типу float:

 x = float(input())

print(x)

Действительные (вещественные) числа представляются в виде чисел с десятичной точкой (а не запятой, как принято при записи десятичных дробей в русских текстах). Для записи очень больших или очень маленьких по модулю чисел используется так называемая запись «с плавающей точкой». В этом случае число представляется в виде некоторой десятичной дроби, называемой мантиссой, умноженной на целочисленную степень десяти (порядок). Например, расстояние от Земли до Солнца равно 1.496·1011, а масса молекулы воды 2.99·10-23.

Числа с плавающей точкой в программах на языке Питон, а также при вводе и выводе записываются так: сначала пишется мантисса, затем пишется буква e, затем пишется порядок. Пробелы внутри этой записи не ставятся. Например, указанные выше константы можно записать в виде 1.496e11 и 2.99e-23. Перед самим числом также может стоять знак минус.

Напомним, что результатом операции деления / всегда является действительное число (float), в то время как результатом операции // является целое число (int).

Преобразование действительных чисел к целому производится с округлением в сторону нуля, то есть int(1.7) == 1, int(-1.7) == -1.

Библиотека math

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

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

import math

Например, пусть мы хотим округлять вещественные числа до ближайшего целого числа вверх. Соответствующая функция ceil от одного аргумента вызывается, например, так: math.ceil(x) (то есть явно указывается, что из модуля math используется функция ceil). Вместо числа x может быть любое число, переменная или выражение. Функция возвращает значение, которое можно вывести на экран, присвоить другой переменной или использовать в выражении:

import math

x = math.ceil(4.2)

y = math.ceil(4.8)

print(x)

print(y)

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

from math import ceil

x = 7 / 2

y = ceil(x)

print(y)

# или так:

from math import *

x = 7 / 2

y = ceil(x)

print(y)

Ниже приведен список основных функций модуля math. Более подробное описание этих функций можно найти на сайте с документацией языка Питон.

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

Основные функции библиотека math: округление

Основные функции библиотека math: корни, логарифмы

Основные функции библиотека math: тригонометрия

4. Строки и действия с ними

Строка считывается со стандартного ввода функцией input(). Напомним, что для двух строк определена операция сложения (конкатенации), также определена операция умножения строки на число.

Строка состоит из последовательности символов. Узнать количество символов (длину строки) можно при помощи функции len().

Любой другой объект в Питоне можно перевести к строке, которая ему соответствует. Для этого нужно вызвать функцию str(), передав ей в качестве параметра объект, переводимый в строку.

На самом деле каждая строка, с точки зрения Питона, — это объект класса str. Чтобы получить по объекту другой объект другого класса, как-то ему соответствующий, можно использовать функцию приведения. Пример: int — класс для целых чисел. Перевод строки в число осуществляется функцией int().

s = input()

print(len(s))

t = input()

number = int(t)

u = str(number)

print(s * 3)

print(s + ' ' + u)

Срез (slice) — извлечение из данной строки одного символа или некоторого фрагмента подстроки или подпоследовательности.

Есть три формы срезов. Самая простая форма среза: взятие одного символа строки, а именно, S[i] — это срез, состоящий из одного символа, который имеет номер i. При этом считается, что нумерация начинается с числа 0. 

То есть если S = 'Hello', то S[0] == 'H', S[1] == 'e', S[2] == 'l', S[3] == 'l', S[4] == 'o'.

Заметим, что в Питоне нет отдельного типа для символов строки. Каждый объект, который получается в результате среза S[i] — это тоже строка типа str.

Номера символов в строке (а также в других структурах данных: списках, кортежах) называются индексом.

Если указать отрицательное значение индекса, то номер будет отсчитываться с конца, начиная с номера -1. 

То есть S[-1] == 'o', S[-2] == 'l', S[-3] == 'l', S[-4] == 'e', S[-5] == 'H'.

Или в виде таблицы:

Если же номер символа в срезе строки S больше либо равен len(S), или меньше, чем -len(S), то при обращении к этому символу строки произойдет ошибка IndexError: string index out of range.

Срез с двумя параметрами: S[a:b] возвращает подстроку из b - a символов, начиная с символа c индексом a, то есть до символа с индексом b, не включая его. Например, S[1:4] == 'ell', то же самое получится если написать S[-4:-1]. Можно использовать как положительные, так и отрицательные индексы в одном срезе, например, S[1:-1] — это строка без первого и последнего символа (срез начинается с символа с индексом 1 и заканчивается индексом -1, не включая его).

При использовании такой формы среза ошибки IndexError никогда не возникает. Например, срез S[1:5] вернет строку 'ello', таким же будет результат, если сделать второй индекс очень большим, например, S[1:100] (если в строке не более 100 символов).

Если опустить второй параметр (но поставить двоеточие), то срез берется до конца строки. Например, чтобы удалить из строки первый символ (его индекс равен 0), можно взять срез S[1:]. Аналогично если опустить первый параметр, то можно взять срез от начала строки. То есть удалить из строки последний символ можно при помощи среза S[:-1]. Срез S[:] совпадает с самой строкой S.

Любые операции среза со строкой создают новые строки и никогда не меняют исходную строку. В Питоне строки вообще являются неизменяемыми, их невозможно изменить. Можно лишь в старую переменную присвоить новую строку.

Если задать срез с тремя параметрами S[a:b:d], то третий параметр задает шаг, как в случае с функцией range, то есть будут взяты символы с индексами a, a + d, a + 2 * d и т. д. При задании значения третьего параметра, равному 2, в срез попадает каждый второй символ, а если взять значение среза, равное -1, то символы будут идти в обратном порядке. Например, можно перевернуть строку срезом S[::-1].

s = 'abcdefg'

print(s[1])

print(s[-1])

print(s[1:3])

print(s[1:-1])

print(s[:3])

print(s[2:])

print(s[:-1])

print(s[::2])

print(s[1::2])

print(s[::-1])

5. Списки и действия с ними 

Списками в Python называются массивы. Они могут содержать данные различных типов. Для создания списка автоматически можно использовать метод list():

>>> list('Python')

['P','y','t','h','o','n']

Также можно это сделать напрямую, присвоив переменной значение типа list:

# Пустой список

>>> s = []

# список с данными разных типов

>>> l = ['s', 'p', ['isok'], 2]

>>> s

[]

>>> l

['s', 'p', ['isok'], 2]

Также можно использовать генераторы списков:

>>> a = ['P', 'y', 't', 'h', 'o', 'n']

>>> b = [i * 3 for i in a]

>>> b

['PPP', 'yyy', 'ttt', 'hhh', 'ooo', 'nnn']

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

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

Методы списков вызываются по схеме: list.method(). Ниже будут перечислены полезные методы для работы со списками:

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

>>> var = ['l', 'i', 's', 't']

>>> var.append('a')

>>> print(var)

['l', 'i', 's', 't', 'a']

extend(L) - расширяет список, добавляя к концу все элементы списка L

>>> var = ['l', 'i', 's', 't']

>>> var.extend(['l', 'i', 's', 't'])

>>> print(var)

['l', 'i', 's', 't', 'l', 'i', 's', 't']

insert(i, a) - вставляет на i позицию элемент a

>>> var = ['l', 'i', 's', 't']

>>> var.insert(2,'a')

>>> print(var)

['l', 'i', 'a', 's', 't']

remove(a) - удаляет первый элемент в списке со значением a, возвращает ошибку, если такого элемента не существует

>>> var = ['l', 'i', 's', 't', 't']

>>> var.remove('t')

>>> print(var)

['l', 'i', 's', 't']

pop(i) - удаляет i-ый элемент и возвращает его, если индекс не указан, удаляет последний элемент

>>> var = ['l', 'i', 's', 't']

>>> var.pop(0)

'l'

>>> print(var)

['i', 's', 't']

index(a) - возвращает индекс элемента a (индексация начинается с 0)

>>> var = ['l', 'i', 's', 't']

>>> var.index('t')

3

count(a) - возвращает количество элементов со значением a

>>> var = ['l', 'i', 's', 't']

>>> var.count('t')

1

sort([key = функция]) - сортирует список на основе функции, можно не прописывать функцию, тогда сортировка будет происходить по встроенному алгоритму

>>> var = ['l', 'i', 's', 't']

>>> var.sort()

>>> print(var)

['i', 'l', 's', 't']

reverse() - разворачивает список

>>> var = ['l', 'i', 's', 't']

>>> var.reverse()

>>> print(var)

['t', 's', 'i', 'l']

copy() - поверхностная копия списка, при присвоении переменной копии списка, значение данного списка не изменяется в случае изменения первого. Если переменной присвоить список через "=", тогда значение этой переменной будет меняться при изменении оригинала

>>> var = ['l', 'i', 's', 't']

>>> asd = var.copy()

>>> print(asd)

['l', 'i', 's', 't']

>>> var = ['l', 'i', 's', 't']

>>> asd = var

>>> print(asd)

['l', 'i', 's', 't']

>>> print(var)

['l', 'i', 's', 't']

>>> var.reverse()

>>> print(asd)

['t', 's', 'i', 'l']

>>> print(var)

['t', 's', 'i', 'l']

>>> var = ['l', 'i', 's', 't']

>>> asd = var.copy()

>>> print(asd)

['l', 'i', 's', 't']

>>> print(var)

['l', 'i', 's', 't']

>>> var.reverse()

>>> print(asd)

['l', 'i', 's', 't']

>>> print(var)

['t', 's', 'i', 'l']

clear() - очищает список

>>> var = ['l', 'i', 's', 't']

>>> var.clear()

>>> print(var)

[]

6. Словари и действия с ними 

Словари - это неупорядоченные коллекции пар "ключ-значение". В качестве ключей могут использоваться ссылки на хешируемые объекты, а в качестве значений - ссылки на объекты любого типа. Т.к. словари являются неупорядоченными коллекциями, то к ним не применяется понятие индекса элемента и не применяется операция извлечения среза.

Хешируемые объекты - объекты, которые имеют метод __hash__() и могут участвовать в операциях сравнения на равенство с помощью метода __eq__().

Метод __hash__() возвращает одно и то же значение объекта на протяжении его жизненного цикла.

Чтобы создать словарь можно использовать метод dict():

>>> d = dict(short='dict', long='dictionary')

>>> print(d)

{'short': 'dict', 'long': 'dictionary'}

>>> d = dict([(1, 1), (2, 4)])

>>> print(d)

{1: 1, 2: 4}

В созданных выше словарях мы получили пары "ключ-значение", в частности ключ short и соответствующее ему значение dict.Также можно создать словарь следующим образом:

>>> d = {}

>>> print(d)

{}

>>> d = {'dict': 1, 'dictionary': 2}

>>> print(d)

{'dict': 1, 'dictionary': 2}

Еще один способ - использовать метод fromkeys():

>>> d = dict.fromkeys(['a', 'b'])

>>> print(d)

{'a': None, 'b': None}

>>> d = dict.fromkeys(['a', 'b'], 100)

>>> print(d)

{'a': 100, 'b': 100}

Также можно использовать генератор словарей:

>>> d = {a: a ** 2 for a in range(7)}

>>> print(d)

{0: 0, 1: 1, 2: 4, 3: 9, 4: 16, 5: 25, 6: 36}

Как можно работать со словарями:

>>> d = {1: 2, 2: 4, 3: 9}

>>> print(d[1])

2

>>> d[4] = 4 ** 2

>>> print(d)

{1: 2, 2: 4, 3: 9, 4: 16}

>>> d['1']

Traceback (most recent call last):

File "", line 1, in

    d['1']

KeyError: '1'

В первом случае мы обратились к ключу "1", после чего получили вывод на экран его значения "2". Затем мы создали новый ключ "4" и присвоили ему значение "16", после чего эта пара добавилась к нашему словарю. В последнем примере мы попробовали обратиться к несуществующему ключу, поскольку значение '1' стоит в кавычках, а значит это другой тип данных, которого нет в нашем словаре, после чего получили сообщение о том, что такого ключа нет.

Методы для работы со словарями

Методы вызываются по схеме: dict.method(). Ниже будут перечислены полезные методы для работы со словарями:

clear() - очищает словарь

>>> d = {'a': 1, 'b': 2}

>>> d.clear()

>>> print(d)

{}

copy() - возвращает копию словаря

>>> d = {'a': 1, 'b': 2}

>>> b = d.copy()

>>> print(b)

{'a': 1, 'b': 2}

fromkeys(seq[,value]) - создает словарь с ключами из seq и значением value

>>> d.fromkeys(['a', 'b'], 10)

{'a' : 10, 'b' : 10}

get(key[, default]) - возвращает значение ключа, но если его нет, возвращает default

>>> d = {'a': 1, 'b': 2}

>>> d.get('a')

1

items() - возвращает пары (ключ, значение)

>>> d = {'a': 1, 'b': 2}

>>> d.items()

dict_items([('a', 1), ('b', 2)])

keys() - возвращает ключи в словаре

>>> d = {'a': 1, 'b': 2}

>>> print(d.keys())

dict_keys(['a', 'b'])

pop(key[, default]) - удаляет ключ и возвращает значение. Если ключа нет, возвращает default

>>> d = {'a': 1, 'b': 2}

>>> d.pop('a')

1

>>> print(d)

{'b': 2}

popitem() - удаляет и возвращает пару (ключ, значение) с конца

>>> d = {'a': 1, 'b': 2}

>>> d.popitem()

('b', 2)

>>> print(d)

{'a': 1}

setdefault(key[, default]) - возвращает значение ключа, но если его нет, создает ключ с значением default

>>> d = {'a': 1, 'b': 2}

>>> d.setdefault('e', 6)

6

>>> d.setdefault('f')

>>> print(d)

{'a': 1, 'b': 2, 'e': 6, 'f': None}

update([other]) - обновляет словарь, добавляя пары (ключ, значение) из other. Существующие ключи перезаписываются

>>> d = {'a': 1, 'b': 2}

>>> d.update({'d':5})

>>> print(d)

{'a': 1, 'b': 2, 'd': 5}

values() - возвращает значения в словаре

>>> d = {'a': 1, 'b': 2}

>>> d.values()

dict_values([1, 2])

7. Множества и действия с ними

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

>>> a = set()

>>> print(a)

set()

>>> a = set('hello')

>>> print(a)

{'h', 'o', 'l', 'e'}

>>> a = {'a', 'b', 'c', 'd'}

>>> print(a)

{'b', 'c', 'a', 'd'}

>>> a = {i ** 2 for i in range(10)}

>>> print(a)

{0, 1, 4, 81, 64, 9, 16, 49, 25, 36}

Множества удобно использовать для удаления повторяющихся элементов:

>>> words = ['hello', 'daddy', 'hello', 'mum']

>>> set(words)

{'hello', 'daddy', 'mum'}

Методы для работы со множествами

Методы множеств, в основном, вызываются по схеме: set.method(). Ниже будут перечислены полезные методы для работы с множествами:

len(s) - число элементов в множестве (размер множества)

>>> a = {'a', 'b', 'c', 'd'}

>>> len(a)

4

• x in s - принадлежит ли x множеству s

>>> a = {'a', 'b', 'c', 'd'}

>>> 'a' in a

True

• isdisjoint(other) - истина, если set и other не имеют общих элементов

>>> a = {'a', 'b', 'c', 'd'}

>>> a.isdisjoint('a')

False

>>> a.isdisjoint('f')

True

• issubset(other) или set <= other - истина, если все элементы set принадлежат other

>>> a = {'a', 'b', 'c', 'd'}

>>> a.issubset({'a', 'b', 'c', 'd','f','e'})

True

• issuperset(other) или set >= other - аналогично
• union(other, ...) или set | other | ... - возвращает объединение нескольких множеств

>>> a = {'a', 'b', 'c', 'd'}

>>> a.union({'f','d'})

{'b', 'a', 'c', 'f', 'd'}

• intersection(other, ...) или set & other & ... - возвращает пересечение множеств

>>> a = {'a', 'b', 'c', 'd'}

>>> a.intersection({'f','a'})

{'a'}

• difference(other, ...) или set - other - ... -возвращает множество из всех элементов set, не принадлежащие ни одному из other

>>> a = {'a', 'b', 'c', 'd'}

>>> a.difference({'a','f','d'})

{'b', 'c'}

• symmetric_difference(other); set ^ other - возвращает множество из элементов, встречающихся в одном множестве, но не встречающиеся в обоих

>>> a = {'a', 'b', 'c', 'd'}

>>> a.symmetric_difference({'a','d'})

{'b', 'c'}

• copy() - копия множества

>>> a = {'a', 'b', 'c', 'd'}

>>> d = a.copy()

>>> print(d)

{'d', 'b', 'a', 'c'}

• update(other, ...); set |= other | ... - объединение множеств. Метод, вносящий изменения в множество

>>> a = {'a', 'b', 'c', 'd'}

>>> a.update({'w','z'})

>>> print(a)

{'z', 'b', 'a', 'c', 'w', 'd'}

• intersection_update(other, ...); set &= other & ... - пересечение множеств. Метод, вносящий изменения в множество

>>> a = {'a', 'b', 'c', 'd'}

>>> a.intersection_update({'a','d'})

>>> print(a)

{'a', 'd'}

• difference_update(other, ...); set -= other | ... - вычитание множеств. Метод, вносящий изменения в множество

 >>> a = {'a', 'b', 'c', 'd'}

>>> a.difference_update({'a','d'})

>>> print(a)

{'b', 'c'}

• symmetric_difference_update(other); set ^= other - множество из элементов, встречающихся в одном множестве, но не встречающиеся в обоих. Метод, вносящий изменения в множество

>>> a = {'a', 'b', 'c', 'd'}

>>> a.symmetric_difference_update({'a','b'})

>>> print(a)

{'c', 'd'}

• add(elem) - добавляет элемент в множество. Метод, вносящий изменения в множество

>>> a = {'a', 'b', 'c', 'd'}

>>> a.add('r')

>>> print(a)

{'r', 'c', 'a', 'd', 'b'}

• remove(elem) - удаляет элемент из множества. KeyError, если такого элемента не существует. Метод, вносящий изменения в множество

>>> a = {'a', 'b', 'c', 'd'}

>>> a.remove('b')

>>> print(a)

{'c', 'a', 'd'}

• discard(elem) - удаляет элемент, если он находится в множестве. Метод, вносящий изменения в множество

>>> a = {'a', 'b', 'c', 'd'}

>>> a.discard('c')

>>> print(a)

{'a', 'b', 'd'}

• pop() - удаляет первый элемент из множества. Так как множества не упорядочены, нельзя точно сказать, какой элемент будет первым. Метод, вносящий изменения в множество

>>> a = {'a', 'b', 'c', 'd'}

>>> a.pop()

'c'

>>> print(a)

{'a', 'b', 'd'}

• clear() - очистка множества. Метод, вносящий изменения в множество

>>> a = {'a', 'b', 'c', 'd'}

>>> a.clear()

>>> print(a)

set()

frozenset: единственное отличие от set заключается в том, что frozenset не меняется, соответственно, к frozenset можно применить только те методы, которые не меняют множество.

Практические задания:

Задание 1

Мы предлагаем вам потренироваться с логическими и побитовыми операторами. Ниже будут приведены выражения и ответы к ним. Попробуйте мысленно или на бумаге решить эти выражения. 

Для:

a = True

b = False

Решите:

1. a and b

2. (a and b) or b

3. (a and b) or not (a and b)

4. a and b or not (a or b) or b

5. b and b or not a and (a or b or a) or not (a or b)

6. 1 << 2

7. 1 & 0 | 1 >> 1

8. 1 & 0 | 1 >> 0

9. (7 & 9) ^ (1 | 0) & (3 & 4)

Задание 2

Напишите код, который получает на вход любое число, а на выходе сообщает четное ли это число, или нет

Задание 3

Вспомните хотя бы пять стран, в которых вам хотелось бы побывать:

• Сохраните названия стран в списке. Проследите за тем, чтобы список не хранился в алфавитном порядке
• Выведите список в исходном порядке
• Выведите список в алфавитном порядке
• Выведите список в обратном алфавитном порядке 
• Измените порядок элементов вызовом reverse(). Выведите новый список

Домашнее задание 2:

Задание 1:

Написать код, который бы решал заданное линейное уравнение в виде: kx + b = 0. На вход: k, b. На выходе - корень уравнения

Примеры уравнений:

14x - 5 = 0

6x + 1 = 0

4x + 8 = 0

- 3,2x + 1,12 = 0

Задание 2:

Создайте словарь, в котором значения - месяц, а ключ - порядковый номер. Выведите его.

Измените название любых 2-ух месяцев (название можно придумать самому). Выведите изменение

Добавьте новый 13-ый месяц (название можно придумать самому). Выведите весь словарь