Introdução
Bem-vindo ao laboratório sobre as funções nativas (built-in functions) do Python. O interpretador Python fornece um conjunto rico de funções e tipos que estão sempre disponíveis, sem a necessidade de qualquer importação. Estas funções são os blocos de construção fundamentais para realizar tarefas comuns, desde a manipulação de dados até operações de entrada/saída (input/output).
Neste laboratório, você ganhará experiência prática com algumas das funções nativas mais essenciais, categorizadas em grupos lógicos. Ao final deste laboratório, você estará apto a usar essas funções para escrever código Python mais eficiente e legível.
Conversão e Inspeção de Tipos de Dados
Nesta etapa, você aprenderá a converter entre diferentes tipos de dados e inspecionar objetos usando funções como int(), str(), list(), dict(), type() e isinstance(). Estes são fundamentais para manipular dados em Python.
Nota: Se você não está familiarizado com o uso do WebIDE (semelhante ao VS Code), aprenda primeiro neste laboratório.
Primeiro, abra o arquivo step1_conversion.py no explorador de arquivos à esquerda. Escreveremos nosso código neste arquivo.
Adicione o seguinte código a step1_conversion.py. Este código demonstra como converter uma string para um inteiro, uma tupla para uma lista e uma lista de pares para um dicionário. Ele também mostra como verificar o tipo de um objeto.
## step1_conversion.py
## int(): Retorna um objeto inteiro a partir de um número ou string.
num_str = "123"
num_int = int(num_str)
print(f"String '{num_str}' como inteiro: {num_int}")
## str(): Retorna uma versão em string de um objeto.
int_val = 456
str_val = str(int_val)
print(f"Inteiro {int_val} como string: '{str_val}'")
## list(): Cria uma nova lista a partir de um iterável.
my_tuple = ('a', 'b', 'c')
my_list = list(my_tuple)
print(f"Tupla {my_tuple} como lista: {my_list}")
## dict(): Cria um novo dicionário.
my_pairs = [('x', 1), ('y', 2)]
my_dict = dict(my_pairs)
print(f"Lista de pares {my_pairs} como dict: {my_dict}")
## type(): Retorna o tipo de um objeto.
print(f"Tipo de num_int: {type(num_int)}")
## isinstance(): Retorna True se o objeto for uma instância de uma classe.
is_list = isinstance(my_list, list)
print(f"my_list é uma instância de list? {is_list}")
Agora, salve o arquivo e execute-o a partir do terminal.
python3 step1_conversion.py
Você deverá ver a seguinte saída, que confirma que as conversões e inspeções de tipo de dados foram bem-sucedidas.
String '123' as integer: 123
Integer 456 as string: '456'
Tuple ('a', 'b', 'c') as list: ['a', 'b', 'c']
List of pairs [('x', 1), ('y', 2)] as dict: {'x': 1, 'y': 2}
Type of num_int: <class 'int'>
Is my_list an instance of list? True
Operações Matemáticas e Numéricas
Nesta etapa, você realizará cálculos matemáticos comuns usando funções nativas. Abordaremos abs(), sum(), min(), max(), round() e pow().
Abra o arquivo step2_math.py no explorador de arquivos.
Adicione o seguinte código a step2_math.py. Este script demonstra como aplicar várias funções matemáticas a números e listas de números.
## step2_math.py
numbers = [5, -10, 15, -2, 8]
## abs(): Retorna o valor absoluto de um número.
print(f"Valor absoluto de -10: {abs(-10)}")
## sum(): Soma os itens de um iterável.
print(f"Soma dos números {numbers}: {sum(numbers)}")
## min(): Retorna o menor item em um iterável.
print(f"Mínimo dos números: {min(numbers)}")
## max(): Retorna o maior item em um iterável.
print(f"Máximo dos números: {max(numbers)}")
## round(): Retorna o número arredondado para uma precisão dada.
pi_approx = 3.14159
print(f"Arredondando {pi_approx} para 2 casas decimais: {round(pi_approx, 2)}")
## pow(): Retorna a base elevada à potência do expoente (exp).
print(f"2 elevado à potência de 3: {pow(2, 3)}")
Salve o arquivo e execute-o no terminal.
python3 step2_math.py
A saída deve exibir os resultados de cada operação matemática.
Absolute value of -10: 10
Sum of numbers [5, -10, 15, -2, 8]: 16
Minimum of numbers: -10
Maximum of numbers: 15
Rounding 3.14159 to 2 decimal places: 3.14
2 to the power of 3: 8
Trabalhando com Sequências e Iteráveis
Nesta etapa, você aprenderá a manipular e processar sequências como listas e tuplas. Abordaremos len(), sorted(), reversed(), enumerate(), map(), filter() e zip(). Muitas dessas funções retornam iteradores, que são objetos eficientes e que economizam memória.
Abra o arquivo step3_sequences.py.
Adicione o seguinte código a step3_sequences.py. Este script demonstrará como obter o comprimento de uma lista, ordená-la, invertê-la e realizar transformações mais complexas usando map, filter e zip.
## step3_sequences.py
my_list = [3, 1, 4, 1, 5, 9]
print(f"Lista original: {my_list}")
## len(): Retorna o comprimento (o número de itens) de um objeto.
print(f"Comprimento da lista: {len(my_list)}")
## sorted(): Retorna uma nova lista ordenada a partir dos itens no iterável.
print(f"Lista ordenada: {sorted(my_list)}")
## reversed(): Retorna um iterador reverso. Convertemos para uma lista para imprimir.
print(f"Lista invertida: {list(reversed(my_list))}")
## enumerate(): Retorna um objeto enumerate (iterador de pares índice, valor).
print(f"Lista enumerada: {list(enumerate(my_list))}")
## map(): Retorna um iterador que aplica uma função a cada item do iterável.
squared_numbers = map(lambda x: x*x, my_list)
print(f"Números ao quadrado (map): {list(squared_numbers)}")
## filter(): Constrói um iterador a partir de elementos do iterável para os quais uma função retorna verdadeiro.
even_numbers = filter(lambda x: x % 2 == 0, my_list)
print(f"Números pares (filter): {list(even_numbers)}")
## zip(): Itera sobre vários iteráveis em paralelo.
list_a = ['a', 'b', 'c']
list_b = [1, 2, 3]
zipped = zip(list_a, list_b)
print(f"Listas combinadas (zipped): {list(zipped)}")
Salve o arquivo e execute-o.
python3 step3_sequences.py
Você verá a saída de várias operações de sequência. Observe como funções como reversed, map, filter e zip retornam iteradores, que convertemos para listas usando list() para exibir seu conteúdo.
Original list: [3, 1, 4, 1, 5, 9]
Length of the list: 6
Sorted list: [1, 1, 3, 4, 5, 9]
Reversed list: [9, 5, 1, 4, 1, 3]
Enumerated list: [(0, 3), (1, 1), (2, 4), (3, 1), (4, 5), (5, 9)]
Squared numbers (map): [9, 1, 16, 1, 25, 81]
Even numbers (filter): [4]
Zipped lists: [('a', 1), ('b', 2), ('c', 3)]
Entrada Saída e Representação de Objetos
Nesta etapa, você lidará com operações básicas de entrada/saída (Input/Output - I/O) e controlará como os objetos são representados como strings. Focaremos em print(), open(), repr() e format(). Também mencionaremos brevemente input().
Abra o arquivo step4_io.py.
A função input() lê uma linha do console, a converte em uma string e a retorna. Por exemplo: name = input("Enter your name: "). Não a usaremos em nosso script para evitar pausar a execução, mas é uma função crucial de se conhecer.
Agora, adicione o seguinte código a step4_io.py. Este script escreverá em um arquivo, lerá dele e demonstrará diferentes maneiras de representar e formatar objetos como strings.
## step4_io.py
import datetime
## open(): Abre um arquivo e retorna um objeto de arquivo correspondente.
## Usamos a instrução 'with' para garantir que o arquivo seja fechado automaticamente.
file_path = "/home/labex/project/my_file.txt"
with open(file_path, "w") as f:
f.write("Hello, LabEx!\n")
f.write("This is a test file.")
print(f"Escrita bem-sucedida em {file_path}")
## Leitura do arquivo
with open(file_path, "r") as f:
content = f.read()
print("--- Conteúdo do Arquivo ---")
print(content)
print("--------------------")
## repr(): Retorna uma string contendo uma representação imprimível e inequívoca de um objeto.
now = datetime.datetime(2023, 10, 27, 10, 30, 0)
print(f"str(now): {str(now)}")
print(f"repr(now): {repr(now)}")
## format(): Converte um valor para uma representação "formatada".
formatted_string = format(123.4567, ".2f")
print(f"Número formatado (123.4567 para .2f): {formatted_string}")
Salve o arquivo e execute-o no terminal.
python3 step4_io.py
O script criará e escreverá em my_file.txt, o lerá de volta e imprimirá o conteúdo. Ele também mostra a diferença entre str() e repr() para um objeto datetime e demonstra a formatação de números.
Successfully wrote to /home/labex/project/my_file.txt
--- File Content ---
Hello, LabEx!
This is a test file.
--------------------
str(now): 2023-10-27 10:30:00
repr(now): datetime.datetime(2023, 10, 27, 10, 30)
Formatted number (123.4567 to .2f): 123.46
Introspecção de Objetos e Metaprogramação
Nesta etapa final, você explorará funções avançadas para interagir com atributos de objetos e namespaces. Isso é frequentemente chamado de introspecção ou reflexão. Usaremos getattr(), hasattr(), setattr(), dir(), globals() e locals().
Abra o arquivo step5_introspection.py.
Definiremos uma classe simples e, em seguida, usaremos funções de introspecção para inspecionar e modificar dinamicamente suas instâncias. Adicione o seguinte código a step5_introspection.py.
## step5_introspection.py
class Person:
species = "Homo sapiens"
def __init__(self, name, age):
self.name = name
self.age = age
p = Person("Alice", 30)
## hasattr(): Retorna True se o objeto tiver o atributo nomeado.
print(f"A pessoa tem o atributo 'name'? {hasattr(p, 'name')}")
print(f"A pessoa tem o atributo 'height'? {hasattr(p, 'height')}")
## setattr(): Este é o correspondente de getattr(). Ele define um atributo em um objeto.
print("Definindo o atributo 'height' para 175...")
setattr(p, 'height', 175)
print(f"A pessoa tem o atributo 'height' agora? {hasattr(p, 'height')}")
## getattr(): Retorna o valor do atributo nomeado de um objeto.
print(f"Nome da pessoa: {getattr(p, 'name')}")
print(f"Altura da pessoa: {getattr(p, 'height')}")
## dir(): Retorna a lista de nomes no escopo local atual ou os atributos de um objeto.
## Verificamos se 'height' está agora na lista de atributos.
print(f" 'height' está em dir(p)? {'height' in dir(p)}")
## globals(): Retorna um dicionário da tabela de símbolos global atual.
## Verificaremos se nossa classe 'Person' está em globals.
print(f" 'Person' está em globals? {'Person' in globals().keys()}")
## locals(): Retorna um dicionário da tabela de símbolos local atual.
def a_func():
x = 10
print(f" 'x' está em locals()? {'x' in locals().keys()}")
a_func()
Salve o arquivo e execute-o.
python3 step5_introspection.py
A saída demonstra como você pode verificar, definir e obter dinamicamente atributos de um objeto usando seus nomes em string. Também mostra como inspecionar os atributos de um objeto e as variáveis disponíveis nos escopos global e local.
Does person have 'name' attribute? True
Does person have 'height' attribute? False
Setting attribute 'height' to 175...
Does person have 'height' attribute now? True
Person's name: Alice
Person's height: 175
Is 'height' in dir(p)? True
Is 'Person' in globals? True
Is 'x' in locals()? True
Resumo
Parabéns por completar o laboratório! Você adquiriu experiência prática com uma ampla gama de funções built-in (integradas) essenciais do Python.
Neste laboratório, você aprendeu a:
- Converter entre tipos de dados e inspecionar objetos (
int,str,type,isinstance). - Realizar operações matemáticas comuns (
abs,sum,min,max,round). - Manipular e processar sequências e iteráveis (
len,sorted,map,filter,zip). - Lidar com I/O básico de arquivos e representação de objetos como string (
open,repr,format). - Inspecionar e modificar dinamicamente objetos e namespaces (
hasattr,getattr,setattr,dir).
Essas funções são fundamentais na programação Python do dia a dia. Dominá-las melhorará significativamente sua eficiência e legibilidade ao codificar. Continue explorando outras funções built-in e pratique o uso delas em seus próprios projetos.
