SlideShare uma empresa Scribd logo
1 de 765
Baixar para ler offline
Lógica'de'Programação'com' 
Python' 
Prof.'Ronaldo'Ramos'
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' 
'
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)'
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)'
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)'
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)' 
'
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'
7.'Programação'Modular' 
a. Módulos'padrão,'compilados'e'pacotes'
8.'Entrada'e'Saída' 
a. Entradas'e'Saídas'Formatadas' 
b. Operações'em'arquivos' 
– ''''(Leitura,'Gravação,'Pesquisa)'
9.'Tratamento'de'Erros'e'Exceções' 
a. Blocos'de'Tratamento'de'Exceções'
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'
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'
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'
Vamos'lá'.....'' 
' 
' 
' 
1.'Introdução'aos'Algoritmos'
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]'
1.b'Caracterís>cas'do'Algoritmo' 
• Finito' 
• Não'ambíguo' 
• Capaz'de'receber,'gerar'e'fornecer' 
informações' 
• Executável''
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'
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' 
' 
'
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'
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' 
' 
'
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?' 
' 
''
1.c'–'Formas'de'Representação' 
Textual'' ' ' ' ' ' ' 'Gráfica' 
1.Leia' 
2.Calcule' 
3.Escreva' 
'''' 
' 
' 
'' 
Receba' 
A,B' 
X' X>Y' 
Y'
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'
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'
1.e'–'Estruturas'Básicas' 
Estrutura'Seqüencial:' 
' 
Início' 
Leia'(Receba)'' 
Calcule'' 
Escreva' 
Fim' 
Início' 
Receba' 
Calcule' 
Escreva' 
Fim'
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'
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'
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)' 
'
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).' 
'
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,''
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.'' 
'
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'' 
'' 
'' 
'' 
'
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'
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')' 
''
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.' 
'' 
'
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'
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' 
''
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'
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' 
''' 
''
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.' 
'
Aula'2'–'Seqüências'e'Desvios''
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”)' 
'
2.b'Entradas'e'Saídas' 
Ex:' 
' 
Nome'='input(“Digite'o'nome'do'fucionario”)' 
Valor=input(“Digite'o'valor”)' 
'' 
Experimente...'
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' 
''
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'
2.c'Gravando'os'Fontes' 
Use'o'IDLE'ou'outro'editor'qualquer'para'gravar'os'fontes.'(Nano'por'exemplo)' 
'
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' 
'
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' 
'
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.' 
''
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>' 
' 
''
2.d'Desvios'Aninhados' 
Faça'algoritmos'para:' 
' 
Receber'três'números'e'selecionar'o'maior'entre'eles.' 
'
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'
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' 
'
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'' 
''
Aula'3'n'Laços'
Aula'3'n'Laços' 
Blocos'de'comandos'executados'repe>damente'.'
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' 
'
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' 
'
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' 
'' 
'
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'
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' 
'''''''
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'
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'
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)'
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'
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)'
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'
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'
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'
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'
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)'
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'
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'
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)'
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'
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'
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'
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'
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)'
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'
2.e'Laços'Enquanto'(While)' 
' 
Resumo'do'algoritmo:' 
' 
Entradas:'3,2,4,6' 
' 
Saída:'12'
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.' 
'
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' 
'
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' 
'
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' 
'
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' 
'
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' 
'
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.' 
''
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' 
''
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>]'
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.$
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'
Aula'4'–'Introdução'às'Estruturas'de'Dados'
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’]]' 
'
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]'?' 
''''
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' 
' 
'''
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'' 
' 
'' 
'''
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' 
'' 
'''
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' 
' 
'''
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' 
'' 
'''
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' 
'' 
'''
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' 
''' 
'''
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' 
'' 
'''
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' 
'' 
'''
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?' 
'
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' 
''''
2.e'Gerando'Séries'com'range()' 
Sintaxe:' 
' 
range(inicio,fim,passo)' 
' 
Experimente.' 
''''
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'
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'
2.e'Pausa'–'Concatenação' 
' 
É'possível'somar'valores'alfanuméricos:' 
' 
‘a’'+'‘b’' 
' 
nome'='‘Paulo’' 
sobrenome'='‘Pedreira’' 
Espaco'='‘''‘' 
' 
str'='nome''+'espaco'+'sobrenome' 
' 
str'='?' 
'''
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' 
''
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' 
''
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.' 
''
Fim'da'Aula'4' 
'''
Aula'5'n'Recursão' 
'''
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' 
'
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 ''
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?' 
'''
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'' 
'
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.' 
'
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)'
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í'...' 
''
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' 
'
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' 
''''
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' 
'
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' 
'
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'
Fim'da'Aula'5' 
PAUSA'.....................'
Aula'6'–'Recursão'2'('A'Missão)' 
'''
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]]' 
'' 
'' 
'
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''''''' 
''
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' 
'
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.'' 
' 
'' 
'
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'....'' 
'
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'...?''''''''''' 
'
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'''' 
' 
'' 
'
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'' 
'''
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.....' 
''
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.' 
'
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'
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"
Fim'da'Aula'6'
Aula'7'n'Ordenamento'
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'.....'''
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'
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'
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'
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'
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'
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'
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'
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'
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'
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'
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'
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'
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'
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'
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'
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'
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'
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'
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'
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'
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'
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'
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'
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'
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'
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'
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'
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'
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'
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'
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'
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'
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'
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'
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'
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'
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'
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'
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'
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'
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'
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'
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'
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'
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'
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'
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]' 
''
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''='''[']' 
''
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''='''[']' 
''
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]'' 
''
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'
Ordenamento(4)'n'Quicksort' 
'''' 
''' 
Data'source:'first'N'words'of'Charles'Dicken's'life'work.' 
Machine:'Dell'2.2GHz'PC'with'1GB'memory'
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’)']' 
'
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'.....' 
'
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'.....' 
''
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.'' 
''
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.' 
''
Análise'de'Algoritmos' 
Um'algoritmo'é'estável'se'ele'mantém'a'ordem'dos'elementos'repe>dos'na'entrada.'
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' 
'
Fim'da'Aula'7' 
'''
Aula'8'–'Programação'Orientada'a'Objetos'' 
'''
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>'' 
'
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' 
'
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'
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>' 
''
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”'
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()'
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'
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)"" 
'
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)' 
''
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' 
'
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.'
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' 
''
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.'
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' 
'
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.' 
'
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' 
'
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)' 
''''''''' 
'
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' 
'
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)' 
'
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' 
''
Logica programacao python-slides
Logica programacao python-slides
Logica programacao python-slides
Logica programacao python-slides
Logica programacao python-slides
Logica programacao python-slides
Logica programacao python-slides
Logica programacao python-slides
Logica programacao python-slides
Logica programacao python-slides
Logica programacao python-slides
Logica programacao python-slides
Logica programacao python-slides
Logica programacao python-slides
Logica programacao python-slides
Logica programacao python-slides
Logica programacao python-slides
Logica programacao python-slides
Logica programacao python-slides
Logica programacao python-slides
Logica programacao python-slides
Logica programacao python-slides
Logica programacao python-slides
Logica programacao python-slides
Logica programacao python-slides
Logica programacao python-slides
Logica programacao python-slides
Logica programacao python-slides
Logica programacao python-slides
Logica programacao python-slides
Logica programacao python-slides
Logica programacao python-slides
Logica programacao python-slides
Logica programacao python-slides
Logica programacao python-slides
Logica programacao python-slides
Logica programacao python-slides
Logica programacao python-slides
Logica programacao python-slides
Logica programacao python-slides
Logica programacao python-slides
Logica programacao python-slides
Logica programacao python-slides
Logica programacao python-slides
Logica programacao python-slides
Logica programacao python-slides
Logica programacao python-slides
Logica programacao python-slides
Logica programacao python-slides
Logica programacao python-slides
Logica programacao python-slides
Logica programacao python-slides
Logica programacao python-slides
Logica programacao python-slides
Logica programacao python-slides
Logica programacao python-slides
Logica programacao python-slides
Logica programacao python-slides
Logica programacao python-slides
Logica programacao python-slides
Logica programacao python-slides
Logica programacao python-slides
Logica programacao python-slides
Logica programacao python-slides
Logica programacao python-slides
Logica programacao python-slides
Logica programacao python-slides
Logica programacao python-slides
Logica programacao python-slides
Logica programacao python-slides
Logica programacao python-slides
Logica programacao python-slides
Logica programacao python-slides
Logica programacao python-slides
Logica programacao python-slides
Logica programacao python-slides
Logica programacao python-slides
Logica programacao python-slides
Logica programacao python-slides
Logica programacao python-slides
Logica programacao python-slides
Logica programacao python-slides
Logica programacao python-slides
Logica programacao python-slides
Logica programacao python-slides
Logica programacao python-slides
Logica programacao python-slides
Logica programacao python-slides
Logica programacao python-slides
Logica programacao python-slides
Logica programacao python-slides
Logica programacao python-slides
Logica programacao python-slides
Logica programacao python-slides
Logica programacao python-slides
Logica programacao python-slides
Logica programacao python-slides
Logica programacao python-slides
Logica programacao python-slides
Logica programacao python-slides
Logica programacao python-slides
Logica programacao python-slides
Logica programacao python-slides
Logica programacao python-slides
Logica programacao python-slides
Logica programacao python-slides
Logica programacao python-slides
Logica programacao python-slides
Logica programacao python-slides
Logica programacao python-slides
Logica programacao python-slides
Logica programacao python-slides
Logica programacao python-slides
Logica programacao python-slides
Logica programacao python-slides
Logica programacao python-slides
Logica programacao python-slides
Logica programacao python-slides
Logica programacao python-slides
Logica programacao python-slides
Logica programacao python-slides
Logica programacao python-slides
Logica programacao python-slides
Logica programacao python-slides
Logica programacao python-slides
Logica programacao python-slides
Logica programacao python-slides
Logica programacao python-slides
Logica programacao python-slides
Logica programacao python-slides
Logica programacao python-slides
Logica programacao python-slides
Logica programacao python-slides
Logica programacao python-slides
Logica programacao python-slides
Logica programacao python-slides
Logica programacao python-slides
Logica programacao python-slides
Logica programacao python-slides
Logica programacao python-slides
Logica programacao python-slides
Logica programacao python-slides
Logica programacao python-slides
Logica programacao python-slides
Logica programacao python-slides
Logica programacao python-slides
Logica programacao python-slides
Logica programacao python-slides
Logica programacao python-slides
Logica programacao python-slides
Logica programacao python-slides
Logica programacao python-slides
Logica programacao python-slides
Logica programacao python-slides
Logica programacao python-slides
Logica programacao python-slides
Logica programacao python-slides
Logica programacao python-slides
Logica programacao python-slides
Logica programacao python-slides
Logica programacao python-slides
Logica programacao python-slides
Logica programacao python-slides
Logica programacao python-slides
Logica programacao python-slides
Logica programacao python-slides
Logica programacao python-slides
Logica programacao python-slides
Logica programacao python-slides
Logica programacao python-slides
Logica programacao python-slides
Logica programacao python-slides
Logica programacao python-slides
Logica programacao python-slides
Logica programacao python-slides
Logica programacao python-slides
Logica programacao python-slides
Logica programacao python-slides
Logica programacao python-slides
Logica programacao python-slides
Logica programacao python-slides
Logica programacao python-slides
Logica programacao python-slides
Logica programacao python-slides
Logica programacao python-slides
Logica programacao python-slides
Logica programacao python-slides
Logica programacao python-slides
Logica programacao python-slides
Logica programacao python-slides
Logica programacao python-slides
Logica programacao python-slides
Logica programacao python-slides
Logica programacao python-slides
Logica programacao python-slides
Logica programacao python-slides
Logica programacao python-slides
Logica programacao python-slides
Logica programacao python-slides
Logica programacao python-slides
Logica programacao python-slides
Logica programacao python-slides
Logica programacao python-slides
Logica programacao python-slides
Logica programacao python-slides
Logica programacao python-slides
Logica programacao python-slides
Logica programacao python-slides
Logica programacao python-slides
Logica programacao python-slides
Logica programacao python-slides
Logica programacao python-slides
Logica programacao python-slides
Logica programacao python-slides
Logica programacao python-slides
Logica programacao python-slides
Logica programacao python-slides
Logica programacao python-slides
Logica programacao python-slides
Logica programacao python-slides
Logica programacao python-slides
Logica programacao python-slides
Logica programacao python-slides
Logica programacao python-slides
Logica programacao python-slides
Logica programacao python-slides
Logica programacao python-slides
Logica programacao python-slides
Logica programacao python-slides
Logica programacao python-slides
Logica programacao python-slides
Logica programacao python-slides
Logica programacao python-slides
Logica programacao python-slides
Logica programacao python-slides
Logica programacao python-slides
Logica programacao python-slides
Logica programacao python-slides
Logica programacao python-slides
Logica programacao python-slides
Logica programacao python-slides
Logica programacao python-slides
Logica programacao python-slides
Logica programacao python-slides
Logica programacao python-slides
Logica programacao python-slides
Logica programacao python-slides
Logica programacao python-slides
Logica programacao python-slides
Logica programacao python-slides
Logica programacao python-slides
Logica programacao python-slides
Logica programacao python-slides
Logica programacao python-slides
Logica programacao python-slides
Logica programacao python-slides
Logica programacao python-slides
Logica programacao python-slides
Logica programacao python-slides
Logica programacao python-slides
Logica programacao python-slides
Logica programacao python-slides
Logica programacao python-slides
Logica programacao python-slides
Logica programacao python-slides
Logica programacao python-slides
Logica programacao python-slides
Logica programacao python-slides
Logica programacao python-slides
Logica programacao python-slides
Logica programacao python-slides
Logica programacao python-slides
Logica programacao python-slides
Logica programacao python-slides
Logica programacao python-slides
Logica programacao python-slides
Logica programacao python-slides
Logica programacao python-slides
Logica programacao python-slides
Logica programacao python-slides
Logica programacao python-slides
Logica programacao python-slides
Logica programacao python-slides
Logica programacao python-slides
Logica programacao python-slides
Logica programacao python-slides
Logica programacao python-slides
Logica programacao python-slides
Logica programacao python-slides
Logica programacao python-slides
Logica programacao python-slides
Logica programacao python-slides
Logica programacao python-slides
Logica programacao python-slides
Logica programacao python-slides
Logica programacao python-slides
Logica programacao python-slides
Logica programacao python-slides
Logica programacao python-slides
Logica programacao python-slides
Logica programacao python-slides
Logica programacao python-slides
Logica programacao python-slides
Logica programacao python-slides
Logica programacao python-slides
Logica programacao python-slides
Logica programacao python-slides
Logica programacao python-slides
Logica programacao python-slides
Logica programacao python-slides
Logica programacao python-slides
Logica programacao python-slides
Logica programacao python-slides
Logica programacao python-slides
Logica programacao python-slides
Logica programacao python-slides
Logica programacao python-slides
Logica programacao python-slides
Logica programacao python-slides
Logica programacao python-slides
Logica programacao python-slides
Logica programacao python-slides
Logica programacao python-slides
Logica programacao python-slides
Logica programacao python-slides
Logica programacao python-slides
Logica programacao python-slides
Logica programacao python-slides
Logica programacao python-slides
Logica programacao python-slides
Logica programacao python-slides
Logica programacao python-slides
Logica programacao python-slides
Logica programacao python-slides
Logica programacao python-slides
Logica programacao python-slides
Logica programacao python-slides
Logica programacao python-slides
Logica programacao python-slides
Logica programacao python-slides
Logica programacao python-slides
Logica programacao python-slides
Logica programacao python-slides
Logica programacao python-slides
Logica programacao python-slides
Logica programacao python-slides
Logica programacao python-slides
Logica programacao python-slides
Logica programacao python-slides
Logica programacao python-slides
Logica programacao python-slides
Logica programacao python-slides
Logica programacao python-slides
Logica programacao python-slides
Logica programacao python-slides
Logica programacao python-slides
Logica programacao python-slides
Logica programacao python-slides
Logica programacao python-slides
Logica programacao python-slides
Logica programacao python-slides
Logica programacao python-slides
Logica programacao python-slides
Logica programacao python-slides
Logica programacao python-slides
Logica programacao python-slides
Logica programacao python-slides
Logica programacao python-slides
Logica programacao python-slides
Logica programacao python-slides
Logica programacao python-slides
Logica programacao python-slides
Logica programacao python-slides
Logica programacao python-slides
Logica programacao python-slides
Logica programacao python-slides
Logica programacao python-slides
Logica programacao python-slides
Logica programacao python-slides
Logica programacao python-slides
Logica programacao python-slides
Logica programacao python-slides
Logica programacao python-slides
Logica programacao python-slides
Logica programacao python-slides
Logica programacao python-slides
Logica programacao python-slides
Logica programacao python-slides
Logica programacao python-slides
Logica programacao python-slides
Logica programacao python-slides
Logica programacao python-slides
Logica programacao python-slides
Logica programacao python-slides
Logica programacao python-slides
Logica programacao python-slides
Logica programacao python-slides
Logica programacao python-slides
Logica programacao python-slides
Logica programacao python-slides
Logica programacao python-slides
Logica programacao python-slides
Logica programacao python-slides
Logica programacao python-slides
Logica programacao python-slides
Logica programacao python-slides
Logica programacao python-slides
Logica programacao python-slides
Logica programacao python-slides
Logica programacao python-slides
Logica programacao python-slides
Logica programacao python-slides
Logica programacao python-slides
Logica programacao python-slides
Logica programacao python-slides
Logica programacao python-slides
Logica programacao python-slides
Logica programacao python-slides
Logica programacao python-slides
Logica programacao python-slides
Logica programacao python-slides
Logica programacao python-slides
Logica programacao python-slides
Logica programacao python-slides
Logica programacao python-slides
Logica programacao python-slides
Logica programacao python-slides
Logica programacao python-slides
Logica programacao python-slides
Logica programacao python-slides
Logica programacao python-slides
Logica programacao python-slides
Logica programacao python-slides
Logica programacao python-slides
Logica programacao python-slides
Logica programacao python-slides
Logica programacao python-slides
Logica programacao python-slides
Logica programacao python-slides
Logica programacao python-slides
Logica programacao python-slides
Logica programacao python-slides
Logica programacao python-slides
Logica programacao python-slides
Logica programacao python-slides
Logica programacao python-slides
Logica programacao python-slides
Logica programacao python-slides
Logica programacao python-slides
Logica programacao python-slides
Logica programacao python-slides
Logica programacao python-slides
Logica programacao python-slides
Logica programacao python-slides
Logica programacao python-slides
Logica programacao python-slides
Logica programacao python-slides
Logica programacao python-slides
Logica programacao python-slides
Logica programacao python-slides
Logica programacao python-slides
Logica programacao python-slides
Logica programacao python-slides
Logica programacao python-slides
Logica programacao python-slides
Logica programacao python-slides
Logica programacao python-slides
Logica programacao python-slides
Logica programacao python-slides
Logica programacao python-slides
Logica programacao python-slides
Logica programacao python-slides
Logica programacao python-slides
Logica programacao python-slides
Logica programacao python-slides
Logica programacao python-slides
Logica programacao python-slides
Logica programacao python-slides
Logica programacao python-slides
Logica programacao python-slides
Logica programacao python-slides
Logica programacao python-slides
Logica programacao python-slides
Logica programacao python-slides
Logica programacao python-slides
Logica programacao python-slides
Logica programacao python-slides
Logica programacao python-slides
Logica programacao python-slides
Logica programacao python-slides
Logica programacao python-slides
Logica programacao python-slides
Logica programacao python-slides
Logica programacao python-slides
Logica programacao python-slides
Logica programacao python-slides
Logica programacao python-slides
Logica programacao python-slides
Logica programacao python-slides
Logica programacao python-slides
Logica programacao python-slides
Logica programacao python-slides
Logica programacao python-slides
Logica programacao python-slides
Logica programacao python-slides
Logica programacao python-slides
Logica programacao python-slides
Logica programacao python-slides
Logica programacao python-slides
Logica programacao python-slides
Logica programacao python-slides
Logica programacao python-slides
Logica programacao python-slides
Logica programacao python-slides
Logica programacao python-slides
Logica programacao python-slides
Logica programacao python-slides
Logica programacao python-slides
Logica programacao python-slides
Logica programacao python-slides
Logica programacao python-slides
Logica programacao python-slides
Logica programacao python-slides
Logica programacao python-slides
Logica programacao python-slides
Logica programacao python-slides
Logica programacao python-slides
Logica programacao python-slides
Logica programacao python-slides
Logica programacao python-slides
Logica programacao python-slides
Logica programacao python-slides
Logica programacao python-slides
Logica programacao python-slides
Logica programacao python-slides
Logica programacao python-slides
Logica programacao python-slides
Logica programacao python-slides
Logica programacao python-slides
Logica programacao python-slides

Mais conteúdo relacionado

Mais procurados

Python - Introdução Básica
Python - Introdução BásicaPython - Introdução Básica
Python - Introdução Básica
Christian Perone
 
Aula 6 - Estruturas de seleção encadeada - parte 1
Aula 6 - Estruturas de seleção encadeada - parte 1Aula 6 - Estruturas de seleção encadeada - parte 1
Aula 6 - Estruturas de seleção encadeada - parte 1
Pacc UAB
 
Java orientação a objetos (associacao, composicao, agregacao)
Java   orientação a objetos (associacao, composicao, agregacao)Java   orientação a objetos (associacao, composicao, agregacao)
Java orientação a objetos (associacao, composicao, agregacao)
Armando Daniel
 
Aula 5 - Estruturas de seleção encadeada - parte 2
Aula 5 - Estruturas de seleção encadeada - parte 2Aula 5 - Estruturas de seleção encadeada - parte 2
Aula 5 - Estruturas de seleção encadeada - parte 2
Pacc UAB
 

Mais procurados (20)

Python - Introdução Básica
Python - Introdução BásicaPython - Introdução Básica
Python - Introdução Básica
 
Estrutura de Dados - Aula 06 - Pilhas Estáticas
Estrutura de Dados - Aula 06 - Pilhas EstáticasEstrutura de Dados - Aula 06 - Pilhas Estáticas
Estrutura de Dados - Aula 06 - Pilhas Estáticas
 
Aula 6 - Estruturas de seleção encadeada - parte 1
Aula 6 - Estruturas de seleção encadeada - parte 1Aula 6 - Estruturas de seleção encadeada - parte 1
Aula 6 - Estruturas de seleção encadeada - parte 1
 
Aula 10 - Diagrama de Sequencia.pdf
Aula 10 - Diagrama de Sequencia.pdfAula 10 - Diagrama de Sequencia.pdf
Aula 10 - Diagrama de Sequencia.pdf
 
Programando para web com python - Introdução a Python
Programando para web com python - Introdução a PythonProgramando para web com python - Introdução a Python
Programando para web com python - Introdução a Python
 
Introdução a python
Introdução a pythonIntrodução a python
Introdução a python
 
Banco de Dados I - Aula 06 - Banco de Dados Relacional (Modelo Lógico)
Banco de Dados I - Aula 06 - Banco de Dados Relacional (Modelo Lógico)Banco de Dados I - Aula 06 - Banco de Dados Relacional (Modelo Lógico)
Banco de Dados I - Aula 06 - Banco de Dados Relacional (Modelo Lógico)
 
Introdução a Banco de Dados (Parte 2)
Introdução a Banco de Dados (Parte 2)Introdução a Banco de Dados (Parte 2)
Introdução a Banco de Dados (Parte 2)
 
Java orientação a objetos (associacao, composicao, agregacao)
Java   orientação a objetos (associacao, composicao, agregacao)Java   orientação a objetos (associacao, composicao, agregacao)
Java orientação a objetos (associacao, composicao, agregacao)
 
Introdução a linguagem Python
Introdução a linguagem PythonIntrodução a linguagem Python
Introdução a linguagem Python
 
Python e django na prática
Python e django na práticaPython e django na prática
Python e django na prática
 
BD I - Aula 04 A - Resumo MER e Mapeamento Relacional
BD I - Aula 04 A - Resumo MER e Mapeamento RelacionalBD I - Aula 04 A - Resumo MER e Mapeamento Relacional
BD I - Aula 04 A - Resumo MER e Mapeamento Relacional
 
Aula 5 - Estruturas de seleção encadeada - parte 2
Aula 5 - Estruturas de seleção encadeada - parte 2Aula 5 - Estruturas de seleção encadeada - parte 2
Aula 5 - Estruturas de seleção encadeada - parte 2
 
Banco de Dados
Banco de DadosBanco de Dados
Banco de Dados
 
6 estruturas de dados heterogêneas
6  estruturas de dados heterogêneas6  estruturas de dados heterogêneas
6 estruturas de dados heterogêneas
 
Lógica de programação { para iniciantes }
Lógica de programação { para iniciantes }Lógica de programação { para iniciantes }
Lógica de programação { para iniciantes }
 
Introdução a Linguagem de Programação C
Introdução a Linguagem de Programação CIntrodução a Linguagem de Programação C
Introdução a Linguagem de Programação C
 
Estrutura de Dados - Conceitos fundamentais
Estrutura de Dados - Conceitos fundamentaisEstrutura de Dados - Conceitos fundamentais
Estrutura de Dados - Conceitos fundamentais
 
Aula 01 - Algoritmo e Programação
Aula 01 - Algoritmo e ProgramaçãoAula 01 - Algoritmo e Programação
Aula 01 - Algoritmo e Programação
 
Introdução ao Python
Introdução ao PythonIntrodução ao Python
Introdução ao Python
 

Destaque

14 programando em python - interfaces graficas com tk
 14   programando em python - interfaces graficas com tk 14   programando em python - interfaces graficas com tk
14 programando em python - interfaces graficas com tk
Victor Marcelino
 
Formação mp escola de servos
Formação mp escola de servosFormação mp escola de servos
Formação mp escola de servos
Carlos Junior
 

Destaque (15)

Daniel 7
Daniel 7Daniel 7
Daniel 7
 
Daniel 10
Daniel 10Daniel 10
Daniel 10
 
Construção de interfaces gráficas com Tkinter
Construção de interfaces gráficas com TkinterConstrução de interfaces gráficas com Tkinter
Construção de interfaces gráficas com Tkinter
 
Daniel 6
Daniel 6Daniel 6
Daniel 6
 
14 programando em python - interfaces graficas com tk
 14   programando em python - interfaces graficas com tk 14   programando em python - interfaces graficas com tk
14 programando em python - interfaces graficas com tk
 
Formação mp escola de servos
Formação mp escola de servosFormação mp escola de servos
Formação mp escola de servos
 
REFLEXÕES E INFORMAÇÕES
REFLEXÕES E INFORMAÇÕESREFLEXÕES E INFORMAÇÕES
REFLEXÕES E INFORMAÇÕES
 
“Anunciando a Palavra – O ministério da evangelização"
“Anunciando a Palavra – O ministério da evangelização"“Anunciando a Palavra – O ministério da evangelização"
“Anunciando a Palavra – O ministério da evangelização"
 
Daniel 5
Daniel 5Daniel 5
Daniel 5
 
Daniel 9
Daniel 9Daniel 9
Daniel 9
 
Daniel 2
Daniel 2Daniel 2
Daniel 2
 
Python Interface Gráfica Tkinter
Python Interface Gráfica TkinterPython Interface Gráfica Tkinter
Python Interface Gráfica Tkinter
 
Daniel 1
Daniel 1Daniel 1
Daniel 1
 
Daniel 4
Daniel 4Daniel 4
Daniel 4
 
Daniel 3
Daniel 3Daniel 3
Daniel 3
 

Semelhante a Logica programacao python-slides

Introdução a Linguagem C
Introdução a Linguagem CIntrodução a Linguagem C
Introdução a Linguagem C
apolllorj
 
A Linguagem Lua e suas Aplicações em Jogos
A Linguagem Lua e suas Aplicações em JogosA Linguagem Lua e suas Aplicações em Jogos
A Linguagem Lua e suas Aplicações em Jogos
elliando dias
 
Aula 3 - Algoritmos computacionais - parte 1
Aula 3 - Algoritmos computacionais - parte 1Aula 3 - Algoritmos computacionais - parte 1
Aula 3 - Algoritmos computacionais - parte 1
Pacc UAB
 
Conceitos e técnicas de programação aula 2
Conceitos e técnicas de programação aula 2Conceitos e técnicas de programação aula 2
Conceitos e técnicas de programação aula 2
Robson Ferreira
 
Linguagem C 01 Primeiros Passos
Linguagem C 01 Primeiros PassosLinguagem C 01 Primeiros Passos
Linguagem C 01 Primeiros Passos
Regis Magalhães
 
Algoritmos C/C++ - Aula 01
Algoritmos C/C++ - Aula 01Algoritmos C/C++ - Aula 01
Algoritmos C/C++ - Aula 01
Leandro Rezende
 

Semelhante a Logica programacao python-slides (20)

Introdução a Linguagem C
Introdução a Linguagem CIntrodução a Linguagem C
Introdução a Linguagem C
 
Apres. Marcos Souza2
Apres. Marcos Souza2Apres. Marcos Souza2
Apres. Marcos Souza2
 
A Linguagem Lua e suas Aplicações em Jogos
A Linguagem Lua e suas Aplicações em JogosA Linguagem Lua e suas Aplicações em Jogos
A Linguagem Lua e suas Aplicações em Jogos
 
Algoritmos, Inteligência Artificial e Políticas Públicas
Algoritmos, Inteligência Artificial e Políticas PúblicasAlgoritmos, Inteligência Artificial e Políticas Públicas
Algoritmos, Inteligência Artificial e Políticas Públicas
 
Aula 3 - Algoritmos computacionais - parte 1
Aula 3 - Algoritmos computacionais - parte 1Aula 3 - Algoritmos computacionais - parte 1
Aula 3 - Algoritmos computacionais - parte 1
 
Curso Completo de Linguagem de Programação C
Curso Completo de Linguagem de Programação CCurso Completo de Linguagem de Programação C
Curso Completo de Linguagem de Programação C
 
Comandos de Controle de Programa em C
Comandos de Controle de Programa em CComandos de Controle de Programa em C
Comandos de Controle de Programa em C
 
Conceitos e técnicas de programação aula 2
Conceitos e técnicas de programação aula 2Conceitos e técnicas de programação aula 2
Conceitos e técnicas de programação aula 2
 
Arduino e Python: Do It Yourself
Arduino e Python: Do It YourselfArduino e Python: Do It Yourself
Arduino e Python: Do It Yourself
 
Python No Terra (2006-12-21)
Python No Terra  (2006-12-21)Python No Terra  (2006-12-21)
Python No Terra (2006-12-21)
 
Algoritmos e Programação: Funcionamento do computador. Conceito e definição d...
Algoritmos e Programação: Funcionamento do computador. Conceito e definição d...Algoritmos e Programação: Funcionamento do computador. Conceito e definição d...
Algoritmos e Programação: Funcionamento do computador. Conceito e definição d...
 
Aula09 traducaosin110
Aula09 traducaosin110Aula09 traducaosin110
Aula09 traducaosin110
 
Linguagem C 01 Primeiros Passos
Linguagem C 01 Primeiros PassosLinguagem C 01 Primeiros Passos
Linguagem C 01 Primeiros Passos
 
Linguagem C - Controle de Programa
Linguagem C - Controle de ProgramaLinguagem C - Controle de Programa
Linguagem C - Controle de Programa
 
Algoritmos C/C++ - Aula 01
Algoritmos C/C++ - Aula 01Algoritmos C/C++ - Aula 01
Algoritmos C/C++ - Aula 01
 
Linguagem C clecioamerico
Linguagem C clecioamericoLinguagem C clecioamerico
Linguagem C clecioamerico
 
Aula 01 Logica de Programacao - Logica Matematica 1.pdf
Aula 01 Logica de Programacao - Logica Matematica 1.pdfAula 01 Logica de Programacao - Logica Matematica 1.pdf
Aula 01 Logica de Programacao - Logica Matematica 1.pdf
 
Aula 01 Logica de Programacao - Logica Matematica 1.pdf
Aula 01 Logica de Programacao - Logica Matematica 1.pdfAula 01 Logica de Programacao - Logica Matematica 1.pdf
Aula 01 Logica de Programacao - Logica Matematica 1.pdf
 
Abel Pires e Pedro Jesus
Abel Pires e Pedro JesusAbel Pires e Pedro Jesus
Abel Pires e Pedro Jesus
 
Inteligencia Artificial e Aprendizado de Máquina
Inteligencia Artificial e Aprendizado de MáquinaInteligencia Artificial e Aprendizado de Máquina
Inteligencia Artificial e Aprendizado de Máquina