Logica programacao python-slides

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'

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'

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'
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'
'

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'
'

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'“)'
'acumulador'='acumulador'+'numero'
print''“A'soma'total'dos'números'fornecidos'é'“,Acumulador'
''
'

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”)'
print''“A'soma'total'dos'numeros'fornecidos'eh'“,Acumulador'
Contador':'0' '''''''
Saída'no'Vídeo'

'
Contador'='0''''''''''''''''''''''''''''''''''''''''''''
Acumulador'='0'''''''''''''''''''''''''''''''''''''''Passo'2':'Declara'Acumulador'
Variáveis' Saída'no'Vídeo'
Contador':'0'
Acumulador:'0'
'''''''

'
Contador'='0''''''''''''''''''''''''''''''''''''''''''''
Acumulador'='0''''''''''''''''''''''''''''''''''''''''
Contador':'0'
Acumulador:'0'
'
Digite'a'quan>dade'de'numeros'a'ser'u>lizada''
'''''
Passo'3:'
Solicita'Valor'

'
Contador'='0''''''''''''''''''''''''''''''''''''''''''''
Acumulador'='0''''''''''''''''''''''''''''''''''''''''
Contador':'0'
Acumulador:'0'
Quan>dade:'3'
'
Digite'a'quan>dade'de'numeros'a'ser'u>lizada'3''
'''''
Passo'3:'
Usuário'digita'valor'

'
Contador'='0''''''''''''''''''''''''''''''''''''''''''''
Acumulador'='0''''''''''''''''''''''''''''''''''''''''
print''“A'soma'total'dos'números'fornecidos'eh'“,Acumulador'
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)'

'
Contador'='0''''''''''''''''''''''''''''''''''''''''''''
Acumulador'='0''''''''''''''''''''''''''''''''''''''''
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'

'
Contador'='0''''''''''''''''''''''''''''''''''''''''''''
Acumulador'='0''''''''''''''''''''''''''''''''''''''''
Contador':'0'
Acumulador:'0'
Quan>dade:'3'
numero':'2''
'
Digite'um'valor'numerico'2''
''''
Passo'5:'Usuário'
Fornece'Valor'Numérico'
(2)'

'
Contador'='0''''''''''''''''''''''''''''''''''''''''''''
Acumulador'='0''''''''''''''''''''''''''''''''''''''''
Contador':'1'
Acumulador:'0'
Quan>dade:'3'
numero':'2''
'
''''
Passo'6:'contador'é'incrementado'

'
Contador'='0''''''''''''''''''''''''''''''''''''''''''''
Acumulador'='0''''''''''''''''''''''''''''''''''''''''
Contador':'1'
Acumulador:'2'
Quan>dade:'3'
numero':'2''
'
''''
Passo'7:'Acumulador'é'
acrescido'do'valor'de'numero'

'
Contador'='0''''''''''''''''''''''''''''''''''''''''''''
Acumulador'='0''''''''''''''''''''''''''''''''''''''''
Contador':'1'
Acumulador:'2'
Quan>dade:'3'
numero':'2''
'
''''
Passo'8:''Próxima'Iteração'do'laço.'
Condicão'ainda'é'verdadeira'

'
Contador'='0''''''''''''''''''''''''''''''''''''''''''''
Acumulador'='0''''''''''''''''''''''''''''''''''''''''
Contador':'1'
Acumulador:'2'
Quan>dade:'3'
numero':'2''
'
Digite'um'valor'numerico'2'
Digite'um'valor'numerico''
'''
Passo'9:''Solicita'valor'para'numero'

'
Contador'='0''''''''''''''''''''''''''''''''''''''''''''
Acumulador'='0''''''''''''''''''''''''''''''''''''''''
print''“A'soma'total'dos'números'fornecidos'eh'“,Acumulador'
Contador':'1'
Acumulador:'2'
Quan>dade:'3'
numero':'4''
'
'''
Passo'9:''Usuário'digita'valor'(4)'

'
Contador'='0''''''''''''''''''''''''''''''''''''''''''''
Acumulador'='0''''''''''''''''''''''''''''''''''''''''
Contador':'2'
Acumulador:'2'
Quan>dade:'3'
numero':'4''
'
'''
Passo'10:''Contador'é'incrementado'

'
Contador'='0''''''''''''''''''''''''''''''''''''''''''''
Acumulador'='0''''''''''''''''''''''''''''''''''''''''
Contador':'2'
Acumulador:'6'
Quan>dade:'3'
numero':'4''
'
'''
Passo'11:''Acumulador'é'acrescido'de'
numero'

'
Contador'='0''''''''''''''''''''''''''''''''''''''''''''
Acumulador'='0''''''''''''''''''''''''''''''''''''''''
Contador':'2'
Acumulador:'6'
Quan>dade:'3'
numero':'4''
'
'''
Passo'12:''Proxima'Iteração'
Condição'verdadeira'
Contador'(2)''<'quan>dade'(3)'

'
Contador'='0''''''''''''''''''''''''''''''''''''''''''''
Acumulador'='0''''''''''''''''''''''''''''''''''''''''
Contador':'2'
Acumulador:'6'
Quan>dade:'3'
numero':'4''
'
Digite'um'valor'numerico'''
''
Passo'13:''Solicita'dado'

'
Contador'='0''''''''''''''''''''''''''''''''''''''''''''
Acumulador'='0''''''''''''''''''''''''''''''''''''''''
Contador':'2'
Acumulador:'6'
Quan>dade:'3'
numero':'6''
'
Digite'um'valor'numerico'6'''
''
Passo'13:''Usuário'
fornece'dado'

'
Contador'='0''''''''''''''''''''''''''''''''''''''''''''
Acumulador'='0''''''''''''''''''''''''''''''''''''''''
Contador':'3'
Acumulador:'6'
Quan>dade:'3'
numero':'6''
'
''
Passo'14:'contador'incrementado'

'
Contador'='0''''''''''''''''''''''''''''''''''''''''''''
Acumulador'='0''''''''''''''''''''''''''''''''''''''''
Contador':'3'
Acumulador:'12'
Quan>dade:'3'
numero':'6''
'
''
Passo'15:'Acumulador'acrescido'
de'numero'

'
Contador'='0''''''''''''''''''''''''''''''''''''''''''''
Acumulador'='0''''''''''''''''''''''''''''''''''''''''
Contador':'3'
Acumulador:'12'
Quan>dade:'3'
numero':'6''
'
''
Passo'16:'Próxima'Iteração'
Condicão'falsa'
Contador'(3)'<'quan>dade'(3)'

'
Contador'='0''''''''''''''''''''''''''''''''''''''''''''
Acumulador'='0''''''''''''''''''''''''''''''''''''''''
Contador':'3'
Acumulador:'12'
Quan>dade:'3'
numero':'6''
'
A'soma'total'dos'numeros'fornecidos'eh'12'''
''
Passo'17:'Saida'de'resultado'no'
video'

'
Resumo'do'algoritmo:'
'
Entradas:'3,2,4,6'
'
Saída:'12'

'
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'
'

Lógica:'
'
0,'1,3,6,10,15'.........'N'
'
Detalhe:'Tratanse'de'uma'PA'com'razão'crescente.''
'
'

Lógica:'
'
0,N,1,Nn1,2,Nn2........N,0'
''
Detalhe:'Uma'série'com'valores'crescentes'intercalados'com'valores'decrescentes''
'
'

2.e''Gerando'a'série'de'Fibonacci'
Lógica:'
'
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'
'
'''

• 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''
'
''
'''

• 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'
''
'''

• 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.'
'
'''

• 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.'
'
''
'''

• 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'
''
'''

• Selecione'os'elementos'pares'de'um'vetor'
• 'Use'um'laço'para'acessar'todos'os'elementos'do'vetor.'Imprimir'todos'os'que'forem'
pares'
'''
'''

• 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'
'
''
'''

• 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'
''
'''

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'
''

'''
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'
''

'''
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.'
''

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'
'

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'
''''

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'
'

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'
'

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)'
'''

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]]'
''
''
'

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'''''''
''

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'
'

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'...?'''''''''''
'

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''''
'
''
'

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''
'''

'
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'
[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"

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'

''''
'''
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'

''''
'''
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'

''''
'''
Passo'4':''Mantemos'o'valor'do'elemento'pois'já'está'na'posição'correta!'
'
A'''=''''[''1','''3''',''7,'''4,'''5]'
''
remanescente'

''''
'''
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]'
''
remanescente'

''''
'''
Passo'6':Intercambiamos'os'valores'da'posição'atual'com'a'posição'do'menor'
remanescente'
'
A'''=''''[''1','''3''',''4,'''7,'''5]'
''
remanescente'

''''
'''
Passo'7':'Atualizamos'a'posição'ser'calculada'e'selecionamos'o'menor'valor'
remanescente'
'
A'''=''''[''1','''3''',''4,'''7,'''5]'
''
remanescente'

''''
'''
Passo'8':'Intercambiamos'os'valores'encontrados'
'
A'''=''''[''1','''3''',''4,'''5,'''7]'
''
remanescente'

''''
'''
Passo'9':'Operação'finalizada.'A'Lista'está'ordenada'
'
A'''=''''[''1','''3''',''4,'''5,'''7]'
''
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'

''''
ordenado.'
'''
Passo'2':'Insere'(copia)''elemento'zero'(7)'na'posição'da'chave'
'
A'''=''''['7,'''7''',''1,'''4,'''5]'
''
ordem'correta'

''''
ordenado.'
'''
Passo'3':'Insere'(copia)''o'valor'da'chave'na'posição'0'
'
A'''=''''['3,'''7''',''1,'''4,'''5]'
''
ordem'correta'

''''
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]'
''
ordem'correta'

''''
ordenado.'
'''
Passo'5':''Desloca'(copia)'o'valor'anterior'uma'posição'à'frente'
'
A'''=''''['3,'''7,'''7,'''4,'''5]'
''
ordem'correta'

''''
ordenado.'
'''
Passo'6':''Verifica'se'o'elemento'mais'a'esquerda'é'menor'que'chave'(1)'(falso)'
'
A'''=''''['3,'''7,'''7,'''4,'''5]'
''
ordem'correta'

''''
ordenado.'
'''
Passo'7':''Desloca'(copia'o'elemento'para'frente)'
'
A'''=''''['3,'''3,'''7,'''4,'''5]'
''
ordem'correta'

''''
ordenado.'
'''
Passo'8':''Copia'o'valor'da'chave'para''o'início'
'
A'''=''''['1,'''3,'''7,'''4,'''5]'
''
ordem'correta'

''''
ordenado.'
'''
Passo'9':''Atualiza'chave'(chave'='4)'
'
A'''=''''['1,'''3,'''7,'''4,'''5]'
''
ordem'correta'

''''
ordenado.'
'''
Passo'10':''Verifica'se'o'elemento'a'esquerda'é'maior'que'chave'(verdade)''
'
A'''=''''['1,'''3,'''7,'''4,'''5]'
''
ordem'correta'

''''
ordenado.'
'''
Passo'11':''Desloca'(copia)'elemento'analisado'para'a'direita''
'
A'''=''''['1,'''3,'''7,'''7,'''5]'
''
ordem'correta'

''''
ordenado.'
'''
Passo'12':''Verifica'se'elemento'mais'a'esquerda'é'maior'que'chave''(FALSO)'
'
A'''=''''['1,'''3,'''7,'''7,'''5]'
''
ordem'correta'

''''
ordenado.'
'''
Passo'13:''Insere'(copia)'chave'na'posição'à'direita'do'valor'analisado'
'
A'''=''''['1,'''3,'''4,'''7,'''5]'
''
ordem'correta'

''''
ordenado.'
'''
Passo'14:''Atualiza'a'posição'da'chave'(chave'='5)'
'
A'''=''''['1,'''3,'''4,'''7,'''5]'
''
ordem'correta'

''''
ordenado.'
'''
Passo'15:''Verifica'se'o'elemento'a'esquerda'é'maior'que'chave.'(verdade)'
'
A'''=''''['1,'''3,'''4,'''7,'''5]'
''
ordem'correta'

''''
ordenado.'
'''
Passo'16:''Desloca'(copia)'o'elemento'analisado'para'a'direita'
'
A'''=''''['1,'''3,'''4,'''7,'''7]'
''
ordem'correta'

''''
ordenado.'
'''
Passo'17:''Desloca'(copia)'o'elemento'analisado'para'a'direita'
'
A'''=''''['1,'''3,'''4,'''7,'''7]'
''
ordem'correta'

''''
ordenado.'
'''
Passo'18:''Verifica'se'o'elemento'mais'a'esquerda'é'maior'que'chave'(falso)'
'
A'''=''''['1,'''3,'''4,'''7,'''7]'
''
ordem'correta'

''''
ordenado.'
'''
Passo'19:''Insere'a'chave'à'direita'da'posição'em'análise'e'fim'do'trabalho.'
'
A'''=''''['1,'''3,'''4,'''5,'''7]'
''
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]'
''
ordem'correta'

''''
'''
Passo'2:''Como'estão'fora'de'ordem'permutánlos'
'
A'''=''''['3,'''7,''1,'''4,'''5]'
''
ordem'correta'

''''
'''
Passo'3:''Comparar'os'dois'próximos'
'
A'''=''''['3,'''7,''1,'''4,'''5]'
''
ordem'correta'

''''
'''
Passo'4:''Permutánlos'(Estão'fora'de'ordem)'
'
A'''=''''['3,'''1,''7,'''4,'''5]'
''
ordem'correta'

''''
'''
Passo'5:''Comparar'os'dois'próximos'
'
A'''=''''['3,'''1,''7,'''4,'''5]'
''
ordem'correta'

''''
'''
'
A'''=''''['3,'''1,''4,'''7,'''5]'
''
Passo'6:''Permutánlos'
ordem'correta'

''''
'''
Passo'7':''Comparar'os'dois'próximos'
'
A'''=''''['3,'''1,''4,'''7,'''5]'
''
ordem'correta'

''''
'''
'
A'''=''''['3,'''1,''4,'''5,'''7]'
''
Passo'8':''Permutánlos'
ordem'correta'

''''
'''
Passo'9':''Como'foram'feitas'várias'permutações'nessa'passagem,'reiniciar'comparando'
os'dois'primeiros'elementos.'
'
A'''=''''['3,'''1,''4,'''5,'''7]'
''
ordem'correta'

''''
'''
'
A'''=''''['1,'''3,''4,'''5,'''7]'
''
Passo'10':''Permutar'
ordem'correta'

''''
'''
Passo'11':''Comparar'dois'próximos'
'
A'''=''''['1,'''3,''4,'''5,'''7]'
''
ordem'correta'

''''
'''
'
A'''=''''['1,'''3,''4,'''5,'''7]'
''
ordem'correta'

''''
'''
Passo'14':''Como'foi'feita'uma'permutação,'reiniciar'comparando'os'dois'primeiros'
(Nova'passada)'
'
A'''=''''['1,'''3,''4,'''5,'''7]'
''
ordem'correta'

''''
'''
'
A'''=''''['1,'''3,''4,'''5,'''7]'
''
ordem'correta'

''''
'''
Passo'18':''Como'nenhuma'permutação'foi'feita,'encerrar.'
'
A'''=''''['1,'''3,''4,'''5,'''7]'
''
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]'
''

