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? ;)

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

:)