Python: Tutorial básico I

Introdução ao Tutorial de Python

Este tutorial de introdução ao Python é um guia para ajudá-lo nos primeiros passos na programação com Python, 

 

1. Instalação do Python

  • Instalação no Windows:
    • Baixe o instalador do Python em python.org.
    • Execute o instalador e marque a opção "Add Python to PATH" durante a instalação
       

2. Ambiente de Desenvolvimento Integrado (IDE)

  • Recomendação:

    • Para iniciantes, o IDLE (incluído na instalação do Python) ou IDEs como PyCharm, VS Code, ou Jupyter Notebook são boas opções.

3. Conceitos Básicos

  • Palavras Reservadas: Palavras que têm significados específicos na linguagem e não podem ser usadas como nomes de variáveis ou funções.
    if,
    else,
    for,
    while,
    def,
    class,
    import,
    True,
    False,
    None

  • Entrada e Saída de Dados

     Entrada de dados: Utiliza a função input() para ler dados fornecidos pelo usuário.
    nome = input("Digite seu nome: ")

    Saída de dados: Utiliza a função print() para exibir dados na tela.
    print(f"Olá, {nome}!")
     

  • Estruturas de Dados
    Os principais tipos de estruturas de dados incluem:

  • Tipos de Dados: Python suporta diversos tipos de dados, podendo ser variáveis, constantes, dados primitivos, estruturas compostas e outras estruturas, como veremos a seguir:
     

  • Variáveis: São utilizadas para armazenar dados que podem ser modificados durante a execução do programa.

    • x = 5

    • y = "Olá, Mundo!"
       

  • Constantes: Em Python, as constantes são variáveis cujo valor não deve ser alterado durante a execução do programa. Por convenção, o nome de constantes é escrito em letras maiúsculas, mas Python não impõe restrições à reatribuição de valores.

  • Tipos de Dados Primitivos:

    • Inteiros (int): Números inteiros como 10, -5, 1000.
      • numero_inteiro = 10
    • Ponto Flutuante (float): Números com parte decimal como 3.14, -0.001, 2.0.
      • numero_float = 10.5
    • Booleanos (bool): Valores lógicos True e False.
      • tem_sol = True
      • esta_chovendo = False
    • Strings (str): Sequências de caracteres como "Python", "Olá, Mundo!".
      • texto = "Python"
    • Bytes (bytes): Sequências de bytes, usadas para dados binários.
      • dado_binario = b'\x48\x65\x6c\x6c\x6f'
    • Bytearrays (bytearray): Sequências mutáveis de bytes.
      • barr = bytearray(b'hello')
    • NoneType (None): Tipo especial que representa a ausência de valor.
       
  • Estruturas de Dados Compostas:
    • Listas (list): Sequências mutáveis ordenadas de itens.
      • lista = [1, 2, 3, 4]
    • Tuplas (tuple): Sequências imutáveis ordenadas de itens.
      • tupla = (1, 2, 3, 4)
    • Dicionários (dict): Estruturas de dados chave-valor.
      • dicionario = {"chave1": "valor1", "chave2": "valor2"}
    • Conjuntos (set): Coleções não ordenadas de itens únicos.
      • conjunto = {1, 2, 3, 4, 5}
    • Frozensets (frozenset): Conjuntos imutáveis.
      • conjunto_imutavel = frozenset([1, 2, 3, 4, 5])
         

  • Outros Tipos de Estruturas de Dados:

    • Pilhas (Stacks): Estruturas de dados LIFO (Last In, First Out).
    • Filas (Queues): Estruturas de dados FIFO (First In, First Out).
    • Dequeues (collections.deque): Estruturas de dados de fila dupla que suportam operações eficientes de inserção e remoção em ambas as extremidades.

 

4. Operações Básicas

  • Aritméticas: Realizam operações matemáticas.

    • Adição (+), Subtração (-), Multiplicação (*), Divisão (/), Módulo (%), Exponenciação (**).
      soma = 5 + 3
      diferenca = 5 - 3
      produto = 5 * 3
      quociente = 5 / 3
      resto = 5 % 3
      potencia = 5 ** 3

 

5. Comparação: Comparam valores e retornam True ou False.

  • Igual (==), Diferente (!=), Maior que (>), Menor que (<), Maior ou igual (>=), Menor ou igual (<=).
    igual = (5 == 5) # True
    diferente = (5 != 3) # True
    maior = (5 > 3) # True
    menor = (5 < 3) # False
    maior_ou_igual = (5 >= 5) # True
    menor_ou_igual = (5 <= 3) #
     

6 . Lógicas: Utilizadas para combinar expressões booleanas.

  • E (and), Ou (or), Não (not).
    e = (5 > 3) and (5 < 10) # True
    ou = (5 > 3) or (5 > 10) # True
    nao = not (5 > 3) # False

 

7. Funções: funções são blocos de código reutilizável que realizam uma tarefa específica. Elas permitem dividir o código em partes menores e mais gerenciáveis, facilitando a organização, a reutilização e a manutenção do código. Uma função é composta pelas seguintes partes:

  1. Definição: Começa com a palavra-chave def, seguida pelo nome da função e parênteses (), que podem incluir parâmetros de entrada.

  2. Corpo da Função: É o bloco de código indentado abaixo da definição, onde a lógica da função é escrita.

  3. Retorno: Opcionalmente, uma função pode retornar um valor usando a palavra-chave return.

def sum_val(a, b):
    result_sum = a + b
    return result_sum

# Chamando a função e armazenando o resultado
resultado_soma = sum_val(5, 3)

# Exibindo o resultado
print("Resultado da soma:", resultado_soma)

Neste exemplo A função sum_val recebe dois parâmetros (a e b) e dentro da função, ocorre a soma dos dois parâmetros e armazena o resultado na variável result_sum. Ao chamar sum_val(5, 3), a função retorna o resultado 8, que é armazenado na variável resultado_soma e depois exibido com print().

 

8. Métodos especiais: __init__ e self

  • __init__:  É um método especial usado para inicializar objetos criados a partir de uma classe, e executado automaticamente quando um novo objeto é criado. Exemplo: 
    • class Pessoa: 
    def __init__(self, nome, idade): 
    self.nome = nome 
    self.idade = idade 
pessoa1 = Pessoa('João', 30) 
print(pessoa1.nome) 
---------------------
# Saída: João
  • self: O primeiro parâmetro de todos os métodos de uma classe e que Referencia o próprio objeto, permitindo acessar variáveis de instância dentro dos métodos da classe. Exemplo:

    • class Carro:
          def __init__(self, modelo, ano):
              self.modelo = modelo
              self.ano = ano
          
          def exibir_info(self):
              print(f'Modelo: {self.modelo}, Ano: {self.ano}')

      meu_carro = Carro('Gol', 2003)
      meu_carro.exibir_info()

      ---------------------------------------------
      # Saída: Modelo: Gol, Ano: 2003

 

7. Estruturas de Controle

  • if, else, elif: Permitem controlar o fluxo do programa com base em condições.
    idade = 20
    if idade < 18:
         print("Menor de idade")
    else:
        print("Maior de idade")
     
  • for loops: Iteram sobre uma sequência (como uma lista) ou um intervalo.
    for i in range(5):
        print(i)
    ------------------------------------------
    # Saída: 0 1 2 3 4
  • while loops: Executam um bloco de código enquanto uma condição é verdadeira.
    contador = 0
    while contador < 5:
        print(contador) contador += 1
    --------------------------------------------
    # Saída: 0 1 2 3 4

 

8. Funções Built-in

  • Python possui várias funções integradas úteis como print(), len(), input(), range(), entre outras.
    nome = input("Digite seu nome: ")
    print(f'Olá, {nome}!')
    tamanho_lista = len([1, 2, 3, 4])
    print(tamanho_lista)
    -----------------------------------------------
    # Saída: 4

 

9. Tratamento de Exceções

  • try, except: Utilizados para lidar com exceções (erros) que podem ocorrer durante a execução do programa.
    try:
        numero = int(input("Digite um número: "))
    except ValueError:
        print("Isso não é um número válido!")

 

10. Arquivos e I/O

  • Manipulação de arquivos usando open(), read(), write() para leitura e escrita de dados em arquivos.
    # Escrita em um arquivo
    with open("arquivo.txt", "w") as arquivo:
        arquivo.write("Olá, Mundo!\n")
    # Leitura de um arquivo with open("arquivo.txt", "r") as arquivo:
        conteudo = arquivo.read()
        print(conteudo)
    -----------------------------------------------
    # Saída: Olá, Mundo!

 

11. Módulos e Pacotes

  • Módulos: Arquivos contendo funções, classes e variáveis que podem ser importados em outros programas.
    # math é um módulo built-in
    import math
    print(math.sqrt(16))
    ----------------------------------------------
     # Saída: 4.0
     
  • Pacotes: Diretórios que contêm vários módulos.
    # Estrutura de pacotes
    # meu_pacote/
    # ├── __init__.py
    # ├── modulo1.py
    # └── modulo2.py

    # Importando um módulo do pacote
    from meu_pacote import modulo1
    modulo1.minha_funcao()
     

12. Funções Lambda

  • Funções anônimas definidas com lambda que podem ter apenas uma expressão.
    # Função normal
    def somar(a, b):
        return a + b

    # Função lambda
    somar_lambda = lambda a, b: a + b
    print(somar_lambda(2, 3))
    --------------------------------------------------
    # Saída: 5
     

13. Classes e Objetos

  • Classes: Define um tipo de objeto, encapsulando dados (atributos) e operações (métodos).
    class Pessoa:
    def __init__(self, nome, idade):
        self.nome = nome
        self.idade = idade
    def apresentar(self):
        print(f'Nome: {self.nome}, Idade: {self.idade}')

    # Criando um objeto da classe Pessoa
    pessoa1 = Pessoa('João', 30)
    pessoa1.apresentar()
    ------------------------------------------------------
    # Saída: Nome: João, Idade: 30
     
  • Objetos: Instâncias de classes que possuem atributos e métodos específicos.
    class Carro:
    def __init__(self, modelo, ano):
        self.modelo = modelo
        self.ano = ano

    def exibir_info(self):
        print(f'Modelo: {self.modelo}, Ano: {self.ano}')

    meu_carro = Carro('Gol', 2003)
    meu_carro.exibir_info()
    -----------------------------------------------------
    # Saída: Modelo: Gol, Ano: 2003

 

 

Data de Publicação: 02-07-2024

Categoria: Python