''''
''''
Passo'2':''Criar'lista'Esquerda''L'e'Direita'R''
'
A'''=''''['7,'''4,'''3,'''1,'''5]'
'
L''''='''[]'''''''R''='''[']'
''

''''
''''
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''='''[']'
''

''''
''''
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]''
''

''''
''''
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'

''''
'''
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'
'

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)'
''

''' '
O'uso'da'classe'racional'seria:'
'
a'='Racional(1,2)'
b'='Racional(3,4)''
c'='a*b'
print'c'
''''''
Programa46.py'
'

''' '
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'
''''''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'
''''''return'"nAluno:'"+self.nome+"nEnd:'"+self.endereco+"nenmail:"+self.e$'
#'fim'da'classe'
''

Listas'Encadeadas'
'''
Criando'algumas'variáveis'de'trabalho:'
'
primeiro'='Aluno()'''#'Pode'isso?'Cadê'os'argumentos?'
atual'='primeiro'
ul>mo'='primeiro'
''
Qual'a'u>lidade'destas'varáveis?'
'''''''

Listas'Encadeadas'(Simples)'
'''
obj1"
Nome,'End,'Tel'
Proximo'='<obj2>'
obj3"
Nome,'End,'Tel'
Proximo'='“'
Primeiro'
obj2"
Nome,'End,'Tel'
Proximo'='<obj3>'
Úl>mo'
Atual'

'''
Inserindo"elementos"na"lista:"
'
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)'
''''''''''''''''if'primeiro.nome'=='"":'
''''''''''''''''''''''''primeiro'='obj'
''''''''''''''''''''''''ul>mo'='primeiro'
''''''''''''''''else:'
''''''''''''''''''''''''ul>mo.proximo'='obj'
''''''''''''''''''''''''ul>mo'='ul>mo.proximo'
'''

'''
Imprimindo"a"lista"inteira:"
'
elif'escolha'=='"2":'
''''''''''''''''atual'='primeiro'
''''''''''''''''while'True:'
''''''''''''''''''''''''print'atual'
''''''''''''''''''''''''if'atual.proximo'=='"":'
''''''''''''''''''''''''''''''''break'
''''''''''''''''''''''''else:'
''''''''''''''''''''''''''''''''atual'='atual.proximo'
''''''''''''''''raw_input("Tecle'enter'para'con>nuar'")'
'''
Programa48.py'
'

Listas'Encadeadas'–'Exercício'
'''
Pesquisa"Linear"na"Lista."
""
Dado"um"nome"(“pedro”"por"exemplo)""encontrar"seu"endereço."
"
Programa49.py"
"
E"se"...."
""
Eu"quiser"ordenar"a"lista?"Qual"o"método"mais"rápido?"(Exercício"Proposto)"
"'

Sempre'em'Frente....'
'''
Ligando"o"fim"de"uma"lista"ao"início"da"outra:"Lista"circular."
Lista"circular"com"tamanho"fixo:"buffer"circular."*"
""""""""""""
obj1"
Proximo'='<obj2>'
A'vc'de'tentar'.....'
""
*"Muito"usados"em"transmissões"mul@mídia"""'
obj3"
Proximo'='<obj2>'
obj2"
Proximo'='<obj3>'

Duplo'encadeamento'
'''
Ligando"o"fim"de"uma"lista"ao"início"da"outra:"Lista"circular."
Lista"circular"com"tamanho"fixo:"buffer"circular."*"
""""""""""""
obj1"
Anterior'='“'“'
Próximo'='<obj2>'
A'vc'de'tentar'.....'
"""'
obj3"
Anterior=<obj2>'
Próximo'='<obj2>'
obj2"
Anterior=<obj1>'
Próximo'='<obj3>'

Aula'9'–'Estruturas'de'Dados'Avançadas'
'''

Aula'9'–'Estruturas'de'Dados'Avançadas'
'''
Probleminhas'com'listas'ligadas:'
'
n Demora'em'encontrar'um'elemento'específico'(Solução'é'ordenar?)'
Problema'com'lista'ordenada:'
'
n Demora'na'inserção'de'novos'elementos'(Encontrar'a'posição,'abrir'espaço'e'inserir'o'
elemento'
Detalhe:'uma'lista'encadeada'não'permite'acesso'direto'a'um'elemento'mesmo'que'
seja'ordenada.'
''
Alguém'ajuda'?.....'
'
Novas'estruturas'de'dados.'
''

'Árvores'
'''
''
Raiz'
Nível'0'
Nível'1'
Nó'Pai'
Nível'2' Folhas'
Nó'Filho'
Caracterís>ca':'Apenas'um'caminho'do'nó'raiz'para'qualquer''outro.'Caso'existam'
mais'caminhos'tratanse'de'um'grafo.''

Exemplo'de'Grafo'
'''
''
Uma'árvore'é'um'>po'especial'de'grafo.'

'Árvores'Binárias'
'''
''
30'
50'
90'
20' 40' 85' 99'
• Quando'os'nós'tem'no'máximo'dois'filhos'tratanse'de'uma'árvore'binária'ou'árvore'
de'pesquisa'binária.'(binary'search''tree).'
• Os'dados'são'associados'aos'nós'e'os'nós'esquerdos'tem'valores'menores'que'os'
pais'e'os'direitos'são'superiores.'
• Dependendo'da'ordem'como'os'nós'são'visitados'eles'listam'os'dados'
naturalmente'ordenados.'
'

'Árvores'Binárias'
'''
''
Para'trabalhar'com'árvore'binárias.'
'
Passo'1:'Representar'os'nós.'
'
class'Noh: '#definição'da'classe'Nó'
'dado,esquerdo,direito'='0,None,None'
'def'__init__(self,'dado):'
' 'self.esquerdo'='None'
' 'self.direito'='None'
' 'self.dado'='dado'
'def'__str__(self):'
' 'return'"{",str(dado),"}"'
'
#'fim'da'classe'Noh'

'Árvores'Binárias''
'''
''
'
Passo'2:'A'árvore'(Esqueleto)'
class'ArvoreBinaria:' ' ' ' '#'Definição'da'classe'árvore'
'def'__init__(self):'
'def'criaNoh(self,'dado): ' '#'cria'um'novo'noh'e'o'retorna'
'def'insere(self,'raiz,'dado): '#'insere'um'novo'dado'
'def'apaga(self,raiz,dado):'
'def'pesquisa(self,'raiz,'valor):'#'Pesquisa'um'valor'na'árvore'
'def'menorValor(self,'raiz):'#'entra'no'ramo'esquerdo'e'procura'o'menor'valor'
'def'profundidadeMaxima(self,'raiz):'
'def'tamanho(self,'raiz):'
'def'imprimirArvore(self,'raiz):'#'imprime'a'árvore'
'def'imprimeNohs(self,raiz):'
' ''

'''
''
'
Passo'3:'Método'de'inicialização'da'classe'
class'ArvoreBinaria:' ' ' ' '#'Definição'da'classe'árvore'
'def'__init__(self):'
' 'self.raiz'='None' ''
'def'criaNoh(self,'dado): ' ' '#'cria'um'novo'noh'e'o'retorna'
' 'return'Noh(dado) ' ' ' ''

'''
''
Passo'4:'Definindo'a'função'de'pesquisa'
''
30'
50'
90'
20' 40' 85' 99'
37' 44'
Valor'a'procurar=37'
37<50'
>30'
<40'
37==37'

'''
''
Passo'4:'Definindo'a'função'de'pesquisa'
''
def'pesquisa(self,'raiz,'valor):'#'Pesquisa'um'valor'na'árvore'
' 'if'raiz'=='None:'
' ' 'return'0'
' 'else:'
' ' 'if'valor'=='raiz.dado:'
' ' ' 'return'1'
' ' 'else:'
' ' ' 'if'valor'<'raiz.dado:'
' ' ' ' 'return'self.pesquisa(raiz.esquerdo,'valor)'
' ' ' 'else:'
' ' ' ' 'return'self.pesquisa(raiz.direito,'valor)'

'''
''
Passo'5:'Inserindo'um'Valor'específico'(cria'nó)'
''
30'
50'
90'
Valor'a'inserir'=37'
37<50'
>30'
20' 40' 85' 99'
<40''n>'Inserir'a'esquerda'

'''
''
Passo'5:'Inserindo'um'Valor'específico'(cria'nó)'
''
30'
50'
90'
Valor'a'inserir'=37'
37<50'
>30'
20' 40' 85' 99'
37'
Inserido'no'lado'esquerdo'

'''
''
Passo'6:'Deslocamento'através'da'árvore'(Para'impressão,'por'exemplo)'
''
Caso1':''Deslocamento'ordenado('n>''Em'Ordem'<n').''O'algoritmo'básico'é:'
n Chamar'a'si'próprio'para'visitar'a'árvore'a'par>r'do'ramo'esquerdo'
n Visitar'o'nó'atual'(e'imprimir,'talvez)'
n Chamar'a'si'própria'para'visitar'a'árvore'a'par>r'do'ramos'direito'
Caso'base:'parar'quando'o'nó'for'nulo'(None)'
'
def'imprimirArvore(self,'raiz):'#'imprime'a'árvore'
' ' 'pass'''#'nao'faz'nada'
' 'else:'
' ' 'self.imprimirArvore(raiz.esquerdo)'
' ' 'print'"{",raiz.dado,"}",'
' ' 'self.imprimirArvore(raiz.direito)'

'''
''
Passo'7:'Imprimindo'a'árvore'na'ordem'inversa'
''
Basta'começar'a'impressão'pelo'lado'direito'
'
def'imprimeArvoreInver>da(self,'raiz):'#'imprime'a'árvore'inver>da'
' ' 'pass'
' 'else:'
' ' 'self.imprimeArvoreInver>da(raiz.direito)'
' ' 'print'"{",raiz.dado,"}",'
' ' 'self.imprimeArvoreInver>da(raiz.esquerdo)'
''

'''
''
Passo'8':''Mostrando'a'topologia'da'rede'.'Imprimindo'os'nós'
''
def'imprimeNohs(self,raiz):'
' 'if'raiz'=='None:'return'
' 'a'='raiz.dado'
' 'if'raiz.esquerdo'!='None:'
' ' 'b'='raiz.esquerdo.dado'
' 'else:'
' ' 'b'='None'
' 'if'raiz.direito'!='None:'
' ' 'c'='raiz.direito.dado'
' 'else:'
' ' 'c'='None'
' 'print'"{",a,"[",b,",",c,"]","}",'
' 'self.imprimeNohs(raiz.esquerdo)'
' 'self.imprimeNohs(raiz.direito) ''
Programa50.py"

'''
''
Passo'9:''Visitando'a'árvore'em'prénordem'x'pósnordem'(Aplicações)'
''
PrénOrdem:'
1.'Visitar'o'nó'
2.'Visitar'recursivamente'os'nós'do'lado'esquerdo'
3.'Visitar'recursivamente'os'nós'do'lado'direito ''
'
PósnOrdem'
1. Visitar'recursivamente'os'nós'do'lado'esquerdo'
2. Visitar'recursivamente'os'nós'do'lado'direito'
3. Visitar'os'nós'
''

'''
''
Imagine'uma'árvore'representando'uma'expressão'algébrica'conforme'abaixo'
'
Expressão'é'A'*'('B+'C)'
'
Visitando'a'árvore''podemos'ter:'
'''''
Emnordem:''
A'*'(B'+'C)'':'interfixada'(parenteses'por'sua'conta)'
Prénordem'
*A+BC':' 'prénfixada'(Nunca'precisa'de'parênteses)'
PósnOrdem'
ABC+*:'pósnfixada'(Facilita'o'uso'de'pilhas''para'armazenar'árvores)'
''
''
A'
*'
+'
B' C'

'''
''
Passo'10:''Encontrando'o'mínimo'e'o'máximo'em'uma'árvore:'
''
30'
50'
90'
20' 40' 85' 99'
37' 44'
Caminho'para'
o'mínimo'
Caminho'para'
o'máximo'

'''
''
Passo'10:''Encontrando'o'mínimo'e'o'máximo'em'uma'árvore:'
'
def'menorValor(self,'raiz):'#'entra'no'ramo'esquerdo'e'procura'o'menor'valor'
' 'while(raiz.esquerdo'!='None):'
' ' 'raiz'='raiz.esquerdo'
' 'return'raiz.dado'
'''''

'''
''
Passo'11:''Deletando'nós'
'
Três'casos'a'considerar:'
'
1. O'nó'a'ser'apagado'é'uma'folha'(Não'tem'filhos)'
2. O'nó'tem'um'filho'
3. O'nó'tem'dois'filhos'
'
Os'dois'primeiros'casos'são'mais'simples,'o'segundo'mais'complexo.'
'''

'''
''
'
Caso'1:'O'nó'é'uma'folha'
30'
50'
90'
20' 40' 85' 99'
37' 44'

'''
''
'
Caso'1:'Removemos'a'conexão''e'o'sistema'se'encarrega'de'apagar'a'memória'
30'
50'
90'
20' 40' 85' 99'
37'
44'
Obs:''Se'a''sua'linguagem'
não'possui'coleta'de'lixo'
será'preciso'destruir'
explicitamente'o'objeto'
'
Programa51.py""
esquerdo"="None"

'''
''
'
Caso'2:'O'nó'tem'um'filho'
'"
30'
50'
90'
20' 40' 85' 99'
44'

'''
''
'
Caso'2:'O'nó'tem'um'filho'
'
Programa52.py"
30'
50'
90'
85' 99'
40'
20'
44'

'''
''
'
Caso'3:'O'nó'tem'dois'filhos'
30'
50'
90'
20' 40' 85' 99'
37' 44'

'''
''
'
SOLUÇÃO"ERRADA"
30'
50'
90'
85' 99'
40'
20'
37' 44'

'''
''
Solução:'Subs>tuir'o'nó'por'seu'sucessor'
30'
50'
90'
20' 40' 85' 99'
37' 44'
Seguir'pela'direita'e'no'primeiro'nó'mudar'
a'esquerda'e'prosseguir'até'o'nó'que'não'
tenha'filhos'a'esquerda.'É'ele.'

'''
''
Solução:'Subs>tuir'o'nó'por'seu'sucessor'
30'
50'
90'
37'
20' 40' 85' 99'
44'

'''
''
Caso'par>cular:'O'sucessor'está'à'direita'(Não'possui'filhos'à'esquerda)'
30'
50'
90'
20' 40' 99'
37' 44'
Desloca'a'subnárvore'
inteira'

'''
''
Função'Sucessor:'
def'sucessor(self,noh):'
' 'paiSucessor'='noh'
' 'sucessor'='noh'
' 'atual'='noh.direito'
' 'while'atual'!='None:'
' ' 'paiSucessor'='sucessor'
' ' 'sucessor'='atual'
' ' 'atual'='atual.esquerdo'
' 'if'sucessor'!='noh.direito:'#'refazendo'as'conexões'
' ' 'paiSucessor.esquerdo'='sucessor.direito'
' ' 'sucessor.direito'='noh.direito'
' 'return'sucessor'
''

'''
''
Finalizando'a'função'apagar'
Programa53.py"
'
else:'
' ' 'suc'='sucessor(atual)'
' ' 'if'atual'=='raiz:'
' ' ' 'raiz'='suc'
' ' 'elif'ehFilhoEsquerdo:'
' ' ' 'nohPai.esquerdo'='suc'
' ' 'else:'
' ' ' 'nohPai.direito'='suc'
' ' 'suc.esquerdo'='atual.esquerdo'#'sucessor'não'tem'filho'a'esquerda'
' 'return'True'
''

'''
''
Representando'como'um'Vetor.''Esquerdo(i)'='2*'i'+'1''Direito(i)'='2'*'1'+'2''Pai(i)'(in1)/2''
Exercício':'Converter'da'forma'hierárquica'para'a'forma'vetorial.'

'''
''
Eficiência':'Operações'normais'na'ordem'O(log'N)'
Dificuldade'de'trabalho'com'valores'não'preenchidos.'
Tratar'valore'duplicados.'Nos'exemplos'são'inseridos'no'lado'direito.'
'''

'Árvores'Binárias'n'Exercícios''
'''
''
1. A'par>r'do'programa'desenvolvido'aqui,'desenvolva'um'caso'especial'de'árvore'
binário'que'recebe'caracteres'e'operadores'aritmé>cos'(+,n,*,etc).'Os'caracteres'
devem'ficar'nas'folhas'e'os'simbolos'nos'nós'intermediários.'
2. Pesquise'na'internet'o'conceito'de'codificação'Huffman'e'implementeno''
'''

Aula'10'–'Árvores'VermelhonPretas'''(Red'Black'Trees)'
'''
''

Aula'10'–'Árvores'VermelhonPretas'(RubronNegras?)'
'''
''
Principal'problema'com'árvores'binárias:'
'
n Quando'os'dados'são'preenchidos'na'forma'já'ordenada'ou'inversamente'ordenada'
ela'se'torna'uma'lista'ligada'simples'(desbalanceada)'com'complexidades'de'O(N).'
'
30'
50'
90'
85'

'''
''
Solução:'balancear'a'árvore'na'inserção.'Cada'nó'deve'possuir'aproximadamente'o'
mesmo'número'de'descendentes'dos'dois''lados.'
'
Como?:'Usar'um'conjunto'de'regras'que'constroem'o'que'ficou'conhecido'como'
árvore''vermelhonpretas'ou'rubronnegras'(como'queira).'
'
Regras:'
'
1. Os'nós'são'coloridos'(Vermelho'ou'Preto)'(Se'vc'não'gostar'pode'usar'amarelon
azul,'verdenrosa,'etc).'
2. A'raiz'é'sempre'preta.'
3. Se'um'nó'é'vermelho,'seu'filho'é'preto(O'contrário'não'é''válido)'
4. Todos'os'caminhos'até'as'folhas'ou'um'filho'nulo'(None)'devem'ter'o'mesmo'
número'de'nós'pretos'(Comprimento'de'pretos)'
'
Só'é'aceita'inserção'de'novos'elementos'na'árvore'se'as'regras'acima'forem'
sa>sfeitas.''
''

'''
''
E'quando'a'regra'é'violada:'
1. Trocar'as'cores'dos'nós.'
2. Fazer'rotações.'
'Raiz'Preta'(ok)'
Vermelhos'sem'filhos'(folhas)'(ok)'
Todos'os'caminhos'até'as'folhas'
possuem'dois'nós'pretos'(ok)'
OBS:'Ao'se'seguir'as'regras,'a'árvore'é'man>da'naturalmente'balanceada.'

'''
''
Inserindo'elementos.'Passo'a'Passo.'
Passo'1':'criarArvore(50)'
Passo'2':'inserirNoh(75)'
Nós'são'inseridos'em'vermelho.'
Não'muda'comprimento'de'
pretos,'diminuindo'a'chance'de'
ter'problemas'em'seqüência.'''

'''
''
Primeiro'Problema:'
Passo'4':'inserirNoh(35):''
35'
'
Posição ''='Filho'Direito'do'25.''
Cor ' ''='Vermelho:'
Resultado:'Viola'regra'3'
Solução'(1)': ''Mudar'a'cor'do'nó'25'"'Mudar'o'comprimento'de'preto'"'Mudar''a'
cor'do'75'tb.'
''

'''
''
'
Posição ''='Filho'Direito'do'25.''
Cor ' ''='Vermelho:'
Resultado:'Viola'regra'3'
Solução'(1)': ''Mudar'a'cor'do'nó'25'"'Mudar'o'comprimento'de'preto'"'Mudar''a'
cor'do'75'tb.'
''
'
Solução(2):'Rotação'
Obs:'A'cor'do'25'deve'mudar'para'Preto.'
'

'''
''
''''
Solução(2):'Rotação'
Obs:'A'cor'do'25'deve'mudar'para'Preto.'
''''''
Finalmente'podemos'inserir'o'35'sem'violar'as'regras.'
''

'''
''
Limitando'o'desbalanceamento:'
'
Imagine'a'árvore'ao'lado.'
'
Inserir'um'elemento'filho'do'35:'
'
Se'for'vermelho'viola'a'regra'3'
Se'for'preto'viola'a'regra'4'
Se'mudar'a'cor'do'35'também'violamos'a'regra'4'
.....'
'
Conclusão:'As'regras'RBT'(RednBlacknTree)'impedem'árvores'com'dois'ou'mais'níveis'
de'desbalanceamento.''
''

'''
''
DESAFIO:'Vc'conseguiria'balancear'a'árvore'abaixo?''

'''
''
Filhos'nulos'(Null'/'Nil'/'None)':''Aqueles'filhos'que'o'nó'deveria'ter,'mas'não'tem.'
Complementar'ao'filho'direito'ou'esquerdo.'
Filhos'Nulos'
A'árvore'acima'fere'a'regra'4.'
Comprimento'de'pretos'é'1'
Comprimento'de'pretos'é'2'

'''
''
Detalhes'sobre'rotações:'
'
• Rotação'à'direita:'o'nó'(topo)'deve'ter'filha'à'esquerda'
• Rotação'à'esquerda:'o'nó'(topo)'deve'ter'filho'à'direita'
Obje>vos:'
'
• Levantar'alguns'nós'e'rebaixar'outros'de'forma'a'balancear'a'árvore'
• Assegurar'que'as'caracterís>cas'de'árvores'binárias'não'foram'violadas'
''
'''

'''
''
'
Considere'a'árvore'abaixo.'
'''''''
Neto'de'fora' Neto'de'dentro'
Qual'seria'o'resultado'de'rotacionar'o'25'(topo'50)''à'direita?''O'Filho'direito'do'
25'passará'a'ser'50,'mas'37'não'pode'ser'filho'esquerdo.'A'solução'é'então'
reconectar'o'37'a'outro'nó'
'

'''
''
'
Considere'a'árvore'abaixo.'
'''''''
37'agora'é'filho'de'50.'
Tornounse'>o'de'sua'posição'anterior'
Nó'crossover!'(Neto'de'dentro)'

'''
''
E'quando'temos'subnárvores'inteiras:'Rotação'à'direita'do'50'(topo)'
'
Observe'o'
deslocamento'da'subn
árvore'

'''
''
Inserindo'nós.'
'
Seja'X'um'nó'específico,'
Seja'P'o'nó'pai'de,'
Seja'G'o'nó'avô'de'X.'
'
Roteiro.'
'
1. Descer'na'árvore'procurando'o'ponto'de'inserção'
2. Se'vc'encontrar'um'nó'preto'seguido'de'dois'nós'vermelhos.'Troque'as'cores'do'
filho'com'o'pai'(Flip).'
3. Se'o'flip'provocar'uma'seqüência'de'vermelhos'(viola'regra'3)'faça'uma'simples'
ou'dupla'rotação'em'P''dependendo'se'o'X'é'neto'interno'ou'externo1'
4. Insira'o'nó.'Após'a'inserção'houver'quebra'de'regras:'rotacione.'
1''Veremos'mais'na'frente'como'fazênlas.'

'''
''
Antes'de'Inserir:'Descer'na'árvore'procurando'o'ponto'de'inserção'e'realizar'Flips'no'
caminho'
'
Antes' Depois'
Esta'mudança'não'afeta'o'comprimento'de'pretos,'mas'pode'induzir''a''uma'
seqüência'de'vermelhos'
Se'esta'operação'for'realizada'com'a'raiz,'esta'preserva'a'cor'preta.'

'''
''
Após'a'inserção'as'regras'podem'estar'violadas.'As'posições'de'inserção'em'relação'
ao'pai'e'avô'são:'
'
G
P
X
G
X
P
G
P
X
G
X
P
Neto'de'Fora'
(Filho'Esquerdo)'
Neto'de'Dentro'
(Filho'Direito)'
Neto'de'Dentro'
(Filho'Esquerdo)'
Neto'de'Fora'
(Filho'Direito)'

'''
''
Três'principais'possibilidades'com'relação'às'cores:'
'
G
P
X
G
X
P
a)'P'é'preto' b)'P'é'vermelho''X'está'fora.'
G
X
P
c)'P'é'vermelho''X'está'dentro.'

'''
''
Caso'1':''P'é'preto.'
'
Caminho'Livre.'Nenhum'conflito'vermelhonvermelho'e'nem'há'
mudança'na'profundidade'de'pretos.'Podemos'inserir'nosso'nó'
(sempre'vermelho)''
'
G
P
X
a)'P'é'preto'

'''
''
Caso'2:''P'é'vermelho'e'X'é'um'neto'de'fora.'Precisamos'de'uma'rotação'simples'e'
algumas'mudanças'de'cores.'
'
Imagine'a'árvore'gerada'na'seqüência'de'inserções:'50n25n75n12n6.'Nosso'nó'de'
inserção'é'o'6'
''
O'que'fazer?'
'''

'''
''
'
Passo'1:'Trocar'a''cor'do'avô.'
'

'''
''
'
Passo'2:'Trocar'a''cor'do'pai.'
'

'''
''
''
Passo'3:'Rotacionar'com'o'avo'no'topo'na'direção'que'levante'o'6''(Direita)''
'
A'árvore'agora'está'RB'Correta'e'melhor'
balanceada'

'''
''
Caso'3'–'P'é'vermelho'e'X'é'neto'de'dentro'
'
Vamos'necessitar'de'duas'rotações''e'algumas'mudanças'de'cores.'
'
Considere'a'árvore'abaixo'como'resultado'da'inserção'da'seqüência:'50n25n75n12n18'
'

'''
''
'
Passo'1:'Trocar'a'cor'do'avô'
'

'''
''
'
Passo'2:'Trocar'a'cor'do'nó'inserido'

'''
''
'
Passo'3:'''Realizar'primeira'rotação'colocando'o'neto'de'dentro'na'posição'de'neto'de'
fora.''(Topo'12')'
'
Agora'estamos'na'situação'idên>ca''ao'caso'2.'

'''
''
'
Passo'4:'''Realizar'a'segunda'rotação'à'direita'usando'18'como'topo'
A'árvore'está'correta'e'melhor'balanceada.'

'''
''
E'as'rotações'antes'da'inserção?'

'''
''
1. Após'intercâmbio'de'cores'(flip)'durante'a'localização'
pode'haver'violação'da'regra'3'(vermelhonvermelho).'
'
2. As'possibilidades'são'idên>cas'às'estudadas.'O'nó'
causador'do'conflito'pode'ser'um'neto'dentro'ou'fora.''

'''
''
Neto'de'Fora.'Ao'inserir'o'úl>mo'nó'(3)'na'árvore'abaixo'é'
necessário'trocar'as'cores'(flips)'que'a'deixariam'inválida.'
'
Vermelhos'em'
seqüência'
Solução:'2'trocas'de'cores'e'uma'rotação'

'''
''
Passo'1':'Trocar'a'cor'do'avô''
(Ignorar'por'enquanto'que'a'raiz'deve'ser'preta')'
'

'''
''
Passo'2':'Trocar'a'cor'do'pai'
(Ignorar'por'enquanto'que'a'raiz'deve'ser'preta')'
'

'''
''
Passo'3':''Rotacionar'de'forma'a'levantar'o'nó'causador'do'
problema''
'
Bem'melhor.'

'''
''
Neto'de'Dentro.'A'árvore'50n25n75n12n37n31n43'ficaria'da'
seguinte'forma'antes'de'inserir'o'28'(por'exemplo)'
Vermelhos'em'
seqüência'
Solução:'2'trocas'de'cores'e'duas'rotações'

'''
''
Passo'1:'Trocar'a'cor'do'avô'(50).''
(ignorar'raiz'preta'por'um'momento)'

'''
''
Passo'2:'Trocar'a'cor'do'próprio'nó'(37).''

'''
''
Passo'3:'Girar'(topo'no'pai'25)'de'forma'a'levantar'o'filho'
(37)'

'''
''
Passo'4:'Girar'(topo'na'raiz'50)'de'forma'a'levantar'o'neto'
(37)'
Árvore'balanceada.'

'''
''
Agora'podemos'inserir'o'28'após'flip'na'raiz'

Considerações"adicionais:"
'
a)'Informação'adicional'na'literatura'
b)'Deleção'é'complexa,'mas'pode'ser'subdividida'
c)'Busca,'seleção,'inserção''em'O(log2N)'
d)'Mais'eficiente'que'as'árvores'AVL.''
'''
''
Ver'Programa54.py'
''
OBS:'As'árvores'AVL'fazem'balanceamento'a'par>r'da'medida'dos'comprimentos'dos'
ramos.'Caso'haja'uma'diferença'superior'a'um'são'feitas'rotações'para'balancear'
novamente'a'árvore.'AVL'='(Adelson,'Velskii''e'Landis.'Criadores)'
'''

Aula'10'–'PAUSA'–'Avançando'no'Python'
Estruturas"de"Dados"BuiltfIn"(Vem"incorporado"ao"Python)'
'
n Listas'(operações'básicas)'
>>>'a'='[66.25,'333,'333,'1,'1234.5]'
>>>'print'a.count(333),'a.count(66.25),'a.count(’x’)'
2'1'0'
>>>'a.insert(2,'n1)'
>>>'a.append(333)'
>>>'a'
[66.25,'333,'n1,'333,'1,'1234.5,'333]'
>>>'a.index(333)'
1'
>>>'a.remove(333)'
>>>'a'
[66.25,'n1,'333,'1,'1234.5,'333]'
>>>'a.reverse()'
>>>'a'
[333,'1234.5,'1,'333,'n1,'66.25]'
>>>'a.sort()'
>>>'a'
[n1,'1,'66.25,'333,'333,'1234.5]'
'
'''

'
• '''Listas'como'Pilhas'
'
>>>'stack'='[3,'4,'5]'
>>>'stack'
[3,'4,'5,'6,'7]'
>>>'stack.pop()'
7'
>>>'stack'
[3,'4,'5,'6]'
>>>'stack.pop()'
6'
>>>'stack.pop()'
5'
>>>'stack'
[3,'4]'
'''

'
• '''Listas'como'Filas'
'
>>>'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’]'
'''

'
Ferramentas"para"Programação"Funcional:"
"
Existem'três'funções'internas'que'são'muito'úteis'sobre'listas:'filter(),'map(),'e'reduce().'
'''
''
>>>'def'f(x):'return'x'%'2'!='0'and'x'%'3'!='0'
...'
>>>'filter(f,'range(2,'25))'
'
[5,'7,'11,'13,'17,'19,'23]'
''''

'
"
'''
''
def'cube(x):'return'x*x*x'
'
>>>'map(cube,'range(1,'11))'
'
[1,'8,'27,'64,'125,'216,'343,'512,'729,'1000]'
'
>>>'seq'='range(8)'
>>>'def'add(x,'y):'return'x+y'
...'
>>>'map(add,'seq,'seq)'
[0,'2,'4,'6,'8,'10,'12,'14]'
''

'
"
'''
''
>>>'def'add(x,y):'return'x+y'
...'
>>>'reduce(add,'range(1,'11))'
55'

'
Geração"Automá@ca"de"Listas"
'
>>>'freshfruit'='[’'banana’,'’'loganberry'’,'’passion'fruit'’]'
>>>'[weapon.strip()'for'weapon'in'freshfruit]'
[’banana’,'’loganberry’,'’passion'fruit’]'
>>>'vec'='[2,'4,'6]'
>>>'[3*x'for'x'in'vec]'
[6,'12,'18]'
>>>'[3*x'for'x'in'vec'if'x'>'3]'
[12,'18]'
>>>'[3*x'for'x'in'vec'if'x'<'2]'
[]'
>>>'[[x,x**2]'for'x'in'vec]'
[[2,'4],'[4,'16],'[6,'36]]'
'''

'
Apagando"Elementos"de"Listas"
'
>>>'a'='[n1,'1,'66.25,'333,'333,'1234.5]'
>>>'del'a[0]'
>>>'a'
[1,'66.25,'333,'333,'1234.5]'
>>>'del'a[2:4]'
>>>'a'
[1,'66.25,'1234.5]'
'''

'
Uma"tupla"consiste"em"uma"sequência"imutável"de"valores"separados"por"vírgulas"
"
>>>'t'='12345,'54321,'’hello!’'
>>>'t[0]'
12345'
>>>'t'
(12345,'54321,'’hello!’)'
>>>'#'Tuplas'podem'ser'aninhadas:'
...'u'='t,'(1,'2,'3,'4,'5)'
>>>'u'
((12345,'54321,'’hello!’),'(1,'2,'3,'4,'5))'
>>>'empty'='()'
>>>'singleton'='’hello’,'#'<nn'observe'a'vírgula'extra'
>>>'len(empty)'
0'
>>>'len(singleton)'
1'
>>>'singleton'
(’hello’,)'
'''

'
Uma"tupla"consiste"em"uma"sequência"imutável"de"valores"separados"por"vírgulas"
'''
""
Empacotamento:"
"
t'='12345,'54321,'’hello!’'
""
Desempacotamento:"
"
>>>'x,'y,'z'='t"
"""

Estruturas"de"Dados"BuiltfIn"(Vem"incorporado"ao"Python):"
"Conjuntos'
>>>'basket'='[’apple’,'’orange’,'’apple’,'’pear’,'’orange’,'’banana’]'
>>>'fruits'='set(basket)'#'create'a'set'without'duplicates'
>>>'fruits'
set([’orange’,'’pear’,'’apple’,'’banana’])'
>>>'’orange’'in'fruits'#'fast'membership'tes>ng'
True'
>>>'’crabgrass’'in'fruits'
False'
>>>'a'='set(’abracadabra’)'
>>>'b'='set(’alacazam’)'
>>>'a'#'unique'le|ers'in'a'
set([’a’,'’r’,'’b’,'’c’,'’d’])'
>>>'a'n'b'#'le|ers'in'a'but'not'in'b'
set([’r’,'’d’,'’b’])'
>>>'a'|'b'#'le|ers'in'either'a'or'b'
set([’a’,'’c’,'’r’,'’d’,'’b’,'’m’,'’z’,'’l’])'
>>>'a'&'b'#'le|ers'in'both'a'and'b'
set([’a’,'’c’])'
>>>'a'^'b'#'le|ers'in'a'or'b'but'not'both'
set([’r’,'’d’,'’b’,'’m’,'’z’,'’l’])"
'''

"Dicionários:"
"
>>>'tel'='{’jack’:'4098,'’sape’:'4139}'
>>>'tel[’guido’]'='4127'
>>>'tel'
{’sape’:'4139,'’guido’:'4127,'’jack’:'4098}'
>>>'tel[’jack’]'
4098'
>>>'del'tel[’sape’]'
>>>'tel[’irv’]'='4127'
>>>'tel'
{’guido’:'4127,'’irv’:'4127,'’jack’:'4098}'
>>>'tel.keys()'
[’guido’,'’irv’,'’jack’]'
>>>'tel.has_key(’guido’)'
True'
>>>'’guido’'in'tel'
True"
'
'''

"Dicionários:"
"
>>>'dict([(’sape’,'4139),'(’guido’,'4127),'(’jack’,'4098)])'
{’sape’:'4139,'’jack’:'4098,'’guido’:'4127}'
>>>'dict([(x,'x**2)'for'x'in'(2,'4,'6)])'#'use'a'list'comprehension'
{2:'4,'4:'16,'6:'36}'
'''

"Dicionários:"
"
>>>'dict([(’sape’,'4139),'(’guido’,'4127),'(’jack’,'4098)])'
{’sape’:'4139,'’jack’:'4098,'’guido’:'4127}'
'
>>>'dict([(x,'x**2)'for'x'in'(2,'4,'6)])'#'use'a'list'comprehension'
{2:'4,'4:'16,'6:'36}'
'''

11.'Módulos'E/S'e'Arquivos'em'Python'
'''

"
Técnicas"de"Laço"Usando"Dicionários"
'
Ao'percorrer'um'dicionário'com'um'laço,'a'chave'e'o'valor'correspondente'podem'ser'
ob>dos'simultaneamente'com'o'método'iteritems().'
'
>>>'knights'='{‘gallahad’:'’the'pure’,'’robin’:'’the'brave’}'
>>>'for'k,'v'in'knights.iteritems():'
...'print'k,'v'
...'
gallahad'the'pure'
robin'the'brave'
'''

"
Enumerate"
"
Ao'percorrer'uma'sequência'qualquer,'o'índice'da'posição'atual'e'o'valor'
correspondente'podem'ser'ob>dos'simultaneamente'usando'a'função'enumerate().'
'
>>>'for'i,'v'in'enumerate([’>c’,'’tac’,'’toe’]):'
...'print'i,'v'
...'
0'>c'
1'tac'
2'toee'
'''

"
ZIP"
"
Para'percorrer'duas'ou'mais'sequências'simultaneamente'com'o'laço,'os'items'podem'
ser'agrupados'com'a'função'zip().'
'
>>>'ques>ons'='[’name’,'’quest’,'’favorite'color’]'
>>>'answers'='[’lancelot’,'’the'holy'grail’,'’blue’]'
>>>'for'q,'a'in'zip(ques>ons,'answers):'
...'print'’What'is'your'%s?'It'is'%s.’'%'(q,'a)'
...'
What'is'your'name?'It'is'lancelot.'
What'is'your'quest?'It'is'the'holy'grail.'
What'is'your'favorite'color?'It'is'blue.'
'''

"
reversed"
"
Para'percorrer'uma'sequência'em'ordem'reversa,'chame'a'função'reversed()'com'a'
sequência'na'ordem'
original.'
>>>'for'i'in'reversed(xrange(1,10,2)):'
...'print'i'
...'
9'
7'
5'
3'
1'
'''
xrange'é'uma'função'semelhante'ao'range,'
mas'que'não'gera'a'lista'e'sim'um'objeto'
gerador'da'mesma'o'que'a'torna'
ligeiramente'mais'eficiente'que'o'range()'

"
sorted"
"
Para'percorrer'uma'sequência'de'maneira'ordenada,'use'a'função'sorted(),'que'
retorna'uma'lista'ordenada'com'os'items,'mantendo'o'original'inalterado.'
'''
''
>>>'basket'='[’apple’,'’orange’,'’apple’,'’pear’,'’orange’,'’banana’]'
>>>'for'f'in'sorted(set(basket)):'
...'print'f'
...'
apple'
banana'
orange'
pear'

"
Módulos"
"
Um'módulo'é'um'arquivo'contendo'definições'e'comandos'Python.''
'
• nome'do'arquivo'recebe'o'sufixo'‘.py’.''
• Dentro'de'um'módulo,'seu'nome'(uma'string)'está'disponível'na'variável'global'
__name__.'
Programa55.py'
"
'''

"
Módulos"Compilados""
"
Um'fator'que'agiliza'a'carga'de'programas'curtos'que'u>lizam'muitos'módulos'padrão'
é'a'existência'de'um'arquivo'com'extensão'‘.pyc’'no'mesmo'diretório'do'fonte'‘.py’.''
'
• arquivo'‘.pyc’'contém'uma'versão'“bytencompilada”'do'fonte'‘.py’.'A'data'de'
modificação'de'‘.py’'é'armazenada'dentro'do'‘.pyc’,'e'verificada'automa>camente'
antes'da'u>lização'do'úl>mo.'Se'não'conferir,'o'arquivo'‘.pyc’'existente'é'ren
compilado'a'par>r'do'‘.py’'mais'atual.'
• Na'presença'das'formas'compiladas'(‘.pyc’'e‘.pyo’)'de'um'script,'não'há'necessidade'
da'presença'da'forma'textual(‘.py’).'Isto'é'ú>l'na'hora'de'se'distribuir'bibliotecas'
Python'dificultando'prá>cas'de'engenharia'reversa.'
•'O'módulo'compileall'pode'criar'arquivos'‘.pyc’'(ou'‘.pyo’'quando'é'usado'fO)"para"
todos"os"módulos"em'um'dado'diretório.'
"
Mais"Informações:"Tutorial"Python"
'''

"
dir"
"
A'função'interna'dir()'é'u>lizada'para'se'descobrir'que'nomes'são'definidos'por'um'
módulo.'Ela'retorna'uma'lista'ordenada'de'strings:'
"
Ex."
"
Import'math'
dir(math)''
'''
""

"
Pacotes"
"
Pacotes'são'uma'maneira'de'estruturar'espaços'de'nomes'para'módulos'u>lizando'a'
sintaxe'de'“separação'por'ponto”.'Como'exemplo,'o'módulo'A.B'designa'um'subn
módulo'chamado'‘B’'num'pacote'denominado'‘A’.''
'
O'uso'de'pacotes'permite'aos'autores'de'grupos'de'módulos'(como'NumPy'ou'PIL)'
não'terem'que'se'preocupar'com'colisão'entre'os'nomes'de'seus'módulos'e'os'nomes'
de'módulos'de'outros'autores.''
'''
""

"
Pacotes"
"
Sound/'Topnlevel'package'
__ 'init__.py'Ini>alize'the'sound'package'
'''
'Formats/'Subpackage'for'file'format'conversions'
' '__init__.py'
' 'wavread.py'
' 'wavwrite.py'
' 'aiffread.py'
' 'aiffwrite.py'
' 'auread.py'
' 'auwrite.py'
...'
'Effects/'Subpackage'for'sound'effects'
' '__init__.py'
' 'echo.py'
' 'surround.py'
' 'reverse.py'
...'
'Filters/'Subpackage'for'filters'
' '__init__.py'
' 'equalizer.py'
' 'vocoder.py'
' 'karaoke.py"

"
Pacotes"
'''
""
O'arquivo'__init__.py'pode'ser'vazio'ou'podem'conter'algo'do'>po:'
"
__all__'='["echo",'"surround",'"reverse"]'
""
Onde'define'as'funções'importadas'ao'usar'o'comando'from'pacote'import'*''
'''''
Mais"informações"no"Tutorial"Python"
'

"
Entradas"e"Saídas"(E/S)""f"Formatação"da"Saída"
"
>>>'s'='’Hello,'world.’'
>>>'str(s)'
’Hello,'world.’'
>>>'repr(s)'
"’Hello,'world.’"'
>>>'str(0.1)'
’0.1’'
>>>'repr(0.1)'
’0.10000000000000001’'
>>>'x'='10'*'3.25'
>>>'y'='200'*'200'
>>>'s'='’The'value'of'x'is'’'+'repr(x)'+'’,'and'y'is'’'+'repr(y)'+'’...’'
>>>'print's'
The'value'of'x'is'32.5,'and'y'is'40000…"
'''
""

"
"
>>>'#'The'repr()'of'a'string'adds'string'quotes'and'backslashes:'
...'hello'='’hello,'worldn’'
'
>>>'hellos'='repr(hello)'
'
>>>'print'hellos'
’hello,'worldn’'
'
>>>'#'The'argument'to'repr()'may'be'any'Python'object:'
...'repr((x,'y,'(’spam’,'’eggs’)))'
"(32.5,'40000,'(’spam’,'’eggs’))""
'''
""
""
"""

"
A'seguir,'duas'maneiras'de'se'escrever'uma'tabela'de'quadrados'e'cubos:'
>>>'for'x'in'range(1,'11):'
...'print'repr(x).rjust(2),'repr(x*x).rjust(3),'''#'Observe'a'vírgula'final'na'linha'anterior'
...'print'repr(x*x*x).rjust(4)'
...'
1'1'1'
2'4'8'
3'9'27'
4'16'64'
5'25'125'
6'36'216'
7'49'343'
8'64'512'
9'81'729'
10'100'1000'
'''

"
"
>>>'for'x'in'range(1,11):'
...'print'’%2d'%3d'%4d’'%'(x,'x*x,'x*x*x)'
...'
1'1'1'
2'4'8'
3'9'27'
4'16'64'
5'25'125'
6'36'216'
7'49'343'
8'64'512'
9'81'729'
10'100'1000"
""
"
'''

"
"
Existe'ainda'o'método'zfill()'que'preenche'uma'string'numérica'com'zeros'à'esquerda.'
Ele'entende'sinais''posi>vos'e'nega>vos.'
'
>>>'’12’.zfill(5)'
’00012’'
>>>'’n3.14’.zfill(7)'
’n003.14’'
>>>'’3.14159265359’.zfill(5)'
’3.14159265359’"
'''

"
"
Um'exemplo'de'uso'do'operador'%:'
'
>>>'import'math'
>>>'print'’The'value'of'PI'is'approximately'%5.3f.’'%'math.pi'
The'value'of'PI'is'approximately'3.142.'
'''
"""

"
"
Se'há'mais'do'que'um'formato,'então'o'argumento'à'direita'deve'ser'uma'tupla'com'
os'valores'de'formatação.'
Exemplo:'
>>>'table'='{’Sjoerd’:'4127,'’Jack’:'4098,'’Dcab’:'7678}'
>>>'for'name,'phone'in'table.items():'
...'print'’%n10s'==>'%10d’'%'(name,'phone)'
...'
Jack'''''''''''''''''==>'''''''''''''''''4098'
Dcab'''''''''''''''==>'''''''''''''''''7678'
Sjoerd'''''''''''''==>''''''''''''''''4127"
"
'''

"
"
Se'você'possuir'uma'string'de'formatação'muito'longa,'seria'bom'referenciar'as'
variáveis'de'formatação'por$nome,$ao'invés'de'por$posição.$Isso$pode$ser$ob<do$
passando$um$dicionário$como$argumento$à$direita$e$prefixando$campos'na'string'de'
formatação'com'%(name)format.''Veja'o'exermplo:'
'
>>>'table'='{’Sjoerd’:'4127,'’Jack’:'4098,'’Dcab’:'8637678}'
>>>'print'’Jack:'%(Jack)d;'Sjoerd:'%(Sjoerd)d;'Dcab:'%(Dcab)d’'%'table'
Jack:'4098;'Sjoerd:'4127;'Dcab:'8637678"
'''

"
A'função'open()'retorna'um'objeto'de'arquivo,'e'é'frequentemente'usada'com'dois'
argumentos:'‘open(filename,$mode)’.$
'
>>>'f=open(’/tmp/workfile’,'’w’)'
>>>'print'f'
<open'file'’/tmp/workfile’,'mode'’w’'at'80a0960>'
'
O'parâmetro'mode$pode$assumir$valor$’r’$quando'o'arquivo'será'só'de'leitura,'’w’'
quando'for'só'de'escrita'(se'o'arquivo'já'exis>r'seu'conteúdo'prévio'será'apagado),'e'
’a’'para'abrir'o'arquivo'para'adição;'qualquer'escrita'será'adicionada'ao'final'do'
arquivo.'A'opção'’r+’'abre'o'arquivo'tanto'para'leitura'como'para'escrita.'O'parâmetro'
mode$é$opcional,$em$caso$de$omissão$será$$assumido'’r’.'
'''

"
A'função'open()'retorna'um'objeto'de'arquivo,'e'é'frequentemente'usada'com'dois'
argumentos:'‘open(filename,$mode)’.$
'
>>>'f=open(’/tmp/workfile’,'’w’)'
>>>'print'f'
<open'file'’/tmp/workfile’,'mode'’w’'at'80a0960>'
'
No'Windows'e'no'Macintosh,'’b’'adicionado'a'string'de'modo'indica'que'o'arquivo'
será'aberto'no'formato'binário.'Sendo'assim,'existem'os'modos'compostos':'’rb’,'’wb’,'
e'’r+b’.'O'Windows'faz'dis>nção'entre'arquivos'texto'e'binários:'os'caracteres'
terminadores'de'linha'em'arquivos'texto'são'levemente'alterados'em'leituras'e'
escritas.'Essa'mudança'porntrásndonpano'é'ú>l'em'arquivos'texto'ASCII,'mas'irá'
corromper'um'arquivo'binário'como'no'caso'de'arquivos'‘JPEG’'ou'‘EXE’.'Seja'muito'
cuidadoso'em'usar'o'modo'binário'ao'manipular'tais'arquivos.'
'''
'"

read"
''
'''
Para'ler'o'conteúdo'de'um'arquivo'chame'f.read(size),$que$lê$um$punhado$de$dados$
retornandoOos$como$string.'O'argumento'numérico'size$é$opcional.$Quando$size$for$
omi<do$ou$nega<vo,$todo$o$conteúdo$do$arquivo$será'lido'e'retornado.'É'problema'
seu'se'o'conteúdo'do'arquivo'é'o'dobro'da'memória'disponível'na'máquina.'Caso'
contrário,'no'máximo'size$bytes$serão$lidos$e$retornados.$Se$o$fim$do$arquivo$for$
a<ngido,$f.read()$irá$
retornar'uma'string'vazia'().'
'
>>>'f.read()'
’Esse'é'todo'o'conteúdo'do'arquivo.n’'
>>>'f.read()'
’’'
"

Readline""
''
'''
f.readline()'lê'uma'única'linha'do'arquivo.'O'caracter'de'retorno'de'linha'(n)'é'
deixado'ao'final'da'string,'só'sendo'omi>do'na'úl>ma'linha'do'arquivo'se'ele'já'não'
es>ver'presente'lá.'Isso'elimina'a'ambiguidade'no'valor'de'retorno.'Se'f.readline()'
retornar'uma'string'vazia,'então'o'arquivo'acabou.''
Linhas'em'branco'são'representadas'por'’n’:'uma'string'contendo'unicamente'o'
terminador'de'linha.'
'
>>>'f.readline()'
’Essa'é'a'primeira'linha'do'arquivo.n’'
'
>>>'f.readline()'
’Segunda'linha'do'arquivon’'
'
>>>'f.readline()'
’’"

Readlines""
''
'''
f.readlines()'retorna'uma'lista'contendo'todas'as'linhas'do'arquivo.'Se'for'fornecido'o'
parâmetro'opcional'sizehint,$será$lida$a$quan<dade$especificada$de$bytes$e$mais$o$
suficiente$para$completar$uma$linha.$$
$
Frequentemente,$esta'operação'é'u>lizada'para'ler'arquivos'muito'grandes'sem'ter'
que'ler'todo'o'arquivo'para'a'memória'de'uma'só'vez.'Apenas'linhas'completas'serão'
retornadas.'
'
>>>'f.readlines()'
[’Essa'é'a'primeira'linha'do'arquivo.n’,'’Segunda'linha'do'arquivon’]'
"

Readlines""
''
'''
fUma'maneira'alterna>va'de'ler'linhas'do'arquivo'é'usando'um'laço'diretamente'com'
o'objeto'arquivo.'É'mais'eficiente,'rápido'e'resulta'em'código'mais'simples:'
'
>>>'for'line'in'f:'
print'line,'
'
Esta'é'a'primeira'linha'do'arquivo.'
Segunda'linha'do'arquivo.'
"

Write()"
'''
'''
f.write(string)$escreve$o$conteúdo$da$string$para$o$arquivo,$retornando$None.$
>>>'f.write(’Isso'é'um'teste.n’)'
'
Ao'escrever'algo'que'não'seja'uma'string,'é'necessário'convertênlo'antes:'
>>>'value'='(’a'resposta’,'42)'
>>>'s'='str(value)'
>>>'f.write(s)"

tell(),"seek(),""
'
f.tell()'retorna'um'inteiro'que'indica'a'posição'corrente'de'leitura'ou'escrita'no'
arquivo,'medida'em'bytes'desde'o'início'do'arquivo.'Para'mudar'a'posição'u>lize'
‘f.seek(offset,$from_what)’.$$
A$nova$posição$é$computada'pela'soma'do'offset$a$um$ponto$de$referência,$que$por$
sua$vez$é$definido$pelo$argumento$from_what.$O'argumento'from_what$pode$assumir$
o$valor$0$para$indicar$o$início$do$arquivo,$1$para$indicar$a$posição$corrente$
e'2'para'indicar'o'fim'do'arquivo.'Este'parâmetro'pode'ser'omi>do,'quando'é'
assumido'o'valor'default'0.'
'
>>>'f'='open(’/tmp/workfile’,'’r+’)'
>>>'f.write(’0123456789abcdef’)'
>>>'f.seek(5)'#'Vai'para'o'sexto'byte'
>>>'f.read(1)'
’5’'
>>>'f.seek(n3,'2)'#'Vai'para'o'terceiro'byte'antes'do'fim'
>>>'f.read(1)'
’d’"
'''

close"
'
Quando'acabar'de'u>lizar'o'arquivo,'chame'f.close()'para'fechánlo'e'liberar'recursos.'
Qualquer'tenta>va'de'acesso'ao'arquivo'depois'dele'ter'sido'fechado'implicará'em'
falha.'
'
>>>'f.close()'
>>>'f.read()'
'
Traceback'(most'recent'call'last):'
File'"<stdin>",'line'1,'in'?'
ValueError:'I/O'opera>on'on'closed'file"
'''

• Módulo(pickle(
(
Strings'podem'ser'facilmente'escritas'e'lidas'de'um'arquivo.'Números'exigem'um'
pouco'mais'de'esforço,'uma'vez'que'o'método'read()'só'trabalha'com'strings.'
Portanto,'pode'ser'u>lizada'a'função'int(),'que'recebe'uma'string'’123’'e'a'converte'
para'o'respec>vo'valor'inteiro.'Entretanto,'quando'estruturas'de'dados'mais'
complexas'''(listas,'dicionários,'instâncias'de'classe,etc)'estão'envolvidas,'o'processo'
se'torna'mais'complicado."
'''

• Módulo(pickle(
Para'que'não'seja'necessário'que'usuários'estejam'constantemente'escrevendo'e'
depurando'código'que'torna'estruturas'de'dados'persistentes,'Python'oferece'o'
módulo'padrão'pickle.''
Este'módulo'permite'que'pra>camente'qualquer'objeto'Python'(até'mesmo'código!)'
seja'conver>do'para'uma'representação'string.'Este'processo'é'denominado'pickling.$$
$
E$unpickling$é$o$processo$reverso$de$reconstruir$o$objeto$a$par<r$de$sua$representação$
string.'Enquanto'es>ver'representado'como'uma'string,'o'objeto'pode'ser'
armazenado'em'arquivo,'transferido'pela'rede,'etc.'
Se'você'possui'um'objeto'qualquer'x,'e'um'objeto'arquivo'f'que'foi'aberto'para'
escrita,'a'maneira'mais'simples'de'u>lizar'este'módulo'é:'
pickle.dump(x,'f)'
Para'desfazer,'se'f'for'agora'um'objeto'de'arquivo'pronto'para'leitura:'
x'='pickle.load(f)'
"
Programa56.py""programa57.py"
'''

Exercícios'Propostos'
'''
1. Use'uma'lista'ligada'ou'uma'árvore'binária'para'gravar'um'banco'de'dados'
qualquer'em'seu'computador.'Os'dados'devem'ser'gravados'e'recuperados'em'
arquivos.'
2. Leia'sobre'Bancos'de'Dados'relacionais'na'Internet'e'use'dicionários'para'guardar'
tabelas'relacionais.'Aprenda'como'inserir'dados'nesta'tabela'e'como'realizar'
pesquisasa.'Lembrando'que'estes'dados'devem'ser'gravados'permanentemente'
em'arquivos.'
3. Estude'uma'forma'de'“esconder”'mensagens'em'uma'imagem'(jpeg,'gif,'etc,'ou'
outro'>po'de'arquivo'e'implemente'em'Python.'
''''

AULA'12'–'Exceções'
'''
Erros' durante' a' execução' do' programa'
que' normalmente' interrompem' a' sua'
sequência'natural.'
'

'''
'
Divisão'por'Zero'
''
>>>'10'*'(1/0)'
ZeroDivisionError:'integer'division'or'modulo'by'zero'
''

'
Variável'Inexistente'
''
>>>'4'+'spam*3'
NameError:'name'’spam’'is'not'defined'

'''
'
Impossível'Concatenar'Tipos'Diferentes'
'
>>>'’2’'+'2'
TypeError:'cannot'concatenate'’str’'and'’int’'objects'
'
As'exceções'podem'ser'tratadas'evitando'que'o'
programa'seja'interrompido'de'forma'que'se'tente'
contornar'a'situação'de'erro.'
'

'''
'
'
As'exceções'podem'ser'tratadas'evitando'
que'o'programa'seja'interrompido'de'
forma'que'se'tente'contornar'a'situação'
de'erro.'
'

'
Construção'''try'…'except.'
'
>>>'while'True:'
'''
'...'try:'
' '...'x'='int(raw_input("Entre'com'um'número:'"))'
' '...'break'
'...'except'ValueError:'
' '...'print'"Opa!'Esse'número'não'é'válido.'Tente'de'novo...”'
''

'
'
>>>'while'True:'
'''
'...'try:'
' '...'break'
''
Primeiro'a'cláusula'“Try”'
é'executada!'

'
'
>>>'while'True:'
'''
'...'try:'
' '...'break'
''
Se'não'ocorrer'exceção'a'
cláusula'except'é'ignorada.'

'
'
>>>'while'True:'
'''
'...'try:'
' ''
''
' '...'break'
'…except'ValueError:'
''
Se'ocorrer'exceção'em'um'comando'da'
cláusula'Try,''os'comandos'
remanescentes'são'ignorados.'

>>>'while'True:'
'''
'...'try:'
' '...'Break'
'''''
''
Se'o'>po'da'exceção'ocorrida'>ver'sido'
previsto'junto'a'alguma'palavranreservada'
except,'então'essa'cláusula'será'
executada.'O''fim'da'cláusula'também'
termina'a'execução'do'try.'

>>>''
Try: ''
'''
'while'True:'
'...'try:'
' '...'Break'
except''Excep>on:'
' Se'a'exceção'ocorrida'não'foi'prevista'em'
nenhum'tratador'except'da'construção'try'
em'que'ocorreu,''então'ela'é'entregue'a'
uma'construção'try'mais'externa.''

>>>''
Try: ''
'''
'while'True:'
'...'try:'
' '...'Break'
except''Excep>on'
'
Se'não'exis>r'nenhum'tratador'previsto'
para'tal'exceção'(chamada'unhandled$
excep<on),$a$execução$encerra$com$
uma$mensagem$de$erro.'

Try'pode'ter'múl>plos'excepts.'
'
import'sys'
try:'
'''
'f'='open(’myfile.txt’)'
's'='f.readline()'
'i'='int(s.strip())'
Argumentos'passados'ao'tratamento'da'
except'IOError,'(errno,'strerror):'
exceção.'
'print'"I/O'error(%s):'%s"'%'(errno,'strerror)'
except'ValueError:'
'print'"Could'not'convert'data'to'an'integer."'
except:'
'print'"Unexpected'error:",'sys.exc_info()[0]'
'raise'
“renlevanta”'a'exceção'
desconhecida'

Cláusula'else$(opcional)'é'ú>l'para'um'código'que'precisa'ser'
executado'se'nenhuma'exceção'foi'levantada.'
'
for'arg'in'sys.argv[1:]:'
'try:'
' 'f'='open(arg,'’r’)'
'except'IOError:'
' 'print'’cannot'open’,'arg'
'else:'
' 'print'arg,'’has’,'len(f.readlines()),'’lines’'
' 'f.close()'
'''
Argumentos'passados'
pelo'S.O.'

>>>'try:'
...' ' 'raise'Excep>on(’spam’,'’eggs’)'
...''''except'Excep>on,'inst:'
...' ' ''
'''
' ''
A'cláusula'except'pode'especificar'
uma'variável'depois'do'nome'(ou'
da'tupla'de'nomes)'exceção'
'
print'type(inst)'#'Instância'da'exceção'
...''''''''''''''print'inst.args'#'Argumentos'armazenados'em'.args'
''
...' ' 'print'inst'#'__str__'permite'a'impressão'direta'dos'argumentos'
...'''' ' 'x,'y'='inst'#'__ge>tem__'permite'o'desempacotamento'dos'argumentos'
...'''' ' 'print'’x'=’,'x'
...'''' ' 'print'’y'=’,'y'
<type'’instance’>'
A'variável'será'uma'instância'com'
(’spam’,'’eggs’)'
argumentos'acessíveis'através'do'
(’spam’,'’eggs’)'
__str__'e'__ge>tem__'
x'='spam'
y'='eggs'
Função'type'retorna'o'>po'da'variável'
Acesso'aos'dados'via'args'

>>>'def'this_fails():'
'''
'...'x'='1/0'
'...'
'''
>>>'try:'
'...'this_fails()'
'except'ZeroDivisionError,'detail:'
'...'print'’Handling'runn>me'error:’,'detail'
'...'
'''
Tratadores'de'exceção'são'capazes'
de'capturar'exceções'que'tenham'
sido'levantadas'no'interior'de''
funções'invocadas'na'cláusula'try.''

'''
'
Levantando'Exceções'
''''
>>>'raise'NameError,'’HiThere’'
NameError:'HiThere'
A'palavranreservada'raise'permite'
ao'programador'forçar'a'
ocorrência'de'um'determinado'
>po'de'exceção.''

'''
Levantando'Exceções'
'
>>>'try:'
...' ' 'raise'NameError,'’HiThere’'
...' 'except'NameError:'
...' ' 'print'’An'excep>on'flew'by!’'
...' ' 'raise'
...'
An'excep>on'flew'by!'
NameError:'HiThere'
Caso'você'precise'determinar'se'
uma'exceção'foi'levantada'ou'
não,'mas'não'quer'manipular'o'
erro,'uma'forma'simples'de'
raise'permite'que'você'levantena'
novamente.'

'''
Exceções"Definidas"pelo"Usuário"
''
Programas'podem'definir'novos'
>pos'de'exceções,'através'da'
criação'de'uma'nova'classe.'
Devem'ser'subclasses'da'classe'
Excep>on,'direta'ou'
indiretamente:'
>>>'class'MyError(Excep>on):'
...' ' 'def'__init__(self,'value):'
...' ' ' 'self.value'='value'
...' ' 'def'__str__(self):'
...' ' ' 'return'repr(self.value)'
>>>'try:'
...' ' 'raise'MyError(2*2)'
…'''''except'MyError,'e:'
... '''''''''print'’My'excep>on'occurred,'value:’,'e.value'
My'excep>on'occurred,'value:'4'
>>>'raise'MyError,'’oops!’'
__main__.MyError:'’oops!’'
'

'
>>>'try:'
...' ' ' 'raise'KeyboardInterrupt'
...' ''''''finally:'
...' ' ' 'print'’Goodbye’'
...'
Goodbye,'world!'
File'"<stdin>",'line'2,'?'
KeyboardInterrupt'
'''
'' Programa59.py'
A'construção'try'possui'outra'
cláusula'opcional,'cuja'finalidade'
é'permi>r'a'implementação'de'
ações'de'limpeza,'
que'sempre'devem'ser'
executadas'independentemente'
da'ocorrência'de'exceções'

AULA'12'–'Exceções'Disparadas'
• Asser>onError'
'''
Disparada'na'falha'do'comand'assert.'(u>lizado'para'inserção'de'informações'de'
debug)'
'
• A|ributeError'
Disparada'quando'uma'referência'a'um'atributo'ou'atribuição'falha.'
'
• EOFError'
Disparada'quando'uma'função'de'entrada'(input()'ou'raw_input()')'encontra'o'fim'
do'arquivo'sem'ter'lido'qualquer'dado.'
'

• Floa>ngPointError'
Disparada'na'falha'de'operações'de'ponto'flutuante.'
• GeneratorExit'
Disparada'quando'o'método'close'de'um'generator'é'chamado'
(Tecnicamente'não'é'um'erro)'
'
• IOError'
'
Disparada'devido'a'falha'de'operação'de'E/S'(arquivo'n'não'
encontrado,'disco'cheio,'etc)'
'
'''

'
• ImportError'
'
Disparada'quando'um'comando'import'falha'em'encontrar'a'
definição'do'módulo'ou'o'nome'que'está'sendo'importado.'
'
• IndexError'
'
Disparada'quando'um'índice'está'fora'dos'limites.'
'
• KeyError'
Disparada'quando'uma'chave'de'dicionário'não'é'encontrada.'
''
'

'''
''''
• KeyboardInterrupt'
'
Disparada'quando'o'usuário'interrompe'a'execução'(ControlnC''
ou'Delete)'
'
• MemoryError'
'
Disparada'quando'uma'operação'a>nge'seu'limite'de'memória'
'
• NameError'
Disparada'quando'um'nome'global'ou'local'não'é'encontrado.''

• NotImplementedError'
'
Disparada'por'métodos'abstratos'que'requisitam'que'as'classes'
derivadas'sejam'implementadas.'
'
• OSError'
'
Disparada'quando'uma'função'recebe'erros'do'sistema.'
'
• OverflowError'
'
Disparada'quando'o'resultado'de'uma'operação'aritmé>ca'é'
muito'grande'para'ser'representado.'
'''

• ReferenceError'
'
Disparada'quando'um'proxy'tenta'acessar'um'atributo'já'
apagado'da'memória.'(Ver'módulo'weakref)'
'
• Run>meError'
'
Disparada'quando'um'erro'ocorrido'não'se'classifica'em'
nenhuma'categoria.'
'
• StopItera>on'
Disparada'por'um'método'next()'de'um'iterador'para'sinalizar'
que'não'há'mais'valores'adicionais.'
'
'''

• SyntaxError'
'
Disparada'quando'o'parser'(analisador'do'fonte)'encontra'um'
erro'de'sintaxe.'
'
• SystemError'
'
Disparada'quando'o'interpretador'encontra'um'erro'interno.'
'
• SystemExit'
Disparada'automa>camente'pela'função'sys.exit()'
'''
'''

• TypeError'
'
Disparada'quando'uma'operação'ou'uma'função'é'aplicadaa'um'
objeto'de'um'>po'errado.'(mul>plicar'strings'por'exemplo)'
'
• UnboundLocalError'
'
Referencia'feita'a'uma'variável'local'sem'valor'associado'
'
• UnicodeError'
Disparada'quando'um'erro'de'codificação'ou'decodificação'
Unicode'ocorre.'Suas'descendentes'são:'UnicodeEncodeError,'
UnicodeDecodeError,'UnicodeTranslateError'
'''

'''
''
ValueError'
'
Disparada'quando'uma'operação'ou'função'recebe'um'
argumento'que'tem'o'>po'certo,'mas'um'valor'incorreto.'
'
VMSError'
'
Disparada'quando'um'erro'específico'o'VMS'ocorre.'
'
WindowsError'
'
Disparada'na'presença'de'erros'específicos'do'Windows'
'

• ZeroDivisionError'
'
Disparada'quando'o'denominador'de'uma'divisão'ou'de'um'
módulo'(resto'de'divisão)''é'zero'
'
• Warning'
'
Serve'de'classe'base'para'todos'os'Warnings'(Advertências)'
'
• UserWarning'
'
Classe'base'para'warnings'gerados'pelo'código'do'usuário'
'
'''
''

• Depreca>onWarning'
'
Classe'base'para'advertências'(warnings)'sobre'funcionalidades'
obsoletas'da'linguagem.'
'
• PendingDepreca>onWarning'
'
Classe'base'para'advertências'acerca'de'funcionalidades'que'
serão'descon>nuadas'no'futuro'(obsoletas)'
'
• SyntaxWarning'
Classe'base'para'advertências'acerca'da'sintaxe'dúbia'
'
'''
''

• Run>meWarning'
Classe'base'para'advertências'acerca'do'comportamento'dúbio'
em'tempo'de'execução'
'
• FutureWarning'
Classe'base'para'advertências'acerca'de'construções'que'
mudarão'de'significado'no'futuro.'
'
• ImportWarning'
Classe'base'para'advertências'acerca'de'erros'em'importação'de'
módulos'
'
• UnicodeWarning'
Classe'base'para'advertências'relacionadas'ao'Unicode.'
''

AULA'12'–'Pausa'
Geradores:"Funções"com"memória."
'
Uma'função'normal:'
'
def'f():'
'<'Instruções'>'
'return''<Valor>''''#'Valor'é'retornado'uma'só'vez.'
' ' ' ' ''''''
x''='f()''#'valor'é'retornado'para'x'e'apagado'
''

AULA'12'–'Pausa'
Geradores:"Funções"com"memória."
'
Um'gerador:'
'
def'f():'
'<'Instruções'>'
'yield'<Valor>''''#'Valor'é'retornado'e'dados'são'preservados'
' ' ' ' ''''''
x''='f()''#'a'variável'x'é'associada'a'função'
'
y'='x.next()'#'os'dados'gerados'são'retornados'a'medida'que'a'
função'next()'é'chamada'explicitamente'ou'implicitamente.'
''

AULA'12'–'Pausa'
Um"gerador:"
'
def'f(i=0,limite=0):'
'while'i'<='limite:'
' 'i'+='1'
' 'yield'i''''#'Valor'é'retornado'no'meio'de'um'laço'
' ' ' ''#'Isto'significa'que'a'próxima'chamada'a'next()'
' ' ' ''#'con>nuará'o'laço'
' ' ' ' ''''''
x''='f(0,10)''#'a'variável'x'é'associada'a'função'
y'='x.next()'''
k'='f(1,10)'
for'z'in'k:'print'z'
'
Um'gerador'retorna'um'iterador.'

AULA'12'–'Curiosidade'
Cálculo"do"Pi"""
h|p://pt.wikipedia.org/wiki/Pi#M.C3.A9todos_de_c.C3.A1lculo'
'
• Método'Clássico'
• Método'Estaõs>co'
• Métodos'das'Séries'Infinitas'
• Métodos'numéricos'(aproximações'sucessivas)"
'

Método'Clássico'
'
π='comprimento'da'circunferência'('perímetro'do'polígono)'/'diâmetro''
para'n'(num'de'lados)'%'infinito.'Daí'temos:'
''

Método'Estaõs>co'
'Dado'o'conjunto'de'pontos'aleatoriamente'
Colocado'no'quarto'de'circulo.'
''''
π'

'
'''
Explicação:'Imagine'que'cada'ponto'seja''
um'dardo'lançado'contra'o'quarto'de'circulo'
a'probabilidade'de'cair'dentro'é'proporcional'
as'razões'das'áreas'que'por'sua'vez'dependem'do'
π'
''

Método'Série'Infinita'de'Leibnitz'
'
Programa62.py''''Programa63.py'

Transformação(de(van(Wijngaarden(
Programa64.py'

ValordePi
'
3.141592653589793238462643383279502884197169399375105820974944592307816
40628620899862803482534211706798214808651328230664709384460955058223172
53594081284811174502841027019385211055596446229489549303819644288109756
65933446128475648233786783165271201909145648566923460348610454326648213
39360726024914127372458700660631558817488152092096282925409171536436789
2590360011330530548820466521384146951941511609...'
''''

Aula'13'–'Árvores'2n3n4'
'''

ÁrvoreBinária:''
'''
''

'
Um'nó'contém'uma'informação'básica''
(1'item'de'dado)'e'pode'ter'até'dois'filhos.'
'

ÁrvoreMul@vias(mulway'tree):'''
'''
''

''
Admite''mais'de'um'po'de'dado'e'mais'de'
dois'caminhos'(filhos).'
'

Árvore2f3f4(Mulvias'de'Ordem'4)'
'
'''
''
50' 70' 95'
Cada'nó'possui'de'1'
a'três'itens'de'
dados.'
'
Um'nó'com'três'itens'
de'dados'possui'4'
filhos'
'
30' 35' 55' 78' 100' 105'
As'folhas'sempre'estão'no'mesmo'nível'final'e'podem'conter'
até'3'itens'de'dados.'
'

'
'''
50'
Um'nó'com'um'item'de'
dado'possui'dois'filhos'
30' 50'
50' 70'
Um'nó'com'dois'itens'
de'dados'possui'
três'filhos'
30' 35' 55' 78'
'

'
'''
Não'admite'nós'vazios'
50'
Não'admite'nós'com'
um'só'filho'
40'

13.'Árvores'2n3n4'
'''
''
Exemplo'de'árvore'2n3n4.'Fonte:'Lafore,'Robert'–'Data'Structures'and'Algorithms'in'Java'

13.'Árvores'2n3n4'
'''
''
Organização'da'árvore:'

13.'Árvores'2n3n4'
'''
''
Pesquisandoemumaárvore2f3f4:
'
Similar''à'pesquisa'binária.'Inicia'com'a'raiz.''Selecionar''o'link'que'leva'a'solução'
rependo'a'operação'recursivamente'até'encontrar'o'valor.'
' 64'
50'
60''64''70'

13.'Árvores'2n3n4'
'''
''
Inserindoemumaárvore2f3f4:
.'
Novos'dados'são'inseridos'sempre'nas'
folhas'que'se'localizam'no'úlmo'ramo'da'
árvore.'

13.'Árvores'2n3n4'
'''
''
'
Se'o'dado'fosse'inserido'em'um'nó'com'filhos,'isto'implicaria''na'mudança'do'número'
de'filhos'do'mesmo'para'manter'a'regra'de'que'o'número'de'filhos'é'igual'ao'número'
de'dados'+'1'

13.'Árvores'2n3n4'
'''
''
'
No'caso'mais'simples'o'dado'é'inserido'em'nós'não'completamente'preenchido'

13.'Árvores'2n3n4'
'''
''
Inserindoemespaçosvazios
Caso'haja'um'nó'completo'anterior'ao'ponto'de'inserção'este'deverá'ser'dividido.'É'
exatamente'o'processo'de'divisão'que'mantém'a'árvore'balanceada.'Nós'são'divididos'
no'caminho'de'busca'do'ponto'de'inserção.'
'
''
'

13.'Árvores'2n3n4'
'''
''
Divisãodeumnónãofraiz

Considerando'os'dados'A,B,C'de'um'nó'não'raiz'a'ser'
dividido.'
A' B' C'

13.'Árvores'2n3n4'
'''
''

a) Crianse'um'nó'irmão'do'que'está'sendo'dividido'e'
colocado'à'sua'direita'
A' B' C'

13.'Árvores'2n3n4'
'''
''

b)'O'C'é'movido'para'o'este'nó'
A' B'
C'

13.'Árvores'2n3n4'
'''
''

c)'O'B'é''movido'para'o'pai'do'nó'sendo'dividido'
A'
C'
B'

13.'Árvores'2n3n4'
'''
''

d)'O'A'permanece'onde'estava.'
A'
C'
B'

13.'Árvores'2n3n4'
'''
''
e)'Os'dois'filhos'à'direita'são'desconectados'do'nó'a'ser'
dividido'e'conectados'no'nó'novo.'
A'
C'
B'

13.'Árvores'2n3n4'
'''
''

13.'Árvores'2n3n4'
'''
''

Esse'processo'deve'ser'repedo'para'cada'nó'totalmente'preenchido'onde'seja'
necessário'inserir'dados'

13.'Árvores'2n3n4'
'''
''
Divisãodaraiz

• Crianse'um'novo'nó'raiz'que'será'o'pai'da'anga'raiz'que'será'
dividida'
• Crianse'outro'nó'que'será'irmão'do'nó'a'ser'dividido'
• O'C'é'movido'para'o'irmão'recémncriado'
• O''B'é'movido'para'a'nova'raiz'
• O'A'permanece'
• Os'dois'nós'mais'à'direita'são'desconectados'do'nó'em'
processo'de'divisão'e'reconectados'ao'nó'direito'recémncriado.'

13.'Árvores'2n3n4'
'''
''
Divisãodaraiz

13.'Árvores'2n3n4'
'''
''
QuadroGeral

a) Inserção'normal''b)'Nova'inserção'com'divisão'da'raiz''c)'Inserção'normal'
d)'''Inserção'com'divisão'de'folha''e)'Inserção'com'divisão'de'folha'

13.'Árvores'2n3n4'
'''
''
QuadroGeral

f) Inserção'com'divisão'de'folha'' ' ' 'g)'Resultado'da'inserção'
'
Programa65.py'

