Funções e Módulos em Python

Introdução

Neste laboratório, você explorará dois conceitos fundamentais da programação em Python: funções e módulos. As funções permitem organizar seu código em blocos reutilizáveis, tornando seus programas mais modulares e fáceis de entender. Já os módulos possibilitam a organização de funções e variáveis relacionadas em arquivos separados, promovendo a reutilização e a manutenibilidade do código. Ao dominar esses conceitos, você será capaz de escrever códigos Python mais eficientes e organizados.

Definindo e Utilizando Funções

Nesta etapa, você aprenderá como definir e utilizar funções em Python.

Abra o interpretador Python digitando o seguinte comando no seu terminal:

python

Você verá o prompt do Python (>>>), indicando que agora está no shell interativo do Python.

Vamos começar definindo uma função simples que cumprimenta uma pessoa. No interpretador Python, digite o seguinte:

def greet(name):
    return f"Hello, {name}!"

result = greet("Alice")
print(result)

Você deverá ver a seguinte saída:

Hello, Alice!

As funções são definidas usando a palavra-chave def, seguida pelo nome da função e os parâmetros entre parênteses. O corpo da função deve estar indentado.
Esta função recebe um parâmetro name e retorna uma string de saudação. Em seguida, chamamos a função com o argumento "Alice" e exibimos o resultado.
A instrução return é usada para devolver um valor da função. Se nenhuma instrução return estiver presente, a função retornará None.
As funções podem ser usadas para encapsular código reutilizável e realizar tarefas específicas. Elas são os principais blocos de construção dos programas em Python.

Agora, vamos criar uma função que realiza um cálculo:

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

area = calculate_area(5, 3)
print(f"The area is: {area}")

Você deverá ver a seguinte saída:

The area is: 15

Esta função calcula a área de um retângulo a partir de seu comprimento e largura.

As funções também podem ter valores de parâmetros padrão:

def power(base, exponent=2):
    return base ** exponent

print(power(3))
print(power(3, 3))

Você deverá ver a seguinte saída:

9
27

Aqui, se nenhum expoente for fornecido, a função utiliza 2 como valor padrão.

As funções podem retornar múltiplos valores usando tuplas:

def min_max(numbers):
    return min(numbers), max(numbers)

minimum, maximum = min_max([1, 5, 3, 9, 2])
print(f"Minimum: {minimum}, Maximum: {maximum}")

Você deverá ver a seguinte saída:

Minimum: 1, Maximum: 9

Esta função retorna tanto o valor mínimo quanto o máximo de uma lista de números.

Lembre-se: a indentação é crucial em Python. Os corpos das funções devem ser indentados de forma consistente.

Entendendo o Escopo de Funções

Nesta etapa, você aprenderá sobre o escopo de funções e como as variáveis se comportam dentro e fora das funções.

No interpretador Python, vamos explorar variáveis locais e globais:

x = 10  ## Global variable

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

print_x()

def change_x():
    x = 20  ## Local variable
    print(f"Local x: {x}")

change_x()
print(f"Global x after change_x(): {x}")

Você deverá ver a seguinte saída:

Global x: 10
Local x: 20
Global x after change_x(): 10

Observe que a função change_x() cria uma nova variável local x, que não afeta a variável global x.

Para modificar uma variável global dentro de uma função, utilize a palavra-chave global:

def modify_global_x():
    global x
    x = 30
    print(f"Modified global x: {x}")

modify_global_x()
print(f"Global x after modify_global_x(): {x}")

Você deverá ver a seguinte saída:

Modified global x: 30
Global x after modify_global_x(): 30

Agora a variável global x foi modificada.

As funções também podem acessar variáveis de seu escopo envolvente:

def outer_function(x):
    def inner_function():
        print(f"x from outer function: {x}")
    inner_function()

outer_function(40)

Você deverá ver a seguinte saída:

x from outer function: 40

A função interna consegue acessar o parâmetro x da função externa.

Compreender o escopo das funções é fundamental para escrever um código limpo e livre de erros. Isso ajuda a evitar efeitos colaterais indesejados e torna suas funções mais previsíveis.

Criando e Utilizando Módulos

Nesta etapa, você aprenderá como criar e utilizar módulos em Python.

Saia do interpretador Python digitando exit() ou pressionando Ctrl+D.

Abra o WebIDE no ambiente LabEx VM.

Crie um novo arquivo chamado math_operations.py no diretório ~/project:

touch ~/project/math_operations.py

Abra o arquivo recém-criado no editor do WebIDE e adicione o seguinte conteúdo:

## 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

Este módulo contém quatro operações matemáticas básicas e uma constante PI.

Salve o arquivo (o salvamento automático está ativado no WebIDE).

Agora, crie outro arquivo chamado use_math_module.py no mesmo diretório:

touch ~/project/use_math_module.py

Abra o use_math_module.py no editor do WebIDE e adicione o seguinte conteúdo:

## 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}")

Este script importa o módulo math_operations e utiliza suas funções e constante.

Salve o arquivo e execute-o usando o seguinte comando no terminal:

python ~/project/use_math_module.py

Você deverá ver uma saída semelhante a esta:

Addition: 8
Subtraction: 6
Multiplication: 12
Division: 5.0
Value of PI: 3.14159

Ao criar módulos, você pode organizar funções e variáveis relacionadas em arquivos separados, tornando seu código mais fácil de manter e reutilizar.

Quando você importa um módulo, o Python o compila em bytecode e armazena o código compilado em um diretório chamado __pycache__. Este diretório é criado no mesmo local que o arquivo do módulo e contém arquivos de bytecode compilados (.pyc ou .pyo).

Você pode ignorar este diretório com segurança, pois o Python gerencia automaticamente a compilação e o cache dos módulos.

Importando Funções Específicas de Módulos

Nesta etapa, você aprenderá como importar funções específicas de módulos e usar apelidos (aliases) para tornar seu código mais conciso.

Crie um novo arquivo chamado advanced_math.py no diretório ~/project:

touch ~/project/advanced_math.py

Abra o advanced_math.py no editor do WebIDE e adicione o seguinte conteúdo:

## 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))

Este módulo utiliza o módulo nativo math do Python para fornecer operações matemáticas mais avançadas.

Agora, crie um arquivo chamado use_advanced_math.py no mesmo diretório:

touch ~/project/use_advanced_math.py

Abra o use_advanced_math.py no editor do WebIDE e adicione o seguinte conteúdo:

## 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)}")

Este script importa funções específicas do módulo advanced_math e utiliza apelidos para sin e cos.

Salve o arquivo e execute-o usando o seguinte comando no terminal:

python ~/project/use_advanced_math.py

Você deverá ver uma saída semelhante a esta:

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

Ao importar funções específicas e usar apelidos, você pode tornar seu código mais legível e evitar conflitos de nomes entre diferentes módulos.

Criando um Pacote

Nesta etapa final, você aprenderá como criar um pacote, que é uma forma de organizar módulos relacionados em uma hierarquia de diretórios.

Crie um novo diretório chamado geometry no diretório ~/project:

mkdir ~/project/geometry

Dentro do diretório geometry, crie dois arquivos: __init__.py e shapes.py:

touch ~/project/geometry/__init__.py
touch ~/project/geometry/shapes.py

O arquivo __init__.py é necessário para que o Python trate o diretório como um pacote. Ele pode estar vazio ou conter código de inicialização para o pacote.

Abra o shapes.py no editor do WebIDE e adicione o seguinte conteúdo:

## 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

Agora, crie um arquivo chamado use_geometry_package.py no diretório ~/project:

touch ~/project/use_geometry_package.py

Abra o use_geometry_package.py no editor do WebIDE e adicione o seguinte conteúdo:

## 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)}")

Salve o arquivo e execute-o usando o seguinte comando no terminal:

python ~/project/use_geometry_package.py

Você deverá ver uma saída semelhante a esta:

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

Ao criar um pacote, você organizou módulos relacionados em uma hierarquia de diretórios, facilitando o gerenciamento e a importação de funcionalidades relacionadas em seus projetos.

Resumo

Neste laboratório, você explorou dois conceitos fundamentais da programação em Python: funções e módulos. Você aprendeu como definir e usar funções, compreendeu o escopo de funções, criou e utilizou módulos, importou funções específicas de módulos e organizou módulos relacionados em pacotes.

Você começou criando funções simples e avançou gradualmente para conceitos mais complexos, como escopo de função e variáveis globais. Em seguida, aprendeu a criar módulos para organizar funções e variáveis relacionadas em arquivos separados, tornando seu código mais sustentável e reutilizável.

Você explorou diferentes maneiras de importar funções de módulos, incluindo a importação de funções específicas e o uso de apelidos. Esse conhecimento permite escrever códigos mais concisos e legíveis, evitando conflitos de nomes entre diferentes módulos.

Por fim, você aprendeu a criar um pacote, que é uma maneira de organizar módulos relacionados em uma hierarquia de diretórios. Isso é particularmente útil para projetos maiores, onde é necessário gerenciar múltiplos módulos interconectados.

Esses conceitos de funções e módulos são cruciais para escrever um código Python bem organizado, eficiente e reutilizável. À medida que você continua sua jornada em Python, descobrirá que essas habilidades são essenciais para construir programas mais complexos e colaborar em projetos de grande escala. Lembre-se de praticar esses conceitos regularmente e explorar o vasto ecossistema de módulos e pacotes Python disponíveis para aprimorar suas capacidades de programação.