Ok python!
Для начинающих
Курс для начинающих
«Python за час»
Наш ознакомительный
курс для начинающих «Python за час» рассчитан на быстрое стартовое знакомство с
основами синтаксиса Пайтона. Его можно считать первым шагом на пути полноценного освоения этого замечательного языка программирования. Курс состоит
из последовательности примеров учебника, сопровождаемых подробными комментариями, что позволит вам быстрее погрузиться в атмосферу ядра языка. При этом вовсе необязательно
стремиться пройти весь курс за час или за день. Занимайтесь с той скоростью, с которой позволяют вам ваши способности и время, не забывая набирать
исходный код в редакторе и стараясь приступать к прохождению очередного примера лишь тогда, когда будет закончен полный разбор предыдущего. Однако, если какой-то пример вызовет у вас
затруднения, можете смело пропускать его и двигаться дальше, т.к. позже он наверняка будет рассмотрен в учебнике более подробно. В любом случае, даже простое чтение курса позволит вам
получить достаточно первичных навыков для эффективного чтения учебника и решения
задач нашего сборника на втором этапе учебного процесса.
- Чтобы посмотреть результат выполнения исходного кода примеров курса, используйте кнопку «Результат».
- Чтобы окно консоли после выполнения скрипта сразу не закрывалось, дописывайте в конец скрипта инструкцию input().
-
Если в ходе прохождения курса у вас возникнут трудности или будут обнаружены какие-либо ошибки пишите мне в соцсети
(в первую очередь стараюсь отвечать подписчикам).
pythonCodes
# Ф-ция print выводит значения на экран,
# приводя их перед выводом к строкам.
print('Привет, мир!')
# В Python предусмотрены только однострочные
# комментарии. Пишем их после решетки через
# пробел и стараемся завершать точкой.
# Нажмите кнопку «Результат»Привет, мир!
# Выводим через запятую сразу несколько значений.
# 5 плюс 0.7 (по умол. использ. пробел, т.е. sep=' ').
print(5, 'плюс', 0.7)
# Выводим значения, разделяя их запятой с пробелом и
# закончив вывод двойным переходом на новую строку.
print('a', 'b', 'c', sep=', ', end='\n\n')
# Выводим значения, разделяя их звездочкой и
# закончив вывод строкой ' = ?'.
print('a', 'b', 'c', sep='*', end=' = ?')
# Аргумент sep задает разделитель выводимых значений,
# а end - символы в конце вывода (по умол. end='\n').
# Нажмите кнопку «Результат»5 плюс 0.7
a, b, c
a*b*c = ?
# Для ввода используется ф-ция input().
# Я ввел 'Привет, мир!'
s = input('Введите строку: ')
# А для вывода print().
print('\nВы ввели:', s)Введите строку: Привет, мир!
Вы ввели: Привет, мир!.
# В переменных мы храним значения. В именах можно
# использовать буквы в любом регистре, _ и цифры,
# но с цифр имена начинать запрещено.
# Сохранили в переменной целое число.
num_1 = 7
# Сохранили в переменной вещественное число.
num_2 = 7.45
# Вывели их сумму на экран.
print('7 + 7.45 =', num_1 + num_2) 7 + 7.45 = 14.45
# Еще примеры имен с ошибками и без.
# Начинается со знака подчеркивания.
_f = 7
# Начинается со знака подчеркивания и включает
# русские буквы, одна из которых заглавная.
_Чаво = 'А ничаво!'
# Начинается с заглавной буквы.
St123 = {1, 2, 3}
# Смешивать буквы не рекомендуется.
set_имя = 'Никто'
# Змеиная нотация (для переменных и функций).
go_to_str = True
# Верблюжья нотация.
goToStr = True
# Стиль CupWords (для классов).
GoToStr = True
# Смешивать нотации можно, но не рекомендуется.
goTo_str = False
# Эти имена содержат недопустимые компбинации
# символов: 15var_1, $Var2 или var 3.
# Кстати, имена в Python регистрозависимы.
var_1 = 1
Var_1 = 2
VAR_1 = 3
# Выведем и посмотрим.
print('var_1 хранит ', var_1, end='\n\n')
print('Var_1 хранит ', Var_1, end='\n\n')
print('VAR_1 хранит ', VAR_1) var_1 хранит 1
Var_1 хранит 2
VAR_1 хранит 3
# Python - язык с динамической типизацией, поэтому
# в переменных можно хранить объекты любых типов:
# сперва один, затем другой, меняя их по необходимости.
# Присвоим переменной целое число.
d = 33
# Проверим тип с помощью ф-ции type(obj).
print('Тип переменной d: ', type(d))
# Теперь присвоим той же переменной словарь.
d = {1: 'red', 2: 'green'}
# Тип по-прежнему int? (Выведет False).
print("Тип d все еще int?: ", isinstance(d, int))
# А какой тогда?
print("Новый тип переменной d: ", type(d)) Тип переменной d: <class 'int'>
Тип d все еще int?: False
Новый тип переменной d: <class 'dict'>
# За типами следим сами, иначе получим ошибку.
# Присвоим переменной число с плавающей точкой.
d = 33.47
# Присвоим переменной строку.
s = '33.47'
# Попробуем сложить
res = d + s
# и затем вывести результат на экран.
print(res)
# Получили вполне ожидаемую ошибку. unsupported operand type(s) for +: 'float' and 'str'
# Просим ввести 1-е число с плавающей точкой.
d = input('Введите 1-е вещественное число: ')
# Просим ввести 2-е число с плавающей точкой.
s = input('Введите 2-е вещественное число: ')
# Я ввел 2.44 и 3.27 (см. Результат).
# Самостоятельно преобразуем строки в вещ-ные числа.
d = float(d)
s = float(s)
# А вот теперь сложим
res = d + s
# и выведем результат на экран.
print('d + s =', res) Введите 1-е вещественное число: 2.44
Введите 2-е вещественное число: 3.27
d + s = 5.71
# В Python для разделения инструкций в основном
# используются переводы строк. Поэтому в каждой
# строке стараются писать по одной инструкции.
# Имеем 4 инструкции по одной на каждой строке.
# Точку с запятой нигде не ставим.
a = 3.7
b = 5.2
c = a + b
# Выведет 8.9
print(c)
# -------------------------
# Конечно, точки с запятой ошибок не вызовут,
# но в Python так поступать не принято!!!
a = 3.7;
b = 5.2;
c = a + b;
# Опять же выведет 8.9
print(c); 8.9
8.9
# Математические операции с числами.
# Сложение и вычитание чисел.
res_1 = 3.46 + 1.22 - 35
# Получим -30.32 (вещ-ный рез-т).
print('3.46 + 1.22 - 35 =', res_1, end='\n\n')
# Деление и умножение чисел.
res_2 = 3.4/1.7 + 5*10
# Получим 52.0 (вещ-ный рез-т).
print('3.4/1.7 + 5*10 =', res_2, end='\n\n')
# Возведение в степень.
res_3 = 0.5**3
# Получим 0.125.
print('0.5**3 =', res_3, end='\n\n')
# Деление с округлением вниз.
res_4 = 5//2
# Получим 2.
print('5//2 =', res_4)
res_5 = -5//2
# Получим -3.
print('-5//2 =', res_5, end='\n\n')
# Остаток от деления.
res_6 = 5%3
# Получим 1.
print('5%3 =', res_6) 3.46 + 1.22 - 35 = -30.32
3.4/1.7 + 5*10 = 52.0
0.5**3 = 0.125
5//2 = 2
-5//2 = -3
5%3 = 2
# Скобки используются как обычно в математике.
# Используем для суммы круглые скобки.
res_1 = (3.46 + 1.22)*3 - 0.4
# Получим 13.639999999999999.
print('(3.46 + 1.22)*3 + 0.4 =', res_1, end='\n\n')
# Используем вложенные скобки.
res_2 = ((5/3.2 + 8*2)*3 - 0.4)/(4 - 2**3)
# Получим -13.071875.
print('((5/3.2 + 8*2)*3 - 0.4)/(4 - 2**3) =', res_2) (3.46 + 1.22)*3 + 0.4 = 13.639999999999999
((5/3.2 + 8*2)*3 - 0.4)/(4 - 2**3) = -13.071875
# Используем для чисел встроенные функции.
# Возведение в степень.
res_1 = pow(16, 0.5)
# Получим 4.0.
print('pow(16, 0.5) ->', res_1, end='\n\n')
# Найдем модуль числа.
res_2 = abs(-0.33)
# Получим 0.33.
print('abs(-0.33) ->', res_2, end='\n\n')
# Найдем максимальное из трех чисел.
res_3 = max(45, 7.5, 23.8)
# Получим 45.
print('max(45, 7.5, 23.8) ->', res_3, end='\n\n')
# Найдем минимальное среди этих чисел.
res_4 = min(45, 7.5, 23.8)
# Получим 7.5.
print('min(45, 7.5, 23.8) ->', res_4, end='\n\n')
# Округлим число до трех знаков после запятой.
res_5 = round(45.532917, 3)
# Получим 45.533.
print('round(45.532917, 3) ->', res_5, end='\n\n')
# Используем встроенные функции в выражении.
res_6 = abs(pow(-2, 3) + round(27.321, 1))
# Получим 19.3.
print('abs(pow(-2, 3) + round(27.321, 1)) = ', res_6) pow(16, 0.5) -> 4.0
abs(-0.33) -> 0.33
max(45, 7.5, 23.8) -> 45
min(45, 7.5, 23.8) -> 7.5
round(45.532917, 3) -> 45.533
abs(pow(-2, 3) + round(27.321, 1)) = 19.3
# Условная инструкция if/else.
# А вот для разделения коротких инструкций
# на одной строке используем точку с запятой.
x = 0.5; y = 3
# Осуществляем проверку условного выражения.
if y > 0:
# Делим и выводим рез-т.
print('x/y =', x/y)
# Иначе
else:
# Выводим предупреждение.
print('А на 0 делить нельзя!')
# Вложенные блоки инструкций нужно выделять
# одинаковыми отступами. Рекомендуется использовать
# по 4 пробела на каждый уровень вложенности. x/y = 0.16666666666666666
# Условная инструкция if/elif/else.
# Ведущий ноль у вещ-х чисел разрешается опускать.
x = .33
# Тоже самое, что и 123.45.
y = 1.2345e2
# Проверим равенство чисел. Знак = используется
# для присвоения значений, а комбинация из 2-х
# знаков равно == означает именно равенство.
if x == y:
print(x, 'равно', y)
# Если же x > y.
elif x > y:
print(x, 'больше', y)
# Иначе.
else:
print(x, 'меньше', y)
# Не забываем про кнопку «Результат». 0.33 меньше 123.45
# Разрешается использовать несколько elif.
# Запрашиваем ввод названия.
f = input('Укажите название фрукта: ')
# Осуществляем проверку условных выражений.
# Если введено название 'яблоки'.
if f == 'яблоки':
# Присвоим m строку с таким ценником.
m = '1.9 руб/кг.'
elif f == 'апельсины':
m = '3.4 руб/кг.'
elif f == 'бананы':
m = '2.5 руб/кг.'
elif f == 'груши':
m = '2.8 руб/кг.'
# Если ничего не совпало.
else:
# Сообщим об этом.
m = 'Нет в продаже!'
# Выводим результат.
print(m) Укажите название фрукта: бананы
2.5 руб/кг.
# Булевы объекты True и False.
# Сравним дроби.
n_1 = 155/247
n_2 = 189/289
# Если рез-том сравнения будет True.
if (n_1 > n_2) == True:
print('155/247 > 189/289')
# Если рез-т не равен False.
elif (n_1 == n_2) != False:
print('155/247 = 189/289')
# Иначе.
else:
print('155/247 < 189/289') 155/247 < 189/289
# Логические операторы not, or и and.
# Сохраним числа в переменных.
num_1 = -5
num_2 = 7
# Логическое НЕ инверсирует значение.
if not num_1 == num_2:
print('True', end='\n\n')
# Иначе.
else:
print('False', end='\n\n')
# Логическое ИЛИ (True, если оба значения равны
# True или хотя бы одно из значений равно True).
if num_1 > 0 or num_2 > 0:
print('True', end='\n\n')
# Иначе.
else:
print('False', end='\n\n')
# Логическое И (True, если оба значения равны True).
if num_1 > 0 and num_2 > 0:
print('True')
# Иначе.
else:
print('False') True
True
False
# Создаем строки (неизм-мые упоряд-ные послед-ти символов).
# Присваиваем литерал строки в одинарных кавычках.
str_1 = 'Я – строка в одинарных кавычках.'
# Тип str_1: <class 'str'>.
print('Тип str_1:', type(str_1))
# Присваиваем литерал строки в двойных кавычках.
str_2 = "Я – строка в двойных кавычках."
# Тип str_2: <class 'str'>.
print('Тип str_2:', type(str_2))
# Используем три двойные кавычки.
str_3 = """Я – строка в тройных кавычках.
Я могу располагаться на нескольких строках."""
# Тип str_3: <class 'str'>.
print('Тип str_3:', type(str_3))
# Используем три одинарные кавычки.
str_4 = '''Я тоже строка в тройных кавычках.
Но на этот раз были использованы три одинарные кавычки.'''
# Тип str_4: <class 'str'>.
print('Тип str_4:', type(str_4))Тип str_1: <class 'str'>
Тип str_2: <class 'str'>
Тип str_3: <class 'str'>
Тип str_4: <class 'str'>
# Кавычки внутри других кавычек.
# Используем одинарные кавычки внутри двойных.
str_1 = "Пример 'одинарных' кавычек внутри двойных."
# Выводим строку на экран.
print(str_1, end='\n\n')
# Используем двойные кавычки внутри одинарных.
str_2 = 'Пример "двойных" кавычек внутри одинарных.'
# Выводим строку на экран.
print(str_2, end='\n\n')
# Двойные, одинарные и тройные одинарные внутри тройных.
str_3 = """Вот 'одинарные', вот "двойные", а вот и
'''тройные одинарные''' кавычки внутри тройных."""
# Выводим строку на экран.
print(str_3, end='\n\n')
# Используем одинарные кавычки внутри одинарных.
str_4 = 'Пример \'одинарных\' кавычек внутри одинарных.'
# Выводим строку на экран.
print(str_4, end='\n\n')
# Слэшем экранируем и другие виды однотипных кавычек.
str_5 = """Пример \"\"\"тройных\"\"\" внутри тройных."""
# Выводим строку на экран.
print(str_5)Пример 'одинарных' кавычек внутри двойных.
Пример "двойных" кавычек внутри одинарных.
Вот 'одинарные', вот "двойные", а вот и
'''тройные одинарные''' кавычки внутри тройных.
Пример 'одинарных' кавычек внутри одинарных.
Пример """тройных""" внутри тройных.
# Доступ к символам строки по индексу.
# Формируем строку.
str_1 = 'строка'
# Выводим 1-й символ (нумерация начинается с нуля).
print('str_1[0] ->', str_1[0], end='\n\n')
# Выводим последний символ (длина строки минус один).
print('str_1[len(str_1)-1] ->', str_1[len(str_1)-1], end='\n\n')
# Можно использовать отрицательные индексы, тогда
# нумерация будет идти с конца и начинаться с -1.
print('str_1[-1] ->', str_1[-1], end='\n\n') str_1[0] -> с
str_1[len(str_1)-1] -> а
str_1[-1] -> а
# Порядок извлечения срезов строк.
# Формируем строку.
str_1 = 'Один, два, три.'
# Выводим первые два символа.
print('str_1[0:2] ->', str_1[0:2], end='\n\n')
# Можно и так.
print('str_1[:2] ->', str_1[:2], end='\n\n')
# Выводим последние два символа.
print('str_1[-2:] ->', str_1[-2:], end='\n\n')
# Выводим символы с 3-го по 7-й.
print('str_1[2:7] ->', str_1[2:7], end='\n\n')
# Используем отрицательные индексы.
print('str_1[-7:-2] ->', str_1[-7:-2], end='\n\n')
# Получим поверхностную копию строки.
print('str_1[:] ->', str_1[:], end='\n\n') str_1[0:2] -> Од
str_1[:2] -> Од
str_1[-2:] -> и.
str_1[2:7] -> ин, д
str_1[-7:-2] -> а, тр
str_1[:] -> Один, два, три.
# Используем шаг для срезов.
# Формируем строку.
str_1 = 'Вместе весело шагать...'
# Выводим ее для наглядности.
print('str_1 ->', str_1, end='\n\n')
# Выводим каждый 2-й символ среза (слева направо).
print('str_1[0:10:2] ->', str_1[0:10:2], end='\n\n')
# Можно и так.
print('str_1[:10:2] ->', str_1[:10:2], end='\n\n')
# Выводим каждый третий символ всей строки.
print('str_1[::3] ->', str_1[::3], end='\n\n')
# Выводим каждый 2-й, считая с конца среза (-1, -2,...).
# Сам срез берется справа налево, если шаг отрицательный.
print('str_1[12:2:-2] ->', str_1[12:2:-2], end='\n\n')
# Выводим каждый 3-й символ среза, считая справа налево.
print('str_1[-15:3:-3] ->', str_1[-15:3:-3], end='\n\n')
# Выводим каждый 2-й символ, считая с конца строки.
print('str_1[::-2] ->', str_1[::-2]) str_1 -> Вместе весело шагать...
str_1[0:10:2] -> Вет е
str_1[:10:2] -> Вет е
str_1[::3] -> Вс соат.
str_1[12:2:-2] -> оее т
str_1[-15:3:-3] -> ее
str_1[::-2] -> ..тгшоее теВ
# Некоторые комбинированные операторы присваивания.
# Присвоили начальное значение.
a = 3
print('Начальное значение:', a, end='\n\n')
# Равнозначно a = a + 6.
a += 6
# Теперь a == 9.
print('a += 6 <=> a = a + 6 -> a ==', a, end='\n\n')
# Равнозначно a = a*2.
a *= 2
# Теперь a == 18.
print('a *= 2 <=> a = a*2 -> a ==', a, end='\n\n')
# Равнозначно a = a/2.
a /= 2
a = int(a)
# Теперь a == 9.
print('a /= 2 <=> a = a/2 -> a ==', a, end='\n\n')
# Равнозначно a = a**2.
a **= 2
# Теперь a == 81.
print('a **= 2 <=> a = a**2 -> a ==', a)Начальное значение: 3
a += 6 <=> a = a + 6 -> a == 9
a *= 2 <=> a = a*2 -> a == 18
a /= 2 <=> a = a/2 -> a == 9
a **= 2 <=> a = a**2 -> a == 81
# Для строк можно ограниченно использовать + и *.
# Формируем строки.
str_1 = 'один '
str_2 = 'два'
str_3 = '-'
# Осуществляем конкатенацию строк (т.е. объединение).
print('str_1 + str_2 ->', str_1 + str_2, end='\n\n')
# Повторяем строку 3 раза (str_1 + str_1 + str_1).
print('str_1*3 ->', str_1*3, end='\n\n')
# Заносим в переменную объединение строк str_1 и str_2.
str_1 += str_2
# Теперь в str_1 хранится строка 'один два'.
print('str_1 ->', str_1, end='\n\n')
# Умножением удобно выводить повторяющиеся символы.
str_3 *= 10
# Теперь str_3 равна 10-ти дефисам.
print('str_3 *= 10 ->', str_3) str_1 + str_2 -> один два
str_1*3 -> один один один
str_1 += str_2 -> один два
str_3 *= 10 -> ----------
# Проверяем символы на вхождение в строку.
# Формируем строки.
str_1 = 'Два слова.'
str_2 = 'слова'
# Проверяем наличие символа в первой строке.
answer = 'л' in str_1
# Если операция вернула True,
if answer:
# выводим подтверждение на экран.
print('Буква \'а\' присутствует в строке str_1.', end='\n\n')
# Иначе
else:
# выводим на экран отрицание.
print('Буквы \'а\' нет в строке str_1.', end='\n\n')
# Проверяем вхождение str_2 в str_1, используя not in.
if str_2 not in str_1:
# Выводим подтверждение на экран.
print('str_2 отсутствует в str_1.')
# Иначе
else:
# выводим на экран сообщение.
print('str_2 присутствует в str_1.') Буква 'а' присутствует в строке str_1.
str_2 присутствует в str_1.
# Используем для обхода символов строки цикл for.
# Формируем строку.
str_1 = 'Весенний карнавал.'
# Количество букв будем хранить в счетчике.
n = 0
# Посчитаем количество букв 'а' в строке.
for let in str_1:
# Если очередной символ строки наша буква,
if let == 'а':
# увеличиваем счетчик на 1.
n += 1
# Выводим полученное количество на экран.
print("Количество букв 'а' в строке:", n) Количество букв 'а' в строке: 3
# Методов у строк довольно много. Вот некоторые из них.
# str.upper() и аналог str.lower().
str_1 = "сиНий Кит".upper()
# СИНИЙ КИТ.
print('"сиНий Кит".upper() ->', str_1, end='\n\n')
# Считаем кол-во символов в диапазоне. Вернет 1.
ans = "Синий иней".count('н', 2, 5)
print("Кол-во символов 'н':", ans, end='\n\n')
# Ищем позицию символа в диапазоне. Вернет 3.
ans = "Синий иней".find('и', 2, 5)
print("Индекс 1-го вхождения 'и':", ans, end='\n\n')
# Замена подстрок на новые строки.
str_2 = "Синий иней".replace("иней", "кит")
# Синий иней -> Синий кит.
print('Синий иней ->', str_2, end='\n\n')
# Разбиваем по пробельным символам в список строк.
str_3 = "Синий иней".split()
# ['Синий', 'иней'].
print('"Синий иней".split() ->', str_3, end='\n\n')
# Собираем строку из списка строк.
str_4 = "".join(["У", "х"])
# Ух.
print('"".join(["У", "х"]) ->', str_4, end='\n\n')
# Все символы в нижнем регистре?
str_5 = "Синий".islower()
# False.
print('"Синий".islower() ->', str_5)"сиНий Кит".upper() -> СИНИЙ КИТ
Кол-во символов 'н': 1
Индекс 1-го вхождения 'и': 3
Синий иней -> Синий кит
"Синий иней".split() -> ['Синий', 'иней']
"".join(["У", "х"]) -> Ух
"Синий".islower() -> False
# Создаем списки (изм-мые упоряд-ные посл-ти эл-тов).
# Получаем пустой список.
li_1 = []
# Выведет [].
print(li_1, end='\n\n')
# Элементы перечисляем через запятую.
li_2 = [15, "Иван", None, 34.5, True]
# Выведет [15, 'Иван', None, 34.5, True].
print(li_2, end='\n\n')
# Последнюю запятую можно не опускать.
li_3 = [1, 2, 3,]
# Выведет [1, 2, 3].
print(li_3, end='\n\n')
# Можно использовать списки списков и т.д.
li_4 = [[1, 2, 3],
[4, 5, 6],
[7, 8, 9]]
# Выведет [[1, 2, 3], [4, 5, 6], [7, 8, 9]].
print(li_4, end='\n\n')
# Эле-ми могут быть любые объекты, любой вложенности.
li_5 = [{'1': 'top', '2': ['abc', [4, 5]]}, 0.3]
# Выведет [{'1': 'top', '2': ['abc', [4, 5]]}, 0.3].
print(li_5) []
[15, 'Иван', None, 34.5, True]
[1, 2, 3]
[[1, 2, 3], [4, 5, 6], [7, 8, 9]]
[{'1': 'top', '2': ['abc', [4, 5]]}, 0.3]
# Создаем списки, используя конструктор list.
# Получаем пустой список.
li_1 = list()
# Выведет [].
print(li_1, end='\n\n')
# Получаем список из строки.
li_2 = list('123')
# Выведет ['1', '2', '3'].
print(li_2, end='\n\n')
# Преобразуем кортеж в список.
li_3 = list((15, "Иван", None, 34.5, True))
# Выведет [15, 'Иван', None, 34.5, True].
print(li_3) []
['1', '2', '3']
[15, 'Иван', None, 34.5, True]
# Создаем списки, используя генератор.
# Генерируем список из строки.
li_1 = [simb for simb in '123']
# Выведет ['1', '2', '3'].
print(li_1, end='\n\n')
# Используем более сложное выражение.
li_2 = [int(num)*5 for num in '123']
# Выведет [5, 10, 15].
print(li_2) ['1', '2', '3']
[5, 10, 15]
# Получаем элементы списка по индексу.
# Формируем список из целых чисел.
li_1 = [1, 2, 3, 4, 5]
# Получим 1, т.е. 1-й эл-т списка (нумерация начинается с нуля).
print('li_1[0] ->', li_1[0], end='\n\n')
# Выводим последний эл-т списка (кол-во эл-тов списка минус один).
# Получим 5.
print('li_1[len(li_1)-1] ->', li_1[len(li_1)-1], end='\n\n')
# Можно использовать отрицательные индексы, тогда
# нумерация будет идти с конца и начинаться с -1.
# Опять же получим 5.
print('li_1[-1] ->', li_1[-1]) li_1[0] -> 1
li_1[len(li_1)-1] -> 5
li_1[-1] -> 5
# Получаем по индексу вложенные элементы списка.
# Простой пример вложенных списков.
li_1 = [3.14, ['abc', [4, 5]], 'кот']
# Выводим число 3.14 (1-й элемент списка).
print('li_1[0] ->', li_1[0], end='\n\n')
# Выводим 2-й символ строки 'кот'.
print('li_1[2][1] ->', li_1[2][1], end='\n\n')
# Выводим 3-й символ строки 'abc'.
print('li_1[1][0][2] ->', li_1[1][0][2], end='\n\n')
# Выводим число 5 вложенного списка [4, 5].
print('li_1[1][1][1] ->', li_1[1][1][1]) li_1[0] -> 3.14
li_1[2][1] -> о
li_1[1][0][2] -> c
li_1[1][1][1] -> 5
# Берем срезы у списков.
# Формируем список из целых чисел.
li_1 = [1, 2, 3, 4, 5, 6, 7]
# Получаем список из первых двух эл-тов.
print('li_1[0:2] ->', li_1[0:2], end='\n\n')
# Можно и так, все равно получим [1, 2].
print('li_1[:2] ->', li_1[:2], end='\n\n')
# Получаем список из посл-х двух эл-тов ([6, 7]).
print('li_1[-2:] ->', li_1[-2:], end='\n\n')
# Получаем список [3, 4, 5] из эл-тов с 3-го по 5-й.
print('li_1[2:5] ->', li_1[2:5], end='\n\n')
# Получим [2, 3, 4, 5] (использ. отриц. индексы).
print('li_1[-6:-2] ->', li_1[-6:-2], end='\n\n')
# Убедимся, что список не изменился.
print('li_1 ->', li_1, end='\n\n')
# Напоследок выведем копию списка.
print('li_1[:] ->', li_1[:]) li_1[0:2] -> [1, 2]
li_1[:2] -> [1, 2]
li_1[-2:] -> [6, 7]
li_1[2:5] -> [3, 4, 5]
li_1[-6:-2] -> [2, 3, 4, 5]
li_1 -> [1, 2, 3, 4, 5, 6, 7]
li_1[:] -> [1, 2, 3, 4, 5, 6, 7]
# Используем шаг в срезах списков.
# Формируем список из целых чисел.
li_1 = [1, 2, 3, 4, 5, 6, 7, 8, 9, 10]
# Выводим его для наглядности.
print('li_1 ->', li_1, end='\n\n')
# Выводим каждый 2-й элемент среза (слева направо).
# [1, 3, 5, 7].
print('li_1[0:7:2] ->', li_1[0:7:2], end='\n\n')
# Можно и так, получим опять [1, 3, 5, 7].
print('li_1[:7:2] ->', li_1[:7:2], end='\n\n')
# Выводим каждый третий элемент всего списка.
# [1, 4, 7, 10].
print('li_1[::3] ->', li_1[::3], end='\n\n')
# Выводим каждый 2-й эл-т, считая с конца среза (-1, -2,...).
# Сам срез берется справа налево, если шаг отрицательный.
# [9, 7, 5].
print('li_1[8:2:-2] ->', li_1[8:2:-2], end='\n\n')
# Выводим каждый 3-й эл-т среза, считая справа налево.
# [8, 5].
print('li_1[-3:1:-3] ->', li_1[-3:1:-3], end='\n\n')
# Выводим каждый 2-й эл-т, считая с конца списка.
# [10, 8, 6, 4, 2].
print('li_1[::-2] ->', li_1[::-2]) li_1 -> [1, 2, 3, 4, 5, 6, 7, 8, 9, 10]
li_1[0:7:2] -> [1, 3, 5, 7]
li_1[:7:2] -> [1, 3, 5, 7]
li_1[::3] -> [1, 4, 7, 10]
li_1[8:2:-2] -> [9, 7, 5]
li_1[-3:1:-3] -> [8, 5]
li_1[::-2] -> [10, 8, 6, 4, 2]
# Изменяем значения элементов списка.
# Формируем список из 3-х элементов.
li_1 = ['и', ['b', [4, 5]], 0.3]
# Изменяем третий элемент списка (индекс 2).
li_1[2] = 4
# Выведет ['и', ['b', [4, 5]], 4]
print('li_1[2] = 4 ->', li_1, end='\n\n')
# Изменяем 1-й эл-т вложенного списка [4, 5].
li_1[1][1][0] = 's'
# Выведет ['и', ['b', ['s', 5]], 4].
print("li_1[1][1][0] = 's' -> ", li_1, end='\n\n')
# Используем отрицательный индекс.
li_1[-3] = [1, 2]
# Выведет [[1, 2], ['b', ['s', 5]], 4].
print('li_1[-3] = [1, 2] ->', li_1, end='\n\n')
# Заменим 1-й элемент пустым списком.
li_1[0] = []
# Выведет [[], ['b', ['s', 5]], 4].
print('li_1[0] = [] ->', li_1) li_1[2] = 4 -> ['и', ['b', [4, 5]], 4]
li_1[1][1][0] = 's' -> ['и', ['b', ['s', 5]], 4]
li_1[-3] = [1, 2] -> [[1, 2], ['b', ['s', 5]], 4]
li_1[0] = [] -> [[], ['b', ['s', 5]], 4]
# Используем для списков операторы + и *.
# Формируем списки.
li_1 = [1, 2, 3]
li_2 = [4, 5, 6]
# Осуществляем конкатенацию списков (т.е. объединение).
# Выведет [1, 2, 3, 4, 5, 6].
print('li_1 + li_2 ->', li_1 + li_2, end='\n\n')
# Объединяем с самим собой 3 раза (li_1 + li_1 + li_1).
# Выведет [1, 2, 3, 1, 2, 3, 1, 2, 3].
print('li_1*3 ->', li_1*3, end='\n\n')
# Тоже, что и li_1 = li_1 + li_2.
li_1 += li_2
# Теперь li_1 == [1, 2, 3, 4, 5, 6].
print('li_1 += li_2 ->', li_1) li_1 + li_2 -> [1, 2, 3, 4, 5, 6]
li_1*3 -> [1, 2, 3, 1, 2, 3, 1, 2, 3]
li_1 += li_2 -> [1, 2, 3, 4, 5, 6]
# Используем оператор in применительно к спискам.
# Формируем список.
li_1 = [1, 2, 3, [4, 5]]
# Проверяем наличие числа 8 в списке.
answer = 8 in li_1
# Если операция вернула True,
if answer:
# выводим подтверждение на экран.
print('Число 8 присутствует в списке li_1.', end='\n\n')
# Иначе
else:
# выводим на экран отрицание.
print('Числа 8 нет в списке li_1.', end='\n\n')
# Проверим вхождение, используя not in.
if 5 not in li_1[3]:
# Выводим подтверждение на экран.
print('Число 5 отсутствует в li_1[3].')
# Иначе
else:
# Выводим на экран сообщение.
print('Число 5 присутствует в li_1[3].') Числа 8 нет в списке li_1.
Число 5 присутствует в li_1[3].
# Обходим эл-ты списка циклом for.
# Формируем список.
li_1 = [1, 2, 3, 4, 5]
# Проверим все ли числа в списке целые.
for elem in li_1:
# Если эл-т не является целым числом,
if type(elem) is not int:
# выводим сообщение на экран
print('Не все эл-ты списка целые числа.')
# и прерываем цикл.
break
# Eсли цикл завершился успешно,
else:
# выводим положительный результат.
print('Все эл-ты в списке - целые числа.') Все эл-ты в списке - целые числа.
# Удаляем с помощью del.
# Формируем список.
li_1 = [1, 2, 3, 4, 5, 6, 7]
# Удаляем первый эл-т списка.
del li_1[0]
# Теперь li_1 == [2, 3, 4, 5, 6, 7].
print('del li_1[0] ->', li_1, end='\n\n')
# Удаляем срез списка.
del li_1[2:4]
# Теперь li_1 == [2, 3, 6, 7].
print('del li_1[2:4] ->', li_1, end='\n\n')
# Удаляем каждый 2-й эл-т списка.
del li_1[::2]
# Теперь li_1 == [3, 7].
print('del li_1[::2] ->', li_1, end='\n\n')
# Удаляем сам список.
del li_1
# name 'li_1' is not defined.
print(li_1, end='\n\n') del li_1[0] -> [2, 3, 4, 5, 6, 7]
del li_1[2:4] -> [2, 3, 6, 7]
del li_1[::2] -> [3, 7]
name 'li_1' is not defined
# Пройдемся по некоторым методам списков. Т.к. списки
# изменяемы, методы в основном изменяют сам список.
# Создаем список для манипуляций.
li = ['a', 'b', 'c', 'a']
# Ищем кол-во эл-тов со значением 'a'
n_1 = li.count('a')
# Получим 2.
print('li.count("a") ->', n_1, end='\n\n')
# Ищем индекс 1-го встретившегося эл-та со значением 'c'.
index_1 = li.index('c')
# Выведет 2.
print('li.index("c") ->', index_1, end='\n\n')
# Удаляем элемент списка с индексом 3.
li.pop(3)
# Выведет ['a', 'b', 'c'].
print('Теперь li ->', li, end='\n\n')
# Добавляем в конец списка эл-т (другой список).
li.append([7, 8])
# Выведет ['a', 'b', 'c', [7, 8]].
print('li.append([7, 8]) ->', li, end='\n\n')
# Удаляем 'b' (изменяем сам список).
li.remove('b')
# Выведет ['a', 'c', [7, 8]].
print('li.remove("b") ->', li, end='\n\n')
# Изменяем порядок следования эл-тов на обратный.
li.reverse()
# Выведет [[7, 8], 'c', 'a'].
print('li.reverse() ->', li) li.count("a") -> 2
li.index("c") -> 2
Теперь li -> ['a', 'b', 'c']
li.append([7, 8]) -> ['a', 'b', 'c', [7, 8]]
li.remove("b") -> ['a', 'c', [7, 8]]
li.reverse() -> [[7, 8], 'c', 'a']
# Создаем кортежи (неизм. упоряд-ные посл-ти эл-тов).
# Получаем пустой кортеж.
tpl_1 = ()
# Выведет ().
print(tpl_1, end='\n\n')
# Получаем кортеж с одним элементом.
# (3) нельзя, т.к. это просто число 3.
tpl_2 = (3,)
# Выведет (3,).
print(tpl_2, end='\n\n')
# Элементы перечисляем через запятую.
tpl_3 = (15, "Иван", None, 34.5, True)
# Выведет (15, 'Иван', None, 34.5, True).
print(tpl_3, end='\n\n')
# Последнюю запятую можно не опускать.
tpl_4 = (1, 2, 3,)
# Выведет (1, 2, 3).
print(tpl_4, end='\n\n')
# Эл-ми могут быть любые объекты, любой вложенности.
tpl_5 = (
{'1': 'top', '2': ['abc', (4, 5)]},
0.3,
)
# Выведет ({'1': 'top', '2': ['abc', (4, 5)]}, 0.3).
print(tpl_5) ()
(3,)
(15, 'Иван', None, 34.5, True)
(1, 2, 3)
({'1': 'top', '2': ['abc', (4, 5)]}, 0.3)
# Создаем кортежи, используя констр. tuple.
# Получаем пустой кортеж.
tpl_1 = tuple()
# Выведет ().
print(tpl_1, end='\n\n')
# Получаем кортеж из строки.
tpl_2 = tuple('123')
# Выведет ('1', '2', '3').
print(tpl_2, end='\n\n')
# Преобразуем список в кортеж.
tpl_3 = tuple([15, "Иван", None, 34.5, True])
# Выведет (15, 'Иван', None, 34.5, True).
print(tpl_3) ()
('1', '2', '3')
(15, 'Иван', None, 34.5, True)
# У кортежей почти все как у списков, но они неизменяемы.
# Формируем кортеж из целых чисел.
tpl_1 = (1, 2, 3, 4, 5, 6, 7)
# Получим 1, т.е. 1-й эл-т кортежа (нумерация начинается с нуля).
print('tpl_1[0] ->', tpl_1[0], end='\n\n')
# Получаем кортеж (3, 4, 5) из эл-тов с 3-го по 5-й.
print('tpl_1[2:5] ->', tpl_1[2:5], end='\n\n')
# Выводим каждый 2-й элемент среза (слева направо).
# (1, 3, 5).
print('tpl_1[0:5:2] ->', tpl_1[0:5:2]) tpl_1[0] -> 1
tpl_1[2:5] -> (3, 4, 5)
tpl_1[0:5:2] -> (1, 3, 5)
# Изменяем элементы кортежей.
# Формируем кортеж из 3-х элементов.
tpl_1 = ('и', ['b', [4, 5]], 0.3)
# Изменяем 1-й эл-т вложенного списка [4, 5].
tpl_1[1][1][0] = 's'
# Выведет ('и', ['b', ['s', 5]], 4).
print('tpl_1[1][1][0] = \'s\' ->', tpl_1, end='\n\n')
# А вот так уже не получится (кортеж неизменяем).
tpl_1[0] = 7
# Выведет исключение.
print('tpl_1[0] = 7 ->', tpl_1) tpl_1[1][1][0] = 's' -> ('и', ['b', ['s', 5]], 0.3)
'tuple' object does not support item assignment
# Методов у кортежей мало.
# Создаем кортеж для манипуляций.
tpl = ('a', 'b', 'c', 'a', 'b', 'c')
# Ищем кол-во эл-тов со значением 'b'
n_1 = tpl.count('b')
# Получим 2.
print('tpl.count("b") ->', n_1)
# Ищем кол-во эл-тов со значением 23
n_2 = tpl.count(23)
# Получим 0, т.к. эл-тов с таким значением нет в кортеже.
print('tpl.count(23) ->', n_2, end='\n\n')
# Ищем индекс 1-го встретившегося эл-та со значением 'c'.
index_1 = tpl.index('c')
# Выведет 2.
print('tpl.index("c") ->', index_1)
# Тоже самое, но ищем с 4-го элемента кортежа.
index_2 = tpl.index('c', 3)
# Получим индекс 5, т.к. ищем не сначала кортежа.
print('tpl.index("c", 3) ->', index_2) tpl.count("b") -> 2
tpl.count(23) -> 0
tpl.index("c") -> 2
tpl.index("c", 3) -> 5
# Переходим к словарям (измен-мая именованная коллекция эл-тов).
# Сохраним список в переменной.
li = ['abc', 123, (1, 2, 3)]
# Выводим эл-ты списка.
print(li[0], li[1], li[2], end='\n\n')
# Сохраняем те же объекты, но в словаре.
d = {'str': 'abc', 'num': 123, 'tuple': (1, 2, 3)}
# Выводим эл-ты на экран.
print(d['str'], d['num'], d['tuple']) abc 123 (1, 2, 3)
abc 123 (1, 2, 3)
# Создаем словари.
# Получаем пустой словарь.
dict_1 = {}
# Выведет {}.
print(dict_1, end='\n\n')
# Пары «ключ: значение» перечисляем через запятую.
dict_2 = {'язык': 'Python', 'версия': 3.9}
# Выведет {'язык': 'Python', 'версия': 3.9}.
print(dict_2, end='\n\n')
# Последнюю запятую можно не опускать.
dict_3 = {1: 'один', 2: 'два',}
# Выведет {1: 'один', 2: 'два'}.
print(dict_3, end='\n\n')
# Эле-ми могут быть любые объекты любой вложенности.
dict_4 = {'li': ['a', {0: (False, True), 1: None}],
'tpl': (1, 2, 3)}
print(dict_4) {}
{'язык': 'Python', 'версия': 3.9}
{1: 'один', 2: 'два'}
{'li': ['a', {0: (False, True), 1: None}], 'tpl': (1, 2, 3)}
# Используем конструктор dict.
# Получаем пустой словарь.
dict_1 = dict()
# Выведет {}.
print(dict_1, end='\n\n')
# Используем пары «идентификатор = значение».
dict_2 = dict(one = 1, two = 2)
# Выведет {'one': 1, 'two': 2}.
print(dict_2, end='\n\n')
# Используем список с кортежами пар.
dict_3 = dict([('one', 1), ('two', 2)])
# Выведет опять же {'one': 1, 'two': 2}.
print(dict_3, end='\n\n')
# Разрешены любые допустимые ключи.
dict_4 = dict([(1, 'one'), (2, 'two')])
# Выведет {1: 'one', 2: 'two'}.
print(dict_4) {}
{'one': 1, 'two': 2}
{'one': 1, 'two': 2}
{1: 'one', 2: 'two'}
# Используем для создания генератор.
# Словарь с квадратами чисел 2, 3, 4.
d_1 = {x: x**2 for x in range(2,5)}
# Выведет {2: 4, 3: 9, 4: 16}.
print(d_1) {2: 4, 3: 9, 4: 16}
# Ключи словаря должны быть неизменяемыми объектами.
# Используем для ключей строки.
dict_1 = {'num': 1, 'abc': 'Алфавит'}
print(dict_1, end='\n\n')
# Используем для ключей числа.
dict_2 = {1: 'int', -0.2: 'float', 3j: 'complex'}
print(dict_2, end='\n\n')
# Пробуем использовать список.
dict_3 = {[1, 2]: 'Так нельзя!'}
# Получаем ошибку, т.к. списки изменяемы.
print(dict_3){'num': 1, 'abc': 'Алфавит'}
{1: 'int', -0.2: 'float', 3j: 'complex'}
unhashable type: 'list'
# Доступ к эл-там словаря по ключу.
# Формируем простой словарь.
d_1 = {1: 'один', 'yes': 'да'}
# Выведет один да.
print(d_1[1], d_1['yes'], end='\n\n')
# Используем вложенные списки и словари.
d_1 = {'li': [{'ok': 1, 'no': 2}, 3], 's': 'abc'}
# Выведет 2 b.
print(d_1['li'][0]['no'], d_1['s'][1]) один да
2 b
# Изменяем и добавляем эл-ты.
# Формируем словарь.
d_1 = {1: 1, 2: 2, 3: 0.3}
# Изменяем значение элемента.
d_1[3] = 3
# Выведет {1: 1, 2: 2, 3: 3}.
print(d_1, end='\n\n')
# Добавляем новый эл-т.
d_1[4] = 4
# Выведет {1: 1, 2: 2, 3: 3, 4: 4}.
print(d_1) {1: 1, 2: 2, 3: 3}
{1: 1, 2: 2, 3: 3, 4: 4}
# Операторы + и * не используются со словарями.
# Оператор in работает с ключами словаря.
# Формируем простой словарь.
d_1 = {1: 'один', 'yes': 'да'}
# Выведет True.
print(1 in d_1, end='\n\n')
# Выведет False.
print('no' in d_1, end='\n\n')
# Выведет True.
print('no' not in d_1) True
False
True
# Обходим эл-ты словаря циклом for.
# Формируем словарь.
d_1 = {1: 1, 2: 2, 3: 0.3}
# Запускаем цикл по ключам словаря.
for key in d_1:
# Если эл-т не является целым числом,
if not isinstance(d_1[key], int):
# выводим на экран сообщение
print('Не все эл-ты словаря целые числа.')
# и прерываем цикл.
break
# Eсли цикл завершился успешно,
else:
# выводим положительный результат.
print('Все эл-ты в словаре - целые числа.') Не все эл-ты словаря целые числа.
# Удаляем эл-ты словаря с помощью del.
# Формируем исходный словарь.
d_1 = {1: 1, 2: 2, 3: 0.3, 4: 4}
# Выводим его на экран.
print('Исходный словарь:', d_1, end='\n\n')
# Удаляем эл-т.
del d_1[4]
# Выведет {1: 1, 2: 2, 3: 0.3}.
print('Итоговый словарь:', d_1) Исходный словарь: {1: 1, 2: 2, 3: 0.3, 4: 4}
Итоговый словарь: {1: 1, 2: 2, 3: 0.3}
# Пройдемся по некоторым методам словарей.
# Формируем словарь.
d_1 = {'a': 1, 'b': 2, 'c': 3}
print("d_1 ->", d_1)
# Получаем значение d_1['b']. Выведет 2.
print("d_1.get('b') ->", d_1.get('b'), end='\n\n')
# Выведет список ключей ['a', 'b', 'c'].
print("d_1.keys() ->", list(d_1.keys()))
# Выведет список значений [1, 2, 3].
print("d_1.values() ->", list(d_1.values()))
# Выведет список [('a', 1), ('b', 2), ('c', 3)].
print("d_1.items() ->", list(d_1.items()), end='\n\n')
# Очищаем словарь. Метод вернет None.
d_1.clear()
# Выведет {}.
print(d_1, end='\n\n')
# Используем другой словарь.
d_1.update({'c': 3, 'd': 4})
# Выведет {'c': 3, 'd': 4}.
print("d_1.update({'c': 3, 'd': 4}) ->", d_1, end='\n\n')
# Удаляем и выводим d_1['c'].
d_1.pop('c')
# Выведет {'d': 4}.
print(d_1) d_1 -> {'a': 1, 'b': 2, 'c': 3}
d_1.get('b') -> 2
d_1.keys() -> ['a', 'b', 'c']
d_1.values() -> [1, 2, 3]
d_1.items() -> [('a', 1), ('b', 2), ('c', 3)]
{}
d_1.update({'c': 3, 'd': 4}) -> {'c': 3, 'd': 4}
{'d': 4}
# Множества (неупорядоченная коллекция
# уникальных и неизменяемых объектов).
# Множество из одного эл-та.
s_1 = {1}
print(s_1, end='\n\n')
# Множество из 3-х эл-тов.
s_2 = {'a', 0.1, ('b', 2)}
print(s_2, end='\n\n')
# Вывело {1, 'a'}.
s_3 = {'a', 1, 1}
print(s_3, end='\n\n')
# unhashable type: 'list'
s_1 = {'a', 0.1, ['b', 2]} {1}
{0.1, 'a', ('b', 2)}
{1, 'a'}
unhashable type: 'list'
# Для преобразования типов используются конструкторы.
# False.
print('bool(0):', bool(0))
# True.
print('bool(-1):', bool(1), end='\n\n')
# 0.
print('int(False): ', int(False))
# 53.
print('int("+53"): ', int('+53'))
# -7.
print('int(-7.33): ', int(-7.33), end='\n\n')
# 1.0.
print('float(True): ', float(True))
# -7.33.
print('float("-7.33"): ', float('-7.33'), end='\n\n')
# True.
print('str(True):', str(True))
# -7.33.
print('str(-7.33):', str(-7.33))
# [0.5, 1,5].
print('str([0.5, 1,5]):', str([0.5, 1,5]))
# {'one', 'two'}.
print("str({'one', 'two'}):", str({'one', 'two'}), end='\n\n')
# ('a', 'b', 'c').
print("tuple('abc'):", tuple('abc'))
# (1, 2, 3).
print('tuple([1, 2, 3]):', tuple([1, 2, 3]), end='\n\n')
# ['a', 'b', 'c'].
print("list('abc'):", list('abc'))
# [1, 2, 3].
print('list((1, 2, 3)):', list((1, 2, 3)), end='\n\n')
# {1: 'a', 2: 'b'}.
print("dict([[1, 'a'], (2, 'b')]):", dict([[1, 'a'], (2, 'b')])) bool(0): False
bool(-1): True
int(False): 0
int("+53"): 53
int(-7.33): -7
float(True): 1.0
float("-7.33"): -7.33
str(True): True
str(-7.33): -7.33
str([0.5, 1,5]): [0.5, 1, 5]
str({'one', 'two'}): {'two', 'one'}
tuple('abc'): ('a', 'b', 'c')
tuple([1, 2, 3]): (1, 2, 3)
list('abc'): ['a', 'b', 'c']
list((1, 2, 3)): [1, 2, 3]
dict([[1, 'a'], (2, 'b')]): {1: 'a', 2: 'b'}
# Порядок использования операторов в Пайтоне.
# Теперь a==19, т.к. приоритет оператора * выше, чем у +.
a = 5 + 7*2
print('5 + 7*2 ->', a)
# Теперь b==24, т.к. порядок был указан при помощи скобок.
b = (5 + 7)*2
print('(5 + 7)*2 ->', b, end='\n\n')
c = 2
# Вернет True, т.к. согласно принятому порядку
# это тоже самое, что и a < b and b > c.
print(a < b > c)
# Вернет False, т.к. скобки явно указывают порядок выполнения.
print('a < (b > c) ->', a < (b > c), end='\n\n')
# Согласно принятому порядку это тоже самое, что и c = (a = b).
# А вот использование инструкции c = a += b вызовет ошибку.
c = a = b
# Теперь d == -8, т.к. операторы - и - имеют равный приоритет и
# левую ассоциативность, поэтому 5 - 6 - 7 == (5 - 6) - 7.
d = 5 - 6 - 7
print('5 - 6 - 7 ->', d, end='\n\n')
# Теперь d == 1, т.к. (0 and 0 or 1) == (0 and 0) or 1.
d = 0 and 0 or 1
print('0 and 0 or 1 ->', d)
# Теперь d == 0, т.к. операция в скобках выполняется первой.
d = 0 and (0 or 1)
print('0 and (0 or 1) ->', d) 5 + 7*2 -> 19
(5 + 7)*2 -> 24
True
a < (b > c) -> False
5 - 6 - 7 -> -8
0 and 0 or 1 -> 1
0 and (1 or 0) -> 0
# Инструкция присваивания имеет несколько вариаций.
# Каноническая форма присваивания.
a = 5 + 0.3
# Выведет 5.3.
print(a, end='\n\n')
# Комбинированная форма присваивания.
a += 6
# Теперь a == 9, что равнозначно a = a + 6.
print('a += 6 ->', a, end='\n\n')
# Позиционное присваивание.
b, c = 3, 5
# Выведет b == 3, c == 5.
print('b ==', b, ', c ==', c, end='\n\n')
# Присв-ние 1-го значения группе переменных.
x = y = z = 'Ok'
# Опять же выведет x == 'Ok', y == 'Ok', z == 'Ok'.
print('x ==', x, ', y ==', y, ', z ==', z) 5.3
a += 6 -> 11.3
b == 3 , c == 5
x == Ok , y == Ok , z == Ok
# Еще пример цикла for.
# Формируем список.
li = [2, 5, 9, 4]
# Задаем начальную сумму.
sum = 0
# Запускаем цикл по элементам списка.
for elem in li:
# Если сумма чисел меньше 8,
if sum < 8:
# наращиваем ее.
sum += elem
# Выводим для наглядности на экран.
print(sum)
# Иначе
else:
# выводим предупреждение и
print("Превышен лимит суммы эл-тов!")
# прерываем цикл.
break
# Если цикл не был прерван.
else:
# Выводим итоговое сообщение.
print("Сумма эл-тов равна:", sum)
# Выводим сообщение о завершении проверки.
print("Проверка списка завершена!") 2
7
16
Превышен лимит суммы эл-тов!
Проверка списка завершена!
# Тоже самое, но с циклом while.
# Формируем список.
li = [2, 5, 9, 4]
# Задаем начальную сумму.
sum = 0
# Устанавливаем счетчик итераций.
k = 0
# Запускаем цикл по элементам списка.
while k <= len(li):
# Если сумма чисел меньше 8,
if sum < 8:
# наращиваем ее.
sum += li[k]
# Отслеживаем показания счетчика и суммы.
print(k, ':', sum)
# Счетчик увеличиваем на 1.
k += 1
# Иначе
else:
# выводим предупреждение и
print("Превышен лимит суммы эл-тов!")
# прерываем цикл.
break
# Если цикл не был прерван.
else:
# Выводим итоговое сообщение.
print("Сумма эл-тов равна:", sum)
# Выводим сообщение о завершении проверки.
print("Проверка списка завершена!") 0 : 2
1 : 7
2 : 16
Превышен лимит суммы эл-тов!
Проверка списка завершена!
# Еще один пример цикла while.
# Устанавливаем счетчик.
k = 1
# Запускаем бесконечный цикл.
while True:
# Выводим номер итерации.
print(k, end=' ')
# Счетчик увеличиваем на 1.
k += 1
# Имитируем условную часть цикла do/while.
if k > 5: break 1 2 3 4 5
# Инструкции break и continue в цикле for.
# Допустим, что имеется список чисел от 1 до 20.
li = list(range(1, 21))
# Запускаем цикл по элементам списка.
for k in li:
# Задаем условие прерывания цикла.
if k > 10:
# Прерываем цикл и идем дальше.
break
# Отсеиваем четные числа.
if k%2 == 0:
# Счетчик обязательно увеличиваем.
k += 1
# Пропускаем дальнейшие инструкции
# и возвращаемся в заголовок цикла.
continue
# Выводим нечетные числа на экран.
print(k, end=' ')
# Счетчик увеличиваем на 1.
k += 1
# Инструкция после цикла.
print('\nВывод нечетных чисел окончен!') 1 3 5 7 9
Вывод нечетных чисел окончен!
# Инструкции break и continue в цикле while.
# Устанавливаем счетчик.
k = 1
# Запускаем бесконечный цикл.
while True:
# Задаем условие прерывания цикла.
if k > 10:
# Прерываем цикл и идем дальше.
break
# Отсеиваем четные числа.
if k%2 == 0:
# Счетчик обязательно увеличиваем.
k += 1
# Пропускаем дальнейшие инструкции
# и возвращаемся в заголовок цикла.
continue
# Выводим нечетные числа на экран.
print(k, end=' ')
# Счетчик увеличиваем на 1.
k += 1
# Инструкция после цикла.
print('\nВывод нечетных чисел окончен!') 1 3 5 7 9
Вывод нечетных чисел окончен!
# Создание и вызов функций в Python.
# Функция определяется один раз.
def pow_func(x, y):
# Возводим x в степень y.
p = x**y
# Возвращаем результат вызывающей программе.
return p
# После создания функцию можно вызывать.
res_1 = pow_func(3, 3)
# Получим 27, т.е. 3 в кубе.
print('pow_func(3, 3) ->', res_1, end='\n\n')
# При этом вызовы можно осуществлять многократно.
res_2 = pow_func(4, 2)
# Выведет 16, т.е. 4 в квадрате.
print('pow_func(4,2) ->', res_2) pow_func(3, 3) -> 27
pow_func(4,2) -> 16
# Вызывать ф-цию можно только после определения.
# local variable func_1 referenced before assignment.
# func_1()
# Определяем функцию.
def func_1(): print('func_1 определена!')
# Вызов разрешен, т.к. func_1 уже определена.
# Выведет 'func_1 определена!'.
func_1() func_1 определена!
# Передача аргументов функциям.
# Определяем и вызываем функцию без аргументов.
def func_1(): print('Ok')
# Выведет 'Ok'.
func_1()
# Функция с тремя позиционными аргументами.
def func_2(a, b, c): return a + b + c
# При вызове должны быть переданы все 3 аргумента.
print(func_2(2, 33, 87)) Ok
122
# Аргументам можно задавать значения по умолчанию.
# Укажем для одного аргумента значение по умолчанию.
def func(x, y=1): return x/y
# Везде получим 4.0, т.к. 8/2 = 4.0.
print('func(8, 2) ->', func(8, 2))
# При вызове можно указывать имена.
print('func(x=8, y=2) ->', func(x=8, y=2))
# Но первыми нужно указывать аргументы без имени.
print('func(8, y=2) ->', func(8, y=2), end='\n\n')
# Аргумент со значением по умолчанию можно не указывать.
# Везде получим 2.0, т.к. 2/1 = 2.0.
print('func(2) ->', func(2))
print('func(x=2) ->', func(x=2)) func(8, 2) -> 4.0
func(x=8, y=2) -> 4.0
func(8, y=2) -> 4.0
func(2) -> 2.0
func(x=2) -> 2.0
# Локальные и глобальные переменные.
# Инициализируем глобальные переменные.
y = x = 0
# Выведет 0 0.
print(x, y, end='\n\n')
# Объявляем функцию.
def func_1():
# Будем использовать глобальную переменную.
global x
# Изменяем глобальную переменную из функции.
x = 1
# Это локальная переменная для func_1.
# Здесь она имеет приоритет над глобальной.
# Глобальная переменная осталась прежней.
y = 1
# Выведет 1.
print(y, end='\n\n')
# Вызываем функцию.
func_1()
# Выведет 1 0.
print(x, y) 0 0
1
1 0
# Создание классов и объектов.
# Определяем обычный класс (не наследует других классов).
class Person:
# Определяем 1-й метод (self - текущий экземпляр).
def set_name(self, name):
# Создаем атрибут данных экземпляра.
self.name = name
# Определяем 2-й метод экземпляров.
def get_name(self):
# Используем атрибут данных экземпляра.
return self.name
# Создаем 1-й экземпляр класса.
person_1 = Person()
# Устанавливаем имя сотрудника.
person_1.set_name('Ольга')
# Извлекаем имя сотрудника.
print(person_1.get_name(), end='\n\n')
# Создаем 2-й экземпляр класса.
person_2 = Person()
# Устанавливаем имя сотрудника.
person_2.set_name('Света')
# Извлекаем имя сотрудника.
print(person_2.get_name()) Ольга
Света
# Инструкция import.
# Импортируем два модуля, используя по одной инструкции
# в каждой строке, опуская расширения файлов модулей.
import math
import random
# Импортировать сразу два модуля, перечисляя их
# через запятую, можно, но не рекомендуется PEP8.
# import math, random
# Теперь доступ к переменным в модулях открыт:
# они доступны нам в виде атрибутов объектов модулей.
a = math.pi
b = random.randint(1, 10)
# Выводим случайное произведение на экран.
print(a*b) 6.283185307179586
# Используем короткие псевдонимы.
import math as m
import random as rnd
# Через запятую не рекомендуется PEP8.
# import math as m, random as rnd
# Теперь модули доступны по их псевдонимам.
a = m.pi
b = rnd.randint(1, 10)
# А имя math осталось свободным.
math = 5
# Выводим случайное произведение на экран.
print(math*a*b) 125.66370614359172
# Используем для импорта инструкцию from.
# Импортируем из модуля все имена.
from random import *
# Импортируем из модуля лишь одно имя.
from importlib import reload
# Импортируем только указанные имена, используя для
# некоторых из них псевдонимы (PEP8 не возражает).
from math import degrees as dg, pi, factorial as fctl
# Импортированные инструкцией from имена могут
# использоваться без указания имен их модулей.
# Теперь просто pi вместо math.pi.
print('pi:', pi)
# fctl(5) вместо math.factorial(5).
print('fctl(5):', fctl(5))
# randint(1, 10) вместо random.randint(1, 10).
print('randint(1, 10):', randint(1, 10))pi: 3.141592653589793
fctl(5): 120
randint(1, 10): 9