Skip to main content

Introdução

O Python é uma linguagem de programação de alto nível que foi desenvolvida por Guido van Rossum em 1991. Nós podemos usar ele apenas como uma linguagem de Script ou podemos desenvolver usando programação orientada a objetos.



Função print​

O print é uma função usada para imprimir (mostrar) informações no console (tela/monitor), por padrão cada print exibe apenas uma única linha, mas é possível alterar esse comportamento.


Uma forma de mostrar várias linhas sem usar \n:

print("""linha1
ola
tudo bem? """)

# Resultado: linha1
# ola
# tudo bem?


Operações com string​

Por padrão não é possível fazer operações com string, afinal, não da para somar letras ☹️. Mas é possível usar dois operadores com strings, são eles: + e o *, alem deles dois temos a , mas ela não é um simbolo de operação, mas como estamos falando de string vou explicar ela também.


O operador + é usando para concatenar duas strings (junta duas partes como se fossem uma só):

a = 'Abe'
b = 'lha'

print(a + b)

# Resultado: Abelha

O operador * é usando para multiplicar o valor da string antes dela:

a = 'Abe'
b = 'lha'

print(a*3)

# Resultado: AbeAbeAbe

O operador , é usando para unir strings mas diferente do +, ele adiciona um espaço entre as variáveis:

a = 'Abe'
b = 'lha'

print(a,b)

# Resultado: Abe lha


f-strings e format()​

As f-strings e o método format() são duas maneiras de formatar strings de forma mais flexível, permitindo a incorporação de variáveis e expressões diretamente na string. Ambas as abordagens são úteis para criar strings formatadas dinamicamente.


A f-strings é uma maneira mais recente e legível de formatar strings em Python, introduzidas a partir da versão 3.6. Ela é criada prefixando a string com o caractere f ou F. Dentro da string, você pode incorporar expressões Python usando chaves {}.

nome = "Alice"
idade = 25

mensagem = f"Olá, meu nome é {nome} e eu tenho {idade} anos."
print(mensagem)

# Output: Olá, meu nome é Alice e eu tenho 25 anos.

O método format() é mais antigo, mas ainda é amplamente usado e oferece grande flexibilidade. Você pode criar uma string com espaços reservados e, em seguida, usar o método format() para substituir esses espaços reservados pelos valores desejados.

nome = "Bob"
idade = 30

mensagem = "Olá, meu nome é {} e eu tenho {} anos.".format(nome, idade)
print(mensagem)

# Output: Olá, meu nome é Bob e eu tenho 30 anos.

Você ainda pode, mas não é necessário, enumerar as posições dos argumentos fornecidos dentro das chaves, veja um exemplo: "Olá, meu nome é {0} e eu tenho {1} anos.".format(nome, idade)".



Módulos​

Um módulo é um arquivo em Python que contém uma coleção de funções relacionadas. Antes usar um módulo devemos importar ela com o comando abaixo, em outras palavras um módulo é uma biblioteca contendo instruções, funções e classes.

# Importando o módulo math:
import math


Função​

Uma função é um pedaço de código que podemos reaproveitar sem ter que escrever ele diversas vezes.

#################################
#           Sintaxe             #
#################################
def name(<var>):
    <statement(s)>


def soma():
   num1 = int(input("Digite o primeiro numero: "))
   num2 = int(input("Digite o Segundo numero: "))

   print(num1 + num2)

soma()

Por padrão a endentação é de quatro espaços.


Quando se cria variáveis dentro de uma função, essas variáveis só vão existir dentro da função, ela é uma variável local daquela função. Para se obter o valor de uma variável de uma função usamos o return, por exemplo:

def teste(nome):
   nome = nome + ' Oliveira'
   return nome

a = teste('Joao')

print(a)

# Resultado: Joao Oliveira


Função com Argumentos​

Passando argumentos para uma função com:

def teste(name):
   print(name)

teste('bob')

# Resultado: bob

Função que muda o nome da variável que foi passada para ela, muda apenas o nome da variável. 

nome = 'Joao'
sobrenome = 'Eduardo'
ultimo = 'Oliveira'

def teste(S1, S2):
   print(S1, S2, ultimo)

