Programação Python

Prévia do material em texto

Lógica de Programação
 A Lógica de Programação é a base de todo desenvolvimento de software. Ela envolve a capacidade de resolver problemas de forma estruturada e eficiente, criando algoritmos que guiam o funcionamento de um programa de computador
 A Lógica de Programação é o conjunto de regras e técnicas que os programadores utilizam para projetar e desenvolver programas de computador. É a habilidade de pensar de forma lógica e estruturada, decompondo um problema complexo em etapas mais simples. O objetivo é criar algoritmos claros e eficientes, que possam ser traduzidos em códigos de programação.
 Um bom programador não é apenas alguém que saber escrever código, mas também alguém que sabe pensar de forma lógica e resolver problemas de maneira eficaz. Isso envolve a capacidade de identificar padrões, organizar informações e criar soluções elegantes para desafios específicos.
A Importância da Lógica de Programação:
	A Lógica de Programação desempenha um papel fundamental no desenvolvimento de software e na resolução de problemas. Aqui estão algumas razões pelas quais essa habilidade é essencial:
1 – Resolução de Problema: A Lógica de programação permite que os programadores abordem problemas de forma sistemática, quebrando-os em partes menores e desenvolvendo algoritmos para resolvê-los.
2 – Eficiência: Algoritmos bem projetados são mais eficientes e consomem menos recursos computacionais, o que é crucial em projetos de software.
3 – Facilidade de Manutenção: Código com uma lógica sólida é mais fácil de manter e atualizar, economizando tempo e recursos.
4 – Adaptação a Novas Linguagens: A compreensão da lógica permite que os programadores aprendam rapidamente novas linguagens de programação, uma vez que a lógica é universal.
5 – Algoritmos: Os algoritmos são a implementação prática da lógica de programação. Eles são sequencias de instruções que resolvem um problema específico.
A Conexão entre Lógica de Programação e Algoritmos:
 A lógica de programação está intrinsicamente ligada à criação de algoritmos. Um algoritmo é uma sequência finita de ações que, quando seguidas, resolvem um problema ou realizam uma tarefa específica. A lógica é usada para projetar e otimizar algoritmos, garantindo que eles sejam eficazes e eficientes.
 Ao praticar a lógica de programação, você aprende a criar algoritmos sólidos. Isso envolve a identificação de variáveis, estruturas de controle (como loops e condicionais) e o uso de estruturas de dados apropriadas. Um programador habilidoso pode criar algoritmos elegantes que economizam tempo e recursos.
=============================================================================
 Então resumindo bem, a lógica de programação consiste em ter a capacidade de destrinchar todo e qualquer problema ou objetivo, com o intuito de faze-lo ser executado em sequências racionais, eficientes e eficazes.
 Conceitos Fundamentais:
1 – Sequência: Os comandos fornecidos ao computador serão executados na ordem em que forem escritos. Por exemplo como se fossemos montar um sanduiche: pão, recheio, outro pão.
2 – Decisão (Condicionais): Usamos condições para que o programa escolha caminhos diferentes. Veja o exemplo em Pseudocódigo:
===============================
‘’ se (tempo == ‘’chovendo’’) então
 leve guarda chuva
 senão
 vá sem guarda-chuva
 fim
‘’
===============================
3 – Repetição (Loops): Usamos para repetir uma ação várias vezes. Exemplo:
===============================
‘’ 
 enquanto (não encontrar resposta)
 continue pesquisando
 fim
‘’
===============================
4 – Variáveis: Espaços na memoria do computador para guardar informações
===============================
‘’
idade = 25
nome = ‘’antonio’’
‘’
===============================
O Que é Algoritmo:
 Um algoritmo é uma sequência de raciocínio, instruções ou operações para alcançar um objetivo, sendo necessário que os passos sejam finitos e operados sistematicamente. Um algoritmo, portanto, conta com a entrada (input) e saída (output) de informações mediadas pelas instruções.
 No livro Algoritmos, os autores afirmam que, em um sentido amplo, algoritmo é um processo sistemático para a resolução de um problema ou uma sequência ordenada de passos a ser observada para a realização de uma tarefa.
 O termo é muito utilizado é muito utilizado na matemática e na computação. Em ambas, os conceitos são semelhantes. Na primeira área está associado a um processo de cálculo, o encadeamento de ações necessárias para o cumprimento de uma tarefa. Em suma, é o processo efetivo, que produz solução para um problema em um número finito de etapas.
 Já na informática: ‘’[O termo é associado] a um conjunto de regras e procedimentos lógicos perfeitamente definidos que levam a solução de um problema em um número finito de etapas’’
 Isto é, os algoritmos são sequências finitas de instruções, utilizadas a fim de resolver um problema. Por exemplo, quando você acessa um site, os algoritmos definem o caminho para a correta abertura da página. Quando você interage com um link, outros algoritmos são acionados, indicando o que fazer.
Os Tipos de Estruturas Usadas nos Algoritmos:
As estruturas de programação são fundamentais para escrever qualquer tipo de software, e são elas que ditam o que o programa irá fazer para solucionar ou executar.
Variáveis, tipos de dados e Identificadores:
 Em Python as palavras são utilizadas para armazenar dados e, como essa linguagem é dinamicamente tipada, você não precisa declarar explicitamente o tipo de variável - o Python determina isso no momento da atribuição.
Tipos numéricos:
· Inteiros (int): Usados para números inteiros, sem parte decimal. Exemplos: 10, -3, 5, 8, -123.
· Ponto Flutuante (float): representam números reais com casas decimais. Exemplos: 3.14, -0.5.
· Complexos (complex): Números com uma parte real e outra imaginária. Exemplos: 2 + 3j
Booleanos:
· Booleano (bool): Representa os valores de verdade: True ou False. Esses valores são frequentemente usados em estruturas condicionais para controlar o fluxo do programa.
Sequências de Caracteres:
· Strings (str): Sequência de caracteres (textos). As Strings são imutáveis, o que significa que, uma vez criadas, elas não podem ser alteradas. Exemplo: “Olá, Mundo!” 
Tipo de Coleções:
· Listas (list): Sequências ordenadas e mutáveis que podem conter itens de diferentes tipos. Exemplo: [1, 2, 3, “quatro”].
· Tuplas (tuple): Sequências ordenadas, mas imutáveis. São úteis para armazenar dados que não devem ser modificados. Exemplo: (1, 2, 3).
· Dicionários (dict): Estruturas baseadas em pares chave-valor, permitindo associar dados relacionados. Exemplo: {“nome”: “Alice”, “idade”: 25}.
· Conjuntos (set): Coleções não ordenadas de elementos únicos: Exemplos: {1, 2, 3}.
Tipo Especial: None
· NoneType (none): Representa a ausência de valor. É comum usá-lo para inicializar variáveis ou indicar que algo não possui valor atribuído.
Conciderações Adicionais:
· Tipagem Dinâmica: Isso significa que uma variável pode mudar seu tipo durante a execução do programa. Por Exemplo:
------------------------------------------------------------
a = 5 # a é um int
	a = "texto" # agora, a é uma str
------------------------------------------------------------
· Mutabilidade: Alguns tipos, como listas e dicionários, são mutáveis, permitindo a alteração de seus conteúdos após a criação. Outros, como inteiros, floats, strings e tuplas são imutáveis, o que pode influenciar a forma como você manipula esses objetos durante a programação.
-----------------------------------------------------------------------------------------------------------------------------
Estruturas de Controle de Fluxo:
 Quando falamos de estruturas, estamos nos referindo tanto aos conceitos que controlam o fluxo do programa quanto aos mecanismos para organizar e modularizar o código. Cada uma delas possui seu papel, contribuindo para a clareza, reutilização e eficiênciado software.
Estruturas Condicionais: Essas estruturas permitem que o programa tome decisões com base em condições. As Principais são:
· “if”: Executa um bloco de código se uma condição for verdadeira.
· “elif”: Fornece condições alternativas quando o primeiro “if” (ou outro “elif”) não forz atendido.
· “else”: Executa um bloco de código quando nenhuma das condições anteriores foi satisfeita.
Exemplo: - 
-----------------------------------------------------------------------------------------------------
idade = 20
If idade >= 18:
print(“você é maior de idade.”)
elif idade == 17:
print(“Na maioria dos contextos, você está para se tornar adulto.”)
else:
print(“Você é menor de idade.”)
-----------------------------------------------------------------------------------------------------
Esse tipo de estrutura é central para adaptar o comportamento do programa conforme os dados disponíveis.
Estruturas de Repetição (Loops):
 Os Loops facilitam a execução repetitiva de blocos de código até que uma condição seja atendida ou por um número determinado de vezes.
· “for”: Ideal para iterar sobre sequências (como listas, strings, tuplas ou intervalos).
Exemplo: 
-----------------------------------------------
for numero in range(5):
print(“Número: ”, numero)
-----------------------------------------------
· “while”: Repete enquanto uma condição for verdadeira.
Exemplo:
-----------------------------------------------
contador = 0
while contador