Решение модуля 7.3 Инди-курс программирования на Python

Модуль 7.3 (Возвращаемое значение функции. Оператор return). Оператор return позволяет вернуть из функции значение, которое потом мы можем использовать для своих целей.

Что выведет следующий код?
def square(x):
    print(x**2)

a = square(6)
print(a)
36, а потом None
Что выведет следующий код?
def square(x):
    print(x**2)

a = square(6)
print(a)
1

Давайте считать человека подростком, если его возраст находится в пределах от 12 до 17 лет. Напишите функцию is_person_teenager , которая помогает по возрасту определить является ли человек подростком или нет.

Функция is_person_teenager принимает на вход возраст человека и возвращает True или False

Нужно написать только определение функций is_person_teenager 

def is_person_teenager(num):
    return 12 <= num <= 17   # возвращает True если человек является подростком, иначе False

Напишите функцию factorial, которая принимает на вход одно неотрицательное число, и возвращает значение факториала данного числа.

Нужно написать только определение функции factorial

factorial(3) => 6
factorial(1) => 1
factorial(0) => 1
factorial(5) => 120

# знак => обозначает return
def factorial(n):
    factor = 1          # создаем переменную для подсчета факториала
    for i in range(1, n + 1):  # проходимся по числам от 1 до заданного числа и умножаем на переменную factor
        factor *= i
    return factor       # возвращает факториал(результат переменной factor)

Напишите функцию generate_fizz_buzz_list, которая принимает одно целое число n — размер списка. Функция generate_fizz_buzz_list должна

  1. обойти числа от 1 до n включительно и каждое такое число проверить последовательно на п2 — п5
  2. Если число кратно и трем, и пяти, то в список заносим строку FizzBuzz 
  3. Если число кратно трем, то в список заносим строку Fizz
  4. Если число кратно пяти, то в список заносим строку Buzz
  5. Если число не кратно ни трем ни пяти, то в список заносим само это число

В итоге функция generate_fizz_buzz_list должна вернуть сформированный список из n элементов. Ниже показаны примеры вызова:

generate_fizz_buzz_list(3)  => [1, 2, 'Fizz']
generate_fizz_buzz_list(7)  => [1, 2, 'Fizz', 4, 'Buzz', 'Fizz', 7]
generate_fizz_buzz_list(15) => [1, 2, 'Fizz', 4, 'Buzz', 'Fizz', 7, 8, 'Fizz', 'Buzz', 11, 'Fizz', 13, 14, 'FizzBuzz']

Ваша задача написать только определение функции generate_fizz_buzz_list

def generate_fizz_buzz_list(number):
    sp = []                      # создаем пустой список для добавления в него определённых значений
    for i in range(1, number + 1):    # циклом проходимся по числам от 1 до заданного 
        if i % 3 == 0 and i % 5 == 0: # если число кратно 3 и 5, то в список добавляем FizzBuzz
            sp.append('FizzBuzz')
        elif i % 3 == 0:         # если кратно только 3, то добавляем Fizz
            sp.append('Fizz')
        elif i % 5 == 0:         # если кратно только 5, то добавляем Buzz
            sp.append('Buzz')
        else:                    # если не кратно ни 5 ни 3, то добавляем само число
            sp.append(i)
    return sp                    # возвращаем полученный список

В этой задаче вам необходимо воспользоваться уже готовой функцией gcd(a, b), которая принимает два числа и находит наибольших общий делитель для них.

Ваша задача при помощи функции gcd определить НОД произвольного количества чисел.

def gcd(a, b):
    while b > 0:
        a, b = b, a % b  
    return a  

n = int(input())  # Получаем количество чисел, которые будем сравнивать.
s = int(input())  # Получаем первое число.

for i in range(n - 1):  # Запускаем цикл для ввода оставшихся (n-1) чисел.
    b = int(input())    # Получаем следующее число.
    s = gcd(s, b)       # Вычисляем НОД текущего значения a и введенного числа b.

print(s)      # Выводим наибольший общий делитель всех введенных чисел.

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

find_duplicate([1, 1, 1, 1, 1, 2, 2, 2, 2]) => [1, 2]
find_duplicate([2, 1, 1, 1, 1, 1, 2, 2, 2, 2]) => [2, 1]
find_duplicate([1, 2, 3, 4]) => []
find_duplicate([1, 2, 3, 4, 3]) => [3]

Ваша задача написать только определение функции find_duplicate

def find_duplicate(lst):        
    sp = []         # создаем пустой список для добавления дублей чисел
    for i in lst:   # проходимся по введённому списку 
        if i not in sp and lst.count(i) > 1:  # если числа нет ещё в списке и оно повторяется во введенном списке больше 1 раза, то добавляем его в список
            sp.append(i)
    return sp       # возвращаем полученный список с дублями

