Como Escrever em um Arquivo: write() e Modos de Abertura

Neste tutorial de nosso Curso de Python, vamos mostrar como fazer para escrever algo em um arquivo via programação Python e modos de abertura de arquivos.

• Apostila Python Progressivo em PDF

Caso deseje trabalhar e ganhar dinheiro como programador Python:

• Certificado do Curso de Python

Como Escrever em um Arquivo: Método write()

A palavra print em inglês significa imprimir.

Quando usamos a função print é porque estamos imprimindo, escrevendo na tela do shell e na tela de seu computador, é uma maneira de escrever.

Outra maneira de printar ou escrever é fazendo isso em arquivos. Ou seja, escrevemos via script Python dentro de um arquivo.

Mas, antes, precisamos ver o que é modo de abertura.

Modos de Abertura

Quando falamos em abrir arquivos via função open() fazemos somente:

open(caminho)

Onde caminho é uma string com o endereço do arquivo que queremos abrir.

Porém, isso é o mesmo que fazer:

• open(caminho, 'r')

Esse r é de read, ou seja, leitura. É um modo de abertura, significa que estamos abrindo um arquivo para leitura, ou seja, modo de abertura read.

Nesse modo, podemos apenas ler os dados de um arquivo, não podemos alterar nada.

Escrevendo em Arquivos: write() e 'w'

Antes de escrevermos em um arquivo, precisamos abrir ele no modo escrita.

Para isso, fazemos:

• open(caminho, 'w')

Em seguida, para escrevermos uma string em um arquivo de nome file.txt usamos o método write(), de objetos de tipo File.

Por fim, temos sempre que fechar o arquivo, ao término do script, através do método close().

O seguinte código Python escreve a string "Curso Python Progressivo" no arquivo file.txt:

meuArquivo = open('file.txt', 'w')
meuArquivo.write("Curso Python Progressivo")
meuArquivo.close()

Agora vá lá na pasta que está o seu script Python e veja que apareceu um arquivo de nome file.txt

Abra ele e veja que vai estar escrito lá dentro:

"Curso Python Progressivo".

Prontinho! Você acabou de escrever, printar uma string dentro de um arquivo em seu computador.

Detalhe para uma coisa: se você abrir e escrever em um arquivo que não existe, ele cria esse arquivo.

Adicionando Informações em um Arquivo: Modo append, 'a'

Agora temos um arquivo de nome file.txt e dentro dele teme scrito "Curso Python Progressivo".

Vamos escrever outra frase nele:

"O melhor curso de Python"

Repetimos o código:

meuArquivo = open('file.txt', 'w')
meuArquivo.write("O melhor curso de Python")
meuArquivo.close()

Agora vá lá e leia o que está escrito:

"O melhor curso de Python"

Epa!!!! Alto lá!!!

Cadê a string "Curso Python Progressivo" ? Queríamos adicionar uma string, e não substituir o que tinha lá.

Pois é, ao usar o modo de abertura write 'w', ele sobrescreve o arquivo, caso ele já exista.

Ou seja, apaga e cria um novo, com essa nova informação.

Para ADICIONAR, vamos usar o modo de adição (append mode), simbolizado por 'a' quando formos abrir nosso arquivo.

Repita o código lá de cima, com:

meuArquivo = open('file.txt', 'w')
meuArquivo.write("Curso Python Progressivo\n")
meuArquivo.close()

Agora, modifique seu código para:

meuArquivo = open('file.txt', 'a')
meuArquivo.write("O melhor curso de Python")
meuArquivo.close()

E abra o arquivo de texto:

Voilá! Adicionamos mais uma string, sem apagar o que tinha lá antes!!!

Tudo isso porque usamos o modo de abertura 'a'.

Modos de abertura de Arquivos em Python

