Média de lista em Python, como calcular

Às vezes a gente tem a tendência de complicar as coisas. Semana passada, um amigo me perguntou se há alguma forma de calcular a média de uma lista em Python. Assim como há funções para calcular a soma dos elementos ou o maior elemento, ele esperava que houvesse uma para calcular a média.

Afinal, calcular a média de uma lista é uma necessidade comum, certo? Deve haver no Python algum jeito fácil de fazer, então. Quando eu disse que não, meu amigo gastou alguns segundos pesquisando e chegou nessa solução:

import numpy
l = [ 2, 5, 6.8, 9, 7]
avg = numpy.mean(l)

Funciona. Não é muito código. Mas tem alguns problemas:

  1. Cria uma dependência extra: será preciso ter o numpy instalado para que a aplicação funcione
  2. Complica um pouco mais o código: nem todo mundo sabe o que faz o método .mean(), fazendo com que outros programadores tenham que gastar um tempinho pesquisando
  3. Tem uma performance pior: ou, pelo menos, para os tamanhos de lista mais comum. A função de média do numpy é otimizada. Deveria portanto, ser mais rápida. Se você tiver que calcular centenas de médias de listas gigantescas, numpy vai fazer diferença. Mas não é o caso da maioria das aplicações. Se você for usar pouco a função mean() o custo de importá-la é maior que o de fazer o cálculo você mesmo.

E como fica esse cálculo? O jeito como eu recomendo calcular a média de uma lista em Python é esse:

l = [ 2, 5, 6.8, 9, 7]
avg = sum(l)/len(l)

A dica é: antes de procurar ou construir um módulo com a solução do seu problema, pense se não é um problema simples demais para isso. Se você fizer esse exercício, vai evitar escrever código como esse:

import calculations
x = calculations.sum(2, 7)

Ao invés de:

x = 2 + 7

E não, não tem filosofia, técnica ou estratégia que você posa usar para tentar me convencer de que o primeiro jeito é melhor do que o segundo.

Recursos “escondidos” do Python

Resposta que eu dei à pergunta: Quais são alguns dos recursos ocultos do Python? no Quora.


1. Atribuição múltipla (com tuple unpacking)

a, b, c = 1, 2, 3

2. Com isso dá para trocar o valor de variáveis

a, b = b, a

3. Encadeamento de comparadores

x = 3
print(1 < x < 5) # True

4. Generators

def fib(max):
    n1, n2 = 0, 1
    for i in range(max):
        yield n1
        n1, n2 = n2, n1 + n2
f = fib(20)
for i in f:
    print(i)

5. If em uma linha

aliquota = 0.05 if valor < 1000 else 0.07

6. List comprehension

# Quadrados dos números de 0 a 99
[i ** 2 for i in range(100)]

# Quadrados dos números de 0 a 99, apenas
# se o resultado não contém o dígito "4"
[i ** 2 for i in range(100) if not '4' in str(i**2)]

7. Invertendo uma string

a = a[::-1]

8. enumerate

for i, l in enumerate('palavra'):
    print (i, l, end=' / ')
# 0 p / 1 a / 2 l / 3 a / 4 v / 5 r / 6 a /

9. Unpacking estendido (só Python 3)

a, *b, c = "unpacking"
print(a, b, c)
# u ['n', 'p', 'a', 'c', 'k', 'i', 'n'] g

10. Dict comprehension

d = {i: i**2 for i in range(10)}
print(d)
# {0: 0, 1: 1, 2: 4, 3: 9, 4: 16, 5: 25, 6: 36}

11. String formatting

dados={'nome': 'Joaquim', 'email': 'jsilva@fbi.gov'}
print('%(nome)s <%(email)s>' % dados)
# Joaquim <jsilva@fbi.gov>
print('{nome} <{email}>'.format(**dados))
# Joaquim <jsilva@fbi.gov>

12. zip

list(zip([1, 2, 3], [4, 5, 6]))
[(1, 4), (2, 5), (3, 6)]

Módulos Úteis

1. collections

import collections
print(collections.Counter('banana'))
# Counter({'a': 3, 'n': 2, 'b': 1})
d = collections.defaultdict(lambda:'...')
d['nome'] = 'Teste'
print(d['nome']) # Teste
print(d['idade']) # ...

2. pprint

