match coisa:
    case "A": 
        print("Muito bom")
    case "B":
        print("Tá ok")
    case "C":
        print("Não gostei")
    case "D":
        print("Péssimo")

Eu diria que as semelhanças param por aqui. Em C você permite o compilador otimizar a busca usando table lookup para as posições de memória de cada case e ele executa até achar um break;, mesmo que isso signifique entrar no case seguinte.

Em Python, o match executa cada case sequencialmente e verifica se ele bate com o objeto de entrada e executa somente aquele bloco. O problemas é que ele usa uma sintaxe que parece Python, mas não é válida em outros locais para executar esse match.

match coisa:
    case x, y:
        print(f"coisa {x} e coisa {y}")
    case x:
        print(f"somente uma coisa {x}")

Acima foram introduzidas variáveis x e y nos cases do match. Elas não existem fora dos blocos em que executa. O interpretador desconstrói case x, y em algo como:

if isinstance(coisa, (list, tuple)) and len(coisa) == 2:
    x, y = coisa.

Se essa condição é válida, ele faz um tuple-unpacking e cria as variáveis x e y dentro daquele bloco.

Como se fosse uma regex para estruturas de dados.

coisa = '(a, b)'
re.match(r'\((\w+),\s*(\w+)\)', coisa).groups() == ('a', 'b')

Se você começar a ver todas as regras de casamento de expressões vai ver que complicaram bastante algo que antes você fazia com if-elif-else e acho bem difícil que isso seja utilizado pra algo além de verificar elementos numa lista ou no máximo chaves num dicionário.

Dentro das expressões, você tem valores literais, que são validados por igualdade exceto True, False e None que são por identidade e também nomes. Então se você misturar os dois, ele valida uma parte por igualdade e assinala valores aos nomes. Por fim existe um nome coringa que é o underscore (_) onde ele não assinala valor e este pode ser repetido na regra para delimitar tamanho das estruturas, sem se importar com o conteúdo. Também é utilizado para substituir o caso default existente no switch do C, sendo que você pode na verdade escolher qualquer nome.

match coisa:
    case "selecionar", cor, _:
        print("Lista de 3 elementos: o último não interessa") 
    case {"ação": "selecionar", "cor": cor,  "outro": _}:
        print("Basicamente o mesmo, mas dentro de um dicionário.")
        print("O 'outro' não me importa, mas precisa existir")
    case _:
        print("Todo o resto")

Agora onde a cobra começa a fumar.

Em C, para ter múltiplas opções executando um mesmo códido, você iria escrever:

switch (valores) {
    case 1:
    case 2:
        printf("coisa 1 ou 2");
        break;
    case 3:
        printf("coisa 3");
        break;
}

Em Python você usa uma barra vertical como case 1 | 2:.
Isso é inconsistente com o or lógico que é escrito por extenso e confunde on o bitwise or que usa esse mesmo operador tanto em Python como em C.

A partir daí, você pode fazer uma lambança de misturar estruturas, com “or” dentro e fora, com e sem parêntesis, além de capturar qualquer elemento específico dentro de qualquer parte da estrutura. Você pode repetir nomes de variáveis caso elas estejam em lados diferentes de um “or”. Também é possível usar asteriscos para capturar sub listas, também conhecido como starred assigned em Python normal.

match coisa:
    case [1, *x] | [*x, 2]:
        print(x)

Este exemplo acima gera as seguintes instruções para a máquina virtual do Python (VM).

              2 LOAD_FAST                   0 (coisa)
  7           4 COPY                              1
              6 MATCH_SEQUENCE
  8 POP_JUMP_FORWARD_IF_FALSE    13 (to 36)
             10 GET_LEN
             12 LOAD_CONST               1 (1)
             14 COMPARE_OP               5 (>=)
             20 POP_JUMP_FORWARD_IF_FALSE     7 (to 36)
             22 UNPACK_EX                1
             24 LOAD_CONST               1 (1)
             26 COMPARE_OP               2 (==)
             32 POP_JUMP_FORWARD_IF_FALSE     1 (to 36)
             34 JUMP_FORWARD            23 (to 82)
        >>   36 POP_TOP
             38 COPY                     1
             40 MATCH_SEQUENCE
             42 POP_JUMP_FORWARD_IF_FALSE    15 (to 74)
             44 GET_LEN
             46 LOAD_CONST               1 (1)
             48 COMPARE_OP               5 (>=)
             54 POP_JUMP_FORWARD_IF_FALSE     9 (to 74)
             56 EXTENDED_ARG             1
             58 UNPACK_EX              256
             60 SWAP                     2
             62 LOAD_CONST               2 (2)
             64 COMPARE_OP               2 (==)
             70 POP_JUMP_FORWARD_IF_FALSE     1 (to 74)