• "a"  - Escreve ao final do arquivo; se este não existir, é criado
• "r"  - Abre o arquivo para a leitura, se não existir, lançar um eerro de IOError
• "r+" - Abra um arquivo para leitura e escrita. Se não existe, lança um erro IOError
• "w"  - Abre um arquivo para escrita. Se existe, ele 'trunca' tudo e escreve por cima. Se não existir o arquivo, ele cria
• "w+" - Abre para leitura e escrita. Se existe, apaga todo conteúdo e escreve por cima. Se não existir o arquivo, ele cria
• "ab", "rb", "r+b", "wb", "w+b" - Abre arquivos para trabalhar com entrada e saída no modo binário, para plataformas Windows e Macintosh

Recursividade em Python: Somatório e Fatorial Usando Função Recursiva

"Para aprender recursividade, você precisa saber recursividade..."

Essa frase pode soar bem louca, a primeira vista.
Mas quando te ensinarmos melhor o conceito de uma função recursiva, ela vai fazer total sentido para você.

Somatório na Matemática

Definimos como somatório, uma função matemática representada por:
f(x) = 1 + 2 + 3 + ... + (x-1) + x

Ou seja, somamos tudo de 1 até o valor x.
Exemplos:
f(4) = 1 + 2 + 3 + 4 = 10
f(5) = 1 + 2 + 3 + 4 + 5 = 15
f(6) = 1 + 2 + 3 + 4 + 5 + 6 = 21
etc

Porém, note uma coisa:
f(5) = f(4) + 5 = 10 + 5 = 15
f(6) = f(5) + 6 = 15 + 6 = 21

Ou seja, podemos generalizar:
f(x) = f(x-1) + x

Agora, calma.
Vamos ver o motivo dessa teoria toda.

Função Recursiva em Python

Dizemos que uma função é recursiva quando, dentro dela, ela chama ela mesma.
Porém, com outro argumento.

No exemplo anterior, passamos um valor x para a função recursiva.
Ela soma x com o valor de f(x-1), ou seja, ela vai chamar ela mesma, mas ao invés de passar o parâmetro x, vai passar o parâmetro x-1.

E essa função que recebeu x-1 vai somar (x-1) com f(x-2), ou seja, chamou ela mesma novamente, mas agora com um parâmetro (x-2). E por aí vai.

Onde termina isso?
Ora, com f(1) = 1

Somatório com Função Recursiva

Se ainda está perdido, tudo bem, é pra estar mesmo.
Mas vamos resolver um exemplo que vai te fazer entender melhor.

Crie um script que peça um inteiro positivo para o usuário.
Em seguida, exiba a soma do somatório de 1 até esse número.

Nosso código fica assim:

def somatorio(x):
    if x==1:
        return 1
    else:
        return x + somatorio(x-1)

while True:
    x = int(input("Somatorio de 1 até: "))
    print("Soma: ",somatorio(x) )

Agora vamos ver o que faz linha por linha.

Primeiro, definimos nossa função, vai se chamar somatorio e recebe um valor como parâmetro, o x.
A primeira coisa a se fazer numa função recursiva é definir onde ela vai parar, ou seja, dizer "ei, chega, aqui você vai parar de invocar você mesma"

Nesse caso, é quando o argumento for 1, aí o somatório é 1 e retorna 1.
Se não for argumento 1, ai cai no ELSE, então o retorno é o próprio argumento x somado de somatorio(x-1).

Lembra da função f(x)? Agora ela se chama é somatorio:
somatorio(x) = x + somatorio(x-1)

E prontinho, no cordo do script pedimos um número ao usuário.
Por exemplo, se x =4 :

Primeiro return: 4 + somatorio(3)
Segundo return: 4 + 3 + somatorio(2)
Terceiro return: 4 + 3 + 2 + somatorio(1)
Quarto return: 4 + 3 + 2 + 1 = 10

Fatorial com Recursividade

Para calcularmos o fatorial de um inteiro n, basta multiplicarmos todos os números de 1 até o próprio n. Expressamos o fatorial de n por n !

Por exemplo:

• 4! = 4*3*2*1 = 24
• 5! = 5*4*3*2*1 = 120
• 6! = 6*5*4*3*2*1 = 720

