Ubuntu Wiki

Introdução

Seja bem-vindo ao universo fantástico da linguagem Python. Este tutorial tem a finalidade de ensinar Python em 15 minutos, apresentando-lhe alguns conceitos básicos para que você possa começar sozinho a aprender mais sobre a linguagem. Ao final dessa leitura você vai encontrar vários links na última sessão desta página que serão seu ponto de partida para estudos mais aprofundados sobre a linguagem e seus temas relacionados com Web, Interfaces gráficas e comunidades Python no Brasil e no mundo.

Aprender uma linguagem de programação nova leva tempo e se você quer realmente aprender, obviamente vai levar muito mais que 15 minutos. Nossa intenção é apresentar Python para alguém familiarizado com programação, destacando aspectos específicos da linguagem e apresentando tudo que acreditamos ser essencial para quem está começando.

Antes de começar a leitura, observe alguns aspectos que consideramos importante:

• Você pode programar em Python diretamente no interpretador da linguagem usando um terminal e chamado o comando python, ou pode escrever um arquivo de script e incluir seu código dentro. Este tutorial basea-se na primeira opção.

• Palavras reservadas da linguagem serão destacadas, assim você poderá notá-las imediatamente.

• Alguns conceitos importantes serão brevemente apresentados diretamente no código por meio de comentários. Você perceberá o uso de # ou """ como comentário.

Boa leitura.

Sobre Python

Python é uma linguagem dinâmica de tipagem fraca, onde dados não assumem um tipo único e você pode atribuir um numeral a uma string sem problemas. Aliás, Python é implicitamente tipada: Você não precisa declarar uma variável para usá-la, basta atribuir algo a ela. Mas observe que Python é case sensitive, ou seja, faz diferença entre variáveis com letras maiúsculas e minúsculas. O termo vem do inglês e significa sensível ao tamanho da letra, isto é, var é diferente de VAR, que por sua vez é diferente de Var. Acima de tudo, saiba que Python é uma linguagem orientada a objetos, tudo e absolutamente tudo - incluindo variáveis, funções ou métodos, tipos de dados e etc - são objetos.

Obtendo Ajuda

O sistema de ajuda do Python está disponível dentro do interpretador e pode ser usado a qualquer momento. Se você precisa saber como usar um objeto ou como um método funciona, você vai precisar usar o método help() chamando tanto pelo comando help() quanto passando um parâmetro tal que help(nome_do_objeto). Veja um exemplo a seguir:

   1 >>> help()
   2 
   3 Welcome to Python 2.5!  This is the online help utility.
   4 
   5 If this is your first time using Python, you should definitely check out
   6 the tutorial on the Internet at http://www.python.org/doc/tut/.
   7 
   8 Enter the name of any module, keyword, or topic to get help on writing
   9 Python programs and using Python modules.  To quit this help utility and
  10 return to the interpreter, just type "quit".
  11 
  12 To get a list of available modules, keywords, or topics, type "modules",
  13 "keywords", or "topics".  Each module also comes with a one-line summary
  14 of what it does; to list the modules whose summaries contain a given word
  15 such as "spam", type "modules spam". 
  16 

Existe também o método dir(), que mostra todos os métodos de um objeto, e ainda tem o <nome_do_objeto>.doc que imprime toda a documentação relativa ao objeto:

   1 >>> dir(help)
   2 ['__call__', '__class__', '__delattr__', '__dict__', '__doc__', '__getattribute__', '__hash__', '__init__', '__module__', '__new__', '__reduce__', '__reduce_ex__', '__repr__', '__setattr__', '__str__', '__weakref__']
   3 

Vamos inspecionar os detalhes que o método doc tem para no revelar, use:

   1 >>> dir.__doc__
   2 "dir([object]) -> list of strings\n\nReturn an alphabetized list of names comprising (some of) the attributes\nof the given object, and of attributes reachable from it:\n\nNo argument:  the names in the current scope.\nModule object:  the module attributes.\nType or class object:  its attributes, and recursively the attributes of\n    its bases.\nOtherwise:  its attributes, its class's attributes, and recursively the\n    attributes of its class's base classes."
   3 

Syntax da Linguagem

A linguagem Python não necessita de caracteres de fim de linha tipo ; e blocos de código são especificados por meio de identação. Use identação para marcar o início do bloco tal como begin é usado no pascal ou { em C, saia da indentação para caracterizar o fim do bloco (equivale a end em pascal ou } em C). Uma declaração que necessita de indentação deverá ser sinalizada com(:). Exemplo:

   1 >>> def myFunc():
   2 ...     print "whathever"
   3 ... 
   4 >>> 
   5 

Valores são atribuidos por meio do símbolo =, e para testar logicamente uma igualdade use ==. Você pode incrementar ou decrementar valores usando os operadores += e -= respectivamente. Incremento e decremento vai funcionar com qualquer tipo de dado, inclusive strings.

   1 >>> myvar = 3
   2 >>> myvar += 2
   3 >>> myvar
   4 5
   5 >>> myvar -= 1
   6 >>> myvar
   7 4
   8 >>> mystring = "Hello"
   9 >>> mystring += " world."
  10 

Você também pode usar/atribuir múltiplas variáveis em uma linha, como no exemplo a seguir:

   1 >>> myvar, mystring = mystring, myvar
   2 

Comentários devem iniciar com # para o caso de um comentário por linha, e com """ para o caso de o comentário ter mais de uma linha, devendo ser finalizado com """, como no exemplo a seguir:

   1 """This is a multiline comment.
   2 The following lines concatenate the two strings."""
   3 >>> print mystring
   4 Hello world.
   5 # This swaps the variables in one line(!).
   6 # It doesn't violate strong typing because assignment to a
   7 # variable actually creates a new one and discards the old.
   8 

Estruturas de dados

As estruturas de dados básicas em Python são listas, tuplas e dicionários. Listas são como vetores de uma dimensão, no entanto você pode criar matrizes (vetor de vetores) usando listas formadas de outras listas. Dicionários são vetores associativos, também conhecidos como tabelas hash. Tuplas são um tipo especial de lista que tem como característica o fato de ser imutável, ou seja, você não pode adicionar ou remover conteúdo. Em todos os casos você poderá usar qualquer tipo de dado, ou seja, você poderá misturar inteiros, strings e etc em listas/dicionários/tuplas. É possível ainda misturar estruturas de dados, como por exemplo fazer um dicionário de listas ou uma lista de tuplas. Você pode usar o comando del para deletar variáveis ou itens na lista.

O primeiro item em qualquer estrutura de dados semelhante a um vetor é indexado como 0. Números negativos conta de trás para frente, isto é, -1 é o último elemento. Veja a seguir como usar estruturas de dados:

   1 >>> sample = [1, ["another", "list"], ("a", "tuple")]
   2 >>> mylist = ["List item 1", 2, 3.14]
   3 >>> mylist[0] = "List item 1 again"
   4 >>> mylist[-1] = 3.14
   5 >>> mydict = {"Key 1": "Value 1", 2: 3, "pi": 3.14}
   6 >>> mydict["pi"] = 3.15
   7 >>> mytuple = (1, 2, 3)
   8 >>> anotherList = [1, 2, 3]
   9 >>> del anotherList[0]
  10 >>> print anotherList
  11 [2, 3]
  12 >>> del anotherList
  13 

List comprehensions é um recurso presente em várias linguagens de programação, até na matemática (em teorias conjuntos). Listas por compreensão (traduzindo "ao pé da letra") provê um mecanismo de criação e manipulação de listas muito poderoso, consistindo de uma expressão declarada com uma cláusula seguida de zero or mais cláusulas if ou for, como no exemplo:

   1 >>> lst1 = [1, 2, 3]
   2 >>> lst2 = [3, 4, 5]
   3 >>> print [x * y for x in lst1 for y in lst2]
   4 [3, 4, 5, 6, 8, 10, 9, 12, 15]
   5 >>> print [x for x in lst1 if 4 > x > 1]
   6 [2, 3]
   7 # Check if an item has a specific property.
   8 # "any" returns true if any item in the list is true.
   9 >>> any(i % 3 for i in [3, 3, 4, 4, 3])
  10 True
  11 # Check how many items have this property.
  12 >>> sum(1 for i in [3, 3, 4, 4, 3] if i == 3)
  13 3
  14 

Você pode acessar intervalos dentro de vetores usando :. Deixando o índice de começo em branco o interpretador vai assumir como sendo o primeiro índice disponível, deixando o índice de fim em branco o interpretador percorrerá até o final do vetor. Exemplo:

   1 >>> mylist = ["List item 1", 2, 3.14]
   2 >>> print mylist[:]
   3 ['List item 1', 2, 3.1400000000000001]
   4 >>> print mylist[0:2]
   5 ['List item 1', 2]
   6 >>> print mylist[-3:-1]
   7 ['List item 1', 2]
   8 >>> print mylist[1:]
   9 [2, 3.14]
  10 

Strings

Cada strings pode usar tanto aspas simples como aspas duplas, e você pode ter aspas de qualquer tipo dentro de uma string que utilize aspas de outro tipo, isto é "Ele disse 'hello'." é válido. Strings de múltiplas linhas são cercadas por triplas aspas simples (ou duplas). Python suporta Unicode por padrão, usanda a sintaxe u"Esta é uma String unicode". Para atribuir conteúdo a uma string, vocÊ pode usar o operador %s (modulo) e passar uma tupla. Cada %s será substituído por um item da tupla, da esquerda para a direita, e você também pode fazer substituições usando um dicionário, como em:

   1 >>>print "Name: %s\nNumber: %s\nString: %s" % (myclass.name, 3, 3 * "-")
   2 Name: Poromenos
   3 Number: 3
   4 String: ---
   5  
   6 strString = """This is
   7 a multiline
   8 string."""
   9  
  10 # WARNING: Watch out for the trailing s in "%(key)s".
  11 >>> print "This %(verb)s a %(noun)s." % {"noun": "test", "verb": "is"}
  12 This is a test.
  13 

Controlando fluxo de dados

Para controlar o fluxo de dados você deve utilizar while, if, e for. Não existe uma forma de usar select-case em Python; no entanto, você pode ser criativo usando if e uma lista (ou tupla). Use for para percorrer entre membros de uma lista. Para obter uma lista de números, use range(<valor_inteiro>). Quando for construir testes lógico, lembre-se que você pode encadear condições, ou seja, quando usar 1 < a < 3 o interpretador vai checar se a é, ao mesmo tempo, menor que 3 e maior que 1. Exemplos de uso seguem abaixo:

   1 rangelist = range(10)
   2 >>> print rangelist
   3 [0, 1, 2, 3, 4, 5, 6, 7, 8, 9]
   4 for number in rangelist:
   5     # Check if number is one of
   6     # the numbers in the tuple.
   7     if number in (3, 4, 7, 9):
   8         # "Break" terminates a for without
   9         # executing the "else" clause.
  10         break
  11     else:
  12         # "Continue" starts the next iteration
  13         # of the loop. It's rather useless here,
  14         # as it's the last statement of the loop.
  15         continue
  16 else:
  17     # The "else" clause is optional and is
  18     # executed only if the loop didn't "break".
  19     pass # Do nothing
  20  
  21 if rangelist[1] == 2:
  22     print "The second item (lists are 0-based) is 2"
  23 elif rangelist[1] == 3:
  24     print "The second item (lists are 0-based) is 3"
  25 else:
  26     print "Dunno"
  27  
  28 while rangelist[1] == 1:
  29     pass
  30 

Funções

Funções são declaradas usando a palavra reservada def. Argumentos opcionais podem ser usados durante a declaração da função logo após declararmos o seu nome propriamente dito, eles virão dentro de parenteses e podem ou não ser mandatórios. Para argumentos mandatórios, para cada argumento é atribuído um valor default. Funções podem retornar uma tupla quando precisamos retornar múltiplos valores. Python suporta o uso de funções Lambda, um tipo especial de função auto-contida (em uma linha somente) muito usadas em programação funconal. Parâmetros são passados também por referência, porém tipos imutáveis ( como tuplas, ints, strings, etc) não podem ser modificados. Isto ocorre porque em passagem por referência, somente a localização na memória é passada (um ponteiro), e o valor é realocado para uma variável local ao escopo da função. Alguns exemplos:

   1 # Same as def f(x): return x + 1
   2 functionvar = lambda x: x + 1
   3 >>> print functionvar(1)
   4 2
   5  
   6 # an_int and a_string are optional, they have default values
   7 # if one is not passed (2 and "A default string", respectively).
   8 def passing_example(a_list, an_int=2, a_string="A default string"):
   9     a_list.append("A new item")
  10     an_int = 4
  11     return a_list, an_int, a_string
  12  
  13 >>> my_list = [1, 2, 3]
  14 >>> my_int = 10
  15 >>> print passing_example(my_list, my_int)
  16 ([1, 2, 3, 'A new item'], 4, "A default string")
  17 >>> my_list
  18 [1, 2, 3, 'A new item']
  19 >>> my_int
  20 10
  21 

