Analyse d'une partie de la fonction en python

Le contenu de cet article concerne l'analyse de certaines fonctions en Python. Il a une certaine valeur de référence. Les amis dans le besoin peuvent s'y référer.

En python, une variable n'a pas de type, c'est une référence à un objet, et le type appartient à l'objet
Une variable est essentiellement un espace réservé ! Les variables sont généralement nommées avec des lettres minuscules.

1 : Syntaxe

def Nom de la fonction (liste de paramètres) :
Corps de la fonction
(Les noms de fonctions utilisent généralement une combinaison de lettres minuscules + de chiffres de soulignement simples, etc.)

2 : Types de fonctions couramment utilisées

(1) Fonctions avec paramètres : les paramètres doivent être transmis à la fonction dans le bon ordre

(2) Fonction paramètre par défaut : si aucun paramètre n'est passé, il utilisera les paramètres par défaut. Si les paramètres par défaut ne sont pas à la fin, une erreur sera signalée !

(3) Paramètres de mots clés : les appels de fonction utilisent des paramètres de mots clés pour déterminer les valeurs de paramètres transmises

(4) Paramètres de longueur indéfinie : La fonction peut gérer plus de paramètres que lors de sa déclaration initiale, toutes les variables de

①*args seront regroupées dans un tuple pour stocker toutes les variables sans nom
②Toutes les variables de **args seront regroupées dans un dictionnaire

( 5) Lors de la déclaration d'un fonction, l'astérisque * dans le paramètre peut apparaître seul, et les paramètres après * doivent être transmis avec des mots-clés

(6) Fonction anonyme, utilisez la fonction lambda pour créer une fonction anonyme

①lambda n'est qu'une expression, et le corps de la fonction est beaucoup plus simple que def
②Le corps principal de lambda est une expression, pas un bloc de code
③La fonction a son propre espace de noms et ne peut pas accéder en dehors de son propre paramètre list Ou paramètres dans l'espace de noms global.

Trois : passage des paramètres de la fonction Python :

Type immuable :

passage de valeurs de type C++, telles que int, string, tuple.
Comme fun(a), seule la valeur de a est transmise et n'affecte pas l'objet a lui-même.
Par exemple, modifier la valeur d'un inside fun(a) ne modifie qu'un autre objet copié et n'affectera pas a lui-même.

Type de variable :

Similaire au passage de référence C++, tel. comme des listes et des dictionnaires. Par exemple, fun (la) passe en fait la. Après modification, la outside fun sera également affectée

Tout en python est un objet au sens strict, on ne peut pas dire s'il est passé par valeur ou par. référence. Il faut dire que passer des objets immuables et passer des objets mutables

Quatre : Portée variable

Il existe généralement quatre types de portées en python :

L (Local) portée locale Domaine
E (Enclosant)
G (Global) en fonction en dehors de la fonction de fermeture (Global) Portée globale
B (Intégré) Portée intégrée

la règle de recherche est L -> ;E->G->B

En Python, seuls les modules, classes et fonctions (def, lambda) introduiront de nouvelles portées (comme if /elif/else/, try/sauf, for/while, etc.) n'introduira pas de nouvelles portées, ce qui signifie que les variables définies dans ces instructions sont également accessibles de l'extérieur.

5 : Variables globales et variables locales

Les variables définies à l'intérieur d'une fonction ont une portée locale, et les variables définies en dehors de la fonction ont une portée globale.

Lorsque la portée interne souhaite modifier les variables de la portée externe, les mots-clés globaux et non locaux sont utilisés.

(1) global est utilisé pour modifier la valeur des variables globales

(2) nonlocal est nécessaire pour modifier les variables dans la portée imbriquée (portée englobante, portée externe non globale) Mot-clé non local

Six : Conseils pour l'appel de fonction (important)

Nom de la fonction.__doc__ Récupérer le document d'aide de la fonction

Le nom de la fonction peut être utilisé comme document d'aide d'une autre fonction Formel paramètres

