Tipos Básicos de Variáveis

Tipos Básicos de Variáveis#

Variáveis são estruturas que permitem armazenar valores para leitura e uso posterior. Do ponto de vista computacional, elas funcionam como «apelidos», compreensíveis por humanos, para endereços de memória. Para facilitar a compreensão do conceito, podemos imaginar que a memória do computador é uma espécie de armário e as variáveis indicam as gavetas ou portas onde os valores estão armazenados.

Como na maior parte das linguagens, identificadores (nomes de variáveis, funções, classes, etc) permitem letras minúsculas e maiúsculas, dígitos e traço baixo ou underline (_). Identificadores não possuem limite de tamanho e diferenciam entre minúsculas e maiúsculas (case sensitive), ou seja variavel é diferente de Variavel.

Tipagem Dinâmica em Python#

Python é uma linguagem de tipagem dinâmica, o que significa que você não precisa especificar o tipo de dado de uma variável antes de utilizá-la. O tipo da variável é determinado automaticamente com base no valor atribuído a ela.

Embora a tipagem seja dinâmica, existem alguns tipos de dados principais com os quais devemos nos familiarizar ao trabalhar com Python. Esses tipos de dados incluem:

  • Números inteiros

  • Números de ponto flutuante

  • Strings

Esses tipos são comuns em muitas outras linguagens de programação, como C/C++ e Fortran.

Números Inteiros#

Números inteiros são números sem um ponto decimal. Eles podem ser positivos ou negativos. A maioria das linguagens de programação usa uma quantidade finita de memória para armazenar um único inteiro, mas em Python, a quantidade de memória será expandida conforme necessário para armazenar inteiros grandes.

Os operadores básicos, +, -, * e / funcionam com inteiros.

2+2+3

7

2*-4

-8

Nota

A divisão inteira é um ponto onde o Python 2 e o Python 3 são diferentes

No Python 3.x, dividir 2 inteiros resulta em um número de ponto flutuante. No Python 2.x, dividir 2 inteiros resulta em um número inteiro. O último é consistente com muitas linguagens de programação fortemente tipadas (como Fortran ou C), já que o tipo de dado do resultado é o mesmo das entradas, mas o primeiro está mais alinhado com as nossas expectativas.

3/2

1.5

Para obter um resultado inteiro, usamos o operador //

3//2

1

Python é uma linguagem de tipagem dinâmica—isso significa que não precisamos declarar o tipo de dado de uma variável antes de inicializá-la.

Aqui vamos criar uma variável (pense nela como um rótulo descritivo que pode se referir a algum dado). O operador = atribui um valor à variável.

Por exemplo, podemos criar uma variável idade e armazenar nela o valor 28. Se essa for a primeira vez que o identificador idade aparecer neste trecho de código, a variável será criada nesse momento.

idade = 28

Como este material está escrito usando Jupyter Notebooks, para avaliar o valor da variável, basta digitar seu nome embaixo da declaração (em outras situações, será necessário usar o comando print, mas ainda veremos isso).

idade = 28
idade

28

O símbolo = não está testando igualdade no comando acima. A operação deve ser lida como:

A variável idade recebe o valor 30.

Funções operam sobre variáveis e retornam um resultado.

a = 1.5
b = 3

a + b

4.5

a * b

4.5

Observe que os nomes de variáveis diferenciam maiúsculas de minúsculas, então a e A são diferentes.

A = 2025

Aqui, print() irá exibir a saída na tela. No geral, essa é a forma que devemos proceder para exibir algo na tela (apenas no Jupyter isso não é necessário, assim é melhor já aprender o que funciona em todos os casos, né?)

print(a, A)

1.5 2025

Aqui inicializamos 3 variáveis, todas com o valor 0, mas essas ainda são variáveis distintas, então podemos mudar uma sem afetar as outras.

x = y = z = 0

print(x, y, z)

0 0 0

z = 1

print(z)

1

O Python oferece um sistema de ajuda embutido que pode ser acessado diretamente no console ou no ambiente interativo, como o Jupyter ou IPython. Esse recurso é muito útil quando você precisa de informações sobre funções, métodos ou módulos.

Para obter ajuda sobre um objeto ou função, basta usar o comando help().

help(z)

Help on int object:

