Напишите функцию square()
, которая принимает на вход число и:
# возвращает квадрат
def square(n):
return n ** 2
# выводит на экран сообщение
def square2(n):
print(f"Квадрат числа равен: {n ** 2}")
# возвращает квадрат и выводит сообщение
def square3(n):
print(f"Квадрат числа равен: {n ** 2}")
return n ** 2
# потестим и посмотрим, что получилось
r1 = square(5)
r2 = square2(5) # при сохранении в r2 выдает сообщение
r3 = square3(5) # при сохранении в r3 выдает сообщение
print(r1) # результат сохранился
print(r2) # результат не сохранился – None
print(r3) # результат сохранился
Квадрат числа равен: 25 Квадрат числа равен: 25 25 None 25
Напишите функцию nums()
, которая принимает на вход целое число, а возвращает список из двух элементов: целое число, предшествующее принятому на вход, и число, следующее за ним.
Пример:
Входные данные:
7
Выходные данные:
[6, 8]
def nums(x):
return [x-1, x+1]
nums(3)
[2, 4]
Напишите функцию str_lower()
, которая принимает на вход строку (набор слов через пробел), а возвращает список ее элементов в нижнем регистре.
Пример:
Входные данные:
"В лесу родилась ёлочка В лесу она росла"
Выходные данные:
['в', 'лесу', 'родилась', 'ёлочка', 'в', 'лесу', 'она', 'росла']
def str_lower(text):
return [s.lower() for s in text.split()]
final = str_lower("В лесу родилась ёлочка В лесу она росла")
final
['в', 'лесу', 'родилась', 'ёлочка', 'в', 'лесу', 'она', 'росла']
Напишите функцию my_log()
, которая принимает на вход список чисел, и возвращает список их натуральных логарифмов. Если число меньше или равно 0, на его месте в возвращаемом списке должно быть None.
Пример:
Входные данные:
[1, 3, 2.5, -1, 9, 0, 2.71]
Выходные данные:
[0.0,
1.0986122886681098,
0.9162907318741551,
None,
2.1972245773362196,
None,
0.9969486348916096]
from math import log
# решение 1 – цикл и append()
def my_log(L):
Logs = []
for j in L:
if j > 0:
Logs.append(log(j))
else:
Logs.append(None)
return Logs
print(my_log([1, 3, 2.5, -1, 9, 0, 2.71]))
[0.0, 1.0986122886681098, 0.9162907318741551, None, 2.1972245773362196, None, 0.9969486348916096]
# решение 2 – списковое включение
def my_log(L):
Logs = [log(j) if j > 0 else None for j in L]
return Logs
my_log([1, 3, 2.5, -1, 9, 0, 2.71])
[0.0, 1.0986122886681098, 0.9162907318741551, None, 2.1972245773362196, None, 0.9969486348916096]
Перед разбором задачи 5 – немного про словари. Словарь – это структура в Python, которая включает в себя пары ключ-значение, причем порядок этих пар в словаре не имеет значение. Посмотрим на словарь D
, который включает пары имя-возраст, то есть ключами (до двоеточия) являются имена людей, а значениями (после двоеточия) – их возраст.
D = {'Anna':23, 'Ben':34}
print(D)
{'Anna': 23, 'Ben': 34}
Так как порядок элементов в словаре не имеет значения (поменяем местами Анну и Бэна, для Python это будет тот же словарь), вызвать элемент по индексу, как в списке, не получится:
D[0] # нет ключа 0, есть ключи Anna и Ben
--------------------------------------------------------------------------- KeyError Traceback (most recent call last) <ipython-input-10-496d2465924a> in <module> ----> 1 D[0] # нет ключа 0, есть ключи Anna и Ben KeyError: 0
Зато вызвать значение по ключу легко:
D['Anna']
23
Словарь можно создать на основе списков, если предварительно «склеить» их в список пар ключ-значение. То есть, из такой структуры (см. ниже) легко получить словарь:
[('Anna', 23), ('Ben', 34)]
Чтобы из списка имен и списка возрастов составить такой список пар, пригодится функция zip()
. Эта функция, как молния (отсюда и название), умеет «сшивать» списки.
names = ['Anna', 'Ben']
ages = [23, 34]
zip(names, ages)
<zip at 0x10919e870>
Одна проблема: эта функция возвращает объект, который скрыт он наших глаз. Превратим полученный объект в список с помощью list()
:
list(zip(names, ages))
[('Anna', 23), ('Ben', 34)]
А теперь превратим это в словарь с помощью функции dict()
(от dictionary):
dict(zip(names, ages)) # list() теперь можно опустить, Python поймет
{'Anna': 23, 'Ben': 34}
Напишите функцию, которая принимает на вход два списка (имена людей и их возраст) и делает следующее:
если эти два списка имеют одинаковую длину, то возвращает словарь с парами имя-возраст;
если эти два списка имеют разную длину, то функция выводит на экран сообщение "Списки имеют разную длину" и возвращает пустой словарь.
Пример:
Входные данные:
["Ann", "Tim", "Sam"]
[12, 23, 17]
Выходные данные:
{"Ann": 12, "Tim": 23, "Sam": 17}
Входные данные:
["Ann", "Tim", "Sam"]
[12, 23, 17, 45]
Выходные данные:
Списки имеют разную длину
{}
Подсказка: используйте функцию zip()
и код dict(zip())
.
def info(names, ages):
if len(names) == len(ages):
D = dict(zip(names, ages))
else:
D = {}
print("Списки имеют разную длину")
return D
info(["Ann", "Tim", "Sam"], [12, 23, 17])
{'Ann': 12, 'Tim': 23, 'Sam': 17}
info(["Ann", "Tim", "Sam"], [12, 23, 17, 45])
Списки имеют разную длину
{}
Напишите функцию binom_prob()
, которая считает вероятность того, что проведя n
испытаний Бернулли с вероятностью успеха p
, мы получим ровно k
успехов. Эта функция принимает на вход три аргумента: p
, n
и k
и возвращает такой результат:
$P(X = k) = C_n^k \cdot p^k \cdot (1-p)^{n-k}$
Для расчета биномиального коэффициента можно использовать функцию, написанную на лекции.
# функция factorial() с лекции
def factorial(n):
f = 1
for i in range(2, n+1):
f = f * i
return f
# функция binom() с лекции
def binom(k, n):
return factorial(n) // (factorial(k) * factorial(n - k))
# получилась функция, которая ссылается на binom(),
# определенную ранее, которая, в свою очередь,
# ссылается на factorial(), написанную еще раньше
def binom_prob(n, k, p):
r = binom(k, n) * p ** k * (1 - p) ** (n - k)
return r
Вложенные функции тоже бывают (подробнее посмотрите на DataCamp):
def binom_prob(n, k, p):
# первая
def factorial(n):
f = 1
for i in range(2, n+1):
f = f * i
return f
# вторая, которая ссылается на первую ф-цию
def binom(k, n):
return factorial(n) // (factorial(k) * factorial(n - k))
# результат, который ссылается на вторую ф-цию
r = binom(k, n) * p ** k * (1 - p) ** (n - k)
return r