Python: tipos, listas, dicionários e laços com saídas conferidas

Python é a linguagem que mais aparece em provas de tecnologia quando a banca quer testar lógica sem exigir muita sintaxe. A cobrança é quase sempre a mesma: um trecho curto, e a pergunta “o que será impresso?”. Cada trecho deste guia foi executado em um interpretador Python 3 e a saída mostrada é a obtida. Os detalhes de funções, escopo e exceções ficam em Python: funções, escopo, exceções e pegadinhas.

Operadores aritméticos

Expressão	Saída	Observação
`7 / 2`	3.5	divisão sempre devolve número decimal
`7 // 2`	3	divisão inteira (piso)
`7 % 2`	1	resto
`-7 // 2`	-4	o piso de -3,5 é -4, não -3
`-7 % 2`	1	o resto acompanha o sinal do divisor
`2 ** 10`	1024	potência
`10 / 5`	2.0	continua decimal

A divisão inteira com negativos é pegadinha clássica: // arredonda para baixo, em direção a menos infinito, e não em direção a zero. Já int(-3.9) devolve -3, pois int trunca.

Precisão de decimais binários: 0.1 + 0.2 resulta em 0.30000000000000004, e 0.1 + 0.2 == 0.3 é False, porque números decimais são guardados em binário e nem todo valor decimal cabe exatamente. round(0.1 + 0.2, 2) dá 0.3. Um detalhe do round: round(2.5) é 2 e round(3.5) é 4; o arredondamento vai para o par mais próximo nos empates.

Tipos e conversões

Valor	Tipo
`1`	int
`1.0`	float
`'a'`	str
`True`	bool
`[1, 2]`	list
`(1, 2)`	tuple
`{'a': 1}`	dict
`{1, 2}`	set
`None`	NoneType

Conversão e concatenação: int('42') + 1 dá 43, mas '42' + '1' dá '421' (junção de texto), e '4' * 3 dá '444'. Somar texto com número gera erro; é preciso converter.

Valores que contam como falsos em testes lógicos: 0, texto vazio, lista vazia e None. O texto '0' e o texto ' ' (um espaço) contam como verdadeiros, porque não são vazios. Teste executado: bool(0), bool(''), bool([]) e bool(None) deram False; bool('0') e bool(' ') deram True.

Comparações podem ser encadeadas: 3 > 2 > 1 é True. E 1 == 1.0 é True, mas 10 == '10' é False.

Listas

Listas são sequências mutáveis, indexadas a partir de 0, e aceitam índice negativo.

Com l = [5, 2, 9, 1]:

Expressão	Resultado
`l[0]`	5
`l[-1]`	1
`l[1:3]`	[2, 9] (do índice 1 até antes do 3)
`l[:2]`	[5, 2]
`l[::-1]`	[1, 9, 2, 5] (invertida)
`l[::2]`	[5, 9] (de dois em dois)
`len(l)`	4

Regra do fatiamento: [início:fim:passo], com o fim excluído. Métodos: append(7) acrescenta ao final; insert(1, 8) coloca o 8 na posição 1; pop() remove e devolve o último; remove(2) apaga a primeira ocorrência do valor 2. Em teste, a sequência partiu de [5, 2, 9, 1], virou [5, 2, 9, 1, 7], depois [5, 8, 2, 9, 1, 7], o pop() devolveu 7 e, após remove(2), restou [5, 8, 9, 1].

Diferença cobrada: sorted(l) devolve uma nova lista ordenada e não altera a original; l.sort() ordena a própria lista e devolve None. Tuplas são imutáveis: t[0] = 9 gera TypeError: 'tuple' object does not support item assignment.

Dicionários e conjuntos

O dicionário guarda pares chave-valor. Com d = {'ana': 10, 'bruno': 4}, após d['carla'] = 8:

d['ana'] dá 10; d['zeca'] gera KeyError; d.get('zeca') dá None; d.get('zeca', 0) dá 0.
'ana' in d testa a presença de chave (True).
d.keys(), d.values() e d.items() dão chaves, valores e pares.

O conjunto elimina repetidos: {1, 2, 2, 3, 3, 3} vira {1, 2, 3}, de tamanho 3. Operações: {1,2,3} & {2,3,4} dá {2, 3} (interseção); | dá {1, 2, 3, 4} (união); - dá {1} (diferença). Os conjuntos não têm ordem garantida de exibição nem índice.

Laços e condicionais

range(n) gera de 0 até n-1; range(2, 10, 3) gera 2, 5, 8; sum(range(1, 101)) dá 5050. Compreensões de lista condensam laços: [x*x for x in range(5)] dá [0, 1, 4, 9, 16] e [x for x in range(10) if x % 2 == 0] dá [0, 2, 4, 6, 8].

for n in range(5):
    if n == 3:
        break
    print(n)
else:
    print('sem break')

A saída é 0, 1 e 2, e a mensagem do else não aparece, porque o break ocorreu. O else do laço só executa quando o laço termina sem break. Num for n in range(3): pass seguido de else, o else executa. Esse uso do else é pegadinha frequente.

O while repete enquanto a condição for verdadeira; esquecer de atualizar a variável cria laço infinito. A expressão condicional 'par' if x % 2 == 0 else 'impar', com x igual a 5, resulta em 'impar'.

Textos

Com s = 'concurso': len(s) dá 8; s.upper() dá 'CONCURSO'; s[0:3] dá 'con'; s[::-1] dá 'osrucnoc'; 'a,b,c'.split(',') dá ['a', 'b', 'c']; '-'.join(['a', 'b']) dá 'a-b'. Textos são imutáveis: s[0] = 'x' gera erro. Formatação: f'{3.14159:.2f}' dá 3.14.

Operadores lógicos devolvem valores

5 and 3 dá 3 e 0 or 'x' dá 'x': and e or devolvem um dos operandos, e não necessariamente True ou False. not 0 dá True. E True + True dá 2, pois o booleano é um tipo numérico.

Erros comuns

Usar / esperando inteiro.
Esquecer que o fim do fatiamento é excluído.
Confundir sort() com sorted().
Achar que o else do for roda quando há break.
Esperar ordem fixa em conjuntos.
Usar = (atribuição) em vez de == (comparação) em condições.

Fontes e atualização

Não há norma oficial brasileira sobre a linguagem Python; o conteúdo segue a documentação e o comportamento do interpretador, e todas as saídas foram obtidas executando o código em Python 3. O comportamento de alguns recursos muda entre versões da linguagem: confira a versão citada no edital.

Próximos passos

Continue em Python: funções, escopo, exceções e pegadinhas.
Veja os conceitos de objetos em programação orientada a objetos.
Treine lógica de algoritmos em busca sequencial e binária e Big O.