PYTHON 3

Funcții și OOP-uri
(HandsOn)
Metode de șir:
def stringmethod(para, special1, special2, list1, strfind): #
Scrie codul aici

word1 = ' ' newpara = ' ' pentru i în para:

Dacă i în special1:
Newpara + = i
altfel:
cuvânt1 += i

rword2 = word1[:70]
rword2 = rword2[::-1]
Imprimare(Rword2)

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

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

steag = 0
pentru fiecare din listă1: dacă fiecare din alin.
altfel:
steag = 1 pauză

dacă pavilionul:
imprimare ("Fiecare șir din {0} nu era prezent".fo
rmat(list1))
altfel:
imprimare ("Fiecare șir din {0} a fost
prezent".Format (listă1))

divizat = word1.split()
tipărit(despicat[:20])

ans = []
pentru fiecare în splitted:
dacă splitted.count(each) < 3:dacă
fiecare nu este în ans:
ans.append(fiecare)

imprimare(ans[-20:])
 imprimare(word1.rindex(strfind))

Generator de constante magice:

def generator_Magic(n1):
# Scrie codul tău aici

lst = []
pentru i în interval (3,n1+1):
M = i*(i*i + 1)/2 lst.append(M)

pentru i în interval(len(lst)): randament lst[i]

Generator de numere prime:
def primegenerator (num, val):
# Scrie codul tău aici
lst = []
lst1 = []
lst2 = []
impar = 1
par=0

pentru i în interval(2, num+1):

Dacă I>1:
pentru j în interval(2,i):
dacă (i % j) == 0: rupere;
altfel:
lst.apend(i)

pentru i în interval [len(lst)]:

if(i % 2 == 0):
lst1.apend(lst[i]) par += 2
altfel:
lst2.apend(lst[i])
impar +=2

if(val):
pentru i în interval(len(lst1)): randament lst1[i]
altfel:
Pentru i în interval(len(lst2)): randament lst2[i]
Clase și obiecte 1:
Sarcina 1:
# Scrie codul tau aici clasa Film:

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

self.cost = cost
def __str__(auto):
return"Film : {self.name}\nNumăr de bilete : {sel f.n}\
nCost total : {self.cost}".format(self=self)

Sarcina 2:
#Write codul aici
Comp. clasei:
def __init__(sine, a, b): sine.a = a
sine.b = b

def add(auto,altele):
print("Suma celor două numere complexe :{}+{}i".forma
t(self.a + other.a, self.b + other.b))

def sub(auto,altele):
if(self.b>=other.b):
print("Scăderea celor două numere complexe :{
}+{}i". format(self.a - other.a, self.b - other.b))
altfel:
print("Scăderea celor două numere complexe :{
}{}i". format(self.a - other.a, self.b - other.b))

Clase și obiecte 2:
Sarcina 1:
#Write codul tău aici părinte de clasă :
def __init__(self,t): self.t = t
 Afișaj DEF (auto):

print("Cota părinților este {}

milioane.".format(rotund((s elf.t)/2,2)))

Fiul clasei (părinte):

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

def son_display(auto):
Percentage_for_son = (self.t*self.sp)/100
tipări("Cota Fiului este {}
Million.".format(rotund(Percen tage_for_son,2)))
print("Valoarea totală a activului este {}
milioane.".format(rotund(s elf.t,2)))

fiica clasei(părinte):
def __init__(auto, t, dp):
auto.dp = dp
parent.__init__(sine,t)

def daughter_display(auto):
Percentage_for_daughter = (self.t*self.dp)/100
print("Cota fiicei este {} milioane.".format(rundă(P
ercentage_for_daughter,2)))
print("Valoarea totală a activului este {}
milioane.".format(rotund(s elf.t,2)))

Sarcina 2:
# Scrie codul tău aici dreptunghi de clasă:

Afișaj DEF (auto):

imprimare ("Acesta este un dreptunghi")

Def Area(Self, A, B): Self.a = A Self.B = B

print("Aria dreptunghiului este {}".format(self.a * self.b))

Pătratul clasei :
Afișaj DEF (auto):
imprimare ("Acesta este un pătrat")

def area(self,a): self.a = o imprimare("Aria pătratului este

{}".format(self.a * self.a))
Module 1: Data Ora
Ora importului
def dateandtime (val, tup):
# Scrie codul tău aici
l = []
Dacă Val == 1:
c1 = datetime.date(tup[0],tup[1],tup[2])
L.Apend(C1)
l.append(c1.strftime("%d")+"/"+c1.strftime("%m")+"/"
+c1.strftime("%Y"))

Elif Val == 2:
c1 = datetime.date.fromtimestamp(tup[0])
L.Apend(C1)

Elif Val == 3:
c1 = datetime.time(tup[0],tup[1],tup[2])
L.Apend(C1)
l.apend(c1.strftime("%I"))

Elif Val == 4:
c1 = datetime.date(tup[0],tup[1],tup[2])
l.apend(c1.strftime("%A"))
l.apend(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.Apend(C1)

retur l
Modulele 2: Itertools
Importul iterTools
Operator import

def performIterator(tuplevalues):
# Scrie codul tău aici
l1 = []
ans = []

temp = itertools.cycle(tuplevalues[0])

număr = 0
Pentru i in temp:
L1.Apendice(i)
număr+=1
Dacă numărați == 4:
sparge
ans.append(tuple(l1))

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

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

ans.append(tuple(list(temp)))

temp = itertools.chain(tuplevalues[0],tuplevalues[1],tuplev
alues[2],tuplevalues[3])
ans.append(tuple(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(tuple(list(temp2)))

Tur(ans) de întoarcere

Modulele 3: Criptografie
din cryptography.fernet import Fernet def encrdecr(keyval,
textencr, textdecr):
 # Scrie codul tău aici
mainList = []
f = Fernet (cheie)
mainList.append(f.encrypt(textencr))
d = f.decrypt(textdecr) mainList.append(d.decode())

returnați lista principală

Modulele 4: Calendar
Calendarul de import
Ora importului

def checkLeapYear(an):
dacă (anul % 4) == 0:
dacă (anul % 100) == 0:
if (anul % 400) == 0: rentabilitate 1
altfel:
retur 0
altfel:
Returnarea 1
altfel:
retur 0

def folosindcalendar(datetuple): an = datetuple[0]

leap = checkLeapYear(an)

Dacă bisect == 1:
lună = 2

altfel:
lună = datetuple[1]

print(calendar.lună(an,lună))

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

m = calendar.lunăcalendar(an, lună)
luni = [săptămână[0] pentru săptămână în m dacă săptămână[0]>0] zi
= luni[-1]
 lst = []
LUNĂ = lună
ANUL = anul

pentru i în interval(7):
d = datetime.date(an, lună, zi)

lst.apend(d)

dacă (bisect == 1) și (luna == 2):

IF(ziua == 29):
zi = 0
IF(luna == 12):
lună = 1
an = an + 1
altfel:
lună = lună + 1

Elif (leap == 0) și (luna == 2):

IF(ziua == 28):
zi = 0
IF(luna == 12):
lună = 1
an = an + 1
altfel:
lună = lună + 1
altfel:

dacă((luna == 1) sau (luna == 3) sau (luna == 5) sau (luna

== 7) sau (luna == 8) sau (luna == 10) sau (luna ==
12)) și (ziua == 31):

zi = 0
IF(luna == 12):
lună = 1
an = an + 1
altfel:
lună = lună + 1

ELIF((Luna == 4) sau (Luna == 6) sau (Luna == 9) sau

(luna == 11)) și (ziua == 30):
zi = 0
IF(luna == 12):
lună = 1
an = an + 1
altfel:
lună = lună + 1
 zi = zi + 1

Imprimare(LST)

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

a = (datetime.datetime(AN,LUNĂ,1))
starting_day = a.strftime("%A")

zile = [ "Luni", "Marti", "Miercuri", "Joi", "Frid ay", "Sambata",

"Duminica" ]
număr= [4 pentru i în interval(0,7)]
pos=-1
pentru i în interval (0,7):
dacă (starting_day == zile[i]):
POS = i
sparge

print(zile[pos])
Module 5: Colecții
Importați colecții
Def CollectionFunc(text1, dicționar1, cheie1, val1, deducere, l
ist1):
# Scrie codul tău aici
d = {}
Pentru fiecare în text1.split():
Dacă fiecare în D:
d[fiecare] += 1
altfel:
d[fiecare] = 1
sort_d = dict(sortat(d.items(), cheie = lambda kv:kv[0]))
print(sort_d)

cou = colecții. Contor(dicționar1)

Pentru fiecare din deducere:
cou[fiecare] -= deduce[fiecare]

print(dict(cou))

orde = colecții. ComandatDict()

Pentru i în interval(LEN(Key1)):
orde[cheie1[i]] = val1[i]

del orde[cheie1[1]]

orde[cheie1[1]] = val1[1]

print(dict(orde))

d4 = {"impar":[], " par":[]}

pentru i din lista 1:
Dacă i%2==0:
temp = d4["chiar"] temp.append(i) d4["par"] = temp
altfel:
temp = d4["impar"]

Anexă temp.(i)
d4["impar"] = temp
dacă d4["par"] == []:
del d4["chiar"]
 dacă d4["impar"] == []:
del d4["impar"]
Imprimare(D4)

Excepții de manipulare 1:
Def Handle_Exc1():
# Scrie codul tău aici
a = int(intrare())
b = int(intrare())

dacă(a>150 sau b<100):

print("Valoarea numerelor întregi de intrare în afara
intervalului.");
ELIF (A + B) > 400:
tipărire ("Suma lor este în afara intervalului")
altfel:
imprimare ("All in range")
Excepții 2:
Def FORLoop():
# Scrie codul tău aici
n = int(intrare())
l1 = []
pentru i în intervalul (n):
l1.apend[int(intrare())]

Imprimare(L1)
iter1 = iter(l1)

pentru i în interval [len(L1)]:

imprimare(următorul(iter1))

returnare ITER1

Excepții de manipulare 3:
Def Bank_ATM(sold, alegere, sumă):
# Scrie codul tău aici
steag = 0
dacă soldul < 500:
imprimare ("Conform politicii privind soldul minim,
soldul trebuie să fie de cel puțin 500")
altfel:
if(alegere == 1):
dacă suma < 2000:
imprimare ("Suma minimă a depozitului trebuie să
fie de 2000.")
altfel:
steag = 1
sold += sumă
if(alegere == 2):
dacă(sold - sumă)<500:
print("Nu puteți retrage această sumă din cauza
unei politici privind soldul minim");

altfel:
steag = 1 sold -= sumă
 if(pavilion):
print("Suma soldului actualizat: {}".format(echilibru))

Excepții de manipulare 4:
Def Bibliotecă (taxă de membru, rată, carte): # Scrieți codul
aici dacă (tranșa > 3):
print("Numărul maxim permis de rate este de 3");

altfel:
dacă (tranșă == 0):
print("Numărul de rate nu poate fi zero.")
altundeva:
print("Suma per rată este {}".format(membru
taxă/rată))

ListOfBooks = ["piatra filozofală","camera sec

Rets", "Prizonierul din Azkaban", "Pocalul de Foc", "Ordinul lui
Phoen al IX-lea", "Prețul pe jumătate de sânge", "Talismanele
Morții 1", "Talismanele Morții 2"]

carte = carte.lower()
dacă rezervați în ListOfBooks:
print("Este disponibil în această secțiune")
altundeva:
tipărire ("Nu există o astfel de carte în
această secțiune")