Resumo Python

Prévia do material em texto

Você pode escrever um programa inteiro em um arquivo e usar o interpretador para executar o conteúdo do arquivo como um todo. Esse arquivo é normalmente chamado de código fonte. Por exemplo, nós podemos usar um editor de texto para criar o código fonte no arquivo chamado “programa1.py” com o seguinte conteúdo:
print("Meu primeiro programa soma os numeros 2 e 3:")
print(2 + 3)
Tradicionalmente, o primeiro programa escrito em uma nova linguagem de programação é chamado de “Ola Mundo!” porque tudo que ele faz é apresentar as palavras “Ola Mundo!”. Em Python, ele é assim:
print("Ola Mundo!")
Isso é um exemplo da função print, que na realidade não “imprime” nada em papel. Ela apresenta um valor na tela. Neste caso, o resultado é o texto:
Ola Mundo!
Se você não está seguro sobre a classe a que pertence um valor, Python tem uma função chamada type que pode dizer-lhe isto.
print(type("Ola, mundo!"))
print(type(17))
print("Ola, mundo")
 
 
Não é surpresa que strings pertençam a uma classe chamada str e inteiros pertencem a classe chamada int.
Funções para conversão de valores
Algumas vezes é necessário converter valores de um tipo para o outro. Python fornece alguns funções simples que permitirão que façamos isso. As funções int, float e str irão (tentar) converter seus argumentos para os tipos int, float e str, respectivamente. Nós as chamamos de funções para conversão de valores.
A função int pode converter para int um argumento numérico em ponto flutuante ou um string. Para números em ponto flutuante, a parte decimal do número é descartada - um processo que chamaremso de trucamento para zero ou simplesmente truncamento do número. Vejamos isto isto em ação:
print(3.14, int(3.14))
print(3.9999, int(3.9999)) # Isto não arredonda para o inteiro mais próximo
print(3.0,int(3.0))
print(-3.999,int(-3.999)) # Observe que o resultado está mais próximo de zero
 
print("2345",int("2345")) # examina um string para produzir um int
print(17,int(17)) # int também funciona sobre inteiros
print(int("23garafas"))
 
O conversor de tipos float transforma um inteiro, um float ou um string representado um float de maneira sintaticamente legal em um float.
print(float("123.45"))
print(type(float("123.45")))
 
Se você pedir para que o valor de uma variável seja impresso, Python exibirá o valor que está atualmente associado à variável. Em outras palavras, ao imprimir uma variável será exibido o valor ao qual a variável se refere.
mensagem = "O que ha velhinho?"
n = 17
pi = 3.14159
 
print(mensagem)
print(n)
print(pi)
 
len é uma função nativa (built-in) no Python que returna o número de caracteres em um string. Vimos anteriormente que as funções print e type, logo este é o nosso terceiro exemplo de uma função!
y = 3.14
x = len("Ola")
print(x)
print(y)
 
