1. Introdução à linguagem
de programação Python
Diego Manenti Martins
dmmartins@gmail.com
1

2. O que é Python
• Intuitiva
• Múltiplos paradígmas (estruturado, OO,
funcional)
• Interpretado (bytecode)
• Tipagem dinâmica
• Multiplataforma
• Baterias Inclusas
• Criada por Guido van Rossum
2

3. O Interpretador
mufasa:~ diego$ python
Python 2.6.1 (r261:67515, Aug 2 2010, 20:10:18)
[GCC 4.2.1 (Apple Inc. build 5646)] on darwin
Type "help", "copyright", "credits" or "license" for
more information.
>>> print 'Hello world!'
Hello world!
>>>
3

4. Hello world
#!/usr/bin/env python
# -*- coding: utf-8 -*-
print 'Hello world!'
4

5. Variáveis e Tipos
• Tipagem dinâmica
>>> a = 123
>>> type(a)
<type 'int'>
>>> a = 'DojoTuba'
>>> type(a)
<type 'str'>
• Tipos nativos
• float, inteiro, números complexos, string, tupla, lista,
dicionario, set, etc
5

6. Variáveis e tipos
>>> texto1 = 'um texto'
>>> texto2 = "outro texto"
>>> inteiro = 123
>>> real = 1.23
>>> real2 = 1.23e6 # 1.23 * 10^6
>>> lista = [1, 2, 'teste', real, inteiro]
>>> print 'lista = ', lista
lista = [1, 2, 'teste', 1.23, 123]
>>> tupla = (1, 2, 'teste', real, inteiro)
>>> tupla
(1, 2, 'teste', 1.23, 123)
6

7. Variáveis e tipos
>>> lista
[1, 2, 'teste', 1.23, 123]
>>> lista[0]
1
>>> lista[4]
123
>>> lista[-1]
123
>>> lista[-2]
1.23
7

8. Variáveis e tipos
>>> lista
[1, 2, 'teste', 1.23, 123]
>>> lista[1:3]
[2, 'teste']
>>> lista[1:]
[2, 'teste', 1.23, 123]
>>> lista[:4]
[1, 2, 'teste', 1.23]
>>> lista[-4:-2]
[2, 'teste']
8

9. Variáveis e tipos
>>> dicionario = {'chave': 'valor',
'chave2': 123, 123: lista, real: 'real'}
>>> dicionario
{'chave': 'valor', 123: [1, 2, 'teste',
1.23, 123], 'chave2': 123, 1.23: 'real'}
>>> dicionario['chave']
'valor'
>>> dicionario[123]
[1, 2, 'teste', 1.23, 123]
9

10. Variáveis e tipos
>>> a = 123
>>> b = 1.23
>>> print 'a = %d' % a
a = 123
>>> print 'b = %f' % b
b = 1.230000
>>> print 'a = %d, b = %f' % (a, b)
a = 123, b = 1.230000
>>> valores = {'c1': 123, 'c2': 1.23, 'c3': 'um
texto'}
>>> print 'a = %(c1)d, b = %(c2)f, c = %(c3)s' %
valores
a = 123, b = 1.230000, c = um texto
10

11. Condicionais
>>> if a == 1 and b == 2:
... print 'a = 1 e b = 2'
... elif a == 2 or not b == 2:
... print 'a = 2 ou b != 2'
... elif a in [1, 2, 3]:
... print 'a = 1 ou a = 2 ou a = 3'
... else:
... print 'nao deu!'
>>> c = 1 if a == 2 else 2
11

12. Laços
>>> frutas = ['banana', 'maca', 'uva']
>>>
>>> for fruta in frutas:
... print fruta
...
banana
maca
uva
>>> # nao faca isso
>>> for i in range(len(frutas)):
... print frutas[i]
...
banana
maca
uva
12

13. Laços
>>> i = 0
>>> while i < 10:
... print i
... i += 1
...
0
1
2
3
4
5
6
7
8
9
13

14. Laços?
>>> # Múltiplos de 3 de 0 a 100
... # usando list compression
... m = [x for x in range(100) if x % 3 == 0]
>>> m
[0, 3, 6, 9, 12, 15, 18, 21, 24, 27, 30, 33,
36, 39, 42, 45, 48, 51, 54, 57, 60, 63, 66,
69, 72, 75, 78, 81, 84, 87, 90, 93, 96, 99]
14

15. Funções
>>> def fatorial(n):
... ''' Funcao recursiva que retorna n! '''
... if n > 1:
... return n * fatorial(n - 1)
... else:
... return 1
...
>>> help(fatorial)
Help on function fatorial in module __main__:
fatorial(n)
Funcao recursiva que retorna n!
(END) 15

16. Funções
>>> fatorial(255)
335085068493297911765266512375481494202258406359174
070257677988428620879903573277100562613812676331425
928080211850228244592655013552225185672769253319307
041281108333032565932204170002979216625073425339051
375446604571124033846270103402026299258137842314727
663664364715539630535254110554143943484010991506828
543067506859163858198060416294038335658673919826878
210492461407660579356286524198217620742862096977680
314946743138680797243824768915865600000000000000000
0000000000000000000000000000000000000000000000L
16

17. Funções
>>> # Funções com argumentos com valores padrão
... def potencia(a, b=2):
... ''' Retorna a elevado na potencia b '''
... return a ** b
...
>>> potencia(3) # 3 ^ 2 (argumento padrao)
9
>>> potencia(3, 3) # 3 ^ 3
27
>>> # Passagem de argumentos especificos
... def f(a, b=2, c=3, d=4):
... return a + b + c + d
...
>>> f(2, d=9)
16
17

18. Funções
>>> # Função com número variável de argumentos
... def f(*args):
... for arg in args:
... print arg
...
>>> f(1, 2, 3)
1
2
3
18

19. Funções
>>> # Função com número variável de argumentos
nomeados
... def f(**kwargs):
... for kw in kwargs:
... print '%s=%s' % (kw, kwargs[kw])
...
>>> f(a=1, b=2, c='teste')
a=1
c=teste
b=2
19

20. Classes
>>> class Pessoa(object):
... ''' Classe pessoa. '''
... # Construtor
... def __init__(self, nome='', idade=0):
... self.nome = nome
... self.idade = idade
...
>>> p = Pessoa()
>>> p.nome = 'Joao Pessoa'
>>> p.idade = 150
>>> p.nome
'Joao Pessoa'
>>> p.idade
150
20

21. Classes
>>> dojo = Pessoa('DojoTuba', 5)
>>> joao = Pessoa(nome='Joao', idade=56)
>>> dojo.nome
'DojoTuba'
>>> dojo.idade
5
>>> joao.idade
56
>>> joao.idade = 57
>>> joao.idade
57
21

22. Classes
>>> class Pessoa(object):
... # Funcao privada
... def __get_idade(self):
... return self.__idade
... # Funcao privada
... def __set_idade(self, idade):
... if idade < 0:
... raise ValueError('Idade negativa, tem certeza?')
... elif not type(idade) == int:
... raise TypeError('A idade precisa ser um inteiro!')
... else:
... self.__idade = idade
...
... idade = property(__get_idade, __set_idade)
22

23. Classes
... # Construtor
... def __init__(self, nome='', idade=0):
... self.nome = nome
... try:
... self.__set_idade(idade) # Atributo privado
... except TypeError:
... self.__set_idade(0)
... except ValueError:
... self.__set_idade(0)
...
>>> joao.idade = 'teste'
Traceback (most recent call last):
File "<stdin>", line 1, in <module>
File "<stdin>", line 21, in __set_idade
TypeError: A idade precisa ser um inteiro!
>>> joao.idade = 58
>>> joao.idade
58
23

24. Classes
>>> class Animal(object):
... def falar(self):
... print 'Nao falo!'
...
... def andar(self):
... print 'Estou andando.'
...
>>> class Cachorro(Animal):
... def falar(self):
... print 'Au!'
...
24

25. Classes
>>> a = Animal()
>>> a.falar()
Nao falo!
>>> a.andar()
Estou andando.
>>> c = Cachorro()
>>> c.andar()
Estou andando.
>>> c.falar()
Au!
25

26. Classes
>>> class Homem(object):
... def andar(self):
... print 'Estou andando'
...
>>> class Morcego(object):
... def voar(self):
... print 'Estou voando'
...
>>> class Batman(Homem, Morcego):
... pass
...
>>> b = Batman()
>>> b.andar()
Estou andando
>>> b.voar()
Estou voando
26

27. Módulos
mufasa:~ diego$ cat > hello.py
#!/usr/bin/env python
#-*- coding: utf-8 -*-
def hello(nome):
return 'Hello %s!' % nome
mufasa:~ diego$ python
Python 2.6.1 (r261:67515, Aug 2 2010, 20:10:18)
[GCC 4.2.1 (Apple Inc. build 5646)] on darwin
Type "help", "copyright", "credits" or "license" for more information.
>>> import hello
>>> hello.hello('World!')
'Hello World!!'
27

28. Testando
#!/usr/bin/env python
#-*- coding: utf-8 -*-
import hello
import unittest
class HelloTestCase(unittest.TestCase):
def test_hello_diego(self):
self.assertEqual('Hello diego!', hello.hello('diego'))
def test_hello_world(self):
self.assertEqual('Hello world!', hello.hello('world'))
def test_hello_erro(self):
self.assertEqual('Hello world!', hello.hello('World'))
if __name__ == '__main__':
unittest.main()
28

29. Testando
mufasa:~ diego$ python hellotest.py
.F.
======================================================
================
FAIL: test_hello_erro (__main__.HelloTest)
----------------------------------------------------------------------
Traceback (most recent call last):
File "hellotest.py", line 15, in test_hello_erro
self.assertEqual('Hello world!', hello.hello('World'))
AssertionError: 'Hello world!' != 'Hello World!'
----------------------------------------------------------------------
Ran 3 tests in 0.000s
FAILED (failures=1)
mufasa:~ diego$
29

30. Testando
>>> import unittest
>>> dir(unittest.TestCase)
['__call__', '__class__', '__delattr__', '__dict__', '__doc__', '__eq__', '__format__',
'__getattribute__', '__hash__', '__init__', '__module__', '__ne__', '__new__', '__reduce__',
'__reduce_ex__', '__repr__', '__setattr__', '__sizeof__', '__str__', '__subclasshook__',
'__weakref__', '_exc_info', 'assertAlmostEqual', 'assertAlmostEquals', 'assertEqual',
'assertEquals', 'assertFalse', 'assertNotAlmostEqual', 'assertNotAlmostEquals',
'assertNotEqual', 'assertNotEquals', 'assertRaises', 'assertTrue', 'assert_', 'countTestCases',
'debug', 'defaultTestResult', 'fail', 'failIf', 'failIfAlmostEqual', 'failIfEqual', 'failUnless',
'failUnlessAlmostEqual', 'failUnlessEqual', 'failUnlessRaises', 'failureException', 'id', 'run',
'setUp', 'shortDescription', 'tearDown']
30

31. import this
• Bonito é melhor que feio.
• Explícito é melhor que implícito.
• Simples é melhor que complexo.
• Complexo é melhor que complicado.
• Plano é melhor que aninhado.
• Esparso é melhor que denso.
• Legibilidade conta.
31

32. import this
• Casos especiais não são especiais o bastante para se
quebrar as regras.
• Embora a simplicidade supere o purismo. Erros
nunca deveriam passar silenciosamente. A menos
que explicitamente silenciados.
• Ao encarar a ambiguidade, recuse a tentação de
adivinhar.
• Deve haver uma – e preferencialmente apenas uma
– maneira óbvia de se fazer isto.
• Embora aquela maneira possa não ser óbvia à
primeira vista se você não for holandês.
32

33. import this
• Agora é melhor que nunca.
• Embora nunca, seja muitas vezes melhor que pra já.
• Se a implementação é difícil de explicar, é uma má
idéia.
• Se a implementação é fácil de explicar, pode ser uma
boa idéia.
• Namespaces são uma idéia estupenda – vamos fazer
mais deles!
33