Por que Python? Vamos Conhecer? Vamos Aprender?

Juliano Atanazio
Por que Python?Por que Python?

2/53
About me
Juliano Atanazio
● Graduated in Computer Science for Business Management (Informática para Gestão de
Negócios), FATEC Zona Sul, São Paulo – SP;
● PostgreSQL DBA;
● Linux admin;
● Instructor (PostgreSQL);
● LPIC-1, LPIC-2 Certified;
● Linux user since 2000;
● Free Software enthusiast;
● Favorite technologies: PostgreSQL, Linux, Python, Shell Script, FreeBSD, etc...;
● Headbanger :) m/

3/53
Sobre Python
● Linguagem de programação criada pelo programador holandês
Guido van Rossum em 1991, no Instituto de Pesquisa Nacional
para Matemática e Ciência da Computação de Amsterdam.
● Seu nome foi inspirado no grupo humorístico britânico Monty
Python's Flying Circus;
● Tem comunidade forte e solícita :) ;
● Software Livre: Licença PSF (similar à BSD);
● Linguagem de programação de altíssimo nível;
● Objetiva;

4/53
Sobre Python
● Legível;
● Fácil de aprender;
● Muito produtiva, se faz muito escrevendo pouco;
● Vasta biblioteca (baterias inclusas);
● Multiplataforma: Linux, FreeBSD, MacOS, Windows, *nix, etc...

5/53
Filosofia: The Zen of Python
>>> import this
The Zen of Python, by Tim Peters
Beautiful is better than ugly.
Explicit is better than implicit.
Simple is better than complex.
Complex is better than complicated.
Flat is better than nested.
Sparse is better than dense.
Readability counts.
Special cases aren't special enough to break the rules.
Although practicality beats purity.
Errors should never pass silently.
Unless explicitly silenced.
In the face of ambiguity, refuse the temptation to guess.
There should be one-- and preferably only one --obvious way to do it.
Although that way may not be obvious at first unless you're Dutch.
Now is better than never.
Although never is often better than *right* now.
If the implementation is hard to explain, it's a bad idea.
If the implementation is easy to explain, it may be a good idea.
Namespaces are one honking great idea -- let's do more of those!

7/53
Shells Interativos
Uma grande facilidade de Python é a facilidade de se ter shells
interativos, os quais são muito úteis para se fazer um teste “on
the fly”.
Em uma máquina com Python basta digitar em um terminal ou
python ou python3, respectivamente para Python 2 e Python 3.
Tem-se também terminais alternativos à instalação:
● Web - (https://www.python.org/shell/)
● Ipython - (http://ipython.org/)
● Bpython - (http://bpython-interpreter.org/)
● Dreampie - (http://www.dreampie.org/)

8/53
Aplicabilidade
● Scripts;
● Frameworks web:
● Aplicativos com interface gráfica:
● Servidor de aplicação web:
wxPython tkInter PyGTK PyGobject PyQt

9/53
Aplicabilidade
CMS; (Content Management System: Sistema de Gerenciamento
de Conteúdo):
● Engenharia, Matemática, Ciência, Biologia:
● Embarcados:
● Etc...

10/53
IDEs
Ambientes Integrados de Desenvolvimento (IDEs) não faltam
para se programar em Python. Alguns exemplos a seguir:
http://wiki.python.org.br/IdesPython

11/53
Comunidade
Site global: https://www.python.org/
Site brasileiro: http://python.org.br/
Planet Python: http://planetpython.org/
Planeta Python: http://wiki.python.org.br/planet/
Wiki global: https://wiki.python.org
Wiki do Brasil: http://wiki.python.org.br/
Eventos
PyCon: http://www.pycon.org/
Python Brasil: http://www.pythonbrasil.org.br/
Listas de Discussão
https://mail.python.org/mailman/listinfo
http://python.org.br/lista-de-discussoes

12/53
Livros? (em Português)
e etc...

14/53
Tipagem Dinâmica (Duck Typing)
foo = 7
print(type(foo))
builtins.int
id(foo)
10911904
● Uma variável pode mudar de tipo em tempo de execução;
● A variável se adapta ao tipo do valor a ela atribuído;
● Na verdade, internamente o identificador aponta para outro
objeto criado com o tipo de variável diferente.
foo = 'bar'
print(type(foo))
builtins.str
id(foo)
139630248473968
Nota-se que o id muda se a variável o
tipo do objeto não for mais o mesmo.
Ou seja, não é mais o mesmo objeto
apontado pelo identificador.

15/53
Tipagem Forte
print(7 + '7')
TypeError: unsupported operand type(s) for +: 'int' and 'str'
print(7 + int('7'))
14
● Não são permitidas operações matemáticas entre números e
strings;
● Às vezes é necessário fazer uso de type cast.

16/53
Blocos
i = 0
while i < 10:
i += 1
if (i % 2 == 0):
continue
print(i)
1
3
5
7
9
● Em Python blocos são definidos por indentação e não por
chaves (“{}”) como na maioria das linguagens:
i = 0
while i < 10:
i += 1
if (i % 2 == 0):
continue
print(i)
1
3
5
7
9

17/53
Orientação a Objetos
class Foo(object):
# Atributos
__spam = 0 # private
eggs = 'ipsis litteris' # public
# Métodos
def metodo_1(self):
print('Valor privado = {}'.format(self.__spam))
def metodo_2(self, nome):
print('Meu nome é {}'.format(nome))
f = Foo() Objeto
Classe

18/53
Orientação a Objetos
f.metodo_1()
Valor privado = 0
f.metodo_2('Zé das Coves')
Meu nome é Zé das Coves
print(f.eggs)
ipsis litteris
print(f.__spam)
AttributeError: 'Foo' object has no attribute '__spam'

19/53
Orientação a Objetos: Herança
class Bar(Foo):
# Método construtor
def __init__(self, x):
self.x = x * 7
b = Bar(3)
print(b.x)
21
b.metodo_2('Chiquinho da Silva')
Meu nome é Chiquinho da Silva

20/53
Orientação a Objetos: Herança Múltipla
class Foo(object):
atributo1 = 0
atributo2 = ''
class Bar(object):
atributo3 = 3.14
atributo4 = ''
class Baz(Foo, Bar):
atributo5 = 1
o = Baz()
print(o.atributo1)
0
print(o.atributo3)
3.14
print(o.atributo5)
1

21/53
Arrays em Python?: Listas e Tuplas
Arrays é um recurso muito comum na maioria das linguagens de
programação.
Apesar de haver uma classe pra arrays, a classe array [1],
raramente é usada. Essa classe tem uma abordagem muito mais
próxima do conceito de um array tradicional.
Porém Python dispõe de recursos mais poderosos e flexíveis
que os “tradicionais” arrays, que são as Listas e Tuplas.
Listas e tuplas podem ter elementos de diferentes tipos, inclusive
outras tuplas e listas dentro de si.
[1] https://docs.python.org/3/library/array.html

22/53
Listas
Listas em Python são estruturas de dados mutáveis que
armazenam listas de elementos.
Para se definir uma lista colocamos seus elementos separados
por vírgunas e entre colchetes:
foo = ['a', 77, 1.5]
print(foo[0])
a
print(foo[1])
77
print(type(foo))
<class 'list'>
A lista foi definida com 3 (três) elementos.
Desses elementos, cada um foi de um tipo
diferente, o que não seria possível em um
array.

23/53
Listas
Alguns métodos de listas:
foo.append('teste')
print(foo)
['a', 77, 1.5, 'teste']
foo.insert(0, 'começo')
print(foo)
['começo', 'a', 77, 1.5, 'teste']
print(foo.pop())
teste
print(foo)
['começo', 'a', 77, 1.5]
append: Insere no final
insert: Insere conforme a posição dada
pop: por padrão remove do final e retorna
o elemento retirado

24/53
Tuplas
São estruturas de dados quase idênticas a listas, exceto que são
imutáveis e seus valores são delimitados por parênteses.
Sua grande vantagem com relação às listas é a questão de
desempenho, por ser uma estrutura mais simples e enxuta.
Por ser imutável não tem métodos que alteram seu conteúdo.
foo = ('bar', 'baz', 'eggs', 5, .7)
print(foo[4])
0.7
print(type(foo))
<class 'tuple'>

25/53
Dicionários
Um dicionário em Python é uma estrutura de dados delimitada
por chaves, seus elementos são compostos na forma “chave:
valor”, muito similar a um JSON.
d = {'nome': 'Chiquinho da Silva', 'idade': 50, 'altura': 1.72}
print(d['nome'])
Chiquinho da Silva
for k, v in d.items():
print('{}: {}'.format(k, v))
idade: 50
altura: 1.72
nome: Chiquinho da Silva

26/53
Loops for
Loops for em Python é como se fosse o foreach de outras
linguagens de programação.
O loop é feito em cima de objetos iteráveis.
lista = ['foo', 'bar', 'baz', 'spam', 'eggs']
for i in lista:
print(i)
foo
bar
baz
spam
eggs

27/53
Fatiamento (Slicing)
Alguns tipos de objetos, como strings, listas e tuplas podemos
fatiar valores.
object[ index : nth_element : inc ]
● index: O índice da posição inicial (começa por zero);
● nth_element: A posição final ordinalmente (índice final + 1);
● inc: Incremento, por padrão é 1 (um). Se for usado um
incremento com valor negativo faz com que a interpretação
seja reversa.

28/53
Fatiamento (Slicing)
Dada a string “abcdefghij”:
–+++++++++++
| Elementos: | a | b | c | d | e | f | g | h | i | j |
+++++++++++
| index: | 0 | 1 | 2 | 3 | 4 | 5 | 6 | 7 | 8 | 9 |
–+++++++++++
| nth_element | 1 | 2 | 3 | 4 | 5 | 6 | 7 | 8 | 9 | 10 |
–+++++++++++
print('abcdefghij'[1:5])
bcde
print('abcdefghij'[::-1])
jihgfedcba

29/53
else Além de if
Uma particularidade interessante de Python é o uso de else
logo após um loop for ou um loop while.
Nesses casos o bloco else é executado se o loop não tiver sido
quebrado por um comando break.
Estrutura:
<loop>
else:
comandos

30/53
for com else
for i in range(1, 15):
if (i % 3 == 0) and (i % 2 == 0):
break
print(i)
else:
print('Sem break :)')
1
2
3
4
5
Dadas as condições foi forçada
uma quebra no laço e por isso o
bloco else não foi executado.

31/53
for com else
for i in range(1, 5):
if (i % 13 == 0):
break
print(i)
else:
1
2
3
4
Sem break :)
Não houve quebra no laço, então o
bloco else foi executado

32/53
while com else
i = 1
while (i < 15):
if (i % 3 == 0) and (i % 2 == 0):
break
print(i)
i += 1
else:
1
2
3
4
5
Dadas as condições foi forçada uma
quebra no laço e por isso o bloco eles não
foi executado.

33/53
while com else
i = 1
while (i < 5):
if (i % 13 == 0):
break
print(i)
i += 1
else:
1
2
3
4
5
Sem break :)
Não houve quebra no laço, então o bloco else foi
executado

34/53
Dunder
o = object()
print(o.__doc__)
The most base type
print(o.__str__())
<object object at 0xb7086918>
● A palavra “dunder” é na verdade um apelido para “double
underscore” (duplo underscore);
● Em Python, dunder é o que em algumas linguagens são
conhecidos como “métodos mágicos” ou “atributos mágicos”;
● São métodos ou atributos cujos nomes estão entre dois duplos
underscores. e. g. __doc__, __repr__(), __str__();

35/53
Strings
foo = 'bar'
sql = "SELECT * FROM foo WHERE baz = 'eggs';"
Strings podem ser definidas entre apóstrofos ou entre aspas:
Strings de múltiplas linhas também são delimitadas ou por
apóstrofos ou aspas. Mas são três em cada ponta:
spam = '''
Uma string multilinha
com
apóstrofos
'''
eggs = """
Uma string multilinha
com
aspas
"""
Muito úteis para
strings SQL! :)

36/53
Comentários
# Isto é um comentário em Python
Assim como em Shell Script, comentários de uma única linha
utiliza-se o caractere sustenido (#):
Para comentários de múltiplas linhas pode-se usar uma string
de múltiplas linhas:
'''
Comentário multilinha
com
apóstrofos
'''
"""
Comentário multilinha
com
aspas
"""
Qualquer string não assimilada a uma variável é
considerada como um comentário.

37/53
Doc Strings
Docstrings são comentários que servem de documentação para
um objeto.
class Foo(object):
'Esta é a classe Foo :P'
def metodo(self):
'''
Este é um método
da classe Foo
que só retorna a string "olá!"
'''
return 'olá'
print(Foo.__doc__)
Esta é a classe Foo :P
print(Foo.metodo.__doc__)
Este é um método
da classe Foo
que só retorna a string "olá!"

38/53
Python como Linguagem Procedural
Em SGBDs relacionais, além da linguagem SQL, é possível
criar funções para atender demandas que SQL não atenderia;
O PostgreSQL, por padrão tem PL/pgSQL;
No entanto, ele permite também outras linguagens para se
fazer funções;
E claro, Python está entre elas e no core do sistema :)
https://www.postgresql.org/docs/current/static/plpython.html

39/53
PL/pgSQL:
DO
$marcador$
DECLARE
var1 INT2 := 21;
var2 INT2 := 0;
BEGIN
RAISE NOTICE 'O número é %', (var1/var2);
EXCEPTION WHEN division_by_zero THEN
RAISE EXCEPTION 'Não dividirás por zero!!!';
END;
$marcador$ LANGUAGE plpgsql;

40/53
PL/Python:
DO
$marcador$
var1 = 21
var2 = 0
try:
plpy.notice('O número é %i' % (var1/var2))
except ZeroDivisionError:
plpy.info('Não dividirás por zero!!!')
$marcador$ LANGUAGE plpython3u;
Além da perseptível economia de linhas de código, utilizando
PL/Python dá maior poder para desenvolver funções dentro do
banco, pois poderá contar com as bibliotecas de Python.

41/53
Funções
Python não tem sobrecarga de funções;
Métodos também são funções, porém recebem como primeiro
parâmetro o próprio objeto, convencionalmente identificado como
“self”;
Trabalha com diferentes tipos de parâmetros:
● Sem parâmetros;
● Obrigatórios;
● Opcionais;
● Arbitrários não nomeados;
● Arbitrários nomeados.
def funcao():
return 'foo'
print(funcao())
foo
def funcao():
print('baz')
funcao()
baz
Funções sem parâmetros

42/53
Funções
Parâmetros obrigatórios:
def funcao(x, y):
return x + y
print(funcao(5, 2))
7
Parâmetro opcional:
def funcao(x=7):
return x
print(funcao())
7
print(funcao(2+2+5))
9

43/53
Funções
Parâmetros arbitrários não nomeados:
def funcao(*args):
for i in args:
print(i)
funcao('foo', 'bar', 'baz')
foo
bar
baz
Pode-se ainda passar ou uma lista ou uma tupla para esse tipo
de argumento: t = ('foo', 'bar', 'baz')
funcao(*t)
foo
bar
baz

44/53
Funções
Parâmetros arbitrários nomeados:
def funcao(**kargs):
for k, v in kargs.items():
print('{}: {}'.format(k, v))
funcao(nome='Chiquinho', idade=55)
idade: 55
nome: Chiquinho
Pode-se ainda passar ou um dicionário para esse tipo de
argumento:
d = {'nome': 'Chiquinho', 'idade': 55}
funcao(**d)
idade: 55
nome: Chiquinho

45/53
Funções Anônimas: Lambda
foo = lambda x, y: (x * 2) + y
foo(3, 1)
7
● Lambda são funções anônimas compostas apenas por
expressões;
● Podem ter apenas uma linha;
● Podem ser atribuídas a uma variável;
● Muito utilizadas em programação funcional.

46/53
Compreensão de Lista
m79 = [ x * 9 for x in range(1, 101) if x % 7 == 0]
print(m79)
[63, 126, 189, 252, 315, 378, 441, 504, 567, 630, 693, 756, 819, 882]
Em inglês “list comprehension”, é uma ferramenta para
transformar um objeto iterável em uma lista.
Sintaxe:
[ <expressão> for <referência> in <sequência> if <condição> ]
Multiplicando 9 de 1 até 100, obter todos os múltiplos comuns de
7:

47/53
Módulos: Importação de Bibliotecas
# Importando o móulo sys
import sys
# Chamando a função que está dentro do módulo
sys.exit(0)
Em Python, as bibliotecas são chamadas de módulos. Para se
importar algo podemos utilizar:
● import: Faz importação de toda uma estrutura:
● from: Importa algo dado um caminho, de forma mais precisa,
economizando recursos:
# Importando somente a função exit()
# que pertence ao módulo sys
from sys import exit
# Chamando a função importada
exit(0)

48/53
Funções
P.: E se eu quiser utilizar todos os tipos de argumentos?
R.: Segue a ordem de tipos: obrigatórios, opcionais, arbitrários
não nomeados e arbitrários nomeados.
def funcao(foo, bar, baz=5, *args, **kargs):
print('Argumentos obrigatórios: foo = {}, bar = {}'.format(foo, bar))
print('Argumento opcional: baz = {}'.format(baz))
print('Argumentos arbitrários não nomeados:')
for i in args:
print(i)
print('Argumentos arbitrários nomeados:')
for k, v in kargs.items():
print('{} = {}'.format(k, v))

49/53
E muito mais...
Python vai muito além do que foi dito até aqui:
● Bibliotecas padrão e de terceiros;
● Tratamento de Exceção;
● Geradores (Generators);
● Decoradores (Decorators);
● Propriedades (Properties);
● Threads;
● Interação com bancos de dados;
● etc... etc...

50/53
Conclusão
Python é uma linguagem de programação poderosa, flexível e
fácil de aprender.
É excelente para fins profissionais e educacionais.
Vários ambientes e aplicabilidades.
Então por que não começar a aprender agora? ;)

51/53
Doe!
:)
https://www.python.org/psf/donations/

52/53
Save our planet!Save our planet!

53/53
See you soon!!!
Juliano Atanazio
juliano777@gmail.com
http://slideshare.net/spjuliano
https://speakerdeck.com/julianometalsp
https://juliano777.wordpress.com
:)

Por que Python? Vamos Conhecer? Vamos Aprender?

Recommended

Recommended

More Related Content

What's hot

What's hot (20)

Similar to Por que Python? Vamos Conhecer? Vamos Aprender?

Similar to Por que Python? Vamos Conhecer? Vamos Aprender? (20)

Por que Python? Vamos Conhecer? Vamos Aprender?