[Python-Grundlagen]

Python-Installation

Idle: eine einfache Entwicklungsumgebung, die mit Python geliefert wird

Ausgabefunktion print()

1. Drucken wird ausgegeben

1. Nummer
2. String (muss in Anführungszeichen gesetzt werden)
3. Ausdrücke, die Operatoren enthalten (z. B. 3+1, wobei 3 und 1 Operanden sind und + der Operator ist) (operieren)

#输出数字
print (98.5)

#输出字符串
print ("Hello, clovershrub")
print('hello,world')

#输出表达式
print(3+1)

2. Die Funktion print() kann auch das Ziel der Inhaltsausgabe festlegen

1. Monitor
2. dokumentieren:

fp=open(‘D:/text.txt’,”a+”)#文件不存在就创建，存在就在文件内容后面继续追加
print(‘helloworld‘,file=fp)
fp.close()

Hinweis: Der angegebene Laufwerksbuchstabe existiert, verwenden Sie file=fp
3. Das Ausgabeformat der print()-Funktion

1. Neue Zeile
2. Keine Zeilenumbrüche: verwenden, teilen,print(‘hello’,’world‘,’Python‘)

Escape-Zeichen und Originalzeichen

+ Escape dem ersten Buchstaben der Funktion

换行：\n（newline）

回车：\r (return)

如print(‘hello\rworld’)         在hello的下一行输出world

水平制表符：\t (tab)

如print(‘hello\tworld’)     输出 hello  world

而print(helloooo\tworld)  输出helloooo  world

因为hell这四个字母成为一个字表位，o后\t 占用了其余三个

若是无剩余 则会新开一个字表位

退格：\b (backspace)

如print(‘hello\bworld’)          退格输出hellworld

*原字符：不希望字符串中转义字符起作用，就会使用原字符，即在字符串上加上R或者r
如print(r‘hello\nworld’)         输出hello\nworld

Binär- und Zeichenkodierung

8 Bit (Bit) – 1 Byte (Byte) – 256 Zustände – 256 Symbole 1024 Byte
– 1 KB
1024 KB – 1 MB
1024 MB – 1 GB
1024 GB – 1 TB

Bezeichner und reservierte Wörter

1. Reservierte Wörter: haben eine besondere Bedeutung und können nicht bei der Benennung von Objekten verwendet werden

1. Erstellen Sie eine neue keyword.demo
2. Schlüsselwort importieren
3. print(keyword.kwist) gibt eine Schlüsselwortliste
   
   2 aus. Die Namen, die Variablen/Funktionen/Klassen/Modulen und anderen Objekten gegeben werden, werden als Bezeichner
   3 bezeichnet. Regeln:
4. Buchstaben, Zahlen, Unterstreichungen
5. kann nicht mit einer Zahl beginnen
6. Kann kein reserviertes Wort sein
7. Die Groß-/Kleinschreibung muss unbedingt beachtet werden

Definition und Verwendung von Variablen

Art der Daten

Integer-Typ – int – 98, kann positive Zahlen, negative Zahlen darstellen, 0
Gleitkommatyp – float – 3.1415926
Boolescher Typ – bool – True, False
String-Typ – str – „Das Leben ist kurz, ich verwende Python“ (mit Anführungszeichen, Unabhängig davon, ob es sich um ein einfaches, ein doppeltes oder ein dreifaches Anführungszeichen handelt, handelt es sich um eine Zeichenfolge.)

Integer-Typ

1. Darstellung ganzer Zahlen in verschiedenen Basen

1. Dezimal – Standard
2. Binär – beginnt mit 0b
3. Oktal – beginnt mit 0o
4. Hexadezimal – beginnt mit 0x

Gleitkommatyp

Boolescher Typ

Zeichenfolge

Typkonvertierung

str()

Anders als in anderen Sprachen werden andere Datentypen nicht automatisch in Zeichenfolgen konvertiert, wenn Zeichenfolgen und andere Datentypen über „+“ verbunden werden, sondern es wird ein Fehler gemeldet. Die Lösung besteht darin, eine Typkonvertierung durchzuführen.

a=10

b=198.8

c=False

print（type（a），type（b），type（c））
# 输出：<class ‘int’><class ‘float’> <class ‘bool’>

print（str(a),str(b),str(c),type（a），type（b），type（c））
# 输出：10 198.8 False <class ‘str’> <class ‘str’> <class ‘str’> 

int()

Konvertieren Sie str in den Typ int. str muss eine ganzzahlige Zeichenfolge sein, andernfalls wird ein Fehler gemeldet. Durch die Konvertierung von float in int wird der ganzzahlige Teil von float abgefangen.

s1='128'
f1=98.7
s2="45.6"
ff=True
s3="hello"
print(type(s1),type(f1),type(s2),type(ff),type(s3))
print(int(s1),type(int(s1))) #字符串为数字串
print(int(f1),type(int(f1))) #截取整数部分，小数舍掉
#print(int(s2),type(int(s2))) #字符串为小数串
print(int(ff),type(int(ff)))
#print(int(s3),type(int(s3))) #字符串必须为数字串且为整形

schweben()

1. Für nicht numerische Zeichenfolgen ist die Konvertierung nicht zulässig
2. Der boolesche Wert true wird in 1,0 konvertiert, false wird in 0,0 konvertiert

s1='128.98'
s2="76"
ff=True
s3="hello" 
i=98
print(type(s1),type(s2),type(ff),type(s3),type(i))
print(float(s1),type(float(s1)))# 128.98
print(float(s2),type(float(s2)))# 76.0
print(float(ff),type(float(ff)))# 1.0
#print(float(s3),type(float(s3))) #非数字串不允许转换
print(float(i),type(float(i))) # 98.0

Kommentar

Enthält drei Arten von Kommentaren

1. Einzeilige Kommentare – beginnen mit # und enden mit Newline
2. Mehrzeilige Kommentare – ein Paar mehrzeiliger Code-Kommentare mit drei Anführungszeichen

'''多行注释
多行哦'''

3. Kommentar zur chinesischen Codierungsdeklaration: Geben Sie das Codierungsformat der Quellcodedatei am Anfang der Datei an

Verwendung der Eingabefunktion

Die von input() empfangenen Parameter sind Fragen, die das Programm dem Benutzer stellt, und die Eingaben des Benutzers werden der aktuellen Variablen zugewiesen.

#输入函数input
prasent=input('大圣想要什么礼物呢？')
print(prasent,type(prasent))# 输出：用户键盘输入的内容，类型为str

# 从键盘录入两个整数，计算两个整数的和
a=int(input('请输入一个加数：'))
b=int(input('请输入一个被加数：'))
print(type(a),type(b))
print(a+b)
#print(int(a)+int(b))

Operator

Operatoren in Python: arithmetische Operatoren, Zuweisungsoperatoren, Vergleichsoperatoren, Boolesche Operatoren, bitweise Operatoren

Rechenzeichen

Standardarithmetische Operatoren: +、-、*、/、整除//
Restoperator: %
Potenzierungsoperator:**

