2.2 Data Types and Operators

2.2.1 Conceitos Gerais

A maior parte do curso destina-se aos conceitos básicos.

A indentação é importante para o Python porque ele define quando termina um loop e começa o outro ou quando termina um statement do if;
Como muitas outras linguagens de programação o Python é case sensitive, isto é, maiúsculas e minúsculas definem variáveis diferentes;
Os comentários dentro do código pode ser feito a partir do uso do #. ********************************************************** ### Boas práticas
Utilizar os espaçamentos de maneira adequada para que as fórmulas fiquem fáceis de ler e consequentemente de entender;
Comentar as linhas de código, pois o maior beneficiário desses comentários será você daqui 6 meses quando estiver revisando esse código;

2.2.2 Configuração

Instalei o Anaconda e estou rodando o Spyder 3.3.1. para simular/rodar o Python. O CodeSkulptor 3 é um alternativa.

2.2.2.1 Classes de Variáveis

Define-se as variáveis conforme as suas características e do seu uso, por exemplo, um 32 pode ser um número inteiro, até mesmo um número flutuante e um caracter. Tudo dependerá de como se define ele, usando-se as aspas ter-se-á um caracter, sem o “ponto final” é um número inteiro e com o ponto final o número de ponto flutuante (mais conhecido como float).

A tabela abaixo foi retirada do 39.Summary da lesson 02.

Data Structure	Ordered	Mutable	Constructor	Example
int	NA	NA	`int()`	5
float	NA	NA	`float()`	6.5
string	Yes	No	‘’ ou " " ou `str()`	“teste”
bool	NA	NA	NA	`True` ou `False`
list	Yes	Yes	[ ] ou `list()`	list[1,2]
tuple	Yes	No	( ) ou `tuple()`	tuple(1,2)
set	NA	Yes	{ } ou `set()`	set(1,2)
dictionary	NA	Keys: No	{ } ou `dict()`	dict(“jul”:1,“jun”:2)

2.2.2.2 Inteiros e float’s

Como atribuir um integer e um float nas variáveis?

# Integer
teste_int = 100    # É um inteiro (não colocar o ponto final)
teste_int = 123    # É um inteiro (não colocar o ponto final)

# Float
teste_flo = 100.8  # É um float (só adicionar o ponto final)
teste_flo = 123.   # É um float (só adicionar o ponto final)

Note que haverá um conversão (ou data coercion ) de integer para float caso tenha alguma operação envolvendo os dois tipos de variáveis.

# A nova variável será do tipo float
teste_new = teste_int + teste_flo

Observe que as variáveis podem ser convertidas para integer, float etc. Contudo, deve-se ressaltar que para os casos de conversão de float para integer pode-se ter uma perda de informação significativa.

teste = 100.987      # Variável float

teste = int(100.987) # Convertendo para integer

print(teste)         # Note que o valor impresso é 100
                     # perdeu-se tudo o que estava após a vírgula

2.2.2.3 Boolean `bool`

Além de integer e float, também há o bool que se refere aos booleanos (True e False). Observe que para o Python True e False (1 e 0) devem ser escritos exatamete como está neste texto, em R eles são escritos todos em caixa alta.

2.2.2.4 Strings `str`

O strings é uma cadeia de letras, um exemplo é o texto que estou escrevendo agora.

print("Hello World")  # É a impressão de uma simples string "Hello World", mas poderia
                      # ser bem mais complexa.

meu_texto = "Vamos fazer um teste!111"   # Note que esse exemplo é um pouco mais complexo
print(meu_texto)                         # já que tem espaços, números e caracteres especiais.

Surpreenda-se pois no Python pode-se usar os operadores (+, * etc.) para realizar algumas funções.

+ Une/concatena duas strings;
* Multiplica a string.

2.2.2.5 Containers

A list é uma estrutura de dados que pode conter integer, floats, strings e booleans. Os benefícios das lists é que elas podem ser alteradas (mutability) e também podem ser reorganizadas.

minha_lista = [33 , "anderson" , True , 123.45] # Pode ser tudo misturado
minha_lista[0]                                  # Começa no zero - zero index based
minha_lista[-1]                                 # Tem os seus truques! Último elemento.
minha_lista[2:]                # Slicing        # Retorna os elementos cujo index é maior que 2
minha_lista[:2]                # Slicing        # Retorna os elementos cujo index é menor ou igual a 2
minha_lista[2:3]               # Slicing        # Retorna os elementos cujo index é maior que 2 e menor ou igual a 3

Uma variable da classe tuple é um tipo de lista imutável, isto é, não tem como usar .sorted(). Eles possuem uso específico, por exemplo, em latitude e longitude, pois sempre estão juntos.

# Defining a tuple variable
my_name = "anderson","uyekita"

# Tuple unpacking
pri_nom,sob_nom = my_name