72 JUMP_FORWARD             4 (to 82)
        >>   74 POP_TOP
             76 POP_TOP
             78 LOAD_CONST               0 (None)
             80 RETURN_VALUE
        >>   82 STORE_FAST               1 (x)
             84 POP_TOP

As instruções de 6 até 26 (coluna da esquerda) calculam a primeira metade da expressão do case, onde ele verifica que o objeto é uma sequência (list, tuple etc), pega o tamanho e vê se é maior ou igual a 1, faz um unpack da lista na pilha do interpretador retirando o primeiro elemento do resto, compara esse elemento com o valor 1 e salva o resto da lista na variável x (instrução 82).

A segunda parte são as instruções de 40 a 72, onde faz a mesmas verificações de sequência e seu tamanho, faz um unpack dessa vez pegando o último elemento (0x0100 == 256 significa 1 elemento no final, oposto de 0x0001 que significa 1 elemento no início) da lista e comparando este com o número 2. Novamente salva o resto na variável x (na mesma instrução 82).

Podemos ver que o interpretador trata cada parte do “or” como sua própria expressão e a única garantia é que ele obriga todas as partes a capturarem os mesmos nomes de variável.

Ao meu ver isso tudo são modificações talvez desnecessárias da linguagem para criar algo que se parece com Python (familiaridade), mas funciona de forma diferente o suficiente para encucar mesmo os macacos velhos, ou talvez só esses mesmo. Isso lembra bastante o modus operandi do Ruby, onde a linguagem dá acesso a tantas transformações na execução que você pode escrever DSLs que nada se parecem com Ruby, mas as vezes presas a problemas inerentes da linguagem.

Podemos lembrar que essa não é a primeira vez que Python cria artefatos que imitam parte da sintaxe.

1. Ellipsis. Em Python 2 só era possível utilizar as reticências dentro de um índice de lista/array, como minha_array[1,...] simbolizando que qualquer coisa, como uma dimensão extra, deve ser retornada além do índice 1. Comum em NumPy, por exemplo. No Python 3, foi criado um objeto "..." que traduz para um singleton a fim de acabar com essas inconsistências e também permitir você utilizar em outros locais com ideias similares.
2. Quando foi criada a sintaxe format de interpolação de strings, no Python 2.6 e 3.0, você era obrigado a enumerar as variáveis ou passar por nome, também havia limitação de indexar variáveis dentro da formatação onde qualquer texto era tratado como string, mas números eram convertidos pra inteiro. "text: {0[foo]}".format({"foo": "bar"})
   Isso foi posteriormente removido nas f-strings que, à primeira vista, parecem ser a mesma coisa, mas estas quebram a string em substrings e executam o texto dentro dos colchetes como código Python antes de converter para string. Dicionários também não era possíveis de se definir pelo reuso dos colchetes.