class int(object)
 |  int([x]) -> integer
 |  int(x, base=10) -> integer
 |  
 |  Convert a number or string to an integer, or return 0 if no arguments
 |  are given.  If x is a number, return x.__int__().  For floating point
 |  numbers, this truncates towards zero.
 |  
 |  If x is not a number or if base is given, then x must be a string,
 |  bytes, or bytearray instance representing an integer literal in the
 |  given base.  The literal can be preceded by '+' or '-' and be surrounded
 |  by whitespace.  The base defaults to 10.  Valid bases are 0 and 2-36.
 |  Base 0 means to interpret the base from the string as an integer literal.
 |  >>> int('0b100', base=0)
 |  4
 |  
 |  Built-in subclasses:
 |      bool
 |  
 |  Methods defined here:
 |  
 |  __abs__(self, /)
 |      abs(self)
 |  
 |  __add__(self, value, /)
 |      Return self+value.
 |  
 |  __and__(self, value, /)
 |      Return self&value.
 |  
 |  __bool__(self, /)
 |      True if self else False
 |  
 |  __ceil__(...)
 |      Ceiling of an Integral returns itself.
 |  
 |  __divmod__(self, value, /)
 |      Return divmod(self, value).
 |  
 |  __eq__(self, value, /)
 |      Return self==value.
 |  
 |  __float__(self, /)
 |      float(self)
 |  
 |  __floor__(...)
 |      Flooring an Integral returns itself.
 |  
 |  __floordiv__(self, value, /)
 |      Return self//value.
 |  
 |  __format__(self, format_spec, /)
 |      Default object formatter.
 |  
 |  __ge__(self, value, /)
 |      Return self>=value.
 |  
 |  __getattribute__(self, name, /)
 |      Return getattr(self, name).
 |  
 |  __getnewargs__(self, /)
 |  
 |  __gt__(self, value, /)
 |      Return self>value.
 |  
 |  __hash__(self, /)
 |      Return hash(self).
 |  
 |  __index__(self, /)
 |      Return self converted to an integer, if self is suitable for use as an index into a list.
 |  
 |  __int__(self, /)
 |      int(self)
 |  
 |  __invert__(self, /)
 |      ~self
 |  
 |  __le__(self, value, /)
 |      Return self<=value.
 |  
 |  __lshift__(self, value, /)
 |      Return self<<value.
 |  
 |  __lt__(self, value, /)
 |      Return self<value.
 |  
 |  __mod__(self, value, /)
 |      Return self%value.
 |  
 |  __mul__(self, value, /)
 |      Return self*value.
 |  
 |  __ne__(self, value, /)
 |      Return self!=value.
 |  
 |  __neg__(self, /)
 |      -self
 |  
 |  __or__(self, value, /)
 |      Return self|value.
 |  
 |  __pos__(self, /)
 |      +self
 |  
 |  __pow__(self, value, mod=None, /)
 |      Return pow(self, value, mod).
 |  
 |  __radd__(self, value, /)
 |      Return value+self.
 |  
 |  __rand__(self, value, /)
 |      Return value&self.
 |  
 |  __rdivmod__(self, value, /)
 |      Return divmod(value, self).
 |  
 |  __repr__(self, /)
 |      Return repr(self).
 |  
 |  __rfloordiv__(self, value, /)
 |      Return value//self.
 |  
 |  __rlshift__(self, value, /)
 |      Return value<<self.
 |  
 |  __rmod__(self, value, /)
 |      Return value%self.
 |  
 |  __rmul__(self, value, /)
 |      Return value*self.
 |  
 |  __ror__(self, value, /)
 |      Return value|self.
 |  
 |  __round__(...)
 |      Rounding an Integral returns itself.
 |      
 |      Rounding with an ndigits argument also returns an integer.
 |  
 |  __rpow__(self, value, mod=None, /)
 |      Return pow(value, self, mod).
 |  
 |  __rrshift__(self, value, /)
 |      Return value>>self.
 |  
 |  __rshift__(self, value, /)
 |      Return self>>value.
 |  
 |  __rsub__(self, value, /)
 |      Return value-self.
 |  
 |  __rtruediv__(self, value, /)
 |      Return value/self.
 |  
 |  __rxor__(self, value, /)
 |      Return value^self.
 |  
 |  __sizeof__(self, /)
 |      Returns size in memory, in bytes.
 |  
 |  __sub__(self, value, /)
 |      Return self-value.
 |  
 |  __truediv__(self, value, /)
 |      Return self/value.
 |  
 |  __trunc__(...)
 |      Truncating an Integral returns itself.
 |  
 |  __xor__(self, value, /)
 |      Return self^value.
 |  
 |  as_integer_ratio(self, /)
 |      Return integer ratio.
 |      
 |      Return a pair of integers, whose ratio is exactly equal to the original int
 |      and with a positive denominator.
 |      
 |      >>> (10).as_integer_ratio()
 |      (10, 1)
 |      >>> (-10).as_integer_ratio()
 |      (-10, 1)
 |      >>> (0).as_integer_ratio()
 |      (0, 1)
 |  
 |  bit_count(self, /)
 |      Number of ones in the binary representation of the absolute value of self.
 |      
 |      Also known as the population count.
 |      
 |      >>> bin(13)
 |      '0b1101'
 |      >>> (13).bit_count()
 |      3
 |  
 |  bit_length(self, /)
 |      Number of bits necessary to represent self in binary.
 |      
 |      >>> bin(37)
 |      '0b100101'
 |      >>> (37).bit_length()
 |      6
 |  
 |  conjugate(...)
 |      Returns self, the complex conjugate of any int.
 |  
 |  to_bytes(self, /, length=1, byteorder='big', *, signed=False)
 |      Return an array of bytes representing an integer.
 |      
 |      length
 |        Length of bytes object to use.  An OverflowError is raised if the
 |        integer is not representable with the given number of bytes.  Default
 |        is length 1.
 |      byteorder
 |        The byte order used to represent the integer.  If byteorder is 'big',
 |        the most significant byte is at the beginning of the byte array.  If
 |        byteorder is 'little', the most significant byte is at the end of the
 |        byte array.  To request the native byte order of the host system, use
 |        `sys.byteorder' as the byte order value.  Default is to use 'big'.
 |      signed
 |        Determines whether two's complement is used to represent the integer.
 |        If signed is False and a negative integer is given, an OverflowError
 |        is raised.
 |  
 |  ----------------------------------------------------------------------
 |  Class methods defined here:
 |  
 |  from_bytes(bytes, byteorder='big', *, signed=False)
 |      Return the integer represented by the given array of bytes.
 |      
 |      bytes
 |        Holds the array of bytes to convert.  The argument must either
 |        support the buffer protocol or be an iterable object producing bytes.
 |        Bytes and bytearray are examples of built-in objects that support the
 |        buffer protocol.
 |      byteorder
 |        The byte order used to represent the integer.  If byteorder is 'big',
 |        the most significant byte is at the beginning of the byte array.  If
 |        byteorder is 'little', the most significant byte is at the end of the
 |        byte array.  To request the native byte order of the host system, use
 |        `sys.byteorder' as the byte order value.  Default is to use 'big'.
 |      signed
 |        Indicates whether two's complement is used to represent the integer.
 |  
 |  ----------------------------------------------------------------------
 |  Static methods defined here:
 |  
 |  __new__(*args, **kwargs)
 |      Create and return a new object.  See help(type) for accurate signature.
 |  
 |  ----------------------------------------------------------------------
 |  Data descriptors defined here:
 |  
 |  denominator
 |      the denominator of a rational number in lowest terms
 |  
 |  imag
 |      the imaginary part of a complex number
 |  
 |  numerator
 |      the numerator of a rational number in lowest terms
 |  
 |  real
 |      the real part of a complex number

