Tópicos vistos em aula

Discussão

• Computação sem computadores
• Computador como ferramenta
• O trabalho de um cientista da computação
• O que é um computador
• Características de uma linguagem de programação

Expressões e instruções

• Expressões são “frases” (sequências de operações e operandos) que têm associadas a si:

  1. Um valor
  2. Um tipo

  Por exemplo, a expressão 2 / 2 tem valor 1.0 e tipo float.

• Uma instrução ou declaração é um outro tipo de “frase” que não tem um valor associado, mas simplesmente indica uma operação que o interpretador deve fazer. Até agora vimos dois tipos de intrução:

  1. Atribuição (dar um valor a uma variável), por exemplo, x = 4. Repare que o lado direito do simbolo de = é sempre uma expressão, cujo valor é armazenado na variável.
  2. Importar uma biblioteca, por exemplo, import math

Tipos

(também conhecidos como classes)

• int: número inteiro
• float: número real (“quebrado”)
• str: string (cadeia de caracteres, texto)
• bool: booleano (True ou False, sim ou não, verdadeiro ou falso)

Veja abaixo também a função type, que nos diz qual é o tipo de uma expressão. Vimos também que podemos converter de um tipo para outro usando o nome do tipo como se fosse uma função:

>>> int("34")
34
>>> type("34")
<class 'str'>
>>> type(int("34"))
<class 'int'>

Erro

Erros sempre vão aparecer, e temos que saber lidar com eles. É importante aprender a ler mensagens de erro, por mais confusas que elas possam ser de vez em quando (a tendência é que vá ficando mais fácil com o tempo).

Falamos de alguns tipos de erro:

• Erro de sintaxe: escrevemos alguma coisa que não faz sentido para o Python
• Erro semântico: o nosso programa executa normalmente, mas ele não faz o que a gente gostaria que ele fizesse (esse é o tipo mais perigoso)
• Erro de “runtime”: alguma coisa dá errado durante a execução do programa.

Operadores aritméticos

• +
• -
• *
• / (divisão “real”)
• // (divisão inteira)
• % (módulo ou resto da divisão)
• ** (potenciação)

