Python: Aprender Python

Um guia abrangente de Python

👋 Bem-vindo à documentação do Stackhero!

Stackhero oferece uma solução cloud Python pronta a usar que proporciona uma série de benefícios, incluindo:

  • Implemente a sua aplicação em segundos com um simples git push.
  • Utilize o seu próprio nome de domínio e beneficie da configuração automática de certificados HTTPS para uma segurança reforçada.
  • Desfrute de tranquilidade com backups automáticos, atualizações com um clique, e preços simples, transparentes e previsíveis.
  • Obtenha performance ótima e segurança robusta graças a uma VM privada e dedicada.

Poupe tempo e simplifique a sua vida: só leva 5 minutos para experimentar a solução de hospedagem cloud Python do Stackhero!

Este guia oferece uma visão geral dos conceitos e da sintaxe essenciais do Python. Serve como uma revisão rápida para desenvolvedores experientes e uma introdução amigável para iniciantes. Abrangendo desde tipos de dados básicos até funcionalidades avançadas, este guia inclui tópicos como fluxo de controle, funções, classes, objetos e módulos comuns. Mantenha-o à mão como referência rápida enquanto trabalha em projetos Python. Tenha em mente que o Python possui um vasto ecossistema de bibliotecas e frameworks, portanto, explorar recursos e documentações adicionais ajudará a aprofundar-se em tópicos especializados.

Bom código!

Introdução ao Python

Python é uma linguagem de programação versátil e de alto nível criada por Guido van Rossum e lançada pela primeira vez em 1991. É popular por sua legibilidade e simplicidade, tornando-se uma excelente escolha tanto para iniciantes quanto para desenvolvedores experientes. Python é amplamente utilizado no desenvolvimento web, análise de dados, inteligência artificial, machine learning e automação, entre muitas outras áreas.

Alguns casos de uso comuns para Python incluem a construção de aplicações web usando frameworks como Django ou Flask, análise e visualização de dados com bibliotecas como pandas e matplotlib, e desenvolvimento de modelos de machine learning com ferramentas como TensorFlow e scikit-learn.

A extensa biblioteca padrão do Python e o seu próspero ecossistema de pacotes de terceiros fazem dele uma linguagem poderosa e flexível para enfrentar uma ampla gama de tarefas de programação.

Tipos de dados básicos

Os tipos de dados básicos do Python incluem inteiros (números inteiros), números de ponto flutuante (números com decimais), booleanos (valores verdadeiro/falso) e strings (sequências de caracteres):

  • int: Inteiro, por exemplo, 42
  • float: Número de ponto flutuante, por exemplo, 3.14
  • bool: Booleano, por exemplo, True ou False
  • str: String, por exemplo, "hello"

Exemplo:

integer = 42
floating_point = 3.14
boolean = True
string = "Hello, World!"

Estruturas de dados comuns

Python fornece várias estruturas de dados para ajudá-lo a organizar, armazenar e manipular dados de forma eficiente. As mais comumente usadas são listas, tuplos, dicionários e conjuntos. Listas e tuplos mantêm uma sequência ordenada de elementos, dicionários armazenam pares chave-valor, e conjuntos armazenam elementos únicos. Cada estrutura vem com uma gama de métodos adaptados a casos de uso específicos.

  • Lista: my_list = [1, 2, 3, 4]
  • Tuplo: my_tuple = (1, 2, 3, 4)
  • Dicionário: my_dictionary = {'key1': 'value1', 'key2': 'value2'}
  • Conjunto: my_set = {1, 2, 3, 4}

Listas

As listas são coleções mutáveis e ordenadas de elementos. Permitem duplicados e podem conter elementos de vários tipos de dados, incluindo outras listas, tuplos, dicionários ou conjuntos. Pode-se facilmente adicionar, atualizar e remover elementos. As listas são definidas entre colchetes [] com elementos separados por vírgulas.

Pontos-chave sobre listas:

  1. Mutáveis e ordenadas
  2. Permitem elementos duplicados
  3. Mantêm a ordem em que os elementos são adicionados
  4. Suportam múltiplos tipos de dados
  5. Fornecem operações para adicionar, atualizar e excluir elementos

As listas são comumente usadas quando se precisa de uma coleção dinâmica e redimensionável de itens.

Exemplos:

# Criar uma lista
my_list = [1, 2, 3, 4, 5]

# Acessar elementos
print(my_list[0])  # Saída: 1
print(my_list[-1])  # Saída: 5

# Adicionar elementos
my_list.append(6)
print(my_list)  # Saída: [1, 2, 3, 4, 5, 6]

