funzione python3

Funzione è una buona organizzazione, riutilizzabile, utilizzato per realizzare un unico segmento di codice, o funzioni associate.

La funzione può essere applicato per migliorare la modularità e riutilizzare il codice. Sapete già che Python fornisce molte funzioni incorporate, come la stampa (). Ma si può anche creare la propria funzione, che si chiama una funzione definita dall'utente.

Definire una funzione

È possibile definire una funzione dalla funzione che si desidera, le seguenti semplici regole:

• Blocco funzionaledef parola chiave in principio, seguito dal nome della funzione e identificatori fra parentesi ().
• I parametri in entrata e gli argomenti devono essere poste tra parentesi nel mezzo, può essere utilizzato per definire i parametri tra parentesi.
• La prima riga della dichiarazione funzione può opzionalmente utilizzare un documento stringa - sono utilizzati per la descrizione della funzione.
• contenuti Funzione iniziare con i due punti e l'indentazione.
• ritornare [espressione] fine della funzione, opzionalmente restituire un valore al chiamante. ritornare senza un'espressione equivalente a restituire None.

grammatica

funzioni Python definite utilizzando DEF parola chiave, il formato generale è la seguente:

def 函数名（参数列表）:
    函数体

Per impostazione predefinita, il nome del parametro e il parametro valore è nell'ordine definito nella dichiarazione di funzione corrisponda.

Esempi

Usiamo la funzione di uscita "Ciao Mondo!":

>>> def hello() :
   print("Hello World!")

   
>>> hello()
Hello World!
>>> 

Applicazione del punto più complesso, per portare le variabili dei parametri delle funzioni:

#!/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))

Esempi di uscita sopra:

Welcome w3big
width = 4  height = 5  area = 20

richiamo della funzione

Definire una funzione: dare la funzione di un nome, specificare i parametri della funzione contiene, e la struttura blocco di codice.

Dopo il completamento della struttura di base di questa funzione, è possibile eseguire un'altra chiamata di funzione da eseguire direttamente dal prompt dei comandi di Python.

I seguenti esempi sono chiamati funzione PrintMe ():

#!/usr/bin/python3
 
# 定义函数
def printme( str ):
   "打印任何传入的字符串"
   print (str);
   return;
 
# 调用函数
printme("我要调用用户自定义函数!");
printme("再次调用同一函数");

Esempi di uscita sopra:

我要调用用户自定义函数!
再次调用同一函数

Parametri passati da parametri di valore e passa per riferimento

In Python, tutti i parametri (variabili) sono passati per riferimento. Se si modifica un parametro in una funzione, allora questa funzione viene chiamata la funzione, i parametri originali sono anche cambiato. Ad esempio:

#!/usr/bin/python3
 
# 可写函数说明
def changeme( mylist ):
   "修改传入的列表"
   mylist.append([1,2,3,4]);
   print ("函数内取值: ", mylist)
   return
 
# 调用changeme函数
mylist = [10,20,30];
changeme( mylist );
print ("函数外取值: ", mylist)

E passata nella funzione dell'oggetto alla fine per aggiungere nuovi contenuti utilizzando lo stesso riferimento. Così i risultati di output sono i seguenti:

函数内取值:  [10, 20, 30, [1, 2, 3, 4]]
函数外取值:  [10, 20, 30, [1, 2, 3, 4]]

parametri

Quanto segue è il tipo di parametro formale può essere utilizzato quando si chiama la funzione:

• parametri obbligatori
• argomenti chiave
• I parametri di default
• parametri di lunghezza variabile

parametri obbligatori

Parametri obbligatori nell'ordine corretto da passare alla funzione. Quando il numero di chiamate e deve essere la stessa dichiarazione.

PrintMe funzione call (), si deve passare in un parametro, o si verificherà errore di sintassi:

#!/usr/bin/python3
 
#可写函数说明
def printme( str ):
   "打印任何传入的字符串"
   print (str);
   return;
 
#调用printme函数
printme();

Esempi di uscita sopra:

Traceback (most recent call last):
  File "test.py", line 10, in <module>
    printme();
TypeError: printme() missing 1 required positional argument: 'str'

argomenti chiave

argomenti e la funzione chiave chiamate uno stretto rapporto chiamata di funzione con argomenti a parola chiave per determinare il valore del parametro passato.

Quando si utilizza il parametro parola chiave permette il parametro d'ordine chiamata di funzione è incompatibile con l'affermazione, perché Python interprete capace di abbinare i valori dei parametri utilizzando il nome del parametro.

La funzione PrintMe seguente esempio () viene chiamato con il nome del parametro:

#!/usr/bin/python3
 
#可写函数说明
def printme( str ):
   "打印任何传入的字符串"
   print (str);
   return;
 
#调用printme函数
printme( str = "本教程");

Esempi di uscita sopra:

