Introdução ao Python

Início

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

Se você estiver buscando um curso MOOC complementar, tente os do Udacity e Coursera (introdução à programação [para iniciantes] ou introdução ao Python). Por fim, se você quiser um aprendizado on-line individualizado sem assistir a vídeos, use as opções listadas no final desta postagem (link em inglês), que apresentam o conteúdo de aprendizado de cada recurso e um intérprete interativo de Python para praticar. O que é esse "intérprete" que mencionamos? Você descobrirá na próxima seção.

Introdução à linguagem

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

Uma excelente forma de saber como o código Python funciona é executar o interpretador de Python e digitar o código nele. Se você tiver alguma pergunta, "O que acontece se eu adicionar uma int a um list?". Basta digitá-la no intérprete de Python para saber o que acontece de maneira rápida e provavelmente a melhor. Veja 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 >>> informa 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 devem funcionar para você.

Como mostrado acima, é fácil testar variáveis e operadores. Além disso, o intérprete gera, ou "aumenta" na linguagem Python um erro de tempo de execução se o código tentar ler uma variável que não tenha recebido um valor. Assim como o C++ e o 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 final de uma instrução. Portanto, ao contrário de C++ e Java, o Python não exige ponto e vírgula no final de cada instrução. Os comentários começam com '#' e se estendem até o final da linha.

Código-fonte em Python

Os arquivos de origem 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 shell "python hello.py Alice", que chama o intérprete de Python para executar o código em hello.py, passando a ele o argumento de linha de comando "Alice". Consulte a página de documentos oficiais sobre todas as diferentes opções 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 recuo em vez de chaves. Falaremos sobre isso mais adiante.

#!/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 do programa na linha de comando fica 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 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 do Python pode ser executado diretamente, como acima de python3 hello.py Bob, ou pode ser importado e usado por algum outro módulo. Quando um arquivo Python é executado diretamente, a variável especial "__name__" é definida como "__main__". Portanto, é comum que o if __name__ ==... boilerplate mostrado acima chame uma função main() quando o módulo for executado diretamente, mas não quando ele for importado por outro módulo.

Em um programa Python padrão, a lista sys.argv contém os argumentos da linha de comando da maneira padrão, sendo sys.argv[0] 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 tamanho de uma string, o número de elementos em listas e tuplas (outra estrutura de dados semelhante à matriz) 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 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 por ser o operador "repeat" do Python, o que significa que '-' * 10 dá a '----------', 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 operadores "sobrecarregados" porque têm significados 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, são "aspas triplas", um recurso exclusivo do Python!) As variáveis definidas na função são locais para essa função, então o "resultado" na função acima é separado de uma variável "result" em outra função. A instrução return pode receber um argumento. Nesse caso, esse é o valor retornado ao autor da chamada.

Veja o código que chama a função repeat() acima, gerando 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() em direção à parte inferior do arquivo com as funções que ela chama acima dele.

Recuo

Um recurso incomum do Python é que o recuo do espaço em branco de uma parte do 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 ou de "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 no Python parece um pouco estranho no começo, mas é lógico e descobri que me acostumei rapidamente. Evite usar TABs, porque elas complicam bastante o esquema de recuo (sem mencionar que TABs podem significar coisas diferentes em cada plataforma). Configure seu editor para inserir espaços em vez de TABs para o código Python.

Uma pergunta comum que os iniciantes fazem é: “Quantos espaços preciso usar recuo?”. De acordo com o guia de estilo oficial do Python (PEP 8), use quatro espaços para recuo. Curiosidade: a diretriz de estilo interna do Google determina o recuo em dois espaços.

Código verificado no tempo de execução

O Python faz poucas verificações no tempo de compilação, adiando quase todas as verificações de tipo, nome etc. em cada linha até que ela seja executada. Suponha que a funçã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(). Uma coisa engraçada é que esse código é compilado e executado corretamente, desde que o nome no momento da execução não seja "Guido". Somente quando uma execução realmente tentar executar o repeeeet(), ela perceberá que essa função não existe e emitirá um erro. Há também um segundo erro nesse snippet. nome não recebeu um valor antes de ser comparado a "Guido". O Python gerará um "NameError" se você tentar avaliar uma variável não atribuída. Estes são alguns exemplos que demonstram que, ao executar um programa em 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 linguagens com um sistema de tipo 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 essas informações de tipo ... é uma troca).