Operadores são símbolos especiais que representam computações como adição, multiplicação e divisão. Os valores sobre os quais o operador trabalha são chamados operandos.
As seguintes expressões são legais em Python e os seus significados são mais ou menos claros:
20 + 32
hora - 1
hora * 60 + minutos
minutos / 60
5 ** 2
(5 + 9) * (15 - 7)
Os símbolos +, -, * e o uso de parênteses têm o mesmo significado em Python do que têm em matemática. O asterisco (*) é i símbolo usado para indicar multiplicação, e o ** é os ímbolo da exponenciação. Adição, subtração, multiplicação e exponenciação fazem o que você espera.
Quando o nome de uma variável aparece no lugar de um operando, ele é substituido pelo valor a que ele se refere antes da operação ser realizada. Por exemplo, veja o que pode ser feito se desejamos converter 645 em horas;
minutos = 645
horas = minutos / 60
print(horas)
 
 
Em Python 3, operador de divisão usa o símbolo / que sempre apresenta o resultado em ponto flutuante.
No exemplo anterior, suponha que desejamos agora saber o número de horas cheias e quantos minutos restantes temos em 645 minutos. Python oferece divisão de dois sabores diferentes. O segundo é chamado de divisão inteira (integer division) e usa os operador //. Ele sempre trunca o resultado para o menor inteiro (à esquerda da linha real).
print(7 / 4)
print(7 // 4)
minutos = 645
horas = minutos // 60
print(horas)
O operador módulo (modulus operator), também chamado de operador resto (remainder operator) ou operador resto da divisão(integer remainder operator) trabalho sobre os inteiros (e expressões inteiras) e devolve o resto da divisão do primeiro operando pelo segundo. In Python, o operador resto utiliza o símbolo de porcentagem (%). A sintaxe é a mesma da dos outros operadores
quociente = 7 // 3 # divisão inteira
print(quociente)
resto = 7 % 3
print(resto)
 
O operador resto é surpreendentemente útil. Por exemplo, você pode utilizá-lo para verificar se um número é divisível por outro — se x % y é zero, então x é divisível por y. Também, você pode extrair o dígito ou dígitos mais à direita de um número. Por exemplo, x %10 é o dígito mais a direita de x (na base 10). Similarmente x % 100 é o número formao pelos dois último dígitos de x.
IMPUT
A função imput permite que apresentemos um texto ou prompt ao usuário (prompt string). Quando a função é executada o texto é exibido. O usuário da programa pode digitar o nome e pressionar a tecla enter. Quando isto ocorre o texto que foi digitado é retornado pela função input e, no presente caso, atribuído à variável n.
n = input("Por favor, entre com o seu nome: ")
print("Ola", n)
Mesmo que você pessa ao usuário para digitar a sua idade, você receberá como resposta um string como "17". Será o se trabalho, como programador, converter esse string para int ou float, usando as funções de conversão int ou float que vimos anteriormente.
1
segundos_str = input("Por favor, entre com o número de segundos que deseja converter: ")
total_segs = int(secondos_str)
 
horas = total_segs // 3600
segs_restantes = total_segs % 3600
minutos = segs_restantes // 60
segs_restantes_final = segs_restantes % 60
 
print("Hrs=", horas, "mins=", minutos, "segs=", segs_restantes_final)
 
ATUALIZAÇÃO DE VARIÁVEIS 
Uma das forma mais comuns de reatribuição é atualização (update) onde o novo valor da variável depende do antigo. Por exemplo.
x = x + 1
Isto significa pegue o valor de x, adicione um, e atualize x com o novo valor. O novo valor de x é o anterior mais 1. Apesar desse comando de atribuição parecer um pouco estranho, lembre-se que executar uma atribuição é um processo de dois passos. Primeiro, o valor da lado direito da expressão é calculado. Segundo, faça com que o nome da variável que está no lado esquerdo se refira ao novo objeto resultante. O fato que x aparece em ambos os lados não importa. A semântica do comando de atribuição se encarrega que não haja confusão sobre o resultado.
print(x)
x = x + 1 # atualize x
print(x)
COMANDO FOR 
Em Python, o comando for nos permite escrever programas que implementam iterações. Por exemplo, vamos assumir que temos alguns amigos e que gostaríamos de enviar para cada um deles um email convidando-os para a nossa festa. Ainda não sabemos como enviar emails, então por enquanto vamos apenas imprimir uma mensagem para cada amigo.
for amigo in ["Joe", "Amy", "Brad", "Angelina", "Zuki", "Thandi", "Paris"]:
 print("Ola ", amigo, " Por favor venha a minha festa no sabado!")
FUNÇÃO RANGE
o Python fornece um objeto range (intervalo) nativo que pode ser usado para fornecer uma sequência de valores para o laço for. As sequências começam de 0 e nos casos mostrados abaixo não incluem o 4 e o 10.
for i in range(4):
 # Executa o corpo com i = 0, depois 1, depois 2, depois 3
for x in range(10):
 # x recebe um valor de [0, 1, 2, 3, 4, 5, 6, 7, 8, 9] de cada vez
Nota
Cientistas da computação gostam de contar a partir do 0!
A função range é na verdade uma função muito poderosa para a criação de sequências de inteiros. Ela pode receber um, dois ou três argumentos. Nós vimos o casomais simples de um argumento, como range(4) que cria [0, 1, 2, 3]. Mas e se na verdade quisermos a sequência [1, 2, 3, 4]? Podemos obter isso passando dois argumentos a range, onde o primeiro argumento define o início do intervalo e o segundo argumento define o fim. A chamada range(1, 5) retorna a sequência desejada. Mas o que aconteceu com o 5? Nesse caso interpretamos os argumentos de range para significar range(início, fim+1).
Finalmente, suponha que nós queremos ter uma sequência de números pares. Como é que vamos fazer isso? Fácil, nós adicionamos um outro parâmetro, um passo, que diz ao range o quanto pular. Então, se queremos os 10 primeiros números pares podemos usarrange(0,19,2). A forma mais geral de range é range(início, fim, passo). Você também pode criar uma sequência de números que começa grande e fica menor, usando um valor negativo para o passo.
print(range(0,19,2))
print(range(0,20,2))
print(range(10,0,-1))
 
FUNÇÕES
Em Python, uma função é uma sequência de comandos que executa alguma tarefa e que tem um nome. A sua principal finalidade é nos ajudar a organizar programas em pedaços que correspondam a como imaginamos uma solução do problema.
A sintaxe de uma definição de função é:
def NOME( PARÂMETROS ):
 COMANDOS
Funções que retornam valores são chamadas algumas vezes de funções frutíferas. Em muitas outras linguagens, uma função que não retorna um valor é chamado de procedimento. Mas ficaremos aqui com o jeito do Python e também chamaremos isso de função, ou quando quisermos enfatizar essa propriedade de não retornar valores, chamaremos a função de não-frutífera.
Funções frutíferas ainda permitem ao usuário fornecer informação (argumentos). Entretanto, existe agora um dado adicional que é retornado da função.
Como escrever funções futíferas? Vamos começar com uma função matemática bem simples, a função quadrado. A função quadrado terá um número como parâmetro e retornará o resultado desse número ao quadrado. Segue abaixo um diagrama do código Python seguinte.
.
def quadrado(x):
 y = x * x
 return y
 
aQuadrar = 10
resultado = quadrado(aQuadrar)
print("O resultado de", aQuadrar, "ao quadrado e'", resultado)
 
 
Aqui está o programa em activecode. Note que a definição da função é a mesma que era antes. Tudo que mudou são os detalhes de como o quadrado é feito. Este é um grande exemplo de projeto “caixa preta”. Podemos mudar os detalhes dentro da caixa e ainda assim usar a função exatamente como a usávamos antes.
def quadrado(x):
 somaparcial = 0
 for cont in range(x):
 somaparcial = somaparcial + x
 
 return somaparcial
 
aQuadrar = 10
resultado = quadrado(aQuadrar)
print("O resultado de", aQuadrar, "ao quadrado e'", resultado)
 
No programa acima, note que o variável somaparcial começa com o valor 0. Em seguida, a iteração é feita x vezes. Dentro do laço do for, a atualização ocorre. somaparcial é atualizada com um novo valor que é o valor antigo mais o valor de x.
Este padrão de iteração da atualização da variável é chamada comumente como padrão de acumulação. Nos referimos à variável como o acumulador. Este padrão aparece repetidas vezes. Lembre que a chave para fazer isto funcionar com sucesso é se certificar que a variável é inicializada antes de você começar as iterações. Uma vez dentro da iteração, é requerido que você atualize o acumulador.
Funções podem chamar outras funções
É importante entender que cada uma das funções que a gente escreve pode ser usada e chamada pelas outras funções que a gente escreve. Esta é uma das mais importantes formas que permitem que cientistas da computação peguem um problema grande e o quebrem em um grupo de problemas menores. Este processo de quebrar um problema em subproblemas menores é chamado de decomposição funcional.
OPERADORES 
O operador == é um dos seis operadores de comparação comuns; os outros são:
x != y # x não é igual a y
x > y # x é maior do que y
x < y # x é menor do que y
x >= y # x é maior ou igual a y
x <= y # x é menor ou igual a y
Embora essas operações sejam provavelmente familiares a você, os símbolos em Python são diferentes dos símbolos matemáticos. Um erro comum é usar somente um símbolo de igual (=) em vez de dois sinais iguais (==). Lembre-se de que = é um operador de atribuição e o == é um operador de comparação. Também, os operadores =< ou => não existem.
Existem três operadores lógicos: and, or e not. A semântica (significado) desses operadores é similar ao significado deles em português. Por exemplo, x > 0 and x < 10 é verdadeiro somente se x é maior do que 0 e ao mesmo tempo, x é menor do que 10. Como você descreveria isso em palavras? Você diria que x está entre 0 e 10, não incluindo as extremidades.
n % 2 == 0 or n % 3 == 0 é verdadeiro se uma das condições é verdadeira, isto é, se o número é divisível por 2 ou divisível por 3. Neste caso, uma, ou a outra, ou ambos as partes tem que ser verdadeira para o resultado ser verdadeiro.
Finalmente, o operador not nega uma expressão booleana, de forma que not  x > y é verdadeiro se x > y é falso, isto é, se x é menor ou igual a y.
x = 5
print(x>0 and x<10)
 
n = 25
print(n%2 == 0 or n%3 == 0)
 
 
Erro comum!
Existe um erro muito comum que ocorre quando programadores tentam escrever expressões booleanas. Por exemplo, suponha que queremos verificar se uma variável número tem valor 5, 6, or 7. Em palavras, podemos dizer: “número é igual a 5 ou 6 ou 7”. Entretanto, se traduzimos isto em Python, número == 5 or 6 or 7, isso não será correto. O operador or precisa juntar a verificação das três igualdades. A forma correta de escrever isto é número == 5 or número == 6 or número == 7. Isto pode parecer como um monte de digitação mas é absolutamente necessário. Não dá para fazer de forma mais compacta.
A tabela seguinte resume a precedência dos operadores em Python do maior ao menor. A tabela completa da linguagem pode ser encontrada em Python Documentation.
	Nível
	Categoria
	Operadores
	7(alto)
	exponenciação
	**
	6
	multiplicação
	*,/,//,%
	5
	adição
	+,-
	4
	relacional
	==,!=,<=,>=,>,<
	3
	lógico
	not
	2
	lógico
	and
	1(baixo)
	lógico
	or
COMANDOS DE SELÇÃO BINÁRIA
Com a finalidade de escrever programas úteis, quase sempre temos a necessidade de verificar condições e alterar o comportamento do programa de acordo com os resultados das condições. Comandos de seleção, algumas vezes também denominados de comandos condicionais nos dá essa habilidade. A forma mais simples de seleção é o comando if. Ele é algumas vezes denominado de seleção binária uma vez que admite dois possíveis caminhos de execução.
x = 15
 
if x % 2 == 0:
 print(x, "e' par")
else:
 print(x, "e' impar")
 
 
A sintaxe de um comando if se parece com:
if EXPRESSÃO BOOLEANA:
 COMANDOS_1 # executados se condição tem valor True
else:
 COMANDOS_2 # executados se condição tem valor False
A expressão booleana depois do if é chamada de condição. Se é verdadeira, então os comandos tabulados (COMANDOS_1) são executados. Se não, então os comandos tabulados depois do else são executados.
Fluxograma de um comando if com um else
Um condicional pode também ser aninhado dentro de outro. Por exemplo, assuma que temos duas variáveis inteiras x e y. O seguinte padrão de seleção mostra como podemos decidir como eles são relacionados entre si.
if x < y:
 print("x e' menor do que y.")
else:
 if x > y:
 print("x e' maior do que y.")
 else:
 print("x e y devem ser iguais.")
O condicional externo tem duas ramificações. A segunda ramificação (o else externo) contém outro comando if, o qual tem outras duas ramificações. Aquelas duas ramificações podem também conter comandos condicionais.
Python provê uma forma alternativa de escrever seleções aninhadas como as mostradas na seção anterior. Isto é chamado algumas vezes como condicionaisencadeadas
if x < y:
 print("x e' menor do que y.")
elif x > y:
 print("x e' maior do que y.")
else:
 print("x e y devem ser iguais.")
elif é uma abreviação de else if. Novamente, exatamente uma ramificação será executada. Não há limites no número de elif mas apenas um simples (e opcional) else final é permitido e precisa ser a última ramificação do comando.
Aqui vai o mesmo programa usando elif.
x = 10
y = 10
 
if x < y:
 print("x e' menor do que y.")
elif x > y:
 print("x e' maior do que y.")
else:
 print("x e y devem ser iguais.")
 
 
Funções podem retornar valores booleanos, o que é frequentemente conveniente para esconder dentro de funções testes complidados. Por exemplo:
def eDivisivel(x, y):
 if x % y == 0:
 result = True
 else:
 result = False
 
 return result
 
print(eDivisivel(10,5))
 
INTERAÇÕES
Lembre-se que o comando for processa cada item em uma lista. Cada item, por sua vez, é (re)atribuído a variável de contagem, e o corpo do laço é executado. Vimos este exemplo em um capítulo anterior.
5
for f in ["Joe", "Amy", "Brad", "Angelina", "Zuki", "Thandi", "Paris"]:
 invitation = "Hi " + f + ". Please come to my party on Saturday!"
 print(invitation)
 
 
COMANDO WHILE
Há um outro comando Python que pode ser usado para construir uma iteração. Ele é o comando while. O while fornece um mecanismo muito mais geral para a iteração. Semelhante ao comando if, ele usa uma expressão booleana para controlar o fluxo de execução. O corpo do while será repetido enquanto a expressão booleana de controle for avaliada como True.
A seguir ilustramos uma nova versão do programa que calcula a somatória utilizando o comando while.
15
def someAte(limite):
 """ Retorna a soma de 1+2+3 ... n """
 
 soma = 0
 numero = 1
 while numero <= limite:
 soma = soma + numero
 numero = numero + 1
 return soma
 
print(someAte(4))
 
print(someAte(1000))
Você quase pode ler o while como se fosse em linguagem natural como se fosse a palavara enquanto. Isso significa que, enquantonumero for menor ou igual a limite, continue a executar o corpo do laço. Dentro do corpo, atualize soma usando o padrão acumulador e incremente numero para produzir o próximo elemento da somatória. Ao final da execução do corpo do laço, vamos voltar a testar a condição do while. Quando numero tornar-se maior que limite, a condição falha e o próximo comando a ser executado de acordo com o fluxo de execução do while é o comando return.
Formalmente, este é o fluxo de execução do comando while:
Avalie a condição, que deve resultar em False ou True.
Se o resultado for False, saia do comando while e continue o programa executando o próximo comando.
Se o resultado da condição for True, execute os comandos dentro do corpo do while e, ao final, retorne ao passo 1.
Operação com String
uriosamente, o operador + funciona com strings. No entanto, esse o operador + representa concatenação e não adição. Concatenação significa juntar os dois operandos unindo o fim de um com o começo do outro. Por exemplo:
fruta = " banana"
tipo = "bolo de"
print(tipo + fruta)
 
 
 upper é um método que pode ser chamado em qualquer objeto string para criar um novo string no qual todos os caracteres estão em maiúsculas. lower funciona de forma semelhante, onde todos os caracteres do novo string estão em minúsculas. (O string original ss permanece inalterado. Um novo string é criado e é referenciado por tt.)
Além de upper e lower, a tabela a seguir apresenta um resumo de alguns outros métodos úteis de string. Existem alguns exemplos em activecode que se seguem, de modo que você pode experimentá-los.
	Método
	Parâmetros
	Descrição
	upper
	nenhum
	Retorna um string todo em maiúsculas
	lower
	nenhum
	Retorna um string todo em minúsculas
	capitalize
	nenhum
	Retorna um string com o primeiro caractere em maiúscula, e o resto em minúsculas
	strip
	nenhum
	Retorna um string removendo caracteres em branco do início e do fim
	lstrip
	nenhum
	Retorna um string removendo caracteres em brando do início
	rstrip
	nenhum
	Retorna um string removendo caracteres em brando do fim
	count
	item
	Retorna o número de ocorrências de item
	replace
	old, new
	Substitui todas as ocorrências do substring old por new
	center
	largura
	Retorna um string centrado em um campo de tamanho largura
	ljust
	largura
	Retorna um string justificado à esquerda em um campo de tamanho largura
	rjust
	largura
	Retorna um string justificado à direita em um campo de tamanho largura
	find
	item
	Retorna o índice mais à esquerda onde o substring item é encontrado
	rfind
	item
	Retorna o índice mais à direita onde o substring item é encontrado
	index
	item
	Como find, mas causa um erro em tempo de execução caso item não seja encontrado
	rindex
	item
	Como rfind, mas causa um erro em tempo de execução caso item não seja encontrado
Comprimento
A função len, quando aplicada a um string, retorna o número de caracteres no string (ou seja, o seu comprimento).
fruta = "Banana"
print(len(fruta))
 
Comparação de strings
Os operadores de comparação também funcionam com strings. Para ver se dois strings são iguais, basta escrever uma expressão booleana usando o operador de igualdade.
word = "banana"
if word == "banana":
 print("Yes, we have bananas!")
else:
 print("Yes, we have NO bananas!")
 
 
Varredura com for por item
Um grande número de computações envolvem o processamento de item de um conjunto de cada vez. Para strings, isto significa que nós gostaríamos de processar um caractere de cada vez. Muitas vezes, nós começamos no início, selecionamos um caractere de cada vez, fazemos alguma coisa com ele, e continuamos até o final. Este padrão de processamento é chamado um percurso.
Anteriormente, vimos que o comando for pode iterar sobre os itens de uma sequência (uma lista de nomes no caso abaixo).
for um_nome in ["Joe", "Amy", "Brad", "Angelina", "Zuki", "Thandi", "Paris"]:
 convite = "Oi " + um_nome + ". Venha para a festa nesse sabado!"
 print(convite)
 
Varredura com while
O laço while também pode controlar a geração dos valores de índices. Lembre-se que o programador é responsável por configurar a condição inicial, certificando-se que a condição é correta e certificando-se de que algo muda dentro do corpo para garantir que a condição se tornará falsa.
fruta = "apple"
 
position = 0
while position < len(fruta):
 print(fruta[position])
 position = position + 1
Repetições e contagens
Vamos terminar este capítulo com mais alguns exemplos que mostram variações sobre o tema da iteração pelos dos caracteres de um string. Vamos implementar alguns dos métodos que descrevemos anteriormente para mostrar como eles podem vir a ser.
O programa a seguir conta o número de vezes que uma letra em particular, aChar, aparece em um string. É mais um exemplo do padrão de acumulação que vimos nos capítulos anteriores.
def count(text, aChar):
 lettercount = 0
 for c in text:
 if c == aChar:
 lettercount = lettercount + 1
 return lettercount
 
print(count("banana","a"))
 
 
3
A função count recebe um string como parâmetro. O comando for itera por cada caractere do string e verifica se o caractere é igual ao valor de aChar. Se igual, a variável de contagem, lettercount, é incrementada. Quando todos os caracteres forem processados, lettercount é retornada.
indexação ([])
Acessa um único caractere em um string usando sua posição (com início em 0). Exemplo: 'Isso'[2] resulta em 's'.
função len (comprimento)
Retorna o número de caracteres em um string. Exemplo: len('happy') resulta em 5.
percurso do laço for (for)
Percorrer um string significa acessar cada caractere no string, um de cada vez. Por exemplo, o seguinte laço for:
for ix in 'Exemplo':
 ...
executa o corpo do laço 7 vezes com diferentes valoresde ix a cada vez.
fatiamento ([:])
Uma fatia (slice) é um substring de um string. Exemplo: 'sorvete de banana'[3:6] resulta em vet.
comparação de strings (>, <, >=, <=, ==, !=)
Os seis operadores relacionais (de comparação) comuns funcionam com strings e são avaliados de acordo com a ordem lexicográfica. Exemplos: 'apple' < 'banana' resulta em True. 'Zeta' < 'Appricot' resulta em False. 'Zebra' <= 'aardvark'resulta em True pois todas as letras maiúsculas precedem as minúsculas.
operadores in e not in (in, not in)
O operador in testa se um string está contido em outro. Exemplos: 'curar' in "Eu vou procurar voce." resulta em True.'curdado' in "Eu vou procurar voce." resulta em False.
indexação ([])
Acessa um único caractere em um string usando sua posição (com início em 0). Exemplo: 'Isso'[2] resulta em 's'.
função len (comprimento)
Retorna o número de caracteres em um string. Exemplo: len('happy') resulta em 5.
percurso do laço for (for)
Percorrer um string significa acessar cada caractere no string, um de cada vez. Por exemplo, o seguinte laço for:
for ix in 'Exemplo':
 ...
executa o corpo do laço 7 vezes com diferentes valores de ix a cada vez.
fatiamento ([:])
Uma fatia (slice) é um substring de um string. Exemplo: 'sorvete de banana'[3:6] resulta em vet.
comparação de strings (>, <, >=, <=, ==, !=)
Os seis operadores relacionais (de comparação) comuns funcionam com strings e são avaliados de acordo com a ordem lexicográfica. Exemplos: 'apple' < 'banana' resulta em True. 'Zeta' < 'Appricot' resulta em False. 'Zebra' <= 'aardvark'resulta em True pois todas as letras maiúsculas precedem as minúsculas.
operadores in e not in (in, not in)
O operador in testa se um string está contido em outro. Exemplos: 'curar' in "Eu vou procurar voce." resulta em True.'curdado' in "Eu vou procurar voce." resulta em False.
Como você esperaria, podemos também atribuir listas a variáveis e termos listas como parâmetro de funções.
vocabulario = ["iteracao", "selecao", "controle"]
numeros = [17, 123]
vazia = []
lista_mista = ["ola", 2.0, 5*2, [10, 20]]
 
print(numeros)
print(lista_mista)
nova_lista = [numeros, vocabulario]
print(nova_lista)
 
 
[17, 123]
['ola', 2, 10, [10, 20]]
[[17, 123], ['iteracao', 'selecao', 'controle']]
Comprimento de uma lista
Da mesma forma que occore com strings, a função len retorna o comprimento de uma lista (o número de elementos na lista). Entretanto, como listas podem conter itens que são listas, é importante notar que len somente retorna o comprimento da lista mais externa. Em outras palavras, sublistas de uma lista são consideradas como sendo um elemento simples quando contamos o comprimento da lista.
uma_lista = ["ola", 2.0, 5, [10, 20]]
print(len(uma_lista))
print(len(['spam!', 1, ['Brie', 'Roquefort', 'Pol le Veq'], [1, 2, 3]]))
 
 
4
4
Acessando os elementos
A sintaxe para acessar um elemento de uma lista é a mesma usada para acessar um caractere de um string. Nós usamos o operador de indexação ( [] – não confundir com a lista vazia). A expressão dentro dos conchetes especifica o índice. Lembrar que o índice do primeiro elemento é 0. Qualquer expressão que tenha como resultado um número inteiro pode ser usada como índice e como com strings, índices negativos indicarão elementos da direita para a esquerda ao invés de da esquerda para a direita.
numeros = [17, 123, 87, 34, 66, 8398, 44]
print(numeros[2])
print(numeros[9-8])
print(numeros[-2])
print(numeros[len(numeros)-1])
 
 
87
123
8398
44
Pertinência em uma Lista
in e not in são operadores booleanos ou lógicos que testam a pertinência (membership) em uma sequência. Já usamos esses operadores com strings e eles também funcionam aqui.
frutas = ["maca", "laranja", "banana", "cereja"]
 
print("maca" in frutas)
print("pera" in frutas)
 
 
True
False
Concatenação e repetição
Novamente, como com strings, o operador + concatena listas. Analogamente, o operador * repete os itens em uma lista um dado número de vezes.
frutas = ["maca", "laranja", "banana", "cereja"]
print([1, 2] + [3, 4])
print(frutas + [6, 7, 8, 9])
 
print([0] * 4)
print([1, 2, ["ola", "adeus"]]*2)
 
 
[1, 2, 3, 4]
['maca', 'laranja', 'banana', 'cereja', 6, 7, 8, 9]
[0, 0, 0, 0]
[1, 2, ['ola', 'adeus'], 1, 2, ['ola', 'adeus']]
Listas são mutáveis
Diferentemente de strings, listas são mutáveis (mutable). Isto significa que podemos alterar um item em uma lista acessando-o diretamente como parte do comando de atribuição. Usando o operador e indexação (colchetes) à esquerda de um comando de atribuição, podemos atualizar um dos itens de uma lista.
frutas = ["banana", "maca", "cereja"]
print(frutas)
 
frutas[0] = "pera"
frutas[-1] = "laranja"
print(frutas)
 
 
 ['banana', 'maca', 'cereja']
['pera', 'maca', 'laranja']
Repetições e referências
Já vimos que o operador de repetição trabalho sobre strings e também sobre listas. Por exemplo.
lista_original = [45, 76, 34, 55]
print(lista_original*3)
 
 
 [45, 76, 34, 55, 45, 76, 34, 55, 45, 76, 34, 55]
Listas e o laço for
É possível percorrermos uma lista (list traversal) iterando através de itens ou iterando através de índices.
frutas = ["pera", "laranja", "banana", "cereja"]
 
for uma_fruta in frutas: # por item
 print(uma_fruta)
 
 
pera
laranja
banana
cereja
É quase como leríamos em linguagem natural: para (cada) fruta) em (a lista de) frutas, escreva (o nome da) fruta.
Podemos também usar o índice para acessar os itens iterativamente.
frutas = ["pera", "laranja", "banana", "cereja"]
 