# Atualizar elementos
my_list[0] = 0
print(my_list)  # Saída: [0, 2, 3, 4, 5, 6]

# Excluir elementos
del my_list[0]
print(my_list)  # Saída: [2, 3, 4, 5, 6]

Dicionários

Os dicionários são coleções mutáveis e não ordenadas de pares chave-valor. Cada chave deve ser única, e pode-se usar essas chaves para acessar seus valores associados. Como as listas, os dicionários podem armazenar elementos de vários tipos de dados, incluindo coleções aninhadas. Eles são definidos entre chaves {} com pares chave-valor separados por vírgulas, e chaves e valores separados por dois pontos.

Pontos-chave sobre dicionários:

  1. Coleção mutável e não ordenada
  2. Composta por pares chave-valor com chaves únicas
  3. Acesso aos valores usando chaves
  4. Armazenam vários tipos de dados

Os dicionários são ideais para tarefas onde é necessário realizar buscas, como configurações ou contagens de frequência.

Exemplos:

# Criar um dicionário
my_dictionary = {'a': 1, 'b': 2, 'c': 3}

# Acessar elementos
print(my_dictionary['a'])  # Saída: 1

# Adicionar elementos
my_dictionary['d'] = 4
print(my_dictionary)  # Saída: {'a': 1, 'b': 2, 'c': 3, 'd': 4}

# Atualizar elementos
my_dictionary['a'] = 0
print(my_dictionary)  # Saída: {'a': 0, 'b': 2, 'c': 3, 'd': 4}

# Excluir elementos
del my_dictionary['a']
print(my_dictionary)  # Saída: {'b': 2, 'c': 3, 'd': 4}

Tuplos

Os tuplos são coleções imutáveis e ordenadas de elementos. Funcionam muito como listas, exceto que uma vez criado um tuplo, seus elementos não podem ser alterados, adicionados ou removidos. Os tuplos são definidos usando parênteses () com elementos separados por vírgulas.

Pontos-chave sobre tuplos:

  1. Coleção imutável e ordenada
  2. Suportam múltiplos tipos de dados
  3. Estrutura de tamanho fixo

Os tuplos são úteis quando se precisa de uma coleção imutável, ou quando se deseja usar a coleção como chave de dicionário.

Exemplo:

# Criar um tuplo
my_tuple = (1, 2, 3, 4, 5)

# Acessar elementos
print(my_tuple[0])  # Saída: 1
print(my_tuple[-1])  # Saída: 5

# Nota: Tuplos são imutáveis

Conjuntos

Os conjuntos são coleções mutáveis e não ordenadas que armazenam elementos únicos. Eles removem automaticamente duplicados e não mantêm uma ordem. Os conjuntos podem conter elementos de vários tipos de dados, excluindo tipos mutáveis como listas e dicionários. Podem ser definidos usando chaves {} ou o construtor set().

Pontos-chave sobre conjuntos:

  1. Mutáveis e não ordenados
  2. Armazenam apenas elementos únicos, removendo automaticamente duplicados
  3. Excluem tipos mutáveis (como listas e dicionários)

Os conjuntos são ideais para testes de pertencimento, deduplicação e realização de operações de conjunto como união, interseção e diferença.

# Criar um conjunto
my_set = {1, 2, 3, 4, 5}

# Verificar pertencimento
print(1 in my_set)  # Saída: True

# Adicionar um elemento
my_set.add(6)
print(my_set)  # Saída: {1, 2, 3, 4, 5, 6}

# Atualizar removendo um elemento e adicionando outro
my_set.remove(1)
my_set.add(0)
print(my_set)  # Saída: {0, 2, 3, 4, 5, 6}

# Excluir um elemento
my_set.remove(0)
print(my_set)  # Saída: {2, 3, 4, 5, 6}

Instruções condicionais: if, elif, else

As instruções condicionais permitem executar código com base em se uma condição é verdadeira ou falsa.

if condition1:
  # fazer algo
elif condition2:
  # fazer outra coisa
else:
  # fazer outra coisa

Exemplo:

x = 42

if x > 50:
  print("x é maior que 50")
elif x < 50:
  print("x é menor que 50")
else:
  print("x é igual a 50")

Ciclo for

Os ciclos for iteram sobre uma sequência, como uma lista ou um intervalo, executando um bloco de código para cada elemento.

Exemplo:

for i in range(5):
  print(i)

Ciclo while

Os ciclos while executam um bloco de código enquanto uma condição especificada for verdadeira.

Exemplo:

i = 0
while i < 5:
  print(i)
  i += 1

Funções

As funções encapsulam código em blocos reutilizáveis que podem aceitar entradas (argumentos) e retornar saídas. Elas são definidas usando a palavra-chave def e podem ser chamadas pelo seu nome.

def function_name(argument1, argument2=default_value):
  # fazer algo
  return result

Exemplo:

def add(a, b):
  return a + b

result = add(3, 4)
print(result)  # Saída: 7

Funções lambda

As funções lambda, também conhecidas como funções anônimas, são funções concisas de uma única expressão criadas usando a palavra-chave lambda. Elas são comumente usadas para operações curtas, frequentemente como argumentos para funções como map(), filter(), ou sorted().

lambda arguments: expression

Exemplo:

add = lambda a, b: a + b
result = add(3, 4)
print(result)  # Saída: 7

Compreensões de lista

As compreensões de lista permitem criar listas em uma única linha legível combinando uma expressão com um ciclo e uma condição opcional. Elas são excelentes para transformar ou filtrar dados.

new_list = [expression for item in iterable if condition]

Exemplo:

squares = [x * x for x in range(1, 6)]
print(squares)  # Saída: [1, 4, 9, 16, 25]

Tratamento de exceções

O tratamento de exceções permite que o seu programa gerencie erros de execução de forma elegante. Python fornece os blocos try, except, e finally para capturar e lidar com exceções, garantindo que o seu programa continue ou termine suavemente.

try:
    # código que pode gerar uma exceção
except ExceptionType as error_variable:
    # lidar com a exceção
finally:
    # código a ser executado independentemente de uma exceção ter ocorrido

Exemplo:

try:
  result = 10 / 0
except ZeroDivisionError:
  print("Não é possível dividir por zero!")

Classes e objetos

As classes definem modelos para criar objetos na programação orientada a objetos (OOP). Os objetos são instâncias de uma classe com atributos (dados) e métodos (funções) que realizam tarefas específicas. A OOP promove código estruturado, reutilizável e sustentável.

class ClassName:
  def __init__(self, attribute1, attribute2):
    self.attribute1 = attribute1
    self.attribute2 = attribute2

  def method_name(self, argument1):
    # fazer algo
    return result

Exemplo:

class Dog:
  def __init__(self, name, age):
    self.name = name
    self.age = age

  def bark(self):
    print("Woof!")

# Criar uma instância de Dog
dog1 = Dog("Buddy", 3)
dog1.bark()  # Saída: Woof!

Importação de módulos

Os módulos são arquivos separados contendo código Python como funções, classes ou variáveis. Importar módulos permite estender a funcionalidade do seu programa usando bibliotecas e frameworks externos.

import module_name
from module_name import specific_function_or_class

Exemplo:

import math
print(math.sqrt(16))  # Saída: 4.0

Entrada/Saída de ficheiros

A entrada/saída (I/O) de ficheiros cobre a leitura e escrita de ficheiros em Python. Isto é essencial ao trabalhar com armazenamento e recuperação de dados.

Leitura de um ficheiro

with open('filename.txt', 'r') as file:
  content = file.read()

Escrita em um ficheiro

with open('filename.txt', 'w') as file:
  file.write('conteúdo a escrever no ficheiro')

Gerenciadores de contexto

Os gerenciadores de contexto ajudam a gerenciar recursos, como ficheiros ou conexões de rede, garantindo que sejam adquiridos e liberados corretamente. Usar um gerenciador de contexto garante que o seu código seja mais limpo e mais tolerante a falhas.

with resource as alias:
  # usar resource como alias

Exemplo:

with open('file.txt', 'r') as file:
  content = file.read()
  print(content)  # Saída: Hello, World!

Decoradores

Os decoradores permitem estender ou modificar o comportamento de funções ou classes sem alterar o seu código-fonte. Eles envolvem outra função e adicionam alguma funcionalidade antes ou depois da execução da função envolvida.

def decorator_function(func):
  def wrapper(*args, **kwargs):
    # fazer algo antes de chamar a função
    result = func(*args, **kwargs)
    # fazer algo depois de chamar a função
    return result
  return wrapper

@decorator_function
def my_function():
  # fazer algo

Exemplos:

def greet_decorator(func):
  def wrapper(name):
    return "Hello, " + func(name) + "!"
  return wrapper

@greet_decorator
def get_name(name):
  return name

print(get_name("John"))  # Saída: Hello, John!

Módulo Itertools

O módulo itertools fornece funções para criar e trabalhar com iteradores. Inclui iteradores infinitos (como count, cycle e repeat), iteradores finitos (como accumulate, chain, compress), e iteradores combinatórios (como product, permutations e combinations).

Exemplo:

import itertools

for i in itertools.count(5, 5):
  if i > 20:
    break
  print(i)  # Saída: 5, 10, 15, 20

Módulo Collections

O módulo collections oferece tipos de dados de contêiner especializados que podem ajudar a melhorar os seus programas.

from collections import namedtuple, defaultdict, Counter, deque

Exemplos:

from collections import namedtuple, deque, Counter, OrderedDict, defaultdict

# namedtuple
Person = namedtuple('Person', 'name age')
person1 = Person("Alice", 30)
print(person1.name, person1.age)  # Saída: Alice 30

# deque
dq = deque([1, 2, 3, 4, 5])
dq.append(6)
dq.appendleft(0)
print(dq)  # Saída: deque([0, 1, 2, 3, 4, 5, 6])

# Counter
count = Counter("hello world")
print(count)  # Saída: Counter({'l': 3, 'o': 2, 'h': 1, 'e': 1, ' ': 1, 'w': 1, 'r': 1, 'd': 1})

# OrderedDict
od = OrderedDict()
od['a'] = 1
od['b'] = 2
od['c'] = 3
print(od)  # Saída: OrderedDict([('a', 1), ('b', 2), ('c', 3)])

# defaultdict
dd = defaultdict(int)
dd['a'] += 1
dd['b'] += 2
print(dd)  # Saída: defaultdict(<class 'int'>, {'a': 1, 'b': 2})

Expressões regulares

As expressões regulares permitem um processamento e manipulação de texto poderosos. O módulo re fornece funções como match, search, findall, finditer, split e sub.

Exemplo:

import re

pattern = r'\d+'
result = re.findall(pattern, "There are 10 cats and 5 dogs.")
print(result)  # Saída: ['10', '5']

Datas e horas

Trabalhar com datas e horas é um requisito comum, especialmente para análise de dados ou tarefas de agendamento. O módulo datetime fornece classes e funções para trabalhar com datas, horas e intervalos.

import datetime

# datetime, date, time, timedelta, timezone

Exemplos:

from datetime import datetime, timedelta

# Data e hora atuais
current_time = datetime.now()
print("Data e hora atuais:", current_time)

# Data e hora personalizadas
custom_date = datetime(2022, 12, 31, 23, 59, 59)
print("Data e hora personalizadas:", custom_date)

# Converter string para datetime
date_str = "2023-01-01 00:00:00"
date_obj = datetime.strptime(date_str, "%Y-%m-%d %H:%M:%S")
print("String para datetime:", date_obj)

# Converter datetime para string
date_str2 = date_obj.strftime("%Y-%m-%d %H:%M:%S")
print("Datetime para string:", date_str2)

# Aritmética de datas e horas
one_day = timedelta(days=1)
yesterday = current_time - one_day
tomorrow = current_time + one_day
print("Ontem:", yesterday)
print("Amanhã:", tomorrow)

Fatiamento de listas

O fatiamento de listas permite extrair uma porção de uma lista ou outro tipo de sequência especificando valores de início, fim e passo opcionais. Este recurso é muito útil para extrair subsequências.

my_list[start:end:step]

Exemplo:

my_list = [0, 1, 2, 3, 4, 5]
sub_list = my_list[1:4]
print(sub_list)  # Saída: [1, 2, 3]

Formatação de strings

A formatação de strings é o processo de combinar texto estático com valores dinâmicos. Python oferece vários métodos de formatação, incluindo formatação com %, o método str.format(), e f-strings (Python 3.6+), que permitem gerar facilmente strings formatadas.

Formatação com %

print("Hello, %s" % name)

str.format

print("Hello, {}".format(name))

f-strings (Python 3.6+)

print(f"Hello, {name}")

Exemplo:

name = "John"
age = 30
formatted_string = f"My name is {name} and I am {age} years old."
print(formatted_string)  # Saída: My name is John and I am 30 years old.

Argumentos de linha de comando

Os argumentos de linha de comando permitem passar valores de entrada para um script Python ao executá-lo a partir da linha de comando. A lista sys.argv fornece acesso a esses argumentos, facilitando a sua análise e uso dentro do seu script.

import sys

arguments = sys.argv

Exemplo:

# Salve este código em um ficheiro chamado "cmd_args.py"
# Execute com: python cmd_args.py Alice
# Saída esperada: Hello, Alice!
import sys

if len(sys.argv) > 1:
  print(f"Hello, {sys.argv[1]}!")
else:
  print("Nenhum argumento fornecido.")

Other articles for Python