本教程

L'esempio seguente mostra l'utilizzo di parametri di funzionamento non è necessario utilizzare l'ordine specificato:

#!/usr/bin/python3
 
#可写函数说明
def printinfo( name, age ):
   "打印任何传入的字符串"
   print ("名字: ", name);
   print ("年龄: ", age);
   return;
 
#调用printinfo函数
printinfo( age=50, name="w3big" );

Esempi di uscita sopra:

名字:  w3big
年龄:  50

I parametri di default

Quando la funzione viene chiamata, se il parametro non viene passato, userà i parametri di default. L'esempio che segue, se nessun parametro di età in entrata, il valore di default:

#!/usr/bin/python3
 
#可写函数说明
def printinfo( name, age = 35 ):
   "打印任何传入的字符串"
   print ("名字: ", name);
   print ("年龄: ", age);
   return;
 
#调用printinfo函数
printinfo( age=50, name="w3big" );
print ("------------------------")
printinfo( name="w3big" );

Esempi di uscita sopra:

名字:  w3big
年龄:  50
------------------------
名字:  w3big
年龄:  35

parametri di lunghezza variabile

Potrebbe essere necessario una funzione in grado di gestire più di dichiarazione originale di parametri. Questi parametri sono detti parametri di lunghezza variabile, ed i due tipi di parametri sono differenti, non denominazione dichiarazione. La sintassi di base è la seguente:

def functionname([formal_args,] *var_args_tuple ):
   "函数_文档字符串"
   function_suite
   return [expression]

Con un asterisco (*) verranno memorizzati nei nomi delle variabili tutti i parametri variabili senza nome. Se nessun argomento quando la funzione viene chiamata, è una tupla vuota. Non possiamo passare variabili senza nome a una funzione. I seguenti esempi:

#!/usr/bin/python3
 
# 可写函数说明
def printinfo( arg1, *vartuple ):
   "打印任何传入的参数"
   print ("输出: ")
   print (arg1)
   for var in vartuple:
      print (var)
   return;
 
# 调用printinfo 函数
printinfo( 10 );
printinfo( 70, 60, 50 );

Esempi di uscita sopra:

输出:
10
输出:
70
60
50

funzione anonima

python utilizzando lambda per creare una funzione anonima.

Il cosiddetto anonima, il che significa che non è più utilizzare questa istruzione modulo definizione standard per definire una funzione.

• Basta un'espressione lambda, il corpo della funzione è molto più semplice def.
• Il corpo è un'espressione lambda, piuttosto che un blocco di codice. Siamo in grado di confezionare solo una logica limitata nell'espressione lambda.
• funzione lambda ha un proprio spazio dei nomi, e non è possibile accedere al di fuori della propria lista degli argomenti oi parametri namespace globale.
• Anche se la funzione lambda sembra solo scrivere una sola riga, ma non lo stesso di funzioni inline in C o C ++, quest'ultimo obiettivo non è occupato quando si chiama la piccola funzione di memoria di stack per aumentare l'efficienza operativa.

grammatica

sintassi funzione Lambda contiene una sola istruzione, come segue:

lambda [arg1 [,arg2,.....argn]]:expression

I seguenti esempi:

#!/usr/bin/python3
 
# 可写函数说明
sum = lambda arg1, arg2: arg1 + arg2;
 
# 调用sum函数
print ("相加后的值为 : ", sum( 10, 20 ))
print ("相加后的值为 : ", sum( 20, 20 ))

Esempi di uscita sopra:

相加后的值为 :  30
相加后的值为 :  40

istruzione return

ritornare [espressione] istruzione viene utilizzata per uscire dalla funzione, in modo selettivo al chiamante restituisce un espressione.istruzione return senza parametri restituisce None. Non ci sono esempi precedenti dimostrano come restituire un valore, il seguente viene illustrato l'utilizzo della dichiarazione di ritorno:

#!/usr/bin/python3

# 可写函数说明
def sum( arg1, arg2 ):
   # 返回2个参数的和."
   total = arg1 + arg2
   print ("函数内 : ", total)
   return total;

# 调用sum函数
total = sum( 10, 20 );
print ("函数外 : ", total)

Esempi di uscita sopra:

函数内 :  30
函数外 :  30

Mirino variabile

Pyhton, la variabile non è la posizione in cui il programma può accedere, accesso dipende da dove viene assegnato alla variabile.

#!/usr/bin/python3

total = 0; # 这是一个全局变量
# 可写函数说明
def sum( arg1, arg2 ):
    #返回2个参数的和."
    total = arg1 + arg2; # total在这里是局部变量.
    print ("函数内是局部变量 : ", total)
    return total;

#调用sum函数
sum( 10, 20 );
print ("函数外是全局变量 : ", total)

函数内是局部变量 :  30
函数外是全局变量 :  0