Курс для начинающих
«Python за час»

# Ф-ция 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
# Получим 2.
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