3. Ainda na formatação de strings, as f-strings mudam a sintaxe no caso acima, mas ainda mantém a sub sintaxe de formatação, tipo `f'{x:.2f}” que mostra um float só até 2 casas decimais, além de permitir a formatação obscura de f'{x!r} onde “!r” converte a string para sua representação, que contém aspas. Isso foi criado na era anterior pela limitação de que você podia colocar variáveis na string, mas não podia fazer operações. Com essa nova possibilidade, você não precisa necessariamente mais disso, apesar de ser prático.
4. As f-strings, agora processadas pelo interpretador e não mais analisadas em tempo de execução, em teoria seriam uma cópia fiel do Python, mas por problemas de gramática, elas ainda diferem do original por não permitir a contra-barra \ para escapar caracteres dentro dos blocos de código. Dicionários podem ser colocados dentro dos blocos de variáveis, mas existe ambiguidade (exemplo: f'{{3:{1:2}}}' == '{3: 1}') — De qualquer forma, vimos que existiu convergência dela nas suas várias iterações.
5. Um outro momento em que Python criou sintaxe específica para um sub conjunto da linguagem, tentando fingir que era a mesma foi dentro dos argumentos de uma função, na hora da definição. Durante certo tempo havia limitação entre o que você podia escrever com asterisco para fazer star unpacking e posição dos argumentos. Mesmo com a capacidade de ter argumentos keyword-only, os problemas trazidos do Python 2 ainda enrijeciam a interface. Mesmo depois da remoção de tuple unpacking dentro dos argumentos. Exemplo: def f(x, /, y, *args, z=1, w=2, k, **kw): ...

Por que eu trouxe esses exemplos especificamente? Na sintaxe de casamento do match, estamos novamente convertendo o que parece ser uma pseudo linguagem para código da mesma VM do Python.

1. Por quê o underscore precisa existir se já temos a Ellipsis (...) ou o próprio asterisco sozinho? Menos teclas a clicar?
2. Por quê o “or” usa apenas uma barra vertical que vai contra a política de escrever inglês do Python? Utilizar múltiplos cases, como em C, não seria viável já que você pode colocá-lo dentro de partes da estrutura.
3. Mais uma vez existe mistura entre sintaxe que define estruturas e que separa partes da sub-sintaxe.
4. Existe real necessidade de casar certas estruturas com o match? Como por exemplo objetos de classes que não sejam listas e dicionários? Sim tem uma forma de fazer isso no match:

No caso de outros objetos, você usa um nome com parêntesis e o interpretador valida se a coisa é objeto de uma classe com aquele nome e verifica se “os argumentos” daquela classe batem com valores de atributos do objeto!

match coisa:
    case Bagulho(x=1, y=2):
        print(f'{coisa.x} = 1 e {coisa.y} = 2')

Brutal… Será que compensa aprender uma nova sintaxe só para fazer `coisa.x == 1 and coisa.y == 2` ?

Vocês querem mais, crianças?

Sim, tem mais. Após cada expressão no case você pode inserir um if alguma coisa que nada mais é que uma expressão normal em Python que valida algo mais que não pode ser expresso apenas pela estrutura. Na documentação, eles chamas essa funcionalidade de “flag” para desabilitar um match, mas ao meu ver isso basicamente transforma o case num if-elif-else, que o pessoal do Python dizia ser terminantemente contra, ao implementar a funcionalidade.

match coisa:
    case x, y if x > y:
        ...
    case x, _ if x < 20:
        ...
    case x if len(x) == 100:
        # Seria deselegante escrever (_, _, _, ...) com 100 itens
    case _, if flag:
        ...

Não vou me repetir aqui, mas outra vez ficou confuso. Pelo menos o if não foi tão massacrado, já que ele existe também nessa posição dentro das list comprehensions.

Espero que um dia o match no Python amadureça para ficar mais conciso com o resto da linguagem e talvez incorporar o if de forma mais elegante, possivelmente como o Kotlin faz na sua expressão when. Até lá, acredito que eu o evite a não ser para usar como um switch.

Por exemplo, em um vídeo de 30 minutos, eu quero os trechos: 0 a 10 minutos, 11 a 16 minutos e 18 minutos até o fim. Primeiro, é preciso criar os 3 segmentos, aqui chamados de “part%02d.mp4”.

ffmpeg -i video.mp4 -t 00:10:00 -c copy part01.mp4
ffmpeg -ss 00:11:00 -i video.mp4 -t 00:05:00 -c copy part02.mp4
ffmpeg -ss 00:18:00 -i video.mp4 -c copy part03.mp4

Comandos utilizados:
-i ARQUIVO_DE_INPUT
-ss TEMPO_DE_SEEK
-t DURAÇÃO_DO_SEGMENTO

O uso de -c copy faz com que não seja realizada transcodificação do vídeo, mas apenas cópia de arquivo. Entretanto, isso faz com que os cortes não sejam precisos e determinados pelos keyframes do vídeo, ficando possivelmente maiores que o pedido. Se for preciso fazer cortes com precisão, é preciso recodificar o segmento (e mover o comando “-ss” para depois do arquivo de input).

Para juntar os pedaços, crie um arquivo de texto, por exemplo “lista.txt” com o seguinte conteúdo:

file 'part01.mp4'
file 'part02.mp4'
file 'part03.mp4'


Agora é só executar:

ffmpeg -f concat -i lista.txt -c copy video_final.mp4

Funciona com qualquer formato/codec suportado pelo FFmpeg. Se o seu programa não suportar algum dos comandos, provavelmente é uma versão antiga. Utilize 1.0 ou superior.

g = f ** 2 + 1   #função que eleva ao quadrado e soma 1
g(10) == 101

O código abaixo é uma versão (muito) simplificada do módulo que coloquei no GitHub, mas serve como exemplo de uso de metaclasses em Python (neste caso, Python 3):

import operator

class MetaFuncBuilder(type):
    def __init__(self, *args, **kw):
        super().__init__(*args, **kw)
        attr = '__{0}{1}__'

        for op in (x for x in dir(operator) if not x.startswith('__')):
            oper = getattr(operator, op)
            op = op.rstrip('_') #special case for keywords: and_, or_

            def func(self, *n, oper=oper):
                return type(self)(lambda x: oper(self.func(x), *n),
                                  self.op + [(oper.__name__, n[0])
                                             if n else oper.__name__])
            def rfunc(self, n, *, oper=oper):
                return type(self)(lambda x: oper(n, self.func(x)),
                                  self.op + [(n, oper.__name__)])
           
            setattr(self, attr.format('', op), func)
            setattr(self, attr.format('r', op), rfunc)

class FuncBuilder(metaclass=MetaFuncBuilder):
    def __init__(self, func=None, op=None):
        self.op = op if op else []
        self.func = func if func else lambda x: x

    def __repr__(self):
        return '<var %s>' % self.op

    def __call__(self, *args):
        if not args:
            return self.func() #unary operators
        required, *args = args
        out = self.func(required)
        return out(*args) if args else out

f = FuncBuilder()

Em duas situações é comum o uso de metaclasses em Python: para que um certa classe tenha propriedades novas ou para automatizar algum mecanismo nas classes. Neste caso, usei para automatizar a criação de métodos para cada operador em Python, com ajuda do módulo operator.

Em Python, os operadores matemáticos binários existem nas formas __op__, __rop__ e __iop__, onde op é o nome, r significa que o objeto é o segundo operador e i significa in-place. Outros operadores existem em apenas uma forma.
Assim, o código pega os operadores e cria as três formas de cada um (os que existem em apenas uma forma ficam com 2 formas extras que não causam problema algum, já que não são nunca chamadas) e todos os operadores, ao invés de executar a operação designada, apenas criam uma novo objeto-função que pode ser chamado ou ter novas funções adicionadas.

O módulo no GitHub tem uma centena de outras funcionalidades para gerar essas funções, mas ele sofre de um problema que pode ser bem sério: Chamadas de função em Python são caras!

Basicamente, cada objeto do tipo FuncBuilder guarda a operação que tem que executar e o próximo da lista. Isso gera um monte de chamadas de função em cima dos operadores, o que pode deixar o código muito mais lento.

Minha próxima alteração pra esse código seria juntar todas as operações numa só chamada de função, o que não vai permitir extrair uma função de dentro de outra (como é possível agora por meio de closures), mas vai reduzir o custo para apenas uma chamada de função, como seria natural. Isso não vai ser tão simples por causa dessa estrutura recursiva da classe, mas quando tiver tempo, eu faço.

Tem um site de tirinhas chamado Vida de Programador que posta situações corriqueiras (as vezes) de forma engraçada.

Na tirinha de hoje, ele mostrava o código de um programador iniciante:

bool isValid;
...
switch(isValid) {
case true: ...
case false: ...
}

Claro que não faz sentido tanta verborragia pra algo tão simples como uma variável booleana. No entanto, as pessoas se esquecem que os compiladores atuais são muito bons e não vão deixar seu código lento só porque você preferiu que ele fosse “mais legível”.

Uma excelente ferramenta online chamada GCC Explorer mostra a saída assembly do seu compilador preferido com diversos níveis de otimização.

Independente do nível de otimização, o código gerado para o trecho acima será extamente o mesmo que para “if...else” ou o operador ternário “? :“.

int testFunction(bool x) {
  switch (x) {
    case true:
        return 10;
        break;
    case false:
        return 12;
  }
}

int testFunction2(bool x) {
  return x? 10 : 12;
}

E o Assembly gerado (com -O2) será:

testFunction(bool):
	cmpb	$1, %dil
	sbbl	%eax, %eax
	andl	$2, %eax
	addl	$10, %eax
	ret
testFunction2(bool):
	cmpb	$1, %dil
	sbbl	%eax, %eax
	andl	$2, %eax
	addl	$10, %eax
	ret

Se você olhar, não há nenhum jump no assembly gerado. Ele compara a variável com o número 1, subtrai o registro de retorno dele mesmo com borrow, faz um AND com o 2 e depois soma 10. Você não ia pensar que retornar 12 ou 10 significa colocar 2 ou 0 numa variável e depois somar 10, mas o compilador sabe que lógica AND e OR para números inteiros é muito mais rápida que jumps e faz tudo sem que você se preocupe. Esse código seria semelhante a:

int testFunction3(bool x) {
  return 10 + (2 & -(1-x));
}

Mas o GCC consegue diminuir ainda mais o assembly!

testFunction3(bool):
	leal	3(%rdi), %eax
	andl	$2, %eax
	addl	$10, %eax
	ret

Só que ninguém vai querer ler um código tão feio assim que apenas poupa 1 nanossegundo.

Sem dar razão à pessoa que fez um switch para um bool, se o código não é o gargalo do seu programa, não há motivo para mudar. Como escreveu Donald Knuth: otimização prematura é a raiz de todo o mal.

O Blender ficou muito mais prático com essa interface, mas é preciso se acostumar com os novos comandos e a posição dos botões e menus. No site Blender Guru tem uma cola dos comandos que é bastante completa.

Sobre o Cycles, ele é um Ray tracer de verdade e produz imagens muito mais reais que o renderizador interno (Internal), além de trazer a possibilidade de editar a cena e produzir imagens ao mesmo tempo.

O modo de funcionamento do Cycles é bem diferente do Internal pois ele não divide a imagens em quadrados e renderiza cada um numa thread. Ele gera a imagem inteira de uma vez e vai aprimorando o resultado a cada iteração, o que é um pouco estranho já que a renderização só acaba após o número de passos que for definido.

Em alguns testes que fiz, de 10 a 50 passos, já é razoável para ver o que está acontecendo na imagem (bom para editar em tempo real), mas para uma boa qualidade de imagem são precisos de 1000 a 4000 passos, algo que pode demorar horas, mesmo para uma cena razoavelmente simples (no meu Core i5).

Pode parecer que o Cycles é uma faca de dois gumes, já que permite visualizar o resultado praticamente em tempo real, mas demora pra produzir uma imagem final com pouca granularidade. Na verdade, o Cycles traz ainda mais um diferencial: a possibilidade de renderizar a imagem via GPU com CUDA/OpenCL, o que pode ter um ganho alto de desempenho, além de deixar a CPU livre para outras tarefas. Pena que minha placa de vídeo é bem ruim (a Intel não aprende mesmo…) e não serve para o propósito.

Abaixo um vídeo do Cycles em ação:

De cara dá pra perceber que a qualidade de imagem é muito maior que se fosse renderizado com o Internal, principalmente quando se pensa em iluminação. Antigamente, você precisaria colocar umas 3 lâmpadas, no mínimo, e fazer centenas de ajustes para conseguir um efeito legal. Agora você pode adicionar apenas um objeto com o material “Emission” e você tem uma fonte de luz que reflete nas superfícies e produz um efeito muito bom.

Outra coisa que sempre foi praticamente impossível de fazer direito no Blender é vidro ou qualquer coisa transparente. No Cycles, ao escolher o material Glass, você tem de cara um vidro de alta qualidade sem precisar fazer qualquer ajuste. Para outros materiais, basta ajustar o índice de refração (IOR) para o valor real do mesmo.

Em cinco minutos coloquei 3 planos, um cubo e um chimpanzé (Suzanne + subsurf) numa cena iluminada por outros dois planos e modifiquei os materiais. Depois de meia hora renderizando em torno de 1000 passos, fiquei com uma imagem que demoraria horas para ajustar a iluminação e ter um efeito parecido.

Não é nenhuma obra de arte, mas mostra como é fácil ter efeitos interessantes sem perder muito tempo.

A única diferença entre o uso do Blender Internal e o Cycles é a janela de edição de materiais que, por enquanto, é um pouco pobre em usabilidade e obriga o uso de Composite Nodes para coisas não básicas. De qualquer forma, não deixa de ser algo bom pois o uso do Node editor não é complicado e acaba sendo prático.

Uma coisa que senti falta é a pré-visualização do material, mas com a renderização em tempo quase real, acaba não sendo tão ruim.

Como o Cycles ainda não está oficialmente incorporado ao Blender, é preciso pegar um build que tenha sido feito recentemente no SVN do projeto para poder usar. No site GraphicAll.org tem vários e só precisa escolher o sistema operacional e arquitetura.

De acordo com o roadmap do Blender, o Cycles deve chegar no Blender 2.61 em dezembro.

A fração de segundo depois que você aperta Enter e percebe seu erro, mas é tarde demais, você acabou de excluir um arquivo ou diretório valioso e não existia nenhum backup. Ou talvez você tinha um backup, mas é de um mês atrás…
E em estado de choque que você vê num flash o último mês passar diante de seus olhos e percebe a dor que vai dar para fazer tudo de novo…
Carlo Wood

Recuperar dados de partições Ext3 e 4 é bastante complicado, como explicado com muitos detalhes neste link.

A primeira coisa a fazer é desmontar a partição afetada ou, se não for possível, desligar o computador e usar um LiveCD de alguma distribuição Linux (usei Ubuntu num pendrive) ou colocar o HD dentro de outra máquina.

Para resolver o problema, eu testei sem sucesso duas ferramentas (foremost e scalpel) que fazem análise sequencial dos blocos do HD procurando por padrões conhecidos, algo que demorou uma eternidade para verificar toda a partição de 1TB que eu tinha e “recuperou” centenas de arquivos corrompidos com nomes do tipo “100201234.jpg” e nada do que eu queria.

Talvez o fato da minha partição ser LVM e a real partição Ext4 estivesse dentro do volume lógico os programas não funcionaram, mas de qualquer forma existe uma solução melhor.

Uma ferramenta chamada Extundelete foi quem salvou meu dia. Ela acessa o journal do sistema de arquivos e consegue achar novamente os arquivos com os nomes originais e, no meu caso, até manteve a estrutura de diretórios de onde estava o arquivo.

Pra usar, instale o “Extundelete” pelo gerenciador de pacotes da distribuição usada (para Ubuntu):
# apt-get install extundelete

ou pegue o código fonte do site e compile com
# ./configure
# make
# make install

Para executar, é preciso passar a partição a ser usada para que o programa monte em modo read only (se for LVM, como no meu caso, vai ser necessário seguir mais alguns passos).
# extundelete /dev/nome_da_particao --restore-all

Em menos de um minuto, o comando acima restaurou centenas de arquivos, incluindo o que eu queria.

Pode acontecer de existirem vários outros roteadores de vizinhos usando o mesmo canal e possivelmente com um sinal mais forte (aquele povo que compra antenas enormes na Uruguaiana ou Santa Ifigênia) estarem fazendo a sua placa wireless perder muitos pacotes.

Todo roteador Wi-Fi vem com uma página de configuração que permite escolher o canal da faixa de 2.4GHz em que vai operar.
Caso não se lembre como acessar ou se não foi você quem instalou, provavelmente olhando qual o gateway da sua máquina você acha o IP do roteador (algo como 192.168.0.1).

Na hora de escolher o canal ideal para sua conexão, é preciso saber que parte da banda os roteadores mais próximos estão localizados e, para isso, existe um excelente aplicativo gratuito chamado InSSIDer que fornece informações bem detalhadas.

Em uma das abas do programa, ele mostra os canais das redes ao alcance, assim como suas intensidades. Ele também mostra a intensidade ao longo do tempo além de outras informações como fabricante, velocidade da rede, largura do canal etc.

Assim, é fácil escolher o canal do seu Wi-Fi apenas verificando qual está menos utilizado (geralmente as extremidades).

Outra coisa é, se você tem um Wi-Fi 802.11n de 300mpbs (bastante comum nos roteadores de 2011) ele pode ocupar o dobro da banda no espectro por utilizar 2 canais, o que melhora a qualidade geral da sua internet, mas causa mais interferência na dos outros :).

Esse é um programa que vale a pena ter instalado.

Portar pequenos programas de uma versão para outra pode ser bastante simples (como no Txt2Tags que precisei de umas 2 ou 3hs para fazer funcionar) quando já se conhece os possíveis problemas e suas soluções, mas nem tudo está bem documentado.

Claro que tudo isso seria muito mais difícil se não houvesse script chamado 2to3.py que vem junto com as versões mais novas do interpretador para automatizar o processo. O problema que existem coisas que ele é incapaz de traduzir ou que precisam de mudanças mais bruscas no código para que funcionem.

Por algum motivo, o site “Dive into Python 3” que tinha uma versão online do livro homônimo foi removido do ar e perdi a melhor referência para o tópico que existia, ** Encontrei um novo mirror do Dive into Python 3 **

Também existem outros bons textos por ai.

Algumas das mudanças mais importantes na nova versão são os iteradores usados em lugares que antes retornavam listas, o uso de unicode por padrão (que na minha opinião já vale por todo o trabalho de portar código) e a troca de algumas palavras-chaves (statements) por funções e vice-versa.

Sobre essa última mudança, as palavras-chave tem o poder de mudar o local em que se encontram enquanto outros nomes podem significar qualquer coisa que o programador queira e só podem ser verificados em tempo de execução, não podendo transformar o ambiente.

Por exemplo, o comando yield faz com que o a função que o contenha seja transformada num gerador mesmo que ele nunca seja executado ou tenha bytecode para isso!

def gerador():
    if 0:
        yield

Neste código acima, o interpretador vai ver que o if nunca será executado e não vai gerar bytecode para nada dentro dele (no caso o yield), mas a função não vai retornar o implícito None quando for chamada. Ela vai retornar um gerador vazio que pode ser usado num loop for.

Usando o módulo dis para desmontar bytecode vemos que a função só retorna None, mas ela vai ter um flag para mostrar sua utilidade:

>>> dis.dis(gerador)
  2           0 LOAD_CONST               0 (None)
              3 RETURN_VALUE

Ainda sobre isso, True, False e None agora são palavras reservadas e que não podem ser modificadas, fazendo com que, se o exemplo acima fosse feito com False ao invés de 0, ele geraria bytecode no Python 2, mas não no Python 3!

No sentido contrário, as palavras-chave print e exec do Python 2 agora são funções e não podem mais alterar seu ambiente.

No caso do print, não tem problema algum e a sintaxe ficou bem melhor, mas o exec (que normalmente seu uso não é uma boa prática de programação) pode ter um comportamento bem diferente nas duas versões do interpretador.

Essa informação não vai ser encontrada na documentação do Python (apenas alguns avisos que não explicam bem a situação) e geralmente a pessoa vai procurar saber disso quando bater de cara com esse problema e nada funcionar.

Olhe o código abaixo (Não tome como exemplo de boa programação):

a = 1
def f():
    exec("a = 2")
    print(a)

f()
print(a)

No Python 2, a função vai imprimir “2” e o outro print vai imprimir “1”, como esperado. No Python 3, o número “1” vai ser impresso nos dois casos.

O que aconteceu?

O meu amigo dis mostra como a variável “a” é chamada no bytecode para impressão dentro da função:

Python 2:

3            8 LOAD_NAME                0 (a)

Python 3:

3           13 LOAD_GLOBAL              2 (a)

Como o Python 3 não consegue ver nenhum a dentro da função, ele assume que é uma palavra definida globalmente e vai embora. No Python 2, é percebida a existência da palavra exec e transforma a busca por um nome sendo primeiro no namespace local e, se não encontrar, no namespace global.

O que, por um lado traz o resultado “desejado”, também faz todos os acessos a funções e variáveis serem mais lento.

Soluções:
1 – Não usar exec.

Praticamente sempre é possível fazer uma solução sem exec que seja simples, mas se for necessário, é preciso tomar cuidado com essa mudança ou passar um segundo parâmetro para a função dizendo em que namespace você quer se o resultado seja avaliado e usar a informação nele.

Normalmente, ninguém usa exec para situações como a que eu mostrei, mas para gerar conteúdo (funções, classes, subclasses, etc) em tempo de execução e muitas vezes existem ferramentas melhores, como as metaclasses e os decoradores.

[Atualizado!] – Veja as novas funcionalidades no fim

Não sei se alguém já fez, mas criei um wrapper para essas funções em python, para os que já tem o ícone do Python no desktop e não querem abrir um terminal :).

Disponível em http://dl.dropbox.com/u/6016495/zz.py. Funciona tanto em Python 2 como em Python 3.

Exemplos:

>>> import zz
>>> int(zz.calcula('19+23'))
42
>>> zz.senha()
'k23Civ'
>>> zz.ramones()
'Come back baby, come back'
>>> zz.dolar
09/05/2011 compra   venda   hora
Comercial   1,618   1,620   17:01   +0,18
Paralelo    1,700   1,820   20/2/2011   0,00
Turismo     1,560   1,730   16:16   +0,58

>>> print(zz.loteria('megasena'))
megasena:
   08 - 11 - 14 - 30 - 36 - 38 
   Concurso 1281 (07/05/2011)
   Acumulado em R$ 2.000.000,00 para 11/05/2011

>>> zz.cpf('11111111111')
'CPF válido'
>>> zz.converte('cf', 32)
'32 C = 89.60 F'

[Novo!]
Agora também funciona com Pipes, podendo encadear funções ZZ e usar STDIN!
Mais exemplos:

>>> '1+2+3+4' | zz.calcula
'10'
>>> print('a\nb\nc\nd\na\nb\nc' | zz.uniq)
a
b
c
d
>>> 'oi, beleza?, oi, e ai, oi io, oi' | zz.contapalavra('oi', pipe=True)
'4'

Note que, se quiser ter uma chamada de função junto com o pipe, tem que adicionar o argumento “pipe=True”, senão ele calcula primeiro a resposta e tenta fazer a operação ‘or’ entre as strings. Podia ser esse segundo o comportamento padrão, mas teria que usar sempre um pipe pra pegar o valor final, que não é minha intenção.

A ideia de usar o operador ‘or’ pra fazer ligação entre chamadas de funções eu peguei desse site: http://dev-tricks.net/pipe-infix-syntax-for-python

Se quiser usar, pode colocar diretamente na pasta de módulos do Python, como por exemplo (no Linux):
/usr/local/lib/pythonX.Y/dist-packages

Bônus:
E, pra quem quiser, apresento o modo mais estranho de calcular 2+2+2+2:

>>> int((zz.calcula('2+2')[:-1]+'+2' | zz.calcula(pipe=True))[:-1] + '+2' | zz.calcula)
8

Após baixar e instalar, você pode começar a programar interfaces no método convencional ou usar o QtDesigner (ferramenta do Qt) para fazer isso.

Por exemplo, você pode fazer assim:

Abra o QtDesigner e crie um novo projeto. Pode ser Widget ou MainWindow, faz pouca diferença no arquivo gerado.

Coloque seus botões, labels, caixas, etc:

Junte os sinais que não precisam de código. Aqui eu coloquei a caixa e o slider para um atualizar o valor do outro e o checkbox para desativar ou ativar o frame contendo a caixa e o slider.

Agora, você vai salvar um arquivo no formato .ui, que é um XML que vai ser usado para gerar o nosso programa.

Dentro da pasta de instalação do PyQt, que fica dentro do diretório do Python, existe uma ferramenta chamada pyuic4, que faz a conversão. No Linux, você pode rodar o programa diretamente, mas no Windows é uma boa criar um arquivo .bat contendo o comando que vai ser usado para converter o arquivo XML em código Python.

@”C:\Python32\python” “C:\Python32\Lib\site-packages\PyQt4\uic\pyuic.py” controle.ui > form.py

Verifique a pasta de instalação e escolha o nome do arquivo que você salvou e salve isso num arquivo com extensão .bat.
Agora é só dar dois cliques que deve surgir um arquivo chamado form.py, que contem uma classe para modificar uma janela que você tenha criado.

Agora você tem que criar um outro arquivo Python para ser seu programa a ser executado e criar alguns objetos. Existem bons tutoriais de PyQt4 pela internet, então não vou ficar detalhando muito.

Basicamente, você tem que criar um QApplication, uma janela (QWidget ou QMainWindow) e passar essa janela para a função do arquivo form.py que vai criar os botões, etc.

Após isso, você tem que conectar os sinais e os slots dos seus objetos para criar as funcionalidades desejadas. Neste caso, a cada evento no slider ou na caixa, um sinal serial está sendo enviado para o microcontrolador.

Cada slot é um novo método que você deve criar ou então usar de um artifício que são as funções lambda do Python.
Imagem do programa sendo executado:

Abaixo um exemplo de código:
Qualquer dúvida, faça um comentário!

from PyQt4 import QtGui, QtCore
import sys, serial 
import scan, form

class Main():
    def __init__(self):
        self.app = QtGui.QApplication(sys.argv)
        self.janela = QtGui.QMainWindow()
        self.ui = form.Ui_Form()  #Referências para elementos da janela
        self.ui.setupUi(self.janela)
        self.cria_slots()
        self.encontra_portas()
        self.janela.show()

    def cria_slots(self):
        self.ui.bt_conectar.clicked.connect(self.slot_conexao)
        self.ui.box_valor.valueChanged.connect(self.envia_info)
        self.ui.ck_ativar.clicked.connect(self.set_on_off)

    def encontra_portas(self):
        for porta in scan.scan():
            self.ui.box_porta.addItem(porta[0])

    #Criar outros métodos aqui

if __name__ == '__main__':
    prog = Main()
    prog.app.exec_()