Python - Introdução Básica

Apresentação Introdução Linguagem
Python
Introdução Básica
Christian S. Perone
christian.perone@gmail.com
22 de abril de 2013

Parte I
Apresentação

Apresentação
▸ Christian S. Perone
▸ Trabalha como desenvolvedor
▸ Colaborador e mantenedor open-source
▸ Blog
▸ http://pyevolve.sourceforge.net/wordpress
▸ Projetos
▸ https://github.com/perone
▸ Twitter @tarantulae

Roteiro
Apresentação
Apresentação
Introdução
Características
Casos de sucesso
Implementações
Read-Eval-Print Loop (REPL)
Versões da Linguagem
Linguagem
Variáveis
Tipos de Dados
Funções
Controles de Fluxo
Orientação a Objetos
Decorators
Exceções
Métodos Mágicos
Propriedades
Módulos e Pacotes
Dúvidas ?

Parte II
Introdução

Características
▸ VHLL (Very-High-Level Language)
▸ Interpretada
▸ Multiparadigma
▸ Imperativa
▸ Orientada a Objetos
▸ Funcional
▸ Tipagem dinâmica
▸ Fortemente tipada
▸ Baterias inclusas (Python Standard Library)
▸ Extensível
▸ Comunidades em diversas áreas

Casos de sucesso - Large Hadron Collider (LHC)
The large funcionality
available in Python’s library in
combination with the
flexibility provided by the
language itself was the main
reason for the choice.
—Dr. Andreas Pfeiffer,
CMS. (CERN, LHC).

Casos de sucesso - Industrial Light and Magic (ILM)
Python plays a key role in our
production pipeline. Without
it a project the size of The
Avengers would have been
very difficult to pull off. From
crowd rendering to batch
processing to compositing,
Python binds all things
together.
—Tommy Burnette,
Lucasfilm.

Casos de sucesso - OpenStack
A comunidade do OpenStack
escolheu Python como a
linguagem de desenvolvimento
exclusiva para o projeto e ela é
hoje exigida em novos projetos.

Casos de sucesso - Continuum Analytics
A Continuum Analytics recebeu
um financiamento de U$3 milhões
de um fundo de pesquisa da
DARPA para trabalhar no NumPy,
SciPy e técnicas de visualização
para exploração interativa de
grandes quantidades de dados.

Implementações
O interpretador oficial (referência) da linguagem Python é chamado
CPython, entretanto no “ecossistema” da linguagem também existem
outros interpretadores, como por exemplo:
▸ Jython (Java)
▸ IronPython (.NET)
▸ PyPy (RPython)
É importante compreender a diferença entre a linguagem e os
interpretadores da linguagem.

Read-Eval-Print Loop (REPL)
Uma das vantagens do Python é o prompt do interpretador, que
quando executado apresenta um REPL (Read-Eval-Print Loop). No
REPL do Python você pode interagir a qualquer momento com o
interpretador, esta é uma das mais importantes ferramentas de
aprendizado da linguagem, você pode testar pequenos trechos de
código sem precisar encapsular isto em uma classe (aka Java) ou criar
um arquivo de fonte separado. Exemplo de uso:
>>> print ’Hello world’
Hello world
>>> a = 2
>>> b = 3
>>> print a+b
5

Principais versões da linguagem
Hoje temos duas principais versões da linguagem:
Versão 2.x Lançada em 16 de Out 2000, trouxe novidades como list
comprehensions. Atualmente o branch da versão 2.x é o
que tem mais módulos externos disponíveis e também é
a mais utilizada pela comunidade. Esta introdução ao
Python aborda esta versão da linguagem, mais
especificamente a versão 2.7.

Versão 3.x Lançada em 3 de Dez 2008, foco em reparar algumas
inconsistências da linguagem e reduzir a duplicação de
recursos. Nesta versão a retrocompatibilidade de
sintaxe com as versões anteriores foi quebrada.

Versão 3.x Lançada em 3 de Dez 2008, foco em reparar algumas
inconsistências da linguagem e reduzir a duplicação de
recursos. Nesta versão a retrocompatibilidade de
sintaxe com as versões anteriores foi quebrada.
Ambas versões foram planejadas para coexistirem e receberem
atualizações em paralelo. Muitos recursos que foram introduzidos na
versão 3.x foram também portados para a versão 2.x.

