Einführung in Python-Funktionen

Funktion

Konzept:
In einem vollständigen Projekt können einige Funktionen wiederholt verwendet werden. An dieser Stelle werden wir diese Funktionen als Funktionen kapseln und die Funktionen dann direkt aufrufen, wenn wir sie verwenden.
Essenz:
Die Kapselung von Funktionen ist Funktionen.
Vorteile:
1. Vereinfachen Sie die Codestruktur und erhöhen Sie den Grad der Wiederverwendung von Code.
2. Es ist bequem zu ändern, zu warten und zu debuggen

1. Funktionen erstellen und aufrufen

Verwendung :

'''
def(关键字) 函数名（）：
	函数体
	return 返回表达式
函数名（） #调用
'''
#函数名可以大小写字母、下划线开头，不能数字开头
def func():
	a=1
	b=2
	print('这是返回值%d'%(a+b))
func()

###############################
这是返回值3

Zweitens die Parameter der Funktion

Konzept : Die Parameter der Funktion sind die Dinge in Klammern, die personalisiert werden können

def func(grade):    #括号里的参数近似相当于变量
	print('我的成绩为：'+grade)
func('100')

################################
我的成绩为：100

3. Der Rückgabewert der Funktion

Konzept : Wenn wir das Ausführungsergebnis der Funktion benötigen, um die Daten anstelle des von uns angegebenen Ergebnisses zurückzugeben, verwenden Sie das Schlüsselwort in der Funktion: return+der angegebene Rückgabewert

def func(a,b):
	return a+b
print(func(1,2))	

################################
3

Hinweis : Wenn return innerhalb der Funktion verwendet wird, muss print() aufgerufen werden , sonst erfolgt keine Ausgabe

Viertens die Parameter der Funktion

Bedeutung : Wenn die Funktion keine Parameter hat, wird die Funktion sehr einfach und starr und führt dementsprechend eine einzelne
Funktion aus Parameter Parameter) und aktuelle Parameter (aktuelle Parameter). Formaler Parameter : Der Parameter in Klammern während der Funktionserstellung und -definition Tatsächlicher Parameter : Der Parameter oder Wert, der beim Aufruf der Funktion übergeben wird

str1 = '满分'
def func(grade):  #小括号里面的grade就是形参
	return grade
print(func(str1))  #调用时候的参数就是实参

#####################################
满分

2. Das Konzept der Schlüsselwortparameter : Gewöhnliche Parameter werden Positionsparameter genannt.Beim Aufrufen übergeben wir möglicherweise versehentlich die falsche Reihenfolge der Parameter, was zu inkonsistenten Ergebnissen mit unseren Erwartungen führt, zum Beispiel:

def func(fruit,color):
	print(fruit,'这个水果是',color,'色')
func('红','apple')	

####################################
红 这个水果是 apple 色

Verwenden Sie Schlüsselwortargumente:

def func(fruit,color):
	print(fruit,'这个水果是',color,'色')
func(color='红',fruit='apple')	

##############################
apple 这个水果是 红 色

3. Das Konzept der Standardparameter : Der Standardparameter ist der Wert, der dem formalen Parameter zugewiesen wird, wenn der formale Parameter gesetzt wird (anders als das Schlüsselwort parameter )

def func(fruit='Apple',color='是红色'):
	print(fruit,color)
func()

################################
Apple 是红色	

func(fruit='Pear',color='是黄色')#在传递参数过程中，替换了默认的值

#####################################
Pear 是黄色

4. Das Konzept der Positionsvariablenparameter (variable Parameter) : Fügen Sie ein Sternchen ( * ) vor dem Parameter hinzu, wenn Sie nicht wissen, wie viele Parameter in einer bestimmten Situation verwendet werden

def func(*test):
	print('test有%d个参数'%len(test))
	print('最后一个参数是',test[-1])
	print(type(test))
	print(test)
func(1,2,2,4,5,5,3)

#################################
test有7个参数
最后一个参数是 3
<class 'tuple'>
(1, 2, 2, 4, 5, 5, 3)

