Функции и модули Python: от основ до продвинутых концепций

Введение

В этом практическом занятии (лабораторной работе) вы познакомитесь с двумя фундаментальными концепциями программирования на Python: функциями и модулями. Функции позволяют организовать ваш код в повторно используемые блоки, делая программы более модульными и легкими для понимания. Модули позволяют организовать связанные функции и переменные в отдельные файлы, способствуя повторному использованию и поддерживаемости кода. Освоив эти концепции, вы сможете писать более эффективный и организованный код на Python.

Skills Graph

%%%%{init: {'theme':'neutral'}}%%%% flowchart RL python(("Python")) -.-> python/BasicConceptsGroup(["Basic Concepts"]) python(("Python")) -.-> python/FunctionsGroup(["Functions"]) python(("Python")) -.-> python/ModulesandPackagesGroup(["Modules and Packages"]) python/BasicConceptsGroup -.-> python/variables_data_types("Variables and Data Types") python/FunctionsGroup -.-> python/function_definition("Function Definition") python/FunctionsGroup -.-> python/arguments_return("Arguments and Return Values") python/FunctionsGroup -.-> python/scope("Scope") python/ModulesandPackagesGroup -.-> python/importing_modules("Importing Modules") python/ModulesandPackagesGroup -.-> python/creating_modules("Creating Modules") python/ModulesandPackagesGroup -.-> python/using_packages("Using Packages") python/ModulesandPackagesGroup -.-> python/standard_libraries("Common Standard Libraries") subgraph Lab Skills python/variables_data_types -.-> lab-393141{{"Функции и модули Python"}} python/function_definition -.-> lab-393141{{"Функции и модули Python"}} python/arguments_return -.-> lab-393141{{"Функции и модули Python"}} python/scope -.-> lab-393141{{"Функции и модули Python"}} python/importing_modules -.-> lab-393141{{"Функции и модули Python"}} python/creating_modules -.-> lab-393141{{"Функции и модули Python"}} python/using_packages -.-> lab-393141{{"Функции и модули Python"}} python/standard_libraries -.-> lab-393141{{"Функции и модули Python"}} end

Определение и использование функций

В этом шаге вы узнаете, как определять и использовать функции в Python.

Откройте интерпретатор Python, введя следующую команду в терминале:
```
python
```
Вы должны увидеть приглашение Python (>>>), что означает, что вы теперь в интерактивной оболочке Python.

Начнем с определения простой функции, которая приветствует человека. В интерпретаторе Python введите следующее:
```
>>> def greet(name):
...     return f"Hello, {name}!"
...
>>> result = greet("Alice")
>>> print(result)
Hello, Alice!
```
1. Функции определяются с использованием ключевого слова def, за которым следуют имя функции и параметры в скобках. Тело функции должно быть с отступом.
2. Эта функция принимает параметр name и возвращает строку приветствия. Затем мы вызываем функцию с аргументом "Alice" и выводим результат.
3. Оператор return используется для возврата значения из функции. Если оператора return нет, функция возвращает None.
4. Функции можно использовать для инкапсуляции повторно используемого кода и выполнения конкретных задач. Они являются основными строительными блоками программ на Python.
Теперь создадим функцию, которая выполняет расчет:
```
>>> def calculate_area(length, width):
...     return length * width
...
>>> area = calculate_area(5, 3)
>>> print(f"The area is: {area}")
The area is: 15
```
Эта функция вычисляет площадь прямоугольника по его длине и ширине.
Функции также могут иметь значения параметров по умолчанию:
```
>>> def power(base, exponent=2):
...     return base ** exponent
...
>>> print(power(3))
9
>>> print(power(3, 3))
27
```
Здесь, если показатель степени не указан, функция использует значение 2 по умолчанию.
Функции могут возвращать несколько значений с использованием кортежей:
```
>>> def min_max(numbers):
...     return min(numbers), max(numbers)
...
>>> minimum, maximum = min_max([1, 5, 3, 9, 2])
>>> print(f"Minimum: {minimum}, Maximum: {maximum}")
Minimum: 1, Maximum: 9
```
Эта функция возвращает как минимальное, так и максимальное значения из списка чисел.

Помните, что отступы имеют решающее значение в Python. Тела функций должны быть отступлены последовательно.

Понимание области видимости функций

В этом шаге вы узнаете о области видимости функций и о том, как переменные ведут себя внутри и вне функций.

