1. O documento apresenta um resumo sobre lógica de programação com a linguagem Python. Aborda conceitos de algoritmos, linguagens algorítmicas, variáveis, estruturas de decisão e repetição. Também introduz a linguagem Python para representação de algoritmos.

1. Lógica'de'Programação'com'
Python'
Prof.'Ronaldo'Ramos'

2. 1.'Algoritmos'
a. Conceito'
b. Caracterís>cas''
c. Formas'Representa>vas'
d. Máquina'para'Execução'de'Algoritmos'
e. Estruturas'Algorítmicas''
– ''''''(Sequência,'Decisão,'Iteração)'
f. Linguagem'Algorítmica'
'

3. 2.'Linguagem'para'Algoritmos'
a. Variáveis,'atribuição'e'expressões'
b. Entradas'e'saídas'(E/S)'(I/O)'
c. Seqüência'de'Instruções'
d. Desvios'condicionais'(Decisões)'
e. Repe>ções'(Laços)'

4. 3.'Linguagens'de'Programação'
a. Codificação'de'algoritmos'(Fonte'x'Objeto)'
– ''''(Estrutura'de'um'Programa'Fonte/Objeto)'
b. Tradutores'(Interpretadores'x'Compiladores)'
c. Portabilidade'de'Código'Fonte'
d. Portabilidade'de'Código'Objeto'
e. E'na'WEB?'
f. O'Mundo'dos'Scripts''
– ''''(javascript,'php,'python'etc'etc)'

5. 4.'Python'
a. Usando'o'interpretador'intera>vamente'
b. Escrevendo'scripts'em'arquivos'textos''
c. Variáveis,'expressões'aritmé>cas'e'lógicas'
d. Desvios'condicionais'
e. Repe>ções'(Variantes,'Contadores,'Ranges)'
f. Cláusulas'de'controle'de'laços'
g. Definindo'funções'em'Python'
– ''''(Argumentos'e'Funções'Lambda)'

6. 5.'Iteração'e'Recursão'
a. Operações'repe>>vas'
b. Geração'de'Séries'e'Progressões'
c. Funções'itera>vas''
– ''''(Fatorial,'Fibonacci,'Somatório,'etc)'
d. Recursividade'e'Funções'Recursivas'''
– '''(Fatorial,'Fibonacci,'Ackerman,'etc)'
'

7. 6.'Estruturas'de'Dados'
a. Listas'em'Python'
b. Vetores'e'Matrizes'
c. Pilhas'em'Python.''
– '''(Operações'append,'push,'pop,'etc)''
d. Tuplas,'Sequencias,'Conjuntos'e'Dicionários'

8. 7.'Programação'Modular'
a. Módulos'padrão,'compilados'e'pacotes'

9. 8.'Entrada'e'Saída'
a. Entradas'e'Saídas'Formatadas'
b. Operações'em'arquivos'
– ''''(Leitura,'Gravação,'Pesquisa)'

10. 9.'Tratamento'de'Erros'e'Exceções'
a. Blocos'de'Tratamento'de'Exceções'

11. 10.'Pesquisa'e'Ordenamento'
a. Pesquisa'linear'simples'em'listas'
b. Pesquisa'binária'em'listas'ordenadas'
c. Métodos'de'Ordenamento'
– '''(Inserção,'Seleção,'Bolha,'Classificação'Rápida)'
d. Complexidade'do'Algoritmos'
e. Comparação'de'performance'de'algoritmos'

12. 11.'POO'em'Python'
a. Classes'e'Objetos'
b. Herança'Simples'e'Múl>plas'
c. Composição'e'Agregação'
d. Relacionamento'inter'Classes/Objetos'

13. 12.'Tópicos'Adicionais'
a. Recursividade'avançada'(Torres'de'Hanói)'
b. Listas'encadeadas'
c. Buffer'circular'
d. Árvores'e'Grafos'
e. Busca'em'árvores'e'Grafos'
f. Métodos'numéricos'(Cálculo'do'Pi,'Integração'
Numérica,'Raízes'de'Polinômios,'etc)'
g. Mul>nThreading'e'Programação'Concorrente'
h. Metanheurís>cas'
i. Busca'na'WEB'

14. Vamos'lá'.....''
'
'
'
1.'Introdução'aos'Algoritmos'

15. 1.a'–Definição'de'Algoritmos'''''
'''
Um'algoritmo'é'uma'seqüência'finita'de'instruções'
bem'definidas'e'não'ambíguas,'cada'uma'das'
quais'pode'ser'executada'mecanicamente'num'
período'de'tempo'finito'e'com'uma'quan>dade'
de'esforço'finita.'
'
'
''''[Fonte:'Wikipedia]'

16. 1.b'Caracterís>cas'do'Algoritmo'
• Finito'
• Não'ambíguo'
• Capaz'de'receber,'gerar'e'fornecer'
informações'
• Executável''

17. 1.b'–Exemplos'de'algoritmos'
Exemplo'1:''Receita'de'Bolo'
1.'Providencie'manteiga,'ovos,'massa,'etc.'
2.'Misture'os'ingredientes'
3.'Despeje'a'mistura'na'fôrma'de'bolo'
4.'Leve'a'fôrma'ao'forno'
5.'Espere'até'ficar'no'ponto'
6.'Re>re'a'fôrma'do'forno'

18. 1.b'–'Observações'
Que'tempo'é'“Ficar'no'Ponto”?''Qual'a'quan>dade'dos'
ingredientes?'Muito,'pouco?'O'que'significa'muito'ou'pouco?'
Quando'acender'ou'apagar'o'forno?'Misturar'os'ingredientes'de'
que'forma?Qualquer'pessoa'executaria'a'receita'da'mesma'
forma'e'obteria'os'mesmos'resultados?'
'
Conclusão:'
'
'Uma'receita'gastronômica'não'é'um'bom'exemplo'de'
algoritmo.'
'Português,'Inglês,'Francês'etc'são'ambíguos'
'Corriqueiramente'a'comunicação'é'incompleta'
'
'

19. 1.b'Exemplos'(2)''
Calcular'a'Media'Aritmé>ca'
1.'Receba'dois'números,'chamenos'de'A'e'B.'
2.'Calcule'a'media'aritmé>ca'segundo'a'fórmula'
(a+b)/2'e'represente'o'resultado'por'média'
3.'Mostre'o'valor'representado'por'média'

20. 1.b''–'Observações'(2)'
'
Melhoria'em'relação'ao'algoritmo'1.'(menor'ambigüidade)'
Algoritmos'são'usados'para'que'problemas'possam'ser'
solucionados'mecanicamente.'
Português'não'é'uma'boa'linguagem'para'fazer'algoritmos.'
(Ambígua,'prolixa,'etc)'
Para'fazer'algoritmos'usamnse'linguagens'algorítmicas'
'
'

21. 1.b'n'Exercícios''
Exercícios:'
'
Experimente'descrever'de'forma'precisa,'detalhada,'não'
ambígua,'tarefas'simples'do'co>diano'como:'
• Trocar'um'pneu'
• Trocar'uma'lâmpada'queimada'
• Escovar'os'dentes'
• Ler'as'horas'em'relógio'com'ponteiros'(analógico)'
• Re>rar'dinheiro'em'um'caixa'eletrônico'
Nem'tudo'é'tão'simples'quanto'parece.'Não'é'mesmo?'
'
''

22. 1.c'–'Formas'de'Representação'
Textual'' ' ' ' ' ' ' 'Gráfica'
1.Leia'
2.Calcule'
3.Escreva'
''''
'
'
''
Receba'
A,B'
X' X>Y'
Y'

23. 1.c'–'Símbolos'Gráficos'
Entradas'de'dados'
Cálculos'
Decisão'
Saídas'de'dados'
Operações'com'bancos'de'dados'
Início'e'Fim'

24. 1.d'–'Máquinas'para'Executar'Algoritmos'
Unidade'
de'
Entrada'
'''''''
''
Memória'Principal'
Unidade'
de'Saída'
Unidade'de'Lógica'e'
Aritmé>ca'
Unidade'De'Controle'
Programa' Dados'

25. 1.e'–'Estruturas'Básicas'
Estrutura'Seqüencial:'
'
Início'
Leia'(Receba)''
Calcule''
Escreva'
Fim'
Início'
Receba'
Calcule'
Escreva'
Fim'

26. 1.e'–'Estruturas'Básicas'
Estrutura'de'Decisão:'
'
Início'
Leia'(Receba)''
Se'<condicao>'for'verdade'
'''''faça'isto'
Senão'
'''''faça'aquilo'
Escreva'
Fim'
Início'
Escreva'
Receba'
Condição'
Fim'
Verdade'
Falso'

27. 1.e'–'Estruturas'Básicas'
Estrutura'de'Repe>ção:'
'
Início'
Leia'(Receba)''
Repita'10'vezes'
'faça'isso'
Escreva'
Fim'
Início'
Repita'10'vezes'
Faça'isto'
Fim'do'
Repita'
Fim'

28. 1.f'–'Linguagem'Algorítmica'
Portugol'(Português'Estruturado):'Comandos'e'Instruções're>rados'do'Português.'
'
Exemplos'de'Instruções:'
Leia':''Pára'a'execução'do'algoritmo'até'que'sejam'fornecidos'os'dados'especificados'
na'instrução.'Os'dados'são'guardados'na'lista'de'variáveis.'
'
Escreva:''Envia'dados'especificados'na'forma'de'variáveis''para'a'unidade'de'saída'
(Video/Impressão)'
'
Ex:'
'
Leia'A'
Escreva'A'
'
O'Algoritmo'acima'recebe'uma'informação'qualquer,'representa'esta'informação'
internamente'pelo'símbolo'A'(variável)'e'Envia'a'mesma'para'a'unidade'de'saída'
(imprime'no'vídeo,'por'exemplo)'
'

29. 2.'Linguagem'para'Algoritmos'
• A'u>lização'do'Portugol'facilita'a'compreensão'da'construção'de'algoritmos'
independente'de'qualquer'linguagem'de'programação,'no'entanto','nada'impede'que'
seja'u>lizada'uma'linguagem'de'programação'real'para'estudar'lógica.'
• Você'não'precisa'aprender'esperanto'para'depois'aprender'inglês'ou'francês.'Você'
nem'mesmo'precisa'falar'bem'português'para'aprender'outra'língua'...'
• Aqui'u>lizaremos'uma'linguagem'simples'sinta>camente'para'estudar'lógica'de'
programação'(Python)'
• Vá'no'site'h|p://www.python.org/'faça'o'“download”'do'python'para'o'OS'
(Windows,'Linux,'Mac'OS)'que'você'mais'gosta,'instaleno'e'vamos'começar.'A'
instalação'é'extremamente'fácil'e'alguns'Linux'já'o'trazem'instalado'por'“default”.'Se'
não'conseguir,'peça'ajuda';n).'
'

30. 2.a'Variáveis'
Variáveis'são'nomes'que'representam'dados.'Assemelhamnse'às'variáveis'da'álgebra.'
Na'prá>ca'representam'um'endereço'de'memória'e'um'>po'de'dado'que'está'
guardado'neste'endereço.'
'
Algumas'linguagens'são'restri>vas'com'relação'aos'>pos'de'dados'(Sistemas'
fortemente'>pados),''outras'não.''
'
Os'nomes'de'variáveis'devem'começar'com'caracteres'alfabé>cos'e'podem'ter'
restrições'de'tamanho.'
'
Exemplos'válidos:'''''''A,'a','_1,'nome,'x,y,'xx,'yy,'_taxa,'media''
'
Exemplos'inválidos:'''n1,'1nome,'234,'*8,'9,''/3,'!3,'?2,''

31. 2.a'Variáveis'n'Atribuição'
Uma'operação'de'atribuição'é'a'associação'de'um'valor'(dado)'a'uma'variável.'Usanse'
normalmente,'no'texto,'o'símbolo'de'igualdade''para'indicar'a'operação.'
'
Ex:''''''A'='2','nome'='‘Pedro’,'X'='Y'
'
Em'Portugol'costumanse'usar'a'seta''esquerda'!'para'atribuição.'
'
Ex.'A'!'2','nome''! ‘Pedro’,'X'!'Y'
'
A'Sintaxe'(forma'de'uso)'da'atribuição'pode'ser:'
<variavel>'='<expressão>'
'
Onde,'
'
<expressão>''pode'ser'um'literal,(outra'variável,''expressão'aritmé+ca(ou'expressão'
lógica(
'
Obs:'A'variável'fica'sempre'no'lado'esquerdo'e'é'seguida'imediatamente'pelo'
operador'de'atribuição.''
'

32. 2.a'Variáveis'n'literais'
Um'literal'pode'ser:'
'
• Um'número'inteiro':'''0,'1,'n987,'1024','etc'
• Um'número'com'ponto'decimal'(real'ou'float)':'n0.123,'5.67876,''etc'
• Caracteres:'‘A’,'“B”,'‘c‘'
• Cadeias'(seqüencias)'de'caracteres:''‘Maria'da'Penha’,'“Joao'do'Pulo”'
• Valores'lógicos:'True'(Verdade),'False'(Falso)'
OBS:''
1. Em'caracteres'ou'cadeias'(Strings)'usar'sempre'apóstrofos'ou'aspas'duplas''
''
''
''
'

33. 2.a'Variáveis'–'Expressões'aritmé>cas'
Uma'expressão'aritmé>ca'representa'um'cálculo'a'ser'realizado'(fórmula).'Pode'ser'
composta'de'literais,'variáveis'e'operadores.'
'
Ex.'
'''
Literais''
2''+''3'+'x'*'3'–'4'/'2'+'y''
Operadores'
Variáveis'

34. 2.a'Variáveis'–'Operadores'Aritmé>cos'
Os'principais'operadores'aritmé>cos'são:'
'
+'Soma''
n ''Subtração''
/'Divisão''
*'Mul>plicação'''
'
Os'operadores'mul>plicação'e'divisão'têm'prioridade'em'relação'a'soma'e'subtração.'
Podense'usar'parênteses'para'alterar'a'ordem'(dentro'do'parêntese'tem'prioridade).''
'
Exercício:'
Qual'o'valor'das'expressões'abaixo?'
'
1'+'2'*'3'
(1'+'2)'*'3'
6'/'3''n''1'
6'/'(3'–'1')'
''

35. 2.a'Variáveis'em'Expressões'
Qual'o'valor'final'das'variáveis'no'algoritmo'abaixo?'
'
1. X'='2'+'3'*'4'/'(2'+'2)'–'4'
2. Y'=''X'*'X'+''2'
3. X'='Y'
4. Y'='Y'+'1'
''
OBS:'
'
1. Atribuição'do'>po'Y'='Y'+'1'pode'ser'lida'da'seguinte'forma:'Considere'o'valor'
atual'de'Y,'some'1'e'coloque'o'resultado'na'própria'variável'Y.''Em'álgebra'poderia'
ser'representada'da'seguinte'forma'Yi+1'='Yi'+'1'ou''Y(T)'='Y(Tn1)''+'1.'
2. Quando'dois'operadores'tem'a'mesma'ordem'de'precedência,'a'operação'é'
executada'da'esquerda'para'a'direita.'
''
'

36. 2.a'Expressões'Lógicas'
Expressões'cujo'significado'(resultado'do'cálculo)'é'um'valor'de'verdade:'True'
(Verdade)'ou'False'(Falso).'U>liza'operadores'lógicos'e/ou'relacionais'
''''
Literais''
True'and''3'>'x'''
Operador'Lógico'
Variável'
Operador'Relacional'

37. 2.a'Operadores'Lógicos'
Os'principais'operadores'lógicos'são:'
'
and''nn'“e“''lógico.'Conec>vo'de'conjunção'lógica'
or'''''nn'“ou“'lógico.'Conec>vo'de'disjunção'
not''nn'“negação”'inversão'de'valor'lógico'
'
Qual'o'valor'final'das'variáveis'abaixo?'
'
X''''='True'and'False'
Y''''='True'or'False'
Z''''='True'
W''='not'Z'
''

38. 2.a'Tabelas'de'Verdade'
A" B" A"and"B" A"or"B" Not"A"
True'' True' True' True' False'
True' False' False' True' False'
False' True' False' True' True'
False' False' False' False' True'
True''='Verdadeiro'
False''='Falso'

39. 2.a'Operadores'Relacionais'
Os'principais'operadores'relacionais'são:'
'
>'''''n'Maior'do'que'
>='''n'Maior'ou'igual'a''''''
<'''''n'Menor'do'que'
<'=''n'Menor'ou'igual'a''
!='''n'Diferente'de''''
==''n'Igual'a''
Qual'o'valor'final'das'variáveis'abaixo?'
'
X''''=''2'=='3'
Y''''=''2''<''3'
Z''''=''2''>''3'
W''=''2'<='3'
K''''='''2'!=''3'
Q'''='''K'=='W'
'''
''

40. 2.a'Hora'de'Pra>car'
Ligar'o'Python,'criar'as'variáveis'dos'exemplos'fornecidos.'Mostrar'seus'valores.'Usar'
o'Python'como'uma'calculadora.'
'

41. Aula'2'–'Seqüências'e'Desvios''

42. 2.b'Entradas'e'Saídas'
Normalmente'em'uma'operação'de'entrada'de'dados,'a'execução'do'algoritmo'
(programa)'é'interrompida'até'que'determinadas'informações'sejam'fornecidas'a'
par>r'de'uma'das'unidades'de'entrada.'
'
Em'Portugol'usanse'a'instrução'Leia'para'operações'de'entrada.''
'
A'sintaxe'seria':'Leia'<'lista'de'variáveis>'
'
Ex.'Leia'a,b,c,..'
'
Os'dados'são'fornecidos'na'ordem'com'que'as'variáveis'estão'colocadas'na'instrução'
Leia'
'
Em'Python'usanse'o'comando'input.'Input'é'uma'função'que'recupera'dados'e'as'
disponibiliza'para'uma'variável'especificada.'
'
Sintaxe:'
<var>'='input(“Texto'a'ser'apresentado”)'
'

43. 2.b'Entradas'e'Saídas'
Ex:'
'
Nome'='input(“Digite'o'nome'do'fucionario”)'
Valor=input(“Digite'o'valor”)'
''
Experimente...'

44. 2.b'Entradas'e'Saidas'
Saidas'de'dados'implica'na'impressão'em'vídeo,'no'envio'de'dados'por'portas'de'
comunicação,'gravação'em'disco,'etc.'
'
No'momento'vamos'permanecer'u>lizando'as'saidas'em'vídeo.'Mais'tarde'veremos'as'
outras'formas.'
'
Em'portugol'usanse'a'instrução'“Escreva”'ou'“Imprima”'seguida'da'lista'de'variáveis,'
expressões'ou'literais'a'serem'impressos.'
'
Ex.'Escreve'“Maria'recebeu'R$”,salario,'“'este'mes”'
'
Resultado'deste'comando'poderia'ser':'Maria'recebeu'R$'500,00'este'mes.'
'
Em'Python'usanse'o'print.'
'
Sintaxe:''print'<expressão>''''#'Até'a'versão'2.5'
''''''''print(<Expressao>)'''#'A'par>r'da'versão'3'
''

45. 2.c'Algoritmos'Simples'
Calculando'a'médias'entre'dois'números'quaisquer.'
'
Em'portugol:'
'
Leia'A,B'
C!'(A+B)/2'
Escreva'C'
'
Em'Python:'
'
A'='input(“Digite'um'valor'para'A'”)'
B'='input(“Digite'um'valor'para'B'”)'
C'='(A+B)/2'
print'C'
''''
Início'
A,B'
C=(A+B)/2'
C'
FIM'

46. 2.c'Gravando'os'Fontes'
Use'o'IDLE'ou'outro'editor'qualquer'para'gravar'os'fontes.'(Nano'por'exemplo)'
'

47. 2.c'Exercícios'
Faça'programas'em'Python'para:'
'
a) Calcular'os'três'primeiros'múl>plos'de'um'dado'número'
b) Calcular'as'raízes'de'uma'equação'de'segundo'grau'(Que'tenha'raízes'reais)'
c) Calcular'a'área'de'um'círculo,'retângulo,'triângulo,'etc'
d) Calcular'o'valor'líquido'de'um'salário'dado,'dadas'também'as'alíquotas'dos'
impostos'sobre'o'valor'bruto.'
e) etc'
'