Variáveis Globais

Variáveis globais são declaradas fora das funções e podem ser lidas sem necessidade de declararmos, porém se você precisas escrever nessa variável, então você precisa declarar ela dentro do escopo da sua função utilizando a palavra-chave global, caso contrário Python vai criar a variável localmente dentro do escopo da função, e ela não existirá como uma variável global disponível para ser usada em outras partes do seu código. Veja os exemplos:

   1 number = 5
   2  
   3 def myfunc():
   4     # This will print 5.
   5     print number
   6  
   7 def anotherfunc():
   8     # This raises an exception because the variable has not
   9     # been assigned to before printing. Python knows that it a
  10     # value will be assigned to it later and creates a new, local
  11     # number instead of accessing the global one.
  12     print number
  13     number = 3
  14  
  15 def yetanotherfunc():
  16     global number
  17     # This will correctly change the global.
  18     number = 3
  19 

Classes

Python suporta uma forma limitada de heranças múltiplas. Variáveis privadas e métodos podem ser declarados (by convention, this is not enforced by the language) adicionando dois caracteres de underscores (p.ex. "spam"), mas saiba que isso é uma conveção: python permite instrospecção total no objeto. Nós também podemos atribuir valores arbitrários para as instâncias de classes. Veja os exemplos a seguir:

   1 class MyClass:
   2     common = 10
   3     def __init__(self):
   4         self.myvariable = 3
   5     def myfunction(self, arg1, arg2):
   6         return self.myvariable
   7  
   8     # This is the class instantiation
   9 >>> classinstance = MyClass()
  10 >>> classinstance.myfunction(1, 2)
  11 3
  12 # This variable is shared by all classes.
  13 >>> classinstance2 = MyClass()
  14 >>> classinstance.common
  15 10
  16 >>> classinstance2.common
  17 10
  18 # Note how we use the class name
  19 # instead of the instance.
  20 >>> MyClass.common = 30
  21 >>> classinstance.common
  22 30
  23 >>> classinstance2.common
  24 30
  25 # This will not update the variable on the class,
  26 # instead it will create a new one on the class
  27 # instance and assign the value to that.
  28 >>> classinstance.common = 10
  29 >>> classinstance.common
  30 10
  31 >>> classinstance2.common
  32 30
  33 >>> MyClass.common = 50
  34 # This has not changed, because "common" is
  35 # now an instance variable.
  36 >>> classinstance.common
  37 10
  38 >>> classinstance2.common
  39 50
  40  
  41 # This class inherits from MyClass. Multiple
  42 # inheritance is declared as:
  43 # class OtherClass(MyClass1, MyClass2, MyClassN)
  44 class OtherClass(MyClass):
  45     def __init__(self, arg1):
  46         self.myvariable = 3
  47         print arg1
  48  
  49 >>> classinstance = OtherClass("hello")
  50 hello
  51 >>> classinstance.myfunction(1, 2)
  52 3
  53 # This class doesn't have a .test member, but
  54 # we can add one to the instance anyway. Note
  55 # that this will only be a member of classinstance.
  56 >>> classinstance.test = 10
  57 >>> classinstance.test
  58 10
  59 

Tratamento de exceções

Você pode tratar exceções em Python envolvendo seus blocos de código com try-except:

   1 def some_function():
   2     try:
   3         # Division by zero raises an exception
   4         10 / 0
   5     except ZeroDivisionError:
   6         print "Oops, invalid."
   7     else:
   8         # Exception didn't occur, we're good.
   9         pass
  10     finally:
  11         # This is executed after the code block is run
  12         # and all exceptions have been handled, even
  13         # if a new exception is raised while handling.
  14         print "We're done with that."
  15  
  16 >>> some_function()
  17 Oops, invalid.
  18 We're done with that.
  19 