В интерпретаторе Python исследуем локальные и глобальные переменные:

>>> x = 10  ## Глобальная переменная

>>> def print_x():
...     print(f"Global x: {x}")
...
>>> print_x()
Global x: 10

>>> def change_x():
...     x = 20  ## Локальная переменная
...     print(f"Local x: {x}")
...
>>> change_x()
Local x: 20
>>> print(f"Global x after change_x(): {x}")
Global x after change_x(): 10

Обратите внимание, что функция change_x() создает новую локальную переменную x, которая не влияет на глобальную переменную x.

Чтобы изменить глобальную переменную внутри функции, используйте ключевое слово global:
```
>>> def modify_global_x():
...     global x
...     x = 30
...     print(f"Modified global x: {x}")
...
>>> modify_global_x()
Modified global x: 30
>>> print(f"Global x after modify_global_x(): {x}")
Global x after modify_global_x(): 30
```
Теперь глобальная переменная x была изменена.
Функции также могут обращаться к переменным из объемлющей области видимости:
```
>>> def outer_function(x):
...     def inner_function():
...         print(f"x from outer function: {x}")
...     inner_function()
...
>>> outer_function(40)
x from outer function: 40
```
Внутренняя функция может обращаться к параметру x внешней функции.

Понимание области видимости функций является важным аспектом написания чистого и безошибочного кода. Это помогает избежать непреднамеренных побочных эффектов и делает ваши функции более предсказуемыми.

Создание и использование модулей

В этом шаге вы узнаете, как создавать и использовать модули Python.

Выйдите из интерпретатора Python, введя exit() или нажав Ctrl+D.
Откройте WebIDE в среде виртуальной машины LabEx.

Интерфейс WebIDE в виртуальной машине LabEx

Создайте новый файл с именем math_operations.py в директории ~/project:
```
touch ~/project/math_operations.py
```
Откройте только что созданный файл в редакторе WebIDE и добавьте следующее содержимое:
```
## math_operations.py

def add(a, b):
    return a + b

def subtract(a, b):
    return a - b

def multiply(a, b):
    return a * b

def divide(a, b):
    if b!= 0:
        return a / b
    else:
        return "Error: Division by zero"

PI = 3.14159
```
Этот модуль содержит четыре базовые математические операции и константу PI.
Сохраните файл (автосохранение включено в WebIDE).
Теперь создайте еще один файл с именем use_math_module.py в той же директории:
```
touch ~/project/use_math_module.py
```

Откройте файл use_math_module.py в редакторе WebIDE и добавьте следующее содержимое:

## use_math_module.py

import math_operations

result_add = math_operations.add(5, 3)
result_subtract = math_operations.subtract(10, 4)
result_multiply = math_operations.multiply(2, 6)
result_divide = math_operations.divide(15, 3)

print(f"Addition: {result_add}")
print(f"Subtraction: {result_subtract}")
print(f"Multiplication: {result_multiply}")
print(f"Division: {result_divide}")
print(f"Value of PI: {math_operations.PI}")

Этот скрипт импортирует модуль math_operations и использует его функции и константу.

Сохраните файл и запустите его, используя следующую команду в терминале:
```
python ~/project/use_math_module.py
```
Вы должны увидеть вывод, похожий на следующий:
```
Addition: 8
Subtraction: 6
Multiplication: 12
Division: 5.0
Value of PI: 3.14159
```

Создавая модули, вы можете организовать связанные функции и переменные в отдельные файлы, делая ваш код более поддерживаемым и повторно используемым.

При импорте модуля Python компилирует его в байт-код и сохраняет скомпилированный код в директории __pycache__. Эта директория создается в том же месте, где находится файл модуля, и содержит скомпилированные файлы байт-кода (.pyc или .pyo).

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

Импорт конкретных функций из модулей

В этом шаге вы узнаете, как импортировать конкретные функции из модулей и использовать псевдонимы (aliases), чтобы сделать ваш код более компактным.

Создайте новый файл с именем advanced_math.py в директории ~/project:
```
touch ~/project/advanced_math.py
```
Откройте файл advanced_math.py в редакторе WebIDE и добавьте следующее содержимое:
```
## advanced_math.py

import math

def square_root(x):
    return math.sqrt(x)

def power(base, exponent):
    return math.pow(base, exponent)

def sin(angle):
    return math.sin(math.radians(angle))

def cos(angle):
    return math.cos(math.radians(angle))
```
Этот модуль использует встроенный модуль math Python для предоставления более продвинутых математических операций.
Теперь создайте файл с именем use_advanced_math.py в той же директории:
```
touch ~/project/use_advanced_math.py
```

