Exceções, classes e a biblioteca padrão

9 / 3 não gera exceção (例外), então não se entra em except. A cláusula else só é executada quando não ocorreu exceção, então else é executado depois de try. A cláusula finally é sempre executada, quer tenha ocorrido exceção ou não, então ela é executada por último. Por isso as 3 linhas são try, else, finally. Uma alternativa que inclui except é a ordem para o caso em que você acha, por engano, que ocorreu uma exceção; ZeroDivisionError não ocorre nesta chamada. Uma alternativa sem finally é a ordem que você obteria se confundisse finally com "a limpeza para quando ocorre uma exceção".

A cláusula else (else節) de uma instrução try só é executada quando a cláusula try terminou até o fim sem gerar exceção. Vale a pena lembrar que essa direção é oposta à do else de uma instrução if, que é para "quando a condição é falsa": o else do try fica do lado de "quando tudo correu bem". O que é executado quando ocorreu uma exceção é a cláusula except. O que é sempre executado, quer tenha ocorrido exceção ou não, é, por sua vez, a cláusula finally. Quando nenhuma das cláusulas except corresponde, a execução não cai no else; essa exceção se propaga para quem chamou.

f() prepara o valor que vai retornar, mas, antes de realmente retornar, executa a cláusula finally (finally節). Por isso F é impresso primeiro, e o valor de retorno continua sendo T. g() tem um return dentro da sua cláusula finally, e ele sobrescreve o return da cláusula try, então o valor de retorno passa a ser N. print avalia f() e g() e depois os exibe juntos em uma linha, então a linha F vem primeiro, e a linha T N vem depois. A alternativa que dá T T é a resposta para o caso em que você acha que o return do finally é ignorado, e a alternativa em que F vem depois é a resposta para o caso em que você acha que finally é executado depois do return.

KeyboardInterrupt fica diretamente abaixo de BaseException; ele não herda de Exception. issubclass(KeyboardInterrupt, Exception) é False. Ele serve para quando um usuário tenta interromper o programa com Ctrl-C, então a hierarquia (階層) é separada para que ele não seja engolido por acidente por um except Exception escrito de forma ampla. SystemExit fica na mesma posição. Os 3 restantes são todos descendentes de Exception: ZeroDivisionError está sob ArithmeticError, FileNotFoundError está sob OSError e ModuleNotFoundError está sob ImportError, então todos eles podem ser capturados por except Exception.

Tanto IndexError quanto KeyError compartilham a mesma natureza de procurar algo por um índice ou uma chave e não encontrar, então são colocados sob o pai comum LookupError. Escrever except LookupError permite capturar juntos tanto um acesso fora do intervalo em uma lista quanto uma chave inexistente em um dicionário. ArithmeticError é o pai de exceções como ZeroDivisionError, para situações em que o próprio cálculo não pode ser realizado. AttributeError é para quando um atributo não é encontrado, e ReferenceError é para quando o alvo de uma referência fraca deixou de existir; ambos ficam diretamente abaixo de Exception e pertencem a uma linhagem diferente de LookupError.

8 / 0 gera ZeroDivisionError, mas ZeroDivisionError é uma classe filha (子クラス) de ArithmeticError. As cláusulas except são verificadas em ordem, de cima para baixo, e a verificação para na primeira que corresponde, então o except ArithmeticError escrito primeiro a captura, e apenas A é impresso. O except ZeroDivisionError posterior nunca tem vez. Só um except correspondente é executado, então não acontece de A e Z serem impressos. O princípio é colocar primeiro o mais restrito (a classe filha) e depois o mais amplo (a classe pai), e o código desta questão está com essa ordem invertida.

Escrever uma tupla entre parênteses depois de except faz com que ele seja executado se qualquer uma delas corresponder. conv("21") dá int("21") como 21, então retorna 42. conv("abc") pode ser passado como string, mas não pode ser interpretado como número, então resulta em ValueError. conv(None) não é de um tipo que possa ser passado para int(), então resulta em TypeError. A distinção — tipo correto mas valor inadequado dá ValueError, e tipo que nem sequer corresponde dá TypeError — é exatamente a ordem da resposta.

Escrever apenas raise, sem argumento, dentro de um bloco except relança (再送出) a exceção que está sendo tratada no momento, tal como está, para quem chamou. Assim, depois que inner é impresso, LoadError se propaga para fora de load(), e o except Exception externo a captura. LoadError herda de Exception, então except Exception pode capturá-la e a execução não para. type(e).__name__ retorna o nome da classe de exceção que foi realmente lançada, então o que é impresso é LoadError, e não o nome do tipo do lado que captura, Exception. Aparecer apenas inner seria a saída para quando a exceção é engolida ali mesmo, sem ser relançada.

