Introdução à Python - Módulo 2

439 views

Published on

Introdução a Python - II JTIMS - Módulo 2
Mini curso - 2013
www.jhoonb.coom

Published in: Education
0 Comments
1 Like
Statistics
Notes
  • Be the first to comment

No Downloads
Views
Total views
439
On SlideShare
0
From Embeds
0
Number of Embeds
2
Actions
Shares
0
Downloads
42
Comments
0
Likes
1
Embeds 0
No embeds

No notes for slide

Introdução à Python - Módulo 2

  1. 1. M2 Introdução à Python 3 Minicurso de Introdução a linguagem de programação Python. II JTIMS - Jornada de Tecnologias da Informação de Mato Grosso do Sul
  2. 2. CONTEÚDO PROGRAMÁTICO Os módulos e arquivos usados, serão disponíveis no site após o termino de cada aula, url: jhoonb.com/courses
  3. 3. CONTEÚDO PROGRAMÁTICO Módulo 2: 1. Funções. a. Definindo, parâmetros, variável global, multíplos retornos 2. Paradigmas de Programação. a. Exemplo de POO. b. Programação Funcional, List comprehension 3. Tipo de Dados (métodos). a. list, dic, str, tuple 4. Exemplos. 5. Exercícios.
  4. 4. MÓDULO 2: Criando Funções Dividir para Conquistar!
  5. 5. MÓDULO 2: Criando Funções Um problema é dividido em diversos subproblemas. As soluções dos sub-problemas são combinadas numa solução do problema maior.
  6. 6. MÓDULO 2: Criando Funções “It is better to have 100 functions operate on one data structure than 10 functions on 10 data structures.” - Alan Perlis.
  7. 7. MÓDULO 2: Criando Funções Uma função é um bloco de código ao qual são opcionalmente passados parâmetros e pode opcionalmente também retornar valores. Uma função é definida pela instrução def que é seguida pelo nome da função e por parêntesis, que contêm a lista de parâmetros. Opcionalmente uma função pode usar a instrução return que termina a função e retorna ao chamador.
  8. 8. MÓDULO 2: Criando Funções Para criar uma função em Python, usa-se a palavra reservada: def def <nomefuncao>(<parametros>): <indentação> <comandos>
  9. 9. MÓDULO 2: Criando Funções ❖ Não é necessário especificar os tipos dos dados nos parâmetros. ❖ As variáveis declaradas dentro das funções tem escopo local, quando a função termina elas são destruídas.
  10. 10. MÓDULO 2: Criando Funções ❖ Pode-se usar funções com retornos, usando return no final da função. def soma(a,b): return a+b >>> soma(2,3) >>> 5
  11. 11. MÓDULO 2: Criando Funções def foo(x): x = x+1 print(x) x = 10 print(x) foo(x) print(x) -> 10 -> 11 -> 10
  12. 12. MÓDULO 2: Criando Funções def funcao1(): print("a função 1 é essa") def funcao2(): print("a funcao 2 é essa") a,b = 2,3 print(" a + b é igual a ", a + b )
  13. 13. MÓDULO 2: Criando Funções >>> >>> >>> >>> >>> funcao1() a função 1 é essa funcao2() a funcao 2 é essa a mais b é igual = 5
  14. 14. MÓDULO 2: Passagem por parâmetros Parâmetros são variáveis que recebem valor do chamador, essas variáveis serão usadas localmente, no escopo da função. Pode-se passar N parâmetros para um função, e no Python NÃO é necessário especificar o tipo da variável. Veja o exemplo:
  15. 15. MÓDULO 2: Passagem por parâmetros def spam(eggs, foo): print(eggs, foo) >>> >>> >>> >>> spam(2,3) 2 3 spam(‘zaz zaz’, ‘ e zaz’ ) zaz zaz e zaz
  16. 16. MÓDULO 2: Passagem por parâmetros Passagem por parâmetro não altera a variável chamada: def spam(x): x = ‘CHAPOLIN’ >>> x = ‘CHAVES’ >>> spam(x) >>> x <- ‘CHAVES’
  17. 17. MÓDULO 2: Variável Global Para se usar uma variável do escopo global dentro do escopo de uma função (que é local), usa-se a palavra reservada global na frente da variável. global x
  18. 18. MÓDULO 2: Variável Global def foo(): global x x += 1 print(x) x = 10 print(x) foo() print(x) -> 10 -> 11 -> 11
  19. 19. MÓDULO 2: Retorno de função Python fornece múltiplos retornos de função,ex.: def spam(x): return x,x,x,x >>> >>> >>> >>> >>> spam(‘spam’) (‘spam’,’spam’,’spam’,’spam’) a,b,c,d = spam(‘eggs’) print(a,b,c,d) ‘eggs’ ‘eggs’ ‘eggs’ ‘eggs’
  20. 20. MÓDULO 2: Exercícios. Exercícios!
  21. 21. MÓDULO 2: Paradigmas de Programação
  22. 22. MÓDULO 2: Paradigmas de Programação Python é uma linguagem multiparadigma, isso quer dizer que existe mais de uma maneira de programar e abstrair os códigos.
  23. 23. MÓDULO 2: Paradigmas de Programação Existem vários paradigmas, como por exemplo: Programação Orientada a Objetos. Programação Funcional. Programação Estruturada/Imperativa. Programação Lógica.
  24. 24. MÓDULO 2: Paradigmas de Programação Programação Funcional: Python, Erlang, Haskell, F#, OCaml ... Trata a computação como uma avaliação de funções matemáticas. [tipos imutáveis]
  25. 25. MÓDULO 2: Paradigmas de Programação Programação Orientada a Objetos: Python, JAVA, C++, Smaltalk, Ruby ... Trata a computação como baseada na composição e interação entre diversas unidades de software chamadas de objetos.
  26. 26. MÓDULO 2: Paradigmas de Programação Programação Estruturada/Imperativa: Python, C, Go, Pascal, Lua ...
  27. 27. MÓDULO 2: Paradigmas de Programação Programação Lógica: Prolog, Lisp, Planner ... Baseada na Lógica matemática, demostrações e inferências. de construção, tem como objetivo realizar funções ou esquemas lógicos por meio de parâmetros e metas.
  28. 28. MÓDULO 2: Paradigmas de Programação
  29. 29. MÓDULO 2: Paradigmas de Programação “A language that doesn't affect the way you think about programming, is not worth knowing.” Alan Perlis
  30. 30. MÓDULO 2: Orientação a Objetos Uma Breve, demonstração rápida, curta, pequena
  31. 31. MÓDULO 2: Orientação a Objetos class Chapolin(object): ‘’’ Mais rapido que uma lesma mais forte que um gambá é o chapolin colorado!! ‘’’’ def __init__(self): self.forca = ‘ de um gamba’ self.qi = ‘ de uma mula’ self.velocidade = ‘ de lesma’
  32. 32. MÓDULO 2: Orientação a Objetos class Chapolin(object): new Style Class ‘’’ Mais rapido que uma lesma mais forte que um gambá é o chapolin colorado!! ‘’’’ def __init__(self): self.forca = ‘ de um gamba’ self.qi = ‘ de uma mula’ self.velocidade = ‘ de lesma’
  33. 33. MÓDULO 2: Orientação a Objetos class Chapolin(object): new Style Class ‘’’ Mais rapido que uma lesma mais forte que um gambá é o chapolin colorado!! ‘’’’ def __init__(self): self.forca = ‘ de um gamba’ self.qi = ‘ de uma mula’ self.velocidade = ‘ de lesma’ DOCSTRING
  34. 34. MÓDULO 2: Orientação a Objetos class Chapolin(object): new Style Class ‘’’ Mais rapido que uma lesma mais forte que um gambá é o chapolin colorado!! ‘’’’ def __init__(self): DOCSTRING self.forca = ‘ de um gamba’ self.qi = ‘ de uma mula’ self.velocidade = ‘ de lesma’ Construtor
  35. 35. MÓDULO 2: Orientação a Objetos class Chapolin(object): new Style Class ‘’’ Mais rapido que uma lesma mais forte que um gambá é o chapolin colorado!! ‘’’’ def __init__(self): DOCSTRING self.forca = ‘ de um gamba’ self.qi = ‘ de uma mula’ self.velocidade = ‘ de lesma’ Construtor
  36. 36. MÓDULO 2: Orientação a Objetos class Chapolin(object): new Style Class ‘’’ Mais rapido que uma lesma mais forte que um gambá é o chapolin colorado!! ‘’’’ def __init__(self): DOCSTRING self.forca = ‘ de um gamba’ self.qi = ‘ de uma mula’ self.velocidade = ‘ de lesma’ Inicializador
  37. 37. MÓDULO 2: Orientação a Objetos def frase1(self): print(‘Não contam com minha ASTUCIA!’) def frase2(self): print(‘PALMA PALMA NAO PRIEMOS CANICO!’) def frase3(self): print(‘Meus novimentos sao FRIAMENTE calculados’) def frase4(self): print(‘se aproveitam de minha nobreza’)
  38. 38. MÓDULO 2: Orientação a Objetos def frase1(self): print(‘Não contam com minha ASTUCIA!’) Métodos def frase2(self): print(‘PALMA PALMA NAO PRIEMOS CANICO!’) def frase3(self): print(‘Meus novimentos sao FRIAMENTE calculados’) def frase4(self): print(‘se aproveitam de minha nobreza’)
  39. 39. MÓDULO 2: Orientação a Objetos def frase1(self): print(‘Não contam com minha ASTUCIA!’) Métodos def frase2(self): print(‘PALMA PALMA NAO PRIEMOS CANICO!’) def frase3(self): self: explicito print(‘Meus novimentos sao FRIAMENTE calculados’) def frase4(self): print(‘se aproveitam de minha nobreza’)
  40. 40. MÓDULO 2: Orientação a Objetos def atributos(self): print(‘Força: ’,self.forca) print(‘Q.I.: ’, self.qi) print(‘Velocidade: ’, self.velocidade) def troca_atributos(self, f,q,v): self.forca = f self.qi = q self.velocidade = v
  41. 41. MÓDULO 2: Orientação a Objetos def atributos(self): print(‘Força: ’,self.forca) print(‘Q.I.: ’, self.qi) print(‘Velocidade: ’, self.velocidade) def troca_atributos(self, f,q,v): self.forca = f self.qi = q self.velocidade = v self: referencia os tributos da classe
  42. 42. MÓDULO 2: Orientação a Objetos def quem_podera_me_defender(self): print(‘EEEEEEEEEEEEEEEEU!!!!!’)
  43. 43. MÓDULO 2: Orientação a Objetos >>> chapolin = Chapolin()
  44. 44. MÓDULO 2: Orientação a Objetos >>> chapolin = Chapolin() Instância da Classe, um novo objeto
  45. 45. MÓDULO 2: Orientação a Objetos >>> chapolin = Chapolin() >>> chapolin.quem_podera_me_defender()
  46. 46. MÓDULO 2: Orientação a Objetos >>> chapolin = Chapolin() >>> chapolin.quem_podera_me_defender() chama um dos métodos pelo operador .
  47. 47. MÓDULO 2: Orientação a Objetos >>> chapolin = Chapolin() >>> chapolin.quem_podera_me_defender() ‘EEEEEEEEEEEEEEEEU!!!!!’
  48. 48. MÓDULO 2: Orientação a Objetos >>> chapolin = Chapolin() >>> chapolin.quem_podera_me_defender() ‘EEEEEEEEEEEEEEEEU!!!!!’ >>> chapolin.frase2() ‘PALMA PALMA NAO PRIEMOS CANICO!’
  49. 49. MÓDULO 2: Orientação a Objetos Isso sem mencionar: Polimorfismo.
  50. 50. MÓDULO 2: Orientação a Objetos Isso sem mencionar: Polimorfismo. Encapsulamento.
  51. 51. MÓDULO 2: Orientação a Objetos Isso sem mencionar: Polimorfismo. Encapsulamento. Classes abertas.
  52. 52. MÓDULO 2: Orientação a Objetos Isso sem mencionar: Polimorfismo. Encapsulamento. Classes abertas. Herança Múltipla.
  53. 53. MÓDULO 2: Orientação a Objetos Isso sem mencionar: Polimorfismo. Encapsulamento. Classes abertas. Herança Múltipla. Sobrecarga de Operadores
  54. 54. MÓDULO 2: Funcional Paradigma Funcional
  55. 55. MÓDULO 2: Programação funcional Uma Breve, rápida, curta, pequena demonstração
  56. 56. MÓDULO 2: Programação funcional Em programação Funcional, as funções são tratadas como valores de primeira importância(First Class Function), o que é o mesmo que dizer que funções podem ser parâmetros ou valores de entrada para outras funções e podem ser os valores de retorno ou saída de uma função. Então podemos entender paradigma funcional como um mapeamento dos valores de entrada nos valores de retorno, através de funções.
  57. 57. MÓDULO 2: Programação funcional ● Legibilidade e manutenibilidade gerados. Isso é porque cada função é criada para realizar uma determinada tarefa específica seus argumentos. ● Como o código é mais fácil ao refatorar, as alterações no design são geralmente mais fáceis de implementar.
  58. 58. MÓDULO 2: Programação funcional Python, conceitos Funcionais: Lambda first-class functions Higher-order functions map() functools.reduce() filter()
  59. 59. MÓDULO 2: Programação funcional Python, conceitos Funcionais: Lambda first-class functions Higher-order functions map() functools.reduce() filter()
  60. 60. MÓDULO 2: Funcional Todos os números pares de 1 a 5 milhões: ...
  61. 61. MÓDULO 2: Funcional Todos os números pares de 1 a 5 milhões: par = lambda x: x % 2 == 0 todos = list(filter(par,range(1,5000001)))
  62. 62. MÓDULO 2: Funcional Todos os números pares de 1 a 5 milhões: ou
  63. 63. MÓDULO 2: Funcional Todos os números pares de 1 a 5 milhões: todos = list(filter(lambda x: x % 2 == 0,range(1,5000001)))
  64. 64. MÓDULO 2: Funcional criptografar uma texto, com a criptografia de Cezar: ...
  65. 65. MÓDULO 2: Funcional criptografar uma texto, com a criptografia de Cezar: texto = list(“as arveres samos nozes”) crip = lambda x: chr(ord(x)+1) novo = list(map(crip, texto))
  66. 66. MÓDULO 2: Funcional decriptar o texto: decrip = lambda x: chr(ord(x)-1) novo = list(map(crip, novo))
  67. 67. MÓDULO 2: Funcional Somar todos os números de 1 a 1000: from functools import reduce soma = reduce(lambda x,y: x+ y, range(1,1001))
  68. 68. MÓDULO 2: Funcional Somar todos os números de 1 a 1000: from functools import reduce soma = reduce(lambda x,y: x+ y, range(1,1001)) Existe uma maneira bem mais fácil e poderosa em Python...
  69. 69. MÓDULO 2: List comprehension List comprehension!
  70. 70. MÓDULO 2: List comprehension List comprehension! Elimina o uso de:
  71. 71. MÓDULO 2: List comprehension List comprehension! Elimina o uso de: functools.reduce()
  72. 72. MÓDULO 2: List comprehension List comprehension! Elimina o uso de: functools.reduce() filter()
  73. 73. MÓDULO 2: List comprehension List comprehension! Elimina o uso de: functools.reduce() filter() map()
  74. 74. MÓDULO 2: List comprehension List comprehension! Uma compreensão de lista é uma construção sintática disponível em algumas linguagens de programação para criação de uma lista baseada em listas existentes. Ela segue a forma da notação de definição de conjunto matemática (Teoria formal de Conjunto) como forma distinta para uso de funções de mapa e filtro.
  75. 75. MÓDULO 2: List comprehension Exemplo do poder linguagem Python. dessa feature na
  76. 76. MÓDULO 2: List comprehension
  77. 77. MÓDULO 2: List comprehension S é o conjunto de todos os números "2 vezes x" onde x é um elemento do conjunto dos números naturais N, pelo qual x ao quadrado é maior que 3
  78. 78. MÓDULO 2: List comprehension Em Python usando List comprehension
  79. 79. MÓDULO 2: List comprehension Em Python usando List comprehension S = [2 * x for x in range(101) if x ** 2 > 3]
  80. 80. MÓDULO 2: List comprehension S = [2 * x for x in range(101) if x ** 2 > 3]
  81. 81. MÓDULO 2: Funcional Finalizando
  82. 82. MÓDULO 2: Funcional Finalizando
  83. 83. MÓDULO 2: Estrutura/tipos de Dados Estrutura/tipos de Dados list, str, dict
  84. 84. MÓDULO 2: Estrutura/tipos de Dados List em Python é: Listas são conjuntos de elementos de qualquer tipo separados por vírgula e que estão entre colchetes, e que podem ser modificados. >>> lista = [2, 3, 4, ‘eggs’] >>> lista[2] = 5 >>> print(lista) [2,3, 5, ‘eggs’]
  85. 85. MÓDULO 2: Estrutura/tipos de Dados Métodos de list: .append(x) adiciona um elemento ao fim da lista .count() retorna o número de vezes que x aparece na lista .extend([x]) estende a lista com novos elementos passados .index(x) retorna o índice (ou posição) de um determinado elemento da lista. .insert(x,y) insere x na posicao y posição.
  86. 86. MÓDULO 2: Estrutura/tipos de Dados Métodos de list: .pop(x), .pop() remove o elemento da posição indicada e o retorna, ou o ultimo se não passar nenhuma elemento .remove() remove o primeiro elemento da lista. .reverse() estende a lista com novos elementos passados .sort() ordena os elementos da lista.
  87. 87. MÓDULO 2: Estrutura/tipos de Dados exemplos...
  88. 88. MÓDULO 2: Estrutura/tipos de Dados Dict, dicionários(Mapeamento):
  89. 89. MÓDULO 2: Estrutura/tipos de Dados Dict, dicionários(Mapeamento): Dicionários são conjuntos não ordenados de pares, onde o primeiro elemento do par, o índice, é chamado de chave e o outro de valor. Um dicionário, em Python, suporta qualquer tipo de objeto, seja ele uma lista ou até mesmo outros dicionários e pode ser modificado. Para criar um dicionário basta declarar pares “chave:valor” separados por vírgula e delimitados por chaves.
  90. 90. MÓDULO 2: Estrutura/tipos de Dados Dict, dicionários(Mapeamento), exemplo: >>> dic = {1:'um', 2:'dois', 3:'tres'} >>> dic[1] 'um' >>> dic[4]='quatro' >>> dic {1: 'um', 2: 'dois', 3: 'tres', 4: 'quatro'}
  91. 91. MÓDULO 2: Estrutura/tipos de Dados Dict, dicionários(Mapeamento), Métodos: .keys() - retorna as chaves do dicionário .values() - retorna os valores do dicionário .items() - returna uma tupla contendo chave/valor. x in y.keys() - verifica se a chave x existe no dicionario y x in y.values() - verifica se o valor x existe no dicionário y del x[key] - deleta a chave/valor do key do dicionário x
  92. 92. MÓDULO 2: Estrutura/tipos de Dados Dict, dicionários(Mapeamento), Métodos: .clear() - remove todos os elementos do dicionário x in d - verifica se a chave x existe no dicionário d x not in d - verifica se a chave x não está no dict d .update(d) atualiza o dict com outro o dict d passado
  93. 93. MÓDULO 2: Estrutura/tipos de Dados Strings, str: Strings são seqüências de caracteres entre aspas que não podem ser modificadas, a menos que você reatribua. Podem ser acessadas via [].
  94. 94. MÓDULO 2: Estrutura/tipos de Dados Strings, str, fatiando strings (slice): Podemos acessar o conteúdo de uma string usando colchetes []. Exemplo: >>> nome = “KIKO” >>> nome[0] ‘K’
  95. 95. MÓDULO 2: Estrutura/tipos de Dados Strings, str, fatiando strings (slice): >>> nome = “KIKO” >>> nome[0] ‘K’ >>> nome[0:2] ‘KI’ >>> nome[:2] ‘KI’
  96. 96. MÓDULO 2: Estrutura/tipos de Dados Strings, str, fatiando strings (slice): >>> nome = “KIKO” >>> nome[2:] >>> ‘K0’ >>> nome[:] >>> ‘KIKO’ >>> nome[0::2] >>> ‘KK’
  97. 97. MÓDULO 2: Estrutura/tipos de Dados Strings, str, fatiando strings (slice): Técnica: STRING[INICIO : FINAL - 1: INCREMENTO]
  98. 98. MÓDULO 2: Estrutura/tipos de Dados Strings, str, métodos: .find(x) - retorna o posicao do valor x se existir .replace(x,y) - retorna a string trocando x por y .upper() - retorna a string com as letras maiúsculas. .lower() - retorna a string com as letras minúsculas. .count(x) - retorna o número de ocorrências de x na string .strip() - retorna a string se espaços no começo e final.
  99. 99. MÓDULO 2: Exercícios Exercícios/Dúvidas?
  100. 100. MÓDULO 2: Referências list: http://docs.python.org/3/library/stdtypes.html#list dict: http://docs.python.org/3/library/stdtypes.html#mapping-types-dict str: http://docs.python.org/3/library/stdtypes.html#text-sequence-type-str tuple: http://docs.python.org/3/library/stdtypes.html#tuple range: http://docs.python.org/3/library/stdtypes.html#range
  101. 101. MÓDULO 2: FIM Material disponível em: jhoonb.com/courses

×