Fonctions 25-Python

05-fonction \ 01-fonction un.pdf
05-fonction \ 02-fonction deux.pdf

1. Documentation fonctionnelle

Réflexion: Après avoir défini une fonction, comment les programmeurs peuvent-ils écrire des programmes qui peuvent rapidement activer la fonction de cette fonction?

Réponse: Notes

Réflexion: S'il y a beaucoup de code, devons-nous trouver l'emplacement de cette définition de fonction dans beaucoup de code pour voir le commentaire? Que faire si vous souhaitez
afficher le rôle de la fonction plus facilement?

Réponse: La documentation de la fonction

La documentation de la fonction est également appelée documentation de la fonction.

1. Grammaire

Documentation pour définir les fonctions

def 函数名(参数):
	""" 说明⽂文档的位置 """
	代码
	......

Afficher la documentation de la fonction

help(函数名)

2. Expérience rapide

def sum_num(a, b):
	""" 求和函数 """
	return a + b
help(sum_num)

Sortir:

Help on function sum_num in module __main__:

sum_num(a, b)
    求和函数

2. Comment modifier les variables globales dans le corps de la fonction

Il y a le code suivant:

a = 100
def testA():
    print(a)    #这里的a应该是全局变量
def testB():
    a = 200     #这里的a应该是局部变量
    print(a)

testA() # 全局变量的值100
testB() # 局部的变量的值200

print(f'全局变量量a = {a}') # 全局变量量a = 100

Sortie du programme:

100
200
全局变量量a = 100

Réflexion: Comment modifier les variables globales à l'intérieur du corps de la fonction testB ()?
Réponse: utilisez le mot-clé global pour déclarer

a = 100
def testA():
    print(a)
def testB():
    # global 关键字声明a是全局变量量
    global a
    a = 200
    print(a)


testA() # 100
testB() # 200

print(f'全局变量量a = {a}') # 全局变量量a = 200

La sortie du programme:

100
200
200
全局变量量a = 200

3. La fonction a plusieurs valeurs de retour

Réflexion: Comment écrire du code si une fonction a plusieurs valeurs de retour

def return_num():
    return 1, 2
result = return_num()
print(result) # (1, 2)

La sortie du programme:

(1, 2)

Remarque:

1. Return a, b est écrit, lors du retour de plusieurs données, la valeur par défaut est le type tuple.
2. Une liste, un tuple ou un dictionnaire peut être concaténé après retour pour renvoyer plusieurs valeurs.

4. Paramètres de fonction

1. Paramètres de localisation

Paramètres de position: lors de l'appel d'une fonction, les paramètres sont passés en fonction de la position du paramètre défini par la fonction.

def user_info(name, age, gender):
	print(f'您的名字是{name}, 年龄是{age}, 性别是{gender}')
user_info('TOM', 20, '男')

Sortie du programme:

您的名字是TOM, 年龄是20, 性别是男

Remarque: l'ordre et le nombre de paramètres passés et définis doivent être cohérents.

2. Paramètres des mots-clés

L'appel de fonction est "键=值"spécifié par le formulaire. Cela peut rendre la fonction plus claire et plus facile à utiliser, et il élimine également le besoin de l'ordre des paramètres.

def user_info(name, age, gender):
	print(f'您的名字是{name}, 年龄是{age}, 性别是{gender}')
user_info('Rose', age=20, gender='女')
user_info('小明', gender='男', age=16)

Sortie du programme:

您的名字是Rose, 年龄是20, 性别是女
您的名字是小明, 年龄是16, 性别是男

3. Paramètres par défaut

Les paramètres par défaut sont également appelés paramètres par défaut, utilisés pour définir des fonctions et fournir des valeurs par défaut pour les paramètres. Lors de l'appel de la fonction, la valeur des paramètres par défaut peut ne pas être transmise (note
: tous les paramètres de position doivent apparaître avant la valeur par défaut paramètres, y compris les définitions de fonctions et les appels).

Remarque: lorsque la fonction est appelée, si vous transmettez la valeur du paramètre par défaut, modifiez la valeur du paramètre par défaut; sinon, utilisez cette valeur par défaut.

5. Paramètres de longueur variable

Les paramètres de longueur variable sont également appelés paramètres variables. Il est utilisé dans les scénarios où vous n'êtes pas sûr du nombre de paramètres qui seront passés lors de l'appel (aucun paramètre ne peut être transmis).

À ce stade, il est très pratique d'utiliser des paramètres de position d'emballage ou des paramètres de mot-clé d'emballage pour le transfert de paramètres.