A primeira chamada é um índice 1 de lista, então 2 é retornado. A segunda procura uma chave que não está no dicionário, então KeyError é gerado, mas o que está escrito em except é apenas IndexError. IndexError e KeyError são ambos filhos de LookupError, mas não são pai e filho um do outro, então um except para IndexError não consegue capturar um KeyError. A exceção não capturada se propaga para quem chamou e, como não há ninguém para recebê-la, o programa para. Se quiser capturar as duas, escreva except LookupError ou coloque as duas lado a lado em uma tupla.

assert condição, mensagem gera AssertionError quando a condição é falsa. Quando a condição é verdadeira, nada acontece. O ponto importante é que, quando o programa é iniciado em um modo otimizado (最適化モード) como python3 -O, a instrução assert é removida por inteiro, e nem uma única linha dela é executada. Por isso, assert não deve ser usado com o propósito de validar a entrada do usuário; para esse propósito, você verifica a condição com if e gera ValueError(...). O melhor é lembrar de assert como uma ferramenta para deixar registradas as suposições internas durante o desenvolvimento, mantendo esse papel separado.

Quando você escreve d.speak(), o Python o reinterpreta como Dog.speak(d) antes de chamá-lo. O que vai para a posição do primeiro argumento aqui é a própria instância (インスタンス) que fez a chamada. A grafia self é apenas uma convenção; não é um nome reservado pela linguagem. Como a linguagem só especifica que a posição do primeiro argumento recebe a própria instância, escrever você mesmo Dog.speak(d) também funciona do mesmo jeito. Criar e devolver uma instância é tarefa de __new__ e do mecanismo por trás da chamada de uma classe, e __init__ apenas inicializa uma instância que já foi criada. Para referir-se a uma classe pai, usa-se super().

kind é uma variável de classe (クラス変数) escrita diretamente abaixo de class, e todas as instâncias criadas a partir dessa classe compartilham essa mesma e única variável. Nem a nem b têm kind em seu próprio __dict__, então, ao ler o atributo, os dois sobem até a classe e veem o mesmo valor. Uma atribuição a Dog.kind reescreve esse único valor compartilhado, então wolf passa a ser visível tanto por a quanto por b, que já tinham sido criados. Como o valor não é copiado no momento em que uma instância é criada, as alternativas em que canine permanece não são a resposta.

Atribuir a a.kind não reescreve a variável de classe; cria uma nova entrada chamada kind no dicionário da instância de a. Daí em diante, ler a.kind encontra primeiro essa nova entrada, que faz sombra sobre a variável de classe. b e Dog.kind continuam com o canine original. Por isso, a.__dict__ tem kind ao lado do name colocado por __init__, e ordená-lo dá ['kind', 'name']. A alternativa em que tudo vira husky é a resposta para o caso em que você acha, por engano, que atribuir na instância reescreve a variável de classe (クラス変数), e a alternativa que dá apenas ['name'] é a resposta para o caso em que você acha que nenhuma sombra é criada.

self.items.append(x) não é uma atribuição a self.items; é apenas a chamada de um método no objeto alcançado por meio de self.items. Nem p nem q têm seu próprio items, então o que os dois alcançam é a mesmíssima lista única guardada como variável de classe (クラス変数). Como resultado, tanto o 1 acrescentado via p quanto o 2 acrescentado via q vão para essa mesma lista, e ela aparece como [1, 2], não importa qual dos dois você olhe. Se quiser um recipiente separado para cada instância, faça a atribuição dentro de __init__ escrevendo self.items = []. Assim ela se dividiria em [1] e [2].

O __init__ de Cat chama super().__init__(name), então o pai, Animal, define self.name. Depois disso, self.color recebe black, então os dois atributos ficam definidos. cry é redefinido no filho, então a implementação do pai é sobrescrita (オーバーライド), e é a versão com meow que é chamada. isinstance(c, Animal) é True, já que Cat de fato herda (継承) de Animal. Se você esquecer de escrever super(), name nunca seria definido e ocorreria AttributeError, então não há uma falha silenciosa que daria um resultado None.