teste(nome, sobrenome)

# Resultado: Joao Eduardo Oliveira


Estruturas de repetição​

As estruturas de repetição permitem a execução repetida de um bloco de código com base em determinadas condições ou contadores. Essas estruturas são valiosas para automatizar tarefas repetitivas e melhorar a eficiência dos programas.


For​

Normalmente usado quando você sabe a quantidade de iteração (repetições) que deverá ocorrer, normalmente usamos array, listas, ranges e outros métodos para controlar isso.

#################################
#           Estrutura           #
#################################
for <var> in <iterable>:
    <statement(s)>


## Usando 'range':
total = 0
vezes = 10
for number in range(vezes):
   total = total + 1
   print(total)
    
## Usando uma lista:
fruits = ["apple", "banana", "cherry"]
for lista in fruits:
  print(lista)

## Usando as letras de uma string:
for letra in "banana":
  print("Letra:", letra)

While​

Muito usado quando não sabemos quantas iterações (repetições) serão feitas, para isso usamos alguma variável booleana para determinar quando continuar ou sair do loop.

#################################
#           Estrutura           #
#################################
<var> = <controller>
while <var> <Comparation> <iterable>:
    <statement(s)>

    ou
<var> = <controller>
while (<var> <Comparation> <iterable>):
    <statement(s)>

# Comparation: 
# < 
# >
# <=
# >=

idade = int(15)
while (idade <= 40):
    idade = int(input("Você é novo, digite a idade de novo: "))


Estruturas de condições​

É uma estrutura que permite analisar resultados e com base nisso ter uma ação.



IF​

Estrutura de decisão com if.

#################################
#           Estrutura           #
#################################
if <var> <Comparation> <iterable>:
    <statement(s)>
elif <var> <Comparation> <iterable>:
    <statement(s)>
else:
    <statement(s)>

## O uso de parenteses é opcional para deixar o código mais limpo.


# Condições lógicas usadas no IF:
    Igual: a == b
    Diferente (não igual): a != b
    Menor que: a < b
    Menor que ou Igual a: a <= b
    Maior que: a > b
    Maior que ou Igual a: a >= b


nome = str(input("Digite seu nome: "))  # Exibindo na tela e pegando entrada do teclado.
# Não precisa converter para string, por default, tudo que vier do teclado já é string.

if (len(nome) >= 15):  # inicio do if, verifica se a quantidade de letras é maior ou igual a 15.
   print("Seu nome é grande.")

elif (len(nome) < 15) and (len(nome) >= 6):  # usando operador AND
   print("Seu nome tem um tamanho razoável.")

else:
   print("Seu nome é pequeno.")

## Extra:
print()
idade = int(input("Digite sua idaide: "))  # igual 'read -p ("") VAR'
# Estou pegando uma entrada do teclado, e convertendo ela para int, depois armazeno na variavel.

Testando se uma variável está vazia:

a = None

if a is None:
    print('Variavel vazia.')

else:
    print('Variavel nao vazia.')

Testando se uma variável é verdadeira ou falsa:

a = False

if a:
    print('Variavel verdadeira.')

else:
    print('Variavel falsa.')

Com o mesmo if acima é possível verificar se uma lista está vazia:

lista = []

if not lista:
    print('lista vazia!')
else:
    print('lista não esta vazia!')

# Resultado: lista vazia!

Usando AND:

a = False
b = False

if a and b:
    print('Tudo verdadeiro.')

else:
    print('Tudo falso.')

Usando OU:

a = False
b = False

if a or b:
    print('Alguém é verdadeiro.')

else:
    print('Nenhuma é verdadeira.')

Verificando se o valor de uma variável está dentro de uma lista ou dicionário:

## Primeiro com dicionário:
dici = {'size': 'fat', 'dia': 'feio'}
periodo = 'dia' 

if periodo in dici.keys():
    print(periodo, 'está dentro do dicionário')

else:
    print(periodo, 'não está dentro do dicionário')


## Usando lista (serve com tupla):



Módulo RANDOM​

A módulo random é usada para gerar numeros pseudo aleatorios. Vamos usar a função randint para gerar números pseudos aleatórios que sejam inteiros.

