Variáveis e Tipos de Dados em Python - Tutorial para Iniciantes

Introdução

Neste laboratório, você aprenderá os conceitos fundamentais de variáveis e tipos de dados em Python. Variáveis são blocos de construção essenciais na programação que permitem armazenar, acessar e manipular dados em seu código. Compreender os diferentes tipos de dados é crucial para escrever programas Python eficazes.

Você criará várias variáveis, explorará os diferentes tipos de dados disponíveis em Python, realizará conversões de tipos e aprenderá a usar variáveis em expressões. Essas habilidades formam a base da programação Python e são necessárias para desenvolver aplicações mais complexas.

Ao final deste laboratório, você se sentirá confortável em criar e usar variáveis com diferentes tipos de dados em Python.

Criando Suas Primeiras Variáveis Python

Nesta etapa, você aprenderá como criar e usar variáveis em Python. Variáveis são contêineres que armazenam valores de dados e lhes dão nomes significativos para facilitar a referência em seu código.

Vamos começar criando um novo arquivo Python e definindo algumas variáveis básicas:

Abra o arquivo /home/labex/project/variables.py no WebIDE.
Adicione o seguinte código para definir três variáveis:

## Criando variáveis básicas
water_supply = 100    ## Quantidade de água em galões
food_supply = 50      ## Quantidade de comida em libras
ammunition = 40       ## Número de cartuchos de munição

Em Python, você cria uma variável especificando um nome seguido pelo sinal de igual (=) e, em seguida, o valor que deseja atribuir a ela.

Vamos adicionar código para exibir os valores dessas variáveis:

## Exibindo valores de variáveis
print("Water supply:", water_supply)
print("Food supply:", food_supply)
print("Ammunition:", ammunition)

Execute seu script abrindo um terminal no WebIDE e executando:

python3 /home/labex/project/variables.py

Você deve ver a seguinte saída:

Water supply: 100
Food supply: 50
Ammunition: 40

Parabéns. Você criou suas primeiras variáveis Python e exibiu seus valores. Essas variáveis armazenam informações que seu programa pode acessar e manipular.

Entendendo os Tipos de Dados Numéricos

Python possui vários tipos de dados que são usados para classificar diferentes tipos de dados. Nesta etapa, você aprenderá sobre dois tipos de dados numéricos: inteiros e floats.

Abra o arquivo /home/labex/project/variables.py no WebIDE.
Adicione o seguinte código ao arquivo para definir variáveis com diferentes tipos de dados numéricos:

## Tipos de dados numéricos
integer_value = 42        ## Inteiro (número inteiro)
float_value = 3.14159     ## Float (número decimal)

Vamos explorar os tipos dessas variáveis usando a função type():

## Verificando os tipos de dados
print("\nCompreendendo os tipos de dados:")
print("integer_value:", integer_value, "- Tipo:", type(integer_value))
print("float_value:", float_value, "- Tipo:", type(float_value))

Agora, vamos realizar algumas operações básicas com esses tipos numéricos:

## Operações básicas com números
sum_result = integer_value + float_value
product_result = integer_value * float_value

print("\nOperações básicas:")
print(f"{integer_value} + {float_value} = {sum_result}")
print(f"{integer_value} * {float_value} = {product_result}")

Execute seu script:

python3 /home/labex/project/variables.py

Você deve ver uma saída semelhante a:

Water supply: 100
Food supply: 50
Ammunition: 40

Understanding data types:
integer_value: 42 - Type: <class 'int'>
float_value: 3.14159 - Type: <class 'float'>

Basic operations:
42 + 3.14159 = 45.14159
42 * 3.14159 = 131.94678

Observe que, ao realizar operações com inteiros e floats, o Python converte automaticamente o resultado para um float, se necessário.

Trabalhando com Strings e Booleanos

Além dos tipos de dados numéricos, Python fornece strings para dados de texto e booleanos para valores verdadeiro/falso. Vamos explorar esses tipos:

Abra o arquivo /home/labex/project/variables.py no WebIDE.
Adicione o seguinte código para definir variáveis string e booleana:

## Tipo de dado string - para texto
camp_name = "Python Base Camp"
location = 'Programming Valley'  ## Strings podem usar aspas simples ou duplas

## Tipo de dado booleano - para valores verdadeiro/falso
is_safe = True
has_water = True
enemy_nearby = False

Adicione código para verificar e exibir essas variáveis:

## Exibindo variáveis string e booleana
print("\nVariáveis string:")
print("Nome do acampamento:", camp_name, "- Tipo:", type(camp_name))
print("Localização:", location, "- Tipo:", type(location))

print("\nVariáveis booleanas:")
print("O acampamento é seguro?", is_safe, "- Tipo:", type(is_safe))
print("Há água disponível?", has_water, "- Tipo:", type(has_water))
print("Inimigo por perto?", enemy_nearby, "- Tipo:", type(enemy_nearby))

Vamos também demonstrar algumas operações com strings:

## Operações com strings
full_location = camp_name + " in " + location
print("\nLocalização completa:", full_location)

## Repetição de string
border = "-" * 20
print(border)
print("Informações do Acampamento")
print(border)

Execute seu script:

python3 /home/labex/project/variables.py

Você deve ver uma saída semelhante a:

Water supply: 100
Food supply: 50
Ammunition: 40

Understanding data types:
integer_value: 42 - Type: <class 'int'>
float_value: 3.14159 - Type: <class 'float'>

Basic operations:
42 + 3.14159 = 45.14159
42 * 3.14159 = 131.94678

String variables:
Camp name: Python Base Camp - Type: <class 'str'>
Location: Programming Valley - Type: <class 'str'>

Boolean variables:
Is the camp safe? True - Type: <class 'bool'>
Is water available? True - Type: <class 'bool'>
Is enemy nearby? False - Type: <class 'bool'>

Full location: Python Base Camp in Programming Valley
--------------------
Camp Information
--------------------

Observe como as strings podem ser concatenadas com o operador + e repetidas com o operador *. Booleanos são úteis para representar condições e controlar o fluxo do programa.

Conversão e Verificação de Tipos de Dados

Às vezes, você precisa converter valores de um tipo de dado para outro ou verificar o tipo de dado de uma variável. Isso é chamado de conversão de tipo (ou type casting). Vamos explorar esse conceito:

Abra o arquivo /home/labex/project/variables.py no WebIDE.
Adicione código para demonstrar a conversão de tipos:

## Exemplos de conversão de tipos
print("\nExemplos de Conversão de Tipos:")

## Convertendo string para inteiro
supplies_str = "75"
supplies_int = int(supplies_str)
print(f"String '{supplies_str}' convertida para inteiro: {supplies_int} - Tipo: {type(supplies_int)}")

## Convertendo inteiro para string
days_int = 30
days_str = str(days_int)
print(f"Inteiro {days_int} convertido para string: '{days_str}' - Tipo: {type(days_str)}")

## Convertendo inteiro para float
distance_int = 100
distance_float = float(distance_int)
print(f"Inteiro {distance_int} convertido para float: {distance_float} - Tipo: {type(distance_float)}")

## Convertendo float para inteiro (nota: isso trunca a parte decimal)
temperature_float = 32.7
temperature_int = int(temperature_float)
print(f"Float {temperature_float} convertido para inteiro: {temperature_int} - Tipo: {type(temperature_int)}")

Adicione código para verificar os tipos de dados:

## Verificação de tipos
print("\nExemplos de Verificação de Tipos:")
value1 = 42
value2 = "42"
value3 = 42.0

print(f"É {value1} um inteiro? {isinstance(value1, int)}")
print(f"É {value2} um inteiro? {isinstance(value2, int)}")
print(f"É {value3} um float? {isinstance(value3, float)}")
print(f"É {value2} uma string? {isinstance(value2, str)}")

Execute seu script:

python3 /home/labex/project/variables.py

Você deve ver uma saída semelhante a:

...previous output...

Type Conversion Examples:
String '75' converted to integer: 75 - Type: <class 'int'>
Integer 30 converted to string: '30' - Type: <class 'str'>
Integer 100 converted to float: 100.0 - Type: <class 'float'>
Float 32.7 converted to integer: 32 - Type: <class 'int'>

Type Checking Examples:
Is 42 an integer? True
Is 42 an integer? False
Is 42.0 a float? True
Is 42 a string? True

Observe que:

int() converte valores para inteiros
float() converte valores para números de ponto flutuante
str() converte valores para strings
Ao converter um float para um inteiro, a parte decimal é truncada (não arredondada)
A função isinstance() verifica se uma variável é de um tipo específico

Essas funções de conversão são úteis quando você precisa processar a entrada de usuários ou ao trabalhar com dados de diferentes fontes.

Variáveis em Expressões e Tomada de Decisão

As variáveis se tornam verdadeiramente poderosas quando usadas em expressões e estruturas de tomada de decisão. Vamos explorar como usar variáveis em cálculos e instruções condicionais:

Abra o arquivo /home/labex/project/variables.py no WebIDE.
Adicione código para demonstrar o uso de variáveis em cálculos:

## Variáveis em expressões
print("\nVariáveis em Expressões:")

water_per_day = 4  ## gallons
food_per_day = 2.5  ## pounds

## Calcular quanto tempo os suprimentos durarão
water_days = water_supply / water_per_day
food_days = food_supply / food_per_day

print(f"Com {water_supply} galões de água, consumindo {water_per_day} galões por dia, a água durará {water_days} dias")
print(f"Com {food_supply} libras de comida, consumindo {food_per_day} libras por dia, a comida durará {food_days} dias")

Adicione código para demonstrar o uso de variáveis em instruções condicionais:

## Usando variáveis para tomada de decisão
print("\nTomada de Decisão com Variáveis:")

## Verificar qual suprimento acabará primeiro
if water_days < food_days:
    limiting_factor = "Water"
    limiting_days = water_days
else:
    limiting_factor = "Food"
    limiting_days = food_days

print(f"{limiting_factor} acabará primeiro, após {limiting_days} dias")

## Verificar se os suprimentos são suficientes para uma jornada de 10 dias
journey_days = 10
sufficient_supplies = water_days >= journey_days and food_days >= journey_days and ammunition >= 20

print(f"Planejando uma jornada de {journey_days} dias.")
print(f"Temos suprimentos suficientes? {sufficient_supplies}")

## Fornecer status específico dos suprimentos
if water_days < journey_days:
    print(f"Aviso: A água só durará {water_days:.1f} dias.")
if food_days < journey_days:
    print(f"Aviso: A comida só durará {food_days:.1f} dias.")
if ammunition < 20:
    print(f"Aviso: Apenas {ammunition} cartuchos de munição disponíveis.")

Execute seu script:

python3 /home/labex/project/variables.py

Você deve ver uma saída semelhante a:

...previous output...

Variables in Expressions:
With 100 gallons of water, consuming 4 gallons per day, water will last 25.0 days
With 50 pounds of food, consuming 2.5 pounds per day, food will last 20.0 days

Decision Making with Variables:
Food will run out first, after 20.0 days
Planning a 10-day journey.
Do we have sufficient supplies? True

Isso demonstra como você pode usar variáveis em cálculos matemáticos e como tomar decisões com base nos valores das variáveis. Observe como usamos operadores de comparação (<, >=) e operadores lógicos (and) para criar condições.

A sintaxe de formatação {water_days:.1f} especifica que o float deve ser exibido com uma casa decimal.

Resumo

Neste laboratório, você aprendeu os conceitos fundamentais de variáveis e tipos de dados em Python. Você criou e usou variáveis de diferentes tipos, incluindo:

Inteiros para números inteiros
Floats para números decimais
Strings para dados de texto
Booleanos para valores verdadeiro/falso

Você também aprendeu como:

Verificar o tipo de uma variável usando a função type()
Converter entre diferentes tipos de dados usando funções como int(), float() e str()
Usar variáveis em expressões e cálculos
Tomar decisões com base nos valores das variáveis usando instruções condicionais

Esses conceitos formam a base da programação em Python. As variáveis permitem que você armazene e manipule dados, enquanto a compreensão dos diferentes tipos de dados ajuda você a usar o tipo certo para cada situação. À medida que você continua sua jornada em Python, você construirá sobre esses fundamentos para criar programas mais complexos e poderosos.