Parte III
Linguagem

Variáveis
Python é uma linguagem dinamicamente tipada, ou seja, os tipos das
variáveis declaradas são resolvidos em tempo de execução (ao
contrário de linguagens estaticamente tipadas como C por exemplo).
Abaixo seguem alguns exemplos de declaração/atribuição de variáveis
em Python:
# Declaração de variável inteira
var_x = 10
# Declaração de variável real
var_y = 10.34
# Declaração de variável string
var_z = ’abcdef’

Variáveis ▸ Inspecionando tipos
Você pode usar a função type() para mostrar na tela qual o tipo da
variável, como no exemplo abaixo usando o REPL do Python:
>>> print type(var_x)
<type ’int’>
>>> print type(var_y)
<type ’float’>
>>> print type(var_z)
<type ’str’>

Variáveis ▸ Mutável vs Imutável
Em Python, alguns tipos de dados são imutáveis, como por exemplo as
strings e as tuplas. Esta abordagem, apesar de incomum a primeira
vista, tem algumas vantagens:

Performance a ideia de uma string imutável traz consigo um
tamanho imutável conhecido no momento da criação e
durante o tempo de vida do objeto.

Memória as strings imutáveis podem ser reutilizadas, duas strings
iguais podem apontar para o mesmo lugar da memória.

Memória as strings imutáveis podem ser reutilizadas, duas strings
iguais podem apontar para o mesmo lugar da memória.
Design imutabilidade é um dos conceitos fundamentais da
Programação Funcional, ela permite você ver o fluxo do
código como uma série de transformações de uma
representação em outra ao invés de uma sequência de
mutações in-place.

Variáveis ▸ Tudo é objeto
Tudo em Python é um objeto, inclusive funções, classes, números, etc.
Você pode usar o REPL do Python para mostrar os atributos de um
objeto da seguinte forma usando o dir():
>>> minha_string = ’abc’
>>> dir(minha_string)
[’__add__’, ’__class__’, ’__contains__’, ’__delattr__’,
(... omitido por brevidade)]

Variáveis ▸ Tudo é objeto
Tudo em Python é um objeto, inclusive funções, classes, números, etc.
Você pode usar o REPL do Python para mostrar os atributos de um
objeto da seguinte forma usando o dir():
>>> minha_string = ’abc’
>>> dir(minha_string)
[’__add__’, ’__class__’, ’__contains__’, ’__delattr__’,
(... omitido por brevidade)]
Você pode também verificar a identidade de um objeto usando a
função id():
>>> var_a = 1000
>>> id(var_a)
32679628
Nota
Esta identidade tem a garantia de ser única e constante para este objeto

Variáveis ▸ Nomes
Em Python, variáveis não são o objeto em si mas sim nomes para um
objeto. Um mesmo objeto pode ser referenciado por mais de um
nome:
>>> var_a = var_b = 5
>>> id(var_a)
32679630
>>> id(var_b)
32679630
O que este trecho de código faz é criar dois nomes para o mesmo
objeto, neste caso o número 5. Ao usar a função id() do Python
podemos constatar que de fato as duas variáveis estão apontando para
o mesmo objeto.

Tipos de Dados ▸ Números
Exemplos de operações matemáticas em Python:
>>> 2+2
4
>>> (50-5*6)/4
5
>>> 7/3
2
>>> 7/3.0
2.3333333333333335
Nota
A divisão por inteiro sempre1
retorna um inteiro.
1
Na versão 3.x este comportamento padrão foi alterado.

Tipos de Dados ▸ Strings
Em Python as strings podem ser declaradas utilizando aspas simples,
duplas ou uma sequência de de três aspas (simples ou duplas).
>>> "hello world"
’hello world’
>>> ’isn’t’
"isn’t"
>>> var_str = """my string"""
’my string’
>>> var_str = "linenbreak"
>>> var_str
’linenbrk’
>>> print var_str
line
brk

Tipos de Dados ▸ Strings II
As strings também podem ser concatenadas e indexadas:
>>> var_str = ’abc’ + ’def’
>>> var_str
’abcdef’
>>> var_str[2]
’c’
>>> var_str[0:2]
’ab’
>>> var_str[2:]
’cdef’
>>> var_str[-2:]
’ef’
A sintaxe var_str[0:2] é chamada de slicing em Python.

Tipos de Dados ▸ Strings III

Tipos de Dados ▸ Strings IV
Note que as strings em Python sao imutáveis, ou seja, qualquer
tentativa de tentar alterá-las irá gerar uma exception:
>>> minha_string = ’hello world’
>>> minha_string[0] = ’H’
Traceback (most recent call last):
File "<stdin>", line 1, in
TypeError: object does not support item assignment

Tipos de Dados ▸ Listas
As listas em Python podem conter diferentes tipos de dados:
# Criando uma nova lista
minha_lista = [1, 2.5, 5, ’string qualquer’]
Ao contrário das strings, listas são mutáveis, o que significa que uma
atribuição é naturalmente válida:
>>> minha_lista
[1, 2.5, 5, ’string qualquer’]
>>> minha_lista[0] = 666
>>> minha_lista
>>> len(minha_lista)
4

Tipos de Dados ▸ Listas ▸ Cópia
Veja o seguinte exemplo:
>>> minha_lista
>>> outra_lista = minha_lista
>>> outra_lista[0] = 666
>>> minha_lista

Tipos de Dados ▸ Listas ▸ Cópia
Veja o seguinte exemplo:
>>> minha_lista
>>> outra_lista = minha_lista
>>> minha_lista
Este comportamento é um efeito do fato de que as variáveis são nomes
para os objetos. Ao atribuir à variável outra_lista a lista
minha_lista, o interpretador utilizou o mesmo objeto minha_lista
ao invés de criar uma nova lista.

Tipos de Dados ▸ Listas ▸ Cópia II
O correto para criar uma nova lista (uma cópia) em Python é o
seguinte:
>>> minha_lista
>>> outra_lista = minha_lista[:]
>>> minha_lista
>>> outra_lista
Isto porque ao fazer slicing, o interpretador sempre cria uma nova lista.

Tipos de Dados ▸ Listas ▸ List Comprehensions
Em Python temos o conceito de List Comprehensions:
>>> lista = [’ab’, ’cd’]
>>> [x.upper() for x in lista]
[’AB’, ’CD’]
>>> lista = [1, 2, 100, 200]
>>> [x for x in lista if x < 100]
[1, 2]
>>> [x**2 for x in range(5)]
[0, 1, 4, 9, 16]
A compreensão é a
propriedade de classificação
em torno da qual se
reagruparão os “elementos”
que a ela correspondem.
Indica os pontos comuns a
determinados tipos de objetos.
A extensão é a própria coleção
desses objetos. (...) Tudo isto
é muito simples.
—Luc Ferry, Kant, Uma
leitura das três “Críticas”.

Tipos de Dados ▸ Dicionários
Um dicionário em Python é uma estrutura que define uma relação de
1 1 entre as respectivas chaves e valores.
# Definindo um dicionário
>>> meu_dicionario = {’nome’: ’Fulano’, ’idade’: 28}
# Acessando valores do dicionário usando as chaves
>>> meu_dicionario[’nome’]
’Fulano’
>>> meu_dicionario[’idade’]
28
# Apagando chaves/valores
>>> del meu_dicionario[’nome’]
# Atribuindo valores
>>> meu_dicionario[’altura’] = 1.72

Tipos de Dados ▸ Dicionários II
Alguns fatos importantes sobre dicionários em Python:
▸ Eles podem conter dados heterogêneos, você pode misturar
inteiros com strings, etc
▸ As chaves de um dicionário são case-sensitive
▸ Um dicionário vazio pode ser declarado como:
>>> meu_dicionario = {}
▸ Você pode limpar um dicionário usando o método clear():
>>> meu_dicionario.clear()
▸ Dicionários requerem que os tipos das chaves implementem um
método hash, reduzindo assim a complexidade de pesquisa em
um dicionário em O(1).

Tipos de Dados ▸ Tuplas
Tuplas não são nada mais do que listas imutáveis, ou seja, logo após
sua criação não se pode alterá-las sem criar uma nova tupla.
>>> minha_tupla = (’a’, ’b’, 2.5, 666)
>>> minha_tupla
(’a’, ’b’, 2.5, 666)
>>> minha_tupla[1]
’b’
>>> tup = (’um’, 2, 3)
>>> var_a, var_b, var_c = tup
>>> print var_a, var_b, var_c
um 2 3
Assim como em uma lista, elementos em uma tupla têm uma ordem e
o slicing também é possível.

Tipos de Dados ▸ Tuplas II
▸ Uma tupla tem um desempenho melhor que uma lista, use-a
quando a sua estrutura de dados não precisar ser alterada, ela
deixará o seu código mais legível e sem efeitos colaterais devido
ao fato de ser uma estrutura imutável.
▸ Tuplas podem ser convertidas em listas e vice-versa:
>>> minha_tupla = (1, 2, 3)
>>> list(minha_tupla)
[1, 2, 3]
>>> minha_lista = [1, 2, 3]
>>> tuple(minha_lista)
(1, 2, 3)

Tipos de Dados ▸ Conjuntos
Sets (ou conjuntos) seguem a definição matemática: são uma coleção
de elementos distintos, ou seja, uma coleção onde itens não se repetem.
Para definir um conjunto em Python usamos o tipo set:
# Usando uma lista
>>> conjunto = set([1, 2, 3, 1, 2, 3])
>>> conjunto
set([1, 2, 3])
# Notação usando chaves
>>> conjunto = {1, 2, 3, 1, 2, 3}
>>> conjunto
set([1, 2, 3])
Nota
A notação usando chaves foi incluída na versão 3.1 do Python e
posteriormente portada para a versão 2.7.

Tipos de Dados ▸ Conjuntos II
Os conjuntos também suportam algumas operações matemáticas:
>>> conj_a = {1, 2, 3}
>>> conj_b = {2, 3, 4}
# União
>>> conj_a.union(conj_b)
set([1, 2, 3, 4])
# Intersecção
>>> conj_a.intersection(conj_b)
set([2, 3])

Funções
Em Python, as funções são declaradas usando a palavra reservada def
(que significa definition). Exemplo da declaração de uma função que
fará a soma de dois parâmetros:
def soma(a, b):
return a+b
Note que Python utiliza espaços para delimitar os blocos do programa,
o número de espaços recomendado pelo guia de estilo oficial (PEP8)
são 4 espaços (sem TAB). Note também que a função soma() também
é um objeto:
>>> soma
<function soma at 0x022C78B0>
>>> soma(2,4)
6

Funções ▸ Argumentos Padronizados
Funções em Python, além de podermos usar parâmetros
padronizados, também podemos realizar chamadas para funções
nomeando parâmetros:
def adiciona_pessoa(nome, idade=28, sexo=’M’):
print nome, idade, sexo
>>> adiciona_pessoa(’christian’)
christian 28 M
>>> adiciona_pessoa(’laura’, sexo=’F’)
laura 28 F
>>> adiciona_pessoa(’pedro’, 12, ’M’)
pedro 12 M

Funções ▸ Lista de Argumentos Arbitrários
Uma função pode ser construída de forma que aceite uma lista de
tamanho arbitrário de argumentos:
def argumentos_arbitrarios(*args):
print ’Argumentos:’, args
# Exemplo de chamada
>>> argumentos_arbitrarios(’teste’, 1, 2.0, [1, 2, 3])
Argumentos: (’teste’, 1, 2.0, [1, 2, 3])
Nota
A lista de argumentos é enviada para a função no argumento args como uma
tupla.

Funções ▸ Argumentos palavra-chave
Quando o último argumento de uma função conter um parâmetro
prefixado com **, este parâmetro irá aceitar argumentos
palavra-chave:
def argumentos_arbitrarios(*args, **kwargs):
print ’Argumentos:’, args
print ’Argumentos palavra-chave:’, kwargs
# Exemplo de chamada
>>> argumentos_arbitrarios(’a’, ’b’, x=’one’, y=’two’)
Argumentos: (’a’, ’b’)
Argumentos palavra-chave: {’x’: ’one’, ’y’: ’two’}
Nota
A lista de argumentos palavra-chave enviados para o parâmetro kwargs está
no formato de um dicionário.

Funções ▸ Notas
Algumas notas importantes sobre funções:
▸ Todas funções retornam um valor, na ausência de return elas
retornarão None.
▸ A primeira linha após a definição de uma função pode ser uma
string, neste caso esta string representará a documentação da
função (chamada de docstring):
def soma(a,b):
"""Função de soma."""
return a+b
Nota
Existem algumas ferramentas (ex. Sphinx), que utilizam esta docstring para
gerar documentação automaticamente.

Funções ▸ Notas II
▸ Você também pode usar o comando help para obter a docstring e
a definição de uma função/método/classe:
def soma(a,b):
"""Função de soma."""
return a+b
# Obtendo help da função
>>> help(soma)
Help on function soma in module __main__:
soma(a, b)
Função de soma.

Funções Anônimas
Como Python adota também o paradigma funcional, você pode
também declarar funções anônimas usando a palavra reservada
lambda (λ), exemplo:
soma_b = lambda a,b: a+b
# Retornando uma função anônima
def soma_lambda(n):
return lambda v: v + n
>>> f = soma_lambda(3)
>>> f(4)
7
A definição de soma_b() é ilustrativa, pois obviamente não há
vantagem alguma em atribuir uma função lambda à uma variável, pois
estaríamos nomeando uma função anônima.

Controles de Fluxo ▸ If
>>> x = 20
>>> if x > 0:
... print "Maior que zero"
... elif x < 0:
... print "Menor que zero"
... else:
... print "Zero"
...
Maior que zero

Controles de Fluxo ▸ For
A palavra reservada for em Python pode iterar em itens de uma
sequência (uma lista, uma string, chaves de um dicionário, etc.):
>>> palavras = [’gato’, ’cachorro’]
>>> for p in palavras:
... print p, len(p)
gato 4
cachorro 8

Controles de Fluxo ▸ For II
Se for preciso iterar em uma sequência numérica, você pode utilizar a
função range(), que gera listas contendo progressões aritméticas:
>>> range(6)
[0, 1, 2, 3, 4, 5]
>>> for i in range(len(palavras)):
... print i, palavras[i]
0 gato
1 cachorro
Existe também outra função chamada xrange() que retorna um
generator ao invés de uma lista, eliminando desta forma a necessidade
da criação de uma lista, que pode ser um gargalo de performance para
iterações em progressões mais longas.

Controles de Fluxo ▸ For III
Entretanto uma solução pythonica para este problema seria usando a
função enumerate():
>>> list(enumerate(palavras))
[(0, ’gato’), (1, ’cachorro’)]
>>> for i,p in enumerate(palavras):
... print i,p
0 gato
1 cachorro

Orientação a Objetos
Python também suporta Orientação a Objetos e contém mecanismos
para criação de classes, herança (múltipla), sobrescrita de métodos
(definidos pelo usuário ou de operadores matemáticos, etc.).
Explícito é melhor que
implícito.
—The Zen of Python,
Tim Peters, 2004.

Orientação a Objetos ▸ Classes
Em Python, as classes são definidas utilizando a palavra reservada
class, um exemplo simples da definição e instanciação de uma classe
pode ser definido como:
class MinhaClasse(object):
pass
# Instanciando um objeto
>>> objeto = MinhaClasse()

Orientação a Objetos ▸ Construtor
Para declarar o construtor de uma classe em Python, utilizamos o
método mágico __init__():
def __init__(self):
pass

Orientação a Objetos ▸ Atributos de Classe
Atributos de classe são atributos compartilhados entre todas instâncias
da classe:
atributo_classe = 10
# Acessível através da classe
>>> print MinhaClasse.atributo_classe
10
# Acessível também através dos objetos da classe
>>> objeto = MinhaClasse()
>>> print objeto.atributo_classe
10

Orientação a Objetos ▸ Atributos de Instância
Atributos de instância são atributos únicos para cada objeto
instanciado e só existem dentro do objeto:
def __init__(self, valor):
self.valor = valor
>>> objeto = MinhaClasse(300)
>>> print objeto.valor
300
>>> print MinhaClasse.valor
Traceback (most recent call last):
File "<stdin>", line 1, in <module>
AttributeError: type object ’MinhaClasse’
has no attribute ’valor’

Orientação a Objetos ▸ Herança Simples
Em Python podemos ter herança simples:
class ClasseBase(object):
def nome(self):
print ’Sou ClasseBase !’
def base(self):
print ’Método da ClasseBase !’
class ClasseDerivada(ClasseBase):
def nome(self):
print ’Sou ClasseDerivada !’
>>> base = ClasseBase()
>>> derivada = ClasseDerivada()
>>> base.nome()
Sou ClasseBase !
>>> derivada.nome()
Sou ClasseDerivada !
>>> derivada.base()
Método da ClasseBase !

Orientação a Objetos ▸ Herança Múltipla
E também herança múltipla:
class ClasseA(object):
def metodo_a(self):
print ’metodo_a !’
class ClasseB(object):
def metodo_b(self):
print ’metodo_b !’
class ClasseC(ClasseA, ClasseB):
pass
>>> obj = ClasseC()
>>> obj.metodo_a()
metodo_a !
>>> obj.metodo_b()
metodo_b !

Orientação a Objetos ▸ Métodos da Classe Base
Ao sobrescrever um método da classe base, muitas vezes precisamos
reutilizar o comportamento da classe base no método derivado:
class ClasseBase(object):
def metodo(self):
print ’Metodo da ClasseBase !’
class ClasseDerivada(ClasseBase):
def metodo(self):
super(ClasseDerivada, self).metodo()
print ’Metodo da ClasseDerivada !’
>>> obj = ClasseDerivada()
>>> obj.metodo()
Metodo da ClasseBase !
Metodo da ClasseDerivada !

Orientação a Objetos ▸ Encapsulamento
Em Python não há um conceito de atributos privados como há em
outras linguagens. Python encoraja os desenvolvedores a serem
responsáveis.

Orientação a Objetos ▸ Encapsulamento II
▸ Um método que inicia com o caractere ’_’ indica que o método é
um método não-público da API e que pode ser alterado no
futuro sem aviso, exemplo:
def _metodo_interno(self):
pass # (...) implementação

Orientação a Objetos ▸ Encapsulamento II
▸ Um método que inicia com o caractere ’_’ indica que o método é
um método não-público da API e que pode ser alterado no
futuro sem aviso, exemplo:
def _metodo_interno(self):
▸ O interpretador utiliza name mangling quando o nome do
método inicia com dois caracteres ’__’ (e acaba com no máximo
um caractere ’_’ ), exemplo:
def __metodo_interno(self):
No exemplo acima, o método __metodo_interno() tem seu
nome alterado para _MinhaClasse__metodo_interno().

Decorators
Decorators permitem a injeção ou modificação de código em funções
ou classes. A sua aplicação se dá através da seguinte construção:
# Em funções
@decorator
def minha_funcao():
pass
# Em classes
@decorator
class MinhaClasse():
pass
# Exemplo útil (Django):
@permission_required(’poll.can_vote’)
def poll_vote(request):

Decorators II
Exemplo de decorator para medir o tempo de execução de uma função:
def mensura_tempo(func):
def func_wrapper(*args):
inicio = time.clock()
resultado = func(*args)
fim = time.clock()
print ’Tempo: ’, fim-inicio
return resultado
return func_wrapper
@mensura_tempo
def teste():
time.sleep(3)
>>> teste()
Tempo: 2.99953640673

Exceções ▸ Tratamento de Exceções
Como em outras linguagens, Python também oferece tratamento de
erros em tempo de execução, denominados Exceptions, ou Exceções.
O tratamento destes erros é realizado através de blocos utilizando as
palavras-chaves try e except:
meu_dicionario = {’chave_a’: 1, ’chave_b’: 2}
try:
print meu_dicionario[’chave_c’]
except KeyError:
print ’Chave não encontrada !’