A ordem de resolução de métodos (メソッド解決順序) é decidida por uma regra chamada linearização C3 (C3線形化), e não por uma simples busca em profundidade. O pai comum A é colocado depois de todos os filhos que herdam de A, então a ordem fica D, B, C, A, object. Se fosse busca em profundidade, entrando em B e indo direto para A, seria D, B, A, C, object, mas não é isso que acontece, e esse é o ponto que exige cuidado. who() procura a partir do início da MRO e usa o primeiro que encontra, então é B que é retornado. Se você escrever class E(C, B), fica E, C, B, A, object; o que é escrito primeiro tem prioridade.

A linearização C3 (C3線形化) tem duas regras: preservar a ordem em que as classes base são listadas e colocar um pai depois de seus filhos. F(A, B) especifica colocar A antes de B, mas B é filho de A, então o pai A precisa vir depois do filho B. Como essas duas regras não podem ser satisfeitas ao mesmo tempo, conclui-se que não é possível construir uma MRO consistente, e ocorre um TypeError no momento em que a definição da classe é avaliada. A falha acontece no instante em que a instrução class é processada, e não só quando você tenta executar algo. A forma correta é escrever primeiro o filho, como em class F(B, A).

_one, que começa com um único sublinhado, é apenas uma convenção que indica uso interno, e seu nome não muda; ele pode ser lido normalmente de fora. __two, que começa com dois sublinhados, passa pela desfiguração de nomes (名前修飾, name mangling), e seu nome real de atributo é reescrito para _P__two, ou seja, _NomeDaClasse__nome. Por isso, escrever p.__two resulta em AttributeError, mas escrever p._P__two permite lê-lo. O que aparece em __dict__ também é o nome desfigurado, então ordenar dá ['_P__two', '_one']. Apenas nomes que começam com dois sublinhados são desfigurados; _one não está sujeito a isso.

print(v) e str(v) usam __str__, então fica V(1, 2). Quando exibido dentro de um contêiner (コンテナ) como uma lista ou um dicionário, porém, __repr__ é usado para cada elemento, então fica [Vec(x=1, y=2)]. Essa distinção de uso é o ponto-chave desta questão. len(v) é o 2 retornado por __len__, e v + Vec(3, 4) é um novo Vec retornado por __add__; passá-lo para print usa __str__ de novo, então V(4, 6) é exibido. Em uma classe em que __str__ não está definido, __repr__ é usado como substituto, mas o inverso — __str__ ser usado no lugar de __repr__ — nunca acontece.

Como __eq__ está definido, p == q compara o atributo x e dá True, mas p e q são objetos criados separadamente, então p is q continua False. O ponto importante aqui é que uma classe que define __eq__ tem automaticamente seu __hash__ definido como None, então Point.__hash__ is None é True. Um objeto sem hash (ハッシュ) não pode ser usado em um conjunto nem como chave de dicionário, então tentar criar {p, q} resulta em TypeError. Se você também quiser poder colocá-lo em um conjunto, precisa definir seu próprio __hash__ que retorne o mesmo valor para objetos iguais.

math.sqrt retorna um float mesmo quando a raiz é exata, então a raiz quadrada (平方根) de 16 é exibida não como 4, mas como 4.0. math.floor arredonda para baixo na reta numérica, então -1.5 vira -2, e math.ceil arredonda para cima, então -1.5 vira -1. Observe que, com números negativos, int(-1.5), que arredonda em direção a 0, dá -1, o que não coincide com o resultado de floor. Confundir floor e ceil dá a ordem -1 -2, e supor que o tipo de retorno de sqrt é int dá 4.

os.path.splitext separa apenas a extensão (拡張子), mantendo o ponto junto ao lado da extensão, e retorna uma tupla de 2 elementos. Por isso fica ('/tmp/z', '.txt'). O ponto não é descartado, dando 'txt'; isso não acontece. os.path.basename retorna o nome no final do caminho, então é 'z.txt'. Quem retorna o lado do diretório, '/tmp', é os.path.dirname, e quando você quer uma tupla com os dois juntos, usa os.path.split. Ajuda lembrar a distinção de que splitext divide pela extensão, e não por um separador de diretórios.

re.match só verifica a correspondência a partir do início da string, então, como o início de 'abc' é 'a', ele não corresponde a 'b' e retorna None. re.search procura inclusive no meio, então corresponde a 'b', e .group() extrai a string correspondida, b. Essa diferença é o ponto sobre re mais cobrado. re.findall retorna uma lista reunindo todas as partes que corresponderam ao padrão (パターン) e, como \d+ significa dígitos consecutivos, fica ['1', '22', '333']. Os caracteres separadores não são incluídos. Se não houver correspondência, retorna uma lista vazia.