Напишите функцию first_unique_char, которая принимает строку символов и возвращает целое число: позицию первого уникального символа в строке. В случае, если уникальных символов в переданной строке нет, верните -1. Регистр символов не учитывайте.

Ваша задача написать только определение функции first_unique_char

def first_unique_char(s):
    for i in s.lower():       # циклом проходимся по строке опущенной в нижний регистр
        if s.count(i) == 1:   # если этот символ встречается в строке 1 раз выводим его индекс
            return (s.index(i))
    else:                     # если мы не нашли уникального символа, выводим -1
        return -1

Ваша задача написать функцию format_name_list, которая принимает список словарей, у каждого словаря в этом списке есть только ключ name.

Функция format_name_list должна вернуть строку, в которой все имена из списка разделяются запятой кроме последних двух имен, они должны быть разделены союзом «и». Если в списке нет ни одного имени, функция должна вернуть пустую строку. Ниже представлены примеры:

format_name_list([{'name': 'Bart'}, {'name': 'Lisa'}, {'name': 'Maggie'}]) => 'Bart, Lisa и Maggie'

format_name_list([{'name': 'Bart'}, {'name': 'Lisa'}]) => 'Bart и Lisa'

format_name_list([{'name': 'Bart'}]) => 'Bart'

format_name_list([]) => ''

Ваша задача написать только определение функции format_name_list

def format_name_list(names: list[dict]) -> str:
    sp = []             # создаем пустой список для занесения туда имен
    for i in names:     # проходимся по словарям и из них в список добавляем имена
        sp.append(i['name'])
    if len(sp) == 0:    # проверяем если в списке нет имен, то выводим пустую строку
        return ''
    elif len(sp) == 1:  # если в списке 1 имя, то выводим это единственное имя
        return sp[0]
    else:               # иначе проверяем...
        if len(sp) == 2:  # если в списке 2 имени то мы их выводим через "и"
            return f'{sp[0]} и {sp[1]}'
            
        else:           # иначе, если в списке больше 2 имен, то выводим все имена через запятую, кроме 2 последних - их выводим через и
            a = ''
            for i in range(1, len(sp) - 1):
                a += (sp[i - 1] + ', ')
            a += f'{sp[-2]} и {sp[-1]}'
            return a

Ваша задача написать функцию get_domain_name, которая принимает строку url, извлекает из нее доменное имя и возвращает его в качестве строки

get_domain_name("http://google.com") => "google"
get_domain_name("http://google.co.jp") => "google"
get_domain_name("www.xakep.ru") => "xakep"
get_domain_name("https://youtube.com") => "youtube"
get_domain_name("https://www.asos.com") => "asos"
get_domain_name("http://www.lenovo.com") => "lenovo"

URL может начинаться с протоколов http://  https:// или с www. URL, начинающиеся с протоколов http://  https://, могут также содержать www.

Ваша задача написать только определение функции get_domain_name

def get_domain_name(url):       # объявляем функцию, которая принимает url-адрес
    if '//' in url:             # если в адресе есть 2 символа '/', то...
        a = url.split('//')     # мы в переменную сохраняем адрес разбитый на список по разделителю '//'
        if 'www' in a[1]:       # дальше проверяем есть ли в разделенном адресе после символов //, комбинация www, если есть, то ...
            a[1]= a[1].split('.')  # ту часть, которая после символов //, разбиваем ещё и по разделмтелю точка
            return a[1][1]      # выводим часть, которую мы разбивали по символу точка, и в списке по середине будет слово - его и выводим
        else:                   # иначе, если нету в адресе комбинации www, то часть после двойного слеша разделяем по точке и выводим часть от двойного слеша и до точки
            a[1] = a[1].split('.')
            return a[1][0]
    else:                       # иначе, если в адресе нету двойного слеша, то ...
        if 'www' in url:        # проверяем наличие комбинации www, если она есть, то разделяем адрес по точке и выводим строку от первой точки до второй
            a = url.split('.')
            return a[1]
        else:                   # иначе если нету ни двойного слеша, ни комбинации www, то делим по точке и выводим первую часть
            a = url.split('.')
            return a[0]

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

Ваша задача создать функцию trailing_zeros, которая принимает неотрицательное число, находит его факториал и возвращает сколько нулей на конце этого факториала .

trailing_zeros(6) =>  1, потому что 6! = 1 * 2 * 3 * 4 * 5 * 6 = 720
trailing_zeros(10) => 2, потому что 10! = 3 628 800
trailing_zeros(20) => 4, потому что 20! = 2 432 902 008 176 640 000

Нужно написать только определение функций trailing_zeros и factorial

