Introdução
Neste laboratório, você explorará dois conceitos fundamentais na programação 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. Os módulos permitem organizar 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 Usando Funções
Nesta etapa, você aprenderá como definir e usar funções em Python.
Abra o interpretador Python digitando o seguinte comando no seu terminal:
python
Você deverá ver o prompt do Python (>>>), indicando que agora você está no shell interativo do Python.
Vamos começar definindo uma função simples que cumprimenta uma pessoa. No interpretador Python, digite primeiro a definição da função:
def greet(name):
return f"Hello, {name}!"
Após digitar a linha indentada com return, pressione Enter em uma linha em branco para finalizar a definição da função. Em seguida, execute a função no mesmo interpretador:
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 pelos parâmetros entre parênteses. O corpo da função deve ser 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 imprimimos o resultado.
A instrução return é usada para retornar um valor da função. Se nenhuma instrução return estiver presente, a função retorna None.
As funções podem ser usadas para encapsular código reutilizável e realizar tarefas específicas. Elas são o principal bloco de construção dos programas Python.
Agora, vamos criar uma função que realiza um cálculo. Defina a função primeiro:
def calculate_area(length, width):
return length * width
Pressione Enter em uma linha em branco para finalizar a definição e, em seguida, chame a função:
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 com base no seu comprimento e largura.
As funções também podem ter valores de parâmetro padrão. Defina a função primeiro:
def power(base, exponent=2):
return base ** exponent
Pressione Enter em uma linha em branco e, em seguida, teste ambas as chamadas:
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 usa 2 como valor padrão.
As funções podem retornar múltiplos valores usando tuplas. Defina a função primeiro:
def min_max(numbers):
return min(numbers), max(numbers)
Pressione Enter em uma linha em branco e, em seguida, chame a função:
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 de que 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 delas.
No interpretador Python, vamos explorar variáveis locais e globais:
x = 10 ## Variável global
def print_x():
print(f"Global x: {x}")
print_x()
def change_x():
x = 20 ## Variável local
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 o x global.
Para modificar uma variável global dentro de uma função, use 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, o x global foi modificado.
As funções também podem acessar variáveis do 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 pode acessar o parâmetro x da função externa.
Entender o escopo de funções é crucial 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 Usando Módulos
Nesta etapa, você aprenderá como criar e usar módulos Python.
Saia do interpretador Python digitando exit() ou pressionando Ctrl+D.
Abra o WebIDE no ambiente da VM LabEx.
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 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 use_math_module.py no editor 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 usa 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 __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 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 advanced_math.py no editor 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 usa o módulo math nativo 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 use_advanced_math.py no editor 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 usa aliases 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 aliases, 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 shapes.py no editor 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 use_geometry_package.py no editor 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 na programação Python: funções e módulos. Você aprendeu como definir e usar funções, entender o escopo de funções, criar e usar módulos, importar funções específicas de módulos e organizar módulos relacionados em pacotes.
Você começou criando funções simples e gradualmente avançou para conceitos mais complexos, como escopo de funções 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 fácil de manter e reutilizar.
Você explorou diferentes maneiras de importar funções de módulos, incluindo a importação de funções específicas e o uso de aliases. Esse conhecimento permite que você escreva um código mais conciso e legível, evitando conflitos de nomes entre diferentes módulos.
Por fim, você aprendeu como criar um pacote, que é uma forma de organizar módulos relacionados em uma hierarquia de diretórios. Isso é particularmente útil para projetos maiores, onde você precisa gerenciar vários módulos relacionados.
Esses conceitos de funções e módulos são cruciais para escrever códigos Python bem organizados, eficientes e reutilizáveis. À medida que você continua sua jornada em Python, descobrirá que essas habilidades são essenciais para construir programas mais complexos e colaborar em projetos maiores. 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.