Agora note duas coisas:
5! = 5 * 4!
6! = 6 * 5!

Ou seja:
n! = n * (n-1)!

Implementando isso em código Python:

def fatorial(x):
    if x==1:
        return 1
    else:
        return x * fatorial(x-1)

while True:
    x = int(input("Fatorial de: "))
    print("Fatorial: ",fatorial(x) )

O ponto de parada é quando a função recebe 1 como argumento.
Aí ela retorna 1.

Se não for 1, retorna o valor do argumento x multiplicado pelo fatorial de (x-1)!

Exercício Proposto: Fibonacci

A série de Fibonacci é uma sequência de números, cujos dois primeiros são 0 e 1. O termo seguinte da sequência é obtido somando os dois anteriores. Faça uma script em Python que solicite um inteiro positivo ao usuário, n. Então uma função exibe todos os termos da sequência até o n-ésimo termo. Use recursividade.

Solução:
Gerar a sequência de Fibonacci

Argumentos e Parâmetros nas Função em Python

Neste tutorial de Python, vamos te explicar o que são argumentos e parâmetros, para que servem, como funcionam e como usar, um dos assuntos mais importantes desta seção de funções em Python.

Tutorial Anterior: Variável Local em Python
Veja também: Como se tornar programador profissional em Python

Argumentos e Parâmetros em Funções Python

No tutorial anterior, falamos das variáveis locais, no caso, dentro de funções.
Vimos que quando declaramos e usamos uma variável dentro de uma função, ela não é 'vista' do lado de fora.

Se tentar imprimir ou usar uma variável que está dentro do escopo de uma função, não vai conseguir. Nem o contrário, se estiver dentro de uma função, não vai conseguir usar variáveis e dados que estão fora da função.

Porém, isso contradiz o que falamos de funções, no início de nossos estudos sobre esse assunto, pois lá explicamos que elas se comunicam entre si, recebem dados, fazem tarefas específicas e retornam dados, ou seja, se comunicam.

Então, vamos aprender agora como fazer para funções se comunicarem com o mundo externo. Uma das maneiras de comunicação é através do uso de argumentos e parâmetros.

• Argumento

Argumento nada mais é que uma informação que passamos para uma função, quando chamamos ela. Enviamos dados (objetos) quando invocamos a função, e ela vai poder usar essas informações do jeito que quiser.

• Parâmetro

Quando você vai definir uma função e deseja que ela receba dados, você precisa definir parâmetros nessa função, um ou mais parâmetros. Uma forma de dizer que aquela função só funciona se receber determinadas informações (parâmetros).

Argumento e Parâmetro - Como Usar

Lembra quando ensinamos a declarar uma função?
Usamos a palavra-chave def, depois damos o nome da função e parêntesis?
E dentro desses parêntesis não tinha nada?




Pronto, agora a diferença vai vir aí.
Dentro desses parêntesis é que a magia vai ocorrer.

A nova definição é:

def nome_da_funcao(parametro1, parametro2, parametro3,...)
    código da função
    código da função
    código da função

Você pode usar quantos parâmetros quiser: um, dois, três...basta especificar na definição da função, o número de parâmetros que ela vai receber.
 
E para invocar, chamar essa função, você deve fazer:
nome_da_funcao(argumento1, argumento2, argumento3,...)

Ou seja, se a função foi declarada como tendo 'x' parâmetros, devemos passar 'x' informações, ou seja, 'x' argumentos ao invocar a função.

Exemplo de Função com Parâmetro

A função seguinte recebe um parâmetro, vamos chamar ele de x, em seguida mostra o dobro desse valor:

def dobro(x):
    dobro = 2*x
    print("Dobro =",dobro)

Para invocar essa função, precisamos fornecer um valor, por exemplo:
dobro(1)

Iremos ver a mensagem na tela: Dobro = 2
Neste caso, x é um parâmetro, pois está definido na função.
Já o valor 1 que passamos, é o argumento.

Vários Argumentos e Parâmetros