from pprint import pprint
pprint(['a' * i for i in range(20)])
# ['',
#  'a',
#  'aa',
#  'aaa',
#  'aaaa',
#  'aaaaa',
#  'aaaaaa',
#  'aaaaaaa',
#  'aaaaaaaa',
#  'aaaaaaaaa',
#  'aaaaaaaaaa',
#  'aaaaaaaaaaa',
#  'aaaaaaaaaaaa',
#  'aaaaaaaaaaaaa',
#  'aaaaaaaaaaaaaa',
#  'aaaaaaaaaaaaaaa',
#  'aaaaaaaaaaaaaaaa',
#  'aaaaaaaaaaaaaaaaa',
#  'aaaaaaaaaaaaaaaaaa',
#  'aaaaaaaaaaaaaaaaaaa']

3. itertools

import itertools
for i in itertools.permutations("123"):
    print("".join(i), end=", ")
# 123, 132, 213, 231, 312, 321,
for i in itertools.product("01", repeat=3):
    print("".join(i), end=", ")
# 000, 001, 010, 011, 100, 101, 110, 111,

4. SimpleHTTPServer

➜  ~ python -m SimpleHTTPServer
Serving HTTP on 0.0.0.0 port 8000 ...

5. webbrowser

import webbrowser
webbrowser.open('https://campus.visie.com.br/')

6. atexit

➜  ~ python3 -q
>>> def teste():
...     print('Bye!')
...
>>> import atexit
>>> atexit.register(teste)
<function teste at 0x10973a620>
>>> ^D
Bye!
➜  ~ _

7. base64

import base64
print(base64.b64encode(b'Teste'))
# b'VGVzdGU='

8. gzip

import gzip
print(gzip.open('teste.txt.gz').read())

Easter Eggs

Tente aí:

>> import this
>> import hello
>> import antigravity
>> from __future__ import braces

Como tornar seu script Python executável

Resposta que eu dei à pergunta: É possível escrever um script executável em Python? no Quora.


Sim!

No Windows, basta associar arquivos .py ao Python. Acredito que o instalador do Python para windows já faz isso. Feito isso, duplo clique no arquivo .py vai executá-lo.

No Linux, Mac, FreeBSD e assemelhados, basta colocar, na primeira linha do seu script:

#!/usr/bin/env python

Em seguida, torne seu script executável com o comando:

chmod +x seuscript.py

Claro, troque “seuscript” pelo nome do seu arquivo. Pronto, ele é executável. Você pode executar com:

./seuscript.py

Diferente do windows, a extensão não precisa ser .py, nem precisa ter extensão. Além disso, você pode mover o script para qualquer lugar no PATH do sistema e poderá executá-lo de qualquer diretório, sem precisar de ./ no início do comando. Por exemplo, pode fazer:

sudo mv ./seuscript.py /usr/local/bin/seucomando

Em seguida pode executar apenas:

seucomando

Sem ./ e em qualquer diretório.

Não seja escravo das suas ferramentas

Muita gente que, como eu, tem um blog, usa o plugin Yoast SEO para WordPress. É muito bom, uma escolha óbvia. Ele praticamente lê seu texto e te diz o que você tem que fazer para melhorar a indexação.

O problema? Muitas vezes, otimizar seu texto para uma determinada palavra-chave o torna chato de ler. Seu texto fica mais ou menos assim:

… Ao usar um plugin de SEO para WordPress, você corre o risco de escrever um texto mecânico. É verdade que plugins de SEO para WordPress são uma coisa boa, mas você precisa tomar cuidado para não deixar seu plugin de SEO para WordPress mandar em você…

Você quer apenas ser encontrado? Tem um monte de sites por aí tão cheios de publicidade que tornam quase impossível ler o que está escrito. O objetivo é ser encontrado e gerar um clique patrocinado, apenas isso. Se é isso o que você está construindo, vá em frente, siga as regras do plugin e você vai poupar um bocado de tempo.

Mas se seu objetivo é que as pessoas encontrem, leiam e entendam o que você está escrevendo, então seguir cegamente as regras não é a melhor decisão.

Escreve para pessoas, depois faça o que for possível para agradar os robôs.

Há um tempo que eu tenho usado o Pylint em alguns projetos. Ele me avisa se eu deixo de seguir algum padrão de código. Ele até dá uma nota para o meu código!