#################################
#           Sintaxe             #
#################################
random.randint(X,M)

# X = Menor número.
# M = Maior número.


import random

for aleatorio in range(5):
   print(random.randint(1,100))

# Gerar numeros para a loteria, hehe (entre 1 e 60):
print(random.randint(1,60))


Sample​

Usado para retornar um resultado, onde nós escolhemos o tamanho de caracteres que conterá o resultado, mas que o valor que será retornado seja aleatório, basicamente, embaralha a string e retorna um tamanho escolhido. Essa é parte básica dessa função, leia a doc da função para mais detalhes.

#################################
#      Sintaxe  Básica          #
#################################
random.sample(X,M)

# X = É de onde ele vai obter a informação.
# M = É o tamanho do resultado que será retornado.


import random

a = "arroz feijao carne"
random.sample(a, 12)
# ['a', ' ', 'o', 'r', 'c', ' ', 'z', 'a', 'a', 'j', 'e', 'i']

# Agora vamos usar o 'join' para remover essa lista (O valor retornado será uma string):
"".join(random.sample(a, 12))
# 'arr caieeofr'

"".join(random.sample(a, 12))
# 'oja a eorfre'

Veja um exemplo prático dessa função em uso para criar um gerador de senhas.



SYS​

O módulo sys é usada para interação com o script a partir de parametros especificos e funções. Isso acontece porque o sys interage com variáveis em uso e suas funções interagem direto com o interpretador.


A função exit é usada encerrar o script (sair do python), igual a: exit 0, exit 1 no bash, também são conhecidos como return codes no bash.

#################################
#           Sintaxe             #
#################################
sys.exit(N)

# N = Número de erro que será retornado para o Shell.


import sys
num = input("Digite um número de 0 até 10: ")

# Se você colocar 'if not num.isdigit()' - Voce pode ver se é um caractere'
if num.isdigit():  # Nao aceitou INT, verifica se é um número.

    if (int(num) >= 0) and (int(num) <= 10):
        print("Parabéns")
        sys.exit(0)

    else:
        print("Erro, número deve estar entre 0 e 10")
        sys.exit(12)

else:
   print("Erro, não foi digitado um número entre 0 até 10")
   sys.exit(10)


ARGV​

O exemplo abaixo demonstra como usar a função argv do módulo sys. Usado para obter parametros fornecidos via linha de comando ao iniciar o script.

#################################
#           Sintaxe             #
#################################
sys.argv(N)

# N = Número da posição do argumento na linha de comando.

####### ARQUIVO SCRIPT PYTHON #######
#!/usr/bin/env python3

import sys
arg1 = sys.argv[1]
arg2 = sys.argv[2]

print('Argumento 1:', arg1)
print('Argumento 2:', arg2)
####### ARQUIVO SCRIPT PYTHON #######

# Agora rode o comando:
$ chmod +x teste.py
$ ./teste.py deu-arg1 certo?-arg2
Argumento 1: deu-arg1
Argumento 2: certo?-arg2

Contando o número de argumentos:

#!/usr/bin/env python3

import sys

# Contando a quantidade de Argumentos, faço 'len(sys.argv) - 1' porque ele conta o arg 0,
# que é o nome do script.
print("Voce digitou",len(sys.argv)-1,"Argumentos.")

# Removendo o item 0 da lista, no caso o nome do script:
sys.argv.remove(sys.argv[0])

# Exibindo todos os argumentos:
print("args:",sys.argv)




Exceções​

Ao obter um erro no código significa que a execução irá falhar, e nós temos que saber como fazer nosso código ser mais inteligente e se precavir de alguns erros. Para isso adicionamos uma exceção ao código Python, segue o exemplo de um erro intencional mas que temos uma tratativa para ele:

def spam(divide):
   try:
       return 42 / divide
   except ZeroDivisionError:
       print("Erro, arg invalido.")

print(spam(2))
print(spam(12))
print(spam(0))
print(spam(1))

Junto com o try nós podemos usar o else antes do except para outras formas de trabalhar e ao final do try podemos usar o finally, ele será usado após encessar a cláusa do try, passando pelo except ou não, é muito usado para limpar o ambiente ou executar algo antes que o código seja encerrado.



