Manipule Vários Objetos Embutidos do Python

Beginner

This tutorial is from open-source community. Access the source code

Introdução

Neste laboratório, você aprenderá como manipular vários objetos Python embutidos. Python oferece uma variedade de tipos de dados embutidos, como números, strings, listas e dicionários. Dominar esses objetos é crucial para todo programador Python.

Além disso, através de exercícios práticos, você praticará operações Python essenciais e aprenderá a trabalhar eficazmente com números, strings, listas e dicionários Python.

Este é um Lab Guiado, que fornece instruções passo a passo para ajudá-lo a aprender e praticar. Siga as instruções cuidadosamente para completar cada etapa e ganhar experiência prática. Dados históricos mostram que este é um laboratório de nível iniciante com uma taxa de conclusão de 85%. Recebeu uma taxa de avaliações positivas de 99% dos estudantes.

Trabalhando com Números Python

Python oferece suporte robusto para operações numéricas. Em programação, números são tipos de dados fundamentais usados para cálculos e representação de quantidades. Este passo irá apresentá-lo à manipulação básica de números em Python, o que é essencial para realizar várias operações matemáticas em seus programas.

Operações Aritméticas Básicas

Para começar a trabalhar com números Python, você primeiro precisa abrir um shell interativo Python. Você pode fazer isso digitando python3 no seu terminal. O shell interativo Python permite que você escreva e execute código Python linha por linha, o que é ótimo para testar e aprender.

python3

Uma vez no shell interativo Python, você pode tentar algumas operações aritméticas básicas. Python segue as regras matemáticas padrão para aritmética, como a ordem das operações (PEMDAS: Parênteses, Expoentes, Multiplicação e Divisão, Adição e Subtração).

>>> 3 + 4*5    ## A multiplicação tem precedência maior que a adição, então 4*5 é calculado primeiro, depois adicionado a 3
23
>>> 23.45 / 1e-02    ## Notação científica para 0.01 é usada aqui. A divisão é realizada para obter o resultado
2345.0

Divisão Inteira

Python 3 lida com a divisão de forma diferente do Python 2. Entender essas diferenças é crucial para evitar resultados inesperados em seu código.

>>> 7 / 4    ## Em Python 3, a divisão regular retorna um float, mesmo que o resultado possa ser um inteiro
1.75
>>> 7 // 4   ## A divisão inteira (trunca a parte decimal) dá o quociente como um inteiro
1

Métodos de Números

Números em Python têm vários métodos úteis que são frequentemente negligenciados. Esses métodos podem simplificar operações numéricas e conversões complexas. Vamos explorar alguns deles:

>>> x = 1172.5
>>> x.as_integer_ratio()    ## Este método representa o float como uma fração, o que pode ser útil para alguns cálculos matemáticos
(2345, 2)
>>> x.is_integer()    ## Verifica se o float é um valor inteiro. Neste caso, 1172.5 não é um inteiro, então retorna False
False

>>> y = 12345
>>> y.numerator    ## Para inteiros, o numerador é o próprio número
12345
>>> y.denominator    ## Para inteiros, o denominador é sempre 1
1
>>> y.bit_length()    ## Este método informa o número de bits necessários para representar o número em binário, o que pode ser útil em operações bitwise
14

Esses métodos são particularmente úteis quando você precisa realizar operações numéricas ou conversões específicas. Eles podem economizar tempo e tornar seu código mais eficiente.

Quando terminar de explorar o shell interativo Python, você pode sair digitando:

>>> exit()

Trabalhando com Strings Python

Strings são um dos tipos de dados mais comumente usados em Python. Elas são usadas para representar texto e podem conter letras, números e símbolos. Neste passo, exploraremos várias operações de string, que são habilidades essenciais para trabalhar com dados de texto em Python.

Criando e Definindo Strings

Para começar a trabalhar com strings em Python, primeiro precisamos abrir um shell interativo Python. Este shell nos permite escrever e executar código Python linha por linha, o que é ótimo para aprender e testar. Abra um shell interativo Python novamente usando o seguinte comando:

python3

Uma vez que o shell esteja aberto, podemos definir uma string. Neste exemplo, criaremos uma string que contém símbolos de ações. Uma string em Python pode ser definida envolvendo texto entre aspas simples (') ou aspas duplas ("). Veja como definimos nossa string:

>>> symbols = 'AAPL IBM MSFT YHOO SCO'
>>> symbols
'AAPL IBM MSFT YHOO SCO'

Agora criamos uma variável de string chamada symbols e atribuímos um valor a ela. Quando digitamos o nome da variável e pressionamos Enter, Python exibe o valor da string.

Acessando Caracteres e Substrings

Em Python, strings podem ser indexadas para acessar caracteres individuais. A indexação começa em 0, o que significa que o primeiro caractere de uma string tem um índice de 0, o segundo tem um índice de 1 e assim por diante. A indexação negativa também é suportada, onde -1 se refere ao último caractere, -2 se refere ao penúltimo caractere e assim por diante.

Vamos ver como podemos acessar caracteres individuais em nossa string symbols:

>>> symbols[0]    ## Primeiro caractere
'A'
>>> symbols[1]    ## Segundo caractere
'A'
>>> symbols[2]    ## Terceiro caractere
'P'
>>> symbols[-1]   ## Último caractere
'O'
>>> symbols[-2]   ## Penúltimo caractere
'C'

Também podemos extrair substrings usando fatiamento (slicing). O fatiamento nos permite obter uma parte da string especificando um índice inicial e final. A sintaxe para fatiamento é string[start:end], onde a substring inclui caracteres do índice inicial até (mas não incluindo) o índice final.

>>> symbols[:4]    ## Primeiros 4 caracteres
'AAPL'
>>> symbols[-3:]   ## Últimos 3 caracteres
'SCO'
>>> symbols[5:8]   ## Caracteres do índice 5 a 7
'IBM'

Imutabilidade de Strings

Strings em Python são imutáveis, o que significa que, uma vez que uma string é criada, você não pode alterar seus caracteres individuais. Se você tentar modificar um caractere em uma string, Python irá gerar um erro.

Vamos tentar alterar o primeiro caractere de nossa string symbols:

>>> symbols[0] = 'a'    ## Isso causará um erro

Você deve ver um erro como este:

Traceback (most recent call last):
  File "<stdin>", line 1, in <module>
TypeError: 'str' object does not support item assignment

Este erro indica que não podemos atribuir um novo valor a um caractere individual em uma string porque as strings são imutáveis.

Concatenação de Strings

Embora não possamos modificar strings diretamente, podemos criar novas strings através da concatenação. Concatenação significa juntar duas ou mais strings. Em Python, podemos usar o operador + para concatenar strings.

>>> symbols += ' GOOG'    ## Anexar um novo símbolo
>>> symbols
'AAPL IBM MSFT YHOO SCO GOOG'

>>> symbols = 'HPQ ' + symbols    ## Adicionar um novo símbolo no início
>>> symbols
'HPQ AAPL IBM MSFT YHOO SCO GOOG'

É importante lembrar que essas operações criam novas strings em vez de modificar a string original. A string original permanece inalterada, e uma nova string é criada com o valor combinado.

Testando por Substrings

Para verificar se uma substring existe dentro de uma string, podemos usar o operador in. O operador in retorna True se a substring for encontrada na string e False caso contrário.

>>> 'IBM' in symbols
True
>>> 'AA' in symbols
True
>>> 'CAT' in symbols
False

Observe que 'AA' retorna True porque é encontrado dentro de "AAPL". Esta é uma maneira útil de pesquisar texto específico dentro de uma string maior.

Métodos de String

Strings Python vêm com inúmeros métodos embutidos que nos permitem realizar várias operações em strings. Esses métodos são funções que estão associadas ao objeto string e podem ser chamadas usando a notação de ponto (string.method()).

>>> symbols.lower()    ## Converter para minúsculas
'hpq aapl ibm msft yhoo sco goog'

>>> symbols    ## A string original permanece inalterada
'HPQ AAPL IBM MSFT YHOO SCO GOOG'

>>> lowersyms = symbols.lower()    ## Salvar o resultado em uma nova variável
>>> lowersyms
'hpq aapl ibm msft yhoo sco goog'

>>> symbols.find('MSFT')    ## Encontrar o índice inicial de uma substring
13
>>> symbols[13:17]    ## Verificar a substring nessa posição
'MSFT'

>>> symbols = symbols.replace('SCO','')    ## Substituir uma substring
>>> symbols
'HPQ AAPL IBM MSFT YHOO  GOOG'

Quando terminar de experimentar, você pode sair do shell Python usando o seguinte comando:

>>> exit()

Trabalhando com Listas Python

Listas são um tipo de estrutura de dados em Python. Uma estrutura de dados é uma maneira de organizar e armazenar dados para que possam ser usados eficientemente. Listas são muito versáteis porque podem armazenar diferentes tipos de itens, como números, strings ou até mesmo outras listas. Neste passo, aprenderemos como realizar várias operações em listas.

Criando Listas a partir de Strings

Para começar a trabalhar com listas Python, primeiro precisamos abrir uma sessão interativa Python. Isso é como um ambiente especial onde podemos escrever e executar código Python imediatamente. Para iniciar esta sessão, digite o seguinte comando em seu terminal:

python3

Uma vez na sessão interativa Python, criaremos uma lista a partir de uma string. Uma string é apenas uma sequência de caracteres. Definiremos uma string que contém alguns símbolos de ações separados por espaços. Em seguida, converteremos essa string em uma lista. Cada símbolo de ação se tornará um elemento na lista.

>>> symbols = 'HPQ AAPL IBM MSFT YHOO GOOG'
>>> symlist = symbols.split()    ## Dividir a string em espaços em branco
>>> symlist
['HPQ', 'AAPL', 'IBM', 'MSFT', 'YHOO', 'GOOG']

O método split() é usado para dividir a string em partes onde houver um espaço em branco. Cada parte então se torna um elemento na nova lista.

Acessando e Modificando Elementos da Lista

Assim como as strings, as listas suportam indexação. Indexação significa que podemos acessar elementos individuais na lista por sua posição. Em Python, o primeiro elemento em uma lista tem um índice de 0, o segundo tem um índice de 1 e assim por diante. Também podemos usar indexação negativa para acessar elementos do final da lista. O último elemento tem um índice de -1, o penúltimo tem um índice de -2 e assim por diante.

Ao contrário das strings, os elementos da lista podem ser modificados. Isso significa que podemos alterar o valor de um elemento na lista.

>>> symlist[0]    ## Primeiro elemento
'HPQ'
>>> symlist[1]    ## Segundo elemento
'AAPL'
>>> symlist[-1]   ## Último elemento
'GOOG'
>>> symlist[-2]   ## Penúltimo elemento
'YHOO'

>>> symlist[2] = 'AIG'    ## Substituir o terceiro elemento
>>> symlist
['HPQ', 'AAPL', 'AIG', 'MSFT', 'YHOO', 'GOOG']

Iterando Através de Listas

Frequentemente, precisamos realizar a mesma operação em cada elemento de uma lista. Podemos usar um loop for para fazer isso. Um loop for nos permite percorrer cada elemento da lista um por um e realizar uma ação específica nele.

>>> for s in symlist:
...     print('s =', s)
...

Quando você executar este código, verá cada elemento da lista impresso com o rótulo s =.

s = HPQ
s = AAPL
s = AIG
s = MSFT
s = YHOO
s = GOOG

Verificando a Pertinência

Às vezes, precisamos verificar se um determinado item existe em uma lista. Podemos usar o operador in para fazer isso. O operador in retorna True se o item estiver na lista e False caso contrário.

>>> 'AIG' in symlist
True
>>> 'AA' in symlist
False
>>> 'CAT' in symlist
False

Adicionando e Removendo Elementos

Listas têm métodos embutidos que nos permitem adicionar e remover elementos. O método append() adiciona um elemento ao final da lista. O método insert() insere um elemento em uma posição específica na lista. O método remove() remove um elemento da lista por seu valor.

>>> symlist.append('RHT')    ## Adicionar um elemento ao final
>>> symlist
['HPQ', 'AAPL', 'AIG', 'MSFT', 'YHOO', 'GOOG', 'RHT']

>>> symlist.insert(1, 'AA')    ## Inserir em uma posição específica
>>> symlist
['HPQ', 'AA', 'AAPL', 'AIG', 'MSFT', 'YHOO', 'GOOG', 'RHT']

>>> symlist.remove('MSFT')    ## Remover por valor
>>> symlist
['HPQ', 'AA', 'AAPL', 'AIG', 'YHOO', 'GOOG', 'RHT']

Se você tentar remover um elemento que não existe na lista, Python irá gerar um erro.

>>> symlist.remove('MSFT')

Você verá uma mensagem de erro como esta:

Traceback (most recent call last):
  File "<stdin>", line 1, in <module>
ValueError: list.remove(x): x not in list

Também podemos encontrar a posição de um elemento na lista usando o método index().

>>> symlist.index('YHOO')
4
>>> symlist[4]    ## Verificar o elemento nessa posição
'YHOO'

Ordenando Listas

As listas podem ser ordenadas no local, o que significa que a lista original é modificada. Podemos ordenar uma lista alfabeticamente ou em ordem inversa.

>>> symlist.sort()    ## Ordenar alfabeticamente
>>> symlist
['AA', 'AAPL', 'AIG', 'GOOG', 'HPQ', 'RHT', 'YHOO']

>>> symlist.sort(reverse=True)    ## Ordenar em ordem inversa
>>> symlist
['YHOO', 'RHT', 'HPQ', 'GOOG', 'AIG', 'AAPL', 'AA']

Listas Aninhadas

Listas podem conter qualquer tipo de objeto, incluindo outras listas. Isso é chamado de lista aninhada.

>>> nums = [101, 102, 103]
>>> items = [symlist, nums]
>>> items
[['YHOO', 'RHT', 'HPQ', 'GOOG', 'AIG', 'AAPL', 'AA'], [101, 102, 103]]

Para acessar elementos em uma lista aninhada, usamos vários índices. O primeiro índice seleciona o elemento da lista externa e o segundo índice seleciona o elemento da lista interna.

>>> items[0]    ## Primeiro elemento (o symlist)
['YHOO', 'RHT', 'HPQ', 'GOOG', 'AIG', 'AAPL', 'AA']
>>> items[0][1]    ## Segundo elemento em symlist
'RHT'
>>> items[0][1][2]    ## Terceiro caractere em 'RHT'
'T'
>>> items[1]    ## Segundo elemento (a lista nums)
[101, 102, 103]
>>> items[1][1]    ## Segundo elemento em nums
102

Quando terminar de trabalhar na sessão interativa Python, você pode sair digitando:

>>> exit()

Trabalhando com Dicionários Python

Em Python, dicionários são uma estrutura de dados fundamental. Eles são armazenamentos chave-valor (key-value), o que significa que permitem mapear um valor (o valor) para outro (a chave). Isso é extremamente útil ao lidar com dados que possuem relações naturais chave-valor. Por exemplo, você pode querer mapear o nome de uma pessoa (a chave) para sua idade (o valor), ou, como veremos neste laboratório, mapear símbolos de ações (chaves) para seus preços (valores).

Criando e Acessando Dicionários

Vamos começar abrindo uma nova sessão interativa Python. Isso é como entrar em um ambiente especial onde você pode escrever e executar código Python linha por linha. Para iniciar esta sessão, abra seu terminal e digite o seguinte comando:

python3

Uma vez na sessão interativa Python, você pode criar um dicionário. Em nosso caso, criaremos um dicionário que mapeia símbolos de ações para seus preços. Veja como você faz isso:

>>> prices = {'IBM': 91.1, 'GOOG': 490.1, 'AAPL': 312.23}
>>> prices
{'IBM': 91.1, 'GOOG': 490.1, 'AAPL': 312.23}

Na primeira linha, estamos criando um dicionário chamado prices e atribuindo a ele alguns pares chave-valor. As chaves são os símbolos das ações (IBM, GOOG, AAPL) e os valores são os preços correspondentes. A segunda linha apenas mostra o conteúdo do dicionário prices.

Agora, vamos ver como acessar e modificar os valores no dicionário usando as chaves.

>>> prices['IBM']    ## Acessar o valor para a chave 'IBM'
91.1

>>> prices['IBM'] = 123.45    ## Atualizar um valor existente
>>> prices
{'IBM': 123.45, 'GOOG': 490.1, 'AAPL': 312.23}

>>> prices['HPQ'] = 26.15    ## Adicionar um novo par chave-valor
>>> prices
{'IBM': 123.45, 'GOOG': 490.1, 'AAPL': 312.23, 'HPQ': 26.15}

Na primeira linha, estamos acessando o valor associado à chave IBM. Nas segunda e terceira linhas, estamos atualizando o valor da chave IBM e, em seguida, adicionando um novo par chave-valor (HPQ com um preço de 26.15).

Obtendo as Chaves do Dicionário

Às vezes, você pode querer obter uma lista de todas as chaves em um dicionário. Existem algumas maneiras de fazer isso.

>>> list(prices)    ## Converter as chaves do dicionário em uma lista
['IBM', 'GOOG', 'AAPL', 'HPQ']

Aqui, estamos usando a função list() para converter as chaves do dicionário prices em uma lista.

Você também pode usar o método keys(), que retorna um objeto especial chamado dict_keys.

>>> prices.keys()    ## Retorna um objeto dict_keys
dict_keys(['IBM', 'GOOG', 'AAPL', 'HPQ'])

Obtendo os Valores do Dicionário

Da mesma forma, você pode querer obter todos os valores em um dicionário. Você pode usar o método values() para isso.

>>> prices.values()    ## Retorna um objeto dict_values
dict_values([123.45, 490.1, 312.23, 26.15])

Este método retorna um objeto dict_values que contém todos os valores no dicionário prices.

Excluindo Itens

Se você deseja remover um par chave-valor de um dicionário, pode usar a palavra-chave del.

>>> del prices['AAPL']    ## Excluir a entrada 'AAPL'
>>> prices
{'IBM': 123.45, 'GOOG': 490.1, 'HPQ': 26.15}

Aqui, estamos excluindo o par chave-valor com a chave AAPL do dicionário prices.

Verificando se uma Chave Existe

Para verificar se uma chave existe em um dicionário, você pode usar o operador in.

>>> 'IBM' in prices
True
>>> 'AAPL' in prices
False

O operador in retorna True se a chave existir no dicionário e False caso contrário.

Métodos de Dicionário

Dicionários têm vários métodos úteis. Vamos analisar alguns deles.

>>> prices.get('MSFT', 0)    ## Obter valor ou padrão se a chave não existir
0
>>> prices.get('IBM', 0)
123.45

>>> prices.update({'MSFT': 25.0, 'GOOG': 500.0})    ## Atualizar múltiplos valores
>>> prices
{'IBM': 123.45, 'GOOG': 500.0, 'HPQ': 26.15, 'MSFT': 25.0}

O método get() tenta obter o valor associado a uma chave. Se a chave não existir, ele retorna um valor padrão (neste caso, 0). O método update() é usado para atualizar vários pares chave-valor no dicionário de uma só vez.

Quando terminar de trabalhar na sessão interativa Python, você pode sair digitando:

>>> exit()

Resumo

Neste laboratório, você aprendeu a trabalhar com vários objetos embutidos do Python. Especificamente, você dominou operações em números Python e seus métodos, manipulou strings por meio de indexação, fatiamento (slicing) e funções embutidas, criou e modificou listas, incluindo ordenação e manipulação de estruturas aninhadas, e usou dicionários para armazenamento e recuperação de chave-valor.

Essas habilidades fundamentais são a base da programação Python mais avançada. A prática regular dessas operações aprimorará sua familiaridade com os tipos de dados embutidos do Python.