Introdução ao Python

Início

Este é o tutorial on-line do Google sobre Python. Ele é baseado no curso introdutório de Python oferecido internamente. Conforme mencionado na página de configuração, este material aborda o Python 3.

Se você quiser um curso MOOC complementar, tente os da Udacity e do Coursera (introdução à programação [iniciantes] ou introdução ao Python). Por fim, se você quiser aprender on-line no seu ritmo sem assistir vídeos, confira os recursos listados no final desta postagem. Cada um deles tem conteúdo de aprendizado de recursos e um interpretador interativo do Python para você praticar. O que é esse "intérprete" que mencionamos? Você vai descobrir na próxima seção.

Introdução ao idioma

Python é uma linguagem dinâmica, interpretada (compilada em bytecode). Não há declarações de tipo de variáveis, parâmetros, funções ou métodos no código-fonte. Isso torna o código curto e flexível, mas você perde a verificação de tipo do código-fonte durante a compilação. O Python rastreia os tipos de todos os valores durante a execução e sinaliza o código que não faz sentido à medida que é executado.

Uma excelente maneira de entender como o código Python funciona é executar o interpretador e digitar o código diretamente nele. Se você tiver uma dúvida como "O que acontece se eu adicionar um int a um list?", basta digitar no interpretador Python para saber o que acontece de forma rápida e provavelmente da melhor maneira. (Confira abaixo o que realmente acontece.)

$ python3        ## Run the Python interpreter
Python 3.X.X (XXX, XXX XX XXXX, XX:XX:XX) [XXX] on XXX
Type "help", "copyright", "credits" or "license" for more information.
>>> a = 6       ## set a variable in this interpreter session
>>> a           ## entering an expression prints its value
6
>>> a + 2
8
>>> a = 'hi'    ## 'a' can hold a string just as well
>>> a
'hi'
>>> len(a)      ## call the len() function on a string
2
>>> a + len(a)  ## try something that doesn't work
Traceback (most recent call last):
  File "", line 1, in 
TypeError: can only concatenate str (not "int") to str
>>> a + str(len(a))  ## probably what you really wanted
'hi2'
>>> foo         ## try something else that doesn't work
Traceback (most recent call last):
  File "", line 1, in 
NameError: name 'foo' is not defined
>>> ^D          ## type CTRL-d to exit (CTRL-z in Windows/DOS terminal)

As duas linhas que o Python imprime depois que você digita "python" e antes do prompt ">>>" informam sobre a versão do Python que você está usando e onde ela foi criada. Desde que a primeira coisa impressa seja "Python 3", esses exemplos vão funcionar para você.

Como você pode ver acima, é fácil testar variáveis e operadores. Além disso, o interpretador gera, ou "gera" em Python, um erro de tempo de execução se o código tentar ler uma variável que não recebeu um valor. Assim como C++ e Java, o Python diferencia maiúsculas de minúsculas. Portanto, "a" e "A" são variáveis diferentes. O fim de uma linha marca o fim de uma instrução. Portanto, ao contrário de C++ e Java, o Python não exige um ponto e vírgula no fim de cada instrução. Os comentários começam com um "#" e se estendem até o fim da linha.

Código-fonte Python

Os arquivos de origem do Python usam a extensão ".py" e são chamados de "módulos". Com um módulo Python hello.py, a maneira mais fácil de executá-lo é com o comando do shell "python hello.py Alice", que chama o interpretador Python para executar o código em hello.py, transmitindo o argumento da linha de comando "Alice". Consulte a página de documentação oficial sobre todas as opções diferentes que você tem ao executar o Python na linha de comando.

Confira um programa hello.py muito simples. Observe que os blocos de código são delimitados estritamente usando indentação em vez de chaves. Falaremos mais sobre isso depois.

#!/usr/bin/python3

# import modules used here -- sys is a very standard one
import sys

# Gather our code in a main() function
def main():
    print('Hello there', sys.argv[1])
    # Command line args are in sys.argv[1], sys.argv[2] ...
    # sys.argv[0] is the script name itself and can be ignored

# Standard boilerplate to call the main() function to begin
# the program.
if __name__ == '__main__':
    main()

Executar esse programa na linha de comando é assim:

$ python3 hello.py Guido
Hello there Guido
$ ./hello.py Alice  ## without needing 'python3' first (Unix)
Hello there Alice

Importações, argumentos de linha de comando e len()

As instruções mais externas em um arquivo Python, ou "módulo", fazem a configuração única. Essas instruções são executadas de cima para baixo na primeira vez que o módulo é importado em algum lugar, configurando as variáveis e funções dele. Um módulo Python pode ser executado diretamente, como acima python3 hello.py Bob, ou pode ser importado e usado por outro módulo. Quando um arquivo Python é executado diretamente, a variável especial "__name__" é definida como "__main__". Portanto, é comum ter o boilerplate if __name__ ==... mostrado acima para chamar uma função main() quando o módulo é executado diretamente, mas não quando é importado por outro módulo.

Em um programa Python padrão, a lista sys.argv contém os argumentos de linha de comando da maneira padrão, com sys.argv[0] sendo o próprio programa, sys.argv[1] o primeiro argumento e assim por diante. Se você souber sobre argv ou o número de argumentos, basta solicitar esse valor do Python com len(sys.argv), assim como fizemos no código do interpretador interativo acima ao solicitar o comprimento de uma string. Em geral, len() pode informar o tamanho de uma string, o número de elementos em listas e tuplas (outra estrutura de dados semelhante a matrizes) e o número de pares de chave-valor em um dicionário.

Funções definidas pelo usuário

As funções em Python são definidas assim:

# Defines a "repeat" function that takes 2 arguments.
def repeat(s, exclaim):
    """
    Returns the string 's' repeated 3 times.
    If exclaim is true, add exclamation marks.
    """

    result = s + s + s # can also use "s * 3" which is faster (Why?)
    if exclaim:
        result = result + '!!!'
    return result

Observe também como as linhas que compõem a função ou a instrução "if" são agrupadas por terem o mesmo nível de indentação. Também apresentamos duas maneiras diferentes de repetir strings, usando o operador +, que é mais fácil de usar, mas * também funciona porque é o operador "repetir" do Python. Isso significa que '-' * 10 resulta em '----------', uma maneira interessante de criar uma "linha" na tela. No comentário do código, sugerimos que * funciona mais rápido do que +, porque * calcula o tamanho do objeto resultante uma vez, enquanto com +, esse cálculo é feito sempre que + é chamado. Os operadores + e * são chamados de "sobrecarregados" porque significam coisas diferentes para números e strings (e outros tipos de dados).

A palavra-chave def define a função com os parâmetros entre parênteses e o código com recuo. A primeira linha de uma função pode ser uma string de documentação ("docstring") que descreve o que a função faz. A docstring pode ser uma única linha ou uma descrição de várias linhas, como no exemplo acima. Sim, essas são "aspas triplas", um recurso exclusivo do Python. As variáveis definidas na função são locais a ela. Portanto, o "resultado" na função acima é separado de uma variável "resultado" em outra função. A instrução return pode receber um argumento, que será o valor retornado ao autor da chamada.

Confira o código que chama a função repeat() acima, imprimindo o que ela retorna:

def main():
    print(repeat('Yay', False))      ## YayYayYay
    print(repeat('Woo Hoo', True))   ## Woo HooWoo HooWoo Hoo!!!

No tempo de execução, as funções precisam ser definidas pela execução de um "def" antes de serem chamadas. É comum definir uma função main() na parte de baixo do arquivo com as funções que ela chama acima.

Recuo

Um recurso incomum do Python é que o recuo de espaço em branco de um trecho de código afeta o significado dele. Um bloco lógico de instruções, como as que compõem uma função, precisa ter o mesmo recuo, definido a partir do recuo da função mãe ou "if" ou qualquer outra coisa. Se uma das linhas de um grupo tiver um recuo diferente, ela será sinalizada como um erro de sintaxe.

O uso de espaços em branco do Python parece um pouco estranho no início, mas é lógico e me acostumei muito rápido. Evite usar TABs, porque eles complicam muito o esquema de indentação. Além disso, TABs podem ter significados diferentes em plataformas diferentes. Configure o editor para inserir espaços em vez de TABs no código Python.

Uma pergunta comum que os iniciantes fazem é: "Quantos espaços devo usar para recuar?" De acordo com o guia de estilo oficial do Python (PEP 8), você precisa usar um recuo de quatro espaços. (Curiosidade: a diretriz de estilo interna do Google determina o uso de dois espaços para indentação.)

Código verificado no tempo de execução

O Python faz muito pouca verificação no momento da compilação, adiando quase todas as verificações de tipo, nome etc. em cada linha até que ela seja executada. Suponha que o main() acima chame repeat() desta forma:

def main():
    if name == 'Guido':
        print(repeeeet(name) + '!!!')
    else:
        print(repeat(name))

A instrução "if" contém um erro óbvio, em que a função "repeat()" é digitada acidentalmente como "repeeeet()". O engraçado no Python é que esse código é compilado e executado corretamente desde que o nome no tempo de execução não seja "Guido". Somente quando uma execução tenta executar o repeeeet() é que ela percebe que não existe essa função e gera um erro. Há também um segundo erro neste snippet: "name" não recebeu um valor antes de ser comparado com "Guido". O Python vai gerar um "NameError" se você tentar avaliar uma variável não atribuída. Estes são alguns exemplos que mostram que, ao executar um programa Python pela primeira vez, alguns dos primeiros erros que você vai encontrar serão erros de digitação simples ou variáveis não inicializadas como estas. Essa é uma área em que linguagens com um sistema de tipos mais detalhado, como Java, têm uma vantagem. Elas podem detectar esses erros no momento da compilação, mas é claro que você precisa manter todas essas informações de tipo. É uma troca.

O Python 3 introduziu as dicas de tipo. As dicas de tipo permitem indicar qual é o tipo de cada argumento em uma função, bem como qual é o tipo do objeto retornado pela função. Por exemplo, na função anotada def is_positive(n: int) -> bool:, o argumento n é um int e o valor de retorno é um bool. Vamos explicar o que esses tipos significam mais adiante. No entanto, as dicas de tipo são totalmente opcionais. Você vai ver cada vez mais código adotando dicas de tipo porque, se você as usar, alguns editores, como o cider-v e o VS.code, poderão executar verificações para confirmar se as funções são chamadas com os tipos de argumento corretos. Eles podem até sugerir e validar argumentos enquanto você edita o código. Este tutorial não aborda dicas de tipo, mas queremos garantir que você saiba o que são caso ouça falar ou veja em algum lugar.

Nomes de variáveis

Como as variáveis do Python não têm nenhum tipo especificado no código-fonte, é muito útil dar nomes significativos a elas para lembrar o que está acontecendo. Use "name" se for um único nome, "names" se for uma lista de nomes e "tuples" se for uma lista de tuplas. Muitos erros básicos do Python resultam do esquecimento do tipo de valor em cada variável. Portanto, use os nomes das variáveis (tudo o que você tem) para ajudar a manter as coisas em ordem.

Quanto à nomenclatura real, algumas linguagens preferem partes_com_sublinhado para nomes de variáveis compostos por "mais de uma palavra", mas outras preferem camelCase. Em geral, o Python prefere o método de sublinhado, mas orienta os desenvolvedores a usar camelCase se a integração for feita em um código Python que já usa esse estilo. A legibilidade é importante. Leia mais na seção sobre convenções de nomenclatura na PEP 8.

Como você pode imaginar, palavras-chave como "if" e "while" não podem ser usadas como nomes de variáveis. Se você fizer isso, vai receber um erro de sintaxe. No entanto, tenha cuidado para não usar elementos integrados como nomes de variáveis. Por exemplo, embora "str", "list" e "print" pareçam bons nomes, você estaria substituindo essas variáveis do sistema. Os built-ins não são palavras-chave e, portanto, estão sujeitos ao uso inadvertido por novos desenvolvedores de Python.

Mais informações sobre módulos e namespaces

Suponha que você tenha um módulo "binky.py" que contém um "def foo()". O nome totalmente qualificado dessa função foo é "binky.foo". Dessa forma, vários módulos do Python podem nomear funções e variáveis como quiserem, e os nomes das variáveis não vão entrar em conflito. module1.foo é diferente de module2.foo. No vocabulário do Python, diríamos que binky, module1 e module2 têm seus próprios "namespaces", que, como você pode imaginar, são vinculações de nome de variável para objeto.

Por exemplo, temos o módulo padrão "sys", que contém alguns recursos padrão do sistema, como a lista argv e a função exit(). Com a instrução "import sys", você pode acessar as definições no módulo sys e disponibilizá-las pelo nome totalmente qualificado, por exemplo, sys.exit(). Sim, "sys" também tem um namespace.

  import sys

  # Now can refer to sys.xxx facilities
  sys.exit(0)

Há outro formulário de importação que se parece com este: "from sys import argv, exit". Isso disponibiliza argv e exit() pelos nomes abreviados. No entanto, recomendamos a forma original com os nomes totalmente qualificados porque é muito mais fácil determinar de onde veio uma função ou um atributo.

Há muitos módulos e pacotes agrupados com uma instalação padrão do interpretador Python, então não é necessário fazer nada extra para usá-los. Elas são conhecidas coletivamente como "Biblioteca padrão do Python". Módulos/pacotes usados com frequência incluem:

• sys: acesso a exit(), argv, stdin, stdout, ...
• re: expressões regulares
• os: interface do sistema operacional, sistema de arquivos

A documentação de todos os módulos e pacotes da biblioteca padrão está disponível em http://docs.python.org/library.

Ajuda on-line, help() e dir()

Há várias maneiras de receber ajuda com o Python.

• Faça uma pesquisa no Google, começando com a palavra "python", como "lista python" ou "string python minúscula". O primeiro resultado geralmente é a resposta. Essa técnica parece funcionar melhor para Python do que para outras linguagens por algum motivo.
• O site oficial de documentação do Python (docs.python.org) tem documentação de alta qualidade. No entanto, muitas vezes acho mais rápido pesquisar algumas palavras no Google.
• Também há uma lista de e-mails oficial do Tutor criada especificamente para quem está começando a programar e/ou usar Python.
• Muitas perguntas (e respostas) podem ser encontradas no StackOverflow e no Quora.
• Use as funções help() e dir() (veja abaixo).

No interpretador Python, a função help() extrai strings de documentação para vários módulos, funções e métodos. Essas strings de documentação são semelhantes ao javadoc do Java. A função dir() informa quais são os atributos de um objeto. Confira abaixo algumas maneiras de chamar help() e dir() do interpretador:

• help(len): string de ajuda para a função len() integrada. Observe que é "len" e não "len()", que é uma chamada para a função, o que não queremos.
• help(sys): string de ajuda para o módulo sys. Primeiro, faça um import sys.
• dir(sys): dir() é como help(), mas apenas fornece uma lista rápida dos símbolos definidos ou "atributos".
• help(sys.exit): string de ajuda para a função exit() no módulo sys.
• help('xyz'.split): string de ajuda para o método split() de objetos de string. Você pode chamar help() com o próprio objeto ou um exemplo dele, além do atributo. Por exemplo, chamar help('xyz'.split) é o mesmo que chamar help(str.split).
• help(list): string de ajuda para objetos list
• dir(list): mostra os atributos do objeto list, incluindo os métodos dele.
• help(list.append): string de ajuda para o método append() de objetos list.