Este é um mini-curso básico de Python. Já foi aplicado na Semana de tecnologia de Universidade Católica e no encontro de tecnologia de Especializa (ZCon).

1. Mini-curso PythonMini-curso Python
Rodrigo Peixoto - rodrigopex@gmail.com
04/11/2008 - 06/11/2008

2. Quem sou eu!?Quem sou eu!?

Engenheiro da Computação – UFPE(2008)

Especialista em Python e Verilog

Usuário Linux desde 2004

Membro admistrador do CinLUG

“Instrutor” de Python pela Especializa

Entusiasta de software livre

Trabalho num projeto para o Governo Federal

3. O que é Python?O que é Python?

Linguagem de alto nível de abstração

Criada por Guido van Rossum em 1991

Linguagem multiparadigma

Orientada a Objetos

Estrutural

Funcional

Possui sintaxe simples e clara

Tipagem forte e dinâmica

4. O que é Python?O que é Python?

Multiplataforma

Interpretada (bytecodes)

Possui ambiente interativo

Biblioteca padrão muito rica

Ótima integração com Linux

Facilmente extensível (C/C++, Java, .NET)

Gnu Public License

5. QuemusaPython?QuemusaPython?
TIOBEIndexTIOBEIndex

6. Quem usa python?Quem usa python?

7. Quem usa Python?Quem usa Python?

8. Python é usado em muitos outrosPython é usado em muitos outros
lugareslugareswww.brasil.gov.br

9. No BrasilNo Brasil

Câmara dos deputados

Presidência da República

Carta na Escola

SEBRAE

CertiSign

SERPRO

INdT

Universidade Metodista

UNESCO Brasil

OAB/SP

Varig

Politec

10. Por que usar Python?Por que usar Python?

Segundo Guido Van Rossum em[4]

Tempo de desenvolvimento reduzido

2 a 10 vezes menor que C/C++ e Java

Código extremamente legível

Pouco treinamento

Linguagem muito simples de aprender

Segundo minhas experiências e pesquisas

Fácil de estender C/C++, Java e .NET

Ótimo para manipulação de Strings

11. Por que usar Python?Por que usar Python?

Muito bom para programação WEB

Integração harmoniosa com o Linux

Biblioteca para as mais variadas áreas

Máquina virtual pequena (Download rápido)

Poderosa (multiparadigma)

O programador vai direto ao ponto. Foca no
problema e não:

Na alocação de memória

Tipo de variáveis

...

12. Por que não usar Python?Por que não usar Python?

IDEs free não muito completas

Desempenho relativamente baixo

Necessidade de bom senso, liberdade ao
extremo

13. O que pode ser feito com Python?O que pode ser feito com Python?

““Basicamente”Basicamente” tudo que pode ser feito em:

Java

C/C++

Haskell

PHP

GUI, Cálculo numérico, Banco de dados, Jogos,
WEB, Mobile, Computação gráfica, ...

14. Python bibliotecasPython bibliotecas

Numpy (c culo num rico)á é

Elixir + SQLAchemy (banco de dados)

Multiprocessing (multiprocessamento)

Pyre (computa o high performance)çã

Pyro (remote objects)

PyS60 (mobile)

PyGame (jogos)

PyUnit (testes unit rios)á

15. Versões de PythonVersões de Python

Cython e Pyrex

Integração com C/C++ (High performance!!!)(High performance!!!)

Jython

Integração com o ambiente Java

IronPython

Integração com o ambiente .NET

16. Caminho para o básicoCaminho para o básico

Shell

Hello World!

Code design

Números

Iteráveis

String

Tuplas

Lista

Dicionários

Entrada e saída

open

print

Expressões

Comandos básicos

Funções

Exceções

Exercícios

17. Shell PythonShell Python

Python possui um shell interativo onde pode-se
executar comandos on-the-fly

Basta executar

$>python

Introspeção e reflexão (são propriedades de sistemas orientados a
objetos que qualificam a existência de mecanismos para descobrir e alterar, em tempo de
execução, informações estruturais sobre um programa e objetos existentes neste)

dir(objeto)

help(objeto)

18. Hello WorldHello World
︅
Abra o terminal Python e digite
→ print “Hello World”
'Hello World'

19. Code designCode design
︅
Nada de ';' no fim das linhas
︅
Nada de '{' e '}' para delimitar blocos
︅
Nada de declarações de tipo de variáveis
︅
Identar é obrigatório!
︅
Padrão de codificação para a linguagem (PEP8)
︅
Códigos mais limpos e organizados!Códigos mais limpos e organizados!

20. NúmerosNúmeros
︅
Inteiros - int()
→ a = 10
→ print a
10
→ 10 + 20
30
→ 10**2
100
︅
Longos - long()
→ B = 10L
→ C =
1000000000000000000
0000000000000000000
0000000000000000000
0000000000000000000
0000000000000000000
0000000000000000000
0000000000000000000
0000000000000000000
0000000000000000000
000000000000000000L

21. Números(2)Números(2)
︅
Float - float()
→ A = 2.3
→ B = 7.66778
→ print int(B)
7
︅
Complexos – complex()
→ C = 3 + 2j
→ C1 = complex(3,2)
→ print c.conjugate()
(3-2j)
→ print c.imag
3.0
→ print c.real
2.0

22. StringsStrings
︅
Construtor – str()
→ print str(4.556)
'4.556'
︅
Métodos
→ “teste”.upper()
“TESTE”
→ “teste”.title()
“Teste”
→ “12345”.split(“3”)
['12','45']
︅
Acesso
→ “teste”[2]
's'
→ “abcd”[-1]
'd'
→ “abcd”[1:]
'bcd'
︅
Concatenação
→ “tes” + “te”
'teste'

23. Strings(2)Strings(2)
︅
Multiplicação
→ “1”*4
'1111'
︅
Métodos principais digite
dir(“”) no shell
︅
Exemplos
→ C =“Uma string de
teste para uso do
split”.split()
['Uma', 'string',
'de', 'teste',
'para', 'uso',
'do', 'split']

24. TuplasTuplas

Homogêneas

Imutáveis

Construtor – tuple()

Pode ser acessada como um iterável

25. Tuplas(2)Tuplas(2)
︅
Construção
→ a = (1,2,3,4)
→ print a
'(1, 2, 3, 4)'
→ b = tuple([1,2,3])
→ print b
(1,2,3)
︅
Acesso
→ (“test”,“one”)[1]
(“one”)
→ (1,2,3,4,5)[:2]
(1,2)

26. ListasListas

Heterogêneas

Mutáveis

Construtor – list()

Pode ser acessada como um iterável

27. Listas(2)Listas(2)
︅
Construcão
→ a = [1,2,3,4]
→ a
'[1, 2, 3, 4]'
→ b = list(tuple(a))
→ print b
'[1, 2, 3, 4]'
︅
Acesso
→ [1,'foi',3.3][:]
[1,'foi',3.3]
→ [1,'foi',3.3][1]
'foi'

28. Listas(3)Listas(3)
︅
Métodos
→ a = [1,2,3]
→ a.append(4)
→ a.pop()
→ a.sort()
︅
Para maiores detalhes
digite dir([])
︅
Auxiliares
→ max(a)
→ min(a)
→ range(6)
[0,1,2,3,4,5]
→ sum([2,3,4])
9

29. DicionáriosDicionários

Tabela hash como tipo primitivo de Python

Acesso mais rápido

“Lista de referências”

Heterogêneo

Mutável

Associações chave <-> valor

30. Dicionários(2)Dicionários(2)
︅
Construção
→ D = {'te':2,6:3.45}
→ E = dict([(1,2),
(3,'texto')])
→ print E
“{1:2, 3:'texto'}”
︅
Acesso
→ D['te']
2
→ E[3]
'texto'
→ del D[6]
→ print D
“{'te':2}”

