View
363
Download
7
Category
Preview:
Citation preview
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!
6/53
Quem usa Python?
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.orgWiki 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/listinfohttp://python.org.br/lista-de-discussoes
12/53
Livros? (em Português)
e etc...
13/53
Ação!
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)
13579
● 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)
13579
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últiplaclass 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, inclusiveoutras 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: 50altura: 1.72nome: 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)
foobarbazspameggs
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 :)')
12345
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: print('Sem break :)')
1234Sem 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 += 1else: print('Sem break :)')
12345
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 += 1else: print('Sem break :)')
12345Sem 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 multilinhacom apóstrofos'''
eggs = """Uma string multilinhacom 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 multilinhacom apóstrofos'''
"""Comentário multilinhacom 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
Python como Linguagem Procedural
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
Python como Linguagem Procedural
PL/Python:DO$marcador$var1 = 21var2 = 0try: 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')
foobarbaz
Pode-se ainda passar ou uma lista ou uma tupla para esse tipo de argumento: t = ('foo', 'bar', 'baz')
funcao(*t)
foobarbaz
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: 55nome: Chiquinho
Pode-se ainda passar ou um dicionário para esse tipo de argumento:
d = {'nome': 'Chiquinho', 'idade': 55}
funcao(**d)
idade: 55nome: 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 sysimport sys
# Chamando a função que está dentro do módulosys.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 sysfrom sys import exit
# Chamando a função importadaexit(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? ;)
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
:)
Recommended