<jupyter_start><jupyter_text>Exemplos da Aula 01 Introdução à PythonQual é o seu domínio da linguagem python? Faça os exercícios abaixo, de acordo com a dificuldade encontrada, escolha um nível de maturidade de python no Moodle. TT007 - Introdução à Ciência de DadosCriado por: <NAME> ---  Exercício 01Escreva um programa que leia um número inteiro positivo (n) do usuário e, em seguida, exiba a soma de todos os inteiros de 1 a n. A soma dos primeiros n inteiros positivos pode ser calculado usando a fórmula: sm = n(n+1)/2<jupyter_code># Lendo inteiro do teclado
n = int(input('Numero: '))

# Computando a soma
sm = (n * (n + 1)) / 2

# Print do resultado
print(f'A soma dos números naturais 1 a {n} é: {int(sm)}')<jupyter_output>A soma dos números naturais 1 a 15 é: 120<jupyter_text>Exercício 02Crie um programa que leia três inteiros do usuário e os exiba de forma ordenada (do menor ao maior). Use as funções mínimo e máximo para encontrar o menor e maiores valores. O valor médio pode ser encontrado calculando a soma de todos os três valores e, em seguida, subtraindo o valor mínimo e o valor máximo.<jupyter_code>a = int(input(f'First number: ').strip())
b = int(input(f'Second number: ').strip())
c = int(input(f'Third number: ').strip())

ma = max(a, b, c)
mi = min(a, b, c)

me = sum((a, b, c)) - (ma + mi)

print(f'\n{mi} -> {me} -> {ma}')<jupyter_output>0 -> 2 -> 15<jupyter_text>Exercício 03A maioria dos anos tem 365 dias. No entanto, o tempo necessário para a Terra orbitar o Sol é um pouco mais do que isso. Como resultado, um dia extra, 29 de fevereiro, está incluído em alguns anos para corrigir essa diferença. Esses anos são chamados de anos bissextos.As regras para determinar se um ano é ou não um ano bissexto são as seguintes:  * Qualquer ano divisível por 400 é um ano bissexto.  * Dos anos restantes, qualquer ano divisível por 100 não é um ano bissexto.  * Dos anos restantes, qualquer ano divisível por 4 é um ano bissexto.  * Todos os outros anos não são anos bissextos.    Escreva um programa que leia um ano do usuário e exiba uma mensagem indicando seja ou não um ano bissexto.<jupyter_code>def bissexto(year):
    """Verica se o número informado á um ano bissexto."""
    if year % 400 == 0:
        return True
    elif year % 100 == 0:
        return False
    elif year % 4 == 0:
        return True
    else:
        return False

y = input(f'Type a year: ').strip()
if y.isdigit():
    y = int(y)
    resp = bissexto(y)
    if resp:
        print(f'{y} is leap (bissexto)')
    else:
        print(f'{y} is not leap (bissexto)')<jupyter_output>2012 is leap (bissexto)<jupyter_text>Exercício 04A duração de um mês varia de 28 a 31 dias. Neste exercício, você criará um programa que lê o nome de um mês do usuário como uma string. Então seu programa deve exibir o número de dias naquele mês. Exibir “28 ou 29 dias” para fevereiro, para que os anos bissextos sejam considerados.<jupyter_code>d = {
    'Janeiro': '31',
    'Fevereiro': '28 or 29',
    'Março': '31',
    'Abril': '30',
    'Maio': '31',
    'Junho': '30',
    'Julho': '31',
    'Agosto': '31',
    'Setembro': '30',
    'Outubro': '31',
    'Novembro': '30',
    'Dezembro': '31'
}

m = input(f'Type a month: ').strip().capitalize()
if m in d:
    print(f'{m} has {d[m]} days in it')
else:
    print(f'Invalid month')<jupyter_output>Fevereiro has 28 ou 29 days<jupyter_text>Exercício 05Um dos primeiros exemplos conhecidos de criptografia foi usado por <NAME>. César precisava fornecer instruções escritas a seus generais, mas não queria que seus inimigos soubesse de seus planos se a mensagem caísse em suas mãos. Como resultado, ele desenvolveu o que mais tarde ficou conhecido como Cifra de César.A ideia por trás dessa cifra é simples, cada letra da mensagem original é deslocada em 3 lugares. Como resultado, A se torna D, B se torna E, C se torna F, D torna-se G, etc. As últimas três letras do alfabeto são colocadas em volta do começando: X torna-se A, Y torna-se B e Z torna-se C. Os caracteres que não são letras não são modificado pela cifra.Escreva um programa que implemente uma cifra de César. Permita que o usuário forneça o mensagem e a quantidade de deslocamento e, em seguida, exiba a mensagem deslocada. Garanta que seu programa codifica letras maiúsculas e minúsculas. Seu programa deve também suporta valores de deslocamento negativos para que possa ser usado para codificar mensagens e decodificar mensagens.<jupyter_code>def cesar_cipher(msg, desloc):
    new_msg = []
    for letter in msg:
        if letter.isalpha():
            if letter >= "a" and letter <= "z":
                pos = ord(letter) - ord('a')
                pos = (pos + desloc) % 26
                new_letter = chr(pos + ord('a'))
                new_msg.append(new_letter)
                
            elif letter >= "A" and letter <= "Z":
                pos = ord(letter) - ord('A')
                pos = (pos + desloc) % 26
                new_letter = chr(pos + ord('A'))
                new_msg.append(new_letter)
        else:
            new_msg.append(letter)
    enc_msg = "".join(new_msg)
    return enc_msg