31. Dicionários(3)Dicionários(3)
︅
Métodos
→ D.keys()
['te']
→ D.values()
2
→ D.has_key('te')
True
︅
Inserção
→ D['nova_chave']= 3
→ D.update({'nova_cha
ve':4})

32. EntradaEntrada
︅
Texto
→ res =
input('pergunta')
→ st =
raw_input('Pergunta
')
︅
Exemplo
→ um_mais_um =
input('digite 1+1')
→ print um_mais_um
2
→ nome =
raw_input(“seu
nome”)
→ print nome
→ ...
︅
Arquivo
→ f =
open('path','modo')
→ open.read()
→ open.readlines()
→ ...

33. SaídaSaída
︅
Função print
praticamente igual ao
printf de C
→ print “nome”
'nome'
→ print “%s:%d” %
(“Idade”,25)
'Idade:25'
︅
Procure na quick ref mais
detalhes
︅
Escrita em arquivo
→ f =
open(“path”,'modo')
→ f.write()
︅
Ou
→ f.writelines(lista)
→ ...

34. ExpressõesExpressões
︅
Booleanas
→ ==, !=, >, <,...
→ is, in, not, and,
or,...
→ 1 == 2
False
→ “te” in “teste”
True
→ “te” is 0
False
︅
Numéricas
→ +, -, *, /, //, **,
%, divmod,...
→ 1 + 2
3
→ 2**5
32
→ divmod(35,8)
(4,3)

35. ComandosComandos
︅
IF .. ELIF .. ELSE ︅
Mini - if
if exp:
<comandos>
elif exp2:
<comandos>
else:
<comandos>
var = ret1 if exp else ret2
var = exp and ret1 or ret2

36. Comandos(2)Comandos(2)
︅
While ︅
For
while exp:
<comandos>
for i in iterable:
<comandos>
while exp:
<comandos>
else:
<comandos>
for i in iterable:
<comandos>
else:
<comandos>

37. FunçõesFunções

Todas polimórficas

Não dá suporte a sobrecarga de método ou
função

Não é precisa declarar o retorno

Podem ter parâmetros:

Número arbitrário

Keywords

Número arbitrário de keywords

Permite valores default

38. Funções(2)Funções(2)
︅
Exemplos
︅
Comando de retorno
def func(a):
<comandos>
def func(a=2):
<comandos>
def func(a,b=3,c=5):
<comandos>
def func(*a):
<comandos>
def func(**kw):
<comandos>
def func_all(a,b=2,*args, **kwargs):
<comandos>
def soma(a, b):
return a + b

39. ExceçõesExceções
︅
Captura
︅
Reenvio
︅
Lancamento
︅
Criando
try:
<comandos>
except:
<comandos>
else:
<comandos>
finally:
<comandos>
raise “Texto”
raise Exception
raise Exception(“Text”)
class MinhaExcecao(Exception):
'''
Documentacao da excecao
'''
passtry:
<comandos>
except:
raise

40. Dicas para exercícioDicas para exercício
︅
Para executar um código
feito em python basta
executar o comando
→ python meu_mod.py
︅
Todo código fonte Python
tem a extensão .py
︅
A função main de Python
if __name__ == '__main__':
<comandos>

41. Mais dicas para o exercícioMais dicas para o exercício
︅
Um código exemplo feito Python seria
def func(a,b):
return a + b
if __name__ == '__main__':
print func(10,30)

42. Exercícios 1Exercícios 1
︅
Desenvolva uma calculadora com as seguinte
operações:
→ Soma
→ Subtração
→ Multiplicação
→ Divisão
︅
O usuário tem que digitar os valores na linha de
comando.

43. Exercício 2Exercício 2
︅
Copie o primeiro parágrafo da página no link abaixo
para um arquivo chamado python_wiki.txt.
Recupere o texto do arquivo e conte quantas
vogais, quantas palavras que iniciam com p e
quantas palavras 'python' existem. Armazene o
resultado num arquivo com o seguinte formato:
→ http://en.wikipedia.org/wiki/Python_programm
ing_language
Contador mini-curso python!
Site: link do site
Vogais: qtd
Palavras iniciadas com p: qtd
Python: qtd

44. Importando módulosImportando módulos
︅
Básico
︅
︅
︅
Importando de...
︅
︅
︅
Importando tudo de um módulo
import modulo
import modules.sub_modulo as novo_nome
from modulo import algo
from modules.sub_modulo import Algo
from modules.sub_modulo import Algo as AL
from modulo import *
from modules.sub_modulo.sub_sub_modulo import *

45. SocketSocket
︅
Comunicação via rede entre Cliente <> Servidor
︅
︅
Cliente
import socket
HOST = '' # Symbolic name meaning the local host
PORT = 50007 # Arbitrary non-privileged port
sock = socket.socket( socket.AF_INET, socket.SOCK_STREAM)
sock.connect((HOST, PORT))
print "from server:", sock.recv(1024)
sock.send("Sim")

46. Socket(2)Socket(2)
︅
Servidor
import socket
HOST = '' # Symbolic name meaning the local host
PORT = 50007 # Arbitrary non-privileged port
s = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
s.setsockopt(socket.SOL_SOCKET, socket.SO_REUSEADDR, 1)
s.bind((HOST, PORT))
s.listen(1)
print "Waiting for connections..."
conn, addr = s.accept()
print 'Connected by', addr
conn.send("Alguem aih?")
print "from cliente:", conn.recv(1024)

47. ThreadsThreads
︅
Divisões internas de esforço em um processo
︅
Várias tarefas ao mesmo tempo
︅
import threading
def func(c):
<comandos>
th = threading.Thread(target=func, args=func_args)
th.start()

48. Threads(2)Threads(2)
︅
Exemplo
import threading
from time import sleep
from random import random
def func(c):
for i in range(10):
t = random()
print c
sleep(t)
th1 = threading.Thread(target=func, args=("th1 -----",))
th2 = threading.Thread(target=func, args=("th2 =====",))
th3 = threading.Thread(target=func, args=("th3 #####",))
th1.start()
th2.start()
th3.start()

49. Threads(3)Threads(3)
import threading
from time import sleep
from random import random
#Algo místico!
def threaded(func):
def proxy(*args, **kwargs):
th = threading.Thread(target=func, args=args, kwargs=kwargs)
th.start()
return th
return proxy
@threaded
def func(c):
for i in range(10):
t = random()
print c
sleep(t)
func("th1 -----")
func("th2 =====")
func("th3 #####")

50. PersistPersistêênciancia

Armazenamento "eterno" de dados [wikipédia]

Os arquivos passam a ser armazenados em
memórias não voláteis

Quando um aplicativo é fechado, se tivermos
não tivermos nada persistido, tudo será perdido

Python tem várias soluções

Escrita em arquivo tradicional

Shelve

Banco de dados

...

51. PersistPersistêência(2)ncia(2)
import shelve
d = shelve.open("nossodb",writeback=True)
print "store Teste de string"
d["i1"] = "Teste de string"
print "store 10L"
d["i2"] = 10L
print "store 3.225567"
d["i3"] = 3.225567
d.close()
import shelve
d = shelve.open("nossodb",writeback=True)
print "load", d["i1"]
print "load", d["i2"]
print "load", d["i3"]
d.close()

52. ReferReferêênciasncias

http://www.scribd.com/doc/6181632/Mini-Curso-de-

www.python.org

http://rgruet.free.fr/PQR25/PQR2.5.html