Skip to content

Atividade on33s4 - Bruna Heleodoro #17

New issue

Have a question about this project? Sign up for a free GitHub account to open an issue and contact its maintainers and the community.

Sign up for GitHub

By clicking “Sign up for GitHub”, you agree to our terms of service and privacy statement. We’ll occasionally send you account related emails.

Already on GitHub? Sign in to your account

Open
BrunaHeleodoro wants to merge 1 commit into
base: main
Choose a base branch
from
Open

Atividade on33s4 - Bruna Heleodoro #17

Changes from all commits
Commits
Show all changes
1 commit
Select commit
File filter

Filter by extension

Filter by extension
Conversations
Failed to load comments.
Loading
Jump to
Jump to file
Failed to load files.
Loading
Diff view
Diff view
261 changes: 261 additions & 0 deletions bruna_heleodoro/bruna_heleodoro_atividade.ipynb
View file
Open in desktop
Original file line number Diff line number Diff line change
@@ -0,0 +1,261 @@
{
"cells": [
{
"cell_type": "markdown",
"metadata": {},
"source": [
"#### [Exercício 36](https://wiki.python.org.br/EstruturaDeRepeticao): Lógica utilizada para a construção da Tabuada com For in Range.\n",
"\n",
"* Criada a variável `num_usuário`, para armazenar o valor que será multiplicado;\n",
" \n",
"* Criada a variável `num_start`, para armazenar o valor que iniciará a tabuada;\n",
" \n",
"* Criada a variável `num_end`, para armazenar o valor que finalizará a tabuada;\n",
" \n",
"* Chamada a estrutura de repetição For in Range:\n",
" \n",
" * `for i in range(num_start, num_end + 1):` -> Aqui informo que a sintaxe básica do range(start, stop, step) utilizará os dados armazenados nas variáveis num_start e num_end. O acréscimo de + 1 em num_end garante que o valor final (num_end) seja incluído na sequência, pois o stop é exclusivo.\n",
" \n",
" * Exemplo: `num_start = 4` e `num_end = 8 -> range(4, 8)` gerará a sequência `[4, 5, 6, 7]`, pois 8 é exclusivo por ser o stop.\n",
" \n",
" * A atribuição do `+ 1` como argumento do stop garante que `num_end` seja incluído na sequência. Exemplo: `num_end + 1 -> num_end = 8 + 1 (9) -> [4,5,6,7,8] `."
]
},
{
"cell_type": "code",
"execution_count": null,
"metadata": {},
"outputs": [],
"source": [
"num_usuario = int(input('Informe um número que você gostaria de montar a tabuada: '))\n",
"num_start = int(input('Informe por qual número deve começar a tabuada: '))\n",
"num_end = int(input('Informe em qual número deve finalizar a tabuada: '))\n",
"\n",
"for i in range(num_start, num_end + 1):\n",
" print(f'{num_usuario} X {i} = {num_usuario * i}')"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"#### [Exercício 36](https://wiki.python.org.br/EstruturaDeRepeticao): Lógica utilizada para a construção da Tabuada com While.\n",
"\n",
"* Criada a variável `num_usuario`, para armazenar o valor que será multiplicado;\n",
" \n",
"* Criada a variável `num_start`, para armazenar o valor que iniciará a tabuada;\n",
" \n",
"* Criada a variável `num_end`, para armazenar o valor que finalizará a tabuada;\n",
"\n",
"* Criado a variável `s` e atribuindo à ela o valor que será recebido na variável `num_start`. Pois `s` é a variável utilizada como o contador na repetição.\n",
" \n",
"* Chamada a estrutura de repetição While:\n",
" \n",
" * `while s <= num_end:` -> Aqui inicio a repetição com While, informando que deve se começar com o valor em `s` e repita até o mesmo ser menor ou igual ao valor de `num_end`.\n",
" \n",
" * Dentro da estrutura eu peço `print(f'{num_usuario} X {s} = {num_usuario * s}')`, ou seja, que seja exibido o número que gostaria de montar a tabuada armazenado na variável `num_usuario` X o valor armazenado na variável `s`, mais o calculo de multiplicação desses valores.\n",
" \n",
" * E a operação de atribuição em `s += 1`, realiza o incremento na váriavel `s` para a mesma ir avançando nos valores até o valor definido na variável `num_end`."
]
},
{
"cell_type": "code",
"execution_count": null,
"metadata": {},
"outputs": [],
"source": [
"num_usuario = int(input('Informe um número que você gostaria de montar a tabuada: '))\n",
"num_start = int(input('Informe por qual número deve começar a tabuada: '))\n",
"num_end = int(input('Informe em qual número deve finalizar a tabuada: '))\n",
"\n",
"s = num_start\n",
"\n",
"while s <= num_end:\n",
" print(f'{num_usuario} X {s} = {num_usuario * s}')\n",
" s += 1"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"#### [Exercício 38](https://wiki.python.org.br/EstruturaDeRepeticao): Lógica utilizada para a construção do Sistema de Consulta de Salário com For in Range.\n",
"\n",
"* Criada a variável `ano_contrato` para armazenar o ano em que o colaborador foi contratado;\n",
" \n",
"* Criada a variável `salario_inicial` para armazenar o salário inicial do colaborador;\n",
" \n",
"* Criada a variável `ano_atual` para armazenar o ano atual vigente;\n",
" \n",
"* Criada a variável `porcentagem_inicial` para armazenar a porcentagem de aumento aplicada no salário inicial;\n",
" \n",
"* Criada a variável `primeiro_aumento` para armazenar o cálculo do aumento ocorrido no salário inicial do colaborador:\n",
" \n",
" * `round((), 2)` - aplicado o arredondamento para que o resultado do cálculo retorne arredondado para duas casas decimais;\n",
" * `porcentagem_inicial / 100` - cálculo que converte o percentual de aumento de forma percentual (por exemplo, 1,5%) para uma fração decimal (0,015). A escolha do cálculo veio da realização de consultas para verificar que o Python padrão não apresenta um operador específico para calcular aumentos percentuais diretamente;\n",
" * `(1 + porcentagem_inicial / 100)` - a adição de 1 ao cálculo de conversão de um formato percentual para uma fração decimal é necessária porque representa o valor original. Por exemplo, se quisermos aumentar o `salario_inicial` em `1,5%`, é necessário adicionar `1` a `0,015`, resultando em `1,015`;\n",
" * `(salario_inicial * (1 + porcentagem_inicial / 100))` - por fim, é realizado o cálculo onde o `salario_inicial` é multiplicado pelo fator calculado `1 + porcentagem_inicial / 100`;\n",
"* Chamando a estrutura de repetição For in Range():\n",
" \n",
" * `for ano in range(1997, ano_atual + 1):` - conforme solicitado pelo exercício, aplicado no range com início em 1997, pois é a partir deste ano a solicitação, e finalizando no ano atual. Assim, para cada `ano` dentro da faixa de 1997 a 2024, o bloco de código a seguir será executado;\n",
" * `porcentagem_anual = porcentagem_inicial * 2` - aqui é realizado o cálculo para dobrar a porcentagem inicial e o valor é armazenado na variável `porcentagem_anual`;\n",
" * `primeiro_aumento` - é atualizada a variável com o cálculo da multiplicação do primeiro aumento pelo percentual do ano vigente;\n",
" * `primeiro_aumento = round(primeiro_aumento, 2)` - o `round()` é utilizado para formatar o valor armazenado na variável `primeiro_aumento` para duas casas decimais;\n",
" * `print(f'Salário no ano {ano}: {primeiro_aumento}')` e `print(f'Porcentagem Anual: {porcentagem_inicial}')` - são utilizados para validar o processo realizado dentro da estrutura de repetição;\n",
"* `print(f'Salário Atual: {salario_atual_formatado}')` - realiza a impressão do salário atual do colaborador;\n",
" \n",
"* Após consultas, realizei a inclusão da biblioteca `locale`, pois acreditei que o valor final do salário do colaborador deveria estar formatado para melhor compreensão, dado o aumento exponencial da porcentagem de aumento salarial ao final do código. Abaixo explico o processo:\n",
" \n",
" * `import locale` - importo a biblioteca para o meu ambiente, permitindo-me chamar suas funções quando necessário. Ela permite formatar números, datas e moedas de acordo com as convenções regionais, incluindo o uso de pontos e vírgulas;\n",
" * `locale.setlocale(locale.LC_ALL, 'pt_BR.UTF-8')` - define a configuração local e aplica a categoria `locale.LC_ALL` para todas as categorias (strings, data e hora, moedas, formatação de números), utilizando a localização específica desejada;\n",
" * `salario_atual_formatado = locale.currency(primeiro_aumento, grouping=True)` - cria a variável `salario_atual_formatado`, que utiliza a função `locale.currency` para formatar um valor como uma string monetária de acordo com as configurações locais. Neste caso, formata o valor de `primeiro_aumento`. O parâmetro `grouping` é opcional e normalmente padrão como `False`, mas aqui é definido como `True` para aplicar o agrupamento de milhares à formatação."
]
},
{
"cell_type": "code",
"execution_count": null,
"metadata": {},
"outputs": [],
"source": [
"import locale\n",
"\n",
"locale.setlocale(locale.LC_ALL, 'pt_BR.UTF-8')\n",
"\n",
"ano_contrato = 1995\n",
"salario_inicial = 1000.00\n",
"ano_atual = 2024\n",
"porcentagem_inicial = 1.5\n",
"\n",
"primeiro_aumento = round(salario_inicial * (1 + porcentagem_inicial / 100),2)\n",
"\n",
"for ano in range(1997,ano_atual + 1):\n",
" porcentagem_anual = porcentagem_inicial * 2\n",
" primeiro_aumento *= 1 + porcentagem_anual / 100\n",
" primeiro_aumento = round(primeiro_aumento,2)\n",
" porcentagem_inicial = porcentagem_anual\n",
" print(f'Salário no ano {ano}: {primeiro_aumento}')\n",
" print(f'Porcentagem Anual: {porcentagem_inicial}')\n",
"\n",
"salario_atual_formatado = locale.currency(primeiro_aumento, grouping=True)\n",
"\n",
"print(f'Salário Atual: {salario_atual_formatado}')"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"#### [Exercício 38](https://wiki.python.org.br/EstruturaDeRepeticao): Lógica utilizada para a construção do Sistema de Consulta de Salário com For in Range e input do usuário.\n",
"\n",
"Aqui é seguido a mesma lógica do código acima, apenas realizando a alteração na atribuição da variável `salario_inicial`.\n",
"\n",
"* `salario_inicial` - agora é atribuido com um `float(input('mensagem para o usuário'))`, onde `float` converte o dado informado pelo usuário em um número de ponto e `input` solicita um dado ao usuário."
]
},
{
"cell_type": "code",
"execution_count": null,
"metadata": {},
"outputs": [],
"source": [
"import locale\n",
"\n",
"locale.setlocale(locale.LC_ALL, 'pt_BR.UTF-8')\n",
"\n",
"ano_contrato = 1995\n",
"salario_inicial = float(input('Informe o seu salário inicial: '))\n",
"ano_atual = 2024\n",
"porcentagem_inicial = 1.5\n",
"\n",
"primeiro_aumento = round(salario_inicial * (1 + porcentagem_inicial / 100),2)\n",
"\n",
"for ano in range(1997,ano_atual + 1):\n",
" porcentagem_anual = porcentagem_inicial * 2\n",
" primeiro_aumento *= 1 + porcentagem_anual / 100\n",
" primeiro_aumento = round(primeiro_aumento,2)\n",
" porcentagem_inicial = porcentagem_anual\n",
" print(f'Salário no ano {ano}: {primeiro_aumento}')\n",
" print(f'Porcentagem Anual: {porcentagem_inicial}')\n",
"\n",
"salario_atual_formatado = locale.currency(primeiro_aumento, grouping=True)\n",
"\n",
"print(f'Salário Atual: {salario_atual_formatado}')"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"#### [Exercício 32](https://wiki.python.org.br/EstruturaDeRepeticao): Lógica utilizada para a construção do Sistema de Cálculo de Fatorial de Número inteiro usando For in Range.\n",
"\n",
"* Inicio o código criando uma função chamada `fatorial(numero)` que recebe o parâmetro `numero` e realiza o cálculo fatorial de um número inteiro;\n",
" \n",
" * `resultado = 1` - criada a variável pois é necessário para o cálculo do fatorial, porque o fatorial de 0 e 1 é sempre 1;\n",
" \n",
" * `fatorial_str = str(numero) + '! = '` - criada variável string para referenciar o número que será calculado o fatorial;\n",
" \n",
" * `for i in range(numero, 0, -1):` - Iniciada estrutura de repetição, onde `i` irá percorrer a faixa de repetição iniciando (start) com o `numero` informado pelo usuário, com fim (stop) em `0` e passo (step) como `-1` para que ocorra de forma decrescente;\n",
" \n",
" * Dentro da estrutura de repetição ocorre a implementação da variável `resultado *= i`, que realiza a multiplicação do `resultado = 1` com o valor de `i`;\n",
" \n",
" * `fatorial_str += str(i)` - recebe a atribuição do valor convertido em string armazenado no `i`.\n",
" \n",
" * `if i != 1:` - adiciona uma condição também para a formatação textual do cálculo, pois se `i` for diferente de `1`, então é adicionado um `x` na variável `fatorial_str`.\n",
" \n",
" * `fatorial_str += ' = ' + str(resultado)` - por fim, adiciona também à variável `fatorial_str` o símbolo de `=` + o `str(resultado)` convertido em string.\n",
" \n",
" * `return fatorial_str` - permite que o resultado do cálculo e a string formatada sejam enviados de volta para onde a função foi chamada;\n",
" \n",
"* Criada a variável `numero`, declarando a mesma `int` e solicitando ao usuário `input()` que informe um número inteiro;\n",
" \n",
"* `resultado_fatorial = fatorial(numero)` - criada variável que chama a função aplicando o parâmetro `numero`, que contém o número informado pelo usuário;\n",
" \n",
"* `print(resultado_fatorial)` - exibe o resultado da função;"
]
},
{
"cell_type": "code",
"execution_count": null,
"metadata": {},
"outputs": [],
"source": [
"def fatorial(numero):\n",
" resultado = 1\n",
" fatorial_str = str(numero) + '! = '\n",
" for i in range(numero, 0, -1):\n",
" resultado *= i\n",
" fatorial_str += str(i)\n",
" if i != 1:\n",
" fatorial_str += ' x '\n",
" fatorial_str += ' = ' + str(resultado)\n",
" return fatorial_str\n",
"\n",
"numero = int(input(\"Digite um número inteiro para calcular o seu fatorial: \"))\n",
"\n",
"resultado_fatorial = fatorial(numero)\n",
"print(resultado_fatorial)"
]
}
],
"metadata": {
"kernelspec": {
"display_name": "Python 3",
"language": "python",
"name": "python3"
},
"language_info": {
"codemirror_mode": {
"name": "ipython",
"version": 3
},
"file_extension": ".py",
"mimetype": "text/x-python",
"name": "python",
"nbconvert_exporter": "python",
"pygments_lexer": "ipython3",
"version": "3.12.4"
}
},
"nbformat": 4,
"nbformat_minor": 2
}