plusieurs valeurs de retour sont renvoyées sous forme de tuples

fonctions internes, les variables globales sont accessibles sans les modifier ! !

Fonction interne, si vous modifiez la variable globale du même nom, Python pensera que c'est une variable locale ! !

Sept : À propos de la dénomination

(1) Nom du fichier : tout en minuscules, vous pouvez utiliser des traits de soulignement

(2) Nom de la fonction : minuscule, principe du petit chameau

(3) Noms de variables : tous en minuscules, reliés par des traits de soulignement

Pour les règles de dénomination détaillées, veuillez vous référer à PEP8

8 : Plusieurs fonctions spéciales
map
réduire
filtre

# --------------------------------------------------------------------------#
# 函数的语法及调用
# --------------------------------------------------------------------------#


def func(func_name, number):        # 函数的定义
    """打印输入的任何字符串"""
    print(func_name, number)
    return 'Done'


func('func_1', 'faith')             # 函数的调用

# --------------------------------------------------------------------------#
# 不定长参数函数，封装成元组
# --------------------------------------------------------------------------#


def func_1(func_name, *number):
    """
    打印输入的任何字符串
    """
    print(type(number))
    print(func_name, number)
    return 'Done'


func_1('func_1', 1, 2, 2, 3)


def func_2(func_name, number):   #
    print(type(number))
    print(func_name, number)
    return 'Done'


func_2('func_2', (1, 2, 2, 3))


def func_3(func_name, *number):
    print(func_name)
    print(number[3])            # 根据元组index中一部分变量
    print(number[4])
    return 'Done'


func_3('func_3', 1, 2, 2, 3, 'aaa', 'abc')


# get out question: the number of index isn't known in most case!
# --------------------------------------------------------------------------#
# 不定长参数函数，封装成字典
# --------------------------------------------------------------------------#


def func_4(func_name, **number):  # 可变参数必须在函数参数的最后
    # print(type(number))
    print(func_name, number)
    return 'Done'


func_4('func_4', name='faith')

# --------------------------------------------------------------------------#
# 命名关键字函数
# --------------------------------------------------------------------------#


def func_5(a, x, c, *, china, uk):
    print('func_5:', china, uk)
    print(a, x, c)


func_5(1, 2, 3, china='bJ', uk='rs')    # 调用时必须加上关键字
# func_5(1, 2, 3, 'bJ', 'rs')

# --------------------------------------------------------------------------#
# 函数应用之-递归
# --------------------------------------------------------------------------#


def my_sum(i):
    if i < 0:
        raise ValueError    # 抛出错误
    elif i <= 1:
        return i
    else:
        return i + my_sum(i - 1)


print(my_sum(1.4))

# --------------------------------------------------------------------------#
# 传递不可变对象实例
# --------------------------------------------------------------------------#


def change_int(a):
    a = 10


b = 2
change_int(b)
print(b)         # 结果是2
# --------------------------------------------------------------------------#
# 传递可变对象实例
# --------------------------------------------------------------------------#


def change_me(mylist):
    mylist.append([1, 2, 3, 4])
    print("函数内取值: ", mylist)
    return


myList = [10, 20, 30]
change_me(myList)
print("函数外取值: ", myList)

# --------------------------------------------------------------------------#
# 函数内修改全局变量的值
# --------------------------------------------------------------------------#

money = 200  # 模块里面的全局变量


def add_money():
    global money
    money = money + 1
    return money


print("修改后的值money = ", add_money())


# --------------------------------------------------------------------------#
# 匿名函数
# --------------------------------------------------------------------------#
sum_1 = lambda arg1, arg2: arg1 + arg2

# 调用sum函数
print("相加后的值为 : ", sum_1(10, 20))
print("相加后的值为 : ", sum_1(20, 20))

# 单独编译一个文件时候输出结果
if __name__ == "__main__":
    pass

Ce qui précède est le contenu détaillé de. pour plus d'informations, suivez d'autres articles connexes sur le site Web de PHP en chinois!