Нет никаких сомнений в том, что сегодня Python является самым популярным и широко используемым языком программирования. Python гибкий, простой в освоении, с открытым исходным кодом и хорошо поддерживается. Этот универсальный язык программирования НЕОБХОДИМ для всех, кто хочет сделать карьеру в области анализа данных или специалиста по данным. Машинное обучение, глубокое обучение, Интернет вещей и искусственный интеллект, которые в настоящее время находятся на подъеме, также создаются с использованием Python.
К вашему сведению, Python был создан программистом по имени Гвидо ван Россум и впервые выпущен 20 февраля 1991 года. Название Python было выбрано в честь его любимого телешоу Летающий цирк Монти Пайтона.
Что такое функции Python?
Функции — одно из фундаментальных понятий почти всех современных языков программирования. Функции Python — это самый простой способ упаковать логику, которую вы, возможно, захотите использовать более чем в одном месте и более одного раза. Функция — это многократно используемый блок кода, выполняющий определенную задачу, что упрощает управление большими проектами.
Это похоже на волшебное заклинание, которое по мановению палочки выполняет определенные задачи.
В Python есть две основные категории функций:
Определяемые пользователем функции. Функции, которые программист определяет, чтобы избежать повторения кода.
Встроенные функции: функции, которые определены кем-то другим и могут использоваться в вашем коде после установки необходимых пакетов.
Понимание основ: определение и вызов функций
Чтобы определить функцию, мы используем ключевое слово def , за которым следует имя функции и пара круглых скобок. Тело функции расположено с отступом ниже определения и убедитесь, что вы сделали отступ с помощью табуляции или 4 пробелов. Чтобы вызвать функцию, используйте имя функции, за которым следуют круглые скобки.
def myfunction():
print("Hi Barbie!")
# Calling the function
myfunction() # Output: Hi Barbie!
Параметры функции и возвращаемые значения
Функции могут принимать входные параметры, что позволяет им принимать разные значения и производить различные выходные данные. Параметры объявляются в круглых скобках во время определения функции. Разделяются запятыми, если параметров несколько. Кроме того, функции могут возвращать значения с помощью оператора return.
def add_numbers(a, b):
return a + b
result = add_numbers(2, 4)
print(result) # Output: 6
Аргументы по умолчанию и ключевые слова
Python позволяет нам назначать значения по умолчанию параметрам функции, делая их необязательными во время вызовов функций. Это обеспечивает гибкость и позволяет избежать ошибок при вызове функции без предоставления всех аргументов.
def greet_user(name, greeting="Hello"):
print(f"{greeting}, {name}!")
greet_user("Ken") # Output: Hello, Ken!
greet_user("Barbie", greeting="Hi") # Output: Hi, Barbie!
def add(a, b=5, c=15):
return (a+b+c) # The default value is given to argument 'b' and 'c'
print(add(2)) # Output 22
Область действия переменных: глобальные и локальные переменные
Понимание области видимости переменной имеет решающее значение при работе с функциями. Переменные, определенные внутри функции, имеют локальную область видимости и принадлежат только этой конкретной функции. Напротив, переменные, объявленные вне какой-либо функции, имеют глобальную область действия и могут быть доступны внутри функций.
global_var = 20
def print_global_var():
local_var = 4
print(f"Global variable: {global_var}") # Output: Global variable: 20
print(f"Local variable: {local_var}") # Output: Local variable: 4
print_global_var()
Лямбда-функции (анонимные функции)
Лямбда-функции — это небольшие анонимные функции, которые могут иметь любое количество аргументов, но только одно выражение. Они удобны для коротких задач и часто используются в качестве аргументов для функций более высокого порядка, таких как map, filter и reduce. В проектах по науке о данных мы часто будем работать с функциями Lambda для создания эффективных структур данных и конвейеров.
# Regular function
def square(x):
return x * x
# Equivalent lambda function
square_lambda = lambda x: x * x
print(square(7)) # Output: 49
print(square_lambda(7)) # Output: 49
numbers = [1, 2, 3, 4, 5, 6, 7, 8, 9, 10]
even_numbers = list(filter(lambda x: x % 2 == 0, numbers))
print(even_numbers) # Output: [2, 4, 6, 8, 10]
Рекурсивные функции
Рекурсивные функции — это функции, которые вызывают сами себя во время выполнения. Они особенно полезны для решения проблем, которые можно разбить на более мелкие идентичные подзадачи. Рекурсия подходит не для всех ситуаций. Хотя возможно, будет скорее неуклюжим, чем элегантным.
Рекурсия — довольно сложная тема, и ее относительно редко можно увидеть в Python. Тем не менее, это полезная техника, о которой нужно знать, поскольку она позволяет программам проходить структуры, которые имеют произвольные и непредсказуемые формы.
def factorial(n):
if n == 0 or n == 1:
return 1
else:
return n * factorial(n - 1)
print(factorial(6)) # Output: 720
# We could implement factorial() iteratively using a for loop:
def factorial(n):
return_value = 1
for i in range(2, n + 1):
return_value *= i
return return_value
print(factorial(6)) # Output: 720
Функция декораторов
Функция декораторов — это мощная функция Python, которая позволяет нам изменять поведение функций без изменения их кода. Оборачивая их в дополнительный слой логики, реализованный как другая функция. Декораторы — это, по сути, функции, которые принимают другую функцию в качестве аргумента и возвращают новую функцию. Декораторы применяются с использованием синтаксиса @decorator_name прямо над определением функции, что делает код более читаемым и упрощает применение одного и того же поведения к нескольким функциям.
def check(func):
def wrapper(a, b):
if b == 0:
print("Error: Can't divide by zero!")
return None
return func(a, b)
return wrapper
@check
def div(a, b):
return a / b
# If we don't want to change this function and we don't want
# the output of print(div(10, 0)) to 'error', use decorators)
# Test the decorated div function
print(div(10, 2))
# Output: 5.0
print(div(10, 0))
# Output: Error: Can't divide by zero! None
Функции генератора
Функции-генераторы — это функции особого типа, которые используют ключевое слово yield вместо return для создания серии значений вместо возврата одного значения. Они эффективно используют память и идеально подходят для работы с большими наборами данных. В остальном функции-генераторы синтаксически идентичны обычным функциям, но Python специально компилирует их, чтобы при вызове возвращать итерируемый объект.
def countdown(n):
while n > 0:
yield n
n -= 1
for num in countdown(5):
print(num) # Output: 5, 4, 3, 2, 1
# A simple generator for Fibonacci Numbers
def fibonacci_generator(limit):
a, b = 0, 1
while a < limit:
yield a
a, b = b, a + b
# Iterating over the generator object using for loop
for num in fibonacci_generator(100):
print(num)
# Output: 0, 1, 1, 2, 3, 5, 8, 13, 21, 34, 55, 89
Аргументы функций и *args и **kwargs
Функции Python могут принимать переменное количество аргументов. Специальный синтаксис *args используется для передачи списка аргументов переменной длины без ключевых слов, а **kwargs используется для передачи списка аргументов переменной длины с ключевыми словами. Мы можем использовать *args и **kwargs в качестве аргументов функции, когда не уверены в количестве аргументов, которые нужно передать в функции.
# Using *args to pass the variable length arguments to the function
def adder(*num):
sum = 0
for n in num:
sum = sum + n
print("Sum =",sum)
adder(1,3) # Output: Sum = 4
adder(4,5,6,7) # Output: Sum = 22
# Using **kwargs to pass the variable keyword arguments to the function
def actor(**data):
print("\nData type of argument:",type(data))
for key, value in data.items():
print("{} is {}".format(key,value))
actor(First_Name="Cillian", Last_Name="Murphy", Country="Ireland", Age=47)
# Output:
Data type of argument: <class 'dict'>
First_Name is Cillian
Last_Name is Murphy
Country is Ireland
Age is 47
def multi_sum(*args, **kwargs):
total = 0
for num in args:
total += num
for key, value in kwargs.items():
print(f"{key}: {value}")
return total
print(multi_sum(1, 2, 3, a=10, b=20))
# Output:
a: 10
b: 20
6
Мы углубились в продвинутые концепции, такие как лямбда-функции, рекурсия, декораторы и функции-генераторы. Вооружившись этим всесторонним знанием функций Python, мы теперь можем писать более организованный, эффективный и мощный код в ваших проектах по науке о данных и за их пределами. Ниже приведены несколько примеров применения функций Python.
НЕКОТОРЫЕ реальные приложения функций Python
Интернет-корзина
Представьте, что вы разрабатываете систему онлайн-покупок. Вы можете использовать функции для выполнения различных задач, связанных с корзиной, таких как добавление товаров, расчет общей стоимости и создание сводки заказа.
# Function to add items to the cart
def add_to_cart(cart, item, price):
cart[item] = price
print(f"{item} added to the cart.")
# Function to calculate the total price of items in the cart
def calculate_total(cart):
total = sum(cart.values())
return total
# Function to generate an order summary
def order_summary(cart):
print("Order Summary:")
for item, price in cart.items():
print(f"{item}: ${price}")
total = calculate_total(cart)
print(f"Total: ${total}")
# Usage example
shopping_cart = {}
add_to_cart(shopping_cart, "Sofas", 400)
add_to_cart(shopping_cart, "Floor Lamps", 50)
add_to_cart(shopping_cart, "Shoe Racks", 20)
order_summary(shopping_cart)
Инструмент анализа данных
Предположим, вы создаете инструмент анализа данных, который выполняет различные статистические расчеты с наборами данных. Функции могут помочь вам инкапсулировать различные операции анализа данных, делая код более организованным и простым в обслуживании.
# Function to calculate the mean of a list of numbers
def calculate_mean(data):
total = sum(data)
mean = total / len(data)
return mean
# Function to calculate the median of a list of numbers
def calculate_median(data):
sorted_data = sorted(data)
n = len(data)
if n % 2 == 0:
median = (sorted_data[n // 2 - 1] + sorted_data[n // 2]) / 2
else:
median = sorted_data[n // 2]
return median
# Function to calculate the standard deviation of a list of numbers
def calculate_std_deviation(data):
mean = calculate_mean(data)
squared_diff_sum = sum((x - mean) ** 2 for x in data)
std_deviation = (squared_diff_sum / len(data)) ** 0.5
return std_deviation
# Usage example
data = [34, 56, 22, 41, 65, 37, 52, 28, 19, 43]
print("Data:", data)
print("Mean:", calculate_mean(data))
print("Median:", calculate_median(data))
print("Standard Deviation:", calculate_std_deviation(data))
Планировщик сообщений в социальных сетях
Предположим, вы создаете планировщик публикаций в социальных сетях, который автоматизирует публикации на различных платформах. Функции могут помочь вам отделить логику планирования от фактической публикации, что сделает код более удобным для сопровождения.
import time
# Function to schedule a post
def schedule_post(post_content, platform, scheduled_time):
print(f"Scheduling a post on {platform} at {scheduled_time}:")
time.sleep(2) # Simulating scheduling process
print(f"Post content: {post_content}")
print("Post scheduled successfully!")
# Usage example
post_content = "Now I am become Death, the destroyer of worlds."
schedule_post(post_content, "Twitter", "2023-07-25 12:00:00")
Основные платформы социальных сетей, такие как META, Twitter и LinkedIn, а также несколько сторонних инструментов управления социальными сетями предоставляют функции планирования публикаций.
А что, если вы решите НЕ использовать функции в своем коде на Python?
1. Дублирование кода и отсутствие повторного использования:
Без функций вы можете обнаружить, что в вашей программе повторяются одни и те же блоки кода. Дублирование кода не только увеличивает размер вашей кодовой базы, но и усложняет ее обслуживание. Если вам нужно внести изменения в дублированный код, вам придется делать это в нескольких местах, что увеличивает риск появления ошибок.
2. Сложность понимания и отладки:
Когда в вашем коде не хватает функций, он превращается в сложную последовательность инструкций без четкого разделения задач. Это может привести к путанице, особенно для других разработчиков, которые могут сотрудничать с вашим проектом.
3. Снижение читабельности кода:
Код, в котором не используются функции, может быстро превратиться в плотную стену инструкций, что затруднит чтение и понимание общего хода программы. Функции служат высокоуровневыми абстракциями, позволяя вам давать осмысленные имена конкретным операциям, делая код более понятным и читабельным.
4. Увеличенное время разработки:
Написание кода без использования функций может привести к неэффективности и увеличению времени разработки. По мере роста кодовой базы становится все труднее управлять и поддерживать ее. Использование функций позволяет вносить изменения в одном месте, принося пользу всей программе, в которой используется эта функция.
Удачного кодирования!
Мы рассмотрели основы функций Python. Функции — это основа программирования на Python, и их освоение, несомненно, поднимет ваши навыки Python на новую высоту!
