Comandos de Controle de Fluxo em Loops

    for n in range(2, 11):
    if n % 2 == 0:
        pass
    else:
        print(n)

Texto original

O texto original pode conter falhas de gramática ou de concordância, isso ocorre porque ele foi obtido por um processo de extração de texto automático.

Texto extraído do video Algoritmos e Programação de Computadores I - Outros comandos: break, continue e pass

O Lá pessoal, novamente estamos aqui para a nossa próxima vídeo-ala de algoritmos e programação de computadores.
Essa é a continuação da nossa tema de estruturas de repetição.
A gente vai ver nessa vídeo-ala outros comandos que estão relacionados com repetição que são os comandos Brave, Continui e PES.
Vamos começar pelo comando Break.
Quando a gente encerre esse comando Break dentro de um loop que pode ser um for ou um for um raio, ele faz com que aquele laço seja finalizado.
Então, independente da condição de término do raio ou do número de repetições que você estipulou para o for, com o uso do Break, aquele laço vai ser finalizado querendo ou não.
Então, quando ele é chamado, aquele laço é finalizado e o fluxo continua a partir do bloco, não um inventado, logo em seguida, a estrutura de repetição.
Então, olha aqui um exemplo, alguns exemplos do For, para o uso do Break com um comando For.
Então, se uma determinada, aqui eu tenho o For que vai percorrer aquela sequência.
E aí, eu posso colocar uma determinada condição aqui dentro, onde eu digo que se aquela condição for verdadeira, eu executo Break.
E esse Break faz com que aquele laço, onde ele está inserido, que no caso é o For, seja finalizado.
Então, mesmo que a variável que em cima não tenha percorrido ainda toda a sequência, o laço é finalizado, ele termina e a fluxo parte vai aqui para que elas instruções daquele bloco não inventado.
Tá bom? A gente pode usar também o Break com o Aio e a mesma coisa.
Então, aqui eu tenho, nesse caso, aqui eu vou ter duas condições.
A condição normal do Aio, que a gente viu na aula passada, enquanto condição for verdadeira, ele executa aquelas instruções que estão dentro, que estão inventadas, que estão dentro do Aio.
Mas eu posso colocar um Break, ali dentro também, com uma condição, sendo que se aquela condição for verdadeira, ele vai entrar no isch, e lá dentro do isch eu tenho o Break, que faz com que o laço, quer dizer, o Aio, seja finalizado também.
É importante ressaltar aqui, pessoal, que se eu tiver loops alinhados e o Break que estiver dentro do loop mais interno, é apenas aquele loop interno que finaliza, o loop externo, ele continua execução.
Então, é apenas o loop mais interno ao qual o Break pertence é que vai ser finalizado, ou que está para fora, outros loops que estejam englobando esse alheio de dentro, ele continua execução.
Olha um exemplo aqui com o uso do Break, eu quero implementar uma função que verifica se um determinado número passado como o parâmetro é primo ou não, lembrando que números primos são aqueles que são divisíveis por um e por ele mesmo, apenas, e então eu posso definir uma função que vai verificar se todos os números de dois até o imediatamente anterior a ele, ação de vida em aquele número se dividir quer dizer que o número não é primo.
Vamos fazer esse exemplo aqui na prática para a gente ver o funcionamento.
Então, eu vou definir aqui uma função chamada de primo, que vai receber um determinado número, aqui dentro eu vou ter a minha variável y começando com dois, que vai de fato dividir aquele número que a gente passou, e então eu vou usar o I, enquanto o I, formenor do que número, a gente vai verificar se o resto da divisão de num por i é igual a zero.
Se isso acontecer quer dizer que o I divide o número, então quer dizer que esse número ele não é primo, então quando acontecer isso a gente pode inserir um break, porque não tem mais sentido, o I, eu continuo a sua execução, porque a gente já sabe que o número não é primo, porém, se ele não entrar nesse I, o I, ele não está dividindo o número, e aí a gente pode incrementar esse I, para continuar a verificação de todos os números até o número menos um.
Terminando o I, significa que nenhum valor de I divide o número, e aí a gente só retorna se I é igual a número, se I for igual a 1, significa que o I chegou aqui no número 1, também não dividiu, e aí o meu seu I foi incrementado com mais um, quer dizer, o I tem o valor de número, chegou aqui no I, eu vi o I, não é menor do que 1, ele é igual, e aí ele sai, então apenas quando o I é igual a 1 é quando o número é primo, e aí então a gente vai retornar simplesmente uma expressão lógica, no caso é expressão relacional, que retorna um valor lógico verdadeiro ou falso, indicado se se for primo ou não, então vamos rodar aqui, deixa eu, eu estou definindo aqui, então é o número primo, vou colocar aqui, por exemplo, no interpretador, a chamada de número primo do valor 6, por exemplo, ele retorna a C, é falso, porque 6 não é primo, mas o 7 ele é primo, o número 13, por exemplo, também é primo, e assim por diante, a gente tem um comando, continue, ele é, vamos dizer assim o contrário do break, ele quando inserido dentro de um loop, que é um for ou um I, o continue faz com que a nova interação do laço, quer dizer a interação seguinte daquele laço, seja forçada a partir daquele ponto onde o comando foi inserido, então olha só, no for eu tenho aqui o meu bloco, identificado, se eu inserir um continue ali dentro, num determinado ponto, por exemplo, nessa linha, isso faz com que você força a continuação da interação a partir daquele ponto, então quer dizer tudo que estiver abaixo do continue, no caso seria essa outra linha que está aqui, ela não vai ser executada na que é a letteração, então você força a nova interação com um novo valor de var, para a nova valora da sequência, pro I, é a mesma coisa, então se você inserir um continue ali, você força a nova interação do I, quer dizer ele vai verificar antes aqui o I, nessa é condição é verdadeira, e aí ele está forçando a execução, e aquilo tudo que estiver aqui para baixo, mesmo dentro do bloco inventado, ele não vai ser executado, bom vamos ver um exemplo, deu do continue, que é a continuação do exemplo anterior, então dá da função primo que a gente definiu lá com o break, a gente vai implementar agora um programa que vai imprimir todos os números primos de dois até 100, vamos lá, vamos fazer esse exercício aqui, então eu vou fazer agora aqui embaixo o uso de um for que vai percorrer todos esses números de dois até 100, e aí eu vou fazer assim, eu vou verificar se esse número não é primo, se ele não for primo, não tem, a gente não quer imprimir ele, então a gente vai chamar o continue, que é para forçar a execução, a próxima interação do for, onde o N vai receber o próximo valor, se ele não entrar nesse I, a gente vai imprimir o valor aqui na tela, se ele for primo, ele impreme, se não for primo, ele não vai imprimir porque a gente está forçando a nova interação aí para um valor de N, então está aqui a execução todos os números primos de dois até 100, legal, e aí a gente tem o comando pés, o comando pés pessoal é quando a gente tem uma estrutura que pode ser de condição, hoje repeticção, e por algum motivo a gente não quer colocar nenhuma instrução dentro, aí nesse caso ele não vai fazer nada, então o comando pés é simplesmente você adicionar um comando numa determinada linha, que não vai fazer nada, simplesmente vai ignorar aquela linha e vai partir para a próxima, então todos esses humanos, por exemplo, D, F, I, F, El, Seu, For, Eu, precisam necessariamente ter um bloco indentado que seja não vazio, mas pode ser que você tenha que definir aquele bloco, mas por algum motivo você não tenha ainda nenhuma instrução para inserir ali dentro, principalmente por exemplo quando você ainda não implementou ainda aquele bloco, que vai implementar depois no outro dia, mas você quer ainda que a execução executar o seu programa ainda mesmo sem ter definido aquele bloco, aí a gente usa o pés, então olha só, reparem nesse exemplo que eu estou colocando um NIFI1ELS, então esse IIFI tem que ter um bloco indentado, que no caso eu que estaria aqui, e ali dentro eu não quero implementar nenhuma função, nenhuma instrução nada, então eu uso o pés, então ele simplesmente se o IIFI for verdeiro, ele vai entrar nesse bloco indentado, mas não vai fazer nada porque o pés não faz nada, aí ele simplesmente ignora isso e vai pro bloco não indentado que é o que está ali na linha de baixo, então o pés, pessoal, pode se evitar, no caso você pode evitar esses casos onde precisaria do pés, então nesse caso que está aqui, simplesmente eu tirar esse IIFI e colocar um notch aqui, ou em vez de um notch colocar um diferente aqui, em vez de igual, e aí colocar o pinte aqui dentro, e aí eu não teria mais esse IIFI, mas como eu falei o pés em casos especiais, é onde você quer, te explícito aquele bloco, aquela condição, e mas você não tem ainda nenhuma instrução para inserir ali dentro, daí nesse caso você usa o pés, tá, Joy? Muito bem, então essa aí foi a nossa videoaula sobre esses comandos Brick, que continue e pés, essa foi foram as videoaulas sobre os comandos de repetição, e a gente vai continuar na próxima semana com mais um novo assunto aí referente a essa disciplina, então obrigado pela atenção de vocês e a gente se vê numa próxima, até lá!