funkcja Python3
Funkcja to sprawna organizacja, wielokrotnego użytku, stosowane w celu osiągnięcia jeden segment kodu lub związanych funkcji.
Funkcja ta może być stosowana do poprawy modułowości i ponownego wykorzystania kodu. Wiesz już, że Python posiada wiele wbudowanych funkcji, takich jak print (). Ale można też stworzyć własną funkcję, która jest wywoływana funkcja zdefiniowana przez użytkownika.
Definiowanie funkcji
Można zdefiniować funkcję z funkcją chcesz, następujących prostych reguł:
- Blok funkcyjnydef kluczowe na początku, po którym następuje nazwa funkcji i identyfikatorów w nawiasach ().
- Nadchodzące parametry oraz argumenty muszą być umieszczone w nawiasach w środku, to może być stosowane do określenia parametrów nawiasach.
- Pierwsza linia rachunku funkcyjnego można ewentualnie użyć dokumentu String - służą do opisu funkcji.
- Zawartość funkcji zaczynające się dwukropkiem i wgniecenia.
- Powrót [wyrażenie] koniec funkcji, ewentualnie zwrócić wartość do rozmówcy. powrót bez ekwiwalentu ekspresji powrót Brak.
gramatyka
Python funkcje zdefiniowane za pomocą słowa kluczowego def, ogólny format jest następujący:
def 函数名（参数列表）:
函数体
Domyślnie, nazwa parametru i parametr wartość jest w kolejności określonej w deklaracji funkcji dopasowuje się.
Przykłady
Użyjmy funkcję do wyjścia "Hello World!":
>>> def hello() :
print("Hello World!")
>>> hello()
Hello World!
>>>
Zastosowanie bardziej złożonego punktu, aby doprowadzić zmiennych parametrów funkcji:
#!/usr/bin/python3
# 计算面积函数
def area(width, height):
return width * height
def print_welcome(name):
print("Welcome", name)
print_welcome("w3big")
w = 4
h = 5
print("width =", w, " height =", h, " area =", area(w, h))
Przykłady wyżej wyjścia:
Welcome w3big width = 4 height = 5 area = 20
wywołanie funkcji
Definiowanie funkcji: Funkcja dać nazwę, określić parametry funkcji zawiera i struktura blok kodu.
Po zakończeniu podstawowej struktury tej funkcji, można wykonać kolejne wywołanie funkcji którą należy wykonać bezpośrednio z poziomu wiersza poleceń Pythona.
Poniższe przykłady są nazywane PrintMe funkcji ():
#!/usr/bin/python3
# 定义函数
def printme( str ):
"打印任何传入的字符串"
print (str);
return;
# 调用函数
printme("我要调用用户自定义函数!");
printme("再次调用同一函数");
Przykłady wyżej wyjścia:
我要调用用户自定义函数! 再次调用同一函数
Parametry przekazywane przez parametry wartości i przejść przez odniesienie
W Pythonie wszystkie parametry (zmienne) są przekazywane przez odniesienie. Po zmianie parametru w funkcji, to ta funkcja jest wywoływana funkcja, oryginalne parametry zostały zmienione. Na przykład:
#!/usr/bin/python3
# 可写函数说明
def changeme( mylist ):
"修改传入的列表"
mylist.append([1,2,3,4]);
print ("函数内取值: ", mylist)
return
# 调用changeme函数
mylist = [10,20,30];
changeme( mylist );
print ("函数外取值: ", mylist)
I przekazywane do funkcji obiektu na koniec dodać nowe treści, używając tego samego odniesienia. Zatem, wyniki wyjściowe są następujące:
函数内取值: [10, 20, 30, [1, 2, 3, 4]] 函数外取值: [10, 20, 30, [1, 2, 3, 4]]
parametry
Poniżej znajduje się formalny typ parametru mogą być wykorzystane przy wywołaniu funkcji:
- wymagane parametry
- argumenty Hasło
- Parametry domyślne
- Parametry zmiennej długości
wymagane parametry
Wymagane parametry w odpowiedniej kolejności, aby być przekazywane do funkcji. Gdy liczba połączeń i musi być taka sama deklaracja.
Zaproszenie PrintMe () funkcji, należy przejść do parametru, lub nastąpi błąd składni:
#!/usr/bin/python3 #可写函数说明 def printme( str ): "打印任何传入的字符串" print (str); return; #调用printme函数 printme();
Przykłady wyżej wyjścia:
Traceback (most recent call last):
File "test.py", line 10, in <module>
printme();
TypeError: printme() missing 1 required positional argument: 'str'
argumenty Hasło
Złożone argumenty i wywołania funkcji ścisły związek wywołanie funkcji za pomocą argumentów, słów kluczowych, aby określić wartość parametru przyjęta.
Przy użyciu parametru kluczowego umożliwia parametr wywołania funkcji zlecenia jest niezgodna ze stwierdzeniem, ponieważ interpreter Pythona zdolny do dopasowania wartości parametrów przy użyciu nazwy parametru.
W poniższym przykładzie funkcja PrintMe () jest wywoływana z nazwy parametru:
#!/usr/bin/python3 #可写函数说明 def printme( str ): "打印任何传入的字符串" print (str); return; #调用printme函数 printme( str = "本教程");
Przykłady wyżej wyjścia:
本教程
Poniższy przykład pokazuje zastosowanie parametrów funkcji nie trzeba używać podanej kolejności:
#!/usr/bin/python3
#可写函数说明
def printinfo( name, age ):
"打印任何传入的字符串"
print ("名字: ", name);
print ("年龄: ", age);
return;
#调用printinfo函数
printinfo( age=50, name="w3big" );
Przykłady wyżej wyjścia:
名字: w3big 年龄: 50
Parametry domyślne
Gdy funkcja jest wywoływana, gdy parametr nie jest przekazywana, użyje domyślnych parametrów. W poniższym przykładzie, jeśli nie ma przychodzących parametru wiekowej, wartość domyślna:
#!/usr/bin/python3
#可写函数说明
def printinfo( name, age = 35 ):
"打印任何传入的字符串"
print ("名字: ", name);
print ("年龄: ", age);
return;
#调用printinfo函数
printinfo( age=50, name="w3big" );
print ("------------------------")
printinfo( name="w3big" );
Przykłady wyżej wyjścia:
名字: w3big 年龄: 50 ------------------------ 名字: w3big 年龄: 35
Parametry zmiennej długości
Może trzeba funkcję, która może obsłużyć więcej niż oryginalnej deklaracji parametrów. Parametry te nazywane są zmienne parametry długości i dwa rodzaje parametrów są różne, nie nazywając oświadczenie. Składnia podstawowa jest następujący:
def functionname([formal_args,] *var_args_tuple ): "函数_文档字符串" function_suite return [expression]
Gwiazdką (*) będą przechowywane w nazwach zmiennych wszystkie nienazwane zmiennych parametrów. Jeśli żaden argument, gdy funkcja jest wywoływana, to pusta krotka. Nie możemy przekazać zmienną do funkcji nienazwanych. Następujące przykłady:
#!/usr/bin/python3
# 可写函数说明
def printinfo( arg1, *vartuple ):
"打印任何传入的参数"
print ("输出: ")
print (arg1)
for var in vartuple:
print (var)
return;
# 调用printinfo 函数
printinfo( 10 );
printinfo( 70, 60, 50 );
Przykłady wyżej wyjścia:
输出: 10 输出: 70 60 50
funkcja Anonymous
python przy użyciu lambda do tworzenia anonimowej funkcji.
Tzw anonimowe, co oznacza, że nie używa tego standardowego formularza oświadczenia def zdefiniować funkcję.
- Wystarczy wyrażenie lambda, ciało funkcji jest o wiele prostsze niż def.
- Ciało jest wyrażenie lambda, niż blok kodu. Możemy zapakować tylko ograniczoną logikę do wyrażenia lambda.
- Funkcja lambda ma własną przestrzeń nazw, a nie mogą być dostępne poza swoim liście argumentów lub globalnych parametrów nazw.
- Chociaż funkcja lambda wygląda napisać tylko jeden wiersz, ale nie takie same jak funkcje inline w C lub C ++, ten ostatni cel nie jest przy wywołaniu małą funkcję pamięci stosu w celu zwiększenia efektywności operacyjnej zajęte.
gramatyka
Składnia funkcji lambda zawiera tylko jedną instrukcję, jak następuje:
lambda [arg1 [,arg2,.....argn]]:expression
Następujące przykłady:
#!/usr/bin/python3
# 可写函数说明
sum = lambda arg1, arg2: arg1 + arg2;
# 调用sum函数
print ("相加后的值为 : ", sum( 10, 20 ))
print ("相加后的值为 : ", sum( 20, 20 ))
Przykłady wyżej wyjścia:
相加后的值为 : 30 相加后的值为 : 40
return
Powrót [wyrażenie] Oświadczenie służy do wyjścia z funkcji, selektywnie rozmówca zwraca wyrażenie.return bez parametrów zwróci None. Brak wcześniejsze przykłady pokazują, w jaki sposób zwrócić wartość, Poniższy przykład demonstruje użycie instrukcji return:
#!/usr/bin/python3
# 可写函数说明
def sum( arg1, arg2 ):
# 返回2个参数的和."
total = arg1 + arg2
print ("函数内 : ", total)
return total;
# 调用sum函数
total = sum( 10, 20 );
print ("函数外 : ", total)
Przykłady wyżej wyjścia:
函数内 : 30 函数外 : 30
zmienna Zakres
Pyhton zmienna nie ma miejsca, w których można uzyskać dostęp do programu, w zależności od dostępu do której przypisany jest zmienny.
- Zmienne globalne
- zmienne lokalne
Zmienne globalne i lokalne
Definicja funkcji zmiennych wewnętrznych posiadać lokalny zakres, określony w funkcji zewnętrznego ma zakresu globalnych.
Zmienne lokalne mogą być zadeklarowane tylko wewnątrz można uzyskać funkcją jego dostęp do zmiennych globalnych w całej procedury. Podczas wywoływania funkcji, wszystkie nazwy zmiennych w deklaracji funkcja zostanie dodana do zakresu. Następujące przykłady:
#!/usr/bin/python3
total = 0; # 这是一个全局变量
# 可写函数说明
def sum( arg1, arg2 ):
#返回2个参数的和."
total = arg1 + arg2; # total在这里是局部变量.
print ("函数内是局部变量 : ", total)
return total;
#调用sum函数
sum( 10, 20 );
print ("函数外是全局变量 : ", total)
Przykłady wyżej wyjścia:
函数内是局部变量 : 30 函数外是全局变量 : 0