# Editing/Updating a tuple variable
my_name = "jose","silva"

Observe que não é necessário o uso dos parêntesis. Há a particularidade do “tuple unpacking” que é atribuir todos os valores do tuple de uma só vez em outras variáveis, conforme o exemplo.

Uma variável do tipo set possui algumas características marcantes como: é mutável, portanto, pode-se alterar os valores desse container de elementos, mas ela não é ordenada, ou seja, não se tem ideia de quem é o primeiro ou último elemento. Além dessas características, ela não admite valores duplicados.

# Definição de uma lista simples
minha_lista = [1,2,3,1,2,3,4,5,6] # há valores duplicados

meu_set = set(minha_lista)        # {4, 3, 2, 1, 5, 6}
                                  # Agora é um <class 'set'>

Como o set é unordered todas as vezes que imprimir essa variável dessa classe a sequencia dos elementos alterará. Ressalta-se que o in funciona nas variáveis da classe set. Además, há methods específicos para essa classe que será descrita adiante.

O dictionary é uma estrutura de dados peculiar que possui um key que pode ser usado para mapear sendo esse key tendo um value.

# Example dictionary
elements = {"anderson": 1, "hitoshi": 2, "uyekita": 3}

elements["key"] = "value"      # Add value mapped by key
elements["teste"] = 9          # Add a new variable in the dictionary
elements["uma_lista"] = [1,2]  # Add a list
elements["100"] = "a"          # Other example

Observe que o dictionary é bem eclético, tem de tudo e aceita tudo. Pode-se usar o operador in o qual terá um retorno booleano. O método .get() é usado para ter o retorno do value da um dado key.

O nested dictionary é o uso de um dictionary tendo os seus values um outro dictionary.

# Exemplo retirado do site da Udacity.
elements = {"hydrogen": {"number": 1,
                         "weight": 1.00794,
                         "symbol": "H"},
              "helium": {"number": 2,
                         "weight": 4.002602,
                         "symbol": "He"}}

Sendo assim possível organizar informações estruturadas.

2.2.3 Operadores

São os operadores matemáticos básicos:

2.2.3.1 `+` Adição

Adiciona dois elementos.

print(5 + 3) # Somando dois números inteiros

print("Hello" + " " + "World") # Somando três strings

2.2.3.2 `-` Subtração

Subtrai dois elementos.

print(5 - 3)

2.2.3.3 `*` Multiplicação

Multiplica dois elementos.

print(5 * 3)

print("Ha" * 5)  # Terá como saída HaHaHaHaHa

2.2.3.4 `/` Divisão

Divide dois elementos.

print(5 / 3) # Retorna um float

2.2.3.5 `%` Resto da Divisão

Divide dois elementos e retorna o resto da divisão.

print(5 % 3) # Retorna 2

2.2.3.6 `**` Exponenciação

Eleva o primeiro termo ao segundo (normalmente anotamos como 5^3).

print(5 ** 3) # Retorna cinco elevado à terceira potência 5^3

2.2.3.7 `//` Retorna o Quociente da Divisão

Divide dois elementos e retorna o quociente da divisão.

print(5 // 3) # Retorna 1

2.2.3.8 `in` e `not it` Possui/Pertecen/Tem

O retorno desse operador é um valor booleano resultante da busca do primeiro elemento no segundo.

print("hitoshi" in ["anderson","hitoshi","uyekita"])       # Retorna True
print("hitoshi" not in ["anderson","hitoshi","uyekita"])   # Retorna False

2.2.4 Assignment Operators

Conforme abordado em sala de aula, essa forma de notação é para simplificar o código. É muito parecido com o i++(que é o mesmo que i=i+1) do C++.

2.2.4.1 `+=`

Atualização da variável a partir de soma.

teste = teste + 100   # Como eu faço
teste += 100          # Como um programador faz

2.2.4.2 `-=`

Atualização da variável a partir de uma subtração.

teste = teste - 100   # Como eu faço
teste -= 100          # Como um programador faz

2.2.4.3 `*=`

Atualização da variável a partir de uma multiplicação.

teste = teste * 100   # Como eu faço
teste *= 100          # Como um programador faz

2.2.4.4 `/=`

Atualização da variável a partir de uma divisão.

teste = teste / 100   # Como eu faço
teste /= 100          # Como um programador faz

2.2.4.5 `//=`

Atualização da variável pelo quociente de uma divisão.

teste = teste // 100   # Como eu faço
teste //= 100          # Como um programador faz

2.2.4.6 `%=`

Atualização da variável pelo resto de uma divisão.

teste = teste % 100   # Como eu faço
teste %= 100          # Como um programador faz

2.2.4.7 `**=`

Atualização da variável pelo resto de uma divisão.

teste = teste ** 100  # Como eu faço
teste %= 100          # Como um programador faz

Há outros mais complicados no site do Programiz.