Exceções ▸ Levantando Exceções
Para levantar exceções em Python, a palavra reservada raise deve ser
utilizada:
def verifica_numero_primo(numero):
if numero < 0:
raise ValueError(’O valor deve ser maior ’
’ou igual a zero !’)
# (...)
No caso acima, uma exceção built-in ValueError será levantada. Você
também pode criar classes de exceções próprias criando classes que
herdam da classe nativa Exception.

Métodos Mágicos
Métodos mágicos são métodos especiais para implementar protocolos,
sobrescrever operadores, etc. Eles seguem sempre o mesmo formato:
com dois underscores antes e depois do nome do método, como por
exemplo __init__().
class MeuDicionario(object):
def __init__(self):
self.dicionario = {}
def __getitem__(self, key):
return self.dicionario[key]
def __setitem__(self, chave, valor):
self.dicionario[chave] = valor
>>> dicionario = MeuDicionario()
>>> dicionario[’chave’] = 100
>>> print dicionario[’chave’]
100

Propriedades
Propriedades em Python são uma forma de criar getters/setters
flexíveis de forma que a sintaxe ainda continue elegante. Considere o
exemplo abaixo:
class Circulo(object):
def __init__(self, raio):
self.raio = raio
O que acontece se quisermos criar um atributo que contenha sempre a
área do círculo (π ∗ r2
) ? Poderíamos criar um método em separado
para calcular e retornar esta área ou então criar um atributo que é
calculado na execução do construtor; entretanto em Python existe
uma forma mais elegante de se resolver este problema.

Propriedades ▸ Getter
import math
self._raio = raio
@property
def area(self):
return math.pi * self._raio**2
>>> circulo = Circulo(2)
print circulo.area
12.5663706144

Propriedades ▸ Setter
import math
self.raio = raio
@property
def area(self):
return math.pi * self.raio**2
@area.setter
def area(self, area):
self.raio = math.sqrt(area/math.pi)
>>> circulo = Circulo(2)
>>> print circulo.raio
2
>>> circulo.area = 40
>>> print circulo.raio
3.56824823231

Módulos e Pacotes ▸ Módulo
Qualquer arquivo arquivo contendo código-fonte Python é chamado
de Módulo. Um módulo pode ser importado por outros módulos, de
forma que as classes, funções, variáveis globais e outros objetos deste
módulo possam ser acessados por outro módulo. A sintaxe para
importação de um módulo é feita através do importação utilizando a
palavra reservada import:
# Arquivo minhas_funcoes.py
def fibonacci(n):
if n == 0:
return 0
if n == 1:
return 1
return fibonacci(n-1) + fibonacci(n-2)
# Arquivo usa_modulo.py
import minhas_funcoes
resultado = minhas_funcoes.fibonacci(8)

Módulos e Pacotes ▸ Módulo II
Você também pode importar objetos específicos diretamente para o
namespace atual:
# Importa todas funções (má prática)
from minhas_funcoes import *
resultado = fibonacci(8)
# Importa apenas a função soma (boa prática)
from minhas_funcoes import fibonacci
resultado = fibonacci(8)
# Importa módulo usando outro nome
import minhas_funcoes as mf
resultado = mf.fibonacci(2, 3)

Módulos e Pacotes ▸ Pacote
Um pacote em Python não é nada além de uma estrutura de diretório
contendo módulos. Juntamente com o conceito de módulos, os
pacotes são uma maneira eficaz de estruturar e organizar os módulos e
evitar a poluição de namespaces. Exemplo da estrutura de um pacote:
frontend/
__init__.py
desktop/
__init__.py
modulo_a.py
web/
__init__.py
modulo_b.py
# Importando modulo ’modulo_a’
>>> from frontend.desktop import modulo_a
>>> modulo_a.funcao()

Dúvidas ?
Junte-se ao PyTchê ! Acesse http://pytche.org

Python - Introdução Básica

Mais conteúdo relacionado

Mais procurados (20)

Destaque (20)

Semelhante a Python - Introdução Básica (20)

Mais de Christian Perone (7)

Último (19)

Python - Introdução Básica