Listas (Array em Shell Script)​

As listas podem conter diversos valores e se assemelham ao Array no Shell, as listas facilitam a criação de programas que lidem com grandes quantidades de dados. As listas também podem conter outras listas, e com isso, podemos usar elas para organizar os dados de forma hierárquica.

As listas começam sempre na posição 0.

# Criando uma lista
lista1 = [1, 2, 3, 4]
lista2 = ['laranja', 'mamão', 'maçã', 'uva']

# Listando tudo que está na lista:
print("Lista 1:",lista1)
print("Lista 2:",lista2)
print()

# Listar posições específicas
print("Posição 3 da lista 1:",lista1[3])  # Lista a 3 posição, mostra o numero 4
print("Posição 2 da lista 2:",lista2[2])  # lista a segunda posição, exibe 'maçã'
print()

# Exibir a quantidade de itens da lista:
print("A lista 1 tem",len(lista1),"itens.")
print("A lista 2 tem",len(lista2),"itens.")

# Trocando valor do item da lista
lista2[1] = 'morango' # Troca mamão por morango

# Apagando uma posição:
del lista2[3] # Apaga UVA

#### Criando uma lista dentro de outra lista:
lista3 = [[1, 2, 3, 4],['laranja', 'mamão', 'maçã', 'uva']]

# Lista tudo da lista:
print("Lista 3:",lista3)
print()

# Listar posições específicas
print("Posição 3 da lista 1 que esta dentro da lista3:",lista3[1][3])  # Lista a 3 posição da lista 1, retorna UVA
print()

# Exibir a quantidade de itens da lista:
print("A lista 3 tem",len(lista3),"listas.")
print("A lista 3 posição 0 tem",len(lista3[0]),"itens.")
print("A lista 3 posição 1 tem",len(lista3[1]),"itens.")

##### SLICE #####
# [N:M] 
# N = número começando em 0, é o ponto de partida;
# M = número começando em 1, é até onde deverá ser exibido.

# Imprimir usando um intervalo - slice
print(lista3[1][2:4]) # Imprimi o item 2 até 4 da lista 1 que estão dentro de lista3.

# Trocando valor do item da lista
lista3[1][1] = 'morango' - Troca mamão por morango

# Apagando uma posição
del lista2[1][3]


Método index()​

Usado para mostrar qual a posição de um dado na lista:

lista = ['joao', 'rodrigo', 'azeitona', 'picles']

lista.index('azeitona')
# 2


Método append()​

Usado para adicionr um item ao fim da lista:

# Adicionando no fim da lista

lista5 = ['joao', 'rodrigo']
lista6 = [['joao', 'rodrigo'], ['azeitona', 'picles']]

lista5.append('marcelo')
lista6[1].append('tomate')


Método insert()​

Similar ao append(), mas aqui devemos fornecer a posição em que vamos add a informação. Se você escolher uma posição que já tenha um dado, ele não será apagado, mas sim deslocado para frente.

# Aqui escolhemos a posição em que vamos adicionar.

lista5.insert(0,'bruno')


Método remove()​

Similar ao método del, mas com remove() temos que fornecer a string que será apagada:

lista5.remove('bruno')


Método pop()​

Usado para remover o ultimo dado da lista:

lista = ['joao', 'rodrigo', 'azeitona', 'picles']
lista.pop()
# 'picles'

print(lista)
# ['joao', 'rodrigo', 'azeitona']

# Também podemos fornecer qual dado será removido (assim como del):
lista.pop(1)
# 'rodrigo'

print(lista)
# ['joao', 'azeitona']


Método count()​

Retorna o número de vezes um dado aparece na lista:

lista = ['joao', 'rodrigo', 'joao', 'picles']

lista.count("joao")
# 2

# Com index, exibe apenas o primeiro match:
lista.index('joao')
# 0


Método reverse()​

Inverte a posição dos elementos dentro da lista:

lista = ['joao', 'rodrigo', 'joao', 'picles']
lista.reverse()

print(lista)
# ['picles', 'joao', 'rodrigo', 'joao']


