Python: primeiros passos¶

Usando o python como calculadora¶

Você pode usar o python para fazer as operações algébricas básicas de soma, subtração, multiplicação, divisão e exponenciação. Para tal, você pode escrever as operações que deseja fazer usando a seguinte notação:

Operação Resultado
$x + y$ soma de x e y
$x - y$ diferença de x e y
$x * y$ produto de x vezes y
$x / y$ quociente de x por y
$x // y$ divisão inteira de x por y
$x \% y$ resto de x por y
$x ** y$ x elevado a y

Exemplos¶

In [1]:
5 + 4
Out[1]:
9
In [2]:
10 - 53
Out[2]:
-43
In [3]:
37.15 * 101.37
Out[3]:
3765.8955

Exemplos¶

In [4]:
107 / 31
Out[4]:
3.4516129032258065
In [5]:
107 // 31
Out[5]:
3
In [6]:
107 % 31
Out[6]:
14

Exemplos¶

In [7]:
2.72 ** 5.7
Out[7]:
299.94577783032236

Ordem de precedência das operações algébricas¶

O python realiza primeiramente todas as operações de exponenciação da direita para a esquerda, em sequência, da esquerda para a direita, todas as operações de multiplicação, divisão, divisão inteira e resto e, por último, também da esquerda para a direita todas as operações de adição e subtração. Para alterar a ordem de precenência das operações, use parênteses.

In [8]:
print(2 * 3 + 27 / 3 ** 2)
print(2 ** 3 ** 2)
print((2 ** 3) ** 2)

9.0
512
64

A função print¶

Se, no console do python, você digitar a fórmula de uma operação e, em seguida Enter, ele irá exibir o resultado dessa operação na linha abaixo. Se você digitar em um script uma série de operações, quando o script for rodado, o python não exibirá os resultados. Se você entrar uma série de operações em uma célula do jupyter-lab, ele exibirá apenas o resultado da última operação. Para garantir que seu resultado seja exibido, use a função print. Por exemplo, se, em uma linha do seu códugio você digitar print(2 + 7), o python irá imprimir o resultado (9) mesmo que essa não seja a última linha do código.

In [9]:
# O resultado da operação abaixo será exibido
print(3.8342 / 57)

# Já o resultado a operação abaixo não será exibido
5 + 8

# O resultado da operação abaixo será exibido por ser uma operação na última linha dessa célula
81 / 9

0.06726666666666667
Out[9]:
9.0

Você pode fornecer mais de um argumento para a função print. Os argumentos devem ser separados por vírgula. Caso receba mais de um argumento, a função print instrui o python para exibir todos os argumentos separados por espaço

In [10]:
print(5, 7/2)

5 3.5

Casa queira um outro separador, acrescente, como argumento, sep='separador', substituindo separador pelo separador que você deseja. Para ilustrar, o exemplo abaixo usa dois pontos como separador:

In [11]:
print(5, 7/2, sep=':')

5:3.5

Variáveis¶

Para armazenar valores no python, você deve criar uma variável. Para tal, em uma linha escreva o nome que quer dar à variável seguido do sinal de = e do valor que quer atribuir à variável. Por exemplo, o código abaixo cria a variável a e atribui a ela o valor 12.

In [12]:
a = 12

No python, assim como em outras liguagens de computador o sinal "=" representa o operador de atribuição. Agora, se você usar o nome dessa variável em qualquer parte do cógido, o python vai substituir esse nome pelo valor 12.

In [13]:
print(2 * a)

24

Exemplo¶

O código abaixo resolve a equação de 2o grau $$ a x^2 + bx + c = 0 $$ Para qualquer valor numério de $a$, $b$ e $c$ que você escolha, desde que a equação tenha raízes reais

In [14]:
# atribuindo valores aos parâmetros
a = 2
b = 5
c = -10

# calculando o discriminate e armazenando seu valor na variável delta
delta = b ** 2 - 4 * a * c

# calculando as duas raízes

x1 = (-b + delta ** (1 / 2)) / (2 * a)
x2 = (-b - delta ** (1 / 2)) / (2 * a)
print(x1)
print(x2)

1.3117376914898995
-3.8117376914898995

Regras para criação de nomes de variáveis¶

  • O nome de uma variável deve conter apenas letras, números e o símbolo "_"
  • o nome de uma variável não pode iniciar com um número
  • o nome de uma variável não pode ser o nome de uma palavra reservada do python, como por exemplo, "list", "print", etc.

Lembre-se que o python diferencias letras maiúsculas de letras minúsculas. Desse modo, não use A para se referir a uma variável que você chamou de a. De todo modo, a recomendação é ue você nomei variáveis apenas com letras minúsculas. Também evite usar "ç" e letras com acento.

O operador de atribuição é executado depois de todos operadores numéricos. Assim, o código abaixo atribui à variável soma o resultado da soma das variáveis b e c.

In [15]:
b = 2
c = 4
soma = b + c
print(soma)

6

Para modificar o valor de uma variável numérica, simplesmente redefina a variável.

In [16]:
print(a)
a = 5 * 2
print(a)

2
10

Você pode usar o valor atual da variável para calcular seu novo valor.

In [17]:
print(a)
a = a + 7
print(a)

10
17

De fato, alterar o valor de uma variável com base em seu valor é tão frequente que, além da operação de atribuição simples, "=", o python define as seguintes operação de atribuição destinadas a mudar o valor de uma variável com base em seu valor corrente:

In [18]:
print(a)
a += 2     # equivale a a = a + 2
print(a)
a -= 11    # equivala a a = a -11
print(a)
a *= 2     # equivale a a = a * 2
print(a)
a /= 4    # equivale a a = a / 4
print(a)
a **= 3   # equivale a a = a ** 3
print(a)
a //=11   # equivale a a = a // 11
print(a)
a %= 3    # equivale a a = a % 3
print(a)

17
19
8
16
4.0
64.0
5.0
2.0

Tipos de dados numéricos¶

O python possui diversas formas de armazenar dados. Cada uma dessas formas é chamada um tipo. Para dados numéricos há três tipos:

  • Tipo inteiro ou int: armazena números inteiros com precisão limitada apenas pela capacidade de sua máquina;
  • Tipo de ponto flutuante ou float: armazenas número reais com precisão de entre 15 e 17 dígitos; e
  • Tipo complexo ou complex: armazena números complexos com a mesma precisão do tipo de ponto flutuante.

O python (assim como o R) é uma linguagem com tipo dinâmico. Isso significa que a variável ajusta seu tipo para corresponder ao dado atribuídio a ela a cada operação de atribuição. Outras linguagens trabalham com tipo estático. Nessas linguagens, ao criar uma variável, o programador deve explicitamente dizer que tipo de dados ela deverá conter.

Para verificar o tipo de dado de uma variável, digite type(variável), substituindo variável pelo nome de sua variável.

O pyton interpreta todo número digitado sem ponto decimal como um inteiro e todo número digitado com ponto decimal como um float.

In [19]:
numero_1 = 10
print(type(numero_1))

numero_2 = 10.
print(type(numero_2))

<class 'int'>
<class 'float'>

Funções int e float¶

Uma outra forma de criar uma variável contendo um número inteiro ou um número com ponto flutuante consiste em usar as funções int e float, respectivamente. Quanto o python lê int(x), ele tenta converter x em um número inteiro. Se ele não conseguir, ele emite uma mensagem de erro. Se $x$ for um float, o python irá retornar a parte inteira desse float.

De modo similar a intrução float(x) diz ao python para interpretar $x$ como se fosse um número do tipo float.

Você pode usar as funções int e float para converter outros tipos de dados para inteiros e floats respectivamente.

In [20]:
numero_3 = float(numero_1)
print(type(numero_3))
numero_4 = int(numero_2)
print(type(numero_4))

<class 'float'>
<class 'int'>

Números complexos¶

Para criar um número complexo no python, use a notação a + bj na qual a é um int ou um float correspondente à parte real do número complexo, b é um int ou float correspondente à parte imaginária desse número e j é o número imaginário tal que $j = \sqrt{-1}$.

Alternativamente, você pode usar a função complex(a, b). (Se você fornecer apenas um argumento para essa função, o python irá assumir que a parte imagináriz é zero.

Você também pode usar essa função para converter dados do tipo int e float em números complexos.

In [21]:
numero_5 = 5 - 7.2j
print(numero_5)
print(type(numero_5))

numero_6 = complex(1.17, 9)
print(numero_6)
print(type(numero_6))

numero_7 = complex(numero_2)
print(numero_7)
print(type(numero_7))

(5-7.2j)
<class 'complex'>
(1.17+9j)
<class 'complex'>
(10+0j)
<class 'complex'>

Conversão implícita de tipo¶

Usualmente uma operação numérica entre dois dados do um determinado tipo retorna um dado do mesmo tipo. A exceção é a operação de divisão // que, quando aplicada a dois inteiros, retorna um float.

Sempre que você solicitar ao python para fazer uma operação envolvendo um inteiro e um float, ele converterá o interio em float antes de realizar a operação. Se o resultado dessa operação for um número, ele será um float.

Sempre que você solicitar ao python para fazer uma operação envolvendo um inteiro ou um float e um complexo, ele converterá o inteiro ou float em complexo antes de realizar a operação. Se o resultado dessa operação for um número, ele será um complex.

In [22]:
print(type(numero_1), type(numero_2))
print(type(numero_1 + numero_2))

print(type(numero_2), type(numero_5))
print(type(numero_2 * numero_5))

print(type(numero_1/numero_1))

<class 'int'> <class 'float'>
<class 'float'>
<class 'float'> <class 'complex'>
<class 'complex'>
<class 'float'>

Tipo str¶

O tipo str é o tipo de dado que o python usa para armazenar texto. Vamos falar mais desse tipo em outras aulas. Por ora, basta saber que todo dado inserido entre aspas simples ou duplas é tratado pelo python com um objeto do tipo string.

In [23]:
texto_1 = 'Isso é um texto'
print(texto_1)
print(type(texto_1))

texto_2 = "texto entre aspas duplas"
print(texto_2)
print(type(texto_2))

Isso é um texto
<class 'str'>
texto entre aspas duplas
<class 'str'>

Operadores de comparação e tipo lógico¶

Frequentemente queremos comparar dois números. O python possui os operadores de comparação ilustrados nos exemplos do próximo slide.

In [24]:
a = 2
b = 3

# checa se a é igual a b e imprime o resultado
p0 = "A é igual a b?"
print(p0, a == b)

# checa se a é menor do que b e imprime o resultado
p1 = "A é menor do que b?"
print(p1, a < b)


# checa se a é menor ou igual a b e imprime o resultado
p2 = "A é menor ou igual a b?"
print(p2, a <= b)

# checa se a é maior do que b e imprime o resultado
p3 = "A é maior do que b?"
print(p1, a > b)


# checa se a é menor ou igual a b e imprime o resultado
p4 = "A é maior ou igual a b?"
print(p4, a >= b)

# checa se a é diferente de b e imprime o resultado
p5 = "A é diferente de b?"
print(p5, a != b)

A é igual a b? False
A é menor do que b? True
A é menor ou igual a b? True
A é menor do que b? False
A é maior ou igual a b? False
A é diferente de b? True

Tipo lógico¶

Os operadores de comparação retornam um novo tipo de dado, chamado lógico ou booleano e notado no pythom por bool. Os dados de tipo lógico podem assumir apenas dois valores: Ture e False.

In [25]:
print(type(a > b))

<class 'bool'>

Instruções condicionais¶

Instrução if¶

Uma instrução com a forma

if expr1: instruções

ou com a forma

if expr1:
    instruções

nas quais expr1 é uma expressão que resulta em um dado lógico, e instruções é um conjunto de instruções condicionais, diz para o pytho executar as instruções condicionais se, e somente se, expr1 resultar em True.

In [26]:
# O pytho sé imprimiria "a é maior do que b" caso a expressão a > b retornasse True.
# como ela retorna False, ele não faz nada.

if a > b:
    print("A é maior do que b")
In [27]:
# Após verificar que a expressão a < b retorna True, o python imprime
# "A é menor do que b"

if a < b:
    print("A é menor do que b")

A é menor do que b

Instrução if ... else¶

Um código do tipo

if expr1:
    instruções_1
else:
    instruções_2

na qual expr1 é uma expressão que resulta em um dado lógico e instruções_1 e instruções_2 são conjuntos alternativos de instuções, faz com que o python execute as instruções_1 caso expr1 resulte em True e instruções_2 caso expr1 resulte em False.

In [28]:
if a > b:
    print("a é maior do que b")
else:
    print("a não é maior do que b")

a não é maior do que b

Instrução if else em uma linha¶

Caso haja apenas uma instrução a ser executada caso expr1 seja verdadeira e apenas uma instrução a ser executada caso contrário, então você pode usar a seguinte forma para a instrução condicional:

instrução_1 if expr1 else instrução 2
In [29]:
print("a é maior do que b") if a > b else ("a não é maior do que b")
Out[29]:
'a não é maior do que b'

Instrução if ... elif ... else¶

Um código do tipo

if expr1:
    instruções_1
elif expr2:
    instruções_2
elif expr2:
    instruções_3
...
elif exprn:
    instruções_n
else
    instruções_m

no qual expr_1, expr_2, … , expr_n, expr_m são expressões que resultam em um valor lógico, instrui o pytho para executar apenas as intruções_1 caso expr1 resulta em True, apenas instruções_2 caso expr1 resulte em False e expr2 resulte em true e, de uma maneira geral, apenas instruções_k caso expr$i$ resulte em False para $i<k$ e expr$k$ resulte True, e executar instruçõe_m caso expr_1, expr_2, …, expr_n resultem, todas elas, em False.

In [30]:
if a > b:
    print("a é maior do que b")
elif a == b:
    print("a é igual a b")
else:
    print("a é menor do que b")

a é menor do que b

Novamente, caso cada grupo de instruções condicionais consista de apenas uma instrução, você pode, colocá-las todas em uma linha

In [31]:
print("a é maior do que b") if a > b else print("a é igual a b") if a == b else print("a é menor do que b")

a é menor do que b

Operadores lógicos¶

O python possui três operadores lógicos, a saber not, and e or. A tabela abaixo mostra como funcionam os operadores lógicos

Expressão Resultado
not expr1 Retorna True se expr1 for False e True se expr1 for True
expr1 and expr2 Retorna True se expr1 e expr2 forem ambas True e False caso contrário
expr1 or expr2 Retorna False se expr1 e expr2 forem ambas False e True caso contrário

Os operadores lógicos são avaliados depois de todos os operadores de comparação que, por sua vez são avaliados depois de todos os operadores algébricos. Em uma expressão com mais de um operador lógico, o python calcula primeiro as operações com o operador not, depois as operação com o operador and e, por último, as operações com o operador or. Você pode alterar essa ordem usando parênteses.

In [32]:
c = 5
print(a, b, c)

2 3 5
In [33]:
# para testar se, digamos c está entre a e b, usamos
(c > a and c < b) or (c < a and c > b)
# como o python faz primeiro a operação and e, depois, or, os parênteses acima são desnecessários, mas deixam a operação mais clara
Out[33]:
False
In [34]:
# para o último caso, você pode simplesmente escrever
a < c < b
Out[34]:
False

Note que a ordem das operações faz diferença

In [35]:
teste1 = b > a and b < c or b > c and b < a
print(teste1)
teste2 = b > a and (b < c or b > c) and b < a
print(teste2)

True
False

Conversão entre dados lógicos e numéricos¶

Para converter um dado numérico em boolenano. Use a função bool. Números iguais a zero são convertitos em False. Todos os outros números são convertidos em True. Quando um booleano é convertido em dado numérico, ele assume o valor True caso seja diferente de zero e False caso seja igual a zero.

In [36]:
print(bool(2))
print(bool(0.0))
print(bool(-1))
print(bool(0 + 0j))

True
False
True
False
In [37]:
print(int(True))
print(complex(False))
print(float(True))
print(int(False))

1
0j
1.0
0

Conversão implícita de booleano e para booleano¶

Sempre que um booleano é usado em uma operação aritmética, ele é convertido em número.

In [38]:
print( 2 + True)
print( 5 * False)

3
0

Dados numéricos em operações lógicas¶

  • not a retorna False se a=0 e True, caso contrário
  • a and b retorna b caso, ao converter a em booleano obtenha-se True, e False, caso contrário
  • a or b retorna a caso, ao converter a em booleano obtenha-se True, e b caso contrário.
In [39]:
a, b = 1, 2
print(not a)
print(a and b)
print(a or b)
print(a or True)
print(True or a)
print(True and a)
print(a and True)

False
2
1
1
True
1
True