Откройте файл use_advanced_math.py в редакторе WebIDE и добавьте следующее содержимое:

## use_advanced_math.py

from advanced_math import square_root, power
from advanced_math import sin as sine, cos as cosine

x = 16
y = 2
angle = 30

print(f"Square root of {x}: {square_root(x)}")
print(f"{x} to the power of {y}: {power(x, y)}")
print(f"Sine of {angle} degrees: {sine(angle)}")
print(f"Cosine of {angle} degrees: {cosine(angle)}")

Этот скрипт импортирует конкретные функции из модуля advanced_math и использует псевдонимы для функций sin и cos.

Сохраните файл и запустите его, используя следующую команду в терминале:
```
python ~/project/use_advanced_math.py
```
Вы должны увидеть вывод, похожий на следующий:
```
Square root of 16: 4.0
16 to the power of 2: 256.0
Sine of 30 degrees: 0.49999999999999994
Cosine of 30 degrees: 0.8660254037844387
```

Импортируя конкретные функции и используя псевдонимы, вы можете сделать ваш код более читаемым и избежать конфликтов имен между разными модулями.

Создание пакета

В этом последнем шаге вы узнаете, как создать пакет (package), который представляет собой способ организации связанных модулей в иерархию директорий.

Создайте новую директорию с именем geometry в директории ~/project:
```
mkdir ~/project/geometry
```
Внутри директории geometry создайте два файла: __init__.py и shapes.py:
```
touch ~/project/geometry/__init__.py
touch ~/project/geometry/shapes.py
```
Файл __init__.py необходим, чтобы Python воспринимал директорию как пакет. Он может быть пустым или содержать код инициализации пакета.

Откройте файл shapes.py в редакторе WebIDE и добавьте следующее содержимое:

## geometry/shapes.py

import math

def circle_area(radius):
    return math.pi * radius ** 2

def rectangle_area(length, width):
    return length * width

def triangle_area(base, height):
    return 0.5 * base * height

Теперь создайте файл с именем use_geometry_package.py в директории ~/project:
```
touch ~/project/use_geometry_package.py
```

Откройте файл use_geometry_package.py в редакторе WebIDE и добавьте следующее содержимое:

## use_geometry_package.py

from geometry.shapes import circle_area, rectangle_area, triangle_area

radius = 5
length = 4
width = 6
base = 3
height = 8

print(f"Area of circle with radius {radius}: {circle_area(radius):.2f}")
print(f"Area of rectangle with length {length} and width {width}: {rectangle_area(length, width)}")
print(f"Area of triangle with base {base} and height {height}: {triangle_area(base, height)}")

Сохраните файл и запустите его, используя следующую команду в терминале:
```
python ~/project/use_geometry_package.py
```
Вы должны увидеть вывод, похожий на следующий:
```
Area of circle with radius 5: 78.54
Area of rectangle with length 4 and width 6: 24
Area of triangle with base 3 and height 8: 12.0
```

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

Итог

В этом практическом занятии (lab) вы изучили два фундаментальных концепта в программировании на Python: функции и модули. Вы узнали, как определять и использовать функции, понимать область видимости функций, создавать и использовать модули, импортировать конкретные функции из модулей и организовывать связанные модули в пакеты.

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

Вы изучили различные способы импорта функций из модулей, включая импорт конкретных функций и использование псевдонимов (aliases). Эти знания позволяют вам писать более компактный и читаемый код, избегая конфликтов имен между разными модулями.

Наконец, вы узнали, как создать пакет (package), который представляет собой способ организации связанных модулей в иерархию директорий. Это особенно полезно для более крупных проектов, где необходимо управлять множеством связанных модулей.

Эти концепции функций и модулей являются важными для написания хорошо организованного, эффективного и повторно используемого кода на Python. По мере продолжения вашего пути в изучении Python вы обнаружите, что эти навыки являются неотъемлемой частью создания более сложных программ и сотрудничества в крупных проектах. Не забудьте регулярно практиковать эти концепции и изучать обширный экосистему модулей и пакетов Python, доступных для расширения ваших программистских возможностей.