def factorial(n):
    if n == 0:           # если введенное число равно нулю - возвращаем 0
        return 0
    else:                # иначе считаем факториал
        factor = 1       # создаем переменную для подсчета факториала
        for i in range(1, n + 1): # проходимся по числам от 1 до заданного числа и умножаем на переменную factor
            factor *= i
        return factor    # возвращает факториал(результат переменной factor)

def trailing_zeros(n):
    if n == 0:           # если ввели число 0, то факториал будет 0 и на конце будет 0 нулей
        return 0
    else:                # если число не равно 0
        null = 0         # создаем переменную для счетчика нулей
        for i in str(factorial(n))[::-1]:  # проходимся по перевернутой строке
            if i == '0': # если символ равен 0 то к счетчику прибавляем 1
                null += 1
            else:        # если встречается символ не равный нулю - прерываем цикл
                break
        return null      # выводим результат счетчика

К азотистым основаниям относят аденин (A), гуанин (G), цитозин (C) и тимин (T), который входит в состав только ДНК. Они обладают схожими структурами и химическими свойствами. Это гетероциклические органические соединения, производные пиримидина и пурина, входящие в состав нуклеотидов. Аденин и гуанин — производные пурина, а цитозин и тимин — производные пиримидина.

В этой задаче вам необходимо создать функцию count_AGTC, которая принимает на вход строку — последовательность ДНК, состоящая только из символов AGTC. Функция count_AGTC должна подсчитать количество каждого элемента в переданной последовательности и вернуть кортеж из найденных четырех количеств. Порядок элементов в кортеже должен быть именно таким AGTC

count_AGTC('AGGTC') => (1, 2, 1, 1)
count_AGTC('AAAATTT') => (4, 0, 3, 0)
count_AGTC('AGTTTTT') => (1, 1, 5, 0)
count_AGTC('CCT') => (0, 0, 1, 2)

Нужно написать только определение функции count_AGTC 

def count_AGTC(dna):
    A = dna.count('A')  # подсчитываем сколько раз буква А входит в строку
    G = dna.count('G')  # подсчитываем сколько раз буква G входит в строку
    T = dna.count('T')  # подсчитываем сколько раз буква T входит в строку
    C = dna.count('C')  # подсчитываем сколько раз буква C входит в строку
    return A,G,T,C      # выводим результат(если перечислить несколько переменных через запятую, то образуется из них кортеж)

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

Понравилась статья? Поделиться с друзьями:
Подписаться
Уведомить о
guest

4 комментариев
Новые
Старые Популярные
Межтекстовые Отзывы
Посмотреть все комментарии
Алексей
Алексей
10 месяцев назад

def gcd(a, b): while b > 0: a, b = b, a%b return asp = [] # создаем список для добавления в него введенных чиселfor i in range(int(input())): # циклом добавляем определенное количество раз число в список a = int(input()) sp.append(a)for i in range(max(sp), 0, -1): # циклом проходимся от максимального из списка и до нуля с шагом -1 if max(sp) % i == 0 and min(sp) % i == 0: # если встречаем число которое делиться без остатка на максимальное число из списка и на минимальное число, то выводим его и останавливаем цикл print(i) break
без упречное решения только наффига функция? не вызываеться не использовается чисто для мебели???:

Дмитрий
Дмитрий
1 год назад

Спасибо автору сайта за его работу.
Позволю себе предложить решение задачи на нахождение НОД любого количества чисел с применением алгоритма Евклида. Алгоритм Евклида для по определению НОД любого количества чисел: находим значение НОД для любой пары чисел, затем определяем НОД вычисленного значения и других чисел
с применением функции предложенной автором курса:

def gcd(a, b): # функция предложенная автором курса для нахождения НОД двух чисел.
while b > 0:
a, b = b, a%b
return a

num = int(input()) # получаем количество чисел НОД которых необходимо ь.
inp_data = [] # создаем пустой список в который будут помещены числа со ввода

for i in range(num): # создаем цикл в котором будем получать числа со ввода
  inp_data.append(int(input())) # передаем числа со ввода в ранее созданный пустой список

a = inp_data[0]  # создаем переменную и присваиваем ей первое число из введенных (нулевой элемент списка)

for j in range(1,len(inp_data)): # создаем цикл в котором будем последовательно вызывать из списка число от второго(первый элемент списка) до последнего

  z = gcd(a, inp_data[j]) # в новую переменную вызываем функцию которая на первом проходе цикла находит НОД первого и второго числа. При следующих проходах будет определятся НОД ранее вычисленного НОД и следующего числа списка.

  a = z присваиваем переменной значение НОД

print(a) # по завершении цикла выводим на печать НОД всех чисел.

Последний раз редактировалось 1 год назад admin ем
4
0
Оставьте комментарий! Напишите, что думаете по поводу статьи.x