Por que Python? Vamos Conhecer? Vamos Aprender?

384 visualizações

Publicada em

Python é uma linguagem de programação de altíssimo nível.
Fácil de aprender, fácil de dar manutenção, direta e objetiva.
Escreva menos pra se fazer mais :D

Material de evangelização ;)

Publicada em: Software
0 comentários
2 gostaram
Estatísticas
Notas
  • Seja o primeiro a comentar

Sem downloads
Visualizações
Visualizações totais
384
No SlideShare
0
A partir de incorporações
0
Número de incorporações
4
Ações
Compartilhamentos
0
Downloads
16
Comentários
0
Gostaram
2
Incorporações 0
Nenhuma incorporação

Nenhuma nota no slide

Por que Python? Vamos Conhecer? Vamos Aprender?

  1. 1. Juliano Atanazio Por que Python?Por que Python?
  2. 2. 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. 3. 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. 4. 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. 5. 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. 6. 6/53 Quem usa Python?
  7. 7. 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. 8. 8/53 Aplicabilidade ● Scripts; ● Frameworks web: ● Aplicativos com interface gráfica: ● Servidor de aplicação web: wxPython tkInter PyGTK PyGobject PyQt
  9. 9. 9/53 Aplicabilidade CMS; (Content Management System: Sistema de Gerenciamento de Conteúdo): ● Engenharia, Matemática, Ciência, Biologia: ● Embarcados: ● Etc...
  10. 10. 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. 11. 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. 12. 12/53 Livros? (em Português) e etc...
  13. 13. 13/53 Ação!
  14. 14. 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. 15. 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. 16. 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. 17. 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. 18. 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. 19. 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. 20. 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. 21. 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. 22. 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. 23. 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. 24. 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. 25. 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. 26. 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. 27. 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. 28. 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. 29. 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. 30. 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. 31. 31/53 for com else for i in range(1, 5): if (i % 13 == 0): break print(i) else: print('Sem break :)') 1 2 3 4 Sem break :) Não houve quebra no laço, então o bloco else foi executado
  32. 32. 32/53 while com else i = 1 while (i < 15): if (i % 3 == 0) and (i % 2 == 0): break print(i) i += 1 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 eles não foi executado.
  33. 33. 33/53 while com else i = 1 while (i < 5): if (i % 13 == 0): break print(i) i += 1 else: print('Sem break :)') 1 2 3 4 5 Sem break :) Não houve quebra no laço, então o bloco else foi executado
  34. 34. 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. 35. 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. 36. 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. 37. 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. 38. 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. 39. 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. 40. 40/53 Python como Linguagem Procedural 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. 41. 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. 42. 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. 43. 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. 44. 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. 45. 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. 46. 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. 47. 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. 48. 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. 49. 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. 50. 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. 51. 51/53 Doe! :) https://www.python.org/psf/donations/
  52. 52. 52/53 Save our planet!Save our planet!
  53. 53. 53/53 See you soon!!! Juliano Atanazio juliano777@gmail.com http://slideshare.net/spjuliano https://speakerdeck.com/julianometalsp https://juliano777.wordpress.com :)

×