Mas o recurso mais legal do Pylint é poder fazer isso:

import config # pylint: disable = relative-import

Ou seja, não preciso seguir as regras cegamente.

Você também pode decidir quando quebrar as regras. Escolha com cuidado.

Não é sobre quantas linhas de código você escreve

Parece haver uma certa fixação entre os programadores, principalmente os menos experientes, em quantas linhas de código são necessárias para resolver determinado problema.

Às vezes isso é bom. Veja como ler um arquivo texto em Java:

import java.io.*; 
public class ReadingFromFile 
{ 
    public static void main(String[] args) throws Exception 
    { 
	FileReader fr = 
	new FileReader("arquivo.txt"); 

	int i; 
	while ((i=fr.read()) != -1) 
	    System.out.print((char) i); 
    } 
} 

Agora compare com a mesma coisa em Python:

print(open('arquivo.txt').read())

Nesse caso, parece óbvio que a resposta em Python é muito melhor, não? Agora olhe esse código em JavaScript:

urlscore = url.indexOf('http') ? -1 : (url.indexOf('https://')+1)*5 + 
                                      (url.split('/')[2].indexOf('www')?1:0)*2 + 
                                      (url.split('/')[1].indexOf('@')>-1?-1:1)*3

Uau! O sujeito reduziu a função inteira a uma única expressão! Parece uma boa ideia pra você? Coitado de quem tiver que dar manutenção nisso!

Seu inimigo não é a quantidade de código, é a complexidade. É difícil dar uma boa definição técnica de complexidade, mas você a reconhece quando vê.

Quanto mais óbvio, melhor

Quando você está escrevendo código, pense sempre em quem vai ter que lê-lo no futuro. Pode ser você mesmo. Pode ser você mesmo, daqui a cinco, às duas da manhã, correndo para consertar um bug.

É por isso que padrões e convenções são uma ideia tão boa.

Quanto tempo você já passou olhando o código de alguma aplicação, tentando descobrir onde estão as coisas? No web2py, um dos meus frameworks favoritos, quando você cria uma nova aplicação, a pasta de código se parece com isso:

Aplicação nova em web2py, ainda sem nenhum código.

Web2py é um framework MVC, que, você sabe, é a sigla para model, view e controller. Para acessar o banco de dados você escreve um model. E como se chama a pasta onde estão seus models? Ok, models. E as regras de negócio devem ir num controller. E onde estão seus controllers? Na pasta controllers, claro. E as views na pasta views.

Zero esforço para entender, zero esforço para decorar.

Eu sei que é bem pouco esforço decorar que, no seu novo framework da moda, as views estão dentro de /presentation/templates/html, os controllers em /app/core/controllers e os modelos em /persistence/rdbs. Mas pouco é infinitamente mais do que zero. E, acredite, esses pequenos esforços, somados, fazem um bocado de diferença.

Módulo Python: requests

Esqueça urllib e httplib: Requests resolve do jeito certo.

Você pode instalar via pip com:

pip install requests

Depois, veja como é fácil:

>>> import requests
>>> r=requests.get('http://visie.com.br')
>>> for k,v in r.headers.iteritems():print k,'=>',v
... 
content-length => 7669
content-encoding => gzip
accept-ranges => bytes
expires => Mon, 20 Jan 2014 13:18:30 GMT
vary => Accept-Encoding,Cookie
server => Apache
last-modified => Mon, 20 Jan 2014 12:38:24 GMT
cache-control => max-age=3, must-revalidate
date => Mon, 20 Jan 2014 13:18:27 GMT
content-type => text/html; charset=UTF-8
>>> r.status_code
200
>>> r.reason
'OK'
>>> r.content[:15]
'<!DOCTYPE html>'

Se você precisar fazer uma requisição HTTPS com autenticação e obter o retorno em JSON:

>>> r=requests.get('https://httpbin.org/basic-auth/user/passwd',auth=('user','passwd'))
>>> r.json()
{u'authenticated': True, u'user': u'user'}

Para fazer POST:

>>> r=requests.post('https://httpbin.org/post',data={'foo':'bar'})
>>> r.json()['form']
{u'foo': u'bar'}

Tudo muito, muito simples. E o módulo faz muito mais e está muito bem documentado. Olhe lá.