Importando módulos

Bibliotecas externas são chamadas usando a palavra reservada import seguida do nome da biblioteca. Você também pode usar from nome_da_biblioteca import parte_da_biblioteca para chamar partes individuais de uma biblioteca. É recomendável importar somente o que você precisa de uma biblioteca ao invés de chamar import dela inteira, isso economizará memória. Para inspecionar o conteúdo de cada biblioteca utilize o comando dir (veja help para detalhes) em um terminal. A seguir alguns exemplos de uso do comando import:

   1 import random
   2 from time import clock
   3  
   4 randomint = random.randint(1, 100)
   5 >>> print randomint
   6 64
   7 

E/S em arquivos

Python has a wide array of libraries built in. As an example, here is how serializing (converting data structures to strings using the pickle library) with file I/O is used:

   1 import pickle
   2 mylist = ["This", "is", 4, 13327]
   3 # Open the file C:\binary.dat for writing. The letter r before the
   4 # filename string is used to prevent backslash escaping.
   5 myfile = file(r"C:\binary.dat", "w")
   6 pickle.dump(mylist, myfile)
   7 myfile.close()
   8  
   9 myfile = file(r"C:\text.txt", "w")
  10 myfile.write("This is a sample string")
  11 myfile.close()
  12  
  13 myfile = file(r"C:\text.txt")
  14 >>> print myfile.read()
  15 'This is a sample string'
  16 myfile.close()
  17  
  18 # Open the file for reading.
  19 myfile = file(r"C:\binary.dat")
  20 loadedlist = pickle.load(myfile)
  21 myfile.close()
  22 >>> print loadedlist
  23 ['This', 'is', 4, 13327]
  24 

Conclusão e bibliografia recomendada

Este tutorial não tinha a intenção de cobrir todos os tópicos da linguagem Python, mas sim introduzí-lo aos aspectos fundamentais, assim você poderá seguir sozinho seus estudos na linguagem. Uma série de Websites na internet podem levá-lo a ter as mais diversas experiências com a linguagem, explorando aspectos como Programação Web, Toolkits Gráficas, e muito mais. Divirta-se com os links a seguir:

• O Brasil é privilegiado por ter uma das melhores comunidades Python do mundo que se destaca por ser organizada e receptiva a pessoas novas na linguagem. Uma dica é se inscrever na lista de discurssão e participar tirando dúvidas, recebendo ajuda, conhecendo ofertas de emprego para programadores Python e muito mais. Além da lista, o portal de Python no Brasil tem uma extensa documentação em Português de excelente qualidade, acesse PythonBrasil e veja você mesmo.

• Mergulhe no Python (''Dive into Python'') é um livro muito recomendado para o aprendizado de como programar em Python, dirigido aos programadores com alguma experiência prévia... Leia Dive into Python

• O tutorial PyGTK é um tutorial de desenvolvimento com o kit de ferramentas gráficas usado habitualmente para desenvolver aplicações para o Ubuntu. Assume que você já tenha conhecimento de Python mas não necessariamente de GTK. Instale o pacote python-gtk2-tutorial (veja Instalando Software). Você precisará usar o Gerenciador de Pacotes Synaptic para instalar esse pacote. Em seguida, para acessar a documentação, visite python-gtk-tutorial.

• Agora se seu interesse é programação para web, Django é o primeiro nome da lista. Bastante usado, possui uma comunidade Brasileira muito boa e com um portal completo (lista de discurssão também). Visite a comunidade Brasileira de Django, seu ponto de partida para o mundo do desenvolvimento web 2.0, acesse DjangoBrasil.

• Indispensável também é o link para o Portal da documentação oficial de Python (em inglês). Lá você vai encontrar tudo sobre a linguagem, visite PythonDocs e veja você mesmo. Se preferir, existe um wikibook muito bem escrito e em formato tutorial disponível (em inglês também) que trata de maneira clara e objetiva a linguagem. Veja em PythonWikibook.

Créditos