5. Schlüsselwort-Variablenparameter ()
-Konzept : Dieser formale Parameter kann eine beliebige Anzahl von eingehenden Schlüssel-Wert-Paar- Parametern (Schlüsselwort-tatsächliche Parameter) akzeptieren, und die akzeptierten Parameter werden in einem Wörterbuch organisiert

def func(**kwd):
	print(kwd) #kwd以字典的方式组织传入的关键字实参
func(fruit='apple',price=10)	

######################################
{
    
    'fruit': 'apple', 'price': 10}

Hinweis : Wenn Positionsvariablenparameter (args) und Schlüsselwortvariablenparameter (**kwd) zusammen verwendet werden, müssen die Positionsvariablenparameter (args) zuerst und die Schlüsselwortvariablenparameter (**kwd) zuletzt deklariert werden

Fünf, der Umfang der Funktion

1. Prozessverständnis von Funktionen : In Python gibt es nur Funktionen ohne Prozesse

def func():
	print(123)
print(func())

###############################
123
None
#没有return默认返回一个None	

2. Verständnis von Rückgabewerten : Python kann Sequenzen verwenden, um mehrere Arten von einmaligen Rückgabewerten zu packen

def func():
	return 1,2,3,4
print(func())

###############################
(1, 2, 3, 4)

3. Den Gültigkeitsbereich von Variablen
verstehen : Der Gültigkeitsbereich von Variablen ähnelt der Variablensichtbarkeit

def func(gra,num):
	count_grade=gra*num
	return count_grade

final_grade=func(80,5)
print(final_grade)
print(count_grade)

###################################
400
NameError: name 'count_grade' is not defined

Hinweis : Der Grund für den Fehler ist, dass „count_grade“ nicht definiert wurde, weil es innerhalb der func-Funktion definiert ist und nur innerhalb der Funktion gültig ist und ungültig ist, wenn es außerhalb der Funktion aufgerufen wird wird als lokale Variable bezeichnet .
Den lokalen Variablen entsprechen globale Variablen , und der Geltungsbereich globaler Variablen ist größer als der von lokalen Variablen.
example1:

def func(gra,num):
   count_grade=gra*num
   print(grade)
   return count_grade

grade=80
final_grade=func(80,5)
print(final_grade)

###########################
80
400

Beispiel2:

def func(gra,num):
   count_grade=gra*num
   grade=100
   print('in_grade:',grade)
   return count_grade

grade=80
final_grade=func(80,5)
print('out_grade:',grade)
print(final_grade)

#############################
in_grade: 100
out_grade: 80
400

Hinweis : Die Note innerhalb der Funktion hier ist eine neue lokale Variable, die von Python selbst erstellt wurde und nichts mit der externen Note zu tun hat 4. Das Konzept des
globalen Schlüsselworts : Wie im obigen Beispiel gezeigt, schützt Python globale Variablen, und dieser Schutz wirkt sich manchmal auf die Wartung des Codes aus, daher gibt es eine globale Schlüsselwortlösung

def func(gra,num):
   count_grade=gra*num
   global grade
   grade = 100
   print('in_grade:',grade)
   return count_grade

grade=80
final_grade=func(80,5)
print('out_grade:',grade)
print(final_grade)

##################################
in_grade: 100
out_grade: 100
400

6. Eingebaute Funktionen und Verschlüsse

1. Das Konzept der eingebetteten Funktionen : Es ermöglicht, eine andere Funktion innerhalb einer Funktion zu erstellen

def func1():
	print('func1')
	def func2():
		return 'func2'
	return func2()
print(func1())	

############################
func1
func2

Hinweis : func2 ist eine interne Funktion von func1 , daher befindet sich ihr Gültigkeitsbereich auch im Funktionskörper von func1, und ein Fehler wird gemeldet, wenn sie extern aufgerufen wird -globaler Gültigkeitsbereich ) Referenz, dann wird die interne Funktion als Abschluss betrachtet, und der Abschluss ist eine wichtige Komponente der Funktion

def func1(x):
	def func2(y):
		return x*y
	return func2 #这里不用括号

#调用格式1
a=func1(10)
print(a(5))
#调用格式2
print(func1(10)(5))

#########################
50
50	

Hinweis : Es hat dieselbe Bedeutung wie Einbetten, Sie können func2 nicht direkt aufrufen, und es wird ein Fehler gemeldet