From 32ab7a0aeef4ccca02309556da945e3bb5990d2d Mon Sep 17 00:00:00 2001 From: Aleksandr Makarov Date: Thu, 4 Apr 2024 21:18:51 +0400 Subject: [PATCH 01/22] Add file list in lists --- _06_strings/_1_string_type.py | 4 +- _07_lists/list_my_notes | 115 ++++++++++++++++++++++++++++++++++ 2 files changed, 117 insertions(+), 2 deletions(-) create mode 100644 _07_lists/list_my_notes diff --git a/_06_strings/_1_string_type.py b/_06_strings/_1_string_type.py index 7e81490..cf7252b 100644 --- a/_06_strings/_1_string_type.py +++ b/_06_strings/_1_string_type.py @@ -29,9 +29,9 @@ my_string = input("Enter a number: ") -print(type(my_string)) # Outputs: +print(type(my_string), my_string) # Outputs: my_integer = int(my_string) -print(my_integer) # Outputs: 10 +print(type(my_integer), my_integer) # Outputs: 10 big_integer = 2 ** 1000 diff --git a/_07_lists/list_my_notes b/_07_lists/list_my_notes new file mode 100644 index 0000000..3cc9ee5 --- /dev/null +++ b/_07_lists/list_my_notes @@ -0,0 +1,115 @@ +fruits = ['apple', 'banana', 'cherry'] +print(fruits) # Выводит список +print(len(fruits)) # Выводит кол-во элементов в списке +print() + +element1 = 'apple' +element2 = 'banana' +element3 = 'cherry' +fruits_1 = [element1, element2, element3] +print(fruits_1) +print() + + +print('В списках могут хранится str, int, float, bool, list') +my_list = ['apple', 1, 1.5, True, [1, 2, 3]] +print(my_list) +print() + +print('Сравнение списков') +my_ls1 = [1, 2, 3] +my_ls2 = [1, 3, 2] +my_ls3 = [1, 2, 3] +print(my_ls1 == my_ls2) # Сравниваем списки вывод: False +print(my_ls1 == my_ls3) # Сравниваем списки вывод: True +print() + + +print('Вывод bool при пустом списке и при списке со значением') +print(bool([])) +print(bool([0])) +print() + + +print('Проверяем содержится то или иное значение в списке с помощью in') # Регистр важен +fruits_2 = ['apple', 'banana', 'cherry'] +print('banana' in fruits_2) # Вывод True +print('lemon' in fruits_2) # Вывод False +print() + + +print('Передаем переменную str в список, она разбивается на отдельные символы') +word = 'hello my little friend' +my_ls4 = list(word) +print(my_ls4) +print() + + +print('Сложение списков друг с другом') +my_ls5 = [1, 2, 3] +my_ls6 = [4, 5, 6] +my_ls5_plus_ls6 = my_ls5 + my_ls6 +print(my_ls5_plus_ls6) +print() + + +print('Добавляем элементы в список') +fruits_3 = ['apple', 'banana', 'cherry'] +fruits_3.append('watermelon') # Добавляем элемент +print(fruits_3) +print() + + +print('Метод list.pop(index) убирает из списка по индексу и сохраняет в переменную если она есть.') +fruits_4 = ['apple', 'banana', 'cherry'] +fruit = fruits_4.pop(0) # Метод убирает из списка по индексу и сохраняет в переменную. Default index [-1] +print(fruit) +print(fruits) +print() + +print('Добавляем в список элементы других коллекций методом list.extend()') +# Добавляет элементы любой коллекции не удаляя из неё элементы. +fruits_5 = ['apple', 'banana', 'cherry'] # Первоначальный список +fruits_6 = ['fig', 'grape', 'watermelon'] # Второй список, строк +list_int = [5, 6, 7] # Список цифр +tuple_int = (1, 4, 8) # Кортеж цифр +set_1 = set('Goody') # Set со строкой типа str +fruits_5.extend(list_int) # Добавляет элементы списка цифр +fruits_5.extend(tuple_int) # Добавляет элементы кортеж цифр +fruits_5.extend(fruits_6) # Добавляет элементы списка строк +fruits_5.extend(set_1) # Добавляет элементы множества set +print(fruits_5) +print(fruits_6) +print() + + +print('Разворачиваем список') +fruits_7 = ['apple', 'banana', 'watermelon', 'cherry'] +print(fruits_7) +fruits_7.reverse() +print(fruits_7) +print() + + +print('Сортируем список методом list.sort() и list.sort(reverse = True)') +my_ls7 = [9, 600, 85, 111, 25, 400, 320, 1] +my_ls7.sort() # Сортируем список +print(my_ls7) # Выводим список +my_ls7.sort(reverse = True) # Сортируем в обратном порядке +print(my_ls7) # Выводим список +print() + + +print("Используем для разделения строки метод .split() и для соединения метод ' '.join()") +my_string_1 = 'I Love the blue sky' +my_ls8 = my_string_1.split(' ') # Разделяем строку str через разделитель пробел (' '). +print(my_ls8) +my_string_2 = ' '.join(my_ls8) # Соединяем список слов используя разделитель пробел ' '. +print(my_string_2) +print() + +print('Выводим из списка int максимальное число, минимально число и сумму чисел') +my_ls9 = [4, 67, 77, 34, 23, 2809, 5650] +print(max(my_ls9)) +print(min(my_ls9)) +print(sum(my_ls9)) \ No newline at end of file From 3d692b8d55288fe3faf1ac4e148ea8e0cb61975e Mon Sep 17 00:00:00 2001 From: Aleksandr Makarov Date: Thu, 4 Apr 2024 21:27:39 +0400 Subject: [PATCH 02/22] Upgrade lists --- _07_lists/list_my_notes | 7 ++++++- 1 file changed, 6 insertions(+), 1 deletion(-) diff --git a/_07_lists/list_my_notes b/_07_lists/list_my_notes index 3cc9ee5..c4f8b71 100644 --- a/_07_lists/list_my_notes +++ b/_07_lists/list_my_notes @@ -110,6 +110,11 @@ print() print('Выводим из списка int максимальное число, минимально число и сумму чисел') my_ls9 = [4, 67, 77, 34, 23, 2809, 5650] +print(my_ls9) print(max(my_ls9)) print(min(my_ls9)) -print(sum(my_ls9)) \ No newline at end of file +print(sum(my_ls9)) +alf = 'zxcvbnmasdfghjklqwertyuiopAZ' +my_ls10 = list(alf) +print("максимальная буква", max(alf)) +print('минимальная буква', min(alf)) \ No newline at end of file From 72ed5e9397a9666b6e84d6d696413b58547a0c26 Mon Sep 17 00:00:00 2001 From: Aleksandr Makarov Date: Fri, 5 Apr 2024 17:32:36 +0400 Subject: [PATCH 03/22] Add my_index_notes --- _08_indexes_slices/_2_slices.py | 32 ++++++++++---------- _08_indexes_slices/my_index_notes | 50 +++++++++++++++++++++++++++++++ 2 files changed, 66 insertions(+), 16 deletions(-) create mode 100644 _08_indexes_slices/my_index_notes diff --git a/_08_indexes_slices/_2_slices.py b/_08_indexes_slices/_2_slices.py index 6949605..3655d43 100644 --- a/_08_indexes_slices/_2_slices.py +++ b/_08_indexes_slices/_2_slices.py @@ -1,23 +1,23 @@ numbers = [0, 1, 2, 3, 4, 5, 6, 7, 8, 9] -print(numbers[0:5]) # Outputs: [0, 1, 2, 3, 4] +print(numbers[0:5]) # Outputs: [0, 1, 2, 3, 4] new_numbers = numbers[0:5] -print(new_numbers) # Outputs: [0, 1, 2, 3, 4] -print(numbers[0:10]) # Outputs: [0, 1, 2, 3, 4, 5, 6, 7, 8, 9] +print(new_numbers) # Outputs: [0, 1, 2, 3, 4] +print(numbers[0:10]) # Outputs: [0, 1, 2, 3, 4, 5, 6, 7, 8, 9] print(numbers[0:len(numbers)]) # Outputs: [0, 1, 2, 3, 4, 5, 6, 7, 8, 9] -print(numbers[:]) # Outputs: [0, 1, 2, 3, 4, 5, 6, 7, 8, 9] -print(numbers[:5]) # Outputs: [0, 1, 2, 3, 4] -print(numbers[5:]) # Outputs: [5, 6, 7, 8, 9] -print(numbers[0:10:2]) # Outputs: [0, 2, 4, 6, 8] -print(numbers[::2]) # Outputs: [0, 2, 4, 6, 8] -print(numbers[3:2]) # Outputs: [] -print(numbers[0:20]) # Outputs: [0, 1, 2, 3, 4, 5, 6, 7, 8, 9] -print(numbers[-5:-1]) # Outputs: [5, 6, 7, 8] -print(numbers[::-1]) # Outputs: [9, 8, 7, 6, 5, 4, 3, 2, 1, 0] +print(numbers[:]) # Outputs: [0, 1, 2, 3, 4, 5, 6, 7, 8, 9] +print(numbers[:5]) # Outputs: [0, 1, 2, 3, 4] +print(numbers[5:]) # Outputs: [5, 6, 7, 8, 9] +print(numbers[0:10:2]) # Outputs: [0, 2, 4, 6, 8] +print(numbers[::2]) # Outputs: [0, 2, 4, 6, 8] +print(numbers[3:2]) # Outputs: [] +print(numbers[0:20]) # Outputs: [0, 1, 2, 3, 4, 5, 6, 7, 8, 9] +print(numbers[-5:-1]) # Outputs: [5, 6, 7, 8] +print(numbers[::-1]) # Outputs: [9, 8, 7, 6, 5, 4, 3, 2, 1, 0] string = "Hello, world!" -print(string[0:5]) # Outputs: 'Hello' -print(string[7:]) # Outputs: 'world!' -print(string[::2]) # Outputs: 'Hlo ol!' +print(string[0:5]) # Outputs: 'Hello' +print(string[7:]) # Outputs: 'world!' +print(string[::2]) # Outputs: 'Hlo ol!' print(string[::-1]) # Outputs: '!dlrow ,olleH' -print(string[2:1]) # Outputs: ''fd +print(string[2:1]) # Outputs: ''fd diff --git a/_08_indexes_slices/my_index_notes b/_08_indexes_slices/my_index_notes new file mode 100644 index 0000000..0285129 --- /dev/null +++ b/_08_indexes_slices/my_index_notes @@ -0,0 +1,50 @@ +fruits = ['apple', 'banana', 'cherry', 'watermelon'] +print(fruits[0]) +print(fruits[-4]) +print() + + +print('Заменяем через индекс элемент списка') +fruits[0] = 'pineapple' +print(fruits) +print() + + +print('Замена элементов списка друг с другом через присвоение') +print(fruits) +fruits[0], fruits[3] = fruits[3], fruits[0] +print(fruits) +print() + + +print('Слайсы - это срезы по индексам. Можно присваивать в новые списки') +numbers = [0, 1, 2, 3, 4, 5, 6, 7, 8, 9] +print(numbers[0:5]) # Вывод с первого до пятого +print(numbers[:5]) # Тоже вывод с первого до пятого +print(numbers[0:]) # Вывод с первого до последнего +print(numbers[:]) # Тоже вывод с первого до последнего +print(numbers[0:len(numbers)]) # Тоже вывод с первого до последнего +print(numbers[0:12:2]) # Слайсы с шагом 2 третий аргумент +print(numbers[::2]) # Тоже слайс с шагом 2 +print(numbers[3:2]) # Вернет пустой список +print(numbers[0:400]) # Вернет тоже полный список +print(numbers[-5:-1]) # Вернет от 5 до 8 +print(numbers[::-1]) # Разворачиваем список +new_list_numbers = numbers[3:7] # Можно присваивать новым переменным +print(new_list_numbers) +print() + + +# Три способа развернуть лист: +# Первый способ +numbers = [0, 1, 2, 3, 4, 5, 6, 7, 8, 9] +print(numbers[::-1]) +# Второй способ +numbers = [0, 1, 2, 3, 4, 5, 6, 7, 8, 9] +numbers.reverse() +print(numbers) +# Третий способ +numbers = [0, 1, 2, 3, 4, 5, 6, 7, 8, 9] +new_numbers = list(reversed(numbers)) # Нужно обязательно возврат функции reserved обернуть в list +print(new_numbers) +print(list(reversed(list(reversed(numbers))))) \ No newline at end of file From 9e32dac7c47e8dfc633ca68ae881025dde5e126d Mon Sep 17 00:00:00 2001 From: Aleksandr Makarov Date: Fri, 5 Apr 2024 17:37:14 +0400 Subject: [PATCH 04/22] Add modified in indexes_slices --- _08_indexes_slices/_2_slices.py | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/_08_indexes_slices/_2_slices.py b/_08_indexes_slices/_2_slices.py index 3655d43..3af4fae 100644 --- a/_08_indexes_slices/_2_slices.py +++ b/_08_indexes_slices/_2_slices.py @@ -1,6 +1,6 @@ numbers = [0, 1, 2, 3, 4, 5, 6, 7, 8, 9] print(numbers[0:5]) # Outputs: [0, 1, 2, 3, 4] -new_numbers = numbers[0:5] +new_numbers = numbers[0:5] # Save in new_numbers slice [0:5] print(new_numbers) # Outputs: [0, 1, 2, 3, 4] print(numbers[0:10]) # Outputs: [0, 1, 2, 3, 4, 5, 6, 7, 8, 9] print(numbers[0:len(numbers)]) # Outputs: [0, 1, 2, 3, 4, 5, 6, 7, 8, 9] From 807f6f4e27e3762f28b0263cf9342bef2bb7a55f Mon Sep 17 00:00:00 2001 From: Aleksandr Makarov Date: Fri, 5 Apr 2024 18:55:54 +0400 Subject: [PATCH 05/22] Add my_cycle_for --- _09_for_loop_range/my_cycle_for | 69 +++++++++++++++++++++++++++++++++ 1 file changed, 69 insertions(+) create mode 100644 _09_for_loop_range/my_cycle_for diff --git a/_09_for_loop_range/my_cycle_for b/_09_for_loop_range/my_cycle_for new file mode 100644 index 0000000..cd4570e --- /dev/null +++ b/_09_for_loop_range/my_cycle_for @@ -0,0 +1,69 @@ +file_names = ['Document1.txt', 'image1.jpg', 'Document2.txt', 'image2.jpg'] +print(file_names) + + +print('Выводим на экран через цикл каждый элемент списка') +for file_name in file_names: # Количество итераций равно количеству элементов коллекции + print(file_name) + + +print('Выводим на экран через цикл каждый элемент str. То есть символ') +greeting = 'Hello, world!' +for char in greeting: + print(char) +print() + + +print('Считаем через цикл количество подходящих элементов') +greeting = 'Hello, world!' +count_l = 0 +for char in greeting: + if char == 'l': + count_l += 1 +print(count_l) +print() + +print('Перебираем цикл в цикле') +students = ['Alice', 'Bob', 'charlie', 'David'] +for student in students: + print(student) + for char in student: + print(char) + + +print('Создаем список методом range и дополняем его через цикл в котором перебираем range') +numbers = list(range(5, 100 , 10)) # range от 5 до 100 с шагом 10 +for i in range(16): + numbers.append(i) +print(numbers) + +print('Показываем как работают ключевые слова continue и break') +numbers = [0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15] +for num in numbers: # Перебираем список + if num % 2 == 0: # Если цифра равняется чётной заходим в условие + continue # Continue переносит сразу нас в следующую итерацию цикла + if num == 10: # Если цифра равняется 10 то активируем break + break # Этот break никогда не будет активирован потому, что когда num == 10 условие выше вернёт нас в следующую итерацию. + if num == 11: # Если цифра равняется 11 то активируем break + break # Break завершает работу цикла + print(num) + print() + + +print('Прибавляем к каждому элементу списк +1 через цикл по индексам') +numbers = [10, 11, 12, 13, 14, 15] +for i in range(len(numbers)): + numbers[i] += 1 +print(numbers) +print() + + +print('Записываем выбраный элемент через цикл. Индексы коллекции и их количество') +greeting = 'Hello, world!' +indexes_l = [] +count_l = 0 +for i in range(len(greeting)): + if greeting[i] == 'l': + count_l += 1 + indexes_l.append(i) +print(f'В "{greeting}" индексы буквы l {indexes_l} и их количество {count_l}') \ No newline at end of file From f64e1c75440845c44a2c5a3634c10da0fba4d7dd Mon Sep 17 00:00:00 2001 From: Aleksandr Makarov Date: Fri, 5 Apr 2024 19:49:00 +0400 Subject: [PATCH 06/22] Add my_function --- _10_functions/my_function | 52 +++++++++++++++++++++++++++++++++++++++ 1 file changed, 52 insertions(+) create mode 100644 _10_functions/my_function diff --git a/_10_functions/my_function b/_10_functions/my_function new file mode 100644 index 0000000..d9197eb --- /dev/null +++ b/_10_functions/my_function @@ -0,0 +1,52 @@ +numbers_1 = [1, 2, 3, 4, 5, 6, 7] + +average_1 = sum(numbers_1) / len(numbers_1) +print(average_1) + +numbers_2 = [8, 9, 10, 11, 12, 13, 14] +average_2 = sum(numbers_2) / len(numbers_2) +print(average_2) + +# Функция которая считает среднее значение +def avg(numbers): + return sum(numbers) / len(numbers) + + +numbers_3 = [15, 16, 17, 18, 19, 20, 21, 22] +print(avg(numbers_3)) +print(avg(list(range(100)))) + +# Функция которая считает количество гласных в строке +def count_vowels(string): + VOWELS = 'aeiouyAEIOUY' + count = 0 + count_vowels = 0 + for char in string: + count += 1 + if char in VOWELS: + count_vowels += 1 + + return f'количество букв {count} из них гласных {count_vowels}' + +# Вызов функции count_vowels +print(count_vowels('My mother is big-big bisnesswomen')) + +# Функция заглушка которая возвращает ничего +def nothing(): + pass + +# Функция с обязательными аргументами +def format_date(*, day: int, month: str) -> str: + return f'The date is {day} of {month}' + + +#print(format_date(15, 'october')) +#print(format_date('october', 15)) +print(format_date(month='october', day=15)) + +# Функция с обязательными аргументами и с аргументом по умолчанию +def custom_greeting(*, name: str, greeting: str = 'Hello') -> str: + return f'{greeting}, {name}' + +print(custom_greeting(name='Alice', greeting='Good morning')) +print(custom_greeting(name='Alice')) \ No newline at end of file From a3cbc3e59ed919b7718ddc3db71aea4db687c166 Mon Sep 17 00:00:00 2001 From: Aleksandr Makarov Date: Fri, 5 Apr 2024 20:26:53 +0400 Subject: [PATCH 07/22] Add my_variabls_scope --- _07_lists/list_my_notes | 6 ++-- _11_variables_scope/my_variabls_scope | 50 +++++++++++++++++++++++++++ 2 files changed, 53 insertions(+), 3 deletions(-) create mode 100644 _11_variables_scope/my_variabls_scope diff --git a/_07_lists/list_my_notes b/_07_lists/list_my_notes index c4f8b71..6e0c2ae 100644 --- a/_07_lists/list_my_notes +++ b/_07_lists/list_my_notes @@ -16,7 +16,7 @@ my_list = ['apple', 1, 1.5, True, [1, 2, 3]] print(my_list) print() -print('Сравнение списков') +print('Сравнение списков') # Сравнение элементов происходит по их индексам my_ls1 = [1, 2, 3] my_ls2 = [1, 3, 2] my_ls3 = [1, 2, 3] @@ -27,7 +27,7 @@ print() print('Вывод bool при пустом списке и при списке со значением') print(bool([])) -print(bool([0])) +print(bool([0])) # Даже если значение в списке цифра 0, то выведет True print() @@ -64,7 +64,7 @@ print('Метод list.pop(index) убирает из списка по инде fruits_4 = ['apple', 'banana', 'cherry'] fruit = fruits_4.pop(0) # Метод убирает из списка по индексу и сохраняет в переменную. Default index [-1] print(fruit) -print(fruits) +print(fruits_4) print() print('Добавляем в список элементы других коллекций методом list.extend()') diff --git a/_11_variables_scope/my_variabls_scope b/_11_variables_scope/my_variabls_scope new file mode 100644 index 0000000..ba8e647 --- /dev/null +++ b/_11_variables_scope/my_variabls_scope @@ -0,0 +1,50 @@ +def my_function(): + local_var = "I'm local variable" # Переменную нельзя использовать вне функции + print(local_var) +my_function() + + +print('Используем переменную объявленную вне функции в теле функции') +variable = "I'm a variable out of scope" +def my_function(): + print(variable) +my_function() + + +COMFORTABLE_TEMPERATURE = 23 + +def get_diff_from_comfortable_temperature(*, temperature: int) -> int: + return COMFORTABLE_TEMPERATURE - temperature +print(get_diff_from_comfortable_temperature(temperature=20)) + +''' Использование констант в функциях например которые существуют на уровне пакетов +или модулей это нормально, но использование каких-то других переменных скорее всего +приведёт к возникновению ошибки, поэтому лучше этого не делать.''' + +# Изменение глобальной переменной - Абсолютное зло +global_var = "I`m a global variable" + +def my_function(): + global global_var + global_var = 'I defined inside the scopr of my_function' + +print(global_var) +my_function() +print(global_var) + + +DEFAULT_LEVEL_EXPERIENCE = 200 + + +def is_leveled_up(*, current_experience: int, gained_experience: int) -> bool: + total_experience = current_experience + gained_experience + level_up = False + + if total_experience >= DEFAULT_LEVEL_EXPERIENCE: + level_up = True + + return level_up + + +print(is_leveled_up(current_experience=150, gained_experience=60)) # True +print(is_leveled_up(current_experience=10, gained_experience=60)) # False \ No newline at end of file From cd23adf91cbb0d79cb9cf786819a5baee104431c Mon Sep 17 00:00:00 2001 From: Aleksandr Makarov Date: Sat, 6 Apr 2024 03:18:30 +0400 Subject: [PATCH 08/22] Add my_while --- _12_while_loop/my_while | 98 +++++++++++++++++++++++++++++++++++++++++ 1 file changed, 98 insertions(+) create mode 100644 _12_while_loop/my_while diff --git a/_12_while_loop/my_while b/_12_while_loop/my_while new file mode 100644 index 0000000..450b12e --- /dev/null +++ b/_12_while_loop/my_while @@ -0,0 +1,98 @@ +import random + +print('Повторяет цикл пока переменная не дойдет до False') +counter = 1 +while counter <= 5: + print(f'Counter is: {counter}') + counter += 1 +print() + + +print('Повторяет цикл пока не кончится list') +my_list = [0, 1, 2, 3, 4, 5] +while my_list: + element = my_list.pop() + print(f'elementL: {element}') +print(my_list) +print() + +# print('Создадим повторяющийся цикл пока не напишем quit') +# while True: +# answer = input('Enter a number ') +# if answer == 'quit': +# break +# print(f'You entered: {answer}') +# print() + + +# Создаем игру в монетку +HEADS = 'heads' +TAILS = 'tails' +COIN_VALUES = [HEADS, TAILS] +RULETKA = [] +for i in range(19): + RULETKA.append(COIN_VALUES[0]) + RULETKA.append(COIN_VALUES[1]) + + + +def flip_coin(): + return random.choice(RULETKA) + + +def play_martingle (*, starting_funds: int, min_bet: int, max_bet: int) -> int: + steps_to_loose = 0 + current_funds = starting_funds + current_bet = min_bet + current_funds_max = [] + zero1 = 0 + heads1 = 0 + tails1 = 0 + while current_funds > 0: + current_funds_max.append(current_funds) + # print('======') + steps_to_loose += 1 + #print(f'{current_funds=}') + current_funds -= current_bet + #print(f'{current_bet=}') + flipped_coin_value = flip_coin() + #if current_funds == 1000: + # break + if flipped_coin_value == 'heads': + win = current_bet * 2 + #print(f'{win=}') + current_funds += win + current_bet = min_bet + heads1 += 1 + elif flipped_coin_value == 'ZERO': + zero1 += 1 + else: + #print('loose') + tails1 += 1 + current_bet *= 2 + if current_bet > max_bet: + current_bet = min_bet + if current_bet > current_funds: + current_bet = current_funds + + return steps_to_loose, max(current_funds_max), int(sum(current_funds_max) / len(current_funds_max)), zero1, heads1, tails1 + +# print(play_martingle(starting_funds=1000, min_bet=1, max_bet=100)) + + +def simulate_play_martingle(*, starting_funds: int, min_bet: int, max_bet: int, n_games: int): + total_steps_to_loose = [] + total_sum = [] + win_player = 0 + for i in range(n_games): + step_to_loose = play_martingle(starting_funds=starting_funds, min_bet=min_bet, max_bet=max_bet) + if step_to_loose[1] > 1000: + win_player += 1 + #total_steps_to_loose.append(step_to_loose) + total_sum.append(step_to_loose[1]) + + + return win_player, sum(total_sum) - n_games * starting_funds, total_steps_to_loose + + +print(simulate_play_martingle(starting_funds=100, min_bet=1, max_bet=100, n_games=10)) \ No newline at end of file From a4e0216da4f536002c81948163310c23f0c1d512 Mon Sep 17 00:00:00 2001 From: Aleksandr Makarov Date: Sat, 6 Apr 2024 17:58:28 +0400 Subject: [PATCH 09/22] Add new files --- _12_while_loop/{my_while => my_while.py} | 0 _13_tuples/my_tuple.py | 40 +++++++++ _14_dict/_5_howework.py | 1 + _14_dict/my_dict.py | 107 +++++++++++++++++++++++ _14_dict/my_homework.py | 87 ++++++++++++++++++ 5 files changed, 235 insertions(+) rename _12_while_loop/{my_while => my_while.py} (100%) create mode 100644 _13_tuples/my_tuple.py create mode 100644 _14_dict/my_dict.py create mode 100644 _14_dict/my_homework.py diff --git a/_12_while_loop/my_while b/_12_while_loop/my_while.py similarity index 100% rename from _12_while_loop/my_while rename to _12_while_loop/my_while.py diff --git a/_13_tuples/my_tuple.py b/_13_tuples/my_tuple.py new file mode 100644 index 0000000..1a0f162 --- /dev/null +++ b/_13_tuples/my_tuple.py @@ -0,0 +1,40 @@ +print('Объявим tuple переберём в цикле for и проверим на истинность, сделаем вывод по индексу') +user_roles = ('admin', 'editor', 'viewer') +for role in user_roles: + print(role) +print('admin' in user_roles) +print('writer' in user_roles) +print(user_roles[0]) +print() + + +print('Первый tuple хоть и в скобках, но без запятой это не tuple') +not_tuple = ('Gid') +print(type(not_tuple)) # Не tuple, один элемент +my_tuple = ('gid',) +print(type(my_tuple)) # Это tuple, запятой мы показываем это +print() + + +print('Распаковываем кортеж, важно, что бы кортеж был равен кол-ву переменных') +role_1, role_2, role_3 = user_roles +print(role_1) +print(role_2) +print(role_3) +print() + + +print('Распаковываем кортеж где второй элемент пропущен символом _') +role_4, _, role_6 = user_roles +print(role_4) +print(role_6) +print() + + +print('Распаковываем список, важно, что бы список был равен кол-ву переменных') +list_user_roles = ['admin', 'editor', 'viewer'] +role_7, role_8, role_9 = user_roles +print(role_7) +print(role_8) +print(role_9) +print() \ No newline at end of file diff --git a/_14_dict/_5_howework.py b/_14_dict/_5_howework.py index e559a33..85998c5 100644 --- a/_14_dict/_5_howework.py +++ b/_14_dict/_5_howework.py @@ -23,6 +23,7 @@ def get_best_students(*, students: list[dict]) -> list[dict]: best_average_grade = 0 for student in students: grades = student["grades"] + print(grades) if grades is None: average_grade = 0 else: diff --git a/_14_dict/my_dict.py b/_14_dict/my_dict.py new file mode 100644 index 0000000..8785e9d --- /dev/null +++ b/_14_dict/my_dict.py @@ -0,0 +1,107 @@ +print('Вывод объявленного словаря') +person = { + 'name': 'Alice', + 'age': 25, + 'city': 'New York' +} +print(person) +print() + + +print('Добавляем в словарь key:value') +person['job'] = 'Engineer' +print(person) +print() + + +print('Объявляем словарь по другому') +person_2 = {} +person_2['name'] = 'Lise' +person_2['age'] = 21 +person_2['city'] = 'Nevada' +print(person_2) +print() + + +print('Вывод значения по ключу') +print(person_2['city']) # <--- Вывод города +# print(person_2['country']) <--- Запрос неизвестного ключа выдаст ошибку KeyError +print(person_2.get('city')) # <--- Тоже вывод города +print(person_2.get('country')) # <--- Вывод страны, выведет None, так как нет ключа +print(person_2.get('country', 'USA')) # <--- Выведет USA так как ключа нет, но указано значение по умолчанию +print(person_2.get('city', 'Colorado')) # <--- Выведет Nevada, хоть и указано значение по умолчанию, но такой ключ в словаре есть +print() + + +print('Вывод ключей и значений через циклы') +for k in person_2: # Вывод только ключей + print(k) +for k in person_2: # Вывод только ключей + print(person[k]) +print() +# Распаковка key:value в виде tuple +for item in person_2.items(): + print(item, ' <-----> ', type(item)) + key, value = item # Распаковка кортежа из item - key: value + print(key, value) # Вывод распакованного кортежа +print() +# Распаковка сразу по key:value +for key, value in person_2.items(): + print(key) + print(value) +print() +# Итерация только по key +for key in person_2.keys(): + print(key) +print() +# Итерация только по value +for value in person_2.values(): + print(value) +print() + + +print('Сравнение словарей, порядок key не важен ключи всегда уникальные') +person_3 = { + 'name': 'Rick', + 'age': 24, + 'city': 'Dublin' +} +person_4 = { + 'city': 'Dublin', + 'age': 25, + 'name': 'Rick' +} +person_5 = { + 'name': 'Kate', + 'age': 24, + 'city': 'Denver' +} +x = [25] +if person_3['age'] == max(x): + print(person_3) +else: + print(person_4) +# print(person_3 == person_4) # Вывод True так как key and value одинаковые, равные +# print(person_3 == person_5) # Вывод False так как value разные либо разные ключи +# print() + + +print('Объединение двух словарей') +person_6 = { + 'name': 'Kate', + 'age': 24, + 'city': 'Denver' +} +print(person_6) +additional_person_info = { + 'job': 'Engineer', + 'age': 25, + 'married': True, + 'city': 'Nevada' +} + +person_6.update(additional_person_info) # Метод добавляет в первый словарь недостающие key и заменяет у имеющихся key значения на новые +# person_6 = person_6 | additional_person_info # Метод идентичен верхнему, просто другой синтаксис +print(person_6) + + diff --git a/_14_dict/my_homework.py b/_14_dict/my_homework.py new file mode 100644 index 0000000..d844798 --- /dev/null +++ b/_14_dict/my_homework.py @@ -0,0 +1,87 @@ +# задание +# Есть список словарей со студентами `students`. В каждом объекте есть имя и фамилия студента, +# а также список оценок (целых чисел). Нужно написать функцию get_best_students, которая берёт студентов и находит того, +# у кого средний балл наибольший. Возвращает функция список студентов с лучшим баллом. У некоторых студентов в оценках +# есть None: их среднюю оценку мы считаем равной 0. + + +students = [ + {"name": "John", "surname": "Doe", "grades": [5, 5, 4, 4]}, + {"name": "Jane", "surname": "Doe", "grades": [4, 3, 4, 3, 5]}, + {"name": "Bill", "surname": "Gates", "grades": [5, 5, 5, 3]}, + {"name": "Steve", "surname": "Jobs", "grades": [3, 5, 4, 3, 3, 5]}, + {"name": "Guido", "surname": "Van Rossum", "grades": [5, 3, 5, 4, 5, 5, 3, 5]}, + {"name": "Elon", "surname": "Musk", "grades": None} +] + + +# Моё решение вариант 1 +def get_best_students(student): + top_students = [] + score_max = [] + for i in range(len(student)): + #print(student[i]) + if (student[i]['grades']) is not None: + student[i]['grades'] = (sum(student[i]['grades']) / len(student[i]['grades'])) + score_max.append(student[i]['grades']) + else: + student[i]['grades'] = 0 + score_max.append(student[i]['grades']) + #if student[i]['grades'] == max(score_max): + + for i in range(len(student)): + if student[i]['grades'] == max(score_max): + top_students.append(student[i]) + return top_students + + + +# print(get_best_students(students)) +# print(students[3]) + +# Моё решение вариант 2, правильный. +def best_students(students): + top_students = [] + score_max = [] + for student in students: + print(student) + if (student['grades']) is not None: + student['grades'] = (sum(student['grades']) / len(student['grades'])) + score_max.append(student['grades']) + else: + student['grades'] = 0 + score_max.append(student['grades']) + #if student['grades'] == max(score_max): + + for student in students: + if student['grades'] == max(score_max): + top_students.append(student) + return top_students + + + +# print(best_students(students)) + + +# лучшее решение вариант 3, правильный. +def best_students(students): # Объявили функцию + top_students = [] # Объявили лист + score_max = 0 # Объявили переменную int + for student in students: # Цикл по листу словарей. Где каждая итерация передаёт словарь по индексу от [0] до [5] + #print(student) # Вывод словарей по очереди + grade = student['grades'] # В переменную grade кладём значение 'grades' итерируемого студента + if (grade) is not None: # Если переменная не является None, выполняем тело условия + grade_this_student = (sum(grade) / len(grade)) # В новую переменную итерируемого студента вносим среднее значение + else: + grade_this_student = 0 # Если переменная None присваиваем переменной 0 + if grade_this_student > score_max: # Если grade итерируемого больше переменной score_max + score_max = grade_this_student # То в Score_max записываем число из grade итерируемого + top_students = [student] # И в переменную top_students кладем list [итерируемого словаря] + elif grade_this_student == score_max: # Если grade итерируемого равняется score_max + top_students.append([student]) # То в список студентов, добавляем [итерируемого студента] в list + + return top_students + + + +print(best_students(students)) \ No newline at end of file From 876afabe0110e38bacc7157f575cb7c8ba96e367 Mon Sep 17 00:00:00 2001 From: Aleksandr Makarov Date: Sat, 6 Apr 2024 20:28:13 +0400 Subject: [PATCH 10/22] Add my_function --- _07_lists/{list_my_notes => my_list.py} | 0 _15_function_advanced/my_function.py | 61 +++++++++++++++++++++++++ 2 files changed, 61 insertions(+) rename _07_lists/{list_my_notes => my_list.py} (100%) create mode 100644 _15_function_advanced/my_function.py diff --git a/_07_lists/list_my_notes b/_07_lists/my_list.py similarity index 100% rename from _07_lists/list_my_notes rename to _07_lists/my_list.py diff --git a/_15_function_advanced/my_function.py b/_15_function_advanced/my_function.py new file mode 100644 index 0000000..1c37fef --- /dev/null +++ b/_15_function_advanced/my_function.py @@ -0,0 +1,61 @@ +print('Через *args добавляем в фунцию n количество символов') +def add_all (*args): + summury = 0 + for num in args: + summury += num + return summury +print(add_all(1, 2, 3, 5, 7)) +print() + + +print('Добавляем два списка через * в функцию') +values = [1, 2, 3, 4, 5] +other_values = [6, 7, 8, 9, 10] +print(add_all(*values, *other_values)) +print() + + +print('Вызов функции с аргументами **kwargs') +def introduce(**kwargs): + for key, value in kwargs.items(): + print(key) + print(value) + +person_1 = { + 'name': 'Kate', + 'age': 24, + 'city': 'Denver' +} +introduce(**person_1) +print() + + +print('Вызов функции с аргументами **kwargs') +def func_with_all_arguments(x: int, y: int, *args, value: int = 6, **kwargs): + print(x, y) + print(args) + print(value) + print(kwargs) + +func_with_all_arguments(1, 2, 3, 4, 5, **person_1) +print() + +print('Функция возвращает модифицированный словарь и несколько значений return') +def modify_dict(old_dict: dict, **kwargs) -> tuple[dict, bool]: + is_modified = False # По умолчанию is_modified = False + + for key, value in kwargs.items(): # Раскладываем второе значение на ключ значение + # print(old_dict.get(key)) # Что выводится для наглядности + if old_dict.get(key) != value: # Если в старом словаре по ключу из второго словаря kwargs, значение не ровно значению полученному из kwargs + old_dict[key] = value # Тогда старый словарь[ключ из kwargs] мы записываем через = значение переданное из kwargs + is_modified = True # Переменная is_modified становится True + + return old_dict, is_modified + + +product = {'id': 1, 'name': 'Laptop', 'price': 999.99, 'in_stock': False} + +# Передаем в kwargs словарь с in_stock=True, а в старом он был False, значит словарь поменяется. +structure, modify = modify_dict(old_dict=product, in_stock=True) # Записываем два return в две переменные +print(f'Словарь {structure} был ли модифицирован {modify}') +print(type(structure)) \ No newline at end of file From c5246c13932b3b856e06b8d6c030f9c48ed5ffc6 Mon Sep 17 00:00:00 2001 From: Aleksandr Makarov Date: Tue, 9 Apr 2024 22:53:35 +0400 Subject: [PATCH 11/22] Add my_json --- _16_json/my_json.py | 21 +++++++++++++++++++++ 1 file changed, 21 insertions(+) create mode 100644 _16_json/my_json.py diff --git a/_16_json/my_json.py b/_16_json/my_json.py new file mode 100644 index 0000000..c64db7f --- /dev/null +++ b/_16_json/my_json.py @@ -0,0 +1,21 @@ +import json + +book = { + 'title': '1984', + 'author': 'George Orwell', + 'isbn': '978-0451524935', + 'uuid': 'a0eebc99-9c0b-4ef8-bb6d-6bb9bd380a11', + 'count': 30, + 'genres': ['dystopia'] +} + +json_string = json.dumps(book) + +print(type(json_string)) +print(json_string) + +json_string_1 = {"title": "1984", "author": "George Orwell", "isbn": "978-0451524935", "uuid": "a0eebc99-9c0b-4ef8-bb6d-6bb9bd380a11"} + +book = json.loads(json_string) +print(type(json_string_1)) +print(json_string_1) \ No newline at end of file From 46e0ccce477fbb29b8a280870fd102fb69aeef2b Mon Sep 17 00:00:00 2001 From: Aleksandr Makarov Date: Wed, 10 Apr 2024 00:11:02 +0400 Subject: [PATCH 12/22] Add my_request --- _18_requests/my_request.py | 31 +++++++++++++++++++++++++++++++ 1 file changed, 31 insertions(+) create mode 100644 _18_requests/my_request.py diff --git a/_18_requests/my_request.py b/_18_requests/my_request.py new file mode 100644 index 0000000..b645b9a --- /dev/null +++ b/_18_requests/my_request.py @@ -0,0 +1,31 @@ +import requests +import time + +url = 'https://www.binance.com/api/v3/ticker/price' + +response = requests.get(url, params={'symbol': 'SOLUSDT'}) + +# content = response.content +# print(content) +# print(type(content)) + +# price_object = response.json() +# print(price_object) +# print(type(price_object)) + +# price = float(price_object['price']) + +# print(price) + + +solana_prices = [] # Создали список цен +for i in range(30): # цикл 30 повторений + response = requests.get(url, params={'symbol': 'SOLUSDT'}) # Получаем ответ с параментрами с переданного url + price = float(response.json()['price']) # Сохраняем в прайс float с вызовом метода json() что бы перевести полученное в dict + solana_prices.append(price) # Добавляем в список solana_prices + time.sleep(1) # Замираем на 1 секунду с помощью модуля time + +print(solana_prices) +print(len(solana_prices)) +print(max(solana_prices)) +print(min(solana_prices)) From 355cd8d9e7a477212d4bb61fe9228f858c385ed9 Mon Sep 17 00:00:00 2001 From: Aleksandr Makarov Date: Wed, 10 Apr 2024 01:51:52 +0400 Subject: [PATCH 13/22] Add my_comprehansions --- _19_comprehensions/my_comprehansions.py | 51 +++++++++++++++++++++++++ 1 file changed, 51 insertions(+) create mode 100644 _19_comprehensions/my_comprehansions.py diff --git a/_19_comprehensions/my_comprehansions.py b/_19_comprehensions/my_comprehansions.py new file mode 100644 index 0000000..c555bf0 --- /dev/null +++ b/_19_comprehensions/my_comprehansions.py @@ -0,0 +1,51 @@ +# squares = [] +# for x in range(10): +# squares.append(x ** 2) +squares = [x ** 2 for x in range(10)] +print(squares) + + +# even_squares = [] +# for x in range(10): +# if x % 2 == 0: +# even_squares.append(x ** 2) +even_squares = [x ** 2 for x in range(10) if x % 2 == 0] +print(even_squares) + + +labelled_numbers = [] +numbers = [1, 2, 3, 4, 5] +#for num in numbers: +# if num % 2 == 0: +# labelled_numbers.append('even') +# else: +# labelled_numbers.append('odd') +labelled_numbers = ['even' if num % 2 == 0 else 'odd' for num in numbers] +print(labelled_numbers) + + +square_dict = {x: x ** 2 for x in range(10)} +print(square_dict) + + +matrix = [ + [1, 2, 3], + [4, 5 ,6], + [7, 8, 9] +] +#transpore_matrix = [ +# [1, 4, 7], +# [2, 5, 8], +# [3, 6, 9] +#] +transpore_matrix = [] +#for i in range(len(matrix)): +# transpore_row = [] +# for row in matrix: +# transpore_row.append(row[i]) +# transpore_matrix.append(transpore_row) +transpore_matrix = [[row[i] for row in matrix] for i in range(len(matrix))] +print(transpore_matrix) + +listmy = [i for i in range(1, 31)] +print(listmy) \ No newline at end of file From 53c42bcef58980397c29358159aa67b4fd45fdcd Mon Sep 17 00:00:00 2001 From: Aleksandr Makarov Date: Wed, 10 Apr 2024 02:11:06 +0400 Subject: [PATCH 14/22] Add my_sets --- _20_sets/my_sets.py | 33 +++++++++++++++++++++++++++++++++ 1 file changed, 33 insertions(+) create mode 100644 _20_sets/my_sets.py diff --git a/_20_sets/my_sets.py b/_20_sets/my_sets.py new file mode 100644 index 0000000..95ae6f9 --- /dev/null +++ b/_20_sets/my_sets.py @@ -0,0 +1,33 @@ +my_set = {1, 2, 3, 4, 5, 6} + +my_set1 = set() +for i in range(5): + my_set1.add(i) +my_set1.remove(2) # Удалили двойку +print(my_set1) # Вывод {0, 1, 3, 4} + + +my_set2 = {1, 2, 3, 3, 3, 3, 4, 4, 4, 5, 5, 5} +print(my_set2) # Вывод {1, 2, 3, 4, 5} + + +set1 = {1, 2, 3, 4, 5} +set2 = {4, 5, 6 ,7 ,8} +# Объединение сетов - складывает два множества +print(set1.union(set2)) # Вывод {1, 2, 3, 4, 5, 6, 7, 8} +# Пересичение сетов - общие значения двух множеств +print(set1.intersection(set2)) # Вывод {4, 5} +# Различие сетов - элементы множества которые отсутсвуют во втором множестве +print(set1.difference(set2)) # Вывод {1, 2, 3} + +squares = {x ** 2 for x in range(10)} +print(squares) + +print({1, 2, 3} == {3, 2, 1}) # Вывод True + + +numbers = [1, 2, 2, 3, 4, 4, 4, 5, 6, 6, 7] +#unique_numbers = set(numbers) +#unique_numbers = list(unique_numbers) +unique_numbers = list(set(numbers)) # Преобразовываем множество сразу в лист +print(unique_numbers) From a85c59eb804aafdebdf0a257bed3ffc630655ed7 Mon Sep 17 00:00:00 2001 From: Aleksandr Makarov Date: Wed, 10 Apr 2024 12:22:43 +0400 Subject: [PATCH 15/22] Add my_sorted_and_filter --- .../my_sorted_and_filter.py | 70 +++++++++++++++++++ 1 file changed, 70 insertions(+) create mode 100644 _21_sorted_filter_func/my_sorted_and_filter.py diff --git a/_21_sorted_filter_func/my_sorted_and_filter.py b/_21_sorted_filter_func/my_sorted_and_filter.py new file mode 100644 index 0000000..eaa52f8 --- /dev/null +++ b/_21_sorted_filter_func/my_sorted_and_filter.py @@ -0,0 +1,70 @@ +fruits = ['banana', 'apple', 'cherry', 'date'] +sorted_fruits = sorted(fruits) +print(sorted_fruits) # Вывод ['apple', 'banana', 'cherry', 'date'] +sorted_fruits = sorted(fruits, reverse=True) +print(sorted_fruits) # Вывод ['date', 'cherry', 'banana', 'apple'] + + +fruits = ['banana', 'apple', 'cherry', 'date'] +def sort_by_len(element : str) -> int: + return len(element) + +sorted_fruits = sorted(fruits, key=sort_by_len) +print(sorted_fruits) # Вывод ['date', 'apple', 'banana', 'cherry'] + + +people = [ + {'name': 'Alice', 'age': 25}, + {'name': 'Nik', 'age': 21}, + {'name': 'Nina', 'age': 35}, + {'name': 'Anna', 'age': 21}, + {'name': 'Micasa', 'age': 25} +] + +def sort_by_age(person: dict) -> int: + return person['age'] + +sorted_people_age = sorted(people, key=sort_by_age) +print(sorted_people_age) # Вывод [{'name': 'Nik', 'age': 21}, {'name': 'Anna', 'age': 21}, {'name': 'Alice', 'age': 25}, {'name': 'Micasa', 'age': 25}, {'name': 'Nina', 'age': 35}] + + + +def sort_by_age_name(element: dict) -> tuple[int, str]: + return element['age'], element['name'] + +sorted_people_age_name = sorted(people, key=sort_by_age_name) +print(sorted_people_age_name) # Вывод [{'name': 'Anna', 'age': 21}, {'name': 'Nik', 'age': 21}, {'name': 'Alice', 'age': 25}, {'name': 'Micasa', 'age': 25}, {'name': 'Nina', 'age': 35}] + +# FILTER # FILTER # FILTER # FILTER # FILTER # FILTER # FILTER # FILTER # FILTER # FILTER # FILTER # FILTER +# FILTER # FILTER # FILTER # FILTER # FILTER # FILTER # FILTER # FILTER # FILTER # FILTER # FILTER # FILTER +# FILTER # FILTER # FILTER # FILTER # FILTER # FILTER # FILTER # FILTER # FILTER # FILTER # FILTER # FILTER + +def is_even(n: int) -> bool: + return n % 2 == 0 + +numbers = [1, 2, 3, 4, 5, 6, 7, 8, 9] + +filtered_numbers = filter(is_even, numbers) +print(type(filtered_numbers)) # Вывод +print(filtered_numbers) # Вывод +# Обернем в лист +filtered_numbers = list(filter(is_even, numbers)) +print(type(filtered_numbers)) # Вывод +print(filtered_numbers) # Вывод [2, 4, 6, 8] + + + +people = [ + {'name': 'Alice', 'age': 25}, + {'name': 'Nik', 'age': 15}, + {'name': 'Nina', 'age': 35}, + {'name': 'Anna', 'age': 14}, + {'name': 'Micasa', 'age': 18} +] + +def is_adult(person: dict) -> bool: + return person['age'] >= 18 + +filtered_age_people = list(filter(is_adult, people)) # Фильтруем, оборачиваем в лист +filtered_age_people = sorted(filtered_age_people, key=sort_by_age) # Сортируем по возрасту +print(filtered_age_people) # Вывод [{'name': 'Micasa', 'age': 18}, {'name': 'Alice', 'age': 25}, {'name': 'Nina', 'age': 35}] From c3d792c1f13ab5289e5c0f2f0ff1fa478d8d556e Mon Sep 17 00:00:00 2001 From: Aleksandr Makarov Date: Wed, 10 Apr 2024 12:51:34 +0400 Subject: [PATCH 16/22] Add my_lambda --- _22_lambda_func/_2_homework.py | 5 +++++ _22_lambda_func/my_lambda | 21 +++++++++++++++++++++ 2 files changed, 26 insertions(+) create mode 100644 _22_lambda_func/my_lambda diff --git a/_22_lambda_func/_2_homework.py b/_22_lambda_func/_2_homework.py index da7b109..5d8452f 100644 --- a/_22_lambda_func/_2_homework.py +++ b/_22_lambda_func/_2_homework.py @@ -13,3 +13,8 @@ # решение min_people = min(people, key=lambda x: (x["age"], x["name"])) print(min_people) # Output: {'name': 'Bob', 'age': 20} + + +# Не прочитал, что нужны минимальные элементы +my_people = sorted(people, key=lambda people: (people['age'], people['name'])) +print(my_people) # Вывод [{'name': 'Bob', 'age': 20}, {'name': 'Charlie', 'age': 20}, {'name': 'Alice', 'age': 25}, {'name': 'Diana', 'age': 30}] \ No newline at end of file diff --git a/_22_lambda_func/my_lambda b/_22_lambda_func/my_lambda new file mode 100644 index 0000000..2d8361d --- /dev/null +++ b/_22_lambda_func/my_lambda @@ -0,0 +1,21 @@ +def sort_by_len(element: str) -> int: + return len(element) +lambda element: len(element) + + + +sort_by_len_lambda = lambda element: len(element) +print(sort_by_len('banana')) # Вывод 6 +print(sort_by_len_lambda('banana')) # Вывод 6 + + + +fruits = ['banana', 'apple', 'cherry', 'date'] +sorted_fruits = sorted(fruits, key=lambda element: len(element)) +print(sorted_fruits) + + + +fruits = ['banana', 'apple', 'cherry', 'date'] +sorted_len_fruits = max(fruits, key=lambda element: len(element)) +print(sorted_len_fruits) # Вывод banana \ No newline at end of file From 7c75317ec92c636e722f546c6ae42464bb52b52e Mon Sep 17 00:00:00 2001 From: Aleksandr Makarov Date: Wed, 10 Apr 2024 12:52:34 +0400 Subject: [PATCH 17/22] Update my_lambda --- _22_lambda_func/my_lambda | 8 +++++--- 1 file changed, 5 insertions(+), 3 deletions(-) diff --git a/_22_lambda_func/my_lambda b/_22_lambda_func/my_lambda index 2d8361d..233b49e 100644 --- a/_22_lambda_func/my_lambda +++ b/_22_lambda_func/my_lambda @@ -9,13 +9,15 @@ print(sort_by_len('banana')) # Вывод 6 print(sort_by_len_lambda('banana')) # Вывод 6 - +# Используем lambda для сортировки массива fruits = ['banana', 'apple', 'cherry', 'date'] sorted_fruits = sorted(fruits, key=lambda element: len(element)) print(sorted_fruits) - +# Используем lambda функции сортировки max fruits = ['banana', 'apple', 'cherry', 'date'] sorted_len_fruits = max(fruits, key=lambda element: len(element)) -print(sorted_len_fruits) # Вывод banana \ No newline at end of file +print(sorted_len_fruits) # Вывод banana + + From 6e2f2cfbce341c8100a21b5597a757f6c756af69 Mon Sep 17 00:00:00 2001 From: Aleksandr Makarov Date: Wed, 10 Apr 2024 17:12:13 +0400 Subject: [PATCH 18/22] Add my_try_except --- _23_try_except/my_try_except.py | 25 +++++++++++++++++++++++++ 1 file changed, 25 insertions(+) create mode 100644 _23_try_except/my_try_except.py diff --git a/_23_try_except/my_try_except.py b/_23_try_except/my_try_except.py new file mode 100644 index 0000000..aca8165 --- /dev/null +++ b/_23_try_except/my_try_except.py @@ -0,0 +1,25 @@ +import requests + + +def find_average(*, numbers: list) -> float: + return sum(numbers) / len(numbers) + +print(find_average(numbers=[1, 2, 3, 4, 5, 6, 7])) # Вывод 4.0 + +try: # Попытка вополнить + find_average(numbers=[]) # Пустой массив падает с ошибкой ZeroDivisionError: division by zero +except ZeroDivisionError: # Если ошибка + print('The list is empty') + + +print('we are here') + + + +try: + response = requests.get('https://api.binance.com/api/v3/ticker/price', params={'symbol': 'BTCUSDT'}) + bitcoin_price = response.json()["price"] + price = float(bitcoin_price) + print(price) +except requests.exceptions.ConnectionError as error: + print(f"Something goes wrong: {error}") From e521047cabadb7e7a1932400cc9acf07e5d024a3 Mon Sep 17 00:00:00 2001 From: Aleksandr Makarov Date: Wed, 17 Apr 2024 03:13:17 +0400 Subject: [PATCH 19/22] Add my_class --- _24_classes/my_class.py | 171 ++++++++++++++++++++++++++++++++++++++++ 1 file changed, 171 insertions(+) create mode 100644 _24_classes/my_class.py diff --git a/_24_classes/my_class.py b/_24_classes/my_class.py new file mode 100644 index 0000000..00dff0d --- /dev/null +++ b/_24_classes/my_class.py @@ -0,0 +1,171 @@ +# class Ork: +# def __init__(self, *, level: int) -> None: +# self.level = level +# self.health_points = 100 * level +# self.attack_power = 10 * level + +# def attack(self): +# print(f'Ork attacks with {self.attack_power} power') + +# def __str__(self) -> str: +# return f'Ork (level: {self.level}), hp: {self.health_points}' + +# def level_up(self, level): +# self.level += level + + +# ork = Ork(level=2) +# print(ork.level) +# print(ork.health_points) + +# ork.attack() + +# ork.level_up(2) + +# print(ork.level) +# print(ork) + + +# class Elf: +# def __init__(self, *, level: int) -> None: +# self.level = level +# self.health_points = 50 * level +# self.attack_power = 15 * level + +# def attack(self): +# print(f'Elf attacks with {self.attack_power} power') + +# def __str__(self) -> str: +# return f'Elf (level: {self.level}), hp: {self.health_points}' + + + + + + + +# class Character: +# def __init__(self, *, level: int) -> None: +# self.level = level +# self.health_points = self.base_health_points * level +# self.attack_power = self.base_attack_power * level + +# def attack(self, *, target: 'Character') -> None: +# print( +# f'{self.character_name} attacks {target.character_name} ({target.health_points} health_points) ' +# f'with {self.attack_power} power.' +# ) +# target.health_points -= self.attack_power +# print(f'After attack {target.character_name} hp has {target.health_points}') + +# def is_alive(self) -> bool: +# return self.health_points > 0 + +# def __str__(self) -> str: +# return f'{self.character_name} (level: {self.level}, hp: {self.health_points})' + +# class Ork(Character): +# base_health_points = 100 +# base_attack_power = 10 +# character_name = 'Ork' + + +# class Elf(Character): +# base_health_points = 50 +# base_attack_power = 15 +# character_name = 'Elf' + + +# def fight(*, character_1: Character, character_2: Character) -> None: +# while character_1.is_alive() and character_2.is_alive(): +# character_1.attack(target=character_2) +# if character_2.is_alive(): +# character_2.attack(target=character_1) + +# print(f'Character 1: {character_1}, is_alive: {character_1.is_alive()}') +# print(f'Character 2: {character_2}, is_alive: {character_2.is_alive()}') + + +# ork = Ork(level=1) +# elf = Elf(level=3) + +# fight(character_1=ork, character_2=elf) + + + + + +class Character: + def __init__(self, *, level: int) -> None: + self.level = level + self.health_points = self.base_health_points * level + self.attack_power = self.base_attack_power * level + + def attack(self, *, target: 'Character') -> None: + target.got_damage(damage=self.attack_power) + + def got_damage(self, *, damage: int) -> None: + damage = damage * (100 - self.defence) / 100 + damage = round(damage) + self.health_points -= damage + + def is_alive(self) -> bool: + return self.health_points > 0 + + @property + def defence(self) -> int: + defence = self.base_defence * self.level + return defence + + @property + def max_health_points(self) -> int: + return self.level * self.base_health_points + + def health_point_percent(self): + return self.health_points / self.max_health_points * 100 + + def __str__(self) -> str: + return f'{self.character_name} (level: {self.level}, hp: {self.health_points})' + +class Ork(Character): + base_health_points = 100 + base_attack_power = 10 + base_defence = 15 + character_name = 'Ork' + + @property + def defence(self) -> int: + defence = super().defence + if self.health_points < 50: + defence *= 3 + + return defence + + +class Elf(Character): + base_health_points = 50 + base_attack_power = 15 + base_defence = 10 + character_name = 'Elf' + + def attack(self, *, target: Character) -> None: + attack_power = self.attack_power + if target.health_point_percent() < 60: + attack_power = self.attack_power * 3 + target.got_damage(damage=attack_power) + + +def fight(*, character_1: Character, character_2: Character) -> None: + while character_1.is_alive() and character_2.is_alive(): + character_1.attack(target=character_2) + if character_2.is_alive(): + character_2.attack(target=character_1) + + print(f'Character 1: {character_1}, is_alive: {character_1.is_alive()}') + print(f'Character 2: {character_2}, is_alive: {character_2.is_alive()}') + + +ork = Ork(level=1) +elf = Elf(level=1) + +fight(character_1=ork, character_2=elf) \ No newline at end of file From 42756ebad2bf6bd2e4579f855b544b6df69eeac1 Mon Sep 17 00:00:00 2001 From: Ofmeret <165801587+Ofmeret@users.noreply.github.com> Date: Fri, 13 Dec 2024 16:25:32 +0400 Subject: [PATCH 20/22] Update _1_print_funcupdate --- _01_print/_1_print_func.py | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/_01_print/_1_print_func.py b/_01_print/_1_print_func.py index a5fb747..6aa0f3c 100644 --- a/_01_print/_1_print_func.py +++ b/_01_print/_1_print_func.py @@ -1,5 +1,5 @@ print("Hello, world!") - +print("Hello, world!") print("Hello,", "world!") From 649f48290e8816eaf5f132a0a4bea2b7fc9cf855 Mon Sep 17 00:00:00 2001 From: Aleksandr Makarov Date: Fri, 13 Dec 2024 16:46:19 +0400 Subject: [PATCH 21/22] class_up --- _24_classes/my_class.py | 3 ++- 1 file changed, 2 insertions(+), 1 deletion(-) diff --git a/_24_classes/my_class.py b/_24_classes/my_class.py index 00dff0d..dce6f23 100644 --- a/_24_classes/my_class.py +++ b/_24_classes/my_class.py @@ -168,4 +168,5 @@ def fight(*, character_1: Character, character_2: Character) -> None: ork = Ork(level=1) elf = Elf(level=1) -fight(character_1=ork, character_2=elf) \ No newline at end of file +fight(character_1=ork, character_2=elf) +#test \ No newline at end of file From b8e3aca2a012b039d293bbc985eb3df12aa7ab61 Mon Sep 17 00:00:00 2001 From: Aleksandr Makarov Date: Fri, 13 Dec 2024 16:51:21 +0400 Subject: [PATCH 22/22] class_del --- _24_classes/my_class.py | 3 +-- 1 file changed, 1 insertion(+), 2 deletions(-) diff --git a/_24_classes/my_class.py b/_24_classes/my_class.py index dce6f23..00dff0d 100644 --- a/_24_classes/my_class.py +++ b/_24_classes/my_class.py @@ -168,5 +168,4 @@ def fight(*, character_1: Character, character_2: Character) -> None: ork = Ork(level=1) elf = Elf(level=1) -fight(character_1=ork, character_2=elf) -#test \ No newline at end of file +fight(character_1=ork, character_2=elf) \ No newline at end of file