Python

Operadores de Atribuições e Relacionais

Operadores de Atribuição

Os operadores de atribuição são usados para atribuir valores a variáveis, permitindo que o programador manipule os dados de maneira eficiente. O operador básico, e o mais simples, é o símbolo de igualdade =, que realiza a atribuição direta de um valor a uma variável. No entanto, além desse operador básico, Python também possui operadores de atribuição compostos, que combinam a atribuição com operações matemáticas ou lógicas, proporcionando uma maneira mais compacta e eficiente de realizar cálculos ou modificações em variáveis de forma direta.

Esses operadores compostos economizam linhas de código e ajudam a melhorar a legibilidade ao realizar operações como adição, subtração, multiplicação e divisão diretamente dentro da atribuição.

Operador

Descrição

Exemplo

atribuição

nome = "Maria"
print(nome)
"""
Resultado:

Maria
"""

nome = "Maria"

print(nome)

"""

Resultado:

Maria

"""

adição

x = 4
# Adição x = x + 2
x+=2
print('resultado:',x)
"""
Resultado:

resultado: 6
"""

x = 4

# Adição x = x + 2

x+=2

print('resultado:',x)

"""

Resultado:

resultado: 6

"""

subtração

x = 4
# Subitração x = x - 2
x-=2
print('resultado:',x)
"""
Resultado:

resultado: 2
"""

x = 4

# Subitração x = x - 2

x-=2

print('resultado:',x)

"""

Resultado:

resultado: 2

"""

x*=2

multiplicação

x = 4
# Multiplicação x = x * 2
x*=2
print('resultado:',x)
"""
Resultado:

resultado: 8
"""

x = 4

# Multiplicação x = x * 2

x*=2

print('resultado:',x)

"""

Resultado:

resultado: 8

"""

divisão

x = 10
# divisão x = x / 3
x/=3
print('resultado:',x)
"""
Resultado:

resultado: 3.3333333333333335
"""

x = 10

# divisão x = x / 3

x/=3

print('resultado:',x)

"""

Resultado:

resultado: 3.3333333333333335

"""

//=

divisão inteira

x = 10
# divisão inteira x = x // 3
x//=3
print('resultado:',x)
"""
Resultado:

resultado: 3
"""

x = 10

# divisão inteira x = x // 3

x//=3

print('resultado:',x)

"""

Resultado:

resultado: 3

"""

**=

exponenciação

x = 9
# exponenciação x = x ** 2
x**=2
print('resultado:',x)
"""
Resultado:

resultado: 81
"""

x = 9

# exponenciação x = x ** 2

x**=2

print('resultado:',x)

"""

Resultado:

resultado: 81

"""

resto da divisão

x = 9
# resto da divisão x = x % 2
x%=2
print('resultado:',x)
"""
Resultado:

resultado: 1
"""

x = 9

# resto da divisão x = x % 2

x%=2

print('resultado:',x)

"""

Resultado:

resultado: 1

"""

Operadores Relacionais

Os operadores relacionais são usados para comparar dois valores, ajudando a estabelecer relações entre eles. Eles retornam um valor booleano, ou seja, True ou False, dependendo do resultado da comparação realizada. Dessa forma, esses operadores desempenham um papel crucial na avaliação de condições dentro de um programa. Além disso, eles são essenciais para controlar fluxos de execução em estruturas condicionais, como if, e em loops, como while e for, permitindo que o código tome decisões baseadas nas relações entre os valores envolvidos.

Operador

Descrição

Exemplo

igual a

a = 5
b = 5
print("resposta: ",a == b)
"""
Resultado:

resposta:  True
"""

a = 5

b = 5

print("resposta: ",a == b)

"""

Resultado:

resposta: True

"""

diferente de

a = 5
b = 5
print("resposta: ",a != b)
"""
Resultado:

resposta:  False
"""

a = 5

b = 5

print("resposta: ",a != b)

"""

Resultado:

resposta: False

"""

maior que

a = 10
b = 5
print("resposta: ",a &gt; b)
"""
Resultado:

resposta:  True
"""

a = 10

b = 5

print("resposta: ",a > b)

"""

Resultado:

resposta: True

"""

maior ou igual a

a = 10
b = 10
print("resposta: ",a &gt;= b)
"""
Resultado:

resposta:  True
"""

a = 10

b = 10

print("resposta: ",a >= b)

"""

Resultado:

resposta: True

"""

menor que

a = 3
b = 10
print("resposta: ",a &lt; b)
"""
Resultado:

resposta:  True
"""

a = 3

b = 10

print("resposta: ",a < b)

"""

Resultado:

resposta: True

"""

menor ou igual

a = 10
b = 10
print("resposta: ",a &lt;= b)
"""
Resultado:

resposta:  True
"""

a = 10

b = 10

print("resposta: ",a <= b)

"""

Resultado:

resposta: True

"""

Operadores In e Not

Os operadores in e not in são utilizados para verificar a pertinência ou ausência de um elemento dentro de uma sequência (como uma lista, tupla, string, etc.). Eles retornam um valor booleano (True ou False) com base na avaliação de inclusão ou exclusão de um item dentro da sequência.

In retorna True caso contenha o valor

hortifruti = ['banana', 'morango', 'abacate','pera']
print('banana' in hortifruti)
print('acerola' in hortifruti)
"""
Resultado:

True
False
"""

hortifruti = ['banana', 'morango', 'abacate','pera']

print('banana' in hortifruti)

print('acerola' in hortifruti)

"""

Resultado:

True

False

"""

Not In retorna True caso não contenha o valor

hortifruti = ['banana', 'morango', 'abacate','pera']
print('banana' not in hortifruti)
print('acerola' not in hortifruti)
"""
Resultado:

False
True
"""

hortifruti = ['banana', 'morango', 'abacate','pera']

print('banana' not in hortifruti)

print('acerola' not in hortifruti)

"""

Resultado:

False

True

"""

Operadores Is e Is Not

Os operadores is e is not são usados para comparar identidade de objetos, ou seja, se duas variáveis referenciam o mesmo objeto na memória. Diferentemente dos operadores relacionais, que comparam os valores de dois objetos, o is e is not comparam as localizações de memória dos objetos. Essa comparação é fundamental quando queremos saber se duas variáveis estão apontando para a mesma posição de memória, e não apenas se os valores armazenados nelas são iguais.

Is

dois_igual_a_dois =  2 == 2
dois_maior_quatro = 2 &gt; 4
print("resultado: ",dois_igual_a_dois is dois_maior_quatro)

"""
Resultado:

resultado:  False
"""

dois_igual_a_dois = 2 == 2

dois_maior_quatro = 2 > 4

print("resultado: ",dois_igual_a_dois is dois_maior_quatro)

"""

Resultado:

resultado: False

"""

Is Not

dois_igual_a_dois =  2 == 2
dois_maior_quatro = 2 &gt; 4
print("resultado: ",dois_igual_a_dois is not dois_maior_quatro)
"""
Resultado:

resultado:  True
"""

dois_igual_a_dois = 2 == 2

dois_maior_quatro = 2 > 4

print("resultado: ",dois_igual_a_dois is not dois_maior_quatro)

"""

Resultado:

resultado: True

"""

Operadores And, Or, Not e Xor

Os operadores lógicos no Python são usados para combinar expressões booleanas e tomar decisões lógicas com base em condições. Eles trabalham com valores verdadeiros (True) ou falsos (False) e são fundamentais para o controle de fluxo e para criar condições complexas.

Em outras palavras, ao usar operadores lógicos, o programador pode definir condições mais elaboradas, criando fluxos de execução mais flexíveis e adaptáveis. Eles são, portanto, cruciais para garantir que o código execute de maneira correta, dependendo das situações que surgem durante a execução do programa.

Observação: Xor também é conhecido como “ou exclusivo“.

Operador Lógico AND

A and B

True

a = True
b = True
print("resposta: ",a and b)
"""
Resultado:

resposta:  True
"""

a = True

b = True

print("resposta: ",a and b)

"""

Resultado:

resposta: True

"""

True

False

a = True
b = False
print("resposta: ",a and b)
"""
Resultado:

resposta:  False
"""

a = True

b = False

print("resposta: ",a and b)

"""

Resultado:

resposta: False

"""

False

True

a = False
b = True
print("resposta: ",a and b)
"""
Resultado:

resposta:  False
"""

a = False

b = True

print("resposta: ",a and b)

"""

Resultado:

resposta: False

"""

False

a = False
b = False
print("resposta: ",a and b)
"""
Resultado:

resposta:  False
"""

a = False

b = False

print("resposta: ",a and b)

"""

Resultado:

resposta: False

"""

Perceba que em AND o resultado é True apenas em “True and True”

Operador Lógico OR

A or B

True

a = True
b = True
print("resposta: ",a or b)
"""
Resultado:

resposta:  True
"""

a = True

b = True

print("resposta: ",a or b)

"""

Resultado:

resposta: True

"""

True

False

a = True
b = False
print("resposta: ",a or b)
"""
Resultado:

resposta:  True
"""

a = True

b = False

print("resposta: ",a or b)

"""

Resultado:

resposta: True

"""

False

True

a = False
b = True
print("resposta: ",a or b)
"""
Resultado:

resposta:  True
"""

a = False

b = True

print("resposta: ",a or b)

"""

Resultado:

resposta: True

"""

False

a = False
b = False
print("resposta: ",a or b)
"""
Resultado:

resposta:  False
"""

a = False

b = False

print("resposta: ",a or b)

"""

Resultado:

resposta: False

"""

Perceba que em OR o resultado é False apenas em “False or False”

Operador Lógico XOR

A xor B

True

a = True
b = True
print("resposta: ",a ^ b)
"""
Resultado:

resposta:  False
"""

a = True

b = True

print("resposta: ",a ^ b)

"""

Resultado:

resposta: False

"""

True

False

a = True
b = False
print("resposta: ",a ^ b)
"""
Resultado:

resposta:  True
"""

a = True

b = False

print("resposta: ",a ^ b)

"""

Resultado:

resposta: True

"""

False

True

a = False
b = True
print("resposta: ",a ^ b)
"""
Resultado:

resposta:  True
"""

a = False

b = True

print("resposta: ",a ^ b)

"""

Resultado:

resposta: True

"""

False

a = False
b = False
print("resposta: ",a ^ b)
"""
Resultado:

resposta:  False
"""

a = False

b = False

print("resposta: ",a ^ b)

"""

Resultado:

resposta: False

"""

Perceba que em XOR o resultado é True apenas quando são valores opostos uma ao outro : “True xor False” e “False xor True”

Operador NOT

O operador not em Python é um operador lógico utilizado para inverter o valor de uma expressão booleana. Ele funciona de forma simples: se a expressão for verdadeira, o operador not a transforma em falsa; se for falsa, o operador a transforma em verdadeira. Dessa forma, ele realiza a negação do valor lógico de uma expressão, proporcionando uma maneira simples e eficiente de inverter o estado de uma condição.

Portanto, o operador not é uma ferramenta poderosa para quem deseja trabalhar com expressões booleanas de maneira flexível e direta.

NOT A

True

a = True
print("resposta: ",not a)
"""
Resultado:

resposta:  False
"""

a = True

print("resposta: ",not a)

"""

Resultado:

resposta: False

"""

False

a = False
print("resposta: ",not a)
"""
Resultado:

resposta:  True
"""

a = False

print("resposta: ",not a)

"""

Resultado:

resposta: True

"""

Perceba que em NOT inverte o resultado

Referências:

Documentação Python

Livros sobre Introdução a Python da Amazon

Interno:

Quem somos

Veremos neste post variável local e global, comentários e documentação em Python

Declaração de Variáveis

Representa uma posição na memória, onde pode ser armazenado um dado
Possui um nome e um valor
Durante a execução do algoritmo, pode ter seu valor alterado

resultado = 0
resultado += 1
resultado += 1
resultado += 1
print('resultado =',resultado)
"""
Resultado:

resultado = 3
"""

resultado = 0

resultado += 1

print('resultado =',resultado)

"""

Resultado:

resultado = 3

"""

Nome de variável

Dê nome significativo e sucinto a sua variável;
Variáveis de uma única letra como a variável ‘i’ é aceitável apenas para contadores
O nome deve iniciar por letra ou _ (sublinhado ou underscore)
Para separar palavras podemos fazer com _ (underscore) ou letra maiúscula.
Exemplos: retornaNomeObjeto, retorna_nome_objeto
Python é case sesitive pois difere nome de variável que tem letras maiúsculas e minúsculas.
Somos impedidos de usar palavras reservadas da linguagem para nomes de variáveis.
São elas: False, class, finally, is, return, None, continue, for, lambda, try, True, def, from, nonlocal, while, and, del, global, not, with, as, elif, if, or, yield, assert, else, import, pass, break, except, in, raise

primeironome = "Fábio"
primeiroNome = "Mario"
print('Os nomes: ',
primeironome, 'e', primeiroNome, 
'foram armazenados em variáveis diferentes, 
porquê o Python é case sensitive e percebeu a diferença na letra n (maiúscula e minúscula)')
"""
Resultado:

Os nomes:  
Fábio e Mario foram armazenados em variáveis diferentes, 
porquê o Python é case sensitive e percebeu a diferença na letra n (maiúscula e minúscula)
"""

primeironome = "Fábio"

primeiroNome = "Mario"

print('Os nomes: ',

primeironome, 'e', primeiroNome,

'foram armazenados em variáveis diferentes,

porquê o Python é case sensitive e percebeu a diferença na letra n (maiúscula e minúscula)')

"""

Resultado:

Os nomes:

Fábio e Mario foram armazenados em variáveis diferentes,

porquê o Python é case sensitive e percebeu a diferença na letra n (maiúscula e minúscula)

"""

Local

def somaTres(valor):
    # variável a ser utilizada localmente
    valorAdicional = 3
    result = valor + valorAdicional

def somaTres(valor):

# variável a ser utilizada localmente

valorAdicional = 3

result = valor + valorAdicional

Observe que a variável valorAdicional como foi declarada dentro de uma função fica restringida dentro da função somaTres().

Global

O uso de variáveis globais em Python não é recomendado na maioria dos casos, os principais motivos são problemas no paralelismo e funções que dependem de variáveis globais são menos reutilizáveis, já que têm dependências externas implícitas, o que, reduz a modularidade do código.

# Variável global
contador = 0
def incrementar():
    global contador
    contador += 1
incrementar()
incrementar()
incrementar()

print("resultado: ",contador)
"""
Resultado:

resultado:  3
"""

# Variável global

contador = 0

def incrementar():

global contador

contador += 1

incrementar()

print("resultado: ",contador)

"""

Resultado:

resultado: 3

"""

Atribuindo valores as variáveis na mesma linha

nome, aluno, colega = "André","Pedro","Francisco"
print(nome)
print(aluno)
print(colega)
"""
Resultado:

André
Pedro
Francisco
"""

nome, aluno, colega = "André","Pedro","Francisco"

print(nome)

print(aluno)

print(colega)

"""

Resultado:

André

Pedro

Francisco

"""

Comentários e Documentação em Python

Os comentários no código é importante para ajudar a compreender o seu código e de outros colegas programadores.
O comentário com aspas triplas pode permite gerar documentação e passa a aparecer em help( ).
No IDLE do python podemos executar help(print) que apresenta informações sobre esta função solicitada.

Uma linha

# Comentário de uma linha

1	# Comentário de uma linha

Multiplas linhas

"""
Comentário de
mais de uma
linha
"""

"""

Comentário de

mais de uma

linha

"""

Documentação a partir de comentários

def function soma(a,b):
    """
    Soma dois números 'a' e 'b'
    """
    return a + b

def function soma(a,b):

"""

Soma dois números 'a' e 'b'

"""

return a + b

Para gerar documentação deverá instalar a biblioteca pydoc

Depois deverá executar:
pydoc -p 1234
Que cria uma documentação em html do projeto com base nos comentários de três aspas em suas funções e objetos.

Função Print

Para imprimir uma informação em Python, se utiliza a função embutida print( ).
Você pode informar diretamente o texto ou pode passar variáveis.

retornando uma string

# Passando string simples
print("Ola Mundo")
# passando string de multiplas linhas
print("""Silvio
Silva
Firminon
""")
"""
Resultado: 

Ola Mundo
Silvio
Silva
Firminon
"""

# Passando string simples

print("Ola Mundo")

# passando string de multiplas linhas

print("""Silvio

Silva

Firminon

""")

"""

Resultado:

Ola Mundo

Silvio

Silva

Firminon

"""

Separador com espaço em branco e quebra de linha ao final

nome1 = "Silvio"
nome2 = "Silva"
nome3 = "Firmino"
print(nome1,nome2,nome3, sep=' ', end='n')
"""
Resultado: 

Silvio Silva Firminon
"""

nome1 = "Silvio"

nome2 = "Silva"

nome3 = "Firmino"

print(nome1,nome2,nome3, sep=' ', end='n')

"""

Resultado:

Silvio Silva Firminon

"""

Formatando uma String com F-String e Format

aluno = "Pedro"
idade = 12
print(f"Aluno: {aluno}, Idade:{idade}")
print("Aluno: {}, Idade: {}".format(aluno,idade))
"""
Resultado: 

Aluno: Pedro, Idade:12
Aluno: Pedro, Idade: 12
"""

aluno = "Pedro"

idade = 12

print(f"Aluno: {aluno}, Idade:{idade}")

print("Aluno: {}, Idade: {}".format(aluno,idade))

"""

Resultado:

Aluno: Pedro, Idade:12

Aluno: Pedro, Idade: 12

"""

Dica:

No IDLE do Python você pode consultar as funções nativas da linguagem com help( )
Veja:

help(print)
"""
Resultado:

Help on built-in function print in module builtins:
print(...)
    print(value, ..., sep=' ', end='n', file=sys.stdout, flush=False)
    Prints the values to a stream, or to sys.stdout by default.
    Optional keyword arguments:
    file:  a file-like object (stream); defaults to the current sys.stdout.
    sep:   string inserted between values, default a space.
    end:   string appended after the last value, default a newline.
    flush: whether to forcibly flush the stream.
"""

help(print)

"""

Resultado:

Help on built-in function print in module builtins:

print(...)

print(value, ..., sep=' ', end='n', file=sys.stdout, flush=False)

Prints the values to a stream, or to sys.stdout by default.

Optional keyword arguments:

file: a file-like object (stream); defaults to the current sys.stdout.

sep: string inserted between values, default a space.

end: string appended after the last value, default a newline.

flush: whether to forcibly flush the stream.

"""

Vimos hoje, variável local e global, comentários e documentação em Python, continue nos acompanhando !

Referências:

Gerar a documentação com PyDoc
Documentação Python

Livros sobre Introdução a Python da Amazon

Interno:

Quem somos

Operadores em Python

Operadores de Atribuições e Relacionais

Operadores de Atribuição

Operadores Relacionais

Operadores In e Not

Operadores Is e Is Not

Is

Is Not

Operadores And, Or, Not e Xor

Operador Lógico AND

Operador Lógico OR

Operador Lógico XOR

Operador NOT

Variável Local e Global, comentários e documentação em Python

Declaração de Variáveis

Nome de variável

Local

Global

Atribuindo valores as variáveis na mesma linha

Comentários e Documentação em Python

Uma linha

Multiplas linhas

Documentação a partir de comentários

Função Print

retornando uma string

Separador com espaço em branco e quebra de linha ao final

Formatando uma String com F-String e Format

Dica: