MAC0216 - Técnicas de Programação I
Python possui vários tipos de dados que armazenam sequências. Exemplos deles são:
list - sequências mutáveis e heterogêneastuple - sequências imutáveis e heterogêneasstr - sequências imutáveis e homogêneas (de caracteres)bytes - sequências imutáveis e homogêneas (de dados binários)bytearray - sequências mutáveis e homogêneas (de dados binários)Listas (list) e tuplas (tuple) podem conter sequências de valores de qualquer tipo. Inclusive, uma sequência desses tipos pode ser heterogênea, ou seja, pode conter valores de diferentes tipos. Esses tipos de sequência guardam apenas as referências para os valores, por isso são mais flexíveis.
Nesta aula, veremos mais detalhes sobres os tipos list e str.
list)¶Uma lista (tipo list) em Python é uma sequência de valores de qualquer tipo ou classe tais como int, float, bool, str e mesmo list, entre outros.
Existem várias maneiras de se criar uma lista. A maneira mais simples é envolver os elementos da lista por colchetes ([ e ]). Por exemplo, podemos criar uma lista contendo os anos de obtenção das 5 primeiras conquistas do Brasil em Copas do Mundo de Futebol da seguinte maneira:
anos_conquistas = [1958, 1962, 1970, 1994, 2002]
print(type(anos_conquistas))
print("O conteúdo da lista é:", anos_conquistas)
print("A quantidade de elementos da lista é:", len(anos_conquistas))
Para obter o comprimento de uma lista (ou seja, o número de elementos que a lista possui) usamos a função len() (de length), como mostrado no exemplo acima.
[] denota uma lista vazia, ou seja, uma lista que não contém nenhum elemento. O comprimento de uma lista que não contém nenhum elemento é 0.
lista_vazia = [] # cria uma lista vazia, ou seja com nenhum elemento dentro dela
print("O conteúdo da lista é:", lista_vazia)
print("A quantidade de elementos da lista é:", len(lista_vazia))
Usando o operador * conseguimos criar rapidamente listas de um determinado comprimento contendo elementos iguais. Veja os exemplos.
lista1 = [3] * 10 # criar uma lista contendo 10 elementos, todos de valor 3
tamanho = len(lista1)
print("Lista com", len(lista1), "elementos de valor 3:", lista1)
print()
lista2 = [1,2,3] * 5
print("Lista com 5 subsequências repetidas:", lista2)
Ao contrário do conceito de vetores em linguagem C, que são coleções indexadas homogêneas de dados (todos elementos do vetor são de um mesmo tipo), as listas em Python podem conter vários tipos de dados, sendo, portanto, possível armazenar coleções heterogêneas de dados.
Veja o exemplo a seguir:
lista = ["Fulano de tal", 21, 78266123, "Bacharelado em Ciência da Computação"]
print("Lista com elementos de diferentes tipos:", lista)
Usamos l[i] para nos referir à posição de número (= índice) i em uma lista l, sendo que a primeira posição de uma lista é a de índice 0, a segunda é a de índice 1, e assim por diante, até a última posição da lista - que tem índice len(l)-1. Veja os exemplos a seguir:
lista = [10, 20, 30, 40, 50]
print(lista[0]) # mostra o valor do primeiro elemento da lista
print(lista[2])
print(lista[4]) # mostra o valor do último elemento da lista
print(lista[len(lista)-1]) # também mostra o valor do último elemento da lista
Podemos usar números negativos como índices para acessar as posições de uma lista na ordem reversa, ou seja, do fim para o início. O índice -1 se refere a última posição da lista, o -2 se refere à penúltima posição, e assim por diante.
lista5 = [10, 20, 30, 40, 50]
print(lista5[-1]) # mostra o valor do último elemento da lista
print(lista5[-len(lista5)]) # mostra o valor do primeiro elemento da lista
Também é possível modificar o valor de uma posição específica da lista:
lista6 = [10, 20, 30]
print(lista6)
lista6[0] = 5 # altera o valor da primeira posição da lista
lista6[-1] //= 2 # altera o valor da última posição da lista
print(lista6)
Quando tentamos acessar uma posição que não existe na lista, um erro de execução list index out of range é gerado:
lista7 = [10, 20]
print(lista7[2]) # tenta exibir o valor de uma posição que não existe na lista
Podemos usar a função append() para acrescentar novos elementos em uma lista. Para acrescentar o elemento x ao final de uma lista l, fazemos l.append(x). Veja os exemplos a seguir:
lista8 = [40]
print("Estado inicial da lista: ", lista8)
lista8.append(10)
print("Estado da lista depois da primeira inclusão de um novo elemento: ", lista8)
lista8.append(30)
print("Estado da lista depois da segunda inclusão de um novo elemento: ", lista8)
for elemento in lista¶Embora os elementos de uma lista também possam ser percorridos por meio de um laço tradicional (os que vimos nas aulas anteriores), existe um tipo de laço for especial para percorrer todos os elementos de uma lista, começando do seu início para o fim. A estrutura desse laço é
for elemento in lista:
onde elemento é o nome da variável que receberá um elemento da lista e lista é uma lista de elementos. Exemplo:
lista9 = [10, 20, 30, 40]
soma = 0
for numero in lista9:
print(numero)
soma += numero
print("A soma é", soma)
Finalmente, o operador in nos permite verificar se um dado valor está em uma lista. A expressão
valor in lista
devolve True se valor for um elemento de lista, e False no caso contrário.
lista10 = [0,2,4,6,8,10]
print(lista10)
if 4 in lista10:
print("O valor 4 está na lista.")
if 3 not in lista10:
print("O valor 3 não está na lista.")
Obs.: Tanto o laço for ... in ... quanto os operadores in e not in podem ser usados com outros tipos de sequências (como str e tuple) além das listas.
Dados n > 0 e uma sequência com n números reais, imprimi-los na ordem inversa à da leitura.
Obs.: Este problema corresponde ao exercício 1 da lista de exercícios sobre vetores.
#--------------------------------------------
# Programa principal
def main():
print ("Lê n números reais e imprime-os em ordem reversa")
n = int(input("Digite n: "))
cont = 0
seq = [] # cria uma lista vazia
for i in range(n):
num = float(input("Digite um número da sequência: "))
seq.append(num) # coloca num no final da lista
print("Sequência original: ", seq)
print("Solução 1: usando índices decrescentes")
for i in range(n-1,-1,-1):
print(seq[i], end = ' ')
print ()
# ou ainda, usando índices negativos
print("Solução 2: usando índices negativos")
cont = -1
for i in range(1,n+1):
print(seq[-i], end = ' ')
print()
#--------------------------------------------
main()
No Python, é possível usar a função reverse() de um objeto do tipo list para inverter a ordem dos elementos de uma lista. Mas é preciso ter cuidado ao usar essa função, por que ela modifica a lista a partir da qual ela foi chamada.
Já com a função reversed(), obtem-se um iterador reverso da lista, que permite percorrê-la da posição do fim até a posição de início, sem alterar a ordem dos elementos na lista.
A função reversed() pode ser usada com tipos de sequência mutáveis e imutáveis (como tuple e str).
Veja como fica a solução do problema anterior usando essas duas funções:
#--------------------------------------------
# Programa principal
def main():
print ("Lê n números reais e imprime-os em ordem reversa")
n = int(input("Digite n: "))
cont = 0
seq = [] # cria uma lista vazia
for i in range(n):
num = float(input("Digite um número da sequência: "))
seq.append(num) # coloca num no final da lista
print("Sequência original: ", seq)
print("Solução 1: percorrendo a lista com o iterador reverso gerado por reversed()")
for num in reversed(seq):
print(num, end = ' ')
print()
print("Solução 2: usando a função reverse() para inverter os elementos na lista")
seq.reverse() # inverte a ordem dos elementos da lista
print(seq)
#----------------------------------------------
main()
def main():
'''
Programa que le n notas de provas, calcula a media
das notas da prova e imprime o numero de notas
maiores que a media calculada.
'''
# leia o numero de notas
n = int(input("Digite o número de notas: "))
# inicializacoes
soma_notas = 0
lista_notas = []
# calcule a soma das notas e crie uma lista com
# as notas
for i in range(n):
nota = float(input("Digite uma nota: "))
soma_notas += nota
lista_notas.append(nota)
# calcule a media
media_notas = soma_notas/n
print("A media das notas e %.1f" %(media_notas))
# conte quantas notas estao acima da media
cont = 0
for nota in lista_notas:
if nota > media_notas:
cont += 1
print("%d notas sao maiores que %.1f" %(cont, media_notas))
#----------------------------------------------------
main()
#--------------------------------------------
# Programa principal
def main():
print ("Frequência relativa de n lançamentos de uma roleta")
n = int(input("Digite n: "))
cont = 0
seq = [0] * 37 # cria uma lista de 37 posições com zeros
while cont < n:
cont += 1
num = int(input("Digite o resultado do lançamento %d: "%(cont)))
seq[num] += 1
i = 0
for freq in seq:
if freq > 0:
print("frequência dos números sorteados %d = %5.2f" %(i, freq/n))
i += 1
# ou ainda, usando as funções range() e len()
print("Outra solução")
for i in range(len(seq)):
if seq[i] > 0:
print ("frequência dos números sorteados %d = %5.2f" %(i, seq[i]/n))
#--------------------------------------------
main()
Quando fazemos uma de atribuição de uma variável do tipo list para uma outra variável, precisamos ter cuidado. A operação de atribuição nesse caso não faz uma cópia da lista na nova variável, ela apenas cria uma outra referência para a mesma lista. Veja o exemplo a seguir:
lista1 = [20, 40, 30, 10]
print("Lista 1:", lista1)
lista2 = lista1
print("Lista 2:", lista2)
print("Atribuindo um novo valor à primeira posição da Lista 1...")
lista1[0] = 50 # modifica primeira posição de lista1
print("Lista 1:", lista1)
print("Lista 2:", lista2)
print("Inclindo um novo elemento na Lista 2...")
lista2.append(60)
print("Lista 1:", lista1)
print("Lista 2:", lista2)
Pelo exemplo acima, é possível ver que uma modificação em lista1 é refletida também em lista2 e vice-versa. Na verdade, as variáveis lista1 e lista2 são apenas dois nomes diferentes para uma mesma lista.
Esse tipo de comportamento não acontece com variáveis dos tipos int e float. Veja o exemplo a seguir:
num1 = 20
num2 = num1
print(num1, num2)
num1 = 30
print(num1, num2)
num2 = 50
print(num1, num2)
Diante do exposto acima, qual é a forma correta de se copiar uma lista (ou seja, criar uma nova lista com os mesmos elementos de uma lista já existente)?
A função clone() mostrada abaixo exemplifica uma forma de se fazer isso.
def clone(lista):
""" (list) --> list
Cria e retorna um clone da lista recebida como parâmetro.
"""
clone = []
for i in range(len(lista)):
clone.append(lista[i])
return clone
# Testa a função clone
lista3 = [0,1,2,3,4,5,6]
copia_lista3 = clone(lista3) # cria uma cópia de lista3 na variável copia_lista3
print("Lista:", lista3)
print("Cópia da lista:", copia_lista3)
lista3[0] = 100
print("Lista modificada:", lista3)
print("Mas a cópia da lista não foi afetada:", copia_lista3)
Uma outra forma mais simples de criar uma cópia de uma lista é usando o operador o operador de "fatiar" listas :. Veja o exemplo a seguir:
lista3 = [0,1,2,3,4,5,6]
copia_lista3 = lista3[:] # cria uma cópia de lista3 na variável copia_lista3
print("Lista:", lista3)
print("Cópia da lista:", copia_lista3)
lista3[0] = 100
print("Lista modificada:", lista3)
print("Mas a cópia da lista não foi afetada:", copia_lista3)
O exemplo acima mostra o operador : sendo usado em um caso particular, para criar uma cópia de uma lista. Mas, ele pode ser usado para criar uma nova lista a partir de qualquer "fatia" de elementos de uma outra lista. Veja alguns exemplos:
lista4 = [0,1,2,3,4,5,6]
lista5 = lista4[2:5] # Cria uma nova lista contendo os elementos das pos. de 2 até a 4 (inclusive) da lista4
lista6 = lista4[1:4] # Cria uma nova lista contendo os elementos das pos. de 1 até a 2 (inclusive) da lista4
print("L4:", lista4)
print("L5:", lista5)
print("L6:", lista6)
lista4[3] = 100
lista5[1] = 200
lista6[2] = 300
# Mostra que as modificações feitas em uma das listas não afetam as demais
print("L4:", lista4)
print("L5:", lista5)
print("L6:", lista6)
Quando fazemos lista[:], estamos usando o operador : para criar uma nova lista contendo a "fatia completa" de uma outra lista. Mas também podemos usar esse operador sem restringir apenas um dos limites, como nos exemplos abaixo:
lista7 = [0,1,2,3,4,5,6]
print(lista7[3:]) # imprime os elementos da lista a partir da posição 3
print(lista7[:5]) # imprime os elementos da lista até a posição 4
No fatiamento, há ainda a possibilidade de especificar o tamanho do passo para avançar da posição de início até a posição de fim da fatia, como mostrado no exemplo abaixo:
lista8 = [0,1,2,3,4,5,6]
lista9 = lista8[1:6:2]
print(lista9)
no Python, é possível usar a função index() de um objeto do tipo list para obter o índice de um dado elemento dentro de uma lista.
Também há o operador in, que verifica se um dado elemento está em uma lista.
Alguns exemplos de uso do operador in e da função index() são mostrados abaixo:
lista = ["oi", 1, 3.14, "Maçã", 7, False]
print("'oi' in lista", "oi" in lista)
print("'oi' not in lista", "oi" not in lista)
print("not 'oi' in lista", not "oi" in lista)
if 5 in lista:
print("5 está na lista")
else:
print("5 não está na lista")
print("'Maçã' está na posicao %d da lista" %(lista.index("Maçã")))
if lista.index("oi") == 0:
print("'oi' é o primeiro elemento da lista")
Dada uma sequência de n números reais, escreva um programa que conte quantas vezes cada número ocorre na sequência.
def main():
'''
Dados n e uma sequência com n números reais,
conta e imprime o numero de vezes que cada
número ocorre na sequência.
'''
n = int(input("Digite o tamanho da sequência: "))
lista_numeros = []
cont_ocorrencias = []
for i in range(n):
numero = float(input("Digite um número: "))
if numero not in lista_numeros:
lista_numeros.append(numero)
cont_ocorrencias.append(1)
else:
j = lista_numeros.index(numero)
cont_ocorrencias[j] += 1
print(" Número no. ocorrências")
for i in range(len(lista_numeros)):
print("%10.2f %6d" %(lista_numeros[i],cont_ocorrencias[i]))
#---------------------------------------------------
main()
None¶Python possui um valor especial, o None, que pode ser usado para representar a ausência de valor.
O None é útil, por exemplo, quando queremos indicar que uma dada posição de uma lista está vazia (ou seja, não possui um valor associada a ela).
O tipo do valor None é NoneType; aliás, ele é o único valor existente desse tipo.
Veja os exemplos a seguir:
valor = None
print(valor, "-->", type(valor))
lista = [1,2,3,None,5,None]
print(lista," --> tamanho da lista:",len(lista))
Importante: Não confundir o valor especial None com as strings "None" ou "none". O valor especial é escrito sem aspas e com a primeira letra em maiúsculo.
valor1 = "None" # Essa é uma string, não é o valor especial None
print("Tipo do valor 1:", type(valor1))
valor2 = None # Esse é o valor especial None
print("Tipo do valor 2:", type(valor2))
valor1 == valor
Não podemos fazer operações matemáticas envolvendo o None como operador (ele não é equivalente ao valor zero!). Veja a seguir um exemplo de erro gerado quando tentamos fazer operações matemáticas com o None:
valor1 = 12
valor2 = None
valor1 + valor2
Quando precisamos fazer operações matemáticas envolvendo os elementos de uma lista que pode conter posições com o valor None, então é sempre preciso verificar o valor antes de envolvê-lo em algum cálculo, como mostrado no exemplo a seguir:
lista = [1,2,3,None,5,None]
# vamos fazer um laço para somar os elementos da lista
soma = 0
for elemento in lista:
if elemento != None: # só soma o elemento se ele não for None
soma += elemento
print(soma)
Vimos nesta aula várias exemplos de operações em listas, mas que na verdade se aplicam a outros tipos de sequências (como tuple, str e bytes). A tabela a seguir apresenta um resumo dessas e de outras operações para sequências:
| Operação | Descrição | Observações | |
|---|---|---|---|
x in s |
True se existe em s um elemento igual a x, False no caso contrário |
||
x not in s |
False se existe em s um elemento igual a x, True no caso contrário |
||
s + t |
A concatenação de s e t |
||
s * n ou n * s |
Equivale a adicionar s a ela mesma n vezes |
||
s[i] |
i-ésimo elemento de s |
Início na posição 0 | (1) |
s[i:j] |
Fatia de s da posição i até j |
(1)(2) | |
s[i:j:k] |
Fatia de s da posição i até j com passo k |
(1)(2) | |
len(s) |
comprimento de s |
||
min(s) |
menor elemento de s |
||
max(s) |
maior elemento de s |
||
s.index(x[, i[, j]]) |
índice da primeira ocorrência de x em s (na posição i ou depois dela e antes da posição j |
||
s.count(x) |
número total de ocorrências de x em s |
(1) Se i ou j é negativo, o índice é relativo ao fim da sequência.
(2) A fatia de s de i a j é definida como a sequência de itens com índice k tal que i <= k < j. Se i ou j é maior que len(s), considera len(s) no lugar. Se i é omitido ou None, usa 0. Se j é omitido ou None, usa len(s). Se i>= j, a fatia é vazia.
Também vimos nesta aula alguns exemplos de operações de modificação em listas, mas que também podem ser aplicadas a qualquer tipo de sequência mutável (como é o caso de str e bytes).
A tabela a seguir apresenta um resumo dessas e de outras operações de modificação para sequências mutáveis:
| Operação | Descrição | Observações |
|---|---|---|
s[i] = x |
Substitui elemento na i-ésima posição por x |
|
s[i:j] = t |
Substitui a fatia s a i pelo conteúdo do iterável t |
|
del s[i:j] |
Equivale a s[i:j] = [] |
|
s[i:j:k] = t |
Substitui os elementos de s[i:j:k] pelos de t |
t e s[i:j:k] precisam ter o mesmo tamanho |
del s[i:j:k] |
Remove da sequência s os elementos em s[i:j:k] |
|
s.append(x) |
Adiciona x no final da sequência |
|
s.clear() |
Remove todos os elementos da sequência s |
|
s.copy() |
Cria uma cópia (rasa) de s (como o s[:]) |
|
s.extend(t) ou s += t |
Extende s com o conteúdo de t |
|
s *= n |
Atualiza s com o seu conteúdo repetido n vezes |
|
s.insert(i, x) |
Insere x na posição i |
|
s.pop([i]) |
Devolve o elemento na posição i e também o remove de s |
Valor default de i é -1 |
s.remove(x) |
Remove o primeiro elemento de s igual a x |
|
s.reverse() |
Reverte os elementos de s, mudando a sequência original |
https://docs.python.org/3/library/stdtypes.html#typesseq-mutable
str)¶Para lidar com dados textuais em Python, usamos strings, que são objetos do tipo str.
Strings são sequências imutáveis de code points Unicode.
Strings literais podem ser delimitadas de diferentes formas:
com quebras de linha dentro"""
Assim como fazemos com listas, nós podemos:
usar a função len() para saber qual é o tamanho de uma string
acessar uma posição específica de uma string usando o operador de indexação []
usar o operador de "fatiar" : para obter trechos de uma string
Em Python, não existe um tipo de dado separado para caracteres (como o tipo char, de C). A indexação de uma string não vazia produz uma string de tamanho um.
Veja os exemplos a seguir:
texto = "A minha matéria favorita é MAC2166"
print("Texto completo: %s" %(texto))
print("O texto possui %d caracteres" %len(texto))
print("O caracter na posição 3 do texto é:", texto[2], type(texto[2]))
print("O trecho de texto entre as posições 7 e 15 é:", texto[6:15])
Embora possamos acessar o seu valor, não podemos modificar uma posição específica de uma string usando indexação. Strings em Python são imutáveis. Essa é uma diferença importante entre strings e listas. Veja o exemplo abaixo:
poeminha = "Betatinha quando dorme, espalha a rama pelo chão"
poeminha[1] = "a"
Há diferentes formas de se converter valores numéricos em strings. A mais direta delas é por meio da função str(), como mostrado nos exemplos a seguir:
num_dois = 2
print(num_dois, "-->", type(num_dois))
str_dois = str(num_dois) # converte o valor em num_dois para string e armazena-o em str_dois
print(str_dois, "-->", type(str_dois))
str_real = str(3.33333333333)
print(str_real, "-->", type(str_real))
Uma outra forma de converter números em strings é por meio de strings de formatação, como as que frequentemente usamos nos comandos print e input, nos exercícios que fazemos em aula. Veja exemplos a seguir:
num_real1 = 13.2278430
num_real2 = 4.9
num_int1 = 121
num_int2 = 6
str_reais_formatados = "Números reais formatados: |%6.3f|, |%6.3f|" %(num_real1, num_real2)
print(str_reais_formatados)
str_ints_formatados = "Números inteiros formatados: |%4d|, |%4d|" %(num_int1, num_int2)
print(str_ints_formatados)
str_num_simples = "%d" %(num_int1)
print(str_num_simples, "-->", type(str_num_simples))
Há diferentes formas de se formatar strings em Python:
%d (ao estilo printf de C) - https://docs.python.org/3/library/stdtypes.html#printf-style-string-formattingformat() - https://docs.python.org/3/library/stdtypes.html#str.formatVeja exemplos de seu uso abaixo:
nome = "Fulano de Tal"
peso = 87.352
str1 = "Usando o operador '%%d': %s, %3.1f" %(nome, peso)
print(str1)
str2 = "Usando o método 'format()': {}, {:3.1f}".format(nome, peso)
print(str2)
str3 = f"Usando uma 'f-string': {nome} {peso:3.1f}"
print(str3)
O operador + (de concatenação) pode ser aplicado tanto a listas quanto a strings. O primeiro exemplo a seguir mostra um caso de uso envolvendo listas, enquanto o segundo exemplo se refere à concatenação de strings:
lista1 = [1,2,3]
lista2 = [9,8,7,6,5]
lista3 = lista1 + lista2 # cria uma nova lista contendo os elementos de lista1 e lista2
print(lista3)
verso1 = "Como diria o Cebolinha: "
verso2 = "- Keep calm and make an infallible plan!"
citacao = verso1 + verso2 # cria uma nova string com a junção de verso1 e verso2
print(citacao)
ord() e chr()¶A função ord() devolve o código numérico do caractere passado como parâmetro.
A função chr() devolve o caracter corresponde ao código numérico passado como parâmetro.
Veja os exemplos a seguir:
print(type("A"))
print(ord("8"))
print(ord("?"))
print(ord("A"))
print(ord("C"))
print(ord("^"))
print(ord("a"))
A função ord() gerará um erro se passarmos como parâmetro uma string contendo mais de um caracter:
ord("olá!")
print(chr(43))
print(chr(54))
print(chr(65))
print(chr(472))
def main():
texto = input("Digite um texto: ")
n = len(texto)
nv = 0
vogais = ['a', 'e', 'i', 'o', 'u', 'A', 'E', 'I', 'O', 'U']
for letra in texto:
if letra in vogais:
nv += 1
print ("Frequencia relativa = %d/%d = %f" %(nv, n, nv/n))
#-------------------------------------------
main()
for para varrer a lista de vogais)¶def main():
texto = input("Digite um texto: ")
n = len(texto)
nv = 0
vogais = "aeiouAEIOU"
for i in range(n):
for j in range(len(vogais)):
if texto[i] == vogais[j]:
nv += 1
print ("Frequencia relativa = %d/%d = %f" %(nv, n, nv/n))
#-------------------------------------------
main()
O tipo string em Python possui funções para converter uma string para letras maiúsculas ou minúsculas - são as funções upper() e lower(). Veja um exemplo do uso delas a seguir:
texto = "PeQuEno TesTE"
textoMaiusculo = texto.upper() # cria uma string com o texto em letras maiúsculas
textoMinusculo = texto.lower() # cria uma string com o texto em letras minúsculas
print(textoMaiusculo)
print(textoMinusculo)
A função split() de str cria uma lista de strings a partir de uma só string. A função recebe como parâmetro o caractere (ou a string) que será usada como separador de substrings dentro da string a ser "desmembrada". Veja os exemplos de uso dela a seguir:
texto = "Passarim quis pousar, não deu, voou"
palavras = texto.split(" ") # usa o caracter de espaço como separador de substrings
print(palavras)
outro_texto = "Este é um string"
pedacos = outro_texto.split("t") # usa "t" como caracter separador
print(pedacos)
Outros exemplos de operações de Python específicas para strings bastante usadas são:
str.find(sub[, start[, end]]) - devolve o menor índice no qual a string sub é encontrada na fatia s[start:end]str.join(iterable) - devolve uma nova string com a concatenação das strings em iterablestr.replace(old, new[, count]) - devolve uma nova string em que todas as count primeiras ocorrências da string old são substituídas por newstr.strip([chars]) - devolve uma nova string sem os caracteres em chars no início ou no fim da string (o default é remover espaços em branco)Para a descrição dessas e das demais funções para strings, consulte: https://docs.python.org/3/library/stdtypes.html#text-sequence-type-str
List comprehensions (ou listcomps, como são chamadas pelos pythonistas) são uma forma prática e elegante de se construir uma lista com base em uma outra sequência. Com elas, pode-se facilmente criar, por exemplo, uma lista nova a partir da aplicação de uma função a cada um dos elementos da sequência de origem ou da filtragem de seus elementos.
O formato geral de uma listcomp é (a parte do if é opcional):
<nova_lista> = [<expressão> for <item> in <iterável> if <condição> == True]
Veja exemplos de uso de listcomps abaixo:
import math
lista1 = [49, 25, 64, 2]
print("Lista 1:", lista1)
# Gera nova lista com a raiz quadrada dos números da lista original
lista2 = [math.sqrt(num) for num in lista1]
print("Lista 2:", lista2)
# Exibe a lista 1 de novo, para mostrar que ela não
# foi alterada com o listcomp
print("Lista 1 de novo:", lista1)
# Gera lista com as palavras de uma string
lista3 = [palavra for palavra in "Batatinha quando nasce".split()]
print("Lista 3", lista3)
Como pode ser visto na lista2 do exemplo acima, as listcomps podem gerar listas com elementos de tipos de dados diferentes dos da lista original.
Veja abaixo o código de criação das mesmas listas do exemplo anterior, mas desta vez usando apenas laços, sem usar listcomps.
Observe que, com os listcomps, não é preciso criar a lista vazia e nem usar o append para incluir os elementos.
import math
lista1 = [49, 25, 64, 2]
print("Lista 1:", lista1)
# Gera nova lista com a raiz quadrada dos números da lista original
lista2 = []
for num in lista1:
lista2.append(math.sqrt(num))
print("Lista 2:", lista2)
# Exibe a lista 1 de novo, para mostrar que ela não
# foi alterada com os listcomps
print("Lista 1 de novo:", lista1)
# Gera lista com as palavras de uma string
lista3 = []
for palavra in "Batatinha quando nasce".split():
lista3.append(palavra)
print("Lista 3:", lista3)
Obs.: Toda listcomp pode ser reescrita na forma de laço, mas nem todo laço pode ser reescrito como uma listcomp.
Também é possível usar em listcomps condicionais (if), tanto na <expressão> quanto dentro do laço for (para filtrar elementos). Veja os exemplos abaixo:
lista1 = [10, 15, 20, 25, 30, 35]
print("Lista 1:", lista1)
# Gera nova lista somente com o quadrado dos números pares
# da lista original
lista2 = [num**2 for num in lista1 if num % 2 == 0]
print("Lista 2:", lista2)
# Gera nova lista somente com os números da lista
# original que são pares e múltiplos de 3
lista3 = [num for num in lista1 if num % 2 == 0 if num % 3 == 0]
print("Lista 3:", lista3)
# Gera uma lista de strings que indicam se os números na lista
# original são pares ou ímpares
lista4 = ["Par" if num % 2 == 0 else "Ímpar" for num in lista1]
print("Lista 4:", lista4)
A implementação equivalente dos exemplos acima sem usar listcomps é mostrada abaixo:
lista1 = [10, 15, 20, 25, 30, 35]
print("Lista 1:", lista1)
# Gera nova lista somente com o quadrado dos números pares
# da lista original
lista2 = []
for num in lista1:
if num % 2 == 0:
lista2.append(num**2)
print("Lista 2:", lista2)
# Gera nova lista somente com os números da lista
# original que são pares e múltiplos de 3
lista3 = []
for num in lista1:
if num % 2 == 0:
if num % 3 == 0:
lista3.append(num)
print("Lista 3:", lista3)
# Gera uma lista de strings que indicam se os números na lista
# original são pares ou ímpares
lista4 = []
for num in lista1:
if num % 2 == 0:
lista4.append("Par")
else:
lista4.append("Ímpar")
print("Lista 4:", lista4)
Também é possível ter em listcomps laços aninhados, o que possibilita, por exemplo, gerar o produto cartesiano de duas ou mais listas:
cores = ["Verde", "Amarelo", "Azul", "Branco"]
tamanhos = ["P", "M", "G"]
camisetas = [[tam,cor] for tam in tamanhos for cor in cores]
print(camisetas)