13.'Árvores'2n3n4'
'''
''
Relaçãocomárvores
VermelhofPretas

13.'Árvores'2n3n4'
'''
''
Eficiência.

Tempodebusca:

Aproximadamenteequivalenteasarvoresvermelhofpretas(O(Log(N))

Aplicaçõesemarmazenamentoexterno

13.'Árvores'2n3n4'
'''
''
Exercícios:

1. Pesquisenaliteraturaoutrasárvoressemelhantes(BfTreesporexemplo)esuas
relações
2. Verifiqueasaplicaçõesemarmazenamentoexterno.Comoestasárvorespodem
serusadasparaacessoegravaçãodedadosemdiscos
3. Façaumprogramaparaselecionaromenoroumaiorelementodeumaárvore
234
4. Modifiqueoprogramadadoparaimprimiraárvorenaforma(emfordem)
ordenada

Aula'14'–'Tabelas'Hash'
'''
''

14.'Tabelas'Hash'
'''
''
Uma'estrutura'de'dados'cujo'tempo'de'busca'/'
inserção'é'da'ordem'O(1).'
'
(Não'importa'do'tamanho)'
'

14.'Tabelas'Hash'
'''
''
'Muito'bom'para'ser'verdade?'

14.'Tabelas'Hash'
'''
''
São'fáceis'de'programar'...'

14.'Tabelas'Hash'
'''
''
...','mas'tem'desvantagens:'
'
• 'são'baseadas'em'matrizes'(arrays)'diùceis'de'serem'
expandidas'dinamicamente'na'maioria'das'linguagens'
• 'o'programador'precisa'ter'uma'boa'idéia'do'tamanho'
do'conjunto'de'dados'a'armazenar'ou'estar'preparado'
para'redimensionánla'quando'necessário'
• não'há'uma'boa'maneira'de'visitar'os'valores'em'
forma'ordenada'

14.'Tabelas'Hash'
'''
''
porém'....'
''
Se'você'conhece'o'tamanho'dos'dados'e'não'se'
interessa'em'visitánlos'de'forma'ordenada,'tabelas'hash'
são'incomparavelmente'melhor'que'outros'métodos.'

14.'Tabelas'Hash'
'''
''
• Que'é'hashing?!!'
'
Transformação'de'valores'numéricos'ou'
alfanuméricos'(chaves)'em'índices.'Estes'índices'são'
usados'para'armazenar'ou'recuperar'informações.''
A'função'que'faz'isso'é'chamada'função'hash.''

14.'Tabelas'Hash'
'''
''
Aplicação'1':'Dicionário'de'Inglês.'
Palavras:'
'
a'
...'
zyzzvya'
''
Aproximadamente':'50000'
''''
Palavra[1]'='‘a’'
''
Palavra[n]'='‘zyzzvya’'

14.'Tabelas'Hash'
'''
''
Convertendo'palavras'em'números.'
Usando'o'código'ASCII'''(255'Caracteres)'
'
CATS'=''67'65''84''83'''Somando''67'+'65'+'64'+'83'='279''
'
Tabela''Própria'
'
A'='1,'B'='2','C'='3,'D'='4','E'='5,'F'='6,'G'='7','H'='8,'I'='9,'J'='10,'K'='11,'L'='12,'M''='13,'
N'='14,'O'='15,''P'='16,''Q'='17,'R'='18,''S'='19,'T'='20,'U'='21,'V'='22,'W'='23,'X'='24,''Y'
='25,''Z'='26'
'
CATS''=''3'1'20''19'''Somando'3'+'1'+'20'+''19'=''43'
Palavras[43']''='“CATS”'
'

14.'Tabelas'Hash'
'''
''
Então'calculamos'os'índices:'
a'
.....'
.....'
.....'
zzzzzzzzzzzzzz'
'
Palavra[1]'
''
Palavra[50000]'
'
Redundâncias'no'cálculo'do'Hash:'
'
was'' '=' '23'+'1'+'19'='43''''
n'''' '=' '20'+'9'+'14'='43'''''''
give'' '=' '7'+''9'+'22'+'5'='43''''''''
tend' '= '20'+'5'+'14'+'4'='43'''''
moan' '= '13'+15+1+14'='43''''''''
ck' ' '='''' '20+9+3+11'='43''''''''
'

14.'Tabelas'Hash'
'''
''
Colocandopesosnasposições:
'
Notação'posicional'
'
3456''=''3'*'1000'+'4'*'100'+'5'*'10'+'6'*'1'
'
3456''=''3''*'103'+'4'*'102'+'5'*'101'+'6'*'100'
'
Usando'a'mesma'estratégia:'
'
was'' '=' '23'*272'+'1'*271+'19*270'='16813'
n'''' '=' '20'*272''+'9*271'+'14*270'='14827'
give'' '=' '7'*273+''9*272'+'22*271'+'5*270''='144941'
tend' '= '20'*273+'5*272'+'14*271'+'4*270''='397687'
moan' '= '13'*273+15*272+1*271+14*270''='404636'
ck' ' '='''' '20*273+9*272+3*271+11*270''='400313'
''

14.'Tabelas'Hash'
'''
''
Colocandopesosnasposições:
'
Problema:'Os'valores'começam'a'ficar'muito'grandes.'
'
“zzzzzzzzzz”'por'exemplo'seria':'
''
26*279+'26*278+'26*277+'26*276+'26*275+'26*274+'26*273+'26*272+'26*271+'26*270'
'
A'matriz'para'guardar'esse'dicionário'deveria'ter'mais'do'que'279''(''7000000000000)'
posições'(índices)'
'
Muitas'destas'posições'seriam'reservadas'para'strings'que'não'formam'palavras.'Ex.'
aaaa,'bbbbbb,'ccccccc,'abababa,'etc'
'''

14.'Tabelas'Hash'
Confinandovalores'
''
'''
''
0'
1'
2'
3'
4'
5'
6'
7'
0'
1'
2'
3'
4'
199'
200'
201'
• 'Usar'o'módulo'(resto'da'divisão)'
• 'Qualquer'Número'%'5'terá'como'
resultado'um'valor'de'0'a'4'

14.'Tabelas'Hash'
Problema:Nãohámaisgaran@asquedoiselementosdis@ntosusemo
mesmoíndice.(Colisão)

Duassoluções
n Endereçamentoaberto(openaddressing)
n Encadeamentoseparado(separatechaining)'
''
Blablabla'
desmysfy'
...'
melioraon'

14.'Tabelas'Hash'
EndereçamentoAberto
Quando'um'item'não'pode'ser'colocado'na'posição'calculada,'outro'
posição'é'localizada'para'o'mesmo.'
''
Blablabla'
desmysfy'
...'
Posição'original'
melioraon'
'
Posição'Livre'
'

14.'Tabelas'Hash'
EndereçamentoAberto
'
• Busca'linear''(Linear'Probing)'
• Busca'quadrátrica''(Quadrac'Probing)'
• Duplo'Hashing'(double'hashing)'
''

14.'Tabelas'Hash'
BuscaLinear:(Inserção)
Blablabla'
desmysfy'
...'
Posição'original'
melioraon'
'
Posição'Livre'
'
Procura'
seqüencialmente'
uma'posição'vazia'
'

14.'Tabelas'Hash'
BuscaLinear:(Busca)

Blablabla'
desmysfy'
blablabla'
blublublu'''
Melioraon'
Tritritr'
Procura'“melioraon”'na'
posição'do'hash.'
'
Procura'seqüencialmente'
nas'próximas'posições'
'
Busca'Bem'
Sucedida'

14.'Tabelas'Hash'
BuscaLinear:(Busca)

Blablabla'
desmysfy'
blablabla'
blublublu'''
Tritritr'
posição'do'hash.'
'
'
Busca'mal'
sucedida.'

14.'Tabelas'Hash'
BuscaLinear:(Deleção)

Blablabla'
desmysfy'
blablabla'
blublublu'''
(DELETED)'
Tritritr'
posição'do'hash.'
'
'
Encontra'e'
Marca'como'
“Deletado”'''

14.'Tabelas'Hash'
Recomendações
n 'Algumas'Implementações'não'aceitam'deleção.'
n 'A'deleção'deve'ser'usada'eventualmente'pois'reduz'
a'eficiência'das'tabelas'hash.'
n 'Normalmente'não'se'deve'admir'valores'
duplicados'
n 'Devense'dimensionar'a'tabela'hash'como'do'dobro'
da'previsão'do'tamanho'e'não'se'usar'mais'que'2/3'de'
seu'tamanho.'
Programa66.py'

14.'Tabelas'Hash'
Quadra@cProbing(ExploraçãoQuadrá@ca)
desmysfy'
Blasber'
Blabluk'
Tregs'
Bristols'
A'inserção'por'meio'de'
exploração'linear'tende'a'
criar'“clusters”'longos.'
'

14.'Tabelas'Hash'
desmysfy'
Blasber'
Blabluk'
Tregs'
Bristols'
Itens'que'deveriam'estar'
no'meio'do'cluster'fazemn
no'crescer'mais'e'mais'
rápido'
'

14.'Tabelas'Hash'
desmysfy'
Blasber'
Blabluk'
Tregs'
Bristols'
FATOR'DE'CARGA'
'
Número'de'itens'
'
Tamanho'da'Matriz'
'

14.'Tabelas'Hash'
desmysfy'
Blasber'
Blabluk'
Tregs'
Bristols'
Clusters'tendem'a'ser'formar'
mesmo'quando'o'fator'de'carga'é'
baixo.'
'

14.'Tabelas'Hash'
desmysfy'
Blasber'
Blabluk'
Tregs'
Bristols'
Exploração'quadráca'tende'a'
evitar'a'formação'de'grandes'
clusters.'
''

14.'Tabelas'Hash'
desmysfy'
Blasber'
Blabluk'
Tregs'
Bristols'
Faznse'isso'evitando'o'
preenchimento'sequencial'(linear)'
das'células.'
''

14.'Tabelas'Hash'
Exploração'Linear'
''
Posição'de'Inserção'(hash)'='x'
Próximas'posições'''
x+1,'x'+'2,'x'+'3,'....'
''
Exploração'Quadráca'
''Posição'de'Inserção'(hash)'='x'
Próximas'posições''
x+12,'x'+'22,'x'+'32,'....'
''

14.'Tabelas'Hash'
Exploração
Quadrá@ca(Busca)

Blablabla'
desmysfy'
blablabla'
Tritritr'
Melioraon'
posição'do'hash.'
'
Procura'quadracamente'
'
Busca'Bem'
Sucedida'
1'
4'
9'

14.'Tabelas'Hash'
Exploração
Quadrá@ca(Busca)

Blablabla'
desmysfy'
blablabla'
Tritritr'
''
'
posição'do'hash.'
'
Procura'quadracamente'
'
Busca'mal'
Sucedida'
1'
4'
9'

14.'Tabelas'Hash'
Problema:''
'
Todos'os'dados'com'o'mesmo'hash'seguirão'a'mesma'sequência'e'
formarão'o'que'se'chama'“cluster'secundário”'(Não'conõnuo).'
'

14.'Tabelas'Hash'
DuploHashing
Evita'clusters'primários'e'secundários.'Fazendo'um'hash'pela'
segunda'vez'com'uma'diferente'função'hash.'
'''

14.'Tabelas'Hash'
Caracterís@casdaFunçãoHashSecundária
• 'Não'deve'ser'igual'a'função'de'hash'primária'
• Não'deve'nunca'ter'saída'zero'
'
'''
Funçãoquefunciona:
Tamanho'do'deslocamento'='constante'–'(chave'%'
constante)'
'''
Constanteéumnúmeroprimomenorqueo
tamanhodamatriz.
Programa67.py'

14.'Tabelas'Hash'
PorqueUmnúmeroPrimo?
Imagine'que'o'tamanho'da'matriz'seja'20.''
Para'uma'constante'5'e'um'Hash'incial'0'a'lista'de'células'
consultadas'será:'
0'5'10'15'0'5'10'15'..............'Repedamente.'
'
A'mesma'lista'com'tamanho'17'seria:'
0'5'10'15'3'8'13'1'6'11'........'Sem'reper''
'''''''

14.'Tabelas'Hash'
DuploHashing
''
Escolha'freqüente'para'endereçamento'aberto!'
''''
'''
Programa67.py'

14.'Tabelas'Hash'
EncadeamentoSeparado(SeparateChaining)
375'
1040'
370'
98'
21'
18'
440'
210'
13'
34'
VAZIO'
VAZIO'
0'
1'
2'
3'
4'
5'
Listas'ligadas.'

14.'Tabelas'Hash'
EncadeamentoSeparado(SeparateChaining)
• Fator'de'carga'pode'ser'maior'que'1.'
• Desempenho'cai'com'aumento'de'itens'nas'listas.'
• Duplicados'são'permidos'
• Tamanho'primo'não'obrigatório'em'todos'os'casos'
• Inserção'e'deleção'normalmente'feita'nas'listas'
''

15.'Heaps'
'''
Heap'é'uma'área'de'memória'usada'para'
alocação'dinâmica'de'dados'em'linguagens'
como'C++'e'Java.'

15.'Heaps'
'''
É'uma'árvore'binária'com'as'seguintes'
caracteríscas:'
'

15.'Heaps'
'''
a)'Completa.'Todas'as'linhas'preenchidas'com'
exceção'da'úlma.'
Completa' Incompleta'

15.'Heaps'
''' b
)'Normalmente'implementada'como'uma'matriz'
100'
90'
80'
30'
60'
50'
70'
20'
10'
40'
0'
1'
2'
3'
4'
5'
6'
7'
8'
9'
100
90
30' 60'
20' 10' 40' 55'
80'
50' 70'
0'
1' 2'
3' 4' 5' 6'
7' 8 9' 10'
10' 55'

15.'Heaps'
''' c)' Todos' os' nós' devem' estar' de' acordo' com' a'
“Condição' de' Heap”:' ' As' chaves' de' cada' nó'
devem'ser'maior'ou'igual'a'de'seus'filhos.'

