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 o Python 3.

Se você estiver buscando um curso MOOC complementar, experimente os da Udacity e do Coursera (introdução à programação [para iniciantes] ou introdução a Python). Por fim, se você quer aprender on-line no seu próprio ritmo sem assistir vídeos, use as opções listadas ao final desta postagem. Cada um deles oferece conteúdo de aprendizado 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 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 do código-fonte no momento da compilação. 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 forma excelente de ver 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?" Basta digitar no interpretador de Python para conferir o que acontece de forma 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 >>> comando informa sobre a versão do Python usada e onde ela foi criada. Contanto 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" no linguajar Python, um erro de tempo de execução se o código tenta ler uma variável que não recebeu um valor. Assim como C++ e Java, Python diferencia maiúsculas de minúsculas. Por isso, "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, Python não requer ponto e vírgula no final de cada instrução. Os comentários começam com '#' e se estendem até o fim da linha.

Código-fonte do 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 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 para ver todas as opções que você tem ao executar o Python na linha de comando.

Confira este programa hello.py muito simples. Observe que os blocos de código são delimitados estritamente usando recuo 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()

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

$ 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__" é definido como "__main__". Portanto, é comum usar o código boilerplate if __name__ ==... mostrado acima para chamar uma função main() quando o módulo é executado diretamente, mas não quando ele é 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, em que 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() informa o tamanho de uma string, o número de elementos em listas e tuplas (outra estrutura de dados semelhante a uma 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 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 "repeat" do Python. o que significa que '-' * 10 fornece '----------', uma maneira organizada 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. + e * são chamados de "sobrecarregados" operadores porque eles 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. O 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 para essa função, portanto, o "resultado" na função acima é separada de um "resultado" em outra função. A instrução return pode receber um argumento. Nesse caso, ele é o valor retornado ao autor da chamada.

Este é o código que chama a funçãorepeat() 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 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 um trecho de código afeta o significado. 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 "if" ou qualquer coisa. Se uma das linhas de um grupo tiver um recuo diferente, isso será sinalizado 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 muito rapidamente. Evite usar TABs, pois elas complicam muito o esquema de recuo (sem mencionar GUIs podem ter significados diferentes em diferentes plataformas). Configure seu editor para inserir espaços em vez de TABs para código Python.

Uma pergunta comum que iniciantes fazem é: "Quantos espaços preciso recuar?". De acordo com o guia de estilo oficial do Python (PEP 8), o recuo precisa ter quatro espaços. (Curiosidade: a diretriz de estilo interna do Google determina o recuo de 2 espaços).

Código verificado em tempo de execução

O Python faz poucas verificações durante a compilação, adiando quase todas as verificações de tipo, nome etc. em cada linha até que essa linha seja executada. Suponha que o main() acima chame “repet()” da seguinte 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 curioso do 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 realmente tenta executar repeeeet(), ela percebe que essa função não existe e gera um erro. Há também um segundo erro nesse snippet. não recebeu um valor antes de ser comparado com "Guido". O Python vai gerar um erro "NameError" quando você tenta 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 compensação).

O Python 3 introduziu dicas de tipo. As dicas de tipo permitem indicar qual é o tipo de cada argumento em uma função, bem como o que qual é 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 é bool. Abordaremos o significado desses tipos mais tarde. As dicas de tipo são totalmente opcionais. Você verá cada vez mais códigos adotando dicas de tipo, porque, se usá-los, alguns editores, como cider-v e VS.code, podem executar verificações para confirmar se as funções são chamadas com os tipos de argumento certos. Eles podem até sugerir e validar argumentos enquanto você edita o código. Este tutorial não abordará dicas de tipo, mas queremos ter certeza de que você está ciente delas se ouvir sobre eles ou vê-los na natureza.

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, e “names” se for uma lista de nomes, e "tuplas" 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 realmente) para ajudar a manter as coisas em ordem.

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

Como você pode imaginar, palavras-chave como "if" e "while" não podem ser usados como nomes de variáveis - você receberá um erro de sintaxe se fizer isso. No entanto, tenha cuidado para não usar integrados como nomes de variáveis. Por exemplo, enquanto 'str', 'list' e "print" parecem bons nomes, você estaria substituindo essas variáveis de sistema. Integradas não são palavras-chave e, portanto, são suscetíveis ao uso inadvertido por novos desenvolvedores de Python.

Mais informações sobre módulos e os respectivos 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 Python podem nomear suas funções e variáveis como quiserem, sem conflitos entre os nomes das variáveis, já que 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 a objeto de variáveis.

Por exemplo, temos o 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" é possível 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 parecido com este: "from sys import argv, exit". Isso disponibiliza argv e exit() por seus nomes curtos; No entanto, recomendamos o formulário original com os nomes totalmente qualificados porque é muito mais fácil determinar de onde uma função ou um atributo veio.

Existem muitos módulos e pacotes que já vêm com uma instalação padrão do interpretador de Python, portanto você não precisa fazer nada extra para usá-los. Coletivamente, elas são conhecidas como "Biblioteca padrão do Python". Os módulos/pacotes usados com frequência incluem:

• sys: acesso a exit(), argv, stdin, stdout...
• re: expressões regulares
• SO: 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 que comece com a palavra "python", como "python list". ou "python string minúscula". O primeiro hit geralmente é a resposta. Essa técnica parece funcionar melhor para Python do que para outras linguagens, por algum motivo.
• O site de documentos oficial 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.
• Há também uma lista de e-mails oficial para tutores criada especificamente para quem é novo no Python e/ou na 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 de 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() no intérprete:

• help(len): string de ajuda para a função integrada len(). que é "len", e não "len()", que é uma chamada da função que não é
• help(sys): string de ajuda para o módulo sys (precisa executar import sys primeiro)
• 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 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): mostra atributos do objeto list, incluindo os métodos dele.
• help(list.append): string de ajuda do método append() para objetos list