Você pode passar para uma função quantas informações desejar.
Pode passar 1 argumento, dois, dez, mil, 1 milhão... o que quiser.

Só é necessário fazer uma coisa: ao definir a função, deixar bem claro no cabeçalho dela quantos argumentos ela vai receber, colocando o número correto de parâmetros, bem como seus nomes e separados por vírgulas.




Por exemplo, a função a seguir vai receber dois argumentos, pois foi definida com dois parâmetros, x e y:

def soma(x,y):
    soma = x + y
    print("Soma =",soma)

Ela recebe dois argumentos e exibe a soma deles.

Na hora de invocar a função, devemos passar duas informações, ou seja, dois valores, dois argumentos, pois foi assim que a função foi definida, para receber dois dados! Por exemplo:

• soma(1,2)
• soma(-1,1)
• soma(21,12)

Se ela foi definida com n número de parâmetros, ela deve receber n número de argumentos, mais ou menos que isso, dará erro na sua função. Ok?

Exemplo de Função com Parâmetro e Argumento

Crie um programa que peça ao usuário dois valores. Estes números deverão ser repassados para uma função chamada calculadora, que vai mostrar a soma, subtração, divisão e multiplicação desses números.

Nossa função deve ter dois parâmetros. Vamos chamar eles de x e y.
Fora da função, vamos pedir dois números ao usuário e armazenar nas variáveis primeiro e segundo.

Em seguida, passamos essas variáveis como argumentos, para a função calculadora. Veja como ficou nosso código:

def calculadora(x,y):
    print("Soma          =",x+y)
    print("Subtração     =",x-y)
    print("Divisão       =",x/y)
    print("Multiplicação =",x*y)
    
primeiro = float(input("Primeiro número: "))
segundo  = float(input("Segundo número: "))

calculadora(primeiro,segundo)

Nomes de Parâmetros e Argumentos

Note uma coisa extremamente importante no exemplo anterior:
Passamos as variáveis primeiro e segundo como argumentos.

Porém, ao chegar na função calculadora, ela vai tratar esses valores com outros nomes de variáveis: x e y.

Na definição da função, os nomes dos parâmetros são x e y, então dentro da função, serão tratados apenas como x e y, embora tenha passado (1,2) ou (primeiro,segundo) ou (jose,joao) como argumento.

O nome dos argumentos não importa, vão virar o nome dos parâmetros, que você deixou bem claro ao definir sua função.

Exercício Resolvido de Funções com Parâmetros e Argumentos

Crie um script em Python que pede uma frase (string) ao usuário e em seguida um caractere. Em seguida, seu script deve dizer quantas vezes aquele caractere apareceu na frase digitar. Use função com parâmetros.

Primeiro, vamos definir nossa função, a conta_caractere.
Ele deve ter dois parâmetros o texto, que é uma string e char que é um caractere.

Vamos usar a variável interna count para contar quantas vezes char aparece na string texto, usamos um laço while para fazer isso, e cada vez que encontra, o contador é incrementado em uma unidade.

Usamos um laço for de uma maneira bem interessante, vejam:

def conta_caractere(texto,char):
    count = 0
    for letra in texto:
        if letra == char:
            count += 1
    print(char,"apareceu",count,"vezes na string")
    
string=input("Digite um texto qualquer: ")
caractere = input("Digite um caractere: ")

conta_caractere(string,caractere)

Os dados solicitados ao usuários foram armazenados nas variáveis string e caractere, que foram passadas como argumentos para a função conta_caractere. Simples, não?

Exercícios Propostos

01. Crie uma função que recebe um número e exiba seu quadrado.
02. Crie uma função que recebe um valor e exiba seu cubo.
03. Crie uma função que recebe 4 notas de um aluno, e exiba a média dele.
04. Crie uma função que recebe 3 números e exiba o maior deles.

Variável Local em Python - Curso Online Grátis

Seguindo nossos tutoriais sobre Funções em Python, vamos falar novamente em variáveis. No caso, variáveis locais, que possuem um comportamento diferente e bem interessante.

Como Trabalhar sendo Programador Python Profissional

Variável em Funções

Em praticamente todos os scripts que fizemos, usamos variáveis. Seja pra trabalhar com números inteiros, quebrados, strings etc, mas sempre usamos.

Usávamos em uma linha de código, depois alterávamos o valor em outra linha e por aí ia, sem mistério.

Mas quando começamos a trabalhar com funções, algo de diferente acontece.
Vamos ver um exemplo.

Vamos armazenar um valor na variável var dentro da função teste().
Colocamos o número inteiro 2112 dentro dessa variável e damos um print nesse valor, ainda dentro da função.

Fora da função, vamos simplesmente dar um print nessa variável, veja o código:

def teste():
    print("Estamos dentro da função!")
    var=2112
    print("Valor de var:",var)

teste()
print("Agora estamos fora da função!")
print("Valor de var:",var)

Agora veja o resultado:

Dentro da função...tudo ok! Definimos a variável, atribuímos um valor a ela, imprimimos e tudo certo.

Fora da função, não! Deu ruim!!! E agora?

Variável Local em Python

A explicação é muito simples: as variáveis dentro de uma função, não são visíveis fora da função.


Se você criou e usou uma variável dentro de qualquer função, ela só existe naquele escopo, ou seja, apenas ali dentro da função.

Quem está de 'fora', não sabe que ela existe, não sabe o que tem dentro da função.

Vamos fazer mais um teste, com 3 funções. Uma função chama a outra. E em cada função vamos usar uma variável de mesmo nome, a banda, veja:

def teste():
    banda="Rush"
    print("A melhor banda do mundo é ", banda)
    teste2()

def teste2():
    banda="Beatles"
    print("A melhor banda do mundo é ", banda)
    teste3()

def teste3():
    banda="Iron Maiden"
    print("A melhor banda do mundo é ", banda)

teste()

Ou seja, cada função é um 'universo'. Outras funções ou outro escopo, não sabem que se passam lá dentro, nestes casos.

Existem, porém, uma maneira de funções se comunicarem com outras.
Mas isso é assunto para o próximo episódio (sempre quis dizer isso).

Próximo tutorial: Parâmetro e Argumento em Funções Python

Função - Como Declarar, Chamar e Usar funções

Neste tutorial de nossa Apostila de Python online e grátis, vamos aprender como declarar uma função, além de ver como fazer para chamar ela, sempre que quisermos.

• Clique aqui para saber como Trabalhar e Ganhar dinheiro como Programador Python

Como Declarar uma Função: def

Parar criar uma função em linguagem de programação Python, precisamos fazer uma declaração correta e precisa dela.

O escopo da declaração de uma função é:

def nome-funcao(argumentos):
   código
   código
   ...
   return valor

A primeira linha é chamada de hearder ou cabeçalho. A definição da declaração da função começa com a palavra-chave def. O que vem após o def é o nome da função.

No nosso caso, o nome da função é nome-funcao.
Em seguida, um par de parêntesis, que pode conter argumentos (informações para a função usar).

Depois, os dois pontos. E abaixo, o código da sua função.
Por fim, a instrução return com alguma informação, um valor, para retornar para quem chamou a função.

Calma, com exemplos, e aos poucos, você vai entender tudo isso bem melhor.

Há duas coisas opcionais:
Argumentos (informações que você passa para a função, ao chamar ela)
Retornar valor (informações que a função retorna para quem chamou ela)

Como Chamar uma Função

Como você chama alguém? Uma pessoa, um amigo?
Pelo nome, correto?

Em funções, é a mesma coisa. Basta escrever o nome dela, e ela roda.
Simples assim.



Se declaramos uma função assim:

def lalala():
   código
   código

   ... 

O nome dela é lalala, não tem argumentos nem retorna nenhum valor.
Para chamar ela, fazemos com a seguinte linha de código:
lalala()

E pronto. Só isso. Vamos ver um exemplo de código real? 

Exemplo de código com Função

Crie um programa em Python que exibe a mensagem "Olá, mundo!"
Porém, essa mensagem deve rodar de dentro de uma função.

Vamos criar uma função chamada mensagem. O que ela faz é simplesmente exibir uma mensagem, um print.
 
Agora, basta chamar:
mensagem()

Pronto, só isso, veja como fica o código:

def mensagem():
    print("Olá, mundo")

mensagem()

Script de Python com Funções

Em todos nossos scripts e programas de Python, aconteceu uma coisa:
Ele rodava da primeira até a última linha.
Linha por linha.
Na ordem.

No exemplo de código anterior, não.
É definido uma função, tem um print...mas nada ocorre.

Só depois que chamamos a função (mensagem()), é que acontece algo.
Ou seja, o Python pula esses def, não roda ele de cara.

Aliás, se você não tivesse chamado a função via mensagem(), aquele código nem seria executado.

Quando chamamos uma função de nome nome(), o Python sai buscando no código uma def nome(), ou seja, ele sabe que você chamou uma função.

Então ele para tudo e vai buscar onde essa função foi declarada e executa ela.
Ok?

Pode ter  1 milhão de linhas de código com funções. Se elas não forem chamadas, simplesmente não executam.

Mas se tiver uma função de uma linha (como a do exemplo), e ela for chamada 1 milhão de vezes, ela é executada 1 milhão de vezes.

Ou infinita vezes. O código a seguir executa o Olá, mundo! infinitamente:

def mensagem():
    print("Olá, mundo")

while 1:
    mensagem()

Exemplo de Código com Funções

Crie uma função que pede dois números, faz a soma e exibe o resultado, através de uma função. O usuário pode executar a função quantas vezes desejar.

A função que soma será a soma(). Ela é bem simples, pede x, pede y, transforma tudo em float, soma na variável soma e exibe este valor. Pronto.
Função é isso, um código simples, pequeno e bem específico, nada mais, nada menos.

Agora vamos ao programa normal.
Talvez seja preciso chamar a função soma() várias vezes. Quem vai controlar isso é a variável continuar.

Inicialmente ela é 1 (verdadeiro ou TRUE).
Com um laço while, testamos o valor de continuar, como é 1, é TRUE, então o looping roda.

Dentro do laço, é testado o valor de continuar, se for verdadeiro, cai num IF que chama a função soma().

Inicialmente, é tudo verdadeiro, logo a função é invocada.
Ela roda normalmente e faz tudo bonitinho.

Depois, perguntamos ao usuário se ele deseja continuar a fazer mais somas. Se desejar encerrar o programa, basta digitar 0.
continuar vai ser 0, o laço while vai ter teste FALSO e não vai mais executar, encerrando o looping e o programa.

Se digitar qualquer coisa diferente de 0, o teste do laço while vai ser verdadeiro e vai rodar de novo.

Nosso código fica:

def soma():
    x = float(input("Primeiro numero: "))
    y = float(input("Segundo numero: "))
    soma = x + y
    print("Soma: ",soma)

continuar=1

while continuar:
    if(continuar):
        soma()
    continuar=int(input("Digite 0 se desejar encerrar ou qualquer outro numero para continuar: "))

Bacana, né?

Exemplo de Código com Funções

Faça uma calculadora, usando funções. O script pergunta qual operação o usuário deseja rodar (soma, subtração, multiplicação ou divisão) e executa a operação.

A calculadora deve ser executada quantas vezes o usuário desejar.

A ideia aqui é criar várias funções, e dependendo do que o usuário digitar, executar a função corretamente.

Veja a solução completa:
Calculadora em Python usando Funções

Programa que lê números, diz o maior, a soma e a média

Exercício resolvido de Python com código comentado, sobre como ler números, achar o maior valor, calcular a soma e a média.

Como se tornar um programador profissional Python

Exercício resolvido de Python

Código comentado

Faça um programa que leia 'n' números (maior que um), informe o maior, a soma e a média dos números.




Primeiro, perguntamos quantos números o usuário que inserir e armazenamos em 'numeros'.

O primeiro número fornecido é especial, digamos assim.
Como só foi fornecido ele, podemos dizer que é o maior até então.

O maior número é 'primeiro', bem como a soma total dos números digitados, 'soma', também é 'primeiro'.

Vamos usar uma variável de controle que vai de 1 até 'numeros', é a 'count'.

Os dados vão ser fornecidos dentro do loop WHILE.
Cada vez que alguém insere um novo número, na variável 'temp', eu checo se esse número é maior que 'maior', meu maior número armazenado.

Se for, o novo valor de 'temp' é esse número. Se não for, nada ocorre.

Cada vez que insiro esse novo número em 'temp', somo esse valor na soma total 'soma'.

Veja o código de nosso script Python:

numeros=int(input("Quantos numeros: "))

primeiro=int(input("Numero 1: "))

count=1
maior=primeiro
soma=primeiro

while count< numeros:
    count += 1
    temp=int(input("Numero %d: " % count))
    soma += temp
    if temp>maior:
        maior = temp
    
media = soma / numeros
print("Soma:",soma)
print("Maior:", maior)
print("Media: %.2f" % (soma/numeros))

Python - Gerar Todos os Palpites da Mega-Sena

Neste tutorial de nosso Curso de Python, vamos ensinar como criar um programa que exibe todos os palpites possíveis para se jogar na Mega-Sena.

Python e Programação

Faça um script em Python que exiba todos os possíveis palpites da Mega-Sena.
Dados:

1. Cada palpite possui 6 dezenas
2. As dezenas variam de 1 até 60
3. Não pode repetir dezena

Solução:

Existem diversos estudos e pesquisas que tentam usar a programação para ajudar, de alguma maneira, as pessoas sobre como ganhar na Mega-Sena.

Antes de iniciarmos a parte da programação Python, precisamos definir algumas coisas.

Vamos usar 6 variáveis, para representar as 6 dezenas da Mega-Sena, ok?
Elas serão:
dez1 dez2 dez3 dez4 dez5 dez6

A princípio, você poderia pensar:
Só usar laço FOR dentro de laço FOR, para cada uma das dezenas, variando de 1 até 60.

Parece um raciocínio que faz sentido.
Mas temos um problema: se fizer isso, você vai criar palpites com dezenas repetidas, experimente:


O script acima tem vários e vários palpites com dezenas repetidas:
1 1 1 1 1 1
1 2 3 4 5 5
etc etc

Podemos resolver isso deixando uma coisa bem clara:
O palpite "dez1 dez2 dez3 dez4 dez5 dez6" está em ordem crescente.

Ou seja:
dez1 > dez2 > dez3 > dez4 > dez5 > dez6

Isso quer dizer algumas coisas interessantes.
Por exemplo, a última dezena vai de 6 até 60.

Não tem como a última dezena ser 5, por exemplo.
Pois teríamos o menor palpite: 1 2 3 4 5...e a última dezena tem que ser 6 pra cima.

O grande segredo para esse tipo de questões é fazer com que:
dez2 > dez1
dez3 > dez2
dez4 > dez3
dez5 > dez5
dez6 > dez5

Ou seja, para dez1, vamos deixar o intervalo como range(60).
Já para dez2, o range deve começar de modo a ser sempre maior que dez1, e isso é feito assim: range(dez1+1, 60).

A dez3 deve ser sempre maior que dez2, isso é feito usando o seguinte intervalo: range(dez2+1,60), e assim sucessivamente.

Script Que Exibe Todos os Palpites da Mega-Sena

Nosso script fica então:

for dez1 in range(60):
    for dez2 in range(dez1+1,60):
        for dez3 in range(dez2+1,60):
            for dez4 in range(dez3+1,60):
                for dez5 in range(dez4+1,60):
                    for dez6 in range(dez5+1,60):
                        print(dez1+1,dez2+1,dez3+1,dez4+1,dez5+1,dez6+1)

Se você rodar o script acima, certamente vai levar um bom tempo para ver todos os possíveis palpites, que são mais de 50 milhões.

Ao invés de exibir todos, você pode usar um contador, para contar o número de possíveis palpites, veja:

total=0
for dez1 in range(60):
    for dez2 in range(dez1+1,60):
        for dez3 in range(dez2+1,60):
            for dez4 in range(dez3+1,60):
                for dez5 in range(dez4+1,60):
                    for dez6 in range(dez5+1,60):
                        total += 1
print(total)

Entrando no site oficial da Meg-Sena:
http://loterias.caixa.gov.br/wps/portal/loterias/landing/megasena/

Lá, na seção "Probabilidade", vemos que a chance de uma pessoa ganhar é de 1 em 50.063.860

Mas, hora, esse é o número que nosso programa calculou.
Ou seja, nosso script está correto.

Laço FOR em Python - Um loop controlado

Agora que já estudamos e aprendemos direitinho, em nosso Curso Python Progressivo, como usar o laço While, vamos aprender um outro loop, chamado FOR.

Laço FOR em Python - Como usar ?

Sem mais delongas, vamos mostrar como é a declaração e estrutura de um laço for, em Python:

for variavel in [val1, val2, val3, etc]:
    codigo
    codigo
    codigo

Funciona basicamente assim.
A variável 'variavel' vai assumir o valor da variável 'val1', e executa o código.

Em seguida, 'variavel' recebe o valor de val2, e executa o código. E assim sucessivamente, até 'variavel' ter recebido todos os valores da sequência.

Ou seja, nosso laço for tem três coisas:
A variável que vai receber os valores de uma sequência de dados
A sequência de dados
Código a ser executado em cada iteração

Diferente do loop WHILE, que apenas faz um teste (se for verdadeiro executa um código, se for falso, termina o loop), o loop FOR é dito controlado, pois vai executar um determinado número de vezes, que nós escolhemos previamente.

Vamos ver alguns exemplos de uso do laço FOR para firmar os conceitos, só ler essa abstração é meio...abstrato.

Exemplo 1 de uso do laço FOR em Python

"Crie um script em Python que imprima os números de 1 até 5 na tela."
 
Nossa sequência é: 1, 2, 3, 4, 5
Então, nosso código fica:

for val in [1,2,3,4,5]:
    print(val)

Sim, é só isso.
E mais simples é o funcionamento: a variável 'val' recebe o valor 1, e imprime. Depois recebe o valor 2, e imprime....por fim, recebe o valor 5 e imprime.

Como a variável percorreu todos os elementos da lista (esses valores entre colchetes se chamam list e estudaremos as listas com afinco, mais na frente em nosso curso), o laço for acaba.

Exemplo 2 de uso do laço FOR em Python

"Crie um script que imprime todos os dias da semana na tela."
 
Não é obrigatório usarmos números na sequência. Uma lista pode ser formada de strings, por exemplo.

Nosso código fica:

for dia in ['Segunda', 'Terça', 'Quarta', 'Quinta', 'Sexta', 'Sábado', 'Domingo']:
    print(dia)

Ou seja, a variável 'dia' recebe o valor de cada string e imprime na tela.

Exercício:

"Escreva um script que imprima os números de 1 até 1000."

"Nossa senhora, vou ter que usar a sequếncia [1,2,3,4,5,6,7,8,9...,1000] ???
Deus me livre!"

Calma, nobre cavaleiro Python. A programação veio para facilitar nossas vidas, e não o contrário.

Não precisa digitar os mil números, é para isso que serve o Python: trabalhar pra gente!

No próximo tutorial de Python, vamos aprender a usar a função range() do Python, que resolve esse problema e muitos outros.

A função range

Curso de Python com Certificado

Já imaginou ganhar dinheiro com Python?
Se, trabalhando e se tornando um programador Python profissional.

Pois é, pare de imagine e tome uma atitude pra isso se tornar realidade:
Curso de Python