15.'Heaps'
'''
Heap' é' uma' representação' conceitual' de' uma'
matriz'cujos'elementos'são'manipulados'segundo'
este'modelo.'

15.'Heaps'
'''D
iùcil' atravessar' um' “heap”' “na' ordem”' (in'
order)'porque'o'heap'não'é'ordenado,'entretanto'
o'caminho'da'raiz'até'as'folhas'é'descendente.'

15.'Heaps'
'''
A'raiz'possui'o'maior'valor.'

15.'Heaps'
''' Úl'para'a'implementação'de'filas'de'prioridades.'
(Usadas'em'diversas'aplicações,'por'exemplo'em'
escalonamento'(Scheduling))'

15.'Heaps'
'' .'..,' mas' não' permite' a' busca' rápida' de' um'
elemento' pois' não' dá' informações' sobre' que'
caminho'seguir'na'busca.'Isto'significa'que'temos'
que' visitar' a' árvore' inteira' na' busca' de' um'
elemento.'O(n)'

15.'Heaps'
'''
Pra'que'usar?'

15.'Heaps'
'''
Heaps' permitem' a' rápida' eliminação' do' maior'
valor''e'rápida'inserção'de'novos'elementos.'
'
'(Ideal'para'filas'de'prioridades)'

15.'Heaps'
'''
Como'remover'o'maior'elemento?''
Maior'elemento'=''maz[0]'
0'
1'
2'
3'
4'
5'
6'
7'
8'
9'
10' 55'
100'
90'
80'
30'
60'
50'
70'
20'
10'
40'
Abordagem1:
Deslocaralista
inteirapracima
Dáprafazer
maisrápido?

15.'Heaps'
'''
95
82
63' 70'
43' 27' 55' 34'
Nóaserremovido.
51'
37' 10'
30'
Úl@moNó

15.'Heaps'
'''
30
82
63' 70'
43' 27' 55' 34'
51'
37' 10'
Permuta

15.'Heaps'
'''
82
30
63' 70'
43' 27' 55' 34'
51'
37' 10'
Permuta

15.'Heaps'
'''
82
70
63' 30
43' 27' 55' 34'
51'
37' 10'
Permuta

15.'Heaps'
'''
82
70
63' 55
43' 27' 30 34'
51'
37' 10'
Fim' do' processo' com'
apenas'4''permutações.'
'

15.'Heaps'
'''
Como'inserir'um'elemento?''
82'
70'
63' 55'
43' 27' 30' 34'
51'
37' 10'
95' Aserinserido.

15.'Heaps'
'''
82'
70'
63' 55'
43' 27' 30' 34'
51'
37' 10'
95'
Permuta

15.'Heaps'
'''
82'
70'
63' 55'
43' 27' 30' 34'
51'
95' 10'
Permuta
37'

15.'Heaps'
'''
82'
70'
63' 55'
43' 27' 30' 34'
95'
51' 10'
Permuta
37'

15.'Heaps'
'''
95'
70'
63' 55'
43' 27' 30' 34'
82'
51' 10'
37'
Inserção'concluída.'

15.'Heaps'
'''
Permutações'e'Permutações.'
A'
Permuta' Cópias'
B'
C'
D'
A'
TEMP'
Permuta'
Permuta'
A'
B'
C'
D'
A'
Cópia'
Cópia'
Cópia'
Cópia'
3'Permutações'='9'Cópias' Cópia'
Idem'com'5'Cópias'

15.'Heaps'
'''
Relembrando'Detalhes'
100'
90'
80'
30'
60'
50'
70'
20'
10'
40'
0'
1'
2'
3'
4'
5'
6'
7'
8'
9'
100
90
30' 60'
20' 10' 40' 55'
80'
50' 70'
0'
1' 2'
3' 4' 5' 6'
10' 55' 7' 8 9' 10'
Dadoumnócujaposiçãoéxnamatriz,qualaposiçãodopai,
dofilhodireitoedofilhoesquerdo?

15.'Heaps'
'''
Relembrando'Detalhes'
Repostas:

pai =(xf1)/2
Filhoesquerdo =2*x+1
Filhodireito =2*x+2

0'
1'
2'
3'
4'
5'
6'
7'
8'
9'
10' 55'
100'
90'
80'
30'
60'
50'
70'
20'
10'
40'

15.'Heaps'
'''
Abrindo'o'código'
Inserindodados
def'inserir(self,chave):'
''''''''if'self.tamanhoAtual'=='self.tamanhoMaximo:''
' 'return'False'
''''''''novoNoh'='Noh(chave)'
''''''''self.matrizHeap[self.tamanhoAtual]'='novoNoh'''''''''
''''''''self.borbulhaAcima(self.tamanhoAtual)'
''''''''self.tamanhoAtual'+=1'
''''''''return'True'
'''''

15.'Heaps'
'''
Abrindo'o'código'
Borbulhamentopracima
def'borbulhaAcima(self,'indice):'
''''''''pai'='(indicen1)/2'
''''''''base'='self.matrizHeap[indice]'
''''''''while'indice''0'and'self.matrizHeap[pai].obtemChave()''
' ' ' ' ' ' ' ' ' ' ' 'base.obtemChave():''
''''''''''''self.matrizHeap[indice]'='self.matrizHeap[pai]'
''''''''''''indice'='pai'
''''''''''''pai'='(pai'n1')/2'
''''''''self.matrizHeap[indice]'='base'