Método sort()​

Usado para ordenar os dados dentro da lista:

lista5.sort()
lista6[0].sort()
lista6[1].sort()

# Ordena inversamente:
lista6[1].sort(reverse=True)

# Como o sort usa a tabela ASCII para ordenar,
# podemos ordenar de forma alfabética usando:
lista5.sort(key=str.lower)


TIME​

O módulo time fornece várias funções para se trabalhar com o tempo (horas/minutos/dias).



SLEEP​

Usado para fazer com que a execução do código espere X tempo antes de continuar:

import time

print("Esperando 5 segundos.")
time.sleep(5) # Espera 5 segundos
print("Pronto")


CTIME​

Mostra a data baseado em segundos, desde 31 de Dezembro de 1969 as 21:00:00, isso se for usado os segundos como argumentos, se nao for usado, mostra a data/hora atual.

import time

print(time.ctime()) # Mostra a data/hora atual

# Exibindo quando 500 segundos após a data informada acima:
>>> print(time.ctime(500))
Wed Dec 31 21:08:20 1969


Script - pega vários nomes e coloca numa lista​

nomes = []

while True:
   print('Entre com o nome', str(len(nomes) + 1), '- Aperte enter sem nada para parar')
   pega_nome = input()

   if pega_nome == '':
       break
   nomes += [pega_nome] # cincatenação de lista

print('Os nomes são:')
for nome_lista in nomes:
   print(' ' + nome_lista)


Script - Verifica se o convidado foi cadastrado​

É usado NOME in lista_ARRAY para retornar true ou false, vê se o nome esta lá, o not é o inverso.

convidados = ['joao','rodrigo','felipe','fabiano','marcia']

print ("Ve se o convidado está cadastrado.\n")
nome_conv = input("Digite o nome do convidado: ")

if nome_conv not in convidados:
   print("\nConvidado não cadastrado -",nome_conv)

else:
   print("\nConvidado cadastrado -",nome_conv)


Fazendo slicing e concatenação para criar uma nova string​

name = 'Zophie a cat'
print(name[0:7])
# 'Zophie '
print(name[8:12])
# ' cat'
print(name[0:7] + 'the' + name[8:12])
# Zophie the cat


Tuplas​

Uma tupla é igual a uma lista, porém, ao invés de ser criada com colchetes [] ela é criada com parenteses () e seu valor é imutável, ou seja, não pode ser alterado, adicionado ou removido.

lista_tupla = ('Hello', 1.5, 42, 'oi')


TYPE​

Podemos ver qual o tipo de objeto é o dado:

num = '42'
type(num)
# <class 'str'>

num = 42
type(num)
# <class 'int'>

dict = {'key1': 'value1', 'key2': 'value2'}
type(dict)
# <class 'dict'>


DIR​

Ao passar o objeto para o dir, ele nos informa uma lista com os atributos e métodos desse objeto, ou seja, ele nos informa as funções, módulos, strings, listas, dicionários e muito mais.

# Por exemplo, sabemos um dicionário nós temos 3 módulos básicos para trabalhar, são eles: keys, items e values.

# Vamos ver na prática:
print(dir(dict))
['__class__', '__contains__', '__delattr__', '__delitem__', '__dir__', '__doc__', '__eq__', '__format__', '__ge__', '__getattribute__', '__getitem__', '__gt__', '__hash__', '__init__', '__init_subclass__', '__iter__', '__le__', '__len__', '__lt__', '__ne__', '__new__', '__reduce__', '__reduce_ex__', '__repr__', '__reversed__', '__setattr__', '__setitem__', '__sizeof__', '__str__', '__subclasshook__', 'clear', 'copy', 'fromkeys', 'get', 'items', 'keys', 'pop', 'popitem', 'setdefault', 'update', 'values']
# Aqui podemos ver os módulos que citamos e muito mais.

