Python повторение материалов 1-6

number = 1 number = number + 1 # Прибавь 1 к содержимому переменной number number += 1 # То же, что и выше в сокращенной записи print(number)

3

Использовать функцию len(), чтобы найти количество элементов в последовательности (списке, кортеже или строке). my_fruits_list = ['яблоко', 'груша', 'арбуз'] print(len(my_fruits_list)) # В нашем списке три объекта

3

age = input() # считываем возраст без запроса print(age)

32

number = 1 number = number * 2 # Умножь содержимое переменной number на 2 number *= 2 # То же, что и выше в сокращенной записи print(number)

4

Обращаться к символами внутри строки с помощью индексации s = 'Hello' print(s[0]) # Просим вывести первую букву текста, который хранится в переменной s — букву H print(s[1]) # вторую — e print(s[2]) # третью — l print(s[3]) # l print(s[4]) # o print(s) # Просим напечатать всё слово целиком в одной строке

H e l l o Hello

Научились создавать кортежи и узнали, что они неизменяемые (мы не можем добавлять в них новые элементы или заменять старые). my_fruits_tuple = ('яблоко', 'груша') print(my_fruits_tuple) print(type(my_fruits_tuple)) # Проверяем тип нашего кортежа

('яблоко', 'груша') <class 'tuple'>

print('п' in 'привет') # Есть ли буква "п" в слове "привет"?

True

Можно сравнивать и строки. name = 'Петя' print(name == 'Петя') # Строка, сохраненная в переменной name "равна" строке "Петя" — утверждение истинно

True

gender = 'woman' age = 18 print(gender == 'woman' and age >= 18) # Оба условия истинны -> True print(gender == 'men' and age >= 18) # Первое условие ложно -> False print(gender == 'woman' and age >= 25) # Второе условие ложно -> False print(gender == 'men' and age >= 25) # Оба условия ложны -> False

True False False False

my_fruits_list = ['яблоко', 'груша', 'арбуз'] # Истина — яблоко является элементом нашего списка print('яблоко' in my_fruits_list) # Ложь — яблоко является элементом нашего списка print('яблоко' not in my_fruits_list) # Ложь — дыня не является элементом нашего списка print('дыня' in my_fruits_list) # Истина — дыня не является элементом нашего списка print('дыня' not in my_fruits_list)

True False False True

Научились использовать операторы сравнения, чтобы получать логический тип данных. print(2 == 2) # 2 равно 2 — это утверждение истинно print(2 != 2) # 2 не равно 2 — это утверждение ложно print(2 > 3) # 2 больше 3 — это утверждение ложно print(2 < 3) # 2 меньше 2 — это утверждение истинно print(3 >= 3) # 3 больше или равно 3 — это утверждение истинно print(4 <= 3) # 4 меньше или равно 3 — это утверждение ложно

True False False True True False

example = ' my string ' print(example) # Напечатаем строку "как есть" print(example.strip()) # Удалим пробельные символы с обоих краев print(example.lstrip()) # Удалим пробельные символы слева (left-strip) print(example.rstrip()) # Удалим пробельные символы справа (right-strip)

my string my string my string my string

# Найди количество символов в каждом слове списка print(list(map(len, ['Привет', 'ТЕСТ', 'функции', 'map!']))) # Приведи каждое слово к нижнему регистру print(list(map(str.lower, ['Привет', 'ТЕСТ', 'функции', 'map!']))) # Преврати каждую цифру-строку в целое число print(list(map(int, ['1', '10', '1000', '23'])))

[6, 4, 7, 4] ['привет', 'тест', 'функции', 'map!'] [1, 10, 1000, 23]

# Неправильный ответ, потому что сначала вычисляется and, а затем or cherry = 'Да' blueberry = 'Нет' dough = 'Нет' # Программа должна выводить 'Готовим пирог', # если у нас есть хотя бы один вид ягод И тесто if cherry == 'Да' or blueberry == 'Да' and dough == 'Да': print('Готовим пирог') else: print('Не хватает продуктов')

Готовим пирог

Создавать цикл while с составными логическими условиями. n = 0 # Задаем начальное количество съеденных сосисок meow = input('Кот мяукает? да/нет: ') # Узнаем, голоден ли кот while meow == 'да' and n < 10: # Можно в другом порядке: n < 10 and meow == 'да' print('Даем сосиску') # Кормим кота n = n + 1 # Квеличиваем количество сосисок на 1 meow = input('Кот мяукает? да/нет: ') # Узнаем, голоден ли кот теперь print('Съедено сосисок:', n)

Даем сосиску Съедено сосисок: 1

eggs = 1 yougurt = 'да' if eggs < 2: if yougurt == 'нет': print('Идем в магазин') # Идем в магазин только в случае, когда нет ни йогурта, ни яиц print('Завтракаем')

Завтракаем

Научились использовать оператор else для обработки "всех остальных случаев", которые не удовлетворяют нашему условию. eggs = 1 if eggs < 2: print('Завтракаем в кафе') # Завтракаем в кафе только в случае, когда яиц недостаточно else: print('Завтракаем дома') # Во всех остальных случаях (=когда яиц достаточно) — завтракаем дома

Завтракаем в кафе

number = 1 number = number - 1 # Вычти 1 из содержимого переменной number number -= 1 # То же, что и выше в сокращенной записи print(number)

-1

Научились использовать for вместе с range() для перебора списков по индексу. # Программа ниже выводит имя студента из списка names и его оценку из списка grades names = ['Аня', 'Даша', 'Петя'] grades = [10, 9, 10] for i in range(len(names)): # Печатаем индексы всех элементов списка names print(i) for i in range(len(names)): # Печатаем имена студентов под каждым из индексов print(names[i]) for i in range(len(names)): # Печатаем оценки студентов под каждым из индексов print(grades[i]) for i in range(len(names)): # Соединяем имя студента и его оценку по общему индексу print(names[i], grades[i])

0 1 2 Аня Даша Петя 10 9 10 Аня 10 Даша 9 Петя 10

Находить индекс, по которому объект хранится в списке, с помощью .index() Метод принимает аргумент — объект, который ищем, и возвращает целое число — индекс, по которому этот объект хранится. Обратите внимание — если такого объекта в списке нет, то метод выдаст ошибку. shopping_list = ['молоко', 'хлеб'] shopping_list.index('хлеб')

1

Научились программировать цикл while, который повторяет инструкции до тех пор, как условие не станет ложным. # Программа ниже напечатает числа от 1 до 5 number = 1 while number <= 5: # До тех пор, пока значение переменной number меньше или равно 5 print(number) number = number + 1

1 2 3 4 5

Запрашивать ввод с клавиатуры внутри цикла while # Программа ниже будет запрашивать числа и складывать их, # пока сумма не станет больше десяти total = 0 while total <= 10: # Повторяй операции пока сумма чисел меньше или равна 10 number = int(input()) # Считай число total += number # Обнови сумму числе print(total)

11

Научились писать бесконечный цикл while True и прерывать его с помощью break # Программа ниже будет запрашивать числа и складывать их, # пока сумма не станет больше десяти total = 0 while True: # Повторяй операции бесконечно if total > 10: # Но если сумма больше 10, то... break # прерви цикл number = int(input()) # Считай число total += number # Обнови сумму чисел print(total)

11

Конвертировать объекты одного типа данных в другие с помощью специальных функций: int() — в целые числа float() — в десятичные дроби str() — в строки (текстовый тип данных) age = input('Сколько вам лет? ') print(2022 - int(age)) # конвертируем считанный возраст в число, чтобы найти год рождения пользователя print(int(55.8)) # отборсим дробную часть десятичной дроби print(float('9.8')) # превратим строку в десятичную дробь print(str(5) * 3) # превратим число в строку, чтобы повторить его три раза

1990 55 9.8 555

# Программы ниже считает количество букв 'l' в слове word = 'hello' total_l = 0 for letter in word: # Для каждой буквы в слове if letter == 'l': # сделай проверку, что эта буква — буква 'l', и total_l += 1 # если да — посчитай ее print(total_l)

2

Использовать условный оператор if внутри цикла while # Программа ниже напечатает только четные числа от 1 до 5 number = 1 while number <= 5: # До тех пор, пока значение переменной number меньше или равно 5 if number % 2 == 0: # Если число четное, то... print(number) number = number + 1

2 4

my_numbers_list = (1, 2, 5) for number in my_numbers_list: # Умножь каждое число в моем кортеже на 2 print(2 * number)

2 4 10

Использовать функцию type(), чтобы определять, с каким типом данных мы имеем дело. z = 32.2 print(type(z)) # узнаем тип объекта, который хранится в переменной print(type('текст')) # узнаем тип объекта напрямую

<class 'float'> <class 'str'>

Превращать списки в кортежи и наборот. list() — превратит объект в список tuple() — превратит объект в кортеж my_fruits_tuple = ('яблоко', 'груша') print(type(my_fruits_tuple)) my_fruits_list = list(my_fruits_tuple) # Превращаем кортеж в список print(type(my_fruits_list)) my_fruits_tuple_again = tuple(my_fruits_list) # Превращаем список в кортеж print(type(my_fruits_tuple_again))

<class 'tuple'> <class 'list'> <class 'tuple'>

gender = 'woman' age = 18 is_woman = gender == 'woman' # Сохраняем результат логического сравнения в переменную print(is_woman) # Выводим значение переменной # Используем логическое отрицание с переменной: True -> False print(not(is_woman)) # Используем логическое отрицание с выражением: False -> True print(not(gender == 'men' and age >= 18))

True False True

gender = 'woman' age = 18 print(gender == 'woman' or age >= 18) # Оба условия истинны -> True print(gender == 'men' or age >= 18) # Второе условие истинно -> True print(gender == 'woman' or age >= 25) # Первое условие истинно -> True print(gender == 'men' or age >= 25) # Оба условия ложны -> False

True True True False

Узнали, что такое логический тип данных. yes = True # Истина no = False # Ложь print(yes, no) print(type(yes)) # Проверяем тип данных — bool

True False <class 'bool'>

Перезаписывать элементы списка, обратившись к ним по индексу. NB! Кортеж и строка — неизменяемые типы данных. Менять в них элементы не выйдет. my_fruits_list = ['яблоко', 'груша'] my_fruits_list[0] = 'арбуз' # Заменим яблоко на арбуз print(my_fruits_list)

['арбуз', 'груша']

Использовать методы "цепочкой" — вызывая один сразу за другим. # Избавимся от точки, приведем строку к нижнем регистру, а потом превратим ее в список слов our_string = 'Мама мыла Милу.' words = our_string.strip('.').lower().split() print(words)

['мама', 'мыла', 'милу']

shopping_list = ['молоко', 'хлеб', 'сахар', 'хлеб'] shopping_list.remove('хлеб') # Посмотрим на обновлённый список print(shopping_list)

['молоко', 'сахар', 'хлеб']

Метод принимает один аргумент — объект, который нужно добавить. Метод ничего не возвращает, а просто изменяет исходный список (резлультат работы метода нельзя сохранить в переменную!). shopping_list = ['молоко'] print(shopping_list) # Посмотрим на список до работы метода .appned() shopping_list.append('хлеб') # Добавим в него новый элемент print(shopping_list) # Посмотрим на обновлённый список

['молоко'] ['молоко', 'хлеб']

Склеивать и "повторять" последовательности (списки, кортежи, строки) с помощью операторов + и * my_fruits_list_1 = ['яблоко', 'груша', 'арбуз'] my_fruits_list_2 = ['дыня'] print(my_fruits_list_1 + my_fruits_list_2) # Склей два списка print(my_fruits_list_1 * 3) # Повтори список три раза

['яблоко', 'груша', 'арбуз', 'дыня'] ['яблоко', 'груша', 'арбуз', 'яблоко', 'груша', 'арбуз', 'яблоко', 'груша', 'арбуз']

"Распаковывать" список или кортеж при выводе, чтобы красиво их напечатать. my_fruits_list = ['яблоко', 'груша', 'арбуз'] # Печатаем без распаковки print(my_fruits_list) # Печатаем с распаковкой (исчезают скобки и апострофы) print(*my_fruits_list) # Печатаем с распаковкой и разделителем (добавляется запятая # с пробелом между элементами списка) print(*my_fruits_list, sep=', ')

['яблоко', 'груша', 'арбуз'] яблоко груша арбуз яблоко, груша, арбуз

fruits_input = input('Введите названия фруктов, разделенные точкой с запятой: ').split(';') # разбиваем по точке с запятой данные, считанные с клавиатуры print(fruits_input)

['яблоко', 'груша', 'дыня']

Научились создавать списки (с данными или пустые) и записывать их в переменные. my_fruits_list = ['яблоко', 'груша'] my_numbers_list = [1, 2] my_mixed_list = ['творог', 79.90, 2, True] my_empty_list = [] # Также можем использовать list() print(my_fruits_list, my_numbers_list, my_mixed_list, my_empty_list) print(type(my_fruits_list)) # Проверяем тип одного из наших списков

['яблоко', 'груша'] [1, 2] ['творог', 79.9, 2, True] [] <class 'list'>

fruits = 'яблоко,груша,арбуз' # Получили список, состоящий из одной строки — в нашей строке # не было пробелов -> нельзя разбить на элементы print(fruits.split()) # Указали разделитель — получили список фруктов, которые были # разделены запятой в исходной строке print(fruits.split(','))

['яблоко,груша,арбуз'] ['яблоко', 'груша', 'арбуз']

Научились создавать интервалы чисел с помощью функции range() range(старт, финиш, шаг) # Каждое число от 1 (включая) до 6 (не включая) range_1_5 = list(range(1,6)) # Каждое второе число (шаг 2) от 1 (включая) до 21 (не включая) range_1_20 = list(range(1, 21, 2)) # Каждое число в обратном порядке (шаг -1) от 10 (включая) до 0 (не включая) range_10_1 = list(range(10, 0, -1)) print(range_1_5) print(range_1_20) print(range_10_1)

[1, 2, 3, 4, 5] [1, 3, 5, 7, 9, 11, 13, 15, 17, 19] [10, 9, 8, 7, 6, 5, 4, 3, 2, 1]

Работа со строками Создавать новую строку на основе какого-либо условия в цикле for # Программа ниже создаст новую строку из строки `hello`, в которой все гласные заменены на прописной вариант vowels = 'aiueo' # Строка с гласными — будем использовать ее для проверки символов our_string = 'hello' # Строка, с которой будем работат new_string = '' # Пустая строка, куда будем добавлять символы # Перебери символы в строке и сохрани их по очереди в переменную symbol for symbol in our_string: if symbol in vowels: # Если символ в переменной является

hEllO

А также использовать отрицательную индексацию. s = 'Hello' print(s[-1]) # Попросим напечатать последнюю букву строки print(s[-2]) # Попросим напечатать предпоследнюю букву строки print(s[-3]) # Третью с конца print(s[-4]) # Четвёртую с конца print(s[-5]) # Пятую с конца

o l l e H

example = 'ru.hse.ru' print(example) # Напечатаем строку "как есть" print(example.strip('ru')) # Удалим 'ru' с обоих краев print(example.lstrip('ru')) # Удалим 'ru' слева (left-strip) print(example.rstrip('ru')) # Удалим 'ru' справа (right-strip)

ru.hse.ru .hse. .hse.ru ru.hse.

text = 'sample' text *= 2 # Повтори строку два раза и перезапиши содержимое переменной text print(text)

samplesample

А также писать вложенные конструкции с else. eggs = 1 yogurt = 'да' if eggs < 2: if yogurt == 'нет': print('Идем в магазин') else: # else относится к условию про йогурт print('Завтракаем йогуртом') else: # этот else относится к условию про количество яиц print('Завтракаем яичницей')

Завтракаем йогуртом

Научились использовать оператор elif для проверки дополнительных условий. eggs = 0 yougurtyou = 'да' if eggs > 2: # Если дома 3 и больше яйца -> завтракаем яичницей print('Завтракаем яичницей') elif yogurt == 'да': # Если яиц недостаточно, но дома есть йогурт —> завтракаем йогуртом print('Завтракаем йогуртом') else: # Во всех остальных случаях —> идем в кафе print('Завтракаем в кафе')

Завтракаем йогуртом

Научились "разветвлять" логику программы с помощью условного оператора if, а также писать вложенные условия. eggs = 1 yougurt = 'да' # Проверяем условие, что количество яиц меньше двух, то есть их недостаточно if eggs < 2: print('Идем в магазин') print('Завтракаем')

Идем в магазин Завтракаем

Находить минимум или максимум последовательности с помощью min() и max() Эти функции работают со списками, кортежами и другими типами данных. Для определения "минимума" и "максимума" строк используется лексикографический порядок. numbers = [5,7,30] print(f'Минимум списка {numbers}: {min(numbers)}') print(f'Максимум списка {numbers}: {max(numbers)}') s = 'abwgqwe' print(f'Минимальная буква в строке {s}: {min(s)}, максимальная: {max(s)}')

Минимум списка [5, 7, 30]: 5 Максимум списка [5, 7, 30]: 30 Минимальная буква в строке abwgqwe: a, максимальная: w

Считать объекты в списке с помощью .count() Метод принимает аргумент — объект, количество вхождений которого нужно посчитать (это может быть число, строка, список, и т.д.). Метод вовзрващает целое число — количество вхождений, которое можно сохранить в переменную. shopping_list = ['молоко', 'молоко', 'хлеб'] print(f'Молоко встречается {shopping_list.count("молоко")} раза.')

Молоко встречается 2 раза.

s = ' 4242HelloHello42! ' print(f'Найдём первый и последний индекс для симовола "l" : {s.find("l")}, {s.rfind("l")}') # Вернет индекс первого символа последовательности print(f'Найдём первый и последний индекс для последовательности символов "42" : {s.find("42")}, {s.rfind("42")}') # Символа "a" нет в строке — оба метода вернули -1 print(f'Найдём первый и последний индекс для симовола "a" : {s.find("a")}, {s.rfind("a")}')

Найдём первый и последний индекс для симовола "l" : 7, 13 Найдём первый и последний индекс для последовательности символов "42" : 1, 15 Найдём первый и последний индекс для симовола "a" : -1, -1

# Правильный ответ, потому что теперь сначала вычисляется # выражение с or в скобках и только затем and cherry = 'Да' blueberry = 'Нет' dough = 'Нет' # Программа должна выводить 'Готовим пирог', # если у нас есть хотя бы один вид ягод И тесто if (cherry == 'Да' or blueberry == 'Да') and dough == 'Да': print('Готовим пирог') else: print('Не хватает продуктов')

Не хватает продуктов

Останавливать цикл for c помощью break # Программа ниже дает пользователю три попытки угадать число # и выходит из цикла, если число угадано number = 10 for attempt in range(3): # Повтори действие три раза guess = int(input('Введите целое число: ')) if guess == number: # Если число угадано, print('Вы угадали!') ## сообщи об этом break ## выйди из цикла else: # Если чесло не угадано — print('Неверно :(') ## сообщи об этом