O Python 3 introduziu as 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 com anotação def is_positive(n: int) -> bool:, o argumento n é um int e o valor de retorno é um bool. Veremos o que esses tipos significam mais tarde. As dicas de tipo são totalmente opcionais. Você vai encontrar cada vez mais códigos adotando dicas de tipo porque, se você usá-las, alguns editores, como cider-v e VS.code, podem executar verificações para conferir 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 ter certeza de que você as estará ciente se ouvir sobre elas ou vê-las em uso.

Nomes de variáveis

Como as variáveis Python não têm nenhum tipo escrito 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 de 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 manter as informações corretas.

No que diz respeito à nomenclatura, algumas linguagens preferem underlined_parts para nomes de variáveis compostos por "mais de uma palavra", mas outras linguagens preferem camelCasing. Em geral, o Python prefere o método sublinhado, mas orienta os desenvolvedores a adotar camelCasing caso faça a integração com um código Python existente que já usa esse estilo. A legibilidade é importante. Leia mais na seção sobre convenções de nomenclatura em PEP 8.

Como você deve imaginar, palavras-chave como "se" e "enquanto" não podem ser usadas como nomes de variáveis. Você receberá um erro de sintaxe se fizer isso. No entanto, tome cuidado para não usar elementos integrados como nomes de variáveis. Por exemplo, embora "str", "list" e "print" pareçam bons nomes, você substituiria essas variáveis de sistema. Integrados não são palavras-chave e, portanto, são suscetíveis ao uso inadvertido por novos desenvolvedores de Python.

Mais sobre os módulos e os namespaces deles

Suponha que você tenha um módulo "binky.py" que contenha um "def foo()". O nome totalmente qualificado dessa função foo é "binky.foo". Dessa forma, diversos módulos Python podem nomear suas funções e variáveis como quiserem, e os nomes das variáveis não entrarão em conflito — module1.foo é diferente de module2.foo. No vocabulário Python, diríamos que binky, module1 e module2, cada um, têm seus próprios "namespaces", que, como você pode imaginar, são vinculações de variável nome-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 com esta aparência: "from sys import argv, exit". Isso disponibiliza argv e exit() pelos nomes curtos deles. No entanto, recomendamos o formato original com os nomes totalmente qualificados, já que é muito mais fácil determinar a origem de uma função ou um atributo.

Existem muitos módulos e pacotes que vêm com uma instalação padrão do intérprete de Python, portanto, você não precisa fazer nada extra para usá-los. Elas são coletivamente conhecidas como "Biblioteca padrão do Python". Os módulos/pacotes mais usados incluem:

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

Você encontra a documentação de todos os módulos e pacotes da Biblioteca padrão em http://docs.python.org/library.

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

Há várias maneiras de se receber ajuda para Python.

  • Faça uma pesquisa no Google, começando com a palavra "python", como "python list" ou "python string thumbnail". O primeiro hit é muitas vezes a resposta. Por algum motivo, essa técnica parece funcionar melhor para Python do que para outras linguagens.
  • O site oficial de documentos do Python (docs.python.org) tem documentos de alta qualidade. No entanto, muitas vezes acho que pesquisar no Google algumas palavras é mais rápido.
  • Há também uma lista de e-mails oficial do tutor especificamente projetada para aqueles que são novos em Python e/ou programação.
  • Muitas perguntas (e respostas) podem ser encontradas no StackOverflow e no Quora.
  • Use as funções help() e dir() (veja abaixo).

Dentro do interpretador do Python, a função help() extrai strings de documentação para diversos módulos, funções e métodos. Essas strings de documento 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 intérprete:

  • help(len): string de ajuda para a função len() integrada. É "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 (precisa fazer um import sys primeiro).
  • dir(sys) — dir() é como help(), mas apenas mostra uma lista rápida dos símbolos ou “atributos” definidos por ela.
  • 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() para objetos de string. Você pode chamar help() com esse objeto ou com um exemplo (link em inglês) e os atributos dele. Por exemplo, chamar help('xyz'.split) é o mesmo que chamar help(str.split).
  • help(list): string de ajuda para objetos list.
  • dir(list): exibe atributos do objeto list, incluindo os métodos.
  • help(list.append): string de ajuda para o método append() em objetos list.