Porque você deveria aprender várias linguagens de programação

tpp_xlargecover
O programador pragmático não está preso a nenhuma tecnologia.

Há um tempo eu li “The Pragmatic Programmer“, uma espécie de livro de auto-ajuda para programadores. Não é um livro técnico, não vai te ensinar técnicas ou tecnologias, mas fala de um jeito de pensar e traz uma coleção de conselhos daquele tipo que parece óbvio mas ninguém nunca faz.

Um desses conselhos era aprender novas linguagens de programação. Os autores recomendam que você se torne proficiente em uma nova linguagem de programação por ano. O que, eu sei, é muito difícil. Eu não tenho conseguido aprender uma nova linguagem por ano. Mas isso não invalida o conselho de que você deve aprender novas linguagens de programação.

Por que aprender linguagens de programação novas?

Cada linguagem de programação traz consigo um jeito de pensar, um conjunto de soluções e uma comunidade com cultura diferente. E isso enriquece você. O bom programador tem uma visão ampla e não está “preso” a uma única tecnologia.

Por exemplo, digamos que você esteja desenvolvendo um sistema em PHP e precise, de tempos em tempos, fazer parsing de feeds RSS cuja URL foi cadastrada pelos usuários. Digamos que você queira fazer o parsing em segundo plano, a cada meia hora. Claro, você pode usar SimplePie, mas ele não é tão “Simple” assim. Dê uma olhada na documentação. SimplePie é muito poderoso, tem uma porção de recursos, mas vai dar algum trabalho para instalar direito, montar seu script, testar e automatizar.

E se você procurar soluções em outras linguagens de programação? Quanto trabalho vai ter? Vamos ver o que Python tem para nós, usando o excelente módulo feedparser. O módulo feedparser está disponível no gerenciador de pacotes do Ubuntu, e também para instalação via PIP.

import feedparser
print feedparser.parse('https://elcio.com.br/feed')

Mais uma meia dúzia de linhas para ler as URLs e salvar os resultados no banco de dados e pronto, temos um arquivo simples com excelente performance para ser colocado no cron. Bom, falando em performance, esse é o típico processamento que vai rodar muito mais rápido se feito em paralelo. Processamento em paralelo com PHP é um parto, certo? Com Python você pode usar o módulo multiprocessing e fazer isso quase que em uma linha só.

Além de ferramentas, linguagens de programação carregam jeitos de pensar

Uma vez que você já tenha resolvido um problema em uma linguagem de programação, você consegue resolver o mesmo problema em qualquer outra, certo? Bom, quando você aprende uma linguagem nova, você acaba tendo que ler um bocado de código de outras pessoas. E isso te ensina novas soluções para os seus velhos problemas.

Isso é diferente de se aprofundar no estudo de sua linguagem atual. O aprofundamento vai fazer você ler mais códigos das mesmas pessoas, da mesma comunidade, da mesma cultura. Aprender uma linguagem nova faz você ler códigos de gente nova, com outra cultura. Na prática, aprender Python vai fazer você melhor programador PHP, aprender Smalltalk vai fazer você melhor programador Java, etc.

Porque Python

De todas as linguagens de programação que você poderia escolher para começar a aprender algo novo hoje, eu recomendo que, se você ainda não sabe Python, comece por ela. Python roda no Google App Engine, no AWS Elastic Beanstalk e é a linguagem de programação por trás da maioria das ferramentas de administração do Ubuntu. Se você quer construir pequenos scripts para automatizar tarefas em seu servidor, ou quer construir grandes aplicações web para rodar em Cloud, ou se quer criar ferramentas de processamento paralelo massivo, ou interfaces gráficas multiplataforma, Python vai servir.

E é, ao mesmo tempo, uma linguagem que possui recurso fantásticos e vai te ensinar coisas incríveis, e uma das linguagens mais fáceis de aprender que eu conheço.

Que tal começar agora? Leia o excelente “Dive Into Python“, faça os exercícios, depois tente desenvolver alguma coisa na linguagem. E veja se você não vai se tornar mais eficiente em sua linguagem atual.

“Jabá”: Python é a linguagem que escolhemos para a aula de integração multi-linguagem do DevOps Heroes, treinamento da Visie que acontece a partir do dia 27 em São Paulo. Quem estiver lá vai ver isso tudo funcionando na prática. As vagas estão se esgotando.