Неверно :( Вы угадали!

shopping_list = ['молоко', 'хлеб', 'молоко', 'кефир'] # Объедини все элементы shopping_list, использовав в качестве разделителя запятую и пробел s = ', '.join(shopping_list) print(f'Нужно купить: {s}.')

Нужно купить: молоко, хлеб, молоко, кефир.

# Получим ошибку, потому что строки "мороженое" в списке нет shopping_list = ['молоко', 'хлеб'] shopping_list.index('мороженое')

ОШИБКА

# Получим ошибку, потому что строки "мороженое" в списке нет shopping_list = ['молоко', 'хлеб'] shopping_list.remove('мороженое')

ОШИБКА

Методы принимают один аргумент — искомую последовательность символов, и возвращают логические значения True / False, которые можно сохранить в переменную. print(f'Оканчивается ли "hse.ru" на ".ru"? {"hse.ru".endswith("ru")}') print(f'Оканчивается ли "hse.ru" на ".ru" или ".рф"? {"hse.ru".endswith(("ru", ".рф"))}') print(f'Начинается ли строка "https://cbr.ru" с "https"? {"https://cbr.ru".startswith("https")}')

Оканчивается ли "hse.ru" на ".ru"? True Оканчивается ли "hse.ru" на ".ru" или ".рф"? True Начинается ли строка "https://cbr.ru" с "https"? True

# сравните с выводом "по умолчанию" print('Привет') # нет запятой в конце и следующий print() печатает на новой строке print('Маша', 'Аня', 'Петя') # имена разделены пробелом, а не запятой, в конце строки нет восклицательного знака

Привет Маша Аня Петя

Научились использовать range() для того, чтобы повторять действия определенное количество раз. # Программа ниже здоровается с пользователем три раза for action in range(3): # Повтори действие три раза print('Привет!')

Привет! Привет! Привет!

Использовать вложенные циклы for greetings = ['Привет', 'Пока'] names = ['Аня', 'Дима', 'Cвета'] for name in names: for greeting in greetings: print(f'{greeting}, {name}!')

Привет, Аня! Пока, Аня! Привет, Дима! Пока, Дима! Привет, Cвета! Пока, Cвета!

print('Привет', end=', ') # заканчивает строку запятой с пробелом и не переходит на новую строку print('Маша', 'Аня', 'Петя', sep=', ', end='!')

Привет, Маша, Аня, Петя!

Считывать строки, введенные пользователем с клавиатуры, и сохранять их в переменные. name = input('Как вас зовут? ') # считываем имя с запросом 'Как вас зовут?' # (этот запрос не сохраняется в переменную, # но подсказывает пользователю, что нужно ввести) print('Привет,', name)

Привет, Олег

Использовать f-строки для удобной подстановки значений переменных в текст для вывода. name = 'Петя' print(f'Привет, {name}!') # используем префикс f и название переменной в {} скобках print('Привет, {name}!') # убедимся, что без префикса не работает print(f'Привет, name!') # убедимся, что если забыть {} вокруг названия переменной, — тоже не работает

Привет, Петя! Привет, {name}! Привет, name!

s = ' 4242HelloHello42! ' print(f'Проверим их работу на примере строки "{s}""') print(f'Состоит ли строка только из цифр: {s.isdigit()}') print(f'Состоит ли строка только из строчных букв: {s.islower()}') print(f'Состоит ли строка только из прописных букв: {s.isupper()}') print(f'Состоит ли строка только из букв: {s.isalpha()}') print(f'Состоит ли строка только из букв или цифр: {s.isalnum()}')

Проверим их работу на примере строки " 4242HelloHello42! "" Состоит ли строка только из цифр: False Состоит ли строка только из строчных букв: False Состоит ли строка только из прописных букв: False Состоит ли строка только из букв: False Состоит ли строка только из букв или цифр: False

Считать, сколько раз символ или последовательность символов, встречись в строке с помощью .count() Метод принимает аргумент — символ или строку, количество вхождений которого нужно посчитать. Метод вовзрващает целое число — количество вхождений, которое можно сохранить в переменную. print(f'Сколько раз последовательность цифр "42" встречаются в строке: {s.count("42")}') print(f'Сколько раз последовательность цифр "420" встречаются в строке: {s.count("420")}')

Сколько раз последовательность цифр "42" встречаются в строке: 3 Сколько раз последовательность цифр "420" встречаются в строке: 0

Использовать конструкции in / not in с условным оператором. backpack = ['кошелек', 'наушники', 'студенческий', 'тетрадка', 'телефон'] if 'наушники' in backpack: print('Слушаем музыку') else: print('Читаем книжку')

Слушаем музыку

Использовать арифметические операторы + и * при работе со строками. print('Со строками всё немного проще:') print('Их можно склеивать:') first = 'Hello ' second = 'World!' text = first + second print(text) print('И умножать на целое число:') text = first * 4 print(text)

Со строками всё немного проще: Их можно склеивать: Hello World! И умножать на целое число: Hello Hello Hello Hello

Функция работатет только со списками или котрежами, состоящими из числовых значений (целые и вещественные числа, True / False). numbers = [5,7,30] print(f'Сумма списка {numbers}: {sum(numbers)}')

Сумма списка [5, 7, 30]: 42

Выполнять арифметические действия с числами (целыми и дробными) print('Числа (целые и вещественные) можно:') print('Складывать:') print(5 + 7) print(5.5 + 6.5) print('Вычитать:') print(5 - 7) print(5.5 - 7.5) print('Умножать:') print(5 * 7) print(5.5 * 7) print('Делить:') print(8 / 16) print(4.2 / 2) print('Делить нацело:') print(5 // 2) print(5.5 // 2) print('Брать остаток от деления:') print(5 % 2) print(5.5 % 2) print('Возводить в степень:') print(5 ** 2) print(5.5 ** 2)

Числа (целые и вещественные) можно: Складывать: 12 12.0 Вычитать: -2 -2.0 Умножать: 35 38.5 Делить: 0.5 2.1 Делить нацело: 2 2.0 Брать остаток от деления: 1 1.5 Возводить в степень: 25 30.25

print(*('арбуз', 'лимон', 'лайм'), sep='*') # Работает и с кортежем

арбуз*лимон*лайм

Заменять символы или последовательности символов в строке с помощью .replace() Метод .replace(<что заменяем?>, <на что заменяем?>) обязательно принимает два аргумента — две строки. Метод возвращает изменненую строку, которую можно сохранить в переменную. example = 'малако' print(example.replace('а', 'о')) # Меняем "а" на "о" print(example.replace('мал', 'обл')) # Меняем "мал" на "обл"

молоко облако

Выводить на экран информацию. print('привет') # печатаем строку print(2, 10) # печатаем два числа print(y) # печатаем содержимое переменной

привет 2 10 24

Перебирать элементы последовательностей (списков, кортежей, строк) с помощью цикла for my_fruits_list = ['яблоко', 'груша', 'арбуз'] for fruit in my_fruits_list: # Напечатай каждый объект в моем списке print(fruit)

яблоко груша арбуз

Научились обращаться к элементам списков и кортежей по индексам (также как к элементам строк!). my_fruits_list = ['яблоко', 'груша'] print(my_fruits_list[0]) # Первый элемент print(my_fruits_list[1]) # Второй элемент print(my_fruits_list[-1]) # Последний элемент (в этом случае тот же, что и второй) my_fruits_tuple = ('яблоко', 'груша') print(my_fruits_tuple[0]) # Первый элемент кортежа

яблоко груша груша яблоко

Преваращать строки в списки, разбивая их по разделителю, с помощью метода .split() fruits = 'яблоко груша арбуз' print(fruits) # Строка fruits_list = fruits.split() # Нет аргумента -> разбивка идет по пробельным символам print(fruits_list) # Список

яблоко груша арбуз ['яблоко', 'груша', 'арбуз']