15.'Heaps'
'''
Abrindo'o'código'
RemoverRaiz
def'removerMaior(self):'
''''''''raiz'='self.matrizHeap[0]'
''''''''self.tamanhoAtual'n='1'
''''''''self.matrizHeap[0]='self.matrizHeap[self.tamanhoAtual]'
''''''''self.borbulhaAbaixo(0)'
''''''''return'raiz ''

15.'Heaps'
BorbulhamentoAbaixo
'''
def'borbulhaAbaixo(self,indice):'
''''''''topo'='self.matrizHeap[indice]'
''''''''while'indice''self.tamanhoAtual/2:'
''''''''''''filhoEsquerdo'='2'*'indice'+1'
''''''''''''filhoDireito'='filhoEsquerdo'+'1'
''''''''''''if'filhoDireito''self.tamanhoAtual'and' ' ' ' ' ' ' ' ' '''''''''''''''
''''''''''''''''''''''''''''''''''''''''''''''''''''''''self.matrizHeap[filhoEsquerdo].obtemChave()''
'''''''' ' ''''''''''''''''''''''''''''''''''self.matrizHeap[filhoDireito].obtemChave():'
''''''''''''''''filhoMaior'='filhoDireito'
''''''''''''else:'
''''''''''''''''filhoMaior'='filhoEsquerdo'
''''''''''''if'topo.obtemChave()'='self.matrizHeap[filhoMaior].obtemChave():'break'
''''''''''''self.matrizHeap[indice]'='self.matrizHeap[filhoMaior]'
''''''''''''indice'='filhoMaior'
''''''''self.matrizHeap[indice]='topo'

15.'Heaps'
'''
Abrindo'o'código'
Trocandoovalordeumelemento
def'troca(self,indice,novoValor):'
''''''''if'indice''0'or'indice'='self.tamanhoAtual:'return'False'
''''''''valorAngo'='self.matrizHeap[indice].obtemChave()'
''''''''self.matrizHeap[indice].atribuiChave(novoValor)'
''''''''if'valorAngo''novoValor:'
''''''''''''self.borbulhaAcima(indice)'
''''''''else:'
''''''''''''self.borbulhaAbaixo(indice)'
''''''''return'True'

15.'Heaps'
'''
Abrindo'o'código'
Programa69.py

15.'Heaps'
'''
Expandindo'o'Heap'
Linguagens'como'C'ou'Java'podem'apresentar'
problemas' na' expansão' da' matriz' caso' seja''
necessária.' Você' teria' que' construir' uma'
estrtura'que'permisse'o'crescimento'ou'usar'
novos'pos'(Vector'em'Java)''

15.'Heaps'
'''
Expandindo'o'Heap'
O'Tipo'lista'em'Python'(que'é'usado'para'criar'
matrizes)' ' é' dinâmico,' naturalmente'
expansível' com'o' append.'Portanto,'pode' ser'
expandido'naturalmente'

15.'Heaps'
'''
Expandindo'o'Heap'
Você' pode' reescrever' o' programa' aqui'
mostrado'de'forma'a'usar'melhor'os'recursos'
do'Python'sem'limitar'o'tamanho'da'matriz'do'
heap.'

15.'Heaps'
'''
HeapSort'
Método'simples'e'eficiente'de'ordenamento.'

15.'Heaps'
'''
HeapSort'
Idéia'Básica:'
'
a) Inserir'os'elementos'em'um'Heap'
b) Remover'os'elementos'a'parr'da'raiz'um'a'um.'

15.'Heaps'
'''
HeapSort'
for'j'in'range(tamanho):'
'heap.inserir('matrizBruta[j]')''
for'j'in'range(tamanho):'
'matrizOrdenada[j]'='heap.remover()''

15.'Heaps'
'''
Eficiência'do'HeapSort'
Operação'Insert:'' ''O(log(N))'
Operação'remove:'''O(log(N))'
'
A'função'HeapSort'trabalha'N'vezes'ou'seja'
O(N*Log(N))''

15.'Heaps'
'''
Melhorando'o'Borbulhamento'na'Inserção.'
Idéia:''
Ao'invés'de'inserir'e'borbulhar'cada'elemento,'inserimos'o'
elemento'em'uma'posição'qualquer'e'borbulhamos'tudo'de'uma'
vez.'
'
Ganho:''
'
Redução'do'tempo'(N/2'aplicações'do'borbulhamento'abaixo'na'
inserção)''

15.'Heaps'
'''
Melhorando'o'borbulhamento'na'Inserção.'
Idéia:''Subnheaps'corretos'ajudam'a'compor'heaps'corretos.'
95'
70'
63' 55'
43' 27' 30' 34'
82'
51' 10'

15.'Heaps'
'''
Por'onde'começar?'
Idéia:''Não'é'necessário'aplicar'o'borbulhamento'abaixo'nas'
folhas.' 95'
70'
63' 55'
43' 27' 30' 34'
82'
51' 10'

15.'Heaps'
'''
Por'onde'começar?'
Idéia:''Não'é'necessário'aplicar'o'borbulhamento'abaixo'nas'
folhas.' 95'
70'
63' 55'
43' 27' 30' 34'
82'
51' 10'
INICIAR'em''N/2'n'1'
11/2''n'1'=''4''

15.'Heaps'
'''
Nova'função'
Anovaro@nadeborbulhamentoabaixoseriaalgodo@po:

I=N/2–1
while(I=0):
heap.borbulhaAbaixo(I)
If=1'

15.'Heaps'
'''
Forma'recursiva'
Anovaro@nadeborbulhamentoabaixoseriaalgodo@po:

deforganizaHeap(indice):
ifindiceN/2f1:
return#nadaafazer
organizaHeap(indice*2+2)
organizaHeap(indice*2+1)
borbulhaAbaixo(indice)
'
Obs:'Menos'eficiente'que'o'laço'simples.'

15.'Heaps'
'''
Usando'matriz'única'
Na forma atual usamos uma matriz para o heap (inserindo
elementos)eoutramatrizcomoselementosre@radosdoheap
deformaordenada.

Épossíveleconomizarmemória???
'

15.'Heaps'
'''
Usando'matriz'única'
Dadoumheap.'
50'
30'
40'
10'
20'
50'
30'
40'
10'
20'

15.'Heaps'
'''
A'rerada'de'um'elemento'(50)'cria'um'vazio.'
Dadoumheap.'
40'
30'
20'
10'
'nnn'
40'
30'
20'
10'

15.'Heaps'
'''
Que'pode'ser'preenchido'com'o'elemento'rerado'
Dadoumheap.'
40'
30'
20'
10'
'50'
40'
30'
20'
Heap'
10'
Matriz'Ordenada'

15.'Heaps'
'''
Da'mesma'forma'para'o'próximo'elemento.'
Dadoumheap.'
30'
10'
20'
nn'
'50'
30'
10'
20'
Heap'
Matriz'Ordenada'

15.'Heaps'
'''
Que'é'igualmente'preenchido.'
Dadoumheap.'
30'
10'
20'
40'
'50'
30'
10'
20'
Heap'
Matriz'Ordenada'

15.'Heaps'
'''
Rependo'
Dadoumheap.'
20'
10'
nn'
40'
'50'
20'
10'
Heap'
Matriz'Ordenada'

15.'Heaps'
'''
Rependo'
Dadoumheap.'
20'
10'
30'
40'
'50'
20'
10'
Heap'
Matriz'Ordenada'

15.'Heaps'
'''
Finalizando'...'
Dadoumheap.'
10'
nn'
30'
40'
'50'
Heap' 10'
Matriz'Ordenada'

15.'Heaps'
'''
Finalizando'...'
Dadoumheap.'
10'
20'
30'
40'
'50'
Heap' 10'
Matriz'Ordenada'

15.'Heaps'
'''
Finalizando'...'
Construímosumamatrizordenada.'
10'
20'
30'
40'
'50'
Matriz'Ordenada'
Programa70.py

15.'Heaps'
'''
Resumindo...'
• Um'heap'é'uma'estrutura'de'dados'abstrata'(EDA)'normalmente'ulizada'para'
representar'filas'com'prioridades.'
• Uma'fila'de'prioridades'é'uma'estrutura'de'dados'que'ofercem'métodos'de'rápida'
inserção'ou'remoção'do'menor'ou'maior'item.'
''
• Um'heap'permite'remoção'do'maior'item'e'inserção'em'O(N*logN).'
''
• Maior'item'é'sempre'a'raiz.'
'
• O'heap'não'permite'a'visita'ordenada'aos'dados,'a'localização'de'uma'chave'específica'ou'
deleção.'

15.'Heaps'
'''
Resumindo...'
• Um'heap'é'normalmente'implementado'como'uma'matriz'representando'uma'árvore'
binária'completa.'
• Os'nós'possuem'chaves'menores'que'seus'pais'e'maiores'que'seus'filhos.'
• Os'itens'são'inseridos'no'final'da'matriz'e'“borbulhados”'para'cima.'
• Quando'um'elemento'é'rerado'da'raiz'o'úlmo'elemento'é'colocado'aí'e'deslocado'
(“borbulhado”)'para'baixo'até'sua'posição'correta.'
• A'prioridade'de'um'elemento'pode'mudar,'mudando'a'sua'chave.'Ao'mudar'para'maior'o'
item'é'“borbulhado”'para'cima,'do'contrário'para'baixo.'
• Heapsort'é'um'algoritmo'de'ordenamento'eficiente.'O(N*logN)'
• A'idéia'básica'do'heapsort'é'a'inserção'e'rerada'de'elementos'de'um'heap'
• O'heapsort'fica'mais'eficiente'se'a'formação'do'heap'é'feita'após'a'inserção'de'todos'os'
itens'em'posições'aleatórias.'
• Uma'mesma'matriz'pode'servir'para'armazenar'o'heap'e'gerar'a'lista'ordenada.'

15.'Heaps'
'''
Fim'da'aula'15'

16.'Grafos'
'''
''
As' estruturas' de' dados' estudadas' até' aqui' tem'
uma' arquitetura' voltada' para' facilitar' certas'
operações'a'serem'executadas'sobre'as'mesmas.'
Uma'árvore'binária'por'exemplo'é'constuída'de'forma'a'facilitar'a'procura'e'inserção'
de'elementos'

16.'Grafos'
'''
''
Grafos' são' estruturas' voltadas' a' soluções' de'
problemas'do'mundo'real.'

16.'Grafos'
'''
''Um' grafo' é' composto' de' segmentos' e' vérces'
(nós).'
Nós'
Segmentos'

16.'Grafos'
'''
''
Grafo' representando' região' metropolitana' de'
fortaleza.'
Aquiraz'
Fortaleza'
Caucaia'
Maranguape'
Euzébio'
Pacatuba'
BR020'
CE065'
CE060'
Maracanaú'
CE060'
Itainga'
BR116'
CE040'

16.'Grafos'
'''
''
Adjacência'
A'
B'
Dois'nós'(vérces)'são'adjacentes'se'estão'ligados'
por'um'segmento'de'reta'(Eixos).'

16.'Grafos'
'''
''
Caminho'(path)'
A'
B'
C'
ABC''''='
Seqüência'de'eixos'(segmentos)'entre'dois'pontos.'

16.'Grafos'
'''
''
Grafo'Conectado'
A'
Conectado' Não'Conectado'
B'
C'
D'
Existe' pelo' menos' um' caminho' de' um' nó' para'
qualquer'outro.'

16.'Grafos'
'''
''
Grafo'Direcionado'
A'
B'
C'
D'
Os'arcos'(segmentos)'expressam'uma'direção'

16.'Grafos'
'''
''
Grafo'com'Pesos'
A'
B'
60'
40' 30' 10'
C'
D'
Podem' ser' usados' números' sobre' os' arcos'
(pesos).''

16.'Grafos'
'''
''
História:'Leonard'Euller'e'as'Pontes'de'Könisberg'

16.'Grafos'
'''
''
História:'Leonard'Euller'e'as'Pontes'de'Königsberg'
A'
C'
B'
Teorema'de'Euller:'Somente'pode'haver'
dois'vérces'com'número'ímpares'de'
conexões'(o'de'chegada'e'o'de'parda)'
D'

16.'Grafos'
'''
''
Como''representar'no'computador.'
Vérces'pode'ser'representados:'
'
A) Como'números:''1,2,3,....N'
B) Como'objetos'da'classe'Vérce'

16.'Grafos'
'''
''
Exemplo'de'classe'Vérce'
class'Verce:'
'def'__init__(self,rotulo):'
' 'self.rotulo'='rotulo''#'por'exemplo'“A”'
' 'self.visitado'='False'
'def''visitado(self):'
' 'self.visitado'='True'
' ''
'''

16.'Grafos'
'''
''
Representando'os'Arcos'
• Matriz'de'Adjacências'
• Lista'de'Adjacências'
'
' ''
''
'

16.'Grafos'
'''
''
Matriz'Adjacências'

16.'Grafos'
'''
''
Lista'de'Adjacências'

16.'Grafos'
'''
''
Adicionando'um'vérce'ao'laço:'
nVerces'+='1'
listaVerces[nVerces]'='Verce(‘A’);''

16.'Grafos'
'''
''
Adicionando'um'arco'ao'laço:'
Inserindo'um'arco'entre'os'vérces'1'e'3'
usando'matriz'de'adjacências:'
'
adjMat[1][3]'='1''
adjMat[3][1]'='1'

16.'Grafos'
'''
''
Adicionando'um'arco'ao'laço:'
Inserindo'um'arco'entre'os'vérces'1'e'3'
usando'Lista'de'adjacências:'
'
adjlista[1].append(3)''
adjlista[3].append(1)''

16.'Grafos'
'''
''
Procurando'caminhos'em'um'grafo'
Aquiraz'
Fortaleza'
BR020'
CE065'
Caucaia'
Maranguape'
CE040'
BR116' Euzébio'
CE060'
CE060' Itainga'
Maracanaú' Pacatuba'

16.'Grafos'
'''
''
Busca'em'Grafos'
Visitar' os' vérces' seguindo' uma' estratégia'
específica.'

16.'Grafos'
'''
''
Estratégias'
• Busca'em'Profundidade'(Depth'First'Search)'
• Busca'em'Largura'(Breadth'First'Search)'

16.'Grafos'
'''
''
Busca'em'Profundidade'
B'
A'
C'
F'
H'
D' E'
G'
I'

16.'Grafos'
'''
''
Usar'uma'pilha'para'relembrar'
os'nós'visitados.'
Seqüência'1.' A'
Iniciamos' com' o' primeiro'
nó.' Visitamos' e' verificamos'
se'é'a'meta.'

16.'Grafos'
'''
''
os'nós'visitados.'
Seqüência'1.' A'
Marcamos'como'visitado'

16.'Grafos'
'''
''
os'nós'visitados.'
'Colocamos'na'Pilha'
A'
Seqüência'1.'

16.'Grafos'
'''
''
os'nós'visitados.'
P r o c u r a m o s' um' n ó'
adjacente'não'visitado'
A'
Seqüência'2' B'

16.'Grafos'
'''
''
os'nós'visitados.'
Seqüência'2' B'
' 'Marcamos.'
A'

16.'Grafos'
'''
''
os'nós'visitados.'
'''''Coloqueno'na'pilha.'
B' AA''
Seqüência'2'

16.'Grafos'
'''
''
os'nós'visitados.'
'''Repetense'a'seqüência'2''
F' B' A'
F'
F'

16.'Grafos'
'''
''
os'nós'visitados.'
' 'Novamente!'
F' B' A'
H'
H'
H'

16.'Grafos'
'''
''
os'nós'visitados.'
'Novamente???'
'Não'é'mais'possível.'
H' F' B' A'

16.'Grafos'
'''
''
os'nós'visitados.'
Rerar' um' elemento' da'
pilha.'
F' B' A'
Seqüência'3' H'

16.'Grafos'
'''
''
os'nós'visitados.'
Tentar' pegar' o' próximo'
elemento' adjacente' não'
visitado.' Se' exisr' refaz'
seqüência'2'senão'connua.'
F' B' A'
Seqüência'3' H'

16.'Grafos'
'''
''
os'nós'visitados.'
É' o' caso.' Rerar' mais' um'
elemento'
B' A'
F'
Seqüência'3'

16.'Grafos'
'''
''
os'nós'visitados.'
B' A'
Seqüência'3'

16.'Grafos'
'''
''
os'nós'visitados.'
É' o' caso.' Rerar' mais' um'
elemento'
A'
B'
Seqüência'3'

16.'Grafos'
'''
''
os'nós'visitados.'
A'
Seqüência'3'

16.'Grafos'
'''
''
os'nós'visitados.'
Existe.'Reper'Seqüência'2'
A'
Seqüência'3' C'
C'
C'

16.'Grafos'
'''
''
os'nós'visitados.'
Não' existe' adjacente' a' C.'
Reránlo'
A'
Seqüência'3' C'

16.'Grafos'
'''
''
os'nós'visitados.'
Encontrado'outro'adjacente'
a'D'
A'
Seqüência'3' G'
G'
G' D'

16.'Grafos'
'''
''
os'nós'visitados.'
Encontrado'outro'adjacente'
a'G'
A'
Seqüência'3' I'
I'
G' D'

16.'Grafos'
'''
''
os'nós'visitados.'
I' não' tem' adjacentes' não'
visitados'
I' G' D' A'

16.'Grafos'
'''
''
os'nós'visitados.'
I' G' D' A'
Rerar' os' elementos' até'
q u e' um' d e l e s' t e n h a'
adjacentes'não'visitados'

16.'Grafos'
'''
''
os'nós'visitados.'
Se' não' existem' mais,' a'
busca' terminou' (Sem'
Sucesso).'

16.'Grafos'
Operação Pilha
Testa'A''(visita'A)' A'
Testa'B' AB'
Testa'F' ABF'
Testa'H'' ABFH'
Remove'H' ABF'
Remove'F' AB'
Remove'B' A'
Testa'C' AC'
Remove'C' A'
Testa'D' AD'
...' ADG,ADGI,ADG,AD,A,AE,A'
Remove'A'
'''
''
O' Conteúdo' da' pilha' indica'
o' caminho' do' início' da'
busca' até' o' nó' sendo'
examinado.' Caso' a' busca'
t e rmi n e' a í ,' a' p i l h a'
representa'o'caminho!!!'

16.'Grafos'
'''
''
Questão'chave'
Usanse' a' matriz' de' adjacências' para' descobrir' qual' o' elemento'
adjacente'ainda'não'visitado'(testado).'

16.'Grafos'
'''
''
Questão'chave'
def'obtemAdjacenteNaoVisitado(verce):'
'for'j'in'range(numVerces):'
' 'if'matrizAdj[verce][j]'=='1'and'listaVerces[j].visitado'=='
False:'
' ' 'return'j'
'return'n1''
''

Fim'da'Aula'16'
'''
''
Apenas'uma'pausa'.......'

17n'Busca'em'Grafos.'Connuação'...'
'''
''

17.'Busca'em'Grafos'
'''
''
Busca'em'Largura'
B'
A'
C'
F'
H'
D' E'
G'
I'

'''
''
Idéia' Central:' Usar' uma' Lista' como' estrutura'
auxiliar.'
Seqüência'1.' A' Entrada' Saída'
Usar'uma'lista'para'inserir'os'
nós'a'serem'visitados'
Iniciamos' com' o' primeiro'
nó.' Visitamos' e' verificamos'
se'é'a'meta.'

'''
''
auxiliar.'
Seqüência'1.'
A'
Geramos' o' primeiro' nó'
a d j a c e n t e .'
Testamo s ( V i s i t a m o s ) .'
Marcamos.' Inserimos' na'
Fila.''
Entrada' Saída'
B'
B'
B'

'''
''
auxiliar.'
Seqüência'1.'
A'
Geramos' o' próximo' nó'
Fila.''
Entrada' Saída'
C'
C'
C' B'

'''
''
auxiliar.'
Seqüência'1.'
A'
Fila.''
Entrada' Saída'
D'
D'
D' C' B'

'''
''
auxiliar.'
Seqüência'1.'
A'
Fila.''
Entrada' Saída'
E'
E'
E' D' C' B'

'''
''
auxiliar.'
Seqüência'2.' Entrada' Saída'
Quando' não' exisrem'mais'
adjacentes .' Rerar' o'
próximo'elemento'da'Fila.'
E' D' C' B'
B'

'''
''
auxiliar.'
Sequencia'1'(de'novo)' Entrada' Saída'
Gerar' os' nós' adjacentes'
deste' nó.' Visitar' (testar)' e'
colocar'na'Fila.'
E' D' C'
B' F'
F'
F'

'''
''
auxiliar.'
Seqüência'2'(de'novo)' Entrada' Saída'
N ã o' s e n d o' p o s s í v e l'
connuar.' Removense' o'
próximo'da'fila.'
E' D'
C'
F' C'

'''
''
auxiliar.'
L o c a l i z a n s e' o s' n ó s'
adjacentes' ao' rerado.' Se'
possível'
E' D'
C'
F'
?'

'''
''
auxiliar.'
Não' exisndo,' removense' o'
próximo.'
E'
D'
F' D'

'''
''
auxiliar.'
Localizamnse' os' vérces'
adjacentes....'
E'
D'
F'
G'
G' G'

'''
''
auxiliar.'
Seqüência'2'(de'novo)' E' Entrada' Saída'
Não' sendo' possível,' reran
se'o'próximo'....'
G' F' E'

'''
''
auxiliar.'
Seqüência'1'(de'novo)' E' Entrada' Saída'
Gera'adjacente....'
G' F'
?'

'''
''
auxiliar.'
Seqüência'2'(de'novo)' F' Entrada' Saída'
Não'exisndo'....'
G' F'

'''
''
auxiliar.'
Seqüência'1'(de'novo)' F' Entrada' Saída'
Gera'adjacente...'
G'
H'
H'
H'

'''
''
auxiliar.'
G'
Rera'próximo'....'
H' G'

'''
''
auxiliar.'
G'
Verifica'adjacentes'....'
H'
I'
I' I'

'''
''
auxiliar.'
Rera'próximo.'
H'
I' H'

'''
''
auxiliar.'
H'
Procura'Adjacências'...'
I'
?'

'''
''
auxiliar.'
I'
Remove'o'próximo'...'
I'

'''
''
auxiliar.'
I'
Procura'adjacentes'....'

'''
''
auxiliar.'
Fim'da'busca'....'
Entrada' Saída'

Operação Fila
Testa'A''(visita'A)'
Testa'B' B'
Testa'C' BC'
Testa'D'' BCD''
Testa'E' BCDE'
Remove'B' CDE'
Testa'F' CDEF'
Remove'C'' DEF'
Remove'D' EF'
Testa'G' EFG'
...' FG,'G','GH','H','HI,'I'
Remove'I'
'''
''
O' Conteúdo' da' fila' indica' o'
conjunto' de' nós' testados,'
porém' não' totalmente'
e x p a n d i d o s ' ( C o m'
adjacentes'a'explorar).'

'''
''
Outra'vista'do'grafo:'
B' A'
C'
H'
F'
D'
E'
I'
G'

'''
''
Árvore'Geradora'Mínima'(AGM)''
(Minimum'Spanning'Tree)'
A'menor'árvore'que'conecta'todos'os'vérces'de'
um'grafo.'
A'
B' C'
D' E'
A'
B' C'
D' E'

'''
''
Dado'um'número'de'vérces'(V)'o'número'de'
eixos'(E)'='V'n1''
A'
B' C'
D' E'
A'
B' C'
D' E'

'''
''
Para'sua'determinação'podense'usar'tanto'a'busca'
em'largura'como'em'profundidade.'
A'
B' C'
D' E'
A'
B' C'
D' E'

'''
''
Observando'o'caminho'de'uma'busca'em'
profundidade'ao'passar'por'todos'os'nós'é'
exatamente'o'caminho'de'uma'AGM.'

'''
''
A'
B' C'
D' E'
A'
B' C'
D' E'
Caso'1''
OBS:'O'Caminha'da'AGM'não'é'único'

'''
''
A'
B' C'
D' E'
A'
B' C'
D' E'
Caso'2'' ?'

'''
''
A'
B' C'
D' E'
A'
B' C'
D' E'
Caso'2''

'''
''
Ordenamento'Topológico'
Lógica'de'
Programação'
Linguagem'de'
Programação'I'
Linguagem'de'
Programação'II'
Sistemas'
Operacionais'
Bancos'de'
Dados'
Programação'
Para'WEB'
Redes'de'
Computadores'
Exemplo'de'Grafo'mostrando'
disciplinas' prénrequisitos' de'
um'curso'

'''
''
Grafos'Direcionados'
A'
B' C'
Matriz'de'Adjacências'
Listas'de'Adjacências'
'
A:''B'
B:''C'
C:'
'

'''
''
A'
B' C'
Adicionando'Arcos'ao'Grafo'Não'Direcionado'
'def'adicionaArco(self,inicio,fim):'
''''''''self.matrizAdjacencias[inicio][fim]'='1'
''''''''self.matrizAdjacencias[fim][inicio]'='1'
Adicionando'Arcos'ao'Grafo'Direcionado'
'def'adicionaArco(self,inicio,fim):'
''''''''self.matrizAdjacencias[inicio][fim]'='1'
'

'''
''
A'
D'
E' G' H'
B' C'
F'
Qual'a'ordem'topológica??'

'''
''
A'
D'
E' G' H'
B' C'
F'
Qual'a'ordem'topológica??'
BAEDGCFH'

Fim'da'Aula'17'
'''
''
Apenas'uma'pausa'.......'

Aula''18.'Grafos'com'Pesos'
'''
''

18.'Grafos'com'Pesos'
'''
''
Conecvidade'em'Grafos'Direcionados'
A'
B'
C'
D'
E'
Até' onde' posso' chegar' a'
parr'de'A,B,C,D'ou'E?'

'''
''
Algoritmo'de'Warshall'
Modificanse' a' matriz' de' adjacências' construindo' um'
“fecho' transivo”.' Esta' estrutura' permite' a' verificar'
instantaneamente' O(1)' se' um' vérce' dado' pode' ser'
alcançado'a'parr'de'outro.'''

'''
''
Idéia'básica:'Se'vc'pode'chegar'a'B'a'parr'de'A'e'a'C'a'
parr'de'B,'então'você'pode'chegar'a'C'a'parr'de'A'
(Transividade)'

'''
''
Dado'o'Grafo'Abaixo:'
A'
B'
C'
D'
E'
A B C D E
A 0 0 1 0 0
B 1 0 0 0 1
C 0 0 0 0 0
D 0 0 0 0 1
E 0 0 1 0 0

'''
''
Inicianse'pela'linha'A'
Arco'de'A'a'C'
A B C D E
A 0 0 1 0 0
B 1 0 0 0 1
C 0 0 0 0 0
D 0 0 0 0 1
E 0 0 1 0 0

'''
''
Se' soubéssemos' da' existência'
de' um' caminho' de' X' para' A'
então'haveria' caminho'de' X' a'
C.'
Arco'de'A'a'C'
A B C D E
A 0 0 1 0 0
B 1 0 0 0 1
C 0 0 0 0 0
D 0 0 0 0 1
E 0 0 1 0 0

'''
''
Na' coluna'A' achamos' todos'
os' vérces' que' tem' arco'
chegando'em'A'
Arco'de'A'a'C'
A B C D E
A 0 0 1 0 0
B 1 0 0 0 1
C 0 0 0 0 0
D 0 0 0 0 1
E 0 0 1 0 0

A B C D E
A 0 0 1 0 0
B 1 0 0 0 1
C 0 0 0 0 0
D 0 0 0 0 1
E 0 0 1 0 0
'''
''
No' caso' apenas' o' B' está'
ligado'ao'A.' Arco'de'A'a'C'

A B C D E
A 0 0 1 0 0
B 1 0 1 0 1
C 0 0 0 0 0
D 0 0 0 0 1
E 0 0 1 0 0
'''
''
P o r' t r a n s i v i d a d e'
colocamos' o' 1' indicando'
que'há'caminho'de'B'a'C.'
Arco'de'A'a'C'

A B C D E
A 0 0 1 0 0
B 1 0 1 0 1
C 0 0 0 0 0
D 0 0 0 0 1
E 0 0 1 0 0
'''
''
Examinando'a'segunda'linha.'
B'é'ligado'a'A.' Porém'ninguém'é''ligado'a'B'

A B C D E
A 0 0 1 0 0
B 1 0 1 0 1
C 0 0 0 0 0
D 0 0 0 0 1
E 0 0 1 0 0
'''
''
Examinando' a' terceira' linha.'
C'não'é'ligado'a'ninguém.'

A B C D E
A 0 0 1 0 0
B 1 0 1 0 1
C 0 0 0 0 0
D 0 0 0 0 1
E 0 0 1 0 0
'''
''
Examinando' a' quarta' linha.'
D'é'ligado'ao'E.' Porém'ninguém'é''ligado'a'D'

A B C D E
A 0 0 1 0 0
B 1 0 1 0 1
C 0 0 0 0 0
D 0 0 1 0 1
E 0 0 1 0 0
'''
''
Examinando'a'úlma'linha.'E'
é'ligado'ao'C.'
B' e' D' são' ligados' ao' E,'
portanto' também' são'
ligados'a'C'

A B C D E
A 0 0 1 0 0
B 1 0 1 0 1
C 0 0 0 0 0
D 0 0 1 0 1
E 0 0 1 0 0
'''
''
Fecho'Transivo.'
A'
B'
C'
D'
E'

A B C D E
A 0 0 1 0 0
B 1 0 1 0 1
C 0 0 0 0 0
D 0 0 1 0 1
E 0 0 1 0 0
'''
''
matrizAdj[inicio][fim]'=='1'?'
A'
B'
C'
D'
E'
Programa76.py'

'''
''
Distâncias'Rodoviárias'
Aquiraz'
Fortaleza'
Caucaia'
21'(ANEL'VIARIO)' 08'(CE040)'
Maranguape'
27'(CE040)'
30'(ANEL'VIARIO)'
33'(BR116)'
Pacatuba'
16'(BR020)'
25'(CE065)'
Maracanaú'
Euzébio'
17'(CE060)' Itainga'
12'(CE350)'
10'(CE065)'
20'(Rua'Henrique'Silva)'

'''
''
Link'de'Fibra'Óca'–'Cinturão'Digital''
Aquiraz'(F)'
Fortaleza'(B)'
Caucaia'(A)'
Euzébio'(C)'
Itainga'(E)'
Maracanaú'(D)'

'''
''
Aquiraz'(F)'
Fortaleza'(B)'
Caucaia'(A)'
Euzébio'(C)'
Itainga'(E)'
Maracanaú'(D)'
Caminhos'
muito'longos'

'''
''
Aquiraz(F)'
Fortaleza'(B)'
Caucaia'(A)'
Euzébio'(C)'
Itainga'(E)'
Maracanaú'(D)'
10'
6'
4' 7'
12'
7'
8'
6'
7' 5'
Custos'em'milhões'de'reais.'

'''
''
Iniciando'o'processo.'Começando'em'Caucaia.'
Fortaleza'(B)'
Caucaia'(A)'
Maracanaú'(D)'
4'
Lista'de'Arcos'Visitados'em'Ordem'de'Custo'
Es tudando' o' t rajeto' Caucai a'
Maracanaú,' esmanse' o' custo' em' 4'
milhões.'
AD'

'''
''
Fortaleza'(B)'
Caucaia'(A)'
Es tudando' o' t rajeto' Caucai a'
Fortaleza,' esmanse' o' custo' em' 6'
milhões.'
Maracanaú'(D)'
4'
6'
AD' AB'

'''
''
Fortaleza'(B)'
Caucaia'(A)'
1'
6' fará'parte'da'AGM?'
4'
Maracanaú'(D)'
Temos' inicialmente' duas'
opções.'A'de'menor'custo'
Cidade'Hipotéca'H'
1'
Tabela'de'Custos'
AnDnHnB':''6'
AnBnHnD':''8'
BnAnDnH':'11'
BnHnDnA':''6'''
Conhecido' Desconhecido'
Qualquer' caminho' de'
menor' custo' conterá'
(AD)'ou'(DA)'

'''
''
Fortaleza'(B)'
Caucaia'(A)'
AD' faz' parte' da' árvore' geradora'
mínima.'Removense'da'lista'
Maracanaú'(D)'
4'
6'
AB'

'''
''
Connuando'....'
Fortaleza'(B)'
Caucaia'(A)'
DB' DC' DE'
7' Euzébio'(C)'
Maracanaú'(D)'
4'
6'
AB'
12'
8'
Itainga'(E)'

'''
''
Connuando'....'
Fortaleza'(B)'
Caucaia'(A)'
Maracanaú'(D)'
4'
6'
AB'
12'
8'
7'
Euzébio'(C)'
Itainga'(E)'
DB' DC' DE'
A'regra'é'sempre'pegar'o'de'
menor'custo'da'lista.'

'''
''
Connuando'....'
Fortaleza'(B)'
Caucaia'(A)'
Maracanaú'(D)'
4'
6'
12'
8'
Euzébio'(C)'
Itainga'(E)'
DB'
DC' DE'
Estando'D'conectada,'DB'sai'
da'lista.'

'''
''
Connuando'....'
Fortaleza'(B)'
Caucaia'(A)'
Maracanaú'(D)'
4'
BC' DE'
Euzébio'(C)'
6'
Lista:'
12'
8'
Itainga'(E)'
10'
7'
BE' DC'
Próximo'elemento'de'menor'
custo'

'''
''
Connuando'....'
Fortaleza'(B)'
Caucaia'(A)'
Maracanaú'(D)'
4'
BC' DE'
Euzébio'(C)'
6'
Lista:'
12'
8'
Itainga'(E)'
10'
7'
DC'
BE'
Remove'BE'da'lista.'

'''
''
Connuando'....'
Fortaleza'(B)'
Caucaia'(A)'
Maracanaú'(D)'
4'
BC'
6'
Lista:'
8'
Itainga'(E)'
DE'
Euzébio'(C)'
10'
7'
DC'
Remove'da'lista'DE'pois'D'
já' está' ligada' à' rede' de'
fibra.'

'''
''
Próximo'....'
Fortaleza'(B)'
Caucaia'(A)'
Maracanaú'(D)'
4'
6'
Lista:'
8'
Itainga'(E)'
BC'
Euzébio'(C)'
10'
7'
DC'
7'
5'
Aquiraz'(F)'
EC' EF'

'''
''
Próximo'....'
Fortaleza'(B)'
Caucaia'(A)'
Maracanaú'(D)'
4'
6'
Lista:'
8'
Itainga'(E)'
BC'
Euzébio'(C)'
10'
7'
DC'
7'
5'
Aquiraz'(F)'
EC' EF'
N o v a m e n t e' o'
menor.'

'''
''
Próximo'....'
Fortaleza'(B)'
Caucaia'(A)'
Maracanaú'(D)'
4'
6'
Lista:'
8'
Itainga'(E)'
BC'
Euzébio'(C)'
10'
7'
DC'
7'
5'
Aquiraz'(F)'
EF'
N o v a m e n t e' o'
menor.'

'''
''
Próximo'....'
Fortaleza'(B)'
Caucaia'(A)'
Maracanaú'(D)'
4'
Euzébio'(C)'
6'
Lista:'
Itainga'(E)'
7'
7'
5'
Aquiraz'(F)'
EF'
Elimina' cidades'
conectadas.'

'''
''
Próximo'....'
Fortaleza'(B)'
Caucaia'(A)'
Maracanaú'(D)'
4'
6'
Lista:'
Itainga'(E)'
Euzébio'(C)'
7'
7'
5'
Aquiraz'(F)'
EF'
Elimina' cidades'
conectadas.'

'''
''
Finalizando....'
Fortaleza'(B)'
Caucaia'(A)'
Maracanaú'(D)'
4'
6'
Lista:'
Itainga'(E)'
Euzébio'(C)'
7'
7'
5'
Aquiraz'(F)'
EF'
6'
CF'
Duas' úlmas'
opções.'

'''
''
Finalizando....'
Fortaleza'(B)'
Caucaia'(A)'
Maracanaú'(D)'
4'
5' Aquiraz'(F)'
6'
Lista:'
Itainga'(E)'
Euzébio'(C)'
7'
7'
EF'
6'
E s c o l h a' d a'
menor.'

'''
''
Finalizando....'
Fortaleza'(B)'
Caucaia'(A)'
Maracanaú'(D)'
4'
6'
E l i m i n a'
conectadas.'
6'
Lista:'
Itainga'(E)'
Euzébio'(C)'
7'
5' Aquiraz'(F)'

'''
''
Fim'da'construção'da'AGM....'
Fortaleza'(B)'
Caucaia'(A)'
Maracanaú'(D)'
4'
Euzébio'(C)'
6'
6'
Itainga'(E)'
7'
5' Aquiraz'(F)'

'''
''
Questão'chave.'
Usamos' uma' lista' ordenada' por' prioridades' (menor' custo)' para'
conter' todos' o' vérces' a' serem' analisados.'Na' práca' podense'
usar'um'heap'para'ganhar'eficiência'no'processo.'

'''
''
Resumo'do'algoritmo'
I n t r o d u z a' o'
vérce' de' início'
na'árvore.'
'
Repita''o'seguinte'
enquanto'for'
possível'
Encontre' todos' os' vérces' que' são'
vizinho' do' úlmo' adicionado' e' ainda'
não'estão'na'árvore.'Ponhanos'na'lista'
de'prioridades'
Rere' o' arco' de'menor' custo' da' lista'
de' prioridades' adicionandono' e' o' seu'
vérce'correspondente'na'árvore'

'''
''
Arcos'extras'.....'
Após'a'seleção'do'próximo'vérce,'precisamos'lidar'com'o'arcos'
que'levam'a'vérces'já'conectados'(Cidades'já'visitadas).'Se'não'
forem'rerados'podem'levar'a'ciclos'ou'a'permanência'de'arcos'
extras'na'AGM'(Errada).''

'''
''
Arcos'extras'.....'
A' introdução' do' arco' AB' na' árvore'
deve'implicar'na'remoção'do'BD'da'
lista'
Recém' Inser ido' na'
árvore'
6'
4'
7'
A'remover'da'lista'

'''
''
Arcos'extras'.....'
Remoção'de'Duplicados'na'Lista.'
Arcos'na'lista'de'prioridade'que'levem'ao'mesmo'desno'devem'
ser'removidos'permanecendo'apenas'o'de'menor'custo.'
Programa77.py'

18.'Grafos'Direcionados'com'Pesos'
'''
''
O'Problema'do'menor'(melhor)'caminho.'
Fortaleza'(B)'
Caucaia'(A)'
Euzébio'(C)'
Itainga'(E)'
Maracanaú'(D)'
R$'50'
R$'80'
R$'90'
R$'60'
R$'50'
R$'20'
R$'70'
R$'40'

18.'Algoritmo'de'Dijkstra'
'''
''
Algoritmo'do'menor'caminho'(1959)'
★ 11/05/1930'n'Roterdam'–'Holanda'
✚ 6'/08/2002'n'Nuenen'–'Holanda'
'
Instuições'
'
Mathemasch'Centrum'
Eindhoven'University'of'Technology'
The'University'of'Texas'at'Ausn'
Menor'(melhor)'caminho'de'um'vérce'a'todos'os'
outros'em'um'grafo.'

'''
''Questão.'Qual' o'menor' custo' para' ir' de' Caucaia'
(A)'até'qualquer'outra'cidade?'
DePara (B)Fortaleza (C)Eusébio (D)Maracanaú (E)Itai@nga
(A)'Caucaia'
Na'estação'de'Caucaia'sabemos'que'custa'R$'50,00'para'Fortaleza'e'R$''80,00'para'
Maracanaú'''

'''
(A)'Caucaia'(1)' R$'50,00' ???' R$'80,00' ????'
Próximo'passo:???'
'
Regra:''Deslocarnse'pelo'caminho'de'menor'custo'''

'''
''
Situação'até'o'momento'
Fortaleza'(B)'
R$'50'
Caucaia'(A)'
Euzébio'(C)'
Itainga'(E)'
R$'80'
R$'90'
Maracanaú'(D)'
R$'60'
Região'Visitada'
(Vérces'a'Árvore)'
Região'Conhecida'
(Vérces'a'serem'
analisados'e'colocados'
na'arvore)'
Região'Desconhecida'
R$'110'

'''
(A)'Caucaia'(1)' R$'50,00' ???' R$'80,00' ????'
(A)'Caucaia'(2)'
'
R$50,00'(Via'A)*' R$110,00(ViaB)' R$80,00'(Via'A)' ???'
Próximo'passo:???'
'
Regra:''Deslocarnse'pelo'caminho'de'menor'custo'
'
*'Marcada'como'visitada'''

'''
(A)'Caucaia'(1)' R$'50,00' ???' R$'80,00' ????'
(A)'Caucaia'(2)'
'
R$50,00'(Via'A)*' R$110,00(Via'B)' R$80,00'(Via'A)' ???'
Próximo'passo:Visitar'D'(menor'custo)'
'
'

'''
''
Fortaleza'(B)'
R$'50'
Caucaia'(A)'
Euzébio'(C)'
Itainga'(E)'
R$'80'
R$'90'
Maracanaú'(D)'
R$'60'
R$'100'
R$'20'
R$'70'
R$'150'

'''
(A)'Caucaia'(1)' R$'50,00' ???' R$'80,00' ????'
(A)'Caucaia'(2)'
'
R$50,00'(Via'A)*' R$110,00(Via'B)' R$80,00'(Via'A)*' ????'
(A)'Caucaia'(3)'' R$50,00'(Via'A)*'
'
R$100,00(Via'D)'
'
R$80,00'(Via'A)*'
'
R$'150,00'(Via'D)'
'

'''
''
Fortaleza'(B)'
R$'50'
Caucaia'(A)'
Euzébio'(C)'
Itainga'(E)'
R$'80'
R$'90'
Maracanaú'(D)'
R$'60'
R$'20'
R$'70'
R$'150'
R$'140'
R$'40'

'''
(A)'Caucaia'(1)' R$'50,00' ???' R$'80,00' ????'
(A)'Caucaia'(2)'
'
(A)'Caucaia'(3)'' R$50,00'(Via'A)*'
'
R$100,00(Via'D)'
'
R$80,00'(Via'A)*'
'
R$'150,00'(Via'D)'
(A)'Caucaia'(4)' R$50,00'(Via'A)*' RS100,00(Via'D)*' R$80,00'(Via'A)*' R$'140,00'(Via'C)'
'

'''
(A)'Caucaia'(1)' R$'50,00' ???' R$'80,00' ????'
(A)'Caucaia'(2)'
'
(A)'Caucaia'(3)'' R$50,00'(Via'A)*'
'
R$100,00(Via'D)'
'
R$80,00'(Via'A)*'
'
R$'150,00'(Via'D)'
(A)'Caucaia'(4)' R$50,00'(Via'A)*' RS100,00(Via'D)*' R$80,00'(Via'A)*' R$140,00'(Via'C)*'
'

'''
''
Ainda'não'acabou.....'
E'se'eu'quiser'construir'uma'matriz'contendo'as'
menores'distâncias'de'todos'os'vérces'entre'
si?'
'
Solução1':'Poderíamos'rodar'o'algoritmo'de'
Dijkstra'n'vezes'mudando'o'ponto'de'origem'e'
desno.';n)'

'''
''
Solução2':'Algoritmo'de'Floyd''
(Robert'Floyd,'1962)'

'''
''
A' B'
R$'30'
R$'70'
R$'20'
R$'10'
C' D'
DePara (A) (B) (C) (D)
(A)''
(B)''
70' 10'
'
(C)''' 30'
(D)' 20'

'''
''
Idênco'os'algoritmo'de'Warshall.'
(A)''
(B)''
70' 10'
'
(C)''' 30'
(D)' 50' 20'
CnA''(30)''e''DnC'(20)'então'DnA'(50)'''

'''
''
(A)''
(B)''
60' 10'
'
(C)''' 30'
(D)' 50' 20'
DnA''(50)''e''BnD'(10)'então'BnA'(60)'''

'''
''
(A)''
(B)''
60' 30' 10'
'
(C)''' 30'
(D)' 50' 20'
DnC''(20)''e''BnD'(10)'então'BnC'(30)'''

'''
''
(A)''
(B)''
60' 30' 10'
'
(C)''' 30'
(D)' 50' 20'
Desta'vez'a'implementação'é'sua.'(Exercite)'

19.'Ulização'de'ED/Ordenamento'
'''
''

19.'Busca'Avançada:'Heuríscas'
'''
''

19.'Programação'Concorrente'em'Py'
(Threads)'
'''
''

'''
''
1. EDs''de'propósito'geral:''Matrizes'(vetores),'listas'ligadas,'
árvores,'tabelas'hash.'
2. EDs''especializadas:'pilhas,'filas,'filas'de'prioridades,'grafos'
3. Ordenamento:'Inserção,'shellsort,'quicksort,'mergesort,'
heapsort'
4. Grafos:'matriz'de'adjacências,'listas'de'adjacências'
5. Armazenamento'externo:'armazenamento'seqüencial,'
arquivos'indexados,'BnTrees,'Hashing'

'''
''
Usadas'para'armazenamento'geral'como'
registros'em'um'banco'de'dados.'São'elas:'
matrizes,'listas'ligadas,'árvores'e'tabelas'hash.'

'''
''
Início'
Conjunto'
de'Dados''
pequeno'
Tamanho'
previsível'
Pesquisa'e'
inserção'
muito'
rápida.'
Busca'mais'
importante'
que'
inserção.'
Garana'de'
aleatoriedade'
nas'chaves'
Lista'Ligada'
Matriz'
Tabela' Ordenada'
Hash'
Árvore'de'
pesquisa'
binária'
Matriz'não'
Ordenada'
Árvore'
Balanceada'
SIM'
SIM'
SIM'
SIM'
NÃO'
NÃO'
NÃO' NÃO'
NÃO'
SIM'

19.2'EDs'de'Propósito'Geral'
'''
ED Busca Inserção Deleção Atravessar
Matriz' O(N)' O(1)' O(N)' n'
Matriz'Ordenada'
O(log(N))' O(N)' O(N)' O(N)'
'
Lista'ligada' O(N)' O(1)' O(N)' n'
Lista'ligada'ordenada' O(N)' O(N)' O(N)' O(N)'
Árvore'binária'(Média)' O(log(N))'
'
O(log(N))'
'
O(log(N))'
'
O(N)'
'
Árvore'binária'(Pior'caso)'
'
O(N)' O(N)' O(N)' O(N)'
Tabela'hash' O(1)' O(1)' O(1)' n'

19.2'Eds'Especializadas'
'''
''
Normalmente'atrelada'a'um'algoritmo'que'
requer'explicitamente'este'po'de'estrutura.'
Por'exemplo'busca'em'profundidade'em'
grafos'requer'uma'pilha,'enquanto'busca'em'
largura'requer'uma'fila.'

'''
''
Pilhas,'filas'e'listas'com'prioridades'são'pos'de'
dados'abstratos'normalmente'implementados'
ulizando'matrizes,'listas'ligadas'ou'heaps.'

'''
''
Normalmente'estas'estruturas'apresentam'uma'
interface'que'permite'a'inserção'e/ou'deleção'
de'um'elemento.'

'''
''
Estes'itens'são:'
Em'pilhas:'' ' ' 'O'úlmo'elemento'inserido'
Em'filas:' ' ' ' 'O'primeiro'elemento'
inserido'
Prioridades:' ' ' 'O'elemento'com'a'maior'
prioridade.'
'

'''
ED Busca Inserção Comentário
Pilha'
(Matriz'ou'lista'ligada)'
O(1)' O(1)' Apaga'o'úlmo'item'inserido'
Fila'
(Matriz'ou'lista'ligada)'
'
O(1)' O(1)' Apaga'o'item'mais'ango'
Fila'com'prioridades'
(Matriz'Ordenada)'
O(N)' O(1)' Apaga'o'item'com'a'mais'alta'
prioridade'
'
Fila'com'prioridades'
(Heap)'
O(log(N))' O(log(N))' Apaga'o'item'com'a'mais'alta'
prioridade'

19.3'Ordenamento'
'''
Método Média Piorcaso MemóriaExtra
Bolha' O(N2)' O(N2)' Não'
Seleção'
O(N2)' O(N2)' Não'
'
Inserção' O(N2)' O(N2)' Não'
Shellsort' O(N3/2)' O(N3/2)' Não'
Quicksort' (N*LogN)' O(N2)'
'
Não'
Mergesort' (N*LogN)'
'
(N*LogN)'
'
Sim'
Heapsort' (N*LogN)'
'
(N*LogN)'
'
Não'

19.4'Grafos'(Modelam'o'mundo'real)'
'''
Método Média Obs
Busca'em'Profundidade/
Largura'
O(V2)' V'='Número'de'vérces.'Usando'matriz'
de'adjacências'
Idem'
'
O(V'+'E')' E'='Número'de'eixos.'Representação'na'
forma'de'listas'de'adjacências'
AGM'' O(V2)' V'='Número'de'vérces.'Usando'matriz'
de'adjacências'
Idem'' O((V+E')logV')' E'='Número'de'eixos.'Representação'na'
forma'de'listas'de'adjacências'

19.5'Armazenamento'Externo'
'''
''
Início'
Velocidade'é'
importante?'
Velocidade'é'
críca'
Dispõense'de'
espaço'extra'para'
armazenamento?'
Pesquisa'
Sequencial'
BnTrees'
Hashing'
Externo'
Arquivos'
Indexados'
SIM'
SIM'
NÃO'
NÃO'
NÃO'
SIM'

19.'Problemas'Intratáveis'(Insolúveis)'
'''
'' O
'Caixeiro'Viajante:'Percorrer'todas'as'cidades'e'
voltar'ao'ponto'de'origem'minimizando'o'
percurso.'
Aquiraz'(F)'
Fortaleza'(B)'
Caucaia'(A)'
Euzébio'(C)'
Itainga'(E)'
Maracanaú'(D)'
'''''.........'

'''
''
Quantos'caminhos'eu'posso'trilhar'(Devo'
examinar)'para'6'cidades?'
(A)' (B)' (D)' (E)' (C)' (F)' 6'opções'pra'começar'
X'
5'remanescentes'para'cada'
X'
4'remanescentes'nível'2'
X'
3'Remanescentes'nível'3'
X'
2'Remanescentes'nível'4'
X'
1'Remanescente'nível'5'
=720''(6!)''
(B)' (D)' (E)' (C)' (F)'
(D)' (E)' (C)' (F)'
(E)' (C)' (F)'
(C)' (F)'
(F)'

'''
'' Uma'pequena'tabela:'
N N!
6' 720'
10' 3.628.800'
20' 2,43'x'1018'
30' 2,65'x'1032'
40' 8,15'x'1047'
50' 3,04'x'1064'

'''
''
NP''n'Completo'
NP'='Non'Determinisc'Polinomial'Time'
'
Tempo'Polinomial'Não'Determinísco.'
'

19.'Heuríscas'
'''
''
Nem'sempre'sabemos'a'distância'exata'do'ponto'
de'chegada.'
(B)'
f(B)'='10'
(C)'
f(C)=15'
(D)'
f(D)=5'
(E)'
f(E)=6'
(F)'
f(F)=8'
Desenvolvense'uma'função'aproximava'(ou'não)'que'nos'dá'uma'esmava'
da'distância'do'nó'atual'ao'desno.O'Algoritmo'que'sempre'escolhe'a'melhor'
opção'é'chamado'de'algoritmo'guloso'e'esta'busca'é'chamada'de'busca'gulosa.''

19.'Heuríscas'
'''
''
A*'(Peter'Hart,'Nils'Nilsson,'e'Bertram'Raphael,'1968)'
(B)'
f(B)'''='10'
g(B)''='5'
h(B)''='15'
(C)'
f(C)=15'
g(C)''='6'
h(B)''='21'
(D)' (E)'
'
(F)'
'
A*'encontra'um'caminho'ómo'usando'uma'função'heurísca'que'soma'o'
caminhos'já'percorrido'mais'a'esmava'de'distância'até'a'meta.'
g(n)'é'a'distância'percorrida'e'f(n)'é'a'esmava'até'a'meta.'h(n)'='f(n)'+'g(n)'

19.'Heuríscas'
'''
''
Próximo'Curso:'Inteligência'Arficial'
Solução'de'Problemas'por'meio'de'busca.'Jogos.'Metaheuríscas.'etc'etc....'

19.'Programação'Concorrente''
Programa'A'
Parte'1'
' ' 'instruções'1'
'
Parte'2'
' ' 'instruções'2'
Parte'3'
' ' 'Instruções'3'
'
'''
''

Threads'
'
'''
''
Linha'de'execução'é'uma'forma'de'um'processo'dividir'a'si'
mesmo'em'duas'ou'mais'tarefas'que'podem'ser'executadas'
“simultaneamente”.'
'
Em'hardwares'com'múlplas'CPUs'ou'mulncores'as'linhas'de'
execução(Threads)'podem'ser'realizadas'realmente'de'forma'
simultânea.'

Threads'em'Python'
'
'''
''
Implementadas'através'do'módulo'thread.py'ou' ''
'
através'do'módulo'threading.py.'

Threads'em'Python.'Usando'thread'
'
'''
''
Passo'1'
'
Import'thread'

Threads'em'Python'–'Usando'thread'
'
'''
''
Passo'2'
'
#'definir'uma'função'qualquer'com'seus'argumentos'
def'funcaoLinhaExecucaoSeparada(nome,contador,temp):'
'....'
'....'
'....'
'....'

Threads'em'Python'–'Usando'thread'
'
'''
''
Passo'3'
'
#Em'algum'lugar'do'corpo'do'programa'principal'chamar'a'função'
# 'thread.start_new_thread(funcao,argumentos)'
'
thread.start_new_thread(funcaoLinhaExecucaoSeparada,'(Linha$1$,$5,$1))'
'
Programa79.py'

Condições'de'corrida'(Race'Condions)'
'
'''
''
#'Seja'uma'variável'x''
x'='2'
'
#'Seja'uma'linha'A'
def'linhaA():'
'...'
'x'='x+3'''
Qual'o'valor'final'de'X????''''''2,'4,'5,'10,'7,'''
'
#'Seja'uma'linha'B'
def'linhaB():'
'...'
'x'='2*x'''
'
Programa80.py'

Threads'em'Python'–'Usando'threading'
'
'''
''
Semelhante'a'API'Java'
''
#'definir'uma'sub'classe'para'a'classe'threading.Thread'
class'X(threading.Thread):'
'
'....'
'....'
'....'

'
'''
''
No'construtor'da'classe'devense'chamar'o'da'classe'pai.'
''
'def''__init__(self,'....):'
' 'threading.Thread.__init__(self)'
'....'
'....'
'....'

'
'''
''
Definense'o'método'run'que'será'executado'na'chamada'da'
função'start()'
''
'def''run(self,'....):'
' '….'
'....'
'....'
'....'

'
'''
''
Em'algum'lugar'do'programa'crianse'um'objeto'da'classe'X.'
''
'obj'='X()'
'....'
'....'
'....'

'
'''
''
Chamanse'o'método'start'do'objeto.'Como'resultado'a'função'
run'do'objeto'será'executada.'
''
'obj.start()'
'....'
'....'
'....'
Programa82.py'

Projetos'–'Cliente'Servidor'em'Python'
'
'''
''
Cliente'A:'
..........'
'
Cliente'B:'
...........'
'
Servidor'
'
'
'
'
Thread'A'
Thread'B'

'
'''
''
Cliente'A:'
Socket'
'
import'socket''
#'create'Internet'TCP'socket'16'
s'='socket.socket(socket.AF_INET,socket.SOCK_STREAM)''
'
s.connect((host,'port))''
'
s.send(k)''
Resposta'='s.recv(n)''
s.close()''

'
'''
''
Servidor'
Socket'
Thread'
'
Import'thread'
Import'socket'
'
Loop'de'espera'
While'1:'
'recebe'do'socket'e'chama'as'funções'de'tratamento'
…'
'
Nas'funções.'
'Cria'um'thread'para'cada'cliente'
'

O'desafio'é'seu.'
'
'''
''

20.'Programação'Gráfica'em'Python'
'''

'''
Usando'o'Tkinter'
Biblioteca'de'funcionalidades'gráficas'baseada'em'Tcl/Tk.'
Acompanha'as'distribuições'Python'

'''
Usando'o'Tkinter'
Import'Tkinter'
Tkinter._test()'
from'Tkinter'import'*'
root'='Tk()'
root.mainloop()'
'
'

'''
Componentes'de'um'programa'gráfico.'
• Funções'de'tratamento'de'eventos'(Event'handlers)'
• Função'de'desenho'da'interface'
• Loop'principal'(event'loop)'
'
'

'''
Exemplo'com'programa'de'texto.'
Programa83.py'

'''
Objetos'gráficos'de'trabalho.'
Containers'
widgets'
Canvas' Frames'

'''
Criando'um'Frame'
Frame'a'ser' Frame''Mestre'
criado'
minhaCesta'='Frame(pai)'

'''
Gerenciadores'de'Geometria'
Pack' Grid' Place'

'''
Passos'de'um'programa'mínimo.'
'
raiz'='Tk()'
'
cesta'='Frame(Raiz)''
'
cesta.pack()'
''''''''
raiz.mainloop()''
Importa'Tkinter'
Cria''Raiz'
Principal'Frame'
Aciona'
gerenciador'de'
layout'
Loop'principal'

'''
E'os'widgets?'
'
botao'='Bu|on(cesta)'
'
botao[“text”]='“Ola'rapaziada˜'
botao[“background”]='“blue˜'
'
botao.pack()'
''''''''
raiz.mainloop()''
Criar'widget'
Define'
propriedades'
do'widget'
Aciona'
gerenciador'de'
layout'
Loop'principal'
Programa84.py'

'''
Aplicação'Classe'ou'Classe'aplicação?'
'
class'MinhaAplicacao:''
'def'__init__(self,'meuPai):'
' 'self.minhaCesta'='Frame(meuPai)''
' 'self.'minhaCesta.pack()'
' 'self.botao1'='Bu|on(self.'minhaCesta)'
' ' 'self.'botao1[text]='”Alo'rapaziada!''
' 'self.'botao1.pack()'
raiz='Tk()'
minhapp'='MinhaAplicacao(raiz)''
raiz.mainloop()'
Programa85.py'

'''
Múlplos'botões'e'formas'de'manipulánlos.'
'
class'Aplicacao:
''''def'__init__(self,(pai):(
''''''''self.cesta$=$Frame(pai)$
''''''''self.cesta.pack()''''''''
''''''''self.botao1$=$Buaon(self.cesta)$
''''''''self.botao1[text]$=$Alo$rapaziada!$
''''''''self.botao1.pack()$$$$
''''''''self.botao1.pack(side=LEFT)$$
$
$self.botao2$=$Buaon(self.cesta)$
''''''''self.botao2.configure(text=texto$bobo$qualquer)$
''''''''self.botao2.pack()$$$$$
$$$
'
'''''''''
Programa86.py'

'''
Múlplos'botões'e'formas'de'manipulánlos.'
'
Programa86.py'
'
''''''''self.botao3$=$Buaon(self.cesta)$
''''''''self.botao3.configure(text=Vai$entrar$nessa?)$
''''''''self.botao3.pack(side=LEFT)$$$$$''''''''
''''''''self.botao4$=$Buaon(self.cesta,text=Adeus!)$
'''''''''
raiz'='Tk()'
ap'='Aplicacao(raiz)'
raiz.mainloop()'

'''
Bindings:'Conectando'eventos'a'funções.'
'
'
''''''''widget.bind(nome_do_po_de_evento,$função_que_encaminha_eventos)'
Programa87.py'
Event'Listener'

'''
Eventos'do'Teclado'
'
'
Etapas:'
1. Obter'o'foco'para'o'widget'que'vai'tratar'o'evento'
2. Criar'um'“event'biding”'entre'o'evento'sobre'aquele'widget'e'uma'função'específica'
'
OBS:'A'função'focus_force()'ajusta'o'foco'para'o'widget'que'a'chama.'
Programa89.py'

'''
Lista'de'Eventos'
'
Bu|onn1,'B1nMoon,'Bu|onReleasen1,'DoublenBu|onn1,'Enter,'Leave,'
'Return'Key'aShi¢nUp'Configure'
''''
''
''
'''
''
''

'''
Que'widgets?'
'
Bu|on,'Canvas,'Checkbu|on,'Entry','Frame,'Label,'LabelFrame','Listbox','Menu,'
Menubu|on,'Message','OponMenu',PanedWindow','Radiobu|on','Scale','Scrollbar,''
Spinbox,'Text,'Toplevel'
''
Existem'extensões'na'Web.''

'''
Comparlhando'Dados'entre'Event'Handlers'
'
Possibilidade'1':'Usar'variáveis'globais.'
'
def''event_handler'
'global'var1,...,varn'
'
Possibilidade'2':'Usar'variáveis'de'instância'(POO)'
'
'self.var1,'...,self.varN'
''

'''
Comparlhando'Dados'entre'Event'Handlers'
'
Possibilidade'1':'Usar'variáveis'globais.'
'
def''event_handler'
'global'var1,...,varn'
'
Possibilidade'2':'Usar'variáveis'de'instância'(POO)'
'
'self.var1,'...,self.varN'
''
Programa92.py'

'''
Passando'argumentos'para'os'event'handlers'
'
'''
self.bu|onHandler'
'''
self.bu|onHandler()'
Isto'é'um'objeto'usado'como'
referência'para'uma'função.'
Isto'é'uma''chamada'explícita'para'
uma'função.'

'''
Solução'1:'Funções'Lambda.'
'
Funções'anônimas'simples'
'
z'='lambda'x,y:'x+y'
'
Ou'famílias'de'funções.'
'
def'incremento(n):'
'return'lambda'x:'n'+'x'
k'='incremento(10)'
k(0)'
K(1)'
'''

'''
Solução'1:'Funções'Lambda.'
'
Programa93.py'
'''

'''
Solução'2:''curry.'
'
self.bu|on1'=''
'
Bu|on(self.myContainer1,'command=curry(self.bu|onHandler,bu|on_name))'

'''
Solução'3:''Event'Binding/Event'Lambda.'
'
def'event_lambda(f,'*args,'**kwds'):'
'Escrevendo'lambda'numa'interface'mais'amigável''
''
'return'lambda'event,f=f,args=args,kwds=kwds:'f(*args,**kwds)'
'
self.bu|on1.bind(Return,''
'event_lambda(self.bu|onHandler,bu|on_name,1,Good'stuff!))'

Aula'21'–'Programação'WEB'
'''

Aula'21'–'Python'WEBn'Django'
'''
h|p://www.ops.com/zap:8080'
Envia'Solicitação'ao'Servidor'
Prepara'Documento''
Estáco':'Arquivos'html,'
imagens,'etc'
Dinâmico'
Envia'Resposta'(Documento)'
Chama'Programa'para'gerar'
conteúdo'
PHP' Python'
Java' Etc'
Devolve'conteúdo'gerado'

'''
Servidor'Web'
Servidor'de'Aplicação'
Servidor'Bancos'de'
Dados'

'''
1'a'N'Máquinas.'
'

'''
Fases'
'
Desenvolvimento'
'
Testes'
'
Deploy'
'
Uso'em'Ambiente'de'
Produção'
'

'''
Ambiente''
de''
Desenvolvimento''
E'
Testes'
''''''
Ambiente''
de''
Produção.'
Desenvolvedores'
Clientes'

Logica programacao python-slides

Mais conteúdo relacionado

Mais procurados

Destaque

Semelhante a Logica programacao python-slides

Mais de ronaldo ramos

Último

Logica programacao python-slides