for posicao in range(len(frutas)): # por índice
 print(frutas[posicao])
 
 
(chp09_03b)
Run Save Load 
pera
laranja
banana
cereja
Neste exemplo, em cada iteração do laço, a variável posição é usada como um índice da lista, imprimindo o posicao-ésimo item. Note que usamos len como limite superior do intervalo de tal forma que podemos iterar corretamente independentemente do número de itens na lista.
Qualquer expressão sequencial pode ser usada em um laço for. Por exemplo, a função range retornal uma sequência de inteiros.
for numero in range(21):
 if numero % 3 == 0:
 print(numero)
 
 
0
3
6
9
12
15
18
Este exemplo exibe todos os multiplos de 3 entre 0 e 20.
Como listas são mutáveis, é frequentemente desejável que modifiquemos os elementos de uma lista a medida que ela é percorrida. No código a seguir todos os números inteiros entre 1 e 5 são elevados ao quadrado utilizando iteração por posição.
numeros = [1, 2, 3, 4, 5]
print(numeros)
 
for i in range(len(numeros)):
 numeros[i] = numeros[i]**2
 
print(numeros)
 
 
[1, 2, 3, 4, 5]
[1, 4, 9, 16, 25]
Para um minuto para refretir sobre range(len(numeros) até que você entenda como funciona. Estamos interessados aqui sobre ambos o valor e o índice de uma posição da lista de tal maneira que atribuir un novo valor à posição.
Suponha que tenhamos uma função primo(x) que recebe um número inteiro x e retorna True se o valor de x é primo e False em caso contrário. Agora, escrevemos uma função que recebe um número inteiro n e cria e retorna uma lista com todos os números primos menores que n:
def primos_ate(n):
 """ (int) -> list
 Recebe um inteiro n e cria e retorna a lista dos números
 primos menores que n.
 """
 lista_primos = []
 for i in range(2,n):
 if primo(i):
 lista_primos.append(i);
 return lista_primos