Lorsqu'une fonction transmet des variables, il y a deux façons: l'une est les paramètres de position et l'autre les paramètres de mot-clé. De même, il existe deux façons pour les paramètres avec des longueurs variables.

1. Livraison de l'emplacement du colis

def user_info(*args):
	print(args)
user_info('TOM')
user_info('TOM', 20)
user_info('TOM', 20, '男')

La sortie du programme:

('TOM',)
('TOM', 20)
('TOM', 20, '男')

Remarque: Tous les paramètres passés seront argscollectés par des variables. Ils seront fusionnés dans un tuple ( tuple) en fonction de la position du paramètre passé, qui est un argstype de tuple , qui est le transfert de position du package.

2. Livraison des clés de colis

def user_info(**kwargs):
    print(kwargs)
# {'name': 'TOM', 'age': 18, 'id': 110}
user_info(name='TOM')
user_info(name='TOM', age=18)
user_info(name='TOM', age=18, id=110)

La sortie du programme:

{
    
    'name': 'TOM'}
{
    
    'name': 'TOM', 'age': 18}
{
    
    'name': 'TOM', 'age': 18, 'id': 110}

Pour résumer: qu'il s'agisse de transfert d'emplacement de package ou de transfert de mot-clé de package, il s'agit d'un processus de regroupement d'un package.

6. Déballage

1. Déballage: Tuples

def return_num():
	return 100, 200 #这种形式默认返回的是元组
num1, num2 = return_num()
print(num1) # 100
print(num2) # 200

2. Déballage: dictionnaire

Décompressez le dictionnaire et récupérez la clé du dictionnaire

dict1 = {
    
    'name': 'TOM', 'age': 18}
a, b = dict1
# 对字典进行拆包，取出来的是字典的key
print(a) # name
print(b) # age
print(dict1[a]) # TOM
print(dict1[b]) # 18

La sortie du programme:

name
age
TOM
18

3. Échangez les valeurs des variables

a,b = 1,2
print(a)
print(b)

a,b = b,a
print(a)
print(b)

Sortie du programme:

1
2
2
1

7. Citation

1. Connaître les références

En Python, les valeurs sont transmises par référence.
Nous pouvons utiliser id()pour déterminer si deux variables font référence à la même valeur.
Nous pouvons comprendre la valeur id comme l'identification d'adresse de ce morceau de mémoire.

# 1. int类型
a = 1
b = a
print(b) # 1
print("id(a):", id(a))
print("id(b):", id(b))

a = 2
print(b) # 1,说明int类型为不可变类型

print("id(a):", id(a))
print("id(b):", id(b))

La sortie du programme:

1
id(a): 2305065249072
id(b): 2305065249072
1
id(a): 2305065249104
id(b): 2305065249072

Le début de a et b sont la même adresse, vous pouvez également voir à partir de l'impression que la valeur de b est 1, et plus tard exécutée a = 2après que l'original n'est pas conforme à la valeur logique de b devrait être 1, car ils représentent le même morceau de zone de mémoire. Mais par la suite, on peut voir d'après l'impression que les adresses de a et b sont différentes.

2. Liste des références

# 2. 列列表
aa = [10, 20]
bb = aa

print(id(aa))
print(id(bb))

aa.append(30)

print(bb) # [10, 20, 30], 列列表为可变类型
print(id(aa))
print(id(bb))

Sortie du programme:

3066822266688
3066822266688
[10, 20, 30]
3066822266688
3066822266688

8. Citation comme paramètre réel

def test1(a):
    print(a)
    print("before a += a, id(a):", id(a))


    a += a
    print(a)
    print("after a += a,id(a):", id(a))

# int：计算前后id值不不同
b = 100
print('id(b):', id(b))
test1(b)

# 列列表：计算前后id值相同
c = [11, 22]
print('id(c):', id(c))
test1(c)

Sortie du programme:

id(b): 2453566281168
100
before a += a, id(a): 2453566281168
200
after a += a,id(a): 2453566284432
id(c): 2453567835904
[11, 22]
before a += a, id(a): 2453567835904
[11, 22, 11, 22]
after a += a,id(a): 2453567835904

La première est la variable entière b = 100, l'adresse de b est 2453566281168, avant 2453566281168l'exécution de a + = a, l'adresse de a est , après l'exécution, l'adresse de a devient2453566284432

Mais la liste n'a pas changé l'adresse.

9. Types mutables et immuables

Le type dit variable et le type immuable font référence à: les données peuvent être modifiées directement, si elles peuvent être modifiées directement, alors elles sont variables, sinon elles sont immuables

• Type de variable

1. Liste des colonnes
2. dictionnaire
3. ensemble

• Type immuable

1. Entier
2. Point flottant
3. Chaîne
4. Tuple