print(1+1) #加
print(1-1) #减
print(2*4) #乘
print(11/2) #除
print(11//2) #整除运算
print(11%2) #取余
print(2**3) #幂运算 2的3次方

print(9//4)# 2
print(-9//-4)# 2
#一正一负进行整除时，向下取整
print(9//-4)# -3
print(-9//4)# -3

# 一正一负进行取余时，遵循公式：公式 余数=被除数-除数*商
print(9%-4)# 9-(-4)*(-3) 9-12-->-3
print(-9%4)# -9-4*(-3) -9+12-->3 

Aufgabenverwalter

a=3+4
print(a)# 7
b=c=d=20
# 以下3个输出都是同一个值
print(d,id(d))# 14645450672
print(b,id(b))# 14645450672
print(c,id(c))# 14645450672

a=20
a+=30
print(a)# 50
a*=2
print(a)# 100
a/=30
print(a)#3.33333333
a%=3
print(a)# 0.11111111

# 支持系列解包赋值，变量个数和值的个数一定要一致，否则会报错
a,b,c=1,2,3
print(a,b,c)# 1，2，3
# 系列解包赋值的用处：交换两个变量
a,b=10,20
print('交换前',a,b)# 10，20
a,b=b,a
print('交换后',a,b)# 20，10

Vergleichsoperator

Das Ergebnis des Vergleichsoperators ist vom Typ Boolean

a,b=10,20
print('a>b吗?',a>b)
print(a<b)
print(a<=b)
print(a>=b)
print(a==b)# false
print(a!=b)# true

a=10
b=10
print(a==b) #True 说明，a与b的value相等
print(a is b) #True 说明：a与b的id标识相等
print(a is not b)# false

lst1=[11,22,33,44]
lst2=[11,22,33,44]
print(lst1==lst2)# true
print(lst1 is lst2 )# false
print(id(lst1))# 2525441564
print(id(lst2))# 2525665484
print(lst1 is not lst2)# true

boolescher Operator

a,b=1,2
print(a==1 and b==2)# true
print(a==1 and b<2)# false
print(a!=1 and b==2)# false
print(a!=1 and b!=2)# false

print(a==1 or b==2)# true
print(a==1 or b<2)# true
print(a!=1 or b==2)# true
print(a!=1 or b!=2)# false

#not 对bool类型操作数取反
f=True
f2=False
print(not f)# false
print(not f2)# true

s='helloworld'
print('w' in s)# true
print('k' in s)# false
print('w' not in s)# false
print('k' not in s)# true

Bitoperationen

print(4&8) # 输出0。按位与&，同时为1结果为1
print(4|8) # 输出12。按位或|，同时为0结果为0
print(4<<1) # 输出8。向左移动1位 相当于乘以2
print(4<<2) # 输出16。向左移动2位
print(4>>1) # 输出2。向右移动1位，相当于除以二
print(4>>2) # 输出1。除以4

Vorrang des Operators

Zusammenfassung: (), arithmetische Operationen, Bitoperationen, Vergleichsoperationen, Bool-Operationen, Zuweisungsoperationen

1. （）
2. ** Ein Zuweisungsoperator: zuerst Multiplikation und Division, dann Addition und Subtraktion, zuerst Potenzierung, wenn es eine Potenzierungsoperation gibt
3. *、/、//、%
4. +、-
5. <<, >> B-Bit-Operatoren
6. &
7. |

8. ,< ,>=,<=,==,! =C Vergleichsoperator

9. Und
10. oder D Boolescher Operator
11. =E Zuweisungsoperator

Organisationsstruktur des Programms

Jeder einfache oder komplexe Algorithmus kann aus einer sequentiellen Struktur, einer Auswahlstruktur (if-Anweisung) und einer Schleifenstruktur (while for-in-Anweisung) bestehen.

sequentielle Struktur

Programm startet – Code 1 – Code 2 – Code 3... Code N – Programm endet

Boolescher Wert des Objekts

Alles in Python ist ein Objekt. Alle Objekte haben einen booleschen Wert.
Um den booleschen Wert eines Objekts zu erhalten, verwenden Sie die integrierte Funktion bool()

#以下对象bool值均为False
print(bool(False))
print(bool(0))
print(bool(0.0))
print(bool(None))
print(bool(''))
print(bool(""))
print(bool([])) #空列表
print(bool(list())) #空列表
print(bool(())) #空元组
print(bool(tuple())) #空元组
print(bool({
    
    })) #空字典
print(bool(dict())) #空字典
print(bool(set())) #空集合
#其他对象bool值均为True

Zweigstruktur

Wenn bedingter Ausdruck:
Wenn die Bedingung erfüllt ist, führen Sie den eingerückten Code aus.
Sonst:
Wenn die Bedingung nicht erfüllt ist, führen Sie den eingerückten Code in else aus

#单分支结构
money=1000
s=int(input('请输入取款金额：'))
if money>=s:
    money=money-s
    print('取款成功，余额为：',money)

#双分支结构
num=int(input('请输入一个整数：'))
if num/2==0:
    print(num,'是偶数')
else:
    print(num,'是奇数')

#多分支结构
score=float(input('请输入一个成绩：'))
if 90<=score<=100:
    print('A')
elif 80<=score<90:
    print('B')
elif 70<=score<80:
    print('C')
elif 60<=score<70:
    print('D')
elif 0<=score<60:
    print('E')
else:
    print('不是有效成绩')

#嵌套if的使用
answer=input('您是会员吗?y/n')
money=float(input('请输入您的购物金额：'))
if answer=='y':
    if money>=200:
        print(money*0.8)
    elif money>=100:
        print(money*0.9)
    else:
        print(money)
else:
    if money>=200:
        print(money*0.95)
    else:
        print(money)

Bedingte Ausdrücke und Pass-Anweisungen

Der bedingte Ausdruck ist if...else (Abkürzung), Syntaxstruktur: x if 判断条件 else yWenn der boolesche Wert der Beurteilungsbedingung True ist, ist der Rückgabewert des bedingten Ausdrucks x, andernfalls ist der Rückgabewert des bedingten Ausdrucks y

# 从键盘中输入两个整数，判断两个整数的大小
num1=int(input('请输入第一个整数'))
num2=int(input('请输入第二个整数'))
'''if num1>=num2:
    print(num1,'大于等于',num2)
else:
    print(num1,'小于',num2)'''

print(str(num1)+'大于等于'+str(num2) if num1>=num2 else str(num1)+'小于'+str(num2))

'''
pass语句什么都不做，只是一个占位符，用在需要语句的地方
#使用时间：先搭建语法结构，还没好代码怎么写的时候
配套使用：
1. if 语句的条件执行体
2. for--in语句的循环体
3. 定义函数的函数体 
'''
answer=input('您是会员吗?y/n')
if answer=='y':
    pass
else:
    pass

Verwendung der Funktion range()

#range()的三种创建方式
# 第一种创建方式
r=range(10) #默认从零开始，默认相差1称为步长
print(r) #range(0,10)
print(list(r)) #用于查看range对象中的整数序列 -->list是列表的意思
# 输出：[0,1,2,3,4,5,6,7,8,9]

# 第二种创建方式
r=range(1,10) #指定起始值，从1开始到10结束(不包含10)
print(list(r))
# 输出：[1,2,3,4,5,6,7,8,9]

#第三种创建方式
r=range(1,10,2) #步长为2
print(list(r))# 输出：[1,3,5,7,9]

# 判断指定的m
print(9 in r)
print(8 not in r)

while-Schleife

sum=0
a=0
while a<5:
    sum+=a
    a+=1
print(sum)

# 1到100之间![请添加图片描述](https://img-blog.csdnimg.cn/abba8fe6d6e248a290c840187f46ef8a.png)
的偶数和
sum=0
a=1
while a<=100:
    if not bool(a%2):             # if a%2==0:
        sum+=a
    a+=1
print(sum)

for_in-Schleife

for item in 'python':
    print(item)
# range()产生的整数序列，也是一个可迭代对象
for i in range(10):
    print(i)
# 如果在循环体中不需要使用到自定义变量，可将自定义变量写为“_“
for _ in range(5):
    print('人生苦短')

# 100到999之间的水仙花数
for item in range(100,1000):
    ge=item%10
    shi=item//10%10
    bai=item//100
    #print(bai,shi,ge)
    if ge**3+shi**3+bai**3==item:
        print(item)

Flusskontrollanweisungen werden unterbrochen und fortgesetzt

a=0
while a<3:
    pwd=input('请输入密码：')
    if pwd=='8888':
        print('密码正确')
        break
    else:
        print('密码不正确')
    a+=1

for item in range (1,51):
    if item%5!=0:
        continue
    print(item)

else-Anweisung

Wird mit while und for verwendet: Solange die Schleife normal ausgeführt wird, wird else ausgeführt.

for item in range(3):
    pwd=input('请输入密码：')
    if pwd=='8888':
        print('密码正确')
        break
    else:
        print('密码不正确')
else:
    print('对不起，三次密码均输入错误')

Verschachtelte Schleifen

for i in range(1,4):  #行表
    for j in range(1,5): 
        print('*',end='\t') #不换行输出
    print()    #打行

for i in range(1,10):
    for j in range(1,i+1):
        print(i,'*',j,'=',i*j,end='\t')
    print()

Unterbrechen Sie die Doppelschleife und setzen Sie sie fort

Die Unterbrechung und Fortsetzung in der Doppelschleife dienen zur Steuerung der Schleife dieser Ebene.

for i in range(5):
    for j in range(1,11):
        if j%2==0:
            #break
            continue
        print(j,end='\t')
    print()

Liste

Listenerstellung

# 列表对象
# 创建列表的第一种方式,[]
lst=['hello','world',98,'hello']
print(id(lst))
print(type(lst))
print(lst)
print(lst[0],lst[-4])
# 创建列表的第二种方式,list()
lst2=list(['hello','world',98])
print(id(lst2))
print(type(lst2))
print(lst2)

Funktionen auflisten

Holen Sie sich ein einzelnes Element in einer Liste

lst=['hello','world',98,'hello']
print(lst.index('hello')) #列表中有相同元素只返回列表中相同元素的的第一个元素的索引
# print(lst.index('python')) #ValueError: 'python' is not in list
# print(lst.index('hello',1,3)) #ValueError: 'hello' is not in list  1-'world' 2-98 不包括3
print(lst.index('hello',1,4))

lst=['hello','world',98,'hello','world',234]
# 获取索引为2的
print(lst[2])
# 获取索引为-3的
print(lst[-3])
# 获取索引为10的
print(lst[10]) # IndexError: list index out of range

Mehrere Elemente in einer Liste abrufen – Slicing-Vorgang

lst=[10,20,30,40,50,60,70,80]
print(lst[1:6:1])# [20,30,40,50,60]
print(lst[1:6]) #默认步长为1 [20,30,40,50,60]
print(lst[1:6:])#默认步长为1 [20,30,40,50,60]
print(lst[1:6:2]) #步长为2 [20,40,60]
print(lst[:6:2])# [10,30,50]
print(lst[1::2])# [20,40,60,80]
print(lst[::2])# [10,30,50,70]
print(lst[::])# [10,20,30,40,50,60,70,80]
# 步长为负数
print(lst[::-1])# [80,70,60,50,40,30,20,10]
print(lst[7::-1])# [80,70,60,50,40,30,20,10]
print(lst[6:0:-2])# [70,50,30]
# 新切出来的是一个新的列表对象
print('原列表',id(lst))# 2005509464960
lst2=lst[1:6:1]
print('切的片段',id(lst2))# 2005510479424

Beurteilung und Durchquerung von Listenelementen

lst=[10,20,'python','hello']
print(10 in lst) #判断
print(10 not in lst)
for item in lst: #遍历
    print(item)

Listenelemente hinzufügen, löschen und ändern

Listenelemente hinzufügen

# 向列表末尾添加元素
lst=[10,20,30]
print(lst,id(lst))# 2181409792960
lst.append(100)
print(lst,id(lst))# 2181409792960

lst2=['hello','world']
# lst.append(lst2) # 将lst2作为一个元素添加到列表末尾 [10,20,30,['hello','world']]
lst.extend(lst2) # 向列表末尾添加多个元素 [10,20,30,'hello','world']
print(lst)

lst.insert(1,90) # 在任意位置上添加一个元素，在索引为1的位置上添加一个90
print(lst)# [10,90,20,30,'hello','world']

lst3=[True,False,'hello']
lst[1:]=lst3 # 在任意位置添加N个元素，从第一个元素开始后面的元素全删除（切掉），然后再添加元素
print(lst)# [10,True,False,'hello']

Löschen von Listenelementen

lst=[10,20,30,40,50,60,30]
lst.remove(30) #从列表中移除一个元素，如果有重复元素只移除第一个元素
print(lst)# [10,20,40,50,60,30]
# lst.remove(100) #ValueError: list.remove(x): x not in list

#pop()根据索引移除元素
lst.pop(1)
print(lst)# [10,40,50,60,30]
# lst.pop(5) #IndexError: pop index out of range
lst.pop() #如果不指定参数，将删除最后一个参数
print(lst)# [10,40,50,60]

# 切片操作会产生一个新的列表对象，切片相当于从列表中取数
new_lst=lst[1:3]
print('原列表',lst)# [10,40,50,60]
print('切片后列表',new_lst)# [40,50]
# 不产生新的列表对象，而是删除原列表中的内容
lst[1:3]=[]
print(lst)# [10,60]

lst.clear() #清除列表中的所有元素
print(lst)
del lst #将列表对象删除
# print(lst) # NameError: name 'lst' is not defined. Did you mean: 'list'?

Änderungsvorgang von Listenelementen

#修改一个值
lst=[10,20,30,40]
lst[2]=100 
print(lst)# [10,20,100,40]
# 使用切片修改多个值
lst[1:3]=[300,400,500,600]
print(lst)# [20,300,400,500,600,40]

Sortieroperationen für Listenelemente

lst=[20,40,10,98,54]
print('排序前',lst,id(lst))# [20,40,10,98,54] 1632705897408
lst.sort() #升序
print('排序后',lst,id(lst))# [10,20,40,54,98] 1632705897408
# 指定关键字参数，实现列表元素的降序排序
lst.sort(reverse=True) #降序
print(lst)# [98，54，40，20，10]
lst.sort(reverse=False) #升序
print(lst)# [10,20,40,54,98]

# 使用内置函数sorted()对列表进行排序，将产生一个新的列表
lst=[20,40,10,98,54]
new_lst=sorted(lst) #产生一个新列表 升序
print(lst)# [20,40,10,98,54]
print(new_lst)# [10,20,40,54,98]
# 指定关键字参数，实现列表元素的降序排序
desc_lst=sorted(lst,reverse=True) #降序
print(desc_lst)# [98，54，40，20，10]

Listenausdruck

lst=[i*i for i in range(1,10)]
print(lst)
lst2=[i for i in range(2,11,2)]
print(lst2)

Wörterbuch

Variable Sequenz: Eine Sequenz, die hinzugefügt, gelöscht oder geändert werden kann.
Die Liste ist eine geordnete Sequenz.

Der Schlüssel ist eine unveränderliche Sequenz, z. B. str. Unveränderliche Sequenzen können keine Additions-, Lösch- und Änderungsvorgänge ausführen.

Wörterbucherstellung

Mithilfe der integrierten Funktion dict() wird ein Wörterbuch in Form einer Zuweisung erstellt, sodass '' nicht auf der linken Seite hinzugefügt wird. Ob es auf der rechten Seite hinzugefügt wird, hängt vom Datentyp auf der rechten Seite ab.

# 使用花括号
scores={
    
    '张三':100,'李四':98,'王五':45}
print(scores)
# 使用内置函数
stu=dict(name='jack',age=20)
print(stu)

Allgemeine Operationen an Wörterbüchern

Holen Sie sich Wörterbuchelemente

# 获取字典中的值,使用[]
print(scores['张三'])
# print(scores['陈六']) # KeyError: '陈六'
# 使用get()
print(scores.get('张三'))
print(scores.get('陈六')) # None
# 如果查找的key不存在，返回某个默认值
print(scores.get('马七',99)) # 99是在查找‘马七’所对的value不存在时，提供的一个默认值

Wörterbuchelemente hinzufügen, löschen und ändern

scores={
    
    '张三':100,'李四':98,'王五':45}
print("张三" in scores)# true
print("张三" not in scores)# false
del scores['张三'] # 删除指定的key-value对，输出：{'李四':98,'王五':45}
# scores.clear() # 清空字典的元素
print(scores)
scores['陈六']=98 #新增元素
print(scores)# {'李四':98,'王五':45,'陈六':98}
scores['陈六']=100 # 修改元素
print(scores)# {'李四':98,'王五':45,'陈六':100}

Holen Sie sich die Wörterbuchansicht

scores={
    
    '张三':100,'李四':98,'王五':45}
# 获取所有的key
keys=scores.keys()
print(keys)# dict_keys(['张三','李四','王五'])
print(type(keys))# dict_keys
# scores.keys()得到的数据的类型是dict_keys，我们可以将所有的key组成的视图转成列表
print(list(keys))# ['张三','李四','王五']

# 获取所有的value
values=scores.values()
print(values)# dict_values([100,98,45])
print(type(values))# dict_values
print(list(values))# [100,98,45]

#获取所有的key-value对
items=scores.items()
print(items)# dict_items([('张三':100),('李四':98),('王五':45)])
print(list(items)) # 转换之后的列表元素是由元组组成:[('张三':100),('李四':98),('王五':45)]

Durchlaufen von Wörterbuchelementen

item ist der Name des zu durchlaufenden Schlüssels, Score ist der Name des zu durchlaufenden Wörterbuchs

scores={
    
    '张三':100,'李四':98,'王五':45}
# 字典元素的遍历
for item in scores:
    print(item,scores[item],scores.get(item))

Wörterbuchfunktionen

d={
    
    'name':'张三','name':'李四'} # key不允许重复，重复的key会覆盖原来的值
print(d)# {'name':'李四'}
d={
    
    'name':'张三','nikename':'张三'} # value允许重复
print(d)# {'name':'李四','name':'张三','nikename':'张三'}

Wörterbuchgenerierung

items=['Fruits','Books','Others']
prices=[96,78,85,100,120]
# 遍历两个list中的值，分别存放在item,price中，item,price是要放在字典中的，所以最外层用了{}，里面写作item:price，如果想要items大写，那么使用item.upper()
d={
    
    item.upper():price   for item,price in zip(items,prices)}
print(d)# 当两个list的个数不一致时，以短的那个为准
lst=zip(items,prices)
print(list(lst))

Tupel

'''可变序列 列表，字典：可以进行增删改，即列表/字典进行增删改后，列表/字典在内存中的地址不变'''
lst=[10,20,45]
print(id(lst))# 1808459865024
lst.append(200)
print(id(lst))# 1808459865024
'''不可变序列 字符串，元组：不可以进行增删改，
即不可变序列进行增删改并非在原序列上操作，而是在内存中新开辟一个序列，所以不可变序列进行增删改后在内存中的地址会改变'''
s='hello'
print(id(s))# 2753280992112
s=s+'world'
print(id(s))# 2753284295600
print(s)

Wie Tupel erstellt werden

# 第一种，用()
t=('Python','world',98)
print(t)# ('Python','world',98)
print(type(t))# tuple

t2='Python','world',98 # 省略了小括号
print(t2)# ('Python','world',98)
print(type(t2))# tuple

t=('Python',) # 只包含一个元组的元素需要使用逗号和小括号，不然为str类型(此处)
print(t)# ('Python')
print(type(t))# tuple

# 第二种创建方式，内置函数tuple()
t1=tuple(('Python','world',98))
print(t1)# ('Python','world',98)
print(type(t1))# tuple

# 空列表
lst=[]
lst1=list()
# 空字典
d={
    
    }
d1=dict()
# 空元组
t=()
t1=tuple()
print('空列表',lst,lst1)
print('空字典',d,d1)
print('空元组',t,t1)

Warum sollten Tupel als unveränderliche Sequenzen entworfen werden?

Sobald ein unveränderliches Typobjekt erstellt wurde, können alle Daten innerhalb des Objekts nicht mehr geändert werden, wodurch Fehler vermieden werden, die durch die Änderung der Daten verursacht werden. Darüber hinaus ist für unveränderliche Typobjekte in einer Multitasking-Umgebung keine Sperre erforderlich, wenn Objekte gleichzeitig bedient werden. Die

im Tupel gespeicherten Daten sind (10, [20, 30], 9), 10 und 9 sind beide unveränderliche Objekte. Andere Werte können nicht referenziert werden. Wenn ich die Daten bei [20,30] auf 100 ändern möchte, ist dies nicht möglich, da [20,30] ein veränderliches Objekt ist und die Referenz von a Das veränderliche Objekt kann nicht geändert werden. Es kann nur 100 an [20,30] angehängt werden und die Speicheradresse, die ursprünglich auf [20,30] im Tupel zeigt, bleibt unverändert.

t=(10,[20,30],9)
print(type(t))# tuple
print(t[0],type(t[0]),id(t[0]))# 10 int 140716189915072
print(t[1],type(t[1]),id(t[1]))# [20,30] list 2223714708224
print(t[2],type(t[2]),id(t[2]))# 9 int 140716189915040
# 尝试将t[1]修改为100
print(id(100))# 140716189917952
#t[1]=100 #元组不允许修改元素
#由于[20,30]列表，而列表是可变序列，所以可以向列中添加元素，而列表的内存地址不变
t[1].append(100) #向列表中添加元素
print(t,id(t[1]))# [20,30,100] 2223714708224

Durchquerung von Tupeln

#元组的遍历
t=('Python','world',98)
#1.索引
print(t[0])
print(t[1])
print(t[2])
# print(t[3]) #IndexError: tuple index out of range
#2.遍历
for item in t:
    print(item)

versammeln

# 集合的创建方式
# 1.{}
s={
    
    2,3,4,5,6,7,7} #集合中的元素不允许重复
print(s)# {2,3,4,5,6,7}

#2.set()
s1=set(range(6))
print(s1,type(s1))# {0,1,2,3,4,5} set
# 通过set()将列表中的元素转成集合
s2=set([1,2,4,5,5,5,6,6])
print(s2,type(s2))# {1,2,3,5,6} set
# 通过set()将元组中的元素转成集合
s3=set((1,2,4,4,5,65)) #集合中的元素是无序的
print(s3,type(s3))# {1,2,4,5,65} set
# 通过set()将字符串中的元素转成集合
s4=set('python')
print(s4,type(s4))# {'n','h','p','y','t','y'} set
# 通过set()将字典中的元素转成集合
s5=set({
    
    12,4,34,55,66,44,4})
print(s5,type(s5))# {34,66,4,55,12,44} set

# 定义一个空集合
s6={
    
    } #dict字典类型
print(type(s6))# dict
s7=set()
print(type(s7))# set

Sammlungsbezogene Vorgänge

#集合的相关操作
#判断操作
s={
    
    10,2,0,30,40,50}
print(10 in s)# true
print(100 in s)# false
print(0 not in s)# false
#新增操作
s.add(80) #一次添加一个
print(s)# {10,80,2,30,0,40,50}，无序的
s.update({
    
    200,300,4000}) #一次至少添加一个元素，把一个集合添加到指定集合中
print(s)# {200,300,10,80,2,30,0,40,50,4000}，无序的
# 也可以以列表和元组的形式批量往里添加数据
s.update([100,99,6])
s.update((78,56,48))
print(s)# {78,200,56,300,10,100,80,48,2,6,30,0,40,99,50,4000}

#删除操作
s.remove(10)
print(s)# {78,200,56,300,100,80,48,2,6,30,0,40,99,50,4000}
# s.remove(500) #KeyError: 500
# print(s)
# 如果集合中有500则删除，没有也不报错
# s.discard(500) #没有，不报错
# print(s)
s.pop() #只能删除第一个，且不能添加参数
print(s)# {200,56,300,10,100,80,48,2,6,30,0,40,99,50,4000}
s.clear() #清空集合
print(s)# set()

Beziehung zwischen Mengen

# 两个集合是否相等(元素相同，就相等)
s={
    
    10,20,30,40}
s2={
    
    20,30,40,10}
print(s==s2) #T
print(s!=s2) #F
#子集和超集
s1={
    
    10,20,30,40,50,60}
s2={
    
    10,20,30,40}
s3={
    
    10,20,90}
print(s2.issubset(s1)) #T s2的所有数据都在s1中，所以s2是s1的子集
print(s3.issubset(s1)) #F 
print(s1.issuperset(s2)) #T s2的所有数据都在s1中，所以s1是s2的超集
print(s1.issuperset(s3)) #F
#交集
print(s2.isdisjoint(s3)) #F - 有交集
s4={
    
    100,200,300}
print(s2.isdisjoint(s4)) #T - 没有交集

Erfassungsdatenvorgänge

# 集合的数学操作
#(1)交集
s1={
    
    10,20,30,40}
s2={
    
    20,30,40,50,60}
print(s1.intersection(s2))# {40,30,20}
print(s1&s2)# &与intersection等价，都是求交集操作，输出：{40,30,20}

#(2)并集
print(s1.union(s2))# {40,30,20,10,50,60}
print(s1|s2)# |与union等价，都是求并集操作，输出：{40,30,20,10,50,60}

#(3)差集
print(s1.difference(s2)) #s1有s2没有，输出：[10]
print(s1-s2)# -与difference等价，都是求差集操作，输出：[10]
print(s2.difference(s1))# s2有s1没有，输出：[50,60]

#(4)对称差集
print(s1.symmetric_difference(s2)) #集合交集以外的元素，输出：[10,50,60]
print(s1^s2)# ^与symmetric_difference等价，都是求对称差集操作，输出：[10,50,60]

Setproduktion

s={
    
    i*i for i in range(10)}
print(s)

Zusammenfassen

Zeichenfolge

String-Erstellungs- und Persistenzmechanismen

#字符串
#字符串的定义及驻留机制
a='python'
b="python"
c='''python'''
print(a,id(a))# python 1874508798960
print(b,id(b))# python 1874508798960
print(c,id(c))# python 1874508798960

Residency-Mechanismus: Eine Möglichkeit, nur eine Kopie derselben und unveränderlichen Zeichenfolge zu speichern.

Interaktiver Modus: Führen Sie Python unter cmd aus, um in den interaktiven Modus zu gelangen.
Zeichenfolgen, die mit Bezeichnern übereinstimmen: Zeichenfolge b mit alphanumerischen Unterstrichen


wird vervollständigt, wenn das Programm kompiliert wird. Zum Spleißen c verwendet Join, um das Spleißen abzuschließen, wenn das Programm ausgeführt wird. Wenn a c falsch ist,
können Sie sys verwenden, um eine erzwungene Residenz zu implementieren.

Allgemeine Operationen an Strings

String-Abfrageoperationen

#字符串查询操作
s='hello,hello'
print(s.index('lo')) #第一次出现的位置，输出：3
print(s.find('lo'))#第一次出现的位置，输出：9
print(s.rindex('lo')) #最后一次出现的位置
print(s.rfind('lo'))#第一次出现的位置，输出：9

# print(s.index('k')) #ValueError: substring not found 不存在
print(s.find('k')) #-1 不存在

Konvertierung von Zeichenfolgen in Groß- und Kleinschreibung

#字符串的大小写转换操作
s='HelloWorld,wa'
print(s.upper(),id(s.upper())) #全转成大写会产生一个新的字符串对象，输出：HRLLOWORLD,WA 2133868981488
print(s,id(s))#helloworld,wa 2134125876016
print(s.lower()) #全转成小写，如果原来的字符串就是小写的，在执行了lower()后依旧会产生一个新的字符串对象，二者的id()依旧不一样
print(s.swapcase()) #大转小，小转大
print(s.capitalize()) #第一个字符大写，其余小写
print(s.title()) #每个单词首字母大写，其余小写

Operationen zur Ausrichtung von Zeichenfolgeninhalten

#字符串内容对齐操作
s='hello,Python'
#居中对齐
print(s.center(20,'*')) #****hello,Python****
#左对齐
print(s.ljust(20,'*')) #hello,Python********
print(s.ljust(10))#hello,Python
print(s.ljust(20))#hello,Python        
#右对齐
print(s.rjust(20,'*'))#********hello,Python
print(s.rjust(20))#        hello,Python
print(s.rjust(10))#hello,Python
#右对齐，左边用0填充
print(s.zfill(20))#00000000hello,Python
print(s.zfill(10))#hello,Python
print('-8910'.zfill(8))#-0008910

String-Splitting-Operation

#字符串的劈分操作
s='hello world Python'
print(s.split())# 默认以空格拆分，输出：['hello','world','Python']
s1='hello|world|Python'
print(s1.split())# ['hello world Python']
print(s1.split(sep='|'))# 指定分隔符，['hello','world','Python']
print(s1.split(sep='|',maxsplit=1))#['hello','world｜Python'] 
#从右侧分
print(s1.rsplit(sep='|',maxsplit=1))# ['hello｜world','Python']

String-Beurteilungsoperation

#字符串判断的相关方法
#合法标识符
s='hello,python'
print(s.isidentifier()) #F
print('hello'.isidentifier()) #T
print('张三_123'.isidentifier()) #T
#空白字符
print('\t'.isspace()) #T
print(' '.isspace()) #T
#字母
print('abc'.isalpha()) #T
print('张三'.isalpha()) #T
print('张三1'.isalpha()) #F
#十进制数字
print('123'.isdecimal()) #T
print('123四'.isdecimal()) #F
print('ⅡⅢⅣ'.isdecimal()) #F
#数字
print('123'.isnumeric()) #T
print('123四'.isnumeric()) #T
print('ⅡⅢⅣ'.isnumeric()) #T
print('壹贰叁'.isnumeric()) #T
#字母和数字
print('abc1'.isalnum()) #T
print('张三123'.isalnum()) #T
print('abc!'.isalnum()) #F

Andere Operationen an Strings

#字符串的其他操作
#字符串的替换
s='hello,Python'
print(s.replace('Python','Java'))# 用Java替换python，输出：hello,Java
s1='hello,Python,Python,Python'
print(s1.replace('Python','Java',2)) #第三个次数指定替换次数，输出hello,Java,Java,Python
#字符串的合并
# 连接数组元素
lst=['hello','java','python']
print('|'.join(lst))# hello｜java｜python
print(''.join(lst))# hellojavapython
# 连接元组元素
t=('hello','java','python')
print(''.join(t))# hellojavapython
# 连接字符串的元素
print('*'.join('python'))# p*y*t*h*o*n

String-Vergleichsoperationen

#字符串的比较操作
print('apple'>'app') #T
print('apple'>'banana') #F, 97>98 F
print(ord('a'),ord('b')) #原始值这里是字母的ascll码
print(ord('刘'))
print(chr(97),chr(98))# 获取ascii码为97的值，即a。chr()和ord()互为相反的两个方法
print(chr(21016))

'''==和is的区别
==比较的是value
is 比较的是 id'''
a=b='python'
c='python'
print(a==b) #T
print(b==c) #T
print(a is b) #T
print(a is c) #T
print(id(a)) #2383540093936
print(id(b)) #2383540093936
print(id(c)) #2383540093936

String-Slice-Vorgang

#字符串的切片操作
s='hello,python'
print(s[:5]) #没有指定起始位置，从0开始，输出：hello
print(s[6:]) #没有指定结束位置，所以切到字符串最后一个元素，输出：python
s1='!'
newstr=s[:5]+s1+s[6:]
print(newstr) # hello！python
print(id(s))# 1990114866608
print(id(s[:5]))# 1990110831472
print(id(s[6:]))# 1990110735152
print(id(s1))# 1989860883760
print(id(newstr))# 1990110735216

print(s[1:5:1]) #完整写法 从一切到四，步长为一，输出：ello
print(s[::2]) #从0开始切到最后，输出：hlopto
print(s[::-1]) #从最后一个元素开始往前到第一个元素，步长为1，输出：nohtyp,olleh
print(s[-6::1])#从索引为-6的开始，到字符串的最后一个元素，步长为1，输出：python

Zeichenfolge formatieren

Formatierte Zeichenfolge: eine Zeichenfolge, die in einem bestimmten Format ausgegeben wird

#格式化字符串
# % 占位符
name='张三'
age=20
print('我叫%s,今年%d岁' % (name,age))
# {}，0代表取format的第一个参数，所有用到0的地方都使用这个参数的值
print('我叫{0},今年{1}岁,我真的叫{0}'.format(name,age))
# f-string，前面加f代表格式化字符串
print(f'我叫{
      
      name},今年{
      
      age}岁')

#宽度和精度
print('%10d' % 99) #10个宽度，输出：          99
print('%.3f' % 3.1415926) #.3表示小数点后三位，输出：3.142
print('%10.3f' % 3.1415926) #宽度为10，保留三位小数，输出：          3.142
print('hellohello')
# 下面的0均指format第一个参数
print('{0:.3}'.format(3.1415926)) #.3表示一共三位数，输出：3.14
print('{0:.3f}'.format(3.1415926)) #.3f表示3位小数，输出：3.142
print('{0:10.3f}'.format(3.1415926)) #宽度是10位，3位是小数，输出

Konvertierung der String-Kodierung

#字符串的编码转换
s='天涯共此时'
#编码
print(s.encode(encoding='GBK')) #GBK这种编码格式中，一个中文占两个字节
print(s.encode(encoding='UTF-8')) #UTF-8中，一个中文三个字节
#解码
#byte代表的就是一个二进制数据(字节类型的数据)
byte=s.encode(encoding='GBK') #编码
print(byte.decode(encoding='GBK')) #解码
byte=s.encode(encoding='UTF-8')
print(byte.decode(encoding='UTF-8'))

Funktion

Funktionsdefinition und -aufruf

#函数的定义和调用
def calc(a,b):  #a,b为形式参数，形参位置是在函数的定义处
    c=a+b
    return c

result=calc(10,20)  #10,20称为实际参数的值，实参的位置是函数的调用处
print(result)

#函数参数的传递
res=calc(b=10,a=20)  #=左边的变量名称为 关键字参数
print(res)

#函数参数传递的内存分析
def fun(arg1,arg2):
    print('arg1=',arg1)
    print('arg2=',arg2)
    arg1=100
    arg2.append(10)
    print('arg1=',arg1)
    print('arg2=',arg2)

n1=11
n2=[22,33,44]
print('n1=',n1)
print('n2=',n2)
print('-------')
fun(n1,n2)
print('n1=',n1)
print('n2=',n2)

'''在函数调用过程中,进行参数的传递
如果是不可变对象,在函数体的修改不会形象实参的值 arg1修改为100,不会影响n1的值
如果是可变对象，在函数体的修改会影响到实参的值 arg2的修改,append(10),会影响到n2的值'''

Rückgabewert der Funktion

#函数的返回值
def fun(num):
    odd=[]
    even=[]
    for i in num:
        if i % 2: #bool(0)=False
            odd.append(i)
        else:
            even.append(i)
    return odd,even

print(fun([10,29,34,23,44,53,55]))

'''
(1)如果函数没有返回值【函数执行完毕后，不需要给调用处提供数据】 return可以省略
(2)如果函数有一个返回值，直接返回原类型
(3)如果函数有多个返回值，返回结果为元组
'''
def fun1():
    print('hello')
    #return

fun1()

def fun2():
    return 'hello'

res=fun2()
print(res)

def fun3():
    return 'hello','world'

print(fun3())
'''函数在定义时，是否需要返回值，视情况而定'''

Funktionsparameterdefinition

#默认值参数
def fun(a,b=10):  #b为默认值
    print(a,b)

#函数的调用
fun(100)# 100，10
fun(20,30)# 20，30

Beim Betrachten des Quellcodes von print haben wir Folgendes festgestellt:

Dieses Ende ist der Standardwertparameter, der standardmäßig den Zeilenumbruch vornimmt. Wenn Sie die Zeile nicht umbrechen möchten, können Sie andere Werte an end übergeben:

print('hello',end='\t')
print('world')
# 输出：hello world

#函数的参数定义
def fun(*args):  #函数定义时，个数可变的位置参数
    print(args)

fun(10)
fun(10,20,30)

def fun1(**args): #个数可变的关键字参数
    print(args)

fun1(a=10)
fun1(a=20,b=20,c=40)

''' def fun2(*args,*a):
       pass
    报错，个数可变的位置参数，只能是一个
    def fun2(*args,*a):
        pass
    报错，个数可变的关键字参数，只能是一个'''

def fun2(*args1,**args2):
    pass

''' def fun3(**args1,*args2):
        pass
在一个函数定义的过程中，既有个数可变的关键字参数，也有个数可变的位置形参，要求个数可变的位置形参，放在个数可变的关键字形参之前'''

#函数参数总结
def fun(a,b,c):  # a,b,c在函数的定义处，所以是形式参数
    print('a=',a)
    print('b=',b)
    print('c=',c)

#函数的调用
fun(10,20,30)  #函数调用时的参数传递，称为位置传参
'''
输出：
a=10
b=20
c=30
'''
lst=[11,22,33]
fun(*lst)  #函数调用时，将列表的每个元素都转换为位置实参传入
'''
输出：
a=11
b=22
c=33
'''
print('--------')
fun(a=100,c=300,b=200)  #关键字实参
'''
输出：
a=100
b=200
c=300
'''
dic={
    
    "a":111,'b':222,'c':333}
fun(**dic)  #在函数调用时，将字典的键值对都转换为关键字实参传入
'''
输出：
a=111
b=222
c=333
'''
def fun4(a,b,*,c,d):  #从*之后的参数，在函数调用时，只能采用关键字参数传递
    print('a=',a)
    print('b=',b)
    print('c=',c)
    print('d=',d)

#fun4(10,20,30,40) #位置实参传递
fun4(a=10,b=20,c=10,d=40) #关键字实参传递
fun4(10,20,c=30,d=40) #前两个位置实参传递，后两个关键字实参传递

'''函数定义时形参的顺序问题'''
def fun5(a,b,*,c,d,**args):
    pass
def fun6(*args,**args1):
    pass
def fun7(a,b=10,*args,**args1):
    pass

Variablenbereich

#变量的作用域
def fun(a,b):
    c=a+b  #c,就称为局部变量，因为c在函数体内进行定义的变量，a，b为函数的形参，作用范围也是函数内部，相当于局部变量 
    print(c)

name='刘'   #全局变量
print(name)
def fun1():
    print(name)
fun1()

def fun3():
    global age  #函数内部定义的变量，局部变量，其用global声明，这个变量变为全局变量
    age=20
    print(age)
fun3()
print(age)

rekursive Funktion

#递归函数
def fac(n):
    if n==1:
        return 1
    else:
        return n*fac(n-1)

print(fac(9))

#斐波那契数列
def fib(n):
    if n==1:
        return 1
    elif n==2:
        return 1
    else:
        return fib(n-1)+fib(n-2)

print(fib(6))

for i in range(1,7):
    print(fib(i))

Insekt

#bug的常见类型
#1.
age=input('请输入你的年龄：')
print(type(age))
# if age>=18:  #TypeError: '>=' not supported between instances of 'str' and 'int'
if int(age)>=18:
    print('你是成年人了')

#2.
# while i<10:
#     print（i）
i=0
while i<10:
    print(i)
    i+=1

#3.
for i in range(3):
    uname=input('请输入用户名：')
    pwd=input('请输入密码：')
    # if uname='admin' and pwd='admin':
    if uname=='admin' and pwd=='admin':
        print('登陆成功！')
        break
    # else
    else:
        print('输入有误')
else:
    print('对不起，三次均输入错误')

#4.索引越界问题IndexError
lst=[11,22,33,44]
# print(lst[4])  #list index out of range
print(lst[3])

#5.append()方法的使用不熟练
lst=[]
# lst=append('A','B','C')
lst.append('A')
lst.append('B')
lst.append('C')
print(lst)

#被动掉坑问题
''' n1=int(input('请输入一个整数：'))
    n2=int(input('请输入另一个整数：'))
    result=n1/n2
    print('结果为：',result)'''

Pythons Ausnahmemechanismus: try…Exception

Wenn mehrere Ausnahmen abgefangen werden müssen, können mehrere Ausnahmestrukturen verwendet werden:

#try...except结构
try:
    n1=int(input('请输入一个整数：'))
    n2=int(input('请输入另一个整数：'))
    result=n1/n2
    print('结果为：',result)
except ZeroDivisionError:
    print('对不起，除数不允许为零')
except ValueError:
    print('不能将字符转换为数字')
print('程序结束')

#try...except...else结构
try:
    n1=int(input('请输入一个整数：'))
    n2=int(input('请输入另一个整数：'))
    result=n1/n2
except BaseException as e:
    print('出错了',e)
else:
    print('结果为：',result)

#try...except...else...finally结构
try:
    n1=int(input('请输入一个整数：'))
    n2=int(input('请输入另一个整数：'))
    result=n1/n2
except BaseException as e:
    print('出错了',e)
else:
    print('结果为：',result)
finally:
    print('谢谢您的使用')
print('程序结束')

Häufige Ausnahmetypen in Python

#常见的异常类型
# print(10/0)  #ZeroDivisionError

lst=[11,22,33,44]
# print(lst[4])  #IndexError

dic={
    
    'name':'张三','age':20}
# print(dic['gender'])  #KeyError

# print(num)  #NameError

# int a=20  #SyntaxError

#a=int('hello')  #ValueError

Verwendung des Traceback-Moduls

#traceback模块的使用
import traceback
try:
    print('--------------')
    print(1/0)
except:
    traceback.print_exc()

Objekt

Alles in Python ist ein Objekt

Klassenerstellung

Unabhängig davon, ob Sie self in der Instanzmethode schreiben oder nicht, wird es ein self geben (wenn Sie kein Programm schreiben, erhalten Sie eines kostenlos). Self darf nicht in der statischen Methode geschrieben werden, cls muss dies tun in der Klassenmethode übergeben werden.

#定义python中的类
class Student:  #Student为类的名称（类名）由一个或多个单词组成，每个单词首字母大写，其余小写
    native_place='吉林'  #直接写在类里的变量，成为类属性
    def __init__(self,name,age):
        self.name=name  #self.name 称为实例属性，进行了一个赋值操作，将局部变量的name的值赋给实体属性/实例变量
        self.age=age
    #实例方法
    def eat(self):
        print(self.name+'在吃饭')
    #静态方法
    @staticmethod
    def sm():
        print('静态方法')
    #类方法
    @classmethod
    def cm(cls):
        print('类方法')
#在类之外定义的称为函数，再类之内定义的称为方法
def drink():
    print('喝水')

#创建Student类的对象
stu1=Student('张三',20)
stu2=Student('李四',30)
print(id(stu1))# 1421362237888
print(type(stu1))# <class '__main__.Student'>
print(stu1)# <__main__.Student object at 0x0000014AEFCA91C0>
# 1421362237888的十六进制为0x0000014AEFCA91C0
# 实例对象会有一个类指针指向类对象
print(id(Student))# 2218905389200
print(type(Student))# <class ‘type’>
print(Student)# <class '__main__.Student'>
# 下面两行都可以调用类的实例方法：实例对象.实例方法 或者 类对象.实例方法(实例对象)
stu1.eat()  #对象名.方法名()
Student.eat(stu1)  #类名.方法名(类的对象)-->实际上就是方法定义处的self
print(stu1.name)
print(stu1.age)

#类属性的使用方式
#print(Student.native_place)
print(stu1.native_place)# 吉林
print(stu2.native_place)# 吉林
Student.native_place='天津'
print(stu1.native_place)# 天津
print(stu2.native_place)# 天津
#类方法的使用方式
Student.cm()
#静态方法的使用方式
Student.sm()

#动态绑定属性和方法
stu2.gender='女'  #动态绑定性别属性
# print(stu1.name,stu1.age,stu1.gender)  #AttributeError: 'Student' object has no attribute 'gender'
print(stu2.name,stu2.age,stu2.gender)
stu1.eat()
stu2.eat()
def show():
    print('定义在类之外的，称为函数')
stu1.show=show  #动态绑定方法
stu1.show()
# stu2.show()  #AttributeError: 'Student' object has no attribute 'show'

Drei Hauptmerkmale der Objektorientierung

Verkapselung

#封装
class Car:
    def __init__(self,brand):
        self.brand=brand
    def start(self):
        print('汽车已启动...')

car=Car('宝马x5')
car.start()
print(car.brand)

class Student:
    def __init__(self,name,age):
        self.name=name
        self.__age=age  #年龄不希望在类的外部被使用，所以加__
    def show(self):
        print(self.name,self.__age)

stu=Student('张三',20)
stu.show()
#在类的外部使用name和age
print(stu.name)
# print(stu.__age)  #AttributeError: 'Student' object has no attribute '__age'
# print(dir(stu))  #获取对象所有的属性和方法
print(stu._Student__age)  #在类的外部可以通过 _Student__age 进行访问，输出：20

erben

Wenn Sie eine Klasse definieren, schreiben Sie die übergeordnete Klasse in Klammern. Beispielsweise ist die übergeordnete Klasse von Person oben ein Objekt und die übergeordnete Klasse von Student eine Person. Python unterstützt die Mehrfachvererbung. Beispielsweise erbt a ein Objekt, b erbt ein Objekt und c kann a und b gleichzeitig erben:class c(a,b)

#继承
class Person(object):
    def __init__(self,name,age):
        self.name=name
        self.age=age
    def info(self):
        print(self.name,self.age)
#定义子类
class Student(Person):
    def __init__(self, name, age,score):
        super().__init__(name, age)# 在子类的init方法中使用super().__init__调用父类的初始化方法进行赋值
        self.score=score# 然后再对自己内部的属性进行初始化
    def info(self):  #方法的重写，重写父类的info()
        super().info()# 如果还想用到父类的info()的方法体，使用super().info()调用
        print(self.score)
class Teacher(Person):
    def __init__(self, name, age,teachofyear):
        super().__init__(name, age)
        self.teachofyear=teachofyear
    def info(self):  #方法的重写
        super().info()
        print(self.teachofyear)
#测试
stu=Student('Jack',20,'1001')
stu.info()
tea=Teacher('Tom',40,20)
tea.info()

Objektklasse

#object类 -- 所有类的父类
class Student:
    def __init__(self,name,age):
        self.name=name
        self.age=age
    def __str__(self):
        return '我的名字是{0}，今年{1}岁'.format(self.name,self.age)

stu=Student('jack',20)
print(dir(stu))
print(stu)# 默认会调用__str__(self)方法，如果没有覆写，会输出实例对象的内存地址![请添加图片描述](https://img-blog.csdnimg.cn/23447cbce6124d0199d04855c30fdbfb.png)

print(type(stu))

Polymorphismus

Eine statische Sprache wie Java benötigt drei notwendige Bedingungen, um Polymorphismus zu erreichen: Vererbung, Methodenüberschreibung und übergeordnete Klasse, die auf untergeordnete Klassenobjekte verweist. Python ist jedoch eine dynamische Sprache. Es kümmert sich nur darum, ob Sie diese Methode haben, und kümmert sich nicht um die ausruhen.

#多态
class Animal(object):
    def eat(self):
        print('动物会吃')
class Dog(Animal):
    def eat(self):
        print('狗吃骨头')
class Cat(Animal):
    def eat(self):
        print('猫吃鱼')
class Person:
    def eat(self):
        print('人吃五谷杂粮')
#定义一个函数
def fun(obj):
    obj.eat()
#调用
fun(Cat())# 动物会吃
fun(Dog())
fun(Animal())
fun(Person())

Besondere Methoden und besondere Eigenschaften

#特殊属性
class A:
    pass
class B:
    pass
class C(A,B):
    def __init__(self,name,age):
        self.name=name
        self.age=age
class D(A):
    pass
#创建C类对象
x=C('jack',20)  #x是C类型的一个实例对象
print(x.__dict__)  #查看实例对象的属性字典
print(C.__dict__)# 查看类对象的属性字典
print(x.__class__)  #输出对象所属的类型 <class '__main__.C'>
print(C.__bases__)  #C类的父类类型的元组：(<class '__main__.A'>,<class '__main__.B'>)
print(C.__base__)  #类的基类，C继承A和B，所以输出<class '__main__.A'>，如果C继承B和A，则输出<class '__main__.B'>，C多继承时，谁在前就输出谁
print(C.__mro__)  #类的层次结构：(<class '__main__.C'>,<class '__main__.A'>,<class '__main__.B'>,<class 'object'>)
print(A.__subclasses__())  #子类的列表:[<class '__main__.C'>,<class '__main__.D'>]

#类的特殊方法
a=20
b=100
c=a+b  #两个整数类型的对象的相加操作
d=a.__add__(b)# 两个整数类型的对象的相加操作，底层调用的是__add__()进行相加
print(c)# 120
print(d)# 120

class Student:
    def __init__(self,name):
        self.name=name
stu1=Student('张三')
stu2=Student('李四')
s=stu1+stu2  #报错：Student类型不能进行相加，但是我想要相加怎么办呢？给Student类定义一个__add__()方法，如下所示
print(len(stu1))# 同理，如果我想输出长度，也会报错，但是我又想输出怎么办呢？给Student类定义一个__len__()方法，如下所示

class Student:
    def __init__(self,name):
        self.name=name
    def __add__(self,other):  #特殊方法
        return self.name+other.name
    def __len__(self):
        return len(self.name)
stu1=Student('张三')
stu2=Student('李四')
s=stu1+stu2  #实现两个对象的加法运算
print(s)# 张三李四
s=stu1.__add__(stu2)
print(s)# 张三李四

lst=[11,22,33,44]
print(len(lst))# 4，调用len(lst)时底层执行了lst.__len__()
print(lst.__len__())# 4
print(len(stu1))# 2

__new__ und __init__ erstellen Objekte

class Person(object):
    def __new__(cls,*args,**kwargs):
        print('__new__被调用执行了,cls的id值为{0}'.format(id(cls)))
        obj=super().__new__(cls)
        print('创建的对象的id为:{0}'.format(id(obj)))
        return obj        
    
    def __init__(self,name,age):
        print('__init__被调用了,self的id值为:{0}'.format(id(self)))
        self.name=name
        self.age=age

print('object这个类对象的id为:{0}'.format(id(object)))
print('Person这个类对象的id为:{0}'.format(id(Person)))

#创建person类的实例对象
p1=Person('张三',20)
print('p1这个Person类的实例对象的id:{0}'.format(id(p1)))

'''
程序的执行结果：
object这个类对象的id为:140717796113232
Person这个类对象的id为:2690679899360
__new__被调用执行了,cls的id值为2690679899360
创建的对象的id为:2690436007104
__init__被调用了,self的id值为:2690436007104
p1这个Person类的实例对象的id:2690436007104
'''

Flache Kopie und tiefe Kopie der Klasse

#类的浅拷贝与深拷贝
class CPU:
    pass
class Disk:
    pass
class Computer:
    def __init__(self,cpu,disk):
        self.cpu=cpu
        self.disk=disk

#(1)变量的赋值
cpu1=CPU
cpu2=cpu1
print(cpu1)# <__main__.CPU object at 0x000002B4D38D8490>
print(cpu2)# <__main__.CPU object at 0x000002B4D38D8490>
#(2)类的浅拷贝
disk=Disk()  #创建一个硬盘类的对象
computer=Computer(cpu1,disk)  #创建一个计算机类的对象

#浅拷贝
import copy
print(disk)# <__main__.Disk object at 0x000001782E443490>
computer2=copy.copy(computer)
print(computer,computer.cpu,computer.disk)# <__main__.Computer object at 0x000001781F3284C0> <__main__.CPU object at 0x000001781F238490> <__main__.Disk object at 0x000001782E443490>
print(computer2,computer2.cpu,computer2.disk)# <__main__.Computer object at 0x000001781F328190> <__main__.CPU object at 0x000001781F238490> <__main__.Disk object at 0x000001782E443490>

#深拷贝
computer3=copy.deepcopy(computer)
print(computer,computer.cpu,computer.disk)# <__main__.Computer object at 0x000001813E8284C0> <__main__.CPU object at 0x000001813E738490> <__main__.Disk object at 0x000001814D913490>
print(computer3,computer3.cpu,computer3.disk)# <__main__.Computer object at 0x000001813E8281F0> <__main__.CPU object at 0x000001814D943A30> <__main__.Disk object at 0x000001814EA626A0>

Modul

import math
print(id(math))
print(type(math))
print(math)
print(math.pi)
print(dir(math))
print(math.pow(2,3))
print(math.ceil(9.001))
print(math.floor(9.999))

from math import pi
# from math import pow
print(pi)
print(pow(2,3))
# print(math.pow(2,3))

Wenn ich jetzt ein Modul calc.py anpasse, möchte ich es in das Modul demo5.py importieren. Wenn ich es direkt schreibe, import calcwird ein Fehler gemeldet. Ich muss das Paket, in dem sich demo5.py befindet, als Quell-Root festlegen.

Als Hauptprogramm ausführen

Wenn eine calc2.py definiert ist, sieht der Inhalt wie folgt aus:

def add(a,b):
    return a+b

print(add(10,20))

Dann haben wir es in demo7.py eingeführt und ausgeführt print(calc2.add(100,200)). Es wird 30.300 ausdrucken, weil es zuerst den Ausdruck von calc2.py ausgeführt hat. Wenn wir nur 300 ausgeben wollen und es den Ausdruck von calc2.py nicht ausführen lassen wollen, können wir das tun Also:

def add(a,b):
    return a+b

if __name__ == '__main__':  #只有在这个模块运行时，才执行下述代码
    print(add(10,20))

Pakete in Python

Es gibt unzählige Pakete in einem Python-Programm, jedes Paket hat unzählige Module und jedes Modul hat unzählige Klassen, Methoden und Anweisungen. Erstellen Sie ein Paket in Python:

Importieren Sie die Module im Paket in demo8.py

Häufig verwendete Inhaltsmodule in Python

import sys
import time
import urllib.request
import math
print(sys.getsizeof(24))# 28:24占了28个字节
print(sys.getsizeof(45))# 28
print(sys.getsizeof(True))# 28
print(sys.getsizeof(False))# 24
print(time.time())
print(time.localtime(time.time()))
print(urllib.request.urlopen('http://www.baidu.com').read())
print(math.pi)

Installation und Nutzung von Drittmodulen

#第三方模块的安装  pip install 模块名
import schedule
import time

def job():
    print('hh')

schedule.every(3).seconds.do(job)
while True:
    schedule.run_pending()
    time.sleep(1)

dokumentieren

Kodierungsformat

Beim Betrieb chinesischer Textdateien treten häufig verstümmelte Zeichen auf.

So lesen Sie Dateien

Der Interpreter ruft die Ressourcen des Betriebssystems auf, um die .py-Datei zu lesen und die Datei auf der Festplatte zu bearbeiten (die Datei zu lesen und zu schreiben).

Der Inhalt von a.txt ist:

China
schön

#读
file=open('a.txt','r')
print(file.readlines())# ['中国\n','美丽']，输出一个数组
file.close()

Schreiben Sie „Hallo“ in die b.txt-Datei

# 写
file=open('b.txt','w')# 如果没有b.txt文件则创建，如果有b.txt文件，因为第二个参数传的w，所以会清除文件原有的内容，重新写入新内容
file.write('hello')
file.close()
#追加
file=open('b.txt','a')# 如果没有b.txt文件则创建，如果有b.txt文件，因为第二个参数传的a，所以会在原有内容上追加新内容
file.write('hello')
file.close()
#复制图片
src_file=open('logo.png','rb')
target_file=open('copylogo.png','wb')
target_file.write(src_file.read())# 边读边写
target_file.close()
src_file.close()

Gängige Methoden für Dateiobjekte

#读
file=open('a.txt','r')
print(file.read(5))  #读取size个字节或字符
print(file.readline())  #读取一行内容，输出：中国
print(file.readlines())  #把文本文件中的每一行都作为独立的字符对象，并将这些对象放入列表返回。输出：['中国\n','美丽']
#写
file=open('c.txt','a')
# file.write('hello')
lst=['java','go','python']
file.writelines(lst)# hellojavagopython
file.close()
#移动文件指针
file=open('c.txt','r')
file.seek(2)  #将文件移动到新的位置，一个汉字占2字节，这里写1会报错，写2会从国开始输出
print(file.read())
'''
国
美丽
''' 
print(file.tell())  #返回指针当前所处位置。如果文件写完了，file.tell()返回文件长度
file.close()

file=open('d.txt','a')
file.write('hello')
file.flush()  #把缓冲区的内容写入文件，但不关闭文件
file.write('world')
file.close()

mit Aussage

#with语句(上下文管理器)
with open('a.txt','r') as file:# 打开a.txt文件，为打开的这个文件起别名：file，file就是上下文管理器
    print(file.read())
#不用手动关闭!

wird open('a.txt','r')als Kontextausdruck bezeichnet und seine Ausführungsergebnisdatei ist ein Kontextmanager

Kontextmanager: Wenn ein Klassenobjekt __enter__()und __exit__()implementiert zuerst die Methode aus, führen Sie dann den With-Anweisungskörper aus, beenden Sie dann den Kontextmanager und führen Sie die Methode aus. Wenn beim Ausführen des with-Anweisungskörpers eine Ausnahme auftritt, wird die Methode ebenfalls aufgerufen, was darauf hinweist, dass die Methode im Kontextmanager aufgerufen wird, unabhängig davon, ob eine Ausnahme vorliegt oder nicht .



__enter__()__exit__()__exit__()__enter__()__exit__()

Verwenden Sie die with-Anweisung, um das oben genannte Bild zu kopieren:

with open('logo.png','rb') as src_file
	with open('copylogo.png','wb') as target_file
		target_file.write(src_file.read())# 边读边写

Allgemeine Funktionen des OS-Moduls

#os模块与操作系统相关的一个模块
import os
os.system('notepad.exe')# 打开系统中的记事本（应用程序）
os.system('calc.exe')# 打开系统中的计算器（应用程序）
#直接调用可执行文件
os.startfile('C:\\Program Files (x86)\\Tencent\\QQ\\Bin\\QQ.exe')

import os
print(os.getcwd())  #返回当前的工作目录（绝对路径）
lst=os.listdir('python')  #返回指定路径下的文件和目录信息，这里参数要写相对路径
print(lst)
os.makedirs('TXT/1.txt')  #创建多级目录
os.mkdir('TXT/0.txt')  #创建目录
os.rmdir('TXT')  #删除目录
os.removedirs('TXT/1.txt')  #删除多级目录
os.chdir('C:\\')  #改变工作路径
print(os.getcwd())

Gängige Methoden des Pfadmoduls

#os.path模块
import os.path
print(os.path.abspath('1.py'))  #获取文件的绝对路径
print(os.path.exists('1.py'),os.path.exists('2.py'))  #判断文件是否存在T/F
print(os.path.join('C:\\download','1.py'))  #目录和文件拼接操作，输出：C:\\download\\1.py
print(os.path.split('C:\\Users\\26066\\Desktop\\program\\VScode\\.vscode\\python\\helloworld.py'))  #拆分路径和文件，输出：('C:\\Users\\26066\\Desktop\\program\\VScode\\.vscode\\python','helloworld.py')
print(os.path.splitext('helloworld.py'))  #拆分文件和后缀名，输出：('helloworld','.py')
print(os.path.basename('C:\\Users\\26066\\Desktop\\program\\VScode\\.vscode\\python\\helloworld.py'))  #提取文件名，输出：helloworld.py
print(os.path.dirname('C:\\Users\\26066\\Desktop\\program\\VScode\\.vscode\\python\\helloworld.py'))  #提取目录名，输出：C:\\Users\\26066\\Desktop\\program\\VScode\\.vscode\\python
print(os.path.isdir('C:\\Users\\26066\\Desktop\\program\\VScode\\.vscode\\python'))  #判断是否是路径（目录）

#获取当前目录下的.txt文件
import os
path=os.getcwd()# 获取当前目录
lst=os.listdir(path)# 获取路径下的所有文件
for filename in lst:
    if filename.endswith('.txt'):# 如果文件名以.txt结尾
        print(filename)

#
import os
path=os.getcwd()
lst_files=os.walk(path)  #遍历目录下的所有文件夹及其子文件
for dirpath,dirname,filename in lst_files:
    # print(dirpath)# 当前路径
    # print(dirname)# 文件夹
    # print(filename)# 文件
    for dir in dirname:
        print(os.path.join(dirpath,dir))
    for file in filename:
        print(os.path.join(dirpath,file))