# 1. Tupla vazia
t1 = tuple()
print('t1 =', t1)  # t1 = ()

# 2. A partir de uma lista
t2 = tuple([1, 4, 6])
print('t2 =', t2)  # t2 = (1, 4, 6)

# 3. A partir de uma string (cada char vira um elemento)
t3 = tuple('Python')
print('t3 =', t3)  # t3 = ('P', 'y', 't', 'h', 'o', 'n')

# 4. A partir de um dicionário (retorna apenas as chaves)
t4 = tuple({1: 'one', 2: 'two'})
print('t4 =', t4)  # t4 = (1, 2)

# Desempacotamento de tupla — muito usado em retorno de funções
def get_config():
    return ("localhost", 5432, "meu_banco")

host, porta, banco = get_config()
print(host)   # localhost
print(porta)  # 5432
print(banco)  # meu_banco

# Tupla como chave de dicionário (lista não permite isso)
coordenadas = {}
coordenadas[(40.7128, -74.0060)] = "Nova York"
coordenadas[(-23.5505, -46.6333)] = "São Paulo"
print(coordenadas)

notas = (7, 8, 9, 8, 10, 8, 6)

# Quantas vezes o valor 8 aparece?
print(notas.count(8))   # 3

# Em qual posição aparece o valor 9?
print(notas.index(9))   # 2

# Slicing funciona igual às listas
print(notas[1:4])       # (8, 9, 8)
print(notas[-1])        # 6

# Tupla de um único elemento — atenção à vírgula!
t_unico = (42,)         # correto
nao_e_tupla = (42)      # isso é só o número 42 com parênteses
print(type(t_unico))    # <class 'tuple'>
print(type(nao_e_tupla))# <class 'int'>

// JavaScript — array congelado como tupla
const ponto = Object.freeze([40.71, -74.00]);
// ponto[0] = 99; // Erro silencioso em modo normal, exceção em strict mode

// Desestruturação (pattern mais comum)
const [lat, lon] = ponto;
console.log(lat, lon); // 40.71 -74.00

// TypeScript — tupla tipada real
const config: [string, number, boolean] = ["localhost", 5432, true];
const [host, porta, ssl] = config;
console.log(host, porta, ssl); // localhost 5432 true

// Java 16+ — Record como tupla nomeada
record Ponto(double lat, double lon) {}

// Uso
Ponto p = new Ponto(40.71, -74.00);
System.out.println(p.lat()); // 40.71
System.out.println(p.lon()); // -74.00

// Records são imutáveis por padrão — igual a tupla Python
// p.lat = 99; // Erro de compilação

// Antes do Java 16 — biblioteca Apache Commons Lang
// Pair<String, Integer> par = Pair.of("localhost", 5432);

// C# 7+ — Tupla com campos nomeados
var config = (host: "localhost", porta: 5432, ssl: true);
Console.WriteLine(config.host);  // localhost
Console.WriteLine(config.porta); // 5432

// Retorno de função com tupla
(string nome, int idade) GetUsuario()
{
    return ("Carlos", 32);
}

var (nome, idade) = GetUsuario();
Console.WriteLine($"{nome}, {idade} anos"); // Carlos, 32 anos

fn main() {
    // Criando tupla
    let config = ("localhost", 5432_u16, true);

    // Acesso por índice
    println!("{}", config.0); // localhost
    println!("{}", config.1); // 5432

    // Desestruturação
    let (host, porta, ssl) = config;
    println!("Host: {}, Porta: {}, SSL: {}", host, porta, ssl);

    // Função que retorna tupla
    fn dimensoes() -> (f64, f64) {
        (1920.0, 1080.0)
    }
    let (largura, altura) = dimensoes();
    println!("{}x{}", largura, altura); // 1920x1080
}

from collections import namedtuple

# Criando um tipo nomeado
Servidor = namedtuple('Servidor', ['host', 'porta', 'ssl'])

# Instanciando
srv = Servidor(host='localhost', porta=5432, ssl=True)

# Acesso por nome (mais legível que srv[0])
print(srv.host)   # localhost
print(srv.porta)  # 5432
print(srv.ssl)    # True

# Continua sendo uma tupla — imutável
# srv.host = 'outro'  # AttributeError

# Conversão para dict quando precisar
print(srv._asdict())
# OrderedDict([('host', 'localhost'), ('porta', 5432), ('ssl', True)])