Pequena dica de Python: módulo webbrowser

O módulo webbrowser permite abrir uma URL no navegador do usuário. Só isso, simples assim. Por exemplo:

import webbrowser
webbrowser.open("http://visie.com.br")

E o site da Visie será aberto no navegador do usuário. Muito útil se você está fazendo um programa para desktop ou mesmo um script para o terminal. No caso de scripts para terminal, se o usuário estiver rodando o script sob uma interface gráfica o site será aberto no navegador padrão dele, já se estiver rodando via ssh ou num outro terminal sem interface gráfica, será usado um navegador de CLI (como o Lynx) se estiver disponível.

Pequena dica de Python: as classes são dinâmicas

Veja:

>>> class Class:
...   def um(self):
...     return 1
... 
>>> c=Class()
>>> c.um()
1
>>> def dois(self):
...   return 2
... 
>>> Class.dois=dois
>>> c.dois()
2
>>> Class.tres=lambda self:3
>>> c.tres()
3
>>> Class.um=lambda self:'Um modificado.'
>>> c.um()
'Um modificado.'

As classes em Python são completamente dinâmicas. Você pode acrescentar métodos quando quiser e isso se refletirá em todos os objetos criados com aquela classe (mais ou menos como o que você faz em Javascript com prototype.)

Pequena dica de Python: leia os fontes

Python é uma linguagem open-source, com uma extensa biblioteca. E os módulos da biblioteca são escritos em Python. Alguns módulos, como pickle e StringIO, tem versões em C mais rápidas (cPickle e cStringIO) mas as versões em Python são mantidas para que você possa ler os fontes.

Veja como descobrir onde estão os fontes de um módulo qualquer:

>>> import glob
>>> glob.__file__
'/usr/lib/python2.7/glob.pyc'

O nome do arquivo tem a extensão pyc. É um compilado. Tire o último “c” e você terá o caminho do arquivo com o código fonte. Dê uma lida no conteúdo do glob.py, por exemplo, e você deve achar muito simples mas bastante interessante.

Se você está aprendendo Python agora, sempre que for resolver uma tarefa sobre determinado assunto, dê uma olhada no código dos módulos relacionados aquele assunto. Você vai ver como a comunidade Python tem abordado problemas semelhantes aos seus e com certeza vai aprender muito.

Pequena dica de Python: string formatting com locals()

Há muitas situações em que uma função faz cálculos e operações para obter valores e, ao final, deve montar uma string com esses valores. Nesta situação, muita gente monta um dicionário com os valores e usa string formatting para gerar a string a ser retornada. Por exemplo:

# -*- encoding: utf-8 -*-
import string,random

template='''Sugestões para %(nome)s:
 - login: %(login)s
 - email: %(email)s
 - site: www.%(domain)s.com
 - senha: %(passwd)s
'''

def sugere_logins(nome):
    login=nome.split(' ')[0].lower()
    domain=nome.split(' ')[-1].lower()
    email=login+'@'+domain+'.com'
    chars=string.letters+string.digits
    passwd=''.join(random.sample(chars,10))
    dados={'login':login,
           'email':email,
           'nome':nome,
           'domain':domain,
           'passwd':passwd}
    print template % dados

Você pode substituir todo o trecho em que monta o dicionário, usando o resultado da função locals(). A função locals() retorna um dicionário com todas as variáveis locais. No exemplo acima, isso ficaria assim:

# -*- encoding: utf-8 -*-
import string,random

template='''Sugestões para %(nome)s:
 - login: %(login)s
 - email: %(email)s
 - site: www.%(domain)s.com
 - senha: %(passwd)s
'''

def sugere_logins(nome):
    login=nome.split(' ')[0].lower()
    domain=nome.split(' ')[-1].lower()
    email=login+'@'+domain+'.com'
    chars=string.letters+string.digits
    passwd=''.join(random.sample(chars,10))
    print template % locals()

Uso muito esse truque ao trabalhar com web2py, fazendo com que os controllers, ao invés de retornar um dicionário montado por mim, retornem locals().

Pequena dica de Python: rot-13

A dica de hoje não é muito útil. Pelo menos eu nunca usei para nada realmente sério. Mas é bem divertida:

>>> t='All your base are belong to us.'
>>> t.encode('rot-13')
'Nyy lbhe onfr ner orybat gb hf.'

Rot-13 é um encoding comum do Python. Você pode escrever código em rot-13 também, se indicar o encoding do arquivo num cabeçalho:

# -*- encoding: rot-13 -*-
vzcbeg fgevat
sbe v va enatr(20):
    cevag fgevat.nfpvv_ybjrepnfr[:v]

Salve o conteúdo acima no arquivo rot13.py e você poderá executar:

$ python rot13.py

Divertido, não?

Pequena dica de Python: mesclando listas

Essa é bem legal. Temos três listas:

>>> a=[1,2,3]
>>> b=[4,5,6]
>>> c=['a','b','c']

Veja:

>>> zip(a,b,c)
[(1, 4, 'a'), (2, 5, 'b'), (3, 6, 'c')]

Simples e útil, não? E se as listas tiverem tamanhos diferentes?

>>> c=['a','b']
>>> zip(a,b,c)
[(1, 4, 'a'), (2, 5, 'b')]

O resultado será truncado para o tamanho da menor lista. Se você quiser, pode obter um comportamento diferente com map, assim:

>>> map(None,a,b,c)
[(1, 4, 'a'), (2, 5, 'b'), (3, 6, None)]

Veja um truque que eu costumava usar bastante com zip:

>>> colors=['Azul','Vermelho','Amarelo','Verde','Branco']
>>> for i in zip(range(len(colors)),colors):
...   print '%i. %s' % i
... 
0. Azul
1. Vermelho
2. Amarelo
3. Verde
4. Branco

Até que eu descobri enumerate():

>>> for i in enumerate(colors):
...   print '%i. %s' % i
... 
0. Azul
1. Vermelho
2. Amarelo
3. Verde
4. Branco

Pequena dica de Python: any e all

Python tem duas funções muito interessantes: any e all. A função any recebe uma lista (ou outro objeto interável) e retorna True se algum dos elementos for avaliado como True. Já all só retorna True se todos os elementos forem avaliados como True. Veja:

>>> everybody=[1,2,3,4]
>>> anybody=[0,1,0,2]
>>> nobody=[0,0,0,0]
>>> any(everybody)
True
>>> any(nobody)
False
>>> any(anybody)
True
>>> all(everybody)
True
>>> all(nobody)
False
>>> all(anybody)
False

Sem segredos, certo? Mas essas duas funções junto com os generators permite uma sintaxe muito interessante:

>>> v=[10,12,25,14]
>>> any(n>20 for n in v)
True
>>> all(n>20 for n in v)
False

Veja um exemplo disso num código real:

if all(v<100 for v in values):
    msg='Para usar seu cupom de desconto, pelo menos '+
        'um dos produtos deve custar mais de R$ 100,00.'

E numa classe real:

class Form:
    # ...
    def validates(self):
        return not any(field.error for field in self.fields)

Módulo Python: gzip

O módulo gzip nos permite ler e escrever em arquivos .gz sem nenhum trabalho. Veja:

>>> import gzip
>>> f=gzip.open('teste.txt.gz','w')
>>> f.write('Hello!\n')
7
>>> f.close()
>>> 
$ gunzip teste.txt.gz 
$ cat teste.txt 
Hello!
$ gzip teste.txt 
$ python
Python 2.7.3 (default, Apr 20 2012, 22:39:59) 
[GCC 4.6.3] on linux2
Type "help", "copyright", "credits" or "license" for more information.
>>> import gzip
>>> print gzip.open('teste.txt.gz').read()
Hello!

Pequena dica de Python: __missing__

A partir do Python 2.5, ao estender dicionários, você pode dar a suas classes um método __missing_, que será executado toda vez que você tentar acessar um índice inexistente. Veja:

class Counter(dict):
    def __missing__(self, key):
        self[key]=0
        return self[key]

Veja funcionando:

>>> votos=['john','paul','john','john','ringo',
...        'george','paul','ringo','ringo','john',
...        'paul','john','george','paul','paul',
...        'john','paul','john','ringo','paul']
>>> c=Counter()
>>> for v in votos:
...     c[v]+=1
... 
>>> c
{'ringo': 4, 'paul': 7, 'john': 7, 'george': 2}