# Listando os atributos de listas:
print(dir(list))
['__add__', '__class__', '__contains__', '__delattr__', '__delitem__', '__dir__', '__doc__', '__eq__', '__format__', '__ge__', '__getattribute__', '__getitem__', '__gt__', '__hash__', '__iadd__', '__imul__', '__init__', '__init_subclass__', '__iter__', '__le__', '__len__', '__lt__', '__mul__', '__ne__', '__new__', '__reduce__', '__reduce_ex__', '__repr__', '__reversed__', '__rmul__', '__setattr__', '__setitem__', '__sizeof__', '__str__', '__subclasshook__', 'append', 'clear', 'copy', 'count', 'extend', 'index', 'insert', 'pop', 'remove', 'reverse', 'sort']


Função HASATTR​

Usado para verificar se um objeto possui um atributo:

# Olhando a função keys() de dicionarios:
>>> hasattr(dict, "keys")
True

# Não pode usar os '()':
>>> hasattr(dict, "keys()")
False

# Olhando a função items() de dicionarios:
>>> hasattr(dict, "items")
True


Método list() - Convertendo tupla em lista​

lista_tupla = ('ola', 'oie')
list(lista_tupla)
# ['ola', 'oie']


Método copy() - Copiando valores​

import copy

lista2 = copy.copy(lista1)
# Faz uma cópia de algo mutável e não faz apenas uma referencia.


Dicionario​

O dicionário (dictionary) é uma coleção de diversos valores baseados em <chave>: <valor>. Sua forma é idêntica ao json, então muitos preferem trabalhar com dicionários sempre que possível.

## Criando um dicionário simples:
dicionario = {'size': 'fat', 'dia': 'feio'}

## Exibindo o valor da chave 'size':
print(dicionario['size'])
# fat

## Exibindo o valor da chave 'dia':
print(dicionario['dia'])
# feio

# Adicionando uma chave com valor no dicionário?
dicionario['rodrigo'] = '36 tim' # rodrigo é a chave e '36 tim' é o valor


Verificando se uma chave existe no dicionário​

## Criando um dicionário simples:
dicionario = {'size': 'fat', 'dia': 'feio'}

if 'size' in dicionario:
    print('A chave existe!')
else:
    print('A chave não existe!')


## Para verificar se não existe:
if 'size' not in dicionario:
    print('A chave não existe!')
else:
    print('A chave existe!')


Nós também podemos ter dicionários aninhados, que nada mais são do que dicionários dentro de dicionários.

#################################
#           Estrutura           #
#################################
<var_name> = {
    'chave': {'chave': 'valor'},
    'chave': {'chave': 'valor'},
}

## Criando um dicionário aninhado:
dicionario = {
    '1': {'size': 'fat', 'dia': 'feio'},
    '2': {'comida': 'Arroz e feijão', 'bebida': 'agua'}
}

print(dicionario['1'])
# {'size': 'fat', 'dia': 'feio'}

print(dicionario['2'])
# {'comida': 'Arroz e feijão', 'bebida': 'agua'}

print(dicionario['2']['bebida'])
# agua


Método values()​

Usado para retornar apenas os valores:

dicionario = {'size': 'fat', 'dia': 'feio'}

print(dicionario.values())
# dict_values(['fat', 'feio'])


Método keys()​

Usado para ver apenas as chaves do dicionário:

dicionario = {'size': 'fat', 'dia': 'feio'}

print(dicionario.keys())
# dict_keys(['size', 'dia'])


Método setdefault()​

Usado para definir um valor para uma chave caso ela não exista:

dicionario = {'size': 'fat', 'dia': 'feio'}

## Se a chave 'noite' não existir, vamos definir seu valor para 'escura':
dicionario.setdefault('noite', 'escura')

print(dicionario)
# {'size': 'fat', 'dia': 'feio', 'noite': 'escura'}


Método items()​

Usado para ver chave e valor:

dicionario = {'size': 'fat', 'dia': 'feio'}

print(dicionario.items())
# dict_items([('size', 'fat'), ('dia', 'feio')])


Método clear()​

Usado para limpar o dicionário, apagando todos os seus valores:

dicionario = {'size': 'fat', 'dia': 'feio'}

## Limpando o dicionário:
dicionario.clear()

print(dicionario)
# {}


Método get()​

Usado para retornar um o valor baseado na chave (igual a usar o colchetes como em print(dicionario['size'])):

dicionario = {'size': 'fat', 'dia': 'feio'}
dicionario.get('dia')
# 'feio'


Outros Métodos​

Vamos ver outros métodos que temos no python:



len()​

Já foi visto outras vezes, é usado para retornar o tamanho de strings (informando quantos caracteres possui), listas (informando quantos elementos possui), dicionários (informando quantas chaves possui) dentre outras formas que podemos usar o len().

lista = ['joao', 'rodrigo', 'joao', 'picles']
m = "teste"
dict_test = { '1': 'key1', '2': 'key2', '3': 'key3' }

len(lista)
# 4

len(m)
# 5

len(dict_test)
# 3


isdigit()​

Usado para verifica se é um número, porém, não trabalha com números:

lista = ['joao', 'rodrigo', 'joao', 'picles']
m = "teste"
n = 2

lista[0].isdigit()
# False

m.isdigit()
# False

n.isdigit()
# Traceback (most recent call last):
#  File "<stdin>", line 1, in <module>
# AttributeError: 'int' object has no attribute 'isdigit'


os.walk()​

Podemos usar o método walk() que está dentro do módulo os para procurar arquivos no Sistema Operacional, para isso você deve saber exatamente onde está o arquivo, vamos ver um exemplo:

import os

# Onde buscar os arquivos:
search_path = '/tmp/'

# Nome do arquivo a ser encontrado:
find_file = 'encontrar.txt'

for root, dir, files in os.walk(search_path):
    if find_file in files:
        print(os.path.join(root, find_file))


# Resultado: /tmp/encontrar.txt


## 'root' vai mostrar todos os diretórios dentro do caminho especificado.

## 'dirs' ou 'dir' vai gerar uma lista com diretórios, essa lista contém diretórios que estão abaixo de um mesmo diretório pai.

## 'files' vai mostrar todos os arquivos encontrados

Para casos onde não sabemos o nome completo, podemos fazer assim:

import os

# Onde buscar os arquivos:
search_path = '/tmp/'

# Nome do arquivo a ser encontrado:
find_file = 'encon'

for root, dir, files in os.walk(search_path):

    for match in files:
        if find_file in match:
            print(os.path.join(root, match))

            
# Resultado: /tmp/encontrar.txt


Orientação a Objetos​

De acordo com o site hashtagtreinamentos.

Orientação a objeto é basicamente a forma que você programa, ou seja, por padrão nós escrevemos linhas de códigos para o programa e ele vai executar cada linha normalmente. Isso quer dizer que nós estamos escrevendo as ações que serão feitas, o que é chamado de programação imperativa.

Agora dentro da programação orientada a objetos nós vamos criar um objeto e vamos dar para ele métodos e atributos. Isso quer dizer que não vamos simplesmente dar vários comandos para a máquina executar. Para simplificar vamos a um exemplo prático bem simples. Pense em um controle de ar-condicionado.

Ele é um objeto que tem atributos (características), ele vai ter uma cor, geralmente branco, tem botões, uma tela…

Além disso esse controle tem métodos, ou seja, tem o método de ligar, desligar, aumentar a temperatura, diminuir a temperatura, colocar um timer…



Classes​

De acordo com o site wikipedia (acesso em 28 de Agosto de 2022):

Em programação e na orientação a objetos, uma classe é um Tipo abstrato de Dados (TAD); ou seja, uma descrição que abstrai um conjunto de objetos com características similares (um projeto do objeto), é um código da linguagem de programação orientada a objetos que define e implementa um novo tipo de objeto, que terão características (atributos) que guardaram valores e, também funções específicas para manipular estes.[1] Formalmente, é um conceito que encapsula abstrações de dados e procedimentos que descrevem o conteúdo e o comportamento de entidades do mundo real, representadas por objetos.[2] De outra forma, uma classe pode ser definida como uma descrição das propriedades ou estados possíveis de um conjunto de objetos, bem como os comportamentos ou ações aplicáveis a estes mesmos objetos.


Abaixo segue a estrutura para implementar uma classe:

## Para definir uma classe:

class <nome>:
    ...

No lugar dos três pontos colocamos as variáveis e funções.



XXX​

D