m = input('Type a message: ').strip()
d = input('Choose a displacement: ').strip()

encrypted_msg = cesar_cipher(m, int(d))
print(f'Mensagem original: {m}\nMensagem cifrada: {encrypted_msg}')<jupyter_output>Mensagem original: cifra de ceZar 15$### Atacar pelo norte 85612W65215S
Mensagem cifrada: djgsb ef dfAbs 15$### Bubdbs qfmp opsuf 85612X65215T<jupyter_text>Exercício 06Escreva um programa que converta um número binário (base 2) em decimal (base 10). Seu programa deve começar lendo o número binário do usuário como uma string. Então ele deve calcular o número decimal equivalente processando cada dígito no número binário. Finalmente, seu programa deve exibir o número decimal equivalente.<jupyter_code>def converterb_d(n):
    decimal = 0
    n = str(n)
    n = n[::-1]
    tam = len(n)
    for i in range(tam):
        if n[i] == "1":
            decimal = decimal + 2**i
    return decimal

num = int(input('Enter a non-negative number: ').strip())
dec = converterb_d(num)
print(f'Binário: {num}\nDecimal: {dec}')<jupyter_output>Binário: 1101
Decimal: 13<jupyter_text>Exercício 07Este exercício examina o processo de identificação do valor máximo em uma coleção de inteiros. Cada um dos inteiros será selecionado aleatoriamente a partir dos números entre 1 e 100. A coleção de inteiros pode conter valores duplicados, e alguns dos números inteiros entre 1 e 100 podem não estar presentes.Pare um momento e pense em como você lidaria com esse problema no papel. Muitas pessoas verificariam cada inteiro em sequência e se perguntariam se o número que eles estão considerando atualmente é maior do que o maior número que eles viram anteriormente. Se for, então eles esquecem o número máximo anterior e lembram o número atual como o novo número máximo. Esta é uma abordagem razoável, e resultará na resposta correta quando o processo for executado com cuidado. Se vocês estivessem executando esta tarefa, quantas vezes você esperaria precisar atualizar o valor máximo e lembra de um novo número?Embora possamos responder à pergunta feita no final do parágrafo anterior usando teoria da probabilidade, vamos explorá-la simulando a situação. Crie um programa que começa selecionando um número inteiro aleatório entre 1 e 100. Salve este inteiro como o número máximo encontrado até agora. Depois que o inteiro inicial foi selecionado, gera 99 inteiros aleatórios adicionais entre 1 e 100. Verifique cada inteiro conforme é gerado para ver se é maior do que o número máximo encontrado tão longe. Se for, então o seu programa deve atualizar o número máximo encontrado e conte o fato de você ter feito uma atualização. Exibir cada inteiro depois de você gerá-lo. Inclua uma notação com os inteiros que representam um novo máximo.Depois de exibir 100 inteiros, seu programa deve exibir o máximo valor encontrado, junto com o número de vezes que o valor máximo foi atualizado durante o processo. A saída parcial do programa é mostrada abaixo, com… representando os inteiros restantes que seu programa exibirá. Execute o seu programa várias vezes. É o número de atualizações realizadas no valor máximo o que você esperava?<jupyter_code>import random

# Função para gerar numero aleatorio entre 1 e 100
def choose_num():
    n = random.randint(1, 100)
    return n


# Escolher primeiro numero maximo
maxi = choose_num()
print(f'{maxi} *')

# Variavel para atualizacao
num_update = 0


for i in range(0, 99):
    number = choose_num()
    if number > maxi:
        print(f'{number} <== Update')
        maxi = number
        num_update += 1
    print(number)

# Mostrar resultados gerais
print(f'The maximum value found was {maxi}')
print(f'The maximum value was updated {num_update} times')<jupyter_output>54 *
71 <== Update
71
91 <== Update
91
70
89
94 <== Update
94
42
77
60
91
9
72
61
70
72
63
8
89
65
22
9
32
34
46
52
59
97 <== Update
97
71
58
52
28
68
11
55
39
67
77
54
74
91
66
84
56
17
73
53
7
4
9
75
35
81
51
26
88
99 <== Update
99
23
64
4
10
55
93
87
79
26
90
76
79
87
51
10
25
44
20
6
79
27
39
57
99
79
46
22
55
27
37
85
26
8
66
59
68
79
4
80
93
79
2
29
36
The maximum value found was 99
The maximum value was updated 5 times
{'fraction_non_alphanumeric': 0.07617504051863858, 'fraction_numerical': 0.04073473797947055, 'mean_word_length': 3.621068397403894, 'pattern_counts': {'":': 3, '<': 32, '<?xml version=': 0, '>': 31, 'https://': 0, 'lorem ipsum': 0, 'www.': 0, 'xml': 0}, 'pii_count': 0, 'substrings_counts': 0, 'word_list_counts': {'cursed_substrings.json': 0, 'profanity_word_list.json': 0, 'sexual_word_list.json': 0, 'zh_pornsignals.json': 0}}
{'chain_length': '7', 'dir': 'jupyter-structured-clean-dedup', 'id': '269852', 'license': 'MIT', 'n_tokens_mistral': 3529, 'n_tokens_neox': 3302, 'n_words': 1352, 'path': 'Aula01-introducao/exemplos-aula.ipynb', 'repo_name': 'matheuspercario/TT007-IntroducaoDatascience', 'size': '9277'}