Esta página foi traduzida pela API Cloud Translation.

Introdução ao Python

Início

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

Se você estiver procurando 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ê quer um curso on-line individualizado sem assistir vídeos, confira as opções listadas no final deste post. Cada uma delas tem conteúdo de aprendizado 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

O Python é uma linguagem dinâmica e interpretada (compilada por bytescode). 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, e você perde a verificação de tipo no tempo de compilação do código-fonte. O Python rastreia os tipos de todos os valores no ambiente de execução e sinaliza os códigos que não fazem sentido durante a execução.

Uma ótima maneira de entender como o código Python funciona é executar o interpretador Python 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?", digitar isso no interpretador do Python é uma maneira rápida e provavelmente a melhor maneira de saber o que acontece. 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 são impressas depois que você digita python e antes do prompt >>> informa sobre a versão do Python que você está usando e onde ela foi criada. Contanto que a primeira coisa impressa seja "Python 3.", esses exemplos devem funcionar para você.

Como você pode ver acima, é fácil testar variáveis e operadores. Além disso, o intérprete gera, ou "levanta", em linguagem Python, um erro de execução se o código tentar ler uma variável que não recebeu um valor. Assim como C++ e Java, 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 do C++ e do Java, o Python não exige um ponto e vírgula no final 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 de Python para executar o código em hello.py, transmitindo o argumento de linha de comando "Alice". Consulte a página de documentos oficiais sobre todas as opções disponíveis 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 recuo em vez de chaves. Vamos falar mais sobre isso mais tarde:

#!/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()

A execução desse programa na linha de comando é semelhante a:

$ 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 sua configuração única. Essas instruções são executadas de cima para baixo na primeira vez que o módulo é importado para algum lugar, configurando suas variáveis e funções. Um módulo Python pode ser executado diretamente, como acima de 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 que o boilerplate if __name__ ==... mostrado acima chame 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ê conhece argc ou o número de argumentos, basta solicitar esse valor do Python com len(sys.argv), assim como fizemos no código intérprete interativo acima ao solicitar o comprimento de uma string. Em geral, len() pode informar o comprimento 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 formam a função ou if-statement são agrupadas por todas com o mesmo nível de recuo. 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 "repetição" do Python, o que significa que '-' * 10 gera '----------', uma maneira legal de criar uma "linha" na tela. No comentário do código, sugerimos que * funciona mais rápido do que +, o que acontece porque * calcula o tamanho do objeto resultante uma vez, enquanto que 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 recuado. A primeira linha de uma função pode ser uma string de documentação ("docstring") que descreve o que a função faz. O docstring pode ser uma única linha ou uma descrição de várias linhas, como no exemplo acima. Sim, são aspas triplas, um recurso exclusivo do Python. As variáveis definidas na função são locais para essa função, portanto, o "resultado" na função acima é separado de uma variável "result" em outra função. A instrução return pode receber um argumento, que é o valor retornado ao autor da chamada.

Este é o código que chama a função repeat() acima, mostrando o que ela retorna:

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

No ambiente 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 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 pai, "if" ou qualquer outra coisa. Se uma das linhas em 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, pois elas complicam muito o esquema de recuo (sem mencionar GUIs podem ter significados diferentes em diferentes plataformas). Defina o editor para inserir espaços em vez de TABs para código Python.

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

Código verificado em tempo de execução

O Python faz poucas verificações 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 a main() acima chame repeat() assim:

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(). Curiosamente em Python ... esse código é compilado e executado sem problemas, desde que o nome no tempo de execução não seja "Guido". Somente quando uma execução realmente tenta executar repeeeet(), ela percebe que essa função não existe e gera um erro. Há também um segundo erro neste snippet. O nome 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. Esses são alguns exemplos que demonstram que, ao executar um programa Python pela primeira vez, alguns dos primeiros erros que você vê serão simples erros de digitação ou variáveis não inicializadas como essas. Essa é uma área em que as linguagens com um sistema de tipos mais detalhado, como Java, têm uma vantagem... elas podem detectar esses erros no tempo de compilação (mas é claro que você precisa manter todas as informações desse tipo, mas é uma escolha comum).

O Python 3 introduziu dicas de tipo. As dicas de tipo permitem indicar o tipo de cada argumento em uma função, bem como o tipo do objeto retornado pela função. Por exemplo, na função def is_positive(n: int) -> bool: anotada, o argumento n é um int e o valor de retorno é um bool. Vamos explicar o significado desses tipos mais tarde. No entanto, as dicas de tipo são totalmente opcionais. Você vai notar que cada vez mais códigos estão adotando dicas de tipo porque, se você as usar, alguns editores como cider-v e VS.code poderão executar verificações para verificar se as funções são chamadas com os tipos de argumento corretos. Elas podem até sugerir e validar argumentos enquanto você edita o código. Neste tutorial, não abordaremos dicas de tipo, mas queremos ter certeza de que você está ciente delas se ouvir sobre elas ou as vir em qualquer lugar.

Nomes de variáveis

Como as variáveis Python não têm nenhum tipo especificado no código-fonte, é muito útil dar nomes significativos às variáveis para se lembrar do que está acontecendo. Portanto, 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 são causados por esquecimento do tipo de valor em cada variável. Use os nomes das variáveis (tudo o que você tem) para manter as coisas organizadas.

Quanto à nomenclatura, alguns idiomas preferem partes com sublinhado para nomes de variáveis compostas por "mais de uma palavra", mas outros preferem a camelização. Em geral, o Python prefere o método de sublinhado, mas orienta os desenvolvedores a usar a notação camelus 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 no 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, tome cuidado para não usar palavras-chave internas como nomes de variáveis. Por exemplo, embora "str", "list" e "print" pareçam bons nomes, você vai substituir essas variáveis do sistema. Os built-ins não são palavras-chave e, portanto, podem ser usados acidentalmente 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 uma "def foo()". O nome totalmente qualificado dessa função foo é "binky.foo". Dessa forma, vários módulos do Python podem nomear as funções e variáveis como quiserem, e os nomes das variáveis não vão entrar em conflito. O módulo1.foo é diferente do módulo2.foo. No vocabulário do Python, diríamos que binky, module1 e module2 têm cada um o próprio "namespace", que são, como você pode imaginar, vinculações de nome de variável a 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 tem esta aparência: "from sys import argv, exit". Isso torna argv e exit() disponíveis por seus nomes curtos; no entanto, recomendamos o formulário 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 você não precisa fazer nada extra para usá-los. Elas são conhecidas coletivamente como a "biblioteca padrão do Python". Os módulos/pacotes mais usados incluem:

sys: acesso a exit(), argv, stdin, stdout etc.
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 para o Python.

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

No interpretador do Python, a função help() mostra strings de documentação para vários módulos, funções e métodos. Essas strings de documentos 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() no intérprete:

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 é recomendado
help(sys): string de ajuda para o módulo sys (primeiro é necessário fazer uma import sys)
dir(sys): dir() é semelhante a help(), mas mostra 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 do método split() para objetos de string. É possível chamar help() com esse 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): exibe os atributos do objeto list, incluindo os métodos.
help(list.append): string de ajuda do método append() para objetos list