PÍTON 3

Funções e OOPs
(Mão na massa)
Métodos String:
def stringmethod(para, special1, special2, list1, strfind): #
Escreva seu código aqui

word1 = ' ' newpara = '' para i no para:

Se eu em especial1:
newpara += i
senão:
palavra1 += i

rword2 = palavra1[:70]
rword2 = rword2[::-1]
impressão(rword2)

noSpace = rword2.replace(" ", "")

noSpace = special2.join(noSpace) print(noSpace)

bandeira = 0
para cada um na lista1: se cada um no pará: continuar
senão:
bandeira = 1 quebra

se bandeira:
print("Todas as cordas em {0} não estavam
presentes".fo rmat(list1))
senão:
print("Todas as cordas em {0} estavam
presentes".formato (lista1))

dividido = palavra1.split()
impressão (dividida[:20])

ans = []
para cada um em fracionado:
if splitted.count(each) < 3:if each
not in ans:
ans.append(cada)

impressão(ans[-20:])
 print(word1.rindex(strfind))

Gerador de Constante Mágica:

def generator_Magic(n1):
# Escreva seu código aqui

lst = []
para i no intervalo(3,n1+1):
M = i*(i*i + 1)/2 lst.append(M)

para i na faixa(len(lst)): rendimento lst[i]

Gerador de números primos:
def primegenerator(num, val):
# Escreva seu código aqui
lst = []
lst1 = []
lst2 = []
ímpar=1
par=0

para i no intervalo(2, num+1):

Se I>1:
para j no intervalo(2,i):
se (i % j) == 0: quebra;
senão:
lst.apêndice(i)

Para i no intervalo(Len(LST)):
se(i % 2 == 0):
lst1.append(lst[i]) par += 2
senão:
lst2.append(lst[i])
ímpar +=2

if(val):
Para i na faixa(Len(LST1)): rendimento LST1[i]
senão:
Para i na faixa(Len(LST2)): rendimento LST2[i]
Classes e objetos 1:
Tarefa 1:
# Escreva seu código aqui classe Filme:

def __init__(self,name,n,cost): self.name = nome self.n = n

self.cost = custo
def __str__(próprio):
return"Filme : {self.name}\nNúmero de Ingressos : {sel
f.n}\nCusto Total : {self.cost}".formato(self=self)

Tarefa 2:
#Write seu código aqui
Composição da Classe :
def __init__(self, a,b): self.a = a
self.b = b

def add(self, outro):

print("Soma dos dois números complexos :{}+{}i".forma
t(self.a + other.a, self.b + other.b))

def sub(self, other):

if(self.b>=other.b):
print("Subtração dos dois números complexos :{
}+{}i". formato(self.a - other.a, self.b - other.b))
senão:
print("Subtração dos dois números complexos :{
}{}i". formato(self.a - other.a, self.b - other.b))

Classes e Objetos 2:
Tarefa 1:
#Write seu código aqui pai de classe :
def __init__(self,t): self.t = t
 def display (auto):

print("Participação dos pais é {}

milhão.".formato(redondo((s elf.t)/2,2)))

Classe Filho (pai):

def __init__(self, t, sp):
self.sp = sp
parent.__init__(auto,t)

def son_display(próprio):
Percentage_for_son = (self.t*self.sp)/100
print("Participação do Filho é {}
Milhão.".formato(redondo(Percen tage_for_son,2)))
print("Valor Total do Ativo é {}
Milhões.".formato(redondo(s elf.t,2)))

Filha da classe (pais):

def __init__(self, t, dp):
auto.dp = dp
parent.__init__(auto,t)

def daughter_display(self):
Percentage_for_daughter = (self.t*self.dp)/100
print("Participação da Filha é {}
Milhão.".formato(redondo(P ercentage_for_daughter,2)))
print("Valor Total do Ativo é {}
Milhões.".formato(redondo(s elf.t,2)))

Tarefa 2:
# Escreva seu código aqui retângulo de classe :

def display (auto):

print("Este é um retângulo")

def área(self, a, b): self.a = a self.b = b

print("Área do Retângulo é {}".formato(self.a * self.b))

Praça da Classe :
def display (auto):
print("Isto é um Quadrado")

def area(self,a): self.a = uma impressão("Área do quadrado é

{}".formato(self.a * self.a))
Módulos 1: Data e
hora datetime
importar
def dateandtime(val,tup):
# Escreva seu código aqui
l = []
Se val == 1:
c1 = datetime.date(tup[0],tup[1],tup[2])
l.apêndice(c1)
l.append(c1.strftime("%d")+"/"+c1.strftime("%m")+"/"
+c1.strftime("%Y"))

Elif Val == 2:
c1 = datetime.date.fromtimestamp(tup[0])
l.apêndice(c1)

Elif Val == 3:
c1 = datetime.time(tup[0],tup[1],tup[2])
l.apêndice(c1)
l.append(c1.strftime("%I"))

Elif Val == 4:
c1 = datetime.date(tup[0],tup[1],tup[2])
l.append(c1.strftime("%A"))
l.append(c1.strftime("%B"))
l.append(c1.strftime("%j"))

Elif Val == 5:
c1 = datetime.datetime(tup[0],tup[1],tup[2],tup[3],t
up[4],tup[5])
l.apêndice(c1)

retorno l
Módulos 2: Itertools
importar itertools
operador de importação

def performIterator(tuplevalues):
# Escreva seu código aqui
l1 = []
ans = []

temp = itertools.cycle(tuplevalues[0])

contagem = 0
Para eu em temp:
l1.apêndice(i)
contagem+=1
se contar == 4:
quebrar
ans.append(tupla(l1))

ans.append(tuple(list(itertools.repeat(tuplevalues[1][0],le
n(tuplevalues[1])))))

temp = itertools.cumul(tuplevalues[2], operator.add)

ans.append(tupla(list(temp)))

temp = itertools.chain(tuplevalues[0],tuplevalues[1],tuplev
alues[2],tuplevalues[3])
ans.append(tupla(list(temp)))

tempForTask5 = list(itertools.chain(tuplevalues[0],tupleval
ues[1],tuplevalues[2],tuplevalues[3]))

temp2 = itertools.filterfalse(lambda x:x%2==0,tempForTask5)

ans.append(tupla(list(temp2)))

Tupla de retorno (ans)

Módulos 3: Criptografia
de cryptography.fernet import Fernet def encrdecr(keyval,
textencr, textdecr):
 # Escreva seu código aqui
mainList = []
f = Fernet(keyval)
mainList.append(f.encrypt(textencr))
d = f.decrypt(textdecr) mainList.append(d.decode())

return mainList

Módulos 4: Calendário
Importar calendário
importar datetime

def checkLeapYear(ano):
se (ano % 4) == 0:
se (ano % 100) == 0:
if (ano % 400) == 0: retorno 1
senão:
retornar 0
senão:
retornar 1
senão:
retornar 0

def usingcalendar(datetuple): ano = datetuple[0]

leap = checkLeapYear(ano)

Se salto == 1:
mês = 2

senão:
mês = datetuple[1]

impressão(calendário.mês(ano,mês))

#----------------------------------------

m = calendário.mêscalendário(ano, mês)
segundas-feiras = [semana[0] para semana em m se semana[0]>0] dia
= segundas-feiras[-1]
 lst = []
MÊS = mês
ANO = ano

para i no intervalo(7):
d = datetime.date(ano,mês,dia)

lst.apêndice(d)

se (salto == 1) e (mês == 2):

if(dia == 29):
dia = 0
if(mês == 12):
mês = 1
ano = ano + 1
senão:
mês = mês + 1

elif (salto == 0) e (mês == 2):

se(dia == 28):
dia = 0
if(mês == 12):
mês = 1
ano = ano + 1
senão:
mês = mês + 1
senão:

se((mês == 1) ou (mês == 3) ou (mês == 5) ou (mês == 7) ou

(mês == 8) ou(mês == 10) ou (mês == 12)) e (dia ==
31):

dia = 0
if(mês == 12):
mês = 1
ano = ano + 1
senão:
mês = mês + 1

elif((mês == 4) ou (mês == 6) ou (mês == 9) ou

(mês == 11)) e (dia == 30):
dia = 0
if(mês == 12):
mês = 1
ano = ano + 1
senão:
mês = mês + 1
 dia = dia + 1

Impressão(LST)

#----------------------------------------------------------------

a = (datetime.datetime(ANO,MÊS,1))
starting_day = a.strftime("%A")

dias = [ "Segunda-feira", "Terça-feira", "Quarta-feira", "Quinta-

feira", "Frid ay", "Sábado", "Domingo" ]
contagem= [4 para i no intervalo(0,7)]
pos=-1
para i na faixa (0,7):
se (starting_day == dias[i]):
POS = i
quebrar

Impressão(dias[POS])
Módulos 5: Coleções
Importar coleções
def collectionfunc(text1, dictionary1, key1, val1, deduct, l
ist1):
# Escreva seu código aqui
d = {}
para cada um em text1.split():
Se cada um em D:
d[cada] += 1
senão:
d[cada] = 1
sort_d = dict(sorted(d.items(), key = lambda kv:kv[0]))
print(sort_d)

cou = coleções. Contador(dicionário1)

para cada um em deduzir:
cou[cada] -= deduzir[cada]

impressão(dict(cou))

orde = coleções. OrderedDict()

para i no intervalo(len(key1)):
orde[key1[i]] = val1[i]

del orde[key1[1]]

orde[key1[1]] = val1[1]

impressão(ditado(orde))

d4 = {"ímpar":[], " par":[]}

Para i na lista1:
Se I%2==0:
temp = d4["even"] temp.append(i) d4["even"] = temp
senão:
temp = d4["ímpar"]

temp.append(i)
d4["ímpar"] = temp
se d4["par"] == []:
del d4["mesmo"]
 se d4["ímpar"] == []:
del d4["ímpar"]
Impressão(D4)

Manipulando exceções 1:
Def Handle_Exc1():
# Escreva seu código aqui
a = int(input())
b = int(input())

Se(A>150 ou B<100):
print("Valor de inteiros de entrada fora do
intervalo.");
elif(a + b) > 400:
print("Sua soma está fora do alcance")
senão:
print("Tudo ao alcance")
Exceções 2:
Def FORLoop():
# Escreva seu código aqui
n = int(input())
l1 = []
Para i no intervalo (n):
l1.append(int(input()))

Impressão(L1)
iter1 = iter(l1)

Para i na faixa (len(l1)):

impressão(next(iter1))

retornar iter1

Manipulando exceções 3:
Def Bank_ATM(saldo, escolha, montante):
# Escreva seu código aqui
bandeira = 0
se o saldo < 500:
print("De acordo com a Política de Saldo Mínimo, o Saldo
deve ser de pelo menos 500")
senão:
if(escolha == 1):
se montante < 2000:
print("O valor mínimo de depósito deve ser
2000.")
senão:
bandeira = 1
saldo += valor
if(escolha == 2):
if(saldo - montante)<500:
print("Você não pode retirar este valor devido t
o Política de Saldo Mínimo")

senão:
flag = 1 saldo -= valor
 if(bandeira):
print("Valor do Saldo Atualizado:
{}".format(equilíbrio))

Manipulando exceções 4:
Def Biblioteca(taxa de membro, parcelamento, livro): # Escreva
seu código aqui se(parcelamento > 3):
print("Número máximo permitido de parcelas é 3")

senão:
se (parcela == 0):
print("Número de Parcelas não pode ser Zero.")
senão:
print("Valor por Parcela é {}".format(membro
taxa/parcela))

ListOfBooks = ["pedra filosofal","câmara de sec

Rets", "Prisioneiro de Azkaban", "Cálice de Fogo", "Ordem de
Fênix IX", "Preço Meio Sangue", "Relíquias da Morte 1",
"Relíquias da Morte 2"]

livro = book.lower()
se reservar em ListOfBooks:
print("Está disponível nesta seção") else:
print("Não existe tal livro nesta seção")