Outra função, type(), retorna o tipo de dado de uma variável

type(x)

int

Nota

Observe que em linguagens como Fortran e C, você especifica a quantidade de memória que um inteiro pode ocupar (geralmente 2 ou 4 bytes). Isso impõe uma restrição sobre o maior tamanho de inteiro que pode ser representado. O Python adaptará o tamanho do inteiro para que você não tenha overflow.

a = 12345678901234567890123456789012345123456789012345678901234567890
print(a)
print(a.bit_length())
print(type(a))

12345678901234567890123456789012345123456789012345678901234567890
213
<class 'int'>

Atribuições com operações#

Assim como outras linguagens de programação, Python suporta atribuições associadas a certas operações, como soma ou concatenação (+=), subtração (-=), multiplicação (*=), divisão (/=) e outras operações que veremos na próxima Seção. Quando essas atribuições especiais são usadas, a operação associada é realizada sobre os valores da expressão à direita do operador e da variável à esquerda e o novo valor é atribuído à mesma variável. Por exemplo, o código acima pode ser reescrito como:

idade = 30
idade += 1

print(idade)

31

sendo equivalente a

idade = 30
idade = idade + 1

print(idade)

31

Outros exemplos:

idade = 30
idade -= 1

print(idade)

29

idade = 30
idade *= 2

print(idade)

