PYTHON 3

Funktionen und OOPs

(HandsOn)
String-Methoden:
def stringmethod(para, special1, special2, list1, strfind): #
Schreiben Sie hier Ihren Code

word1 = '' newpara = '' für i in para:

wenn i in special1:
newpara += i
else:
word1 += i

rword2 = word1[:70]
rword2 = rword2[::-1]
print(rword2)

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

noSpace = special2.join(noSpace) drucken(noSpace)

flag = 0
für jeden in Liste1: wenn jeder in Absatz: weiter
else:
flag = 1 Pause

if flag:
print("Alle Zeichenfolgen in {0} waren nicht
vorhanden".fo rmat(list1))
else:
print("Jeder String in {0} war vorhanden".format
(list1))

splitted = word1.split()
print(splitted[:20])

ans = []
für jeden in geteilter:
if splitted.count(each) < 3:
if each not in ans:
ans.append(jeweils)

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

Magischer Konstantengenerator:
def generator_Magic(n1):
# Geben Sie hier Ihren Code ein

lst = []
für i im Bereich(3,n1+1):
M = i*(i*i + 1)/2 lst.append(M)

für i im Bereich(len(lst)): Ertrag lst[i]

Primzahlgenerator:
def primegenerator(num, val):
# Geben Sie hier Ihren Code ein
lst = []
lst1 = []
lst2 = []
ungerade=1
even=0

für i im Bereich(2, num+1):

wenn i>1:
für j im Bereich(2,i):
if (i % j) == 0: break;
else:
lst.append(i)

für i im Bereich(len(lst)):
if(i % 2 == 0):
lst1.append(lst[i]) gerade += 2
else:
lst2.append(lst[i])
ungerade +=2

if(val):
für i im Bereich(len(lst1)): Ertrag lst1[i]
else:
für i im Bereich(len(lst2)): Ertrag lst2[i]
Klassen und Objekte 1:
Aufgabe 1:
# Schreibe hier deinen Code Klasse Film:

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

self.cost = Kosten
def __str__(self):
return"Film : {self.name}\nAnzahl der Tickets : {sel
f.n}\ nGesamtkosten : {self.cost}".format(self=self)

Aufgabe 2:
#Gib hier deinen Code ein
class comp:
def __init__(self, a,b): self.a = a
selbst.b = b

def add(self,other):
print("Summe der beiden komplexen Zahlen :{}+{}i".forma
t(self.a + other.a, self.b + other.b))

def sub(self,other):
if(self.b>=other.b):
print("Subtraktion der beiden komplexen Zahlen :{
}+{}i“.format(self.a - other.a, self.b - other.b))
else:
print("Subtraktion der beiden komplexen Zahlen :{
}{}i“.format(self.a - other.a, self.b - other.b))

Klassen und Objekte 2:

Aufgabe 1:
#Schreibe hier deinen Code für die übergeordnete Klasse:
def __init__(self,t): self.t = t
 def display(self):

print("Anteil der Eltern ist {}

Millionen.".format(round((s elf.t)/2,2)))

klasse Sohn(Elternteil):
def __init__(self, t, sp):
selbst.sp = sp
parent.__init__(self,t)

def son_display(self):
Percentage_for_son = (selbst.t*selbst.sp)/100
print("Anteil des Sohnes ist {}
Millionen.".format(round(Percen tage_for_son,2)))
print("Total Asset Worth is {} Million.".format(round(s
elf.t,2)))

klassentochter (Elternteil):
def __init__(self, t, dp):
selbst.dp = dp
parent.__init__(self,t)

def tochter_anzeigen(selbst):
Percentage_for_daughter = (self.t*self.dp)/100
print("Anteil der Tochter ist {}
Millionen.".format(round(P ercentage_for_daughter,2)))
print("Total Asset Worth is {} Million.".format(round(s
elf.t,2)))

Aufgabe 2:
# Schreibe deinen Code hier Klassenrechteck:

def display(self):
print("Das ist ein Rechteck")

def-Bereich (self, a, b): self.a = a self.b = b

print("Fläche des Rechtecks ist {}".format(self.a * self.b))

klassenplatz :
def display(self):
print("Das ist ein Quadrat")

def area(self,a): self.a = a print("Fläche des Quadrats ist

{}".format(self.a * self.a))
Module 1:
Datum/Uhrzeit
datum/Uhrzeit importieren
def dateandtime(val,tup):
# Geben Sie hier Ihren Code ein
l = []
wenn val == 1:
c1 = datetime.date(tup[0],tup[1],tup[2])
l.append(c1)
l.append(c1.strftime("%d")+"/"+c1.strftime("%m")+"/"
+c1.strftime("%Y"))

elif val == 2:
c1 = datetime.date.fromtimestamp(tup[0])
l.append(c1)

elif val == 3:
c1 = datetime.time(tup[0],tup[1],tup[2])
l.append(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],
tup[4],tup[5])
l.append(c1)

return l
Module 2: Itertools
itertoolsimportieren
import-Operator

def performIterator(Tupelwerte):
# Geben Sie hier Ihren Code ein
l1 = []
ans = []

temp = itertools.cycle(Tupelwerte[0])

count = 0
für i in temp:
l1.append(i)
count+=1
if count == 4:
pause
ans.append(Tupel(l1))

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

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

ans.append(Tupel(Liste(Temp)))

temp = itertools.chain(Tupelwerte[0],Tupelwerte[1],Tuplev
alues[2],Tupelwerte[3])
ans.append(Tupel(Liste(Temp)))

tempForTask5 = Liste(itertools.chain(Tupelwerte[0],Tupelwert
ues[1],Tupelwerte[2],Tupelwerte[3]))

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

ans.append(Tupel(Liste(Temp2)))

rückgabetupel (ans)

Module 3: Kryptographie
aus cryptography.fernet import Fernet def encrdecr(keyval,
textencr, textdecr):
 # Geben Sie hier Ihren Code ein
mainList = []
f = Fernet(Schlüsselwert)
mainList.append(f.encrypt(textencr))
d = f.decrypt(textdecr) mainList.append(d.decode())

return mainList

Module 4: Kalender
kalender importieren
datum/Uhrzeit importieren

def checkLeapYear(Jahr):
wenn (Jahr % 4) == 0:
if (year % 100) == 0:
if (year % 400) == 0: return 1
else:
return 0
else:
return 1
else:
return 0

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

lEAP = checkLeapYear(Jahr)

wenn LEAP == 1:
month = 2

else:
month = datetuple[1]

drucken(Kalender.Monat(Jahr,Monat))

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

m = calendar.monthcalendar(Jahr, Monat)
montags = [Woche[0] für Woche in m wenn Woche[0]>0] Tag =
montags[-1]
 lst = []
MONAT = Monat
JAHR = Jahr

für i im Bereich(7):
d = datetime.date(Jahr,Monat,Tag)

lst.append(d)

wenn (LEAP == 1) und (Monat == 2):

wenn(Tag == 29):
tag = 0
wenn(Monat == 12):
month = 1
jahr = Jahr + 1
else:
month = month + 1

elif (LEAP == 0) und (Monat == 2):

wenn(Tag == 28):
tag = 0
wenn(Monat == 12):
month = 1
jahr = Jahr + 1
else:
month = month + 1
else:

wenn((Monat == 1) oder (Monat == 3) oder (Monat == 5) oder

(Monat == 7) oder (Monat == 8) oder(Monat == 10) oder
(Monat == 12)) und (Tag == 31):

tag = 0
wenn(Monat == 12):
month = 1
jahr = Jahr + 1
else:
month = month + 1

elif((Monat == 4) oder (Monat == 6) oder (Monat == 9) oder

(Monat == 11)) und (Tag == 30):
tag = 0
wenn(Monat == 12):
month = 1
jahr = Jahr + 1
else:
month = month + 1
 tag = Tag + 1

print(lst)

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

a = (datetime.datetime(JAHR,MONAT,1))
starting_day = a.strftime("%A")

days = ["Montag", "Dienstag", "Mittwoch", "Donnerstag", "Freitag",

"Samstag", "Sonntag" ]
count= [4 für i im Bereich(0,7)]
pos=-1
für i im Bereich(0,7):
if (starting_day == Tage[i]):
pos = i
pause

drucken(Tage[pos])
Module 5: Kollektionen
kollektionen importieren
def collectionfunc(text1, dictionary1, key1, val1, deduct, l
ist1):
# Geben Sie hier Ihren Code ein
d = {}
für jeden in text1.split():
wenn jeweils in d:
d[each] += 1
else:
d[each] = 1
sort_d = dict(sortiert(d.items(), key = lambda kv:kv[0]))
print(sort_d)

cou = collections.Counter(Wörterbuch1)
für jeden in Abzug:
cou[each] -= Abzug[each]

print(dict(cou))

orde = collections.OrderedDict()
für i im Bereich(len(key1)):
orde[key1[i]] = val1[i]

del orde[key1[1]]

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

print(dict(orde))

d4 = {"odd":[], "even":[]}
für i in Liste1:
if i%2==0:
temp = d4["gerade"] temp.append(i) d4["gerade"] =
temp
else:
temp = d4["ungerade"]

temp.append(i)
d4["ungerade"] = temp
if d4["even"] == []:
 del d4
if d4["odd"] == []:
del d4
print(d4)

Handling Exceptions 1:
def Handle_EXC1():
# Geben Sie hier Ihren Code ein
a = int(input())
b = int(input())

wenn(a>150 oder b<100):

print("Integer-Wert außerhalb des Bereichs eingeben.");
elif(a + b) > 400:
print("Ihre Summe liegt außerhalb des zulässigen
Bereichs")
else:
print("Alles im Sortiment")
Ausnahmen 2:
def FORLoop():
# Geben Sie hier Ihren Code ein
n = int(input())
l1 = []
für i im Bereich(n):
l1.append(int(input()))

print(l1)
iter1 = iter(l1)

für i im Bereich(len(l1)):
drucken(weiter(iter1))

return iter1

Handling Exceptions 3:
def Bank_ATM(Saldo,Auswahl,Betrag):
# Gib hier deinen Code ein
flag = 0
wenn Saldo < 500:
print("Gemäß der Mindestsaldo-Richtlinie muss der Saldo
mindestens 500 betragen")
else:
if(choice == 1):
wenn Betrag < 2000:
print("Der Mindesteinzahlungsbetrag sollte 2000
betragen.")
else:
flag = 1
saldo += Betrag
if(choice == 2):
wenn(Saldo - Betrag)<500:
print("Sie können diesen fälligen Betrag nicht
an die Mindestguthaben-Richtlinie abheben")

else:
flag = 1 Saldo -= Betrag
 if(flag):
print("Aktualisierter Saldobetrag: {}".format(Saldo))

Handling Exceptions 4:
def Bibliothek(Mitgliedsgebühr,Rate,Buch): # Schreiben Sie Ihren
Code hier, wenn(Rate > 3):
print("Maximal zulässige Anzahl von Raten ist 3")

else:
wenn (Rate == 0):
print("Anzahl der Raten kann nicht Null sein.")
sonst:
print("Betrag pro Rate ist {}".Format(Mitglied
entgelt/Rate))

ListOfBooks = ["Philosophenstein","Kammer der sec

rets","Gefangener von Azkaban ","Feuerkelch","Orden von Phoenix
"," Halbblutpreis "," Heiligtümer des Todes 1","Heiligtümer des
Todes 2"]

book = book.lower()
bei Buchung in ListOfBooks:
print("Es ist in diesem Abschnitt verfügbar")
sonst:
print("In diesem Abschnitt existiert kein
solches Buch")