Lembrando que alguns operadores têm precedência sobre outros, então às vezes precisamos usar parênteses para que as contas sejam feitas na ordem que escolhermos (diferente da matemática convencional, aqui só podemos usar o parênteses para esse propósito. O colchete ([) e as chaves ({) tem outras funções).

Funções embutidas

• len: devolve o comprimento de uma string (ou de outros tipos que se apliquem).

  >>> len("Olá, mundo!")
  11

• type: Nos diz qual é o tipo da expressão.

  >>> type(34)
  <class 'int'>
  >>> type(3.3)
  <class 'float'>
  >>> type("Olá!")
  <class 'str'>
  >>> type(4 == 4)
  <class 'bool'>

• min e max: Nos devolve o menor e o maior elemento de um conjunto de valores, respectivamente.

  >>> min(18, -10, 5)
  -10
  >>> min("Alice", "Bruno", "Carla")
  'Alice'
  >>> max(3.88, 3.5, 4.2)
  4.2

Operadores booleanos

São aqueles operadores que nos dão um valor booleano. Por exemplo:

>>> 10 > 5
True

• >
• <
• == (Não confundir com =, usado para atribuir valores a variáveis!)
• >=
• <=
• and
• or
• not
• in

Operações com strings

Aprendemos a:

• concatenar duas strings (s1 + s2)
• concatenar sucessivamente a mesma string (s1 * 4)
• Acessar os elementos de uma string pelo seu índice (o primeiro elemento da string s é o s[0], o enésimo elemento de s é s[n - 1])

Linha de comando vs. Scripts (ou programas)

Vimos que um script (ou um programa) é um arquivo de texto cujo nome tem a extensão “.py”. Ele contém várias linhas com expressões ou instruções, que são executadas sequencialmente. Diferente da linha de comando, onde vínhamos trabalhando até agora, nem todo valor computado é impresso na tela (se quisermos que algo seja impresso, podemos usar o comando print, veja abaixo). Nos referimos ao que está escrito dentro desse arquivo como código fonte.

Suponha que salvamos um script python com o nome script.py. Para executá-lo, usamos o comando

$ python script.py

ou, dependendo do seu sistema operacional:

$ python3 script.py

Repare que esse comando é executado num terminal (ou prompt de comando) do seu sistema operacional, e não na interface do próprio python! Esse terminal pode ter alguns nomes: teminal, cmd, prompt de comando, powershell, etc.

Ou seja, num terminal do seu sistema operacional, você pode invocar o python de duas maneiras:

1. $ python

   Isso vai iniciar a interface de linha de comando do python;

2. $ python script.py

   Isso vai executar o script script.py.

Ao longo desse curso, usaremos >>> para indicar que se trata de um comando dentro da interface do python e $ para indicar que se trata de um comando no terminal do seu sistema operacional.

• Exemplo: interface de linha de comando do Python:

  >>> 2 + 3
  5

• Exemplo: terminal do seu sistema operacional:

  $ python programa.py

Comentários

Vimos como escrever algum texto no nosso código fonte de modo que ele seja ignorado interpretador do Python: isso é, como inserir uma mensagem que é para ser lida por humanos, não computadores. Chamamos esses textos de comentários.

# Isso é ignorado pelo interpretador
print("isso é interpretado")

Print e input

No interpretador da linha de comando, o valor de toda expressão avaliada é impressa na tela:

>>> 2 + 2
4

Num script, isso não é o caso. Se quisermos imprimir algo na tela, temos que usar o comando print.

# Dentro do arquivo script.py
print(2 + 2)

$ python script.py
4

Também podemos fazer o “contrário” do print. Se ao invés de querermos mostrar algo para o usuário, quisermos que ele digite algo como entrada para o programa, usaremos o comando input. Esse comando interrompe a execução do programa até que o usuário digite algo e aperte enter: então o valor da expressão input() é avaliado como a string correspondente a o que o usuário digitou.

NB: o tipo da expressão input() é sempre str!.

# script.py
print("digite o seu nome:")
nome = input()
saudacao = "Olá, " + nome
print(saudacao)

$ python script.py
digite o seu nome:
Arlete
Olá, Arlete

Podemos também passar uma string para o comando input, dentro dos parênteses. Nesse caso, o interpretador vai imprimir essa string logo antes de esperar a entrada do usuário:

# script.py
nome = input("digite o seu nome: ")
saudacao = "Olá, " + nome
print(saudacao)

$ python script.py
digite o seu nome: Bia
Olá, Bia

If, else e elif

Vimos que se quisermos que o programa execute algo condicionalmente (ou seja, que ele só faça uma coisa se uma condição for satisfeita, caso contrário que ele faça outra), usamos o comando if (que quer dize se em inglês).

x = 5

if x > 10:
    print("é maior")

if x < 10:
    print("é menor")

No exemplo acima, o programa vai imprimir é menor, já que x (que tem valor 5) é menor do que 10. Repare como usamos a indentação (os espaços à esquerda das linhas) para indicar quais são as linhas submetidas à condição expressa depois do if.

Opcionalmente, podemos usar o comando else, em seguida do if, para indicar um bloco de código que deve ser executado caso a condição não seja satisfeita (else pode ser traduzido do inglês como caso contrário).

x = 5

if x > 10:
    print("é maior")
else:
    print("é menor ou igual")

Se quisermos, ainda, podemos usar a construção if-elif-else, com a qual podemos usar várias condições. A primeira condição encontrada verdadeira vai ter seu bloco de código correspondente executado (e as seguintes todas serão ignoradas).

x = 7

if x > 10:
    print("é maior que 10")
elif x > 5:
    print("é maior que 5")
elif x > 0:
    print("é maior que 0")
else:
    print("nenhum dos dois")

Tente descobrir qual é a diferença deste código para um igual a ele, mas em que as palavras elif foram substituídas por if.

Laços

Laços (em inglês, loops) são um jeito de fazer algum trecho de código ser executado múltiplas vezes. O jeito mais simples de escrever um laço em python é usando o comando while.

While

While quer dizer “enquanto” em inglês. Sua sintaxe é a seguinte:

while <condição>:
    <código>

Isso quer dizer que o código <código> vai ser executado repetidamente, enquanto a <condição> for verdadeira. Mais detalhadamente, o programa irá seguir os seguintes passos:

1. Avalie a <condição>.
   • Se ela for verdadeira, vá para o passo 2;
   • Se não, encerre o laço.
2. Execute o <código>;
3. Retorne ao passo 1.

Chamamos a cada repetição desse processo de iteração. Vamos ver um exemplo simples:

# while.py

count = 0

while count < 5:
    print("O valor de count é " + str(count))
    count = count + 1

Nesse exemplo, a <condição> é count < 10 e o <código> são as duas linhas indentadas. Isso quer dizer que, a cada iteração, vamos imprimir algum texto na tela e aumentar o valor da variável count (dizemos que estamos incrementando o valor de count). Isso vai acontecer até que o valor de count se iguale a 5, em cujo caso a condição não vai ser satisfeita. Então o laço é encerrado. Veja abaixo a saída deste programa:

$ python while.py
O valor de count é 0
O valor de count é 1
O valor de count é 2
O valor de count é 3
O valor de count é 4

Laços infinitos

A condição verificada no início de cada iteração é sempre a mesma. Portanto, algo deve ser executado no <código> que, em algum momento, deve fazer com que essa condição se torne falsa. Caso contrário, o programa entra em um laço infinito e nunca para! Veja um exemplo:

count = 0

while count < 5:
    print("O valor de count é " + str(count))

No código acima, o programador esqueceu de atualizar a variável count. Isso quer dizer que ela nunca vai deixar de valer 0, e zero nunca vai deixar de ser menor que 5! Então esse laço nunca se encerra. Laços infinitos são um tipo de erro de programação.

Iterando pelos elementos de uma lista

É muito comum que tenhamos uma lista e queiramos executar algum código várias vezes, uma vez para cada lista. Nesse caso, podemos usar uma estrutura parecida com o exemplo acima. Suponha que queiramos simplesmente imprimir o valor de cada item da lista.

# while_lista.py

lista = ["banana", "laranja", "melancia", "manga"]
i = 0 # índice começa em 0

while i < len(lista):
    fruta = lista[i]

    print(fruta)
    i = i + 1

Se executarmos esse programa, veremos:

$ python while_lista.py
banana
laranja
melancia
manga

For

Esse padrão de iteração em elementos de uma lista é tão comum, que se criou um outro comando para isso. Chama-se for, e pode ser traduzido como “para cada”. Sua sintaxe é como segue:

for <variável> in <lista>:
    <código>

E lê-se: para cada <variável> na <lista>, execute o <código>. Ou seja, <código> vai ser executado uma vez para cada item na lista, e em cada iteração dessas a <variável> vai ter como valor esse item da lista. Vejamos um exemplo.

# for.py

lista = ["banana", "laranja", "melancia", "manga"]

for fruta in lista:
    print(fruta)

Ou seja, o código print(fruta) foi executado uma vez para cada item da lista. Em cada execução dessa, a variável fruta tinha como valor um desses itens. Na primeira iteração, o valor de fruta era "banana", na segunda, "laranja", e assim por diante. O resultado do programa é como segue:

$ python for.py
banana
laranja
melancia
manga

Na verdade, a sintaxe que apresentamos acima não está bem correta. O for não precisa ser usado somente com listas, mas com qualquer tipo de dado que tenha elementos que podem ser atribuídos sequencialmente a uma variável. Por exemplo, podemos usar o for com strings:

texto =  "Meu nome é Pedro Álvares Cabral"
count = 0

for letra in texto:
    if letra == "e" or letra == "E":
        count = count + 1

print(count)

Nesse caso, em cada iteração a variável letra vai ter como valor um dos caracteres da string. Tente entender o que o código acima está fazendo.

Uma definição melhor para o for seria, então, que ele pode ser usado com qualquer objeto iterável (em inglês, iterable). Listas e strings são exemplos de tipos iteráveis, mas existem muitos outros. Por exemplo, as tuplas (em inglês, tuples). Vamos estudar esse tipo com calma mais tarde, mas vale saber que podemos usá-la simplesmente separando diferentes elementos por vírgulas. Tente entender o que o código abaixo está fazendo:

for el in 1, "uau!", True, 54.3, "laranja":
    if type(el) == str:
        print(el + " é do tipo string.")

Por completude, apresentamos a sintaxe do comando for, dessa vez (um pouco) mais completa:

for <variável> in <iterável>:
    <código>

Funções

Funções são outros modo de fazer um trecho de código se repetir. Aqui, ao invés de repeti-lo sequencialmente, vamos dar um nome para ele e permitir que ele seja executado posteriormente, bastando para isso uma referência a esse nome. Suponha que queremos “nomear” o trecho de código a seguir, que faz uma conta e imprime o resultado.

res = 2 * 137 + 1
print(res)

Para encapsular essa lógica numa função chamada conta, usamos o seguinte código, que define uma função com esse nome:

def conta():
    res = 2 * 137 + 1
    print(res)

Nesse contexto, o trecho do código chama-se o corpo da função. Posteriormente, o programador poderá chamar (ou executar) essa função usando o seguinte:

>>> conta()
275

Chamar a função conta significa executar o trecho mostrado. Nesse caso, isso quer dizer que o resultado da conta é impresso na tela!

Argumentos

Sempre que executarmos a função conta o mesmo número, 275, será impresso na tela. Na maiora das vezes, queremos que o efeito da função não seja constante, mas sim dependente de algum contexto em que a função foi chamada. Para isso, vamos redefinir a função, agora com um argumento: um valor que é passado para função no momento em que é chamada.

# Chamando a função conta com argumento 37

conta(37)

No exemplo acima, o código está chamando a função com argumento 37, ou então, está passando o valor 37 para ela. Para que isso seja possível, a função tem que ser redefinida:

def conta(x):
    res = 2 * x + 1
    print(res)

Repare que há agora um nome entre parênteses, x, na definição. Quando passamos um valor para essa função, esse x atuará no corpo da função como uma variável cujo valor é exatamente aquele que foi passado para a função.

>>> conta(5)
11
>>> conta(2)
5
>>> conta(10)
21

Uma função pode ter mais de um argumento. Basta separá-los por vírgula, tanto para a definição quanto para a chamada. Vamos redefinir a função conta para usar dois argumentos.

def conta(x, y):
    res = 2 * x + 2 * y + 1
    print(res)

E podemos usá-la assim:

>>> conta(2, 3):
11
>>> conta(0, 1):
3

Valor de retorno

Além de receber valores, funções também podem devolvê-los. Isso quer dizer que chamar uma função é avaliar uma expressão cujo valor é esse que a função devolve. Para devolver um valor, usamos a palavra return. Veja um exemplo:

def conta(x):
    return 2 * x + 1

Essa função é quase igual à anterior, mas, ao invés de imprimir o resultado da conta, ela devolve esse resultado para quem a chamou. Poderíamos usar esse resultado assim:

res = conta(44)
print("O resultado da conta é " + str(res))

Ou seja, conta(44) devolveu um valor que foi armazenado na variável res. Esse valor foi usado para imprimir uma mensagem, fora da função.

Finalmente, a sintaxe para o uso de funções é a seguinte:

• definição:

def <nome da função>(<argumento1>, <argumento2>, ...):
    ...

    return <valor de retorno>

• chamada

<nome da função>(<argumento1>, <argumento2>, ...)

π

Última modificação: 29-05-2023