Imprimir diretamente um objeto date o exibe no formato ISO, com hifens, como 2026-08-22. strftime é o que se usa para mudar o formato (書式), e passar a ele '%Y/%m/%d' retorna a string separada por barras 2026/08/22. Somar timedelta(days=10) a uma data retorna não um timedelta, mas um novo date que aponta para 10 dias depois, então imprimi-lo dá 2026-09-01. O cálculo que atravessa a virada do mês é feito pelo lado do datetime, então não vira uma data inexistente como 2026-08-32, que você obteria simplesmente somando 10 ao número do dia. Se você achar que print(d) usa o mesmo formato de strftime, obtém saídas separadas por barras lado a lado, mas a exibição padrão usa hifens. Quando você subtrai uma data de outra, o que é retornado não é uma data, mas um timedelta, e sua exibição tem uma forma como 10 days, 0:00:00.

'abracadabra' contém a 5 vezes, b e r 2 vezes cada, e c e d uma vez cada. most_common(2) retorna apenas os 2 primeiros em contagem, como uma lista de tuplas de elemento e contagem, então é [('a', 5), ('b', 2)]. Entre b e r, que estão empatados na contagem, vem primeiro o que apareceu primeiro, então b é o escolhido. Counter é um tipo de dicionário (辞書), mas procurar um elemento que não está presente não gera KeyError; retorna 0, o que é uma diferença em relação a um dicionário comum. Ele foi concebido assim para que você não precise verificar a existência antes de fazer a contagem.

Um tipo criado por namedtuple assume a forma Pt(x=1, y=2), com o nome do tipo e os nomes dos campos, quando exibido. O valor pode ser lido tanto pelo nome quanto pelo índice, então p.x e p[0] são ambos 1. E, como namedtuple é um subtipo de tuple, isinstance(p, tuple) é True. Ou seja, é um tipo de tupla (タプル), e seus elementos não podem ser reescritos depois. Se você quiser guardar um valor que possa ser alterado, use _replace, que cria uma nova instância com um valor trocado, ou defina uma classe comum.

O que map retorna não é uma lista, mas um iterador (イテレータ); cada chamada a next() entrega o valor seguinte e, uma vez esgotado, acabou. Como a primeira chamada de list() tira todos os 3 valores, na segunda chamada de list() não sobra nada, e ela vira uma lista vazia. Não vira erro nem None; simplesmente fica vazia em silêncio, o que facilita não perceber. map(str, ...) transforma cada elemento em string, então o primeiro resultado não são números, mas ['1', '2', '3']. O mesmo acontece com filter, zip, enumerate e geradores, então, se você pretende percorrer mais de uma vez, fixe-o em uma lista com list() logo depois de recebê-lo.

Passar None como primeiro argumento de filter filtra pelo valor de verdade (真偽) do próprio elemento. 0, a string vazia e None são todos avaliados como falsos, então são descartados, e o que resta é [1, 2, 'a']. Não é o caso de os descartados permanecerem. all é especificado para retornar True desde que não haja nem um elemento falso, então, para uma lista vazia, sem nenhum elemento, é True. any retorna True se houver pelo menos um elemento verdadeiro, então, para uma vazia, é False. O ponto de essas duas darem respostas opostas quando recebem uma sequência vazia é cobrado com frequência.

Mesmo chamar uma função que contém yield não executa uma única linha do seu corpo. O que volta é apenas um objeto gerador (ジェネレータオブジェクト), então created é impresso primeiro. Só com o primeiro next(g) ela finalmente começa a andar desde o início, imprimindo start, e então para em yield 1 e retorna 1. O next(g) seguinte retoma de onde parou, imprime mid e então para em yield 2, retornando 2. Essa execução preguiçosa (遅延実行) é a diferença decisiva em relação a uma função comum, e chamar next(g) mais uma vez encerra a função, resultando em StopIteration.

== é o operador que pergunta se os valores são iguais, então, como a e b têm o mesmo conteúdo, dá True. is é o operador que pergunta se é o mesmo objeto (オブジェクト) e, como a e b são duas listas criadas separadamente, dá False. Já c = a não cria uma nova lista; apenas dá outro nome ao mesmo objeto, então a is c é True. Ou seja, alterar a lista por meio de c também fica visível por meio de a. None é um objeto especial que existe uma única vez, então escrever x is None é a forma idiomática, mas, quando quiser comparar valores, use sempre ==.