60

idade = 30
idade /= 2

print(idade)

15.0

Atribuições múltiplas#

Python permite que múltiplas atribuições sejam feitas na mesma linha de algumas formas. Primeiro, pode-se simplesmente usar vírgulas para separar os identificadores de variáveis à esquerda do operador de atribuição e os valores à direita do operador de atribuição. Na prática, essa operação de atribuição é realizada por meio de variáveis do tipo Tupla, que veremos mais à frente.

idade, altura = 30, 1.78

print(idade, altura)

30 1.78

Pode-se também envolver os identificadores e os valores em colchetes [ ]. Na prática, essa operação de atribuição é realizada por meio de variáveis do tipo Lista, que também veremos mais à frente.

[idade, altura] = [30, 1.78]

print(idade, altura)

30 1.78

Ponto Flutuante#

Ao operar com números de ponto flutuante e inteiros, o resultado é promovido a um float.

1. + 2

3.0

Mas observe o operador especial de divisão inteira.

1.//2

0.0

Importante

É importante entender que, como existem infinitos números reais entre quaisquer dois limites, em um computador precisamos aproximar isso por um número finito. Existe um padrão IEEE para ponto flutuante que praticamente todas as linguagens e processadores seguem.

Isso significa duas coisas:

  • Nem todo número real terá uma representação exata em ponto flutuante.

  • Há uma precisão finita para os números — abaixo disso, perdemos o controle das diferenças (isso é geralmente chamado de erro de arredondamento).

Dica

O ponto flutuante é essencial para a ciência computacional. Uma ótima introdução ao ponto flutuante e suas limitações é: O que todo cientista da computação deveria saber sobre aritmética de ponto flutuante de D. Goldberg. Este artigo é uma referência incrível para entender como um computador armazena números que também pode ser encontrado nesse link

Considere a seguinte expressão, por exemplo:

0.3/0.1 - 3

-4.440892098500626e-16

0.3/0.1 == 3

False

Aqui está outro exemplo: O número 0.1 não pode ser representado exatamente em um computador. Em nossa impressão, usamos um especificador de formato (as coisas dentro de {}) para pedir que mais precisão seja mostrada:

a = 0.1
print("{:30.20}".format(a))

        0.10000000000000000555

Podemos pedir ao Python para relatar os limites do ponto flutuante.

import sys
sys.float_info

sys.float_info(max=1.7976931348623157e+308, max_exp=1024, max_10_exp=308, min=2.2250738585072014e-308, min_exp=-1021, min_10_exp=-307, dig=15, mant_dig=53, epsilon=2.220446049250313e-16, radix=2, rounds=1)

Observe que isso diz que só podemos armazenar números entre 2.2250738585072014e-308 e 1.7976931348623157e+308.

Também vemos que a precisão é 2.220446049250313e-16 (isso é comumente chamado de epsilon da máquina). Para ver isso, considere adicionar um número pequeno a 1.0. Usaremos o operador de igualdade (==) para testar se dois números são iguais:

Exercício Rapído

Defina duas variáveis, ( a = 1 ) e ( e = 10^{-16} ).

Agora defina uma terceira variável, b = a + e.

Podemos usar o operador == do Python para testar a igualdade. O que você espera que b == a retorne? Execute e veja se concorda com seu palpite.

Operações de Ponto Flutuante#

Os mesmos operadores, +, -, *, / funcionam como de costume para números de ponto flutuante. Para elevar um número a uma potência, usamos o operador ** (isso é o mesmo que em Fortran).

R = 2.0
pi = 3.1415

pi * R**2

12.566

Exercício Rapído

Considere as seguintes expressões. Usando as ideias de precedência, pense sobre qual valor resultará e, em seguida, experimente no código abaixo para ver se você estava certo.

  • 1 + 3*2**2

  • 1 + (3*2)**2

  • 2**3**2

Números Complexos#

O Python usa “j” para denotar a unidade imaginária.

1.0 + 2j

(1+2j)

a = 1j
b = 3.0 + 2.0j
print(a + b)
print(a * b)

(3+3j)
(-2+3j)

Podemos usar abs() para obter a magnitude e, separadamente, obter as partes real ou imaginária.

print("magnitude: ", abs(b))
print("parte real: ", a.real)
print("parte imaginária: ", a.imag)

magnitude:  3.605551275463989
parte real:  0.0
parte imaginária:  1.0

Strings (Textos)#

Dados do tipo texto, também chamados de strings são representados por variáveis do tipo str, que são coleções imutáveis de caracteres Unicode.

O Python não se importa se você usa aspas simples ou duplas para strings:

a = "está é a minha string"
b = 'outra string'

print(a)
print(b)

está é a minha string
outra string

Verificando a presença de caracteres#

Diferente das outras coleções, o operador in e sua negação not in funcionam não só para checar se um caractere pertence à string, mas também pode checar se uma string menor pertence ou não a outra, ou seja se uma string é substring da outra ou não. Note que essas operações diferenciam minúsculas e maiúsculas.

'y' in 'Python'

True

'd' not in 'Python'

True

'tho' in 'Python'

True

'pyt' in 'Python'

False

Concatenando strings#

Strings podem ser concatenadas usando o operador de adição ou colocando apenas um espaço branco entre elas. Além disso, é possível usar a operação join para concatenar strings, intercalando-as com a string sobre a qual faz-se a operação.

a + b

'está é a minha stringoutra string'

a + " . " + b

'está é a minha string . outra string'

'Introdução ' + 'a ' + 'Ciência' + 'da ' + 'Computação'

'Introdução a Ciênciada Computação'

'; '.join(['pêra', 'uva', 'maçã', 'salada mista'])

'pêra; uva; maçã; salada mista'

Muitos dos operadores matemáticos usuais também são definidos para strings.

a * 3

'está é a minha stringestá é a minha stringestá é a minha string'

Existem vários códigos de escape que são interpretados em strings. Esses começam com uma barra invertida, \. Por exemplo, você pode usar \n para uma nova linha.

a = a + "\n" + "hello"
print(a)

está é a minha string
hello

Exercício Rapído

A função input() pode ser usada para pedir a entrada do usuário.

  • Use help(input) para ver como funciona.

  • Escreva um código para pedir a entrada e armazenar o resultado em uma variável. input() retornará uma string.

  • Use a função float() para converter um número inserido como entrada em uma variável de ponto flutuante.

  • Verifique se a conversão funcionou usando a função type().

Textos Longos#

Aspas triplas """ podem envolver strings de várias linhas. Isso é útil para docstrings no início das funções (mais sobre isso mais tarde…).

c = """
É um período de guerra civil. Naves rebeldes, 
atacando de uma base oculta, conquistaram sua primeira 
vitória contra o maligno Império Galáctico.

Durante a batalha, espiões rebeldes conseguiram roubar 
os planos secretos da arma definitiva do Império, a 
Estrela da Morte, uma estação espacial blindada com poder 
suficiente para destruir um planeta inteiro.

Perseguida pelos sinistros agentes do Império, a Princesa 
Leia corre para casa a bordo de sua nave estelar, guardiã 
dos planos roubados que podem salvar seu povo e 
restaurar a liberdade na galáxia..."""

print(c)

É um período de guerra civil. Naves rebeldes, 
atacando de uma base oculta, conquistaram sua primeira 
vitória contra o maligno Império Galáctico.

Durante a batalha, espiões rebeldes conseguiram roubar 
os planos secretos da arma definitiva do Império, a 
Estrela da Morte, uma estação espacial blindada com poder 
suficiente para destruir um planeta inteiro.

Perseguida pelos sinistros agentes do Império, a Princesa 
Leia corre para casa a bordo de sua nave estelar, guardiã 
dos planos roubados que podem salvar seu povo e 
restaurar a liberdade na galáxia...

String Bruta#

Uma string bruta não substitui sequências de escape (como \n). Basta colocar um r antes da primeira aspa:

d = r"está é uma string bruta \n hello"
d

'está é uma string bruta \\n hello'

Acesando e Fatiando Strings#

Caracteres e fatias de strings podem ser acessados. Strings tem acesso direto aos seus elementos por meio de índices inteiros— lembre-se de que o Python começa a contagem em 0:

'Python'[2]

't'

texto = 'python'
texto[2]

't'

O fatiamento é usado para acessar uma parte de uma string.

Fatiar uma string pode parecer um pouco contra-intuitivo se você vem de C ou Fortran. O truque é pensar no índice como representando a borda esquerda de um caractere na string. Quando fizermos arrays mais tarde, o mesmo se aplicará.

Observe também que o Python (como C) usa indexação baseada em 0.

Os índices negativos contam a partir da direita.

# Definindo uma string de exemplo
a = "está é a minha string"

# Imprimindo a string completa
print(a) 

# Imprimindo uma parte da string usando fatiamento
# a[11:14] significa: comece no índice 11 e vá até o índice 14 (exclusivo)
print(a[11:14]) 

# Imprimindo o primeiro caractere da string
# a[0] significa: pegue o caractere no índice 0
print(a[0])


# Imprimindo o segundo caractere a partir do final da string 'a'
print(a[-2])

# Imprimindo uma parte da string usando fatiamento com passo
# a[11:20:2] significa: comece no índice 11, vá até o índice 20 (exclusivo), pegando a cada 2 caracteres
print(a[11:20:2])  # Saída: "mni" (caracteres nos índices 11, 13, 15, 17, 19)

está é a minha string
nha
e
n
nasrn

Quick Exercise

As strings têm muitos métodos (funções que sabem como trabalhar com um tipo de dado específico, neste caso, strings). Um método útil é .find(). Para uma string a, a.find(s) retornará o índice da primeira ocorrência de s.

Para nossa string c acima, encontre o primeiro . (identificando a primeira frase completa) e imprima apenas a primeira frase em c usando esse resultado.

Outras Operações com strings#

Existem também vários métodos e funções que trabalham com strings. Outras operações comuns com strings incluem split, replace, len, find, lower, upper, title.

A operação split divide a string em uma lista contendo substrings delimitadas pela string sep. Caso sep não seja informada, espaços em branco consecutivos serão tratados como delimitadores.

a = 'esta é a minha string'

a.split()

['esta', 'é', 'a', 'minha', 'string']

Poderiamos também aplicar a função na própria string

'olá, tudo bem?'.split(sep=', ')

['olá', 'tudo bem?']

A operação replace substitui todas as ocorrências de uma substring por uma nova substring e dá como resultado a string modificada. Opcionalmente, pode-se informar quantas substituições deseja-se fazer.

print(a)  # Exibe a string original

print(a.replace("esta", "aquela"))  # Exibe a string com "esta" substituído por "aquela"

esta é a minha string
aquela é a minha string

A operação len() retorna o número de aracteres da string

print(a)  # Exibe a string original

print(len(a))  # Exibe o número total de caracteres na string

esta é a minha string
21

A operação find permite encontrar o índice da primeira ocorrência de uma substring em uma string ou em uma fatia de uma string.

'Python'.find('t')

2

'abacaxi'.find('a', 3, 6)

4

Note que o código acima não retorna o mesmo resultado que o código abaixo:

'abacaxi'[3:6].find('a')

1

Isso acontece porque o primeiro código busca a substring na string original, porém desconsidera qualquer ocorrência fora da fatia especificada. Por outro lado, o segundo código primeiro extrai a fatia entre os índices [3, 7), gerando uma nova string, e só depois aplica a operação find.

As operações lower, upper, title servem para modificar a caixa dos caracteres de uma string.

  • lower: coloca todos os caracteres em letras minúsculas

  • upper: coloca todos os caracteres em letras maiúsculas

  • title: coloca a string em formato de título, i.e. as primeiras letras das palavras ficam maiúsculas e as demais minúsculas (note que o algoritmo faz essa transformação em todas as palavras da string)

'INTRODUÇÃO À COMPUTAÇÃO CIENTÍFICA'.lower()

'introdução à computação científica'

'introdução à computação científica'.upper()

'INTRODUÇÃO À COMPUTAÇÃO CIENTÍFICA'

'introdução à computação científica'.title()

'Introdução À Computação Científica'

Note que nossa string original, a, não foi alterada. Em Python, as strings são imutáveis. Operações em strings retornam uma nova string.

type(a)

str

Formatando strings#

Uma das operações mais frequentes sobre strings é a formatação, que permite inserir certos valores em posições pré-definidas de uma string.

Podemos formatar strings ao imprimir para inserir quantidades em lugares específicos na string. Um {} serve como um espaço reservado para uma quantidade e é substituído usando o método .format():

a = 1
b = 2.0
c = "teste"
print("a = {}; b = {}; c = {}".format(a, b, c))

a = 1; b = 2.0; c = teste

Poderiamos juntar string também usando +

print("a="+str(a))

a=1

Mas a maneira mais moderna de fazer isso é usar f-strings.

print(f"a = {a}; b = {b}; c = {c}")

a = 1; b = 2.0; c = teste

Note o f precedendo a aspa inicial "

Uma outra opção é a seguinte, onde você pode especificar o formato de cada variável:

print("a = %i; b = %.2f; c = %s" % (a, b, c))

a = 1; b = 2.00; c = teste
Conteúdo