48. 2.c'Funções'Embu>das'
Linguagens'de'programação'costumam'ter'uma'série'de'funções'embu>das'para'a'
realização'de'operações''matemá>cas'básicas'como'cálculos'de'seno,'cosseno,'
tangentes,'logaritmos,'raiz'quadrada,'potenciação,'etc.'
'
Python'possui'uma'biblioteca'de'funções'em'um'pacote'chamado'math.'Para'u>lizánlo'
devemos'usar'a'instrução'import'math'e'as'seguintes'funções'estarão'disponíveis'
(entre'outras):'
'
math.exp(x)'–'Retorna'o'valor'de'ex''
math.sqrt(x)'–'Raiz'quadrada'de'x'
math.log10(x)'–'Logaritmo'base'10'de'x'
math.log(x)'–'Logaritmo'natural'de'x'
math.pow(x,y)'–'Valor'de'x'elevado'a'y'
math.sin(x),'math.cos(x),'math.tan(x)'–'Seno,'cosseno'e'tangente'de'x'respec>vamente'
math.pi'–'Constante'Pi'='3.141592...'
math.e''n'Constante'e'='2.718....'
''OBS:'1'–'Consultar'a'documentação'oficial'para'a'lista'completa'(h|p://docs.python.org)'
' ''2'–'O'Python'também'trabalha'com'números'complexos.'Ver'exemplos'no'tutorial'
'

49. 2.c'Mais'Operadores'
'
**''n'Operador'de'Exponenciação''2'**'3'equivale'a'math.pow(2,3)'
%'''n'Operador'resto'da'divisão.''4'%'2'tem'como'resultado'zero.'
''

50. 2.d'Desvios'Condicionais'
• Desvio'condicional'é'a'forma'de'permi>r'a'escolha'de'um'entre'múl>plos'fluxos'de'
execução'por'parte'da'máquina.'
• O'caso'mais'simples'se'dá'através'do'uso'da'instrução'“Se”'ou'“if”(Inglês).'
'
Sintaxe'do'“se”'
Em'portugol:'
'
Se'<'condição>'
'então'
' '<instruções'para'o'caso'verdade>'
'senão'
' '<instruções'para'o'caso'falso>'
Fimnse'
Em'Python:'
If'<condição>:'
'<bloco'de'instruções'para'o'caso'verdade>'
else:'
'<bloco'de'instrucoes'para'o'caso'falso>'
'
''

51. 2.d'Desvios'Aninhados'
Faça'algoritmos'para:'
'
Receber'três'números'e'selecionar'o'maior'entre'eles.'
'

52. 2.d'Desvios'Aninhados'
Solução:'
Início'
A,B,C'
Sim' Não'
A>C' A>B' B>C'
Sim' Não' Sim' Não'
C' B'
A' C'
FIM'

53. 2.d'Múl>plas'Opções'
Podemos'u>lizar'uma'estrutura'com'múl>plos'testes'usando'a'estrutura''se'...'senão'
se.'
Em'Portugol'seria:'
'
se'<condição1>'
'então'
' ' 'faça'isto'
'senao'se'<condicao2>'
' ' 'faça'isso'
'senão'se'<condição3>'
' ' 'faça'aquilo'outro'
'senão'se'<condicao4>'
' ' 'faça'outra'coisa'
fimnse'
'

54. 2.d'Múl>plas'Opções'
Podemos'u>lizar'uma'estrutura'com'múl>plos'testes'usando'a'estrutura''se'...'senão'
se.'
Em'Python:'
'
If''''<condição1>:'
' ' 'faça'isto'
elif'<condicao2>:'
' ' 'faça'isso'
elif'<condição3>:'
' ' 'faça'aquilo'outro'
else:'
' 'faça'quando'todas'as'anteriores'falharem''
''

55. Aula'3'n'Laços'

56. Aula'3'n'Laços'
Blocos'de'comandos'executados'repe>damente'.'

57. 2.e'Laços'Enquanto'(While)'
Um'laço'do'>po'enquanto'faz'com'que'um'bloco'de'comandos'seja'executado'
repe>damente'enquanto'uma'determinada'condição'for'verdadeira.'
'
Em'portugol:'
'
Enquanto'<Condição>'faça'
'<'bloco'de'comandos'>'
Fimnenquanto'
'
Em'Python:'
'
While<condição>:'
'bloco'de'comandos'
'

58. 2.e'Laços'Enquanto'(While)'
Seja'o'programa'abaixo'para'imprimir'os'números'de'0'a'1000:'
'
X=0'
While'x<=1000:'
'print'x'
'x'='x'+1'
'
Seja'o'programa'para'imprimir'os'números'pares'até'um'valor'dado:'
'
Limite'='input(“Digite'um'valor”)'
Contador'='0'
While'contador'<=Limite:'
'print'contador'
'contador'='contador'+'2'
'

59. 2.e'Laços'Enquanto'(While)'
Contador':'Uma'variável'que'serve'para'contar'sequencialmente'os'números'sendo'
usada'para'teste'de'condição'de'permanência'no'laço'
'
Acumulador:'Variável'que'acumula'os'resultado'de'sucessivas'operações'realizadas'
u>lizando'seu'próprio'valor'
'
Ex.'Seja'o'algoritmo'para'calcular'a'média'de'“n”'números'fornecidos'via'teclado:'
'
Contador'='0'
Acumulador'='0'
Quan>dade'='input(“Digite'a'quan>dade'de'números'a'ser'u>lizada”)'
while'contador'<'quan>dade:'
'numero'='input(“Digite'um'valor'numerico'“)'
'contador'='contador'+'1'
'acumulador'='acumulador'+'numero'
print''“A'soma'total'dos'números'fornecidos'é'“,Acumulador'
''
'

60. 2.e'Laços'Enquanto'(While)'
Vamos'Executánlo'passo'a'passo:'
'
Contador'='0'''''''''''''''''''''''''''''''''''''''''''Passo'1':'Declara'Contador'
Acumulador'='0'
Quan>dade'='input(“Digite'a'quan>dade'de'numeros'a'ser'u>lizada”)'
while'contador'<'quan>dade:'
'numero'='input(“Digite'um'valor'numerico'“)'
'contador'='contador'+'1'
'acumulador'='acumulador'+'numero'
print''“A'soma'total'dos'numeros'fornecidos'eh'“,Acumulador'
Contador':'0' '''''''
Saída'no'Vídeo'

61. 2.e'Laços'Enquanto'(While)'
Vamos'Executánlo'passo'a'passo:'
'
Contador'='0''''''''''''''''''''''''''''''''''''''''''''
Acumulador'='0'''''''''''''''''''''''''''''''''''''''Passo'2':'Declara'Acumulador'
Quan>dade'='input(“Digite'a'quan>dade'de'numeros'a'ser'u>lizada”)'
while'contador'<'quan>dade:'
'numero'='input(“Digite'um'valor'numerico'“)'
'contador'='contador'+'1'
'acumulador'='acumulador'+'numero'
print''“A'soma'total'dos'numeros'fornecidos'eh'“,Acumulador'
Variáveis' Saída'no'Vídeo'
Contador':'0'
Acumulador:'0'
'''''''

62. 2.e'Laços'Enquanto'(While)'
Vamos'Executánlo'passo'a'passo:'
'
Contador'='0''''''''''''''''''''''''''''''''''''''''''''
Acumulador'='0''''''''''''''''''''''''''''''''''''''''
Quan>dade'='input(“Digite'a'quan>dade'de'numeros'a'ser'u>lizada”)'
while'contador'<'quan>dade:'
'numero'='input(“Digite'um'valor'numerico'“)'
'contador'='contador'+'1'
'acumulador'='acumulador'+'numero'
print''“A'soma'total'dos'numeros'fornecidos'eh'“,Acumulador'
Variáveis' Saída'no'Vídeo'
Contador':'0'
Acumulador:'0'
'
Digite'a'quan>dade'de'numeros'a'ser'u>lizada''
'''''
Passo'3:'
Solicita'Valor'

63. 2.e'Laços'Enquanto'(While)'
Vamos'Executánlo'passo'a'passo:'
'
Contador'='0''''''''''''''''''''''''''''''''''''''''''''
Acumulador'='0''''''''''''''''''''''''''''''''''''''''
Quan>dade'='input(“Digite'a'quan>dade'de'numeros'a'ser'u>lizada”)'
while'contador'<'quan>dade:'
'numero'='input(“Digite'um'valor'numerico'“)'
'contador'='contador'+'1'
'acumulador'='acumulador'+'numero'
print''“A'soma'total'dos'numeros'fornecidos'eh'“,Acumulador'
Variáveis' Saída'no'Vídeo'
Contador':'0'
Acumulador:'0'
Quan>dade:'3'
'
Digite'a'quan>dade'de'numeros'a'ser'u>lizada'3''
'''''
Passo'3:'
Usuário'digita'valor'

64. 2.e'Laços'Enquanto'(While)'
Vamos'Executánlo'passo'a'passo:'
'
Contador'='0''''''''''''''''''''''''''''''''''''''''''''
Acumulador'='0''''''''''''''''''''''''''''''''''''''''
Quan>dade'='input(“Digite'a'quan>dade'de'numeros'a'ser'u>lizada”)'
while'contador'<'quan>dade:'
'numero'='input(“Digite'um'valor'numerico'“)'
'contador'='contador'+'1'
'acumulador'='acumulador'+'numero'
print''“A'soma'total'dos'números'fornecidos'eh'“,Acumulador'
Variáveis' Saída'no'Vídeo'
Contador':'0'
Acumulador:'0'
Quan>dade:'3'
'
Digite'a'quan>dade'de'numeros'a'ser'u>lizada'3''
'''''
Passo'4:'Início'do'laço'
Condição'verdadeira'
Contador'(0)'<'quan>dade'(3)'

65. 2.e'Laços'Enquanto'(While)'
Vamos'Executánlo'passo'a'passo:'
'
Contador'='0''''''''''''''''''''''''''''''''''''''''''''
Acumulador'='0''''''''''''''''''''''''''''''''''''''''
Quan>dade'='input(“Digite'a'quan>dade'de'numeros'a'ser'u>lizada”)'
while'contador'<'quan>dade:'
'numero'='input(“Digite'um'valor'numerico'“)'
'contador'='contador'+'1'
'acumulador'='acumulador'+'numero'
print''“A'soma'total'dos'numeros'fornecidos'eh'“,Acumulador'
Variáveis' Saída'no'Vídeo'
Contador':'0'
Acumulador:'0'
Quan>dade:'3'
'
Digite'a'quan>dade'de'numeros'a'ser'u>lizada'3'
Digite'um'valor'numerico''
''''
Passo'5:'Solicita'valor'
para'numero'

66. 2.e'Laços'Enquanto'(While)'
Vamos'Executánlo'passo'a'passo:'
'
Contador'='0''''''''''''''''''''''''''''''''''''''''''''
Acumulador'='0''''''''''''''''''''''''''''''''''''''''
Quan>dade'='input(“Digite'a'quan>dade'de'numeros'a'ser'u>lizada”)'
while'contador'<'quan>dade:'
'numero'='input(“Digite'um'valor'numerico'“)'
'contador'='contador'+'1'
'acumulador'='acumulador'+'numero'
print''“A'soma'total'dos'numeros'fornecidos'eh'“,Acumulador'
Variáveis' Saída'no'Vídeo'
Contador':'0'
Acumulador:'0'
Quan>dade:'3'
numero':'2''
'
Digite'a'quan>dade'de'numeros'a'ser'u>lizada'3'
Digite'um'valor'numerico'2''
''''
Passo'5:'Usuário'
Fornece'Valor'Numérico'
(2)'

67. 2.e'Laços'Enquanto'(While)'
Vamos'Executánlo'passo'a'passo:'
'
Contador'='0''''''''''''''''''''''''''''''''''''''''''''
Acumulador'='0''''''''''''''''''''''''''''''''''''''''
Quan>dade'='input(“Digite'a'quan>dade'de'numeros'a'ser'u>lizada”)'
while'contador'<'quan>dade:'
'numero'='input(“Digite'um'valor'numerico'“)'
'contador'='contador'+'1'
'acumulador'='acumulador'+'numero'
print''“A'soma'total'dos'numeros'fornecidos'eh'“,Acumulador'
Variáveis' Saída'no'Vídeo'
Contador':'1'
Acumulador:'0'
Quan>dade:'3'
numero':'2''
'
Digite'a'quan>dade'de'numeros'a'ser'u>lizada'3'
Digite'um'valor'numerico'2''
''''
Passo'6:'contador'é'incrementado'

68. 2.e'Laços'Enquanto'(While)'
Vamos'Executánlo'passo'a'passo:'
'
Contador'='0''''''''''''''''''''''''''''''''''''''''''''
Acumulador'='0''''''''''''''''''''''''''''''''''''''''
Quan>dade'='input(“Digite'a'quan>dade'de'numeros'a'ser'u>lizada”)'
while'contador'<'quan>dade:'
'numero'='input(“Digite'um'valor'numerico'“)'
'contador'='contador'+'1'
'acumulador'='acumulador'+'numero'
print''“A'soma'total'dos'numeros'fornecidos'eh'“,Acumulador'
Variáveis' Saída'no'Vídeo'
Contador':'1'
Acumulador:'2'
Quan>dade:'3'
numero':'2''
'
Digite'a'quan>dade'de'numeros'a'ser'u>lizada'3'
Digite'um'valor'numerico'2''
''''
Passo'7:'Acumulador'é'
acrescido'do'valor'de'numero'

69. 2.e'Laços'Enquanto'(While)'
Vamos'Executánlo'passo'a'passo:'
'
Contador'='0''''''''''''''''''''''''''''''''''''''''''''
Acumulador'='0''''''''''''''''''''''''''''''''''''''''
Quan>dade'='input(“Digite'a'quan>dade'de'numeros'a'ser'u>lizada”)'
while'contador'<'quan>dade:'
'numero'='input(“Digite'um'valor'numerico'“)'
'contador'='contador'+'1'
'acumulador'='acumulador'+'numero'
print''“A'soma'total'dos'numeros'fornecidos'eh'“,Acumulador'
Variáveis' Saída'no'Vídeo'
Contador':'1'
Acumulador:'2'
Quan>dade:'3'
numero':'2''
'
Digite'a'quan>dade'de'numeros'a'ser'u>lizada'3'
Digite'um'valor'numerico'2''
''''
Passo'8:''Próxima'Iteração'do'laço.'
Condicão'ainda'é'verdadeira'

70. 2.e'Laços'Enquanto'(While)'
Vamos'Executánlo'passo'a'passo:'
'
Contador'='0''''''''''''''''''''''''''''''''''''''''''''
Acumulador'='0''''''''''''''''''''''''''''''''''''''''
Quan>dade'='input(“Digite'a'quan>dade'de'numeros'a'ser'u>lizada”)'
while'contador'<'quan>dade:'
'numero'='input(“Digite'um'valor'numerico'“)'
'contador'='contador'+'1'
'acumulador'='acumulador'+'numero'
print''“A'soma'total'dos'numeros'fornecidos'eh'“,Acumulador'
Variáveis' Saída'no'Vídeo'
Contador':'1'
Acumulador:'2'
Quan>dade:'3'
numero':'2''
'
Digite'a'quan>dade'de'numeros'a'ser'u>lizada'3'
Digite'um'valor'numerico'2'
Digite'um'valor'numerico''
'''
Passo'9:''Solicita'valor'para'numero'

71. 2.e'Laços'Enquanto'(While)'
Vamos'Executánlo'passo'a'passo:'
'
Contador'='0''''''''''''''''''''''''''''''''''''''''''''
Acumulador'='0''''''''''''''''''''''''''''''''''''''''
Quan>dade'='input(“Digite'a'quan>dade'de'numeros'a'ser'u>lizada”)'
while'contador'<'quan>dade:'
'numero'='input(“Digite'um'valor'numerico'“)'
'contador'='contador'+'1'
'acumulador'='acumulador'+'numero'
print''“A'soma'total'dos'números'fornecidos'eh'“,Acumulador'
Variáveis' Saída'no'Vídeo'
Contador':'1'
Acumulador:'2'
Quan>dade:'3'
numero':'4''
'
Digite'a'quan>dade'de'numeros'a'ser'u>lizada'3'
Digite'um'valor'numerico'2'
Digite'um'valor'numerico'4''
'''
Passo'9:''Usuário'digita'valor'(4)'

72. 2.e'Laços'Enquanto'(While)'
Vamos'Executánlo'passo'a'passo:'
'
Contador'='0''''''''''''''''''''''''''''''''''''''''''''
Acumulador'='0''''''''''''''''''''''''''''''''''''''''
Quan>dade'='input(“Digite'a'quan>dade'de'numeros'a'ser'u>lizada”)'
while'contador'<'quan>dade:'
'numero'='input(“Digite'um'valor'numerico'“)'
'contador'='contador'+'1'
'acumulador'='acumulador'+'numero'
print''“A'soma'total'dos'numeros'fornecidos'eh'“,Acumulador'
Variáveis' Saída'no'Vídeo'
Contador':'2'
Acumulador:'2'
Quan>dade:'3'
numero':'4''
'
Digite'a'quan>dade'de'numeros'a'ser'u>lizada'3'
Digite'um'valor'numerico'2'
Digite'um'valor'numerico'4''
'''
Passo'10:''Contador'é'incrementado'

73. 2.e'Laços'Enquanto'(While)'
Vamos'Executánlo'passo'a'passo:'
'
Contador'='0''''''''''''''''''''''''''''''''''''''''''''
Acumulador'='0''''''''''''''''''''''''''''''''''''''''
Quan>dade'='input(“Digite'a'quan>dade'de'numeros'a'ser'u>lizada”)'
while'contador'<'quan>dade:'
'numero'='input(“Digite'um'valor'numerico'“)'
'contador'='contador'+'1'
'acumulador'='acumulador'+'numero'
print''“A'soma'total'dos'numeros'fornecidos'eh'“,Acumulador'
Variáveis' Saída'no'Vídeo'
Contador':'2'
Acumulador:'6'
Quan>dade:'3'
numero':'4''
'
Digite'a'quan>dade'de'numeros'a'ser'u>lizada'3'
Digite'um'valor'numerico'2'
Digite'um'valor'numerico'4''
'''
Passo'11:''Acumulador'é'acrescido'de'
numero'

74. 2.e'Laços'Enquanto'(While)'
Vamos'Executánlo'passo'a'passo:'
'
Contador'='0''''''''''''''''''''''''''''''''''''''''''''
Acumulador'='0''''''''''''''''''''''''''''''''''''''''
Quan>dade'='input(“Digite'a'quan>dade'de'numeros'a'ser'u>lizada”)'
while'contador'<'quan>dade:'
'numero'='input(“Digite'um'valor'numerico'“)'
'contador'='contador'+'1'
'acumulador'='acumulador'+'numero'
print''“A'soma'total'dos'numeros'fornecidos'eh'“,Acumulador'
Variáveis' Saída'no'Vídeo'
Contador':'2'
Acumulador:'6'
Quan>dade:'3'
numero':'4''
'
Digite'a'quan>dade'de'numeros'a'ser'u>lizada'3'
Digite'um'valor'numerico'2'
Digite'um'valor'numerico'4''
'''
Passo'12:''Proxima'Iteração'
Condição'verdadeira'
Contador'(2)''<'quan>dade'(3)'

75. 2.e'Laços'Enquanto'(While)'
Vamos'Executánlo'passo'a'passo:'
'
Contador'='0''''''''''''''''''''''''''''''''''''''''''''
Acumulador'='0''''''''''''''''''''''''''''''''''''''''
Quan>dade'='input(“Digite'a'quan>dade'de'numeros'a'ser'u>lizada”)'
while'contador'<'quan>dade:'
'numero'='input(“Digite'um'valor'numerico'“)'
'contador'='contador'+'1'
'acumulador'='acumulador'+'numero'
print''“A'soma'total'dos'numeros'fornecidos'eh'“,Acumulador'
Variáveis' Saída'no'Vídeo'
Contador':'2'
Acumulador:'6'
Quan>dade:'3'
numero':'4''
'
Digite'a'quan>dade'de'numeros'a'ser'u>lizada'3'
Digite'um'valor'numerico'2'
Digite'um'valor'numerico'4'
Digite'um'valor'numerico'''
''
Passo'13:''Solicita'dado'

76. 2.e'Laços'Enquanto'(While)'
Vamos'Executánlo'passo'a'passo:'
'
Contador'='0''''''''''''''''''''''''''''''''''''''''''''
Acumulador'='0''''''''''''''''''''''''''''''''''''''''
Quan>dade'='input(“Digite'a'quan>dade'de'numeros'a'ser'u>lizada”)'
while'contador'<'quan>dade:'
'numero'='input(“Digite'um'valor'numerico'“)'
'contador'='contador'+'1'
'acumulador'='acumulador'+'numero'
print''“A'soma'total'dos'numeros'fornecidos'eh'“,Acumulador'
Variáveis' Saída'no'Vídeo'
Contador':'2'
Acumulador:'6'
Quan>dade:'3'
numero':'6''
'
Digite'a'quan>dade'de'numeros'a'ser'u>lizada'3'
Digite'um'valor'numerico'2'
Digite'um'valor'numerico'4'
Digite'um'valor'numerico'6'''
''
Passo'13:''Usuário'
fornece'dado'

77. 2.e'Laços'Enquanto'(While)'
Vamos'Executánlo'passo'a'passo:'
'
Contador'='0''''''''''''''''''''''''''''''''''''''''''''
Acumulador'='0''''''''''''''''''''''''''''''''''''''''
Quan>dade'='input(“Digite'a'quan>dade'de'numeros'a'ser'u>lizada”)'
while'contador'<'quan>dade:'
'numero'='input(“Digite'um'valor'numerico'“)'
'contador'='contador'+'1'
'acumulador'='acumulador'+'numero'
print''“A'soma'total'dos'numeros'fornecidos'eh'“,Acumulador'
Variáveis' Saída'no'Vídeo'
Contador':'3'
Acumulador:'6'
Quan>dade:'3'
numero':'6''
'
Digite'a'quan>dade'de'numeros'a'ser'u>lizada'3'
Digite'um'valor'numerico'2'
Digite'um'valor'numerico'4'
Digite'um'valor'numerico'6'''
''
Passo'14:'contador'incrementado'

78. 2.e'Laços'Enquanto'(While)'
Vamos'Executánlo'passo'a'passo:'
'
Contador'='0''''''''''''''''''''''''''''''''''''''''''''
Acumulador'='0''''''''''''''''''''''''''''''''''''''''
Quan>dade'='input(“Digite'a'quan>dade'de'numeros'a'ser'u>lizada”)'
while'contador'<'quan>dade:'
'numero'='input(“Digite'um'valor'numerico'“)'
'contador'='contador'+'1'
'acumulador'='acumulador'+'numero'
print''“A'soma'total'dos'numeros'fornecidos'eh'“,Acumulador'
Variáveis' Saída'no'Vídeo'
Contador':'3'
Acumulador:'12'
Quan>dade:'3'
numero':'6''
'
Digite'a'quan>dade'de'numeros'a'ser'u>lizada'3'
Digite'um'valor'numerico'2'
Digite'um'valor'numerico'4'
Digite'um'valor'numerico'6'''
''
Passo'15:'Acumulador'acrescido'
de'numero'

79. 2.e'Laços'Enquanto'(While)'
Vamos'Executánlo'passo'a'passo:'
'
Contador'='0''''''''''''''''''''''''''''''''''''''''''''
Acumulador'='0''''''''''''''''''''''''''''''''''''''''
Quan>dade'='input(“Digite'a'quan>dade'de'numeros'a'ser'u>lizada”)'
while'contador'<'quan>dade:'
'numero'='input(“Digite'um'valor'numerico'“)'
'contador'='contador'+'1'
'acumulador'='acumulador'+'numero'
print''“A'soma'total'dos'numeros'fornecidos'eh'“,Acumulador'
Variáveis' Saída'no'Vídeo'
Contador':'3'
Acumulador:'12'
Quan>dade:'3'
numero':'6''
'
Digite'a'quan>dade'de'numeros'a'ser'u>lizada'3'
Digite'um'valor'numerico'2'
Digite'um'valor'numerico'4'
Digite'um'valor'numerico'6'''
''
Passo'16:'Próxima'Iteração'
Condicão'falsa'
Contador'(3)'<'quan>dade'(3)'

80. 2.e'Laços'Enquanto'(While)'
Vamos'Executánlo'passo'a'passo:'
'
Contador'='0''''''''''''''''''''''''''''''''''''''''''''
Acumulador'='0''''''''''''''''''''''''''''''''''''''''
Quan>dade'='input(“Digite'a'quan>dade'de'numeros'a'ser'u>lizada”)'
while'contador'<'quan>dade:'
'numero'='input(“Digite'um'valor'numerico'“)'
'contador'='contador'+'1'
'acumulador'='acumulador'+'numero'
print''“A'soma'total'dos'numeros'fornecidos'eh'“,Acumulador'
Variáveis' Saída'no'Vídeo'
Contador':'3'
Acumulador:'12'
Quan>dade:'3'
numero':'6''
'
Digite'a'quan>dade'de'numeros'a'ser'u>lizada'3'
Digite'um'valor'numerico'2'
Digite'um'valor'numerico'4'
Digite'um'valor'numerico'6'
A'soma'total'dos'numeros'fornecidos'eh'12'''
''
Passo'17:'Saida'de'resultado'no'
video'

81. 2.e'Laços'Enquanto'(While)'
'
Resumo'do'algoritmo:'
'
Entradas:'3,2,4,6'
'
Saída:'12'

82. 2.e'Laços'Enquanto'(While)'
'
Alguns'exercícios:'
'
Modifique'o'programa'anterior'para'calcular'a'média'aritmé>ca'dos'números'
fornecidos'
Faça'um'programa'para'verificar'se'um'número'é'primo''
(N'é'um'valor'qualquer)'
'
Faça'um'programa'para'imprimir'as'seguintes'séries:'
a) 2,4,16,'256'..............N'
b) 0,'1,3,6,10,15'.........'N'
c) 0,N,1,Nn1,2,Nn2........N,0'
d) 1,1,2,3,5,8'...............N'
'
OBS:'o'item'd'é'a'série'conhecida'como'série'de'Fibonacci.'Consulte'a'Wikipedia'para'
ver'o'histórico'desta'série.'A'seguir'veremos'como'implementánlas.'
'

83. 2.e'Números'primos'
Lógica:'
'
Dividir'o'número'sucessivamente'por'2,3,4'....'até'sua'metade'(numero/2)'e'contar'
quantas'divisões'foram'exatas.'Caso'nenhuma'deu'exata'o'número'é'primo.'
''
Solução:'
'
Programa11.py'
'

84. 2.e''Gerando'séries'simples'(1)'
Lógica:'
'
Fazer'uma'variável'mudar'de'valor'gerando'e'imprimindo'os'números'da'série:'
2,4,16,'256'..............N'
'
Detalhe:'Os'números'se'sucedem'pelo'quadrado'do'anterior.'
'
Solução:'Programa12.py'
'

85. 2.e''Gerando'séries'simples'(2)'
Lógica:'
'
Fazer'uma'variável'mudar'de'valor'gerando'e'imprimindo'os'números'da'série:'
0,'1,3,6,10,15'.........'N'
'
Detalhe:'Tratanse'de'uma'PA'com'razão'crescente.''
'
Solução:'Programa13.py'
'

86. 2.e''Gerando'séries'simples'(3)'
Lógica:'
'
Fazer'uma'variável'mudar'de'valor'gerando'e'imprimindo'os'números'da'série:'
0,N,1,Nn1,2,Nn2........N,0'
''
Detalhe:'Uma'série'com'valores'crescentes'intercalados'com'valores'decrescentes''
'
Solução:'Programa14.py'
'

87. 2.e''Gerando'a'série'de'Fibonacci'
Lógica:'
'
Fazer'uma'variável'mudar'de'valor'gerando'e'imprimindo'os'números'da'série:'
1,1,2,3,5,.....N'
'
Detalhe:'Uma'série'onde'o'próximo'valor'é'a'soma'dos'dois'anteriores''
'
Solução:''
a) Programa15.py'
b) Programa16.py'
'

88. 2.e''Uma'pequena'pausa'
'
Python'possui'um'pacote'chamado'random'que'permite'a'geração'de'números'
aleatórios.'Uma'forma'de'u>lização'básica'seria:'
Import'random'
random.seed()'''#'inicializa'o'gerador'
random.randint(1,99)''#'gera'um'número'aleatório'de'1'a'99'
'
nnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnn'
'
Com'o'conhecimento'acima'desenvolva'um'jogo'de'adivinhação'onde'cada'jogador'
executa'o'jogo'e'ganha'aquele'que'>ver'feito'menos'tenta>vas'em'acertar'o'
número'aleatório'gerado.'
'
Solução:''
Programa17.py'
'
Não'se'iluda:'Seu''QI'(Quociente'de'Inteligência)'é'inversamente'proporcional'ao'
número'de'tenta>vas'que'você'faça.'
''

89. 2.e'Um'novo'>po'de'variável'(Listas)'
Uma'lista'é'uma'seqüência'de'dados'de'um'>po'qualquer.'
'
Exs.'
'
A'='[10,'12,'34,'45]'
B'='[“Maria”,”Pedro”,”Paulo”,'“Tiago”]'
'
Use'o'Python'para'criar'e'imprimir'listas.'
'
A'variável'que'representa'a'lista'pode'ser'indexada'para'recuperar'um'elemento'da'
lista.'O'primeiro'elemento'possui'índice'0'e'os'seguintes'variam'com'incremento'
de'1'
Ex.'
A[0]'é'10,''A[1]''é'12,'A[2]'é'34,'A[3]'é'45'
B[0]'é'“Maria”,''etc.'
'
print'lista[X]'':'Escreve'o'elemento'na'posição'X'da'lista'“lista”'
A[X]=<valor>':'Atribui'um'valor'à'posição'X'da'lista'A'
B[Z]=B[W]'"'Variáveis'indexadas'podem'ser'usadas'livremente'em'expressões'
''

90. 2.e'Uma'lista'como'um'vetor'
Um'vetor'é'uma'grandeza'normalmente'representado'pelos'valores'de'suas'
coordenadas'no'espaço.'
'
Um'vetor'no'espaço'cartesiano'pode'ser'representado'pelas'coordenadas'(X,Y)'ou'
(X[1],X[2])'ou'na'notação'do'Python'[X[0],X[1]]'
'
Em'um'espaço'tridimensional'o'vetor'seria'[X[0],X[1],X[2]]'
'
No'espaço'“n”'dimensional'um'vetor'seria':'[X[0],X[1],'X[2]'.....X[Nn1]]'
'
A'diferença'entre'uma'lista'e'um'vetor'em'python'tem'a'ver'apenas'com'a'forma'
como'você'olha'para'os'dados.'
'
Para'criar'a'lista'vazia:'
X=[]'
Ou'preenchida'
X='[<valores'separados'por'virgulas>]'

91. 2.e'Operações'com'listas'
"
append(x)(
Adiciona'um'item'ao'fim'da'lista;'equivalente'a'a[len(a):]'='[x].$
extend(L)(
Extende'a'lista'adicionando'no'fim'todos'os'elementos'da'lista'passada'como'
parâmetro;'equivalente'a'a[len(a):]'='L.$
insert(i,(x)(
Insere'um'item'em'uma'posição'especificada.'O'primeiro'argumento'é'o'índice'do'
elemento'anterior'ao'que'está'para'ser'inserido,'assim'a.insert(0,'x)$insere$no$início$da$
lista,$e$a.insert(len(a),$x)$é$equivalente'a'a.append(x).$
remove(x)(
Remove'o'primeiro'item'da'lista'cujo'valor'é'x.$É$gerado$um$erro$se$este$valor$não$
exis<r.$

92. 2.e'Operações'com'listas'
pop([i(])(
Remove'o'item'na'posição'dada'e'o'retorna.'Se'nenhum'item'for'especificado,'a.pop()'
remove'e'retorna'o'úl>mo'item'na'lista.'(Os'colchetes'ao'redor'de'i$indicam$que$o$
parâmetro$é$opcional,$não$que$você$deva$digitánlos'naquela'posição.'Você'verá'essa'
notação'com'frequência'na'Referência$da$Biblioteca$Python.)$
index(x)(
Retorna'o'índice'do'primeiro'item'cujo'valor'é'igual'ao'argumento'fornecido'em'x,$
gerando$erro$se$este$valor'não'existe'
count(x)(
Retorna'o'número'de'vezes'que'o'valor'x$aparece$na$lista.$
sort()"
Ordena'os'itens'da'lista'sem'gerar'uma'nova'lista.'
reverse()"
Inverte'a'ordem'dos'elementos'na'lista'sem'gerar'uma'nova'lista.'
'
Um'novo'operador''“in”''(Pertence)'
Sintaxe:'
A'in'B'
Retorna'verdadeiro'se'A'pertence'a'B'

93. Aula'4'–'Introdução'às'Estruturas'de'Dados'

94. 2.e'Matrizes'
Matrizes'são'conjuntos'de'dados'normalmente'representados'na'forma'de'tabelas:'
'
Ex.'
1 2'''3'
2 5'''6'
Maria'Pedro'
Joana'Paulo'
'
A'posição'dos'elementos'é'iden>ficada'pelo'numero'da'linha'e'da'coluna'em'que'se'
localiza'o'elemento.'
Uma'matriz'pode'ser'vista'como'uma'lista'composta.'Onde'cada'linha''ou'cada'coluna'
seria'uma'sublista.'
Declarar'uma'matriz'em'Python'é'fácil:'
'
A=[[3,2,3],[4,5,6]]'
Ou'
B=[[‘Maria’,’Pedro’],[‘Joana’,’Paulo’]]'
'

95. 2.e'Matrizes'de'Matrizes?'
Sem'problemas:'
'
Veja'
''
X[0]'=''''1''2'
'''''''3''4'
'
X[1]''=''''‘Pedro’''''‘Paulo’'
''''''''‘Maria’''''‘Joana’'
''
X=[[[1,2],[3,4]],[[‘Pedro’,’Paulo’],[‘Maria’,’Joana’]]]'
''
Quem'é''X[0][1][0]'?'
''''

96. 2.e'Exercícios'com'listas'
• Receba'um'vetor'elemento'por'elemento'do'teclado'e'coloque'em'uma'lista.'
• Selecione'o'maior'e'o'menor'elemento'de'um'vetor'
• Calcule'a'média'aritmé>ca'dos'elementos'de'um'vetor'
• Receba'um''vetor'e'inverta'a'ordem'dos'elementos'(Sem'usar'a'função'reverse)'
• Encontre'a'posição'de'um'elemento'em'uma'lista'(Pesquisa'Linear)'
• Selecione'os'elementos'pares'de'um'vetor'
• Selecione'os'elementos'pares'de'um'vetor'e'copie'para'o'segundo'vetor.'
• Crie'um'vetor'com'valores'intercalados'de'dois'outros'vetores'
'
'''

97. 2.e'Exercícios'com'listas'
• Receba'um'vetor'elemento'por'elemento'do'teclado'e'coloque'em'uma'lista.'
• Dica:'Os'elementos'são'adicionados'através'da'função'append()'
• Solução:'programa18.py''
'
''
'''

98. 2.e'Exercícios'com'listas'
• Selecione'o'maior'e'o'menor'elemento'de'um'vetor'
• Dica:'Usar'duas'variáveis.'Uma'para'guardar'o'maior'valor'e'outra'pra'guardar'o'
menor.''Inicialmente'o'primeiro'elemento'do'vetor'é'atribuído'às'mesmas.'Em'
seguida'comparanse'todos'os'elementos'do'vetor'com'estas'variáveis.'Se'o'
elemento'do'vetor'for'menor'que'a'variável'menor'trocamos'o'valor'de'menor.'A'
mesma'coisa'para'a'variável'maior.'
• Solução:'programa19.py'
''
'''

99. 2.e'Exercícios'com'listas'
• Calcule'a'média'aritmé>ca'dos'elementos'de'um'vetor'
• Dica:'Somar'todos'os'elementos'do'vetor'através'de'um'acumulador'e'em'seguida'
dividir'pelo'número'de'elementos'do'vetor.'
• Solução:'programa20.py'
'
'''

100. 2.e'Exercícios'com'listas'
• Receba'um''vetor'e'inverta'a'ordem'dos'elementos'(Sem'usar'a'função'reverse)'
• Dica:'podemos'inverter'o'vetor'e'depois'imprimir'ou'simplesmente'imprimir'na'
ordem'inversa.'Para'isso'usar'uma'variável'contadora'decrescente.'
'
• Solução:'programa21.py'
''
'''

101. 2.e'Exercícios'com'listas'
• Encontre'a'posição'de'um'elemento'em'uma'lista'(Pesquisa"Linear)"
• Dica:'Comparar'todos'os'elementos'do'vetor'usando'um'laço'e'guardar'a'posição'em'
que'o'elemento'procurado'foi'encontrado'
• Solução:'programa22.py'
''
'''

102. 2.e'Exercícios'com'listas'
• Selecione'os'elementos'pares'de'um'vetor'
• 'Use'um'laço'para'acessar'todos'os'elementos'do'vetor.'Imprimir'todos'os'que'forem'
pares'
• Solução:'programa23.py'
'''
'''

103. 2.e'Exercícios'com'listas'
• Selecione'os'elementos'pares'de'um'vetor'e'copie'para'o'segundo'vetor.'
• Dica:'Idên>co'ao'anterior.'Apenas'com'o'detalhe'de'adicionar'o'elemento'par'
encontrado'a'um'outro'vetor'
'
• Solução:'programa24.py'
''
'''

104. 2.e'Exercícios'com'listas'
• Crie'um'vetor'com'valores'intercalados'de'dois'outros'vetores'
• Usar'varáveis'“índices”.''Uma'para'cada'vetor.'Crie'um'laço'para'criar'o'terceiro'
vetor'e'use'os'índices'de'cada'vetor'para'pegar'os'elementos'deles'e'adicionar'ao'
terceiro'
• Solução:'programa25.py'
''
'''

105. 2.e'Composição'de'Laços'
• que'acontece'quando'colocamos'uma'laço'dentro'de'outro'(Aninhados)?'
• Experimente:'
#'programa26'
x'='0'
while'x'<'10:'
'y=0'
'while'y'<'10':'
' 'print'“x'='“,x',”'y'='“,y'
' 'y'='y'+'1'
'x'='x'+'1'
#'fim'do'programa'
'
Qual'a'saída?'
Quantas'vezes'ele'executou'o'comando'print?'
'

106. 2.e'Composição'de'Laços'
Exercícios:'
'
• Faça'um'programa'para'imprimir'a'tabuada'de'mul>plicar'
Solução:''Programa27.py'
'
• Simule'um'odômetro'digital'no'vídeo'com'(por'exemplo)'segundos,'minutos'e'horas''
Solução:'programa28.py'
''''

107. 2.e'Gerando'Séries'com'range()'
Sintaxe:'
'
range(inicio,fim,passo)'
'
Experimente.'
''''

108. 2.e'Laço'for'
Sintaxe:'
'
Em'portugol:'
'
para''i'='1,n'
'<comandos>'
fimnpara'
'
Em'Python:'
'
For'<var>'in'<lista>'
'<comandos>'
'
Experimente.'
for'i'in'[0,1]:'
'print'i'
'''
Inicio'
Enquanto/
Para'
Calcule'
Fim'

109. 2.e'break,'con>nue,'else'
• O'break,'como'no'C,'quebra'o'laço'mais'interno'de'um'for'ou'while.'
• O'con>nue,'também'emprestado'do'C,'con>nua'o'próximo'passo'do'laço'mais'
interno.'
• Laços'podem'ter'uma'cláusula'else,'que'é'executada'sempre'que'o'laço'se'encerra'
por'exaustão'da'lista'(no'caso'do'for)'ou'quando'a'condição'se'torna'falsa'(no'caso'
do'while),'mas'nunca'quando'o'laço'é'encerrado'por'um''break.'Isto'é'exemplificado'
no'próximo'exemplo'que'procura'números'primos:'
Ver'programa29.py'

110. 2.e'Pausa'–'Concatenação'
'
É'possível'somar'valores'alfanuméricos:'
'
‘a’'+'‘b’'
'
nome'='‘Paulo’'
sobrenome'='‘Pedreira’'
Espaco'='‘''‘'
'
str'='nome''+'espaco'+'sobrenome'
'
str'='?'
'''

111. 2.f'Funções'definidas'pelo'usuário'
'''
Em'portugol:'
'
Definição:'
Função'nome(lista'de'argumentos)'
'<comandos>'
'retorne'<valor>'
'
Fimnfuncao'
'
Chamada:'
'x'='nome(valores)'
'
Em'Python'
'
def'nome(args):'
'<comandos>'
' '[return'<valor>]'#'opcional'
''

112. 2.f'Funções'definidas'pelo'usuário'
'''
Exemplo'1.'Função'fatorial'
'
fat(n)'='1'se'n'='0'
fat(n)'='n*'fat(nn1)''para'n'>'0'
'
Solução'
'
Programa30.py'
''
Obs:'Leia'o'tutorial'oficial'do'python'para'ver'as'possíveis'formas'de'criação'de'funções'
''

113. 2.f'Funções'definidas'pelo'usuário'
'''
Faça'alguns'exercícios:'
'
1. Defina'uma'função'que'gere'a'série'de'Fibonacci'até'determinado'valor'“n”'
passado''como'argumento'
2. Crie'uma'função'para'fatorar'um'número'inteiro'
3. Crie'funções'para'achar'o'mdc,'mmc','etc'de'um'número.'
• Detalhe':'vc'pode'criar'o'seu'próprio'pacote'de'funções'para'uso'posterior.'
''

114. Fim'da'Aula'4'
'''

115. Aula'5'n'Recursão'
'''

116. Função'Recursiva'
'''
Uma'função'recursiva'é'aquela'que'chama'a'si'própria:'
'
def'funcao_recursiva(arg):'
'#'
'#''faz'qualquer'coisa'
'funcao_recursiva(arg2)''#'chama'a'si'própria'
''
Algumas'funções'são,'por'definição,'recursivas.'Um'exemplo'é'a'função'fatorial.'
'
A'função'fatorial'é'definida'como:'
'
fat(o)''é'1'
fat(n)''é'n'*'fat'(nn1)'
'
Desta'forma'ela'se'torna'mais'fácil'de'implementar'que'a'versão'itera>va'que'
fizemos.'Programa31.py'
'

117. 1.'O'programa'chama'fat'passando'3'como'argumento'fat(3)'
'1.1'Criada'a'instância'1'da'função'fat'
'1.2'A'fat1'testa'o'valor'de'n''<'0'(falso)'
'1.3'A'fat1'testa'se'o'valor'de'n'=='0'(falso)'
1.4'A'fat1''mul>plica'n'pelo'resultado'de'chamar'fat(2)'''
1.4.1'Criada'a'instância'2'da'função'fat'com'n'=''2'
1.4.2'a'fat2'testa'se'n''<'0'(falso)'
1.4.3'a'fat2'testa'se''n'=='0''(falso)'
1.4.4'a'fat2'pega'seu'n'(2)'e'mul>plica'por'fat(1)'
'1.4.4.1'Criada'a'instância'3'de'fat'
'1.4.4.2'a'fat3'testa'se'n(1)'<'0'(falso)'
'1.4.4.3'a'fat3'testa'se'n'=='0'''(falso)'
'1.4.4.4'a'fat3'pega'seu'n'(1)''e'mul>plica'por'fat('0)'
' ' '1.4.4.4.1'criada'a'instância'4'de'fat'com'n'=0' ' ' ''''
' '1.4.4.4.2'a'fat4'testa'se'n'(0)'é'menor'que'0'(falso)'
' ' '1.4.4.4.3'a'fat4'testa'se'n'=='0'(verdade)'e'retorna'1'(FIM)'
'1.4.4.5'a'fat3'recebe'o'retorno'da'fat4'(1)'e'mul>plica'por'n'(1)'
'1.4.4.6'a'fat3'retorna'1'(FIM)'
1.4.5'a'fat2'recebe'o'retorno'de'fat3'(1)'e'mul>plica'por'n'(2)'
1.4.6'a'fat2'retorna'2'(FIM)'
1.5'A'fat1'recebe'o'retorno'de'fat2'(2)'e'mul>plica'por'n'(3)'e'retorna'6'(FIM)'
2.'O'programa'principal'recebe'o'retorno'de'fat1'(6)'e'imprime'
3.'Fim ''

118. Função'Recursiva'
'''
Cuidado':'É'preciso'que'a'chamada'recursiva'evite'de'se'tornar'um'laço'infinito.'
'
Para'isso'a'função'tem'que'conter'casos'base'ou'casos'de'parada.'
'
No'caso'da'função'fatorial'é'o'zero,'ou'seja,'uma'chamada'a'fat(0)'retorna'
imediatamente'o'valor'1'sem'que'se'chame'novamente'a'função.'
'
Exemplo2:'Função'de'Fibonacci.'
'
Esta'é'uma'função'que'já'implementamos'na'forma'itera>va'cuja'definição'é'
recursiva.'Ou'seja:'
'
fib(1)'''é''0'''#'casos'bases'
fib(2)'''é''1'
fib(n)'''é''fib(nn1)'+''fib(nn2)'
'''
Ver'programa32.py'
1. OBS:'O'programa16.py'traz'a'versão'itera>va.'Quem'roda'mais'rápido'para'30'
elementos'por'exemplo?'
'''

119. Pesquisa'Binária'
'''
Exemplo'3'–'Pesquisa'Binária'é'um'algoritmo'conhecido'usado'para'pesquisar'um'
valor'em'uma'lista'ordenada.'Funciona'da'seguinte'forma:'
'
Seja'uma'lista'ordenada'“lista”.'Chamemos'de'min'e'max'os'índices'mínimo'e'
máximo'da'lista'onde'a'busca'será'feita.''Inicialmente,'min'='0'e'max'='len(lista)n1'
'
Para'o'caso'base:''min'=='max'
'Então,'ou'o'valor'é'igual'a'lista'[min]'ou'não'está'na'lista'
Para'outros'casos'
'Dividir'o'intervalo'de'busca'em'dois'
'Seja'meio'='(min+max)/2'
'Se'o'valor'é'maior'que'lista'[meio]',''
' 'então'ele'se'encontra'em'
' ' 'algum'dos'índices'entre'meio+1'e'max'
' 'Caso'contrário,''
' ' 'deve'se'encontrar'em'algum'dos'índices'min'e'meio.'
'
Ver'programa33.py''
'

120. Pesquisa'Binária'–'Passo'a'Passo'
'''
Seja'a'Lista:'[1,2,3,4,5,79,99,101]'
'
Seja'o'valor'de'busca:'79'
'
Passo'1'n''Ao'chamar'a'função'de'pesquisa'passe'os'valores'min'='0''max'='7'
Passo'2'n'Como'min'!'='max'calculanse'meio'='7/2'='3'
Passo'3'–'Verifica'se'valor'(79)'>''lista[meio]''(4)'.'Como'é'verdadeiro'chamanse'
recursivamente'a'função'passando'(4,7)''
Passo'4'–'Ao'ser'chamada'a'função'de'pesquisa'com'min'='4'e'max'='7'repetense'a'
operação.'Como'min'!='max','calculanse'meio''='11/2'='5''e'valor'não'é'maior'que'
lista[5]'(79)'chamanse'a'função'passando'(4,5).''
Passo'5'n'Repetense'tudo'e'chamanse'a'função'passando'(5,5)'
Passo'6'–'Ao'ser'chamada'novamente'verifica'que'max'='min'='5'retorna'o'5'para'
a'função'principal.'
Passo'7'–'Na'função'principal'verificanse'se'o'valor'(79)'é'igual'a'lista[5]'(79).'
Sendo'verdadeiro'o'algoritmo'obteve'sucesso'e'o'valor'procurado'está'na'posição'
5.'
'

121. Pesquisa'Binária'–'Exercício'
'''
Refaça'o'programa'do'Jogo'(programa17.py).'Desta'vez'verifique'com'quantas'
tenta>vas'o'computador'acharia'o'número'usando'pesquisa'binária'e'depois'
compare'com'o'número'de'tenta>vas'que'o'jogador'faz.''
'
Se'o'jogador'sempre'acerta'o'mesmo'número'de'vezes'que'o'computador,'ele'
está'ficando'esperto';n)'

122. Mais'sobre'listas'....'
'''
'
Seja'uma'lista'A'='[2,1,3,4,10,6,7,8,9]'
'
A[:5]'se'refere'aos'elementos'[2,1,3,4,10]'
'
A[1:3]'se'refere'aos'elementos'[1,3]'
'
A[:4]''se'refere'aos'elementos'[2,1,3,4]'
'
B=[1,2]'
'
C'='[3,4]'
'
D='B+C'''([1,2,3,4])'
'
É'isso'aí'...'
''

123. Análise'combinatória(1)'
Dadas'duas'variáveis:'A'e'B'
'
Como'permuto'os'valores'de'A'e'B.'
'
Solução'''C''='A'
' 'A'='B'
' 'B'='C'
'
Dadas'duas'listas'A'e'B,"A"='[a1,a2,...an]'e'B'='[b1,b2,...bn].'Onde'len(A)'='Len(B)'
"'
Como'faço'pra'verificar'se'A'pode'ser'ob>da'por'uma'permutação'dos'elementos'de'
B?'
'
Solução:'programa34.py'
'

124. Análise'combinatória(2)'
Dadas'uma'lista'A'='[a1,a2,a3,...,an]"
'
Como'faço'para'achar'todas'as'permutações'de'A???'
''
Caso'1,'se'eu'soubesse'o'tamanho'de'A'#''':''Programa35.py'
'
Caso'2,'como'nem'sempre'se'sabe'o'tamanho'de'A'$':''Programa36.py'
''''

125. Análise'combinatória(3)'
Estudando'o'programa'36.py'
'
Passo'1:'''“Digite'a'lista'“''Entrada:'[1,2]'''x'='[1,2]'
Passo'2:''''Saida'Permutacoes([1,2])'#''Chama'a'função'permutação''(instância'1)'
Passo'15:''Recebe'o'valor'de'permutacoes([1,2])'e'subs>tui'no'print'
print'[[1,2],[2,1]]'
Passo'16:'imprime'o'resultado'final'
Fim'do'programa'
'

126. Análise'combinatória(3)'
Função'permutação':'Instância'1'
Passo'3:'Recebe'Lista'='[1,2]'
Passo'4:'Testa'len(lista)'=='1'(falso)'
Passo'5:'primeiro'='lista[0]'='1';'resto'='lista[1:]'='[2];'resultado''='[]'
Passo'6:'Cria'um'iterador''
For''perm'in'permutacoes(resto)''=>'chama'a'funcao'permutacoes([2])'('Instancia'2)'
Passo'10:'Recebe'a'lista'[2]'e'subs>tui'na'expressão'acima'tendo'como'resultado'
for'perm'in'[2]'
Passo'11:'perm''='[2]'
Passo'12:'cria'laço'for'i'in'range(2)'e'entra'no'laço'com'i'='0'
Passo'13:'Adiciona'ao'resultado'[perm[:0]'+'[primeiro]'+'perm[0:]]'ou'seja'
resultado'='[[]+[1]+[2]]'='[[1,2]]'
Passo'14':'Con>nua'no'laço'com'i'='1'e'adiciona'ao'resultado'
resultado'='[[1,2]]'+'[perm[:1]'+'[primeiro]+'perm[1:]]'='[[1,2]]+'[[2]+[1]+[]]'
resultado'='[[1,2],[2,1]]'
Passo14:'sai'do'laço''e'retorna'resultado'
Fechou'a'instância'1'
'

127. Análise'combinatória(3)'
Função'permutação':'Instância'2'
Passo'7:'
Lista'='[2]'
Passo'8:'
'testa'len(lista)'=='1'(verdade)'
Passo'9:'
Retorna'[2]'para'a'instancia'1'
Fechou'a'instância'2'

128. Fim'da'Aula'5'
PAUSA'.....................'

129. Aula'6'–'Recursão'2'('A'Missão)'
'''

130. Análise'combinatória(4)'
Refazendo'o'programa'36:'
'
Passo1:'input:'recebe'uma'lista'e'a>bui'a'x.'Ex'x'='[1,2,3]'
Passo2:'print:'chama'a'funcao'permutacoes([1,2,3])'para'imprimir'o'resultado'
(instância'1'de'permutacoes)'
Passo25:'recebe'resultado'e'imprime'[[1,2,3],[2,1,3],[2,3,1],[1,3,2],[3,1,2],[3,2,1]]'
''
''
'

131. Análise'combinatória(4)'
Instância'1'de'permutacoes'
Passo3:'recebe'uma'lista'='x'='[1,2,3]'
Passo4:'if:'testa'se'o'comprimento'da'lista'é'um'(falso)'
Passo5:'primeiro'='lista[0]'='1;'resto'='lista[1:]'='[2,3];''resultado'='[]'
Passo6:'for'perm'in'permutacoes([2,3])''%'Chamada'a'permutacoes'(instancia'2)'
Passo'19:'recebe'a'lista'de'permutacoes([2,3])'e'subs>tui'ficando'o'laço:'
'for'perm'in'([[2,3],[3,2]]):'
Passo20'para'perm'='[2,3]'cria'o'laço'i''in'range(len(perm)'2'+'1'='3)'
Passo21'para'i'='0:'calcula'o'resultado'+'='[perm[:0]'+'[primeiro]'+'[0:]]'
='[[]+[1]+[2,3]]'=[[1,2,3]]'
Passo22'para'i'='1':'calcula'o'resultado'+=''[perm[:1]'+'[primeiro]'+'[1:]]'=''
[[1,2,3]]'+'[[2]+[1]+[3]]'='[[1,2,3],[2,1,3]]'
Passo23'para'i'='2'calcula'o'resultado'+='[perm[:2]'+'[primeiro]'+'[2:]]'=''
[[1,2,3],[2,1,3]]'+'[[2,3]+[1]+[]]'='[[1,2,3],[2,1,3],[2,3,1]]'
Passo24:'repete'os'passos'20'a'23'para'perm'='[3,2]'gerando'[1,3,2],[3,1,2],[3,2,1]'
O'Resultado'será'portanto'[[1,2,3],[2,1,3],[2,3,1],[1,3,2],[3,1,2],[3,2,1]]'
Fechada'a'instância'1'''''''
''

132. Análise'combinatória(4)'
Instância'2'de'permutacoes'
Passo7:'recebe'uma'lista'='x'='[2,3]'
Passo8:'if:'testa'se'o'comprimento'da'lista'é'um'(falso)'
Passo9:'primeiro'='lista[0]'='2;'resto'='lista[1:]'='[3];''resultado'='[]'
Passo10:'for'perm'in'permutacoes([3])''%'Chamada'a'permutacoes'(instancia'3)'
Passo14:'recebe''valor'[[3]]''e'subs>tui'na'lista'perm'in'[[3]]'
Passo15:'faz'perm=[3]'e'cria'laço'i'in'range(len(perm)'1'+'1'='2)'
Passo16':'para'i'='0'calcula'o'resultado'+=''[perm[:0]'+[primeiro]+perm[0:]]'
' 'resultado'='[[]+[2]+[3]]'='[[2,3]]'
Passo17:'para'i'='1'calcula'o'resultado''+=[perm[:1]+[primeiro]+perm[1:]]'
' 'resultado'='[[2,3]]'+'[[3]+[2]+[]]'='[[2,3],[3,2]]'
Passo18:'return:'retorna'o'resultado'[[2,3],[3,2]]'para''o'principal'
Fechou'instância'2'
'

133. Análise'combinatória(4)'
Instância'3'de'permutacoes'
Passo11:'recebe'uma'lista'='x'='[3]'
Passo12:'if:'testa'se'o'comprimento'da'lista'é'um'(verdade)'
Passo13:'return:'retorna'o'valor'[[3]]'para'a'instância'2'
Fechada.''
'
''
'

134. Análise'combinatória(4)'n'Moral'
Dada'a'lista''1,2,3'
Re>ra'o'primeiro'elemento'(1)'
Gera'as'possíveis'permutações'dos'restantes'
Ex'2,3''e''3,2''
Insere'o'primeiro'em'cada'uma'das'posições'do'vetor'em'construção'para'cada'
permutação:'
Permutação'A:''2,3'''
Pos.'0':'1'2'3'
Pos.'1':'2'1'3'
Pos.'2':'2'3'1'
Permutação'B:'3,2'
Pos.'0':'1'3'2'
Pos.'1':'3'1'2'
Pos.'2':'3'1'1'
'Pergunta':'como'ele'achou'as'permutações'do'resto???'(2,3)'e'(3,2).'Ora'
simplesmente'chamando'a'função'recursivamente''passando'o'resto'(2,3)'que'faz'a'
mesma'coisa'e'retorna'a'lista'e'assim'por'diante'....''
'

135. Análise'combinatória(5)''
E''itera>vamente?''É'possível???'
Seja'a'lista:''''A'='[1,2,3]'o'número'de'permutações'é'n!'No'caso'3!'='6'
Observe''a'matriz'de'permutações:'
L0:'123'''ou'' 'A[0]'A[1]'A[2]'
L1:'132 ' 'A[0]'A[2]'A[1]'
L2:'213 ' 'A[1]'A[0]'A[2]'
L3:'232 ' 'A[1]'A[2]'A[0]'
L4:'312 ' 'A[2]'A[0]'A[1]'
L5:'321 ' 'A[2]'A[1]'A[0]'
'
Para'L=0'Pos''=''L'div'(nn1)!''='0'div'2!'='0'(divisão'inteira)'
Para'L=1'Pos''=''1'div'2!'='0'
Para'L=2'Pos''=''2'div'2!'='1'
Para'L=3'Pos''=''3'div'2!'='1'
Para'L=4'Pos''=''4'div'2!'='2'
Para'L=5'Pos''=''5'div'2!'='2.'
Graças'a'divisão'inteira'e'a'escolha'certa'dos'parâmetro'de'calculo'temos'uma'
função'que'nos'dá'o'índice'do'elemento'em'função'da'linha.'E'para'resto'...?'''''''''''
'

136. Análise'combinatória(5)''
Para'uma'linha'qualquer'ex'L=4'
O'Calculo'da'Pos'0'é'4'div'2!''=''2'
Ou'seja''''''L4:'3'1'2''ou'A[2]'A[1]''A[0]'
'
Seja'a'lista'A’'=''[1]['2]'(re>ramos''o'elemento'da'posição'já'calculada)'
Podemos'repe>r'as'operações'com'n’'='2'(novo'tamanho).'Observe'que'em'uma'
lista'de'tamanho'2'não'poderia'haver'uma'linha'maior'que'2!'então'temos'que'
confinar'o'índice(L)'da'linha'a'um'valor'entre'0'e'2!.'Fazemos'isso'>rando'o'resto'
da'divisão'entre'L'e'2!''ou'seja'entre'L'e'n’!'''''
'''
Aplicamos'as'mesmas'formas'usando'L’'n’(novos'valores''L'e'n)'
Observe'que''o'mesmo'método'anterior'se'aplica.'Para'a'primeira'posição'
L’(L'%'n’!'<n>'4'%'2!'='0):'Pos'='L’'div'n’!''='0/1!'='0':'A’[0]'='1'''''
'
Agora'é'só'repe>r'a'operação'com'a'lista'que'sobrou.'
'
OBS:'Para'a'linha'5''L’(5'%'2!'<n>'1):'Pos'=''1/1!''='1'':'A’[1]'=0''''
'
''
'

137. Análise'combinatória(5)''
Organizando"o"algoritmo"
'
Receba'a''lista'A'de'tamanho'n'
Crie'um'laço'com'variável'i''na'faixa(0','fatorial(n))'
'faca'L'='i'
'faca'uma'copia'da'lista'(A2'='A)'
'crie'uma'lista'vazia'temp'='[]''''
' 'crie'laço'usando'j'na'faixa(comprimento(A),0,n1)'#'de'trás'pra'frente''
' 'calcule'o'denominador'd'='fatorial(jn1)'
' 'calcule'a'posição'p'='L'/'d''(divisão'inteira)'
' 'recalcule'o'L'para'a'próxima'coluna''L'='L'%'d'
' 'adicione'A2[p]'a'temp'n>'temp.append(A2[p])''
' 'apague'o'elemento'na''posição'p''de'A[2]'
'imprima'o'temp'ou'adicione'a'uma'lista'de'resultados'
'
Programa37.py''
'''

138. Análise'combinatória(5)''
'
Até'agora'só'fizemos'permutações.''E'as'combinações,'arranjos,'etc'???'
'
Digamos'uma'lista'de'n'elementos'='[a1,a2,...an]'
'
Os'arranjos,'ou'seja,''quantas'e'quais'possíveis'formas'de'ordenamento'eu'terei'
re>rando'sempre'um'número'fixo'm'de'elementos'm'<'n?'
'
Combinações,'ou'seja,'quantos'grupos'dis>ntos'eu'posso'gerar'a'par>r'de'um'
subconjunto'da'lista'acima?'
'
E'se'eu'fizer'arranjos'ou'combinações'com'repe>ções?'(A,A)(B,B)'...'etc'
''
Desafios'para'vc.....'
''

139. Filas'
Você'pode'também'u>lizar'uma'lista'como'uma'fila,'onde'o'primeiro'item'
adicionado'é'o'primeiro'a'ser'recuperado'(polí>ca'“primeiro'a'entrar,'primeiro'a'
sair”'(FIFO)'').'Para'adicionar'um'elemento'ao'fim'da'fila'u>liza'append().'Para'
recuperar'um'elemento'do'início'da'fila'use'pop()'com'0'no'índice.'
'
'Por'exemplo:'
'
>>>queue'='["Eric",'"John",'"Michael"]'
>>>queue.append("Terry")''#'Terry'arrives'
>>>queue.append("Graham")' '#'Graham'arrives'
'>>>queue.pop(0)'
’Eric’'
>>>'queue.pop(0)'
’John’'
>>>'queue'
[’Michael’,'’Terry’,'’Graham’]'
'
Exercício':'Uma'boa'parte'das'linguagens'não'possui'comandos'para'manipulação'de'listas.'
Crie'sua'própria'implementação'das'funções'append'e'pop.'
'

140. Pilhas'
Os'métodos'de'lista'tornam'muito'fácil'u>lizar'listas'como'pilhas,'onde'o'item'
adicionado'por'úl>mo'é'o'primeiro''a'ser'recuperado'(polí>ca'“úl>mo'a'entrar,'
primeiro'a'sair”'(LIFO)')'.'Para'adicionar'um'item'ao'topo'da'pilha,'use'append()'
[push].'Para'recuperar'um'item'do'topo'da'pilha'use'pop()'sem'nenhum'índice.''
'
>>>'stack'='[3,'4,'5]'
>>>'stack.append(6)'
>>>'stack.append(7)'
>>>'stack'
[3,'4,'5,'6,'7]'
>>>'stack.pop()'
7'
>>>'stack'
[3,'4,'5,'6]'
>>>'stack.pop()'
6'
'
Exercício:'Implemente'sua'própria'versão'de'push'e'pop'

141. Pense'recursivamente!'Torres'de'Hanói.'
Algoritmo:'
1. Criar'função'torre'de'Hanói'recebendo'como'argumentos'numero''de'anéis'(n),'uma'
pilha'preenchida'representando'a'haste'1'origem"e'duas'pilhas'vazias'(temp"e'
des@no")'representando'as'hastes'2''e'3"
1.1'Dentro'da'função'verificar'se'o'num'de'anéis'='1'.'Se'for're>rar'o'anel'(pop)'da'
pilha'origem'e'colocar'na'des>no'(push/append)'e'retorna.'
1.2'Senão'chamar'a'função'Hanói'(chamada'recursiva)'para'colocar'todos'os'
elementos'até'o'nn1''na'pilha'temp"na'ordem'correta'e'seguindo'as'regras.'
1.3'colocar'o'nnesimo'elemento'na'posição'certa'em'des@no.'
1.4'chamar'a'função'Hanói'(recursiva)'para'transferir'os'nn1'elementos'que'estão'na'
temp"para'a'posição'correta'no'des@no"

142. Fim'da'Aula'6'

143. Aula'7'n'Ordenamento'

144. Ordenamento'
''''
Seja'uma'lista''A'='[a1,a2,...,an]'não'ordenada.'
'
Qual'o'procedimento'para'ordenánla?'Ou'seja'criar'uma'lista'A’='[a’1,a’2,...a’n]'a'
par>r'de'A'onde'a’i+1'>'a’i'''''para'todo'i'em'R?'
'
Tente'antes'de'prosseguirmos.'
'
Veremos'aqui'4'(+2)'métodos:'
'''
1. Seleção,''
2. Inserção,''
3. Borbulhamento''
4. Classificação'Rápida'(Quicksort)'
5. Mergesort'
6. Shellsort'
E'você'pesquisa'outros'.....'''

145. Ordenamento(1)'n'Seleção'
''''
Idéia:''Pesquisar'na'lista'o'menor'elemento'e'trazer'para'a'primeira'posição.'Repe>r'
para'a'segunda,'terceira,'etc'até'chegar'ao'fim'da'lista'tendo'a'mesma'ordenada.'
'''
Passo'1':''Dada'a'lista'seleciona'o'menor'número:'Resultado'='1'na'Posição'2'
'
A'''=''''[''7','''3''',''1,'''4,'''5]'
''
Posição'a'ser'calculada' Posição'do'menor'elemento'da'lista'

146. Ordenamento(1)'n'Seleção'
''''
Idéia:''Pesquisar'na'lista'o'menor'elemento'e'trazer'para'a'primeira'posição.'Repe>r'
para'a'segunda,'terceira,'etc'até'chegar'ao'fim'da'lista'tendo'a'mesma'ordenada.'
'''
Passo'2':''Troca'os'elementos'das'posições'(0)'e'(2)'
'
A'''=''''[''1','''3''',''7,'''4,'''5]'
''
Posição'a'ser'calculada' Posição'do'menor'elemento'da'lista'

147. Ordenamento(1)'n'Seleção'
''''
Idéia:''Pesquisar'na'lista'o'menor'elemento'e'trazer'para'a'primeira'posição.'Repe>r'
para'a'segunda,'terceira,'etc'até'chegar'ao'fim'da'lista'tendo'a'mesma'ordenada.'
'''
Passo'3':''Atualizamos'a'posição'a'ser'calculada'e'selecionamos'o'menor'valor'da'lista'
remanescente'na'posição'1'(3)'
'
A'''=''''[''1','''3''',''7,'''4,'''5]'
''
Posição'a'ser'calculada'
Posição'do'menor'elemento'da'lista'
remanescente'

148. Ordenamento(1)'n'Seleção'
''''
Idéia:''Pesquisar'na'lista'o'menor'elemento'e'trazer'para'a'primeira'posição.'Repe>r'
para'a'segunda,'terceira,'etc'até'chegar'ao'fim'da'lista'tendo'a'mesma'ordenada.'
'''
Passo'4':''Mantemos'o'valor'do'elemento'pois'já'está'na'posição'correta!'
'
A'''=''''[''1','''3''',''7,'''4,'''5]'
''
Posição'a'ser'calculada'
Posição'do'menor'elemento'da'lista'
remanescente'

149. Ordenamento(1)'n'Seleção'
''''
Idéia:''Pesquisar'na'lista'o'menor'elemento'e'trazer'para'a'primeira'posição.'Repe>r'
para'a'segunda,'terceira,'etc'até'chegar'ao'fim'da'lista'tendo'a'mesma'ordenada.'
'''
Passo'5':''Atualizamos'a'posição'a'ser'calculada'e'selecionamos'o'menor'valor'da'lista'
remanescente.'Encontrado'na'posição''3'(4)'
'
A'''=''''[''1','''3''',''7,'''4,'''5]'
''
Posição'a'ser'calculada'
Posição'do'menor'elemento'da'lista'
remanescente'

150. Ordenamento(1)'n'Seleção'
''''
Idéia:''Pesquisar'na'lista'o'menor'elemento'e'trazer'para'a'primeira'posição.'Repe>r'
para'a'segunda,'terceira,'etc'até'chegar'ao'fim'da'lista'tendo'a'mesma'ordenada.'
'''
Passo'6':Intercambiamos'os'valores'da'posição'atual'com'a'posição'do'menor'
remanescente'
'
A'''=''''[''1','''3''',''4,'''7,'''5]'
''
Posição'a'ser'calculada'
Posição'do'menor'elemento'da'lista'
remanescente'

151. Ordenamento(1)'n'Seleção'
''''
Idéia:''Pesquisar'na'lista'o'menor'elemento'e'trazer'para'a'primeira'posição.'Repe>r'
para'a'segunda,'terceira,'etc'até'chegar'ao'fim'da'lista'tendo'a'mesma'ordenada.'
'''
Passo'7':'Atualizamos'a'posição'ser'calculada'e'selecionamos'o'menor'valor'
remanescente'
'
A'''=''''[''1','''3''',''4,'''7,'''5]'
''
Posição'a'ser'calculada'
Posição'do'menor'elemento'da'lista'
remanescente'

152. Ordenamento(1)'n'Seleção'
''''
Idéia:''Pesquisar'na'lista'o'menor'elemento'e'trazer'para'a'primeira'posição.'Repe>r'
para'a'segunda,'terceira,'etc'até'chegar'ao'fim'da'lista'tendo'a'mesma'ordenada.'
'''
Passo'8':'Intercambiamos'os'valores'encontrados'
'
A'''=''''[''1','''3''',''4,'''5,'''7]'
''
Posição'a'ser'calculada'
Posição'do'menor'elemento'da'lista'
remanescente'

153. Ordenamento(1)'n'Seleção'
''''
Idéia:''Pesquisar'na'lista'o'menor'elemento'e'trazer'para'a'primeira'posição.'Repe>r'
para'a'segunda,'terceira,'etc'até'chegar'ao'fim'da'lista'tendo'a'mesma'ordenada.'
'''
Passo'9':'Operação'finalizada.'A'Lista'está'ordenada'
'
A'''=''''[''1','''3''',''4,'''5,'''7]'
''
Posição'a'ser'calculada'
Posição'do'menor'elemento'da'lista'
remanescente'
Ver:'Programa39.py'

154. Ordenamento(2)'n'Inserção'
''''
Idéia:''Atravessar'a'lista'da'esquerda'para'a'direita'mantendo'o'lado'esquerdo'
ordenado.'
'''
Passo'1':'Posiciona'a'posição'a'ser'calculada'(chave)''e'verifica'se'o'primeiro'elemento'
está'em'ordem'com'relação'ao'mesmo.'No'caso'é'falso'(7>3)'
'
A'''=''''['7,'''3''',''1,'''4,'''5]'
''
Posição'a'ser'
calculada'(chave)'
Elemento'a'verificar'se'está'na'
ordem'correta'

155. Ordenamento(2)'n'Inserção'
''''
Idéia:''Atravessar'a'lista'da'esquerda'para'a'direita'mantendo'o'lado'esquerdo'
ordenado.'
'''
Passo'2':'Insere'(copia)''elemento'zero'(7)'na'posição'da'chave'
'
A'''=''''['7,'''7''',''1,'''4,'''5]'
''
Posição'a'ser'calculada'
Elemento'a'verificar'se'está'na'
ordem'correta'

156. Ordenamento(2)'n'Inserção'
''''
Idéia:''Atravessar'a'lista'da'esquerda'para'a'direita'mantendo'o'lado'esquerdo'
ordenado.'
'''
Passo'3':'Insere'(copia)''o'valor'da'chave'na'posição'0'
'
A'''=''''['3,'''7''',''1,'''4,'''5]'
''
Posição'a'ser'calculada'
Elemento'a'verificar'se'está'na'
ordem'correta'

157. Ordenamento(2)'n'Inserção'
''''
Idéia:''Atravessar'a'lista'da'esquerda'para'a'direita'mantendo'o'lado'esquerdo'
ordenado.'
'''
Passo'4':'Atualiza'a'posição'da'chave'Guarda'chave'='1''e'verifica'se'o'elemento'a'
esquerda'é'menor'(falso)'(7>1)'
'
A'''=''''['3,'''7''',''1,'''4,'''5]'
''
Posição'a'ser'calculada'
Elemento'a'verificar'se'está'na'
ordem'correta'

158. Ordenamento(2)'n'Inserção'
''''
Idéia:''Atravessar'a'lista'da'esquerda'para'a'direita'mantendo'o'lado'esquerdo'
ordenado.'
'''
Passo'5':''Desloca'(copia)'o'valor'anterior'uma'posição'à'frente'
'
A'''=''''['3,'''7,'''7,'''4,'''5]'
''
Posição'a'ser'calculada'
Elemento'a'verificar'se'está'na'
ordem'correta'

159. Ordenamento(2)'n'Inserção'
''''
Idéia:''Atravessar'a'lista'da'esquerda'para'a'direita'mantendo'o'lado'esquerdo'
ordenado.'
'''
Passo'6':''Verifica'se'o'elemento'mais'a'esquerda'é'menor'que'chave'(1)'(falso)'
'
A'''=''''['3,'''7,'''7,'''4,'''5]'
''
Posição'a'ser'calculada'
Elemento'a'verificar'se'está'na'
ordem'correta'

160. Ordenamento(2)'n'Inserção'
''''
Idéia:''Atravessar'a'lista'da'esquerda'para'a'direita'mantendo'o'lado'esquerdo'
ordenado.'
'''
Passo'7':''Desloca'(copia'o'elemento'para'frente)'
'
A'''=''''['3,'''3,'''7,'''4,'''5]'
''
Posição'a'ser'calculada'
Elemento'a'verificar'se'está'na'
ordem'correta'

161. Ordenamento(2)'n'Inserção'
''''
Idéia:''Atravessar'a'lista'da'esquerda'para'a'direita'mantendo'o'lado'esquerdo'
ordenado.'
'''
Passo'8':''Copia'o'valor'da'chave'para''o'início'
'
A'''=''''['1,'''3,'''7,'''4,'''5]'
''
Posição'a'ser'calculada'
Elemento'a'verificar'se'está'na'
ordem'correta'

162. Ordenamento(2)'n'Inserção'
''''
Idéia:''Atravessar'a'lista'da'esquerda'para'a'direita'mantendo'o'lado'esquerdo'
ordenado.'
'''
Passo'9':''Atualiza'chave'(chave'='4)'
'
A'''=''''['1,'''3,'''7,'''4,'''5]'
''
Posição'a'ser'calculada'
Elemento'a'verificar'se'está'na'
ordem'correta'

163. Ordenamento(2)'n'Inserção'
''''
Idéia:''Atravessar'a'lista'da'esquerda'para'a'direita'mantendo'o'lado'esquerdo'
ordenado.'
'''
Passo'10':''Verifica'se'o'elemento'a'esquerda'é'maior'que'chave'(verdade)''
'
A'''=''''['1,'''3,'''7,'''4,'''5]'
''
Posição'a'ser'calculada'
Elemento'a'verificar'se'está'na'
ordem'correta'

164. Ordenamento(2)'n'Inserção'
''''
Idéia:''Atravessar'a'lista'da'esquerda'para'a'direita'mantendo'o'lado'esquerdo'
ordenado.'
'''
Passo'11':''Desloca'(copia)'elemento'analisado'para'a'direita''
'
A'''=''''['1,'''3,'''7,'''7,'''5]'
''
Posição'a'ser'calculada'
Elemento'a'verificar'se'está'na'
ordem'correta'

165. Ordenamento(2)'n'Inserção'
''''
Idéia:''Atravessar'a'lista'da'esquerda'para'a'direita'mantendo'o'lado'esquerdo'
ordenado.'
'''
Passo'12':''Verifica'se'elemento'mais'a'esquerda'é'maior'que'chave''(FALSO)'
'
A'''=''''['1,'''3,'''7,'''7,'''5]'
''
Posição'a'ser'calculada'
Elemento'a'verificar'se'está'na'
ordem'correta'

166. Ordenamento(2)'n'Inserção'
''''
Idéia:''Atravessar'a'lista'da'esquerda'para'a'direita'mantendo'o'lado'esquerdo'
ordenado.'
'''
Passo'13:''Insere'(copia)'chave'na'posição'à'direita'do'valor'analisado'
'
A'''=''''['1,'''3,'''4,'''7,'''5]'
''
Posição'a'ser'calculada'
Elemento'a'verificar'se'está'na'
ordem'correta'

167. Ordenamento(2)'n'Inserção'
''''
Idéia:''Atravessar'a'lista'da'esquerda'para'a'direita'mantendo'o'lado'esquerdo'
ordenado.'
'''
Passo'14:''Atualiza'a'posição'da'chave'(chave'='5)'
'
A'''=''''['1,'''3,'''4,'''7,'''5]'
''
Posição'a'ser'calculada'
Elemento'a'verificar'se'está'na'
ordem'correta'

168. Ordenamento(2)'n'Inserção'
''''
Idéia:''Atravessar'a'lista'da'esquerda'para'a'direita'mantendo'o'lado'esquerdo'
ordenado.'
'''
Passo'15:''Verifica'se'o'elemento'a'esquerda'é'maior'que'chave.'(verdade)'
'
A'''=''''['1,'''3,'''4,'''7,'''5]'
''
Posição'a'ser'calculada'
Elemento'a'verificar'se'está'na'
ordem'correta'

169. Ordenamento(2)'n'Inserção'
''''
Idéia:''Atravessar'a'lista'da'esquerda'para'a'direita'mantendo'o'lado'esquerdo'
ordenado.'
'''
Passo'16:''Desloca'(copia)'o'elemento'analisado'para'a'direita'
'
A'''=''''['1,'''3,'''4,'''7,'''7]'
''
Posição'a'ser'calculada'
Elemento'a'verificar'se'está'na'
ordem'correta'

170. Ordenamento(2)'n'Inserção'
''''
Idéia:''Atravessar'a'lista'da'esquerda'para'a'direita'mantendo'o'lado'esquerdo'
ordenado.'
'''
Passo'17:''Desloca'(copia)'o'elemento'analisado'para'a'direita'
'
A'''=''''['1,'''3,'''4,'''7,'''7]'
''
Posição'a'ser'calculada'
Elemento'a'verificar'se'está'na'
ordem'correta'

171. Ordenamento(2)'n'Inserção'
''''
Idéia:''Atravessar'a'lista'da'esquerda'para'a'direita'mantendo'o'lado'esquerdo'
ordenado.'
'''
Passo'18:''Verifica'se'o'elemento'mais'a'esquerda'é'maior'que'chave'(falso)'
'
A'''=''''['1,'''3,'''4,'''7,'''7]'
''
Posição'a'ser'calculada'
Elemento'a'verificar'se'está'na'
ordem'correta'

172. Ordenamento(2)'n'Inserção'
''''
Idéia:''Atravessar'a'lista'da'esquerda'para'a'direita'mantendo'o'lado'esquerdo'
ordenado.'
'''
Passo'19:''Insere'a'chave'à'direita'da'posição'em'análise'e'fim'do'trabalho.'
'
A'''=''''['1,'''3,'''4,'''5,'''7]'
''
Posição'a'ser'calculada'
Elemento'a'verificar'se'está'na'
ordem'correta'
Programa40.py'

173. Ordenamento(3)'n'Borbulhamento'
''''
Idéia:'Comparar'os'elementos'dois'a'dois.'Se'es>verem'fora'de'ordem,'ordenánlos.'
Repe>r'até'que'não'haja'mais'elementos'a'permutar.'
'''
Passo'1:''Comparar'os'dois'primeiros'elementos'
'
A'''=''''['7,'''3,''1,'''4,'''5]'
''
Posição'a'ser'calculada'
Elemento'a'verificar'se'está'na'
ordem'correta'

174. Ordenamento(3)'n'Borbulhamento'
''''
Idéia:'Comparar'os'elementos'dois'a'dois.'Se'es>verem'fora'de'ordem,'ordenánlos.'
Repe>r'até'que'não'haja'mais'elementos'a'permutar.'
'''
Passo'2:''Como'estão'fora'de'ordem'permutánlos'
'
A'''=''''['3,'''7,''1,'''4,'''5]'
''
Posição'a'ser'calculada'
Elemento'a'verificar'se'está'na'
ordem'correta'

175. Ordenamento(3)'n'Borbulhamento'
''''
Idéia:'Comparar'os'elementos'dois'a'dois.'Se'es>verem'fora'de'ordem,'ordenánlos.'
Repe>r'até'que'não'haja'mais'elementos'a'permutar.'
'''
Passo'3:''Comparar'os'dois'próximos'
'
A'''=''''['3,'''7,''1,'''4,'''5]'
''
Posição'a'ser'calculada'
Elemento'a'verificar'se'está'na'
ordem'correta'

176. Ordenamento(3)'n'Borbulhamento'
''''
Idéia:'Comparar'os'elementos'dois'a'dois.'Se'es>verem'fora'de'ordem,'ordenánlos.'
Repe>r'até'que'não'haja'mais'elementos'a'permutar.'
'''
Passo'4:''Permutánlos'(Estão'fora'de'ordem)'
'
A'''=''''['3,'''1,''7,'''4,'''5]'
''
Posição'a'ser'calculada'
Elemento'a'verificar'se'está'na'
ordem'correta'

177. Ordenamento(3)'n'Borbulhamento'
''''
Idéia:'Comparar'os'elementos'dois'a'dois.'Se'es>verem'fora'de'ordem,'ordenánlos.'
Repe>r'até'que'não'haja'mais'elementos'a'permutar.'
'''
Passo'5:''Comparar'os'dois'próximos'
'
A'''=''''['3,'''1,''7,'''4,'''5]'
''
Posição'a'ser'calculada'
Elemento'a'verificar'se'está'na'
ordem'correta'

178. Ordenamento(3)'n'Borbulhamento'
''''
Idéia:'Comparar'os'elementos'dois'a'dois.'Se'es>verem'fora'de'ordem,'ordenánlos.'
Repe>r'até'que'não'haja'mais'elementos'a'permutar.'
'''
'
A'''=''''['3,'''1,''4,'''7,'''5]'
''
Passo'6:''Permutánlos'
Posição'a'ser'calculada'
Elemento'a'verificar'se'está'na'
ordem'correta'

179. Ordenamento(3)'n'Borbulhamento'
''''
Idéia:'Comparar'os'elementos'dois'a'dois.'Se'es>verem'fora'de'ordem,'ordenánlos.'
Repe>r'até'que'não'haja'mais'elementos'a'permutar.'
'''
Passo'7':''Comparar'os'dois'próximos'
'
A'''=''''['3,'''1,''4,'''7,'''5]'
''
Posição'a'ser'calculada'
Elemento'a'verificar'se'está'na'
ordem'correta'

180. Ordenamento(3)'n'Borbulhamento'
''''
Idéia:'Comparar'os'elementos'dois'a'dois.'Se'es>verem'fora'de'ordem,'ordenánlos.'
Repe>r'até'que'não'haja'mais'elementos'a'permutar.'
'''
'
A'''=''''['3,'''1,''4,'''5,'''7]'
''
Passo'8':''Permutánlos'
Posição'a'ser'calculada'
Elemento'a'verificar'se'está'na'
ordem'correta'

181. Ordenamento(3)'n'Borbulhamento'
''''
Idéia:'Comparar'os'elementos'dois'a'dois.'Se'es>verem'fora'de'ordem,'ordenánlos.'
Repe>r'até'que'não'haja'mais'elementos'a'permutar.'
'''
Passo'9':''Como'foram'feitas'várias'permutações'nessa'passagem,'reiniciar'comparando'
os'dois'primeiros'elementos.'
'
A'''=''''['3,'''1,''4,'''5,'''7]'
''
Posição'a'ser'calculada'
Elemento'a'verificar'se'está'na'
ordem'correta'

182. Ordenamento(3)'n'Borbulhamento'
''''
Idéia:'Comparar'os'elementos'dois'a'dois.'Se'es>verem'fora'de'ordem,'ordenánlos.'
Repe>r'até'que'não'haja'mais'elementos'a'permutar.'
'''
'
A'''=''''['1,'''3,''4,'''5,'''7]'
''
Passo'10':''Permutar'
Posição'a'ser'calculada'
Elemento'a'verificar'se'está'na'
ordem'correta'

183. Ordenamento(3)'n'Borbulhamento'
''''
Idéia:'Comparar'os'elementos'dois'a'dois.'Se'es>verem'fora'de'ordem,'ordenánlos.'
Repe>r'até'que'não'haja'mais'elementos'a'permutar.'
'''
Passo'11':''Comparar'dois'próximos'
'
A'''=''''['1,'''3,''4,'''5,'''7]'
''
Posição'a'ser'calculada'
Elemento'a'verificar'se'está'na'
ordem'correta'

184. Ordenamento(3)'n'Borbulhamento'
''''
Idéia:'Comparar'os'elementos'dois'a'dois.'Se'es>verem'fora'de'ordem,'ordenánlos.'
Repe>r'até'que'não'haja'mais'elementos'a'permutar.'
'''
Passo'12':''Comparar'dois'próximos'
'
A'''=''''['1,'''3,''4,'''5,'''7]'
''
Posição'a'ser'calculada'
Elemento'a'verificar'se'está'na'
ordem'correta'

185. Ordenamento(3)'n'Borbulhamento'
''''
Idéia:'Comparar'os'elementos'dois'a'dois.'Se'es>verem'fora'de'ordem,'ordenánlos.'
Repe>r'até'que'não'haja'mais'elementos'a'permutar.'
'''
Passo'13':''Comparar'dois'próximos'
'
A'''=''''['1,'''3,''4,'''5,'''7]'
''
Posição'a'ser'calculada'
Elemento'a'verificar'se'está'na'
ordem'correta'

186. Ordenamento(3)'n'Borbulhamento'
''''
Idéia:'Comparar'os'elementos'dois'a'dois.'Se'es>verem'fora'de'ordem,'ordenánlos.'
Repe>r'até'que'não'haja'mais'elementos'a'permutar.'
'''
Passo'14':''Como'foi'feita'uma'permutação,'reiniciar'comparando'os'dois'primeiros'
(Nova'passada)'
'
A'''=''''['1,'''3,''4,'''5,'''7]'
''
Posição'a'ser'calculada'
Elemento'a'verificar'se'está'na'
ordem'correta'

187. Ordenamento(3)'n'Borbulhamento'
''''
Idéia:'Comparar'os'elementos'dois'a'dois.'Se'es>verem'fora'de'ordem,'ordenánlos.'
Repe>r'até'que'não'haja'mais'elementos'a'permutar.'
'''
Passo'15':''Comparar'os'dois'próximos'
'
A'''=''''['1,'''3,''4,'''5,'''7]'
''
Posição'a'ser'calculada'
Elemento'a'verificar'se'está'na'
ordem'correta'

188. Ordenamento(3)'n'Borbulhamento'
''''
Idéia:'Comparar'os'elementos'dois'a'dois.'Se'es>verem'fora'de'ordem,'ordenánlos.'
Repe>r'até'que'não'haja'mais'elementos'a'permutar.'
'''
Passo'16':''Comparar'os'dois'próximos'
'
A'''=''''['1,'''3,''4,'''5,'''7]'
''
Posição'a'ser'calculada'
Elemento'a'verificar'se'está'na'
ordem'correta'

189. Ordenamento(3)'n'Borbulhamento'
''''
Idéia:'Comparar'os'elementos'dois'a'dois.'Se'es>verem'fora'de'ordem,'ordenánlos.'
Repe>r'até'que'não'haja'mais'elementos'a'permutar.'
'''
Passo'17':''Comparar'os'dois'próximos'
'
A'''=''''['1,'''3,''4,'''5,'''7]'
''
Posição'a'ser'calculada'
Elemento'a'verificar'se'está'na'
ordem'correta'

190. Ordenamento(3)'n'Borbulhamento'
''''
Idéia:'Comparar'os'elementos'dois'a'dois.'Se'es>verem'fora'de'ordem,'ordenánlos.'
Repe>r'até'que'não'haja'mais'elementos'a'permutar.'
'''
Passo'18':''Como'nenhuma'permutação'foi'feita,'encerrar.'
'
A'''=''''['1,'''3,''4,'''5,'''7]'
''
Posição'a'ser'calculada'
Elemento'a'verificar'se'está'na'
ordem'correta'
Programa41.py'

191. Ordenamento(4)'n'Quicksort'
''''
Idéia:Dividir'a'lista'ao'meio'passar'todos'os'elementos'menores'que'o'meio'para'a'
esquerda'e'todos'os'maiores'para'a'direita.''Chamar'a'função'recursivamente'para'
a'lista'direita,'depois'para'a'esquerda'e'em'seguida'concatenar'as'duas.'O'caso'
básico='lista'vazia.'
''''
Passo'1':''Calcular'a'posição'do'meio''para'n'='5'meio'='2'Elemento'='4'
'
A'''=''''['7,'''4,'''3,'''1,'''5]'
''

192. Ordenamento(4)'n'Quicksort'
''''
Idéia:Dividir'a'lista'ao'meio'passar'todos'os'elementos'menores'que'o'meio'para'a'
esquerda'e'todos'os'maiores'para'a'direita.''Chamar'a'função'recursivamente'para'
a'lista'direita,'depois'para'a'esquerda'e'em'seguida'concatenar'as'duas.'O'caso'
básico='lista'vazia.'
''''
Passo'2':''Criar'lista'Esquerda''L'e'Direita'R''
'
A'''=''''['7,'''4,'''3,'''1,'''5]'
'
L''''='''[]'''''''R''='''[']'
''

193. Ordenamento(4)'n'Quicksort'
''''
Idéia:Dividir'a'lista'ao'meio'passar'todos'os'elementos'menores'que'o'meio'para'a'
esquerda'e'todos'os'maiores'para'a'direita.''Chamar'a'função'recursivamente'para'
a'lista'direita,'depois'para'a'esquerda'e'em'seguida'concatenar'as'duas.'O'caso'
básico='lista'vazia.'
''''
Passo'3':''Preencher'a'lista'Esquerda'com'valores'menores'que'4're>rados''de'A''
'
A'''=''''['7,'''4,'''3,'''1,'''5]'
'
L''''='''[3,1]'''''''R''='''[']'
''

194. Ordenamento(4)'n'Quicksort'
''''
Idéia:Dividir'a'lista'ao'meio'passar'todos'os'elementos'menores'que'o'meio'para'a'
esquerda'e'todos'os'maiores'para'a'direita.''Chamar'a'função'recursivamente'para'
a'lista'direita,'depois'para'a'esquerda'e'em'seguida'concatenar'as'duas.'O'caso'
básico='lista'vazia.'
''''
Passo'4':''Preencher'a'lista'Direita'com'valores'maiores''que'4're>rados''de'A''
'
A'''=''''['7,'''4,'''3,'''1,'''5]'
'
L''''='''[3,1]'''''''R''='''[7,5]''
''

195. Ordenamento(4)'n'Quicksort'
''''
Idéia:Dividir'a'lista'ao'meio'passar'todos'os'elementos'menores'que'o'meio'para'a'
esquerda'e'todos'os'maiores'para'a'direita.''Chamar'a'função'recursivamente'para'
a'lista'direita,'depois'para'a'esquerda'e'em'seguida'concatenar'as'duas.'O'caso'
básico='lista'vazia.'
''''
Passo'5':''A'solução'é'L’+'[4]'+'R'’'
'
A'''=''''L’'+'[4]'+''R’'='[''1,'3,'4,'5,'7]''
''
Viu'como'a'recursão'simplifica'as'coisas?? '''''''''''''''''''''''''''''''''''''''Programa42.py'

196. Ordenamento(4)'n'Quicksort'
''''
'''
Data'source:'first'N'words'of'Charles'Dicken's'life'work.'
Machine:'Dell'2.2GHz'PC'with'1GB'memory'

197. Ordenamento(5)'n'Mergesort'
''''
Idéia:Semelhante'ao'quicksort'com'a'diferença'que'não'faz'o'par>cionamento,'ou'
seja,''apenas'divide'a'lista'ao'meio,'ordena'com'mergesort'(recursiva)'as'duas'
sublistas'geradas'e'intercala'os'resultados'gerados'para'compor'a'solução'final.'
'
A'sua'vez'de'implementar'....'
'''
L'''='''[7,'4]'''''''R''='''[3,1,5]'
L’''='''[4,'7]'''''''R’'='''[1,3,5]'
'
A''='L’''(intercalação'ordenada)'''R’'''''''''''=''''''''''[1'(R’)','3(R’)','4(L’),'5(R’),''7(L’)']'
'

198. Ordenamento(6)'n'Shellsort'
''''
Idéia:'Dada'uma'lista'[10,2,3,4,5,6,7,0,n1,n2,8,9,11,15,65,43,32,11,2,0]'
Agrupanse'a'lista'na'forma'de'uma'matriz'de'(digamos)'7'colunas'
'
10'''2'''3'''4''5'''6'''7'
0''''n1''n2'''8''9'11''15'
65'43'32'11''2''0'''50'
''
A'Seguir'ordenamos'as'colunas'
'
0''''n1'''n2'''4'''2'''0''7'
10'''2''''3''''8''5'''6''15'
65 43'32''11''9'11'50'
Em'seguida'diminuímos'sucessivamente'o'numero'de'colunas'e'ordenamos'até'
chegar'a'uma'coluna'onde'o'algoritmo'termina.'Para'se''ordenar'as'colunas'
podense'usar'a'inserção'ou'o'borbulhamento.''
'
Mais'um'exercício'para'vc'.....'
'

199. Ordenamento(7)'n'Outros'
''''
Shakersort''–'Borbulhamento'bidirecional.'Também'chamado'cocktail'sort.'
Heapsort''–'Usa'um'Heap'como'estrutura'de'dados'para'realizar'a'classificação'
Mul>ple'Heapsort'–'Variante'do'Heapsort'
Quicksort'com'triplo'par>cionamento'–'Variante'do'Quicksort.'
Combsort'–'Melhorias'no'bubble'e'quicksort'
Gnome'sort'–'Variação'da'inserção'
''
Outros:'
'
OddnEven'Sort,'Flashsort,'Introsort,'Library'sort,'Pa>ence'sor>ng'',Tree'sort'(binary'
tree'sort),'Strand'sort,'Bead'sort,'Bucket'sort,'Burstsort,'Coun>ng'sort,'Pigeonhole'
sort,'Postman'sort,'Radix'sort,'Smoothsort,'Bitonic'sorter,'Pancake'sor>ng,'
Topological'sort,''Samplesort'.....'
''

200. Exercício'
''''
''
Um'exercício'simples'para'desopilar:'
'
Dadas'duas'listas'não'ordenadas'A'e'B,'faça'um'programa'para'criar'uma'lista'C'
ordenando'e'intercalando'as'duas'listas'(A'e'B)''na'forma'itera>va.''
''

201. Análise'de'Algoritmos'
'''
Obje>vo:'Determinar'quanto'de'espaço'(memória)'será'necessária'para'execução'de'
um'algoritmo'e'quanto'tempo'o'mesmo'levará'para'ser'executado.'
'
Métricas'normalmente'relacionadas'ao'tamanho'da'entrada:'
Complexidade'de'Tempo:'Número'de'passos'do'algoritmo'''
Complexidade'de'Espaço:'Número'de'unidades'de'memória'
''
Es>ma>vas:'
Notações'Big'O,'Omega,'Big'Omega,'Theta,etc'
'
Exs:'''O'Número'de'passos'executados'em'uma'pesquisa'binária'é'proporcional'ao'
logaritmo'do'comprimento'da'lista'de'entrada.'Na'notação'Big'O.''Dizemos'
'que'sua'complexidade'de'tempo'é'O(log(n)).''
'
Vejamos'a'complexidade'dos'algoritmos'aqui'estudados.'
''

202. Análise'de'Algoritmos'
Um'algoritmo'é'estável'se'ele'mantém'a'ordem'dos'elementos'repe>dos'na'entrada.'

203. Exercício'de'Fixação'
'''
Implemente'o'seguinte'algoritmo:'
'
1. Crie'três'ou'mais'funções'uma'para'cada'>po'de'método'de'ordenamento'que'vc'
deseja'testar.'(Ex.'Bolha,'quick,'shell)'
2. Repita'para'i'='100,'500,'1000,1500,2000,3000,4000,5000,10000,20000,50000,100000'
'2.1'Gere'uma'série'de'lista'de'números'aleatórios'de'tamanho'i'
'2.2'Ordene'a'série'chamando'as'funções'definidas'no'passo'1'
'2.3'Guarde''os'tempos'usados'para'cada'operação'de'ordenamento'
5. Crie'uma'tabela'conforme'modelo'abaixo:'
N ' ' 'Metodo'A 'Metodo'B 'Metodo'C' 'Metodo'D'
100 '' 't11 ' ' 't12 ' ' 't13 ' ' 't14'
500'' 't21 ' ' 't22 ' ' 't23 ' ' 't24 ''
...... ' ''
'
Onde'txx''são'os'tempos'levados'em'cada'operação'
6.'Fim'
'
OBS:'Com'os'dados'ob>dos'acima'gere'um'gráfico'no'openoffice'
'

204. Fim'da'Aula'7'
'''

205. Aula'8'–'Programação'Orientada'a'Objetos''
'''

206. Aula'8'–'POO'n'Classes''
'''
Poo'–'Programação'Orientada'a'Objetos.'O'programa'é'executado'em/por'objetos.'
'
Objeto'n'En>dade'que'possui'atributos'(variáveis'internas')'e'métodos'(funções'
internas)'
'
Classe'–'Descrição'abstrata'de'um'grupo'de'objetos.''Um'objeto'é'uma'instância'de'
uma'classe.'Para'se'criar'um'objeto,'primeiro'se'define'a'sua'classe.'
'
Ex.'Criando'uma'classe'em'Python'
'
class'NomeDaClasse:'
<declaraçãon1>'
.'
.'
.'
<declaraçãonN>''
'

207. Aula'8'–'POO'n'Objetos''
'''
Criando'(instanciando)'objetos:'
'
<objeto>''='nome_da_classe()'
'
Ex.'class'Triangulo:'
''''''''c1'='0'
''''''''c2'='0'
''''''''def'h(t):'#'o'método'('função)''deve'ter'pelo'menos'um'argumento'
''''''''''''''''return'math.sqrt(t.c1**2'+t.c2**2)'
''''''#'fim'da'classe'
''''''t'='Triangulo()'
''''''t.c1'='input("Digite'o'tamanho'do'cateto'1'")'
''''''t.c2'='input("Digite'o'tamanho'do'cateto'2'")'
''''''print'"hipotenusa'é'",t.h()'
'
O'Primeiro'argumento'das'funções'é'o'próprio'objeto.''(self'ou'auto)''
Programa43.py'
'

208. Aula'8'–'POO'n'Construtores'
'''
Método'especial'usado'na'instanciação'de'um'objeto.'(programa44.py)'
'
Ex.'
import'math'
import'os'
os.system("clear")'
class'Triangulo:'
''''''''c1=0'
''''''''c2=0'
''''''''def'__init__(self):''''
Construtor'da'classe'
''''''''''''''''self.c1'='input("Digite'o'tamanho'do'cateto'1'")'
''''''''''''''''self.c2'='input("Digite'o'tamanho'do'cateto'2'")'
''''''''def'h(self):'#'a'funcao'deve'ter'pelo'menos'um'argumento'
''''''''''''''''return'math.sqrt(self.c1**2'+self.c2**2)'
#'fim'da'classe'
t'='Triangulo()'
print'"hipotenusa'é'",t.h() ''
Chama'o'construtor'e'cria'instância'

209. Aula'8'–'POO'n'Herança'
'''
Uma'classe'pode'herdar'atributos'e'métodos'de'uma'(herança'simples)'ou'mais'
classes'(herança'múl>pla).'A'sintaxe'é':'
'
class'ClasseDerivada(Base1,'Base2,'Base3):'
<statementn1>'
.'
.'
.'
<statementnN>'
''

210. Aula'8'–'POO'–'Herançan'Exemplo'
'''
Programa45.py'
'
import'math'
import'os'
os.system("clear")'
class'Triangulo:'
''''''''area'='0'
''''''''>po="'"'
''''''''def'__init__(self):'
''''''''''''''''print'"Criada'a'classe'Base”'

211. Aula'8'–'POO'–'Herançan'Exemplo'
'''
class'TrianguloRetangulo(Triangulo):'
''''''''l1'='0'
''''''''l2'='0'
''''''''def'__init__(self):'
''''''''''''''''Triangulo.__init__(self)'
''''''''''''''''print'"Criando'a'classe'derivada"'
''''''''''''''''self.l1'='input("Qual'o'valor'do'lado'1'")'
''''''''''''''''self.l2'='input("Qual'o'valor'do'lado'2'")'
''''''''''''''''self.area'='self.l1''*'self.l2'/'2.0'
''''''''''''''''print'"Area'='",self.area'
'
#'fim'da'classe'
#'inicio'do'programa'principal'
t'='Triangulo()''''''''''''''''
tr'='TrianguloRetangulo()'

212. Aula'8'–'POO'–'Polimorfismo'
'''
Decisão'em'tempo'de'execução'de'qual'método'a'chamar'em'uma'hierárquica.'Na'
prá>ca'é'semelhante'a'>pagem'dinâmica.'(O'python'é'concebido'assim)'
#'chamada'polimorfica'
t'='tr'
print'"Hipotenusa'(Usando't)''",t.h()'
print'"Hipotenusa'(Usando'tr)'",tr.h()'
t.l1'='1000'
print'"l1'em't'é'",'t.l1'
print'"l1'em'tr'é'",'tr.l1'

213. Aula'8'–'POO'–'Sobrecarga'de'Métodos'
'''
Consiste'na'existência'de'métodos'diferentes'com'o'mesmo'nome.'A'chamada'é'definida'
pela'assinatura'do'método.'(Tipos'e'quan>dades'dos'argumentos).'
'
Python'dispensa'a'sobrecarga'de'métodos'usando'argumentos'flexíveis.'
'
a)"Parâmetros"com"valores"“default”"
'
def'ask_ok(prompt,'retries=4,'complaint=’Yes'or'no,'please!’):'
'
b)"Parâmetros"na"forma"chave=valor"
'
def'parrot(voltage,'state=’a's>ff’,'ac>on=’voom’,'type=’Norwegian'Blue’):'
parrot(ac>on'='’VOOOOOM’,'voltage'='1000000)'
'
c)"Listas"de"argumentos"arbitrária"
def'f(*lista)'
X'='f(1,2,3,4,5,6)'
Lista'='(1,2,3,4,5,6)""
'

214. Aula'8'–'POO'–'Sobrecarga'de'Operadores'
'''
Consiste'em'estender'a'funcionalidade'de'operadores'como'“+”''“n”'etc.'para'outros'
>pos'de'dados'que'não'sejam'os'originalmente'aceitos'pelos'mesmos.'Veja'o'exemplo'
abaixo:'
class'Racional:'
'''def'__init__(self,'divisor,'dividendo):'
''''''self.divisor'='divisor'
''''''self.dividendo'='dividendo'
'
'''def'__str__(self):'
''''''return'str(self.divisor)'+''/''+'str(self.dividendo)'
'
'''def'__mul__(self,'outro):'
''''''divisor'='self.divisor*outro.divisor'
''''''dividendo'='self.dividendo*outro.dividendo'
''''''return'Racional(divisor,'dividendo)'
''

215. Aula'8'–'POO'–'Sobrecarga'de'Operadores'
''' '
O'uso'da'classe'racional'seria:'
'
a'='Racional(1,2)'
b'='Racional(3,4)''
c'='a*b'
print'c'
''''''
Programa46.py'
'

216. Aula'8'–'POO'–'Sobrecarga'de'Operadores'
''' '
Operadores'a'sobrecarregar:'
'
__add__:'Adição.''
__sub__:'Sutração.''
__mul__:'Mul>plicação.'
__div__:'Divisão.'
__mod__:'Resto'da'divisão.'
__pos__:'Iden>dade.'
__neg__:'Nega>vo.''
__abs__:'Absoluto.''
''
Ver'documentação'para'mais'informações.'

217. Aula'8'–'POO'–'Composição'/'Agregação'
'''
'Uma'classe'python'pode'ser'definida'dentro'de'outra'e'conseqüentemente'seus'objetos'
estabelecem'a'relação'de'composição.'Relação'forte.'
'
Ex.'
class'universidade: ''
' 'x,y',z','etc'
' 'class'depto:'
' ' 'jhsdkhìd'
'
#'fim'da'classe'
'
Na'relação'de'composição'uma'classe'possui'uma'variável'referenciando'um'objeto'de'
outra'classe.'Uma'relação'mais'fraca.'
class'depto'
'p'='Professor()'
#'fim'da'classe'
''

218. Exercícios'de'Fixação'
''' '
Crie'uma'classe'chamada'de'Ordenadora'com'os'atributos'básicos'para'uma'tarefa'de'
ordenamento.'A'seguir'crie'classes'filhas'que'implementem'os'diversos'métodos'de'
ordenamento'que'estudamos'na'aula'passada.'

219. Registros'
'''
Registros'são'conjuntos'de'dados'>picamente'usados'para'guardar'dados'em'bancos'
de'dados'onde'cada'linha'da'tabela'é'um'registro.'Algumas'linguagens'como'o'pascal'
(record)'ou'C'(struct)'possuem'este'>po'definido.'
'
Em'Python'podemos'usar'classes'sem'métodos'ou'mesmo'listas'ou'tuplas'de'acordo'
com'o'uso'que'faremos'deles.'
'
Lembrando':' ''
lista'='[1,2,3,4]'
tupla'='1,2,3,4'
Ambas'são'acessadas'com'índices,'mas'com'u>lizações'e'possibilidades'diferentes.'
'
Class'registro:'
'nome=“'“'
'idade'='0'
'peso'=''0'
'

220. Registros'
'''
Vamos'então'criar'um'banco'de'dados'de'alunos'do'IFETnCe.'Colocando'em'uma'lista'
os'nomes,'endereços'e'enmails.'
'
Idéia:'
'
Criar'uma'classe'alunos,'criar'uma'lista'vazia'para'adicionar'os'alunos,'perguntar'a'
quan>dade'de'alunos'a'cadastrar'criar'um'programa'para'cadastrar'ou'mostrar'a'lista'
de'alunos.'
'
''
Uma'melhora:'criar'um'menu'de'entrada'para'que'o'usuário'escolha'o'que'deseja'
fazer.'
'

221. Registros'
'''
Definindo'a'classe.'
''
class'Aluno:'
'''def'__init__(self,'nome,endereco,email):'
''''''self.nome'='nome'
''''''self.endereco'='endereco'
''''''self.email'='email'
'''def'__str__(self):'
''''''return'"nAluno:'"+self.nome+"nEnd:'"+self.endereco+"nenmail:"+self.e$'
#'fim'da'classe'
'

222. Registros'
'''
Nosso'menu'do'programa.'
#'inicio'do'programa'
lista'='[]'
while'True:'
''''''''os.system("clear")'
''''''''print'"Escolha'uma'opção'abaixo:"'
''''''''print'"<1>'Cadastrar'um'Aluno"'
''''''''print'"<2>'Listar'os'Alunos'"'
''''''''print'"<3>'Sair'do'Programa"'
''''''''escolha'='raw_input("Digite'sua'escolha'e'pressione'<enter>'")'
''''''''if'escolha'=='"1”:'
''''''''''''''''os.system("clear")'
''''''''''''''''nome'='raw_input("Digite'o'nome'do'aluno'")'
''''''''''''''''end'='raw_input("Digite'o'endereco'do'aluno'")'
''''''''''''''''mail'='raw_input("Digite'o'enmail'do'aluno'")'
''''''''''''''''obj'='Aluno(nome,end,mail)'
''''''''''''''''lista.append(obj)'
'''''''''
'

223. Registros'
'''
Nosso'menu'do'programa.''n'Con>nuação'
'
'elif'escolha'=='"2”:'
''''''''''''''''for'i'in''lista:'
''''''''''''''''''''''''print'i'
''''''''''''''''raw_input("Digite'enter'para'con>nuar”)'
' 'elif'escolha'=='"3":'
''''''''''''''''break'
print'"Fim”'
''
Programa47.py'
'

224. 2'Probleminhas'
'''
Existem'linguagens'que'não'tem'o'>po'lista'como'o'Python'$'
'
a)'Em'C,Java,Pascal,etc''os'vetores'não'são'vistos'como'listas'de'tamanho'variável.'
'
b)'As'vezes'pode'ser'complicado'inserir'um'registro'(objeto)'como'elemento'de'um'
vetor.'*'
'
Uma'solução'para'a'criação'de'bancos'de'dados'como'estes'que'fizemos'seria'u>lizar'
listas'encadeadas.'
'
Vamos'ver'....'
''''
*'Em'python'basta'usar'o'append(obj)'
'

225. Listas'Encadeadas'
'''
Idéia:'
'
Um'conjunto'de'registros,'além'de'conterem'seus'dados'normais,'possuem'também'
referências'para'outros'registros.'
'
Ex.'
'
class'Aluno:'
'''proximo'='""'
'''def'__init__(self,'nome="",endereco="",email=""):'
''''''self.nome'='nome'
''''''self.endereco'='endereco'
''''''self.email'='email'
'''def'__str__(self):'
''''''return'"nAluno:'"+self.nome+"nEnd:'"+self.endereco+"nenmail:"+self.e$'
#'fim'da'classe'
''