Python Xiaozhan _05: les variables Python et fonctions récursives

Aujourd'hui, l'étude: les variables de la fonction python et fonctions récursives

Tout d'abord, les variables globales et locales

Les variables globales: pas de retrait, tête de variables. En général, exprimé en lettres majuscules

Les variables locales: variables définies dans le sous-programme. En général, indiqué par les minuscules

Quand une variable globale et une variable locale avec le même nom:

Dans la définition au sein subprogram des variables locales, les variables locales jouent un rôle, les variables globales à la fonction ailleurs.

Nom de variable globale +: Référencé et lire des variables globales.

+ nonlocal nom de la variable: et lire les variables Referenced locales.

NAME = " pomme " 
def Taxt (): 
    nom = " banane " 
    print (nom)
     def num ():
         global NOM 
        NOM = " chat " 
    num () 
print (NOM) 
Taxt () 
print (NOM) 
>>> pomme 
     banane 
     chat

Il a ajouté:

1. Si aucune touche de fonction interne (Global), est lu de manière préférentielle les variables locales, alors lisez pas les variables globales, et ne peut être réaffecté à des variables globales, les variables globales à des types variables (à savoir le dictionnaire ancestral), la deletions peuvent modifier les éléments internes.

2. Si une touche de fonction interne (global), puis essentiellement appelées variables globales qui peuvent être lus peuvent être modifiés.

3. Lors de la lecture des variables, une priorité dans leur champ d'application à trouver, n'a pas diminué après les couches à trouver.

 

En second lieu, la théorie rhumatoïde: fonction variable à savoir

En fait, comme un caractère stocké dans la mémoire, puis dans la mémoire de stockage de cette fonction lorsque vous devez appeler la fonction d'accès, l'intérieur est niché au onze à lire une fonction équivalente à la fonction à l'intérieur du corps, ensuite un retour en arrière des couches de valeur.

def foo (a): 
    print ( "pomme") 
　　 coo () 
    
def coo (b)
     impression (2 ) 

foo ()

 

Troisièmement, les fonctions récursives

Appel de fonction de leur propre nom de fonction est appelée récursivité.

Caractéristiques: 1, doivent avoir une condition de fin claire (avec retour);

    2, chaque plus profondément dans la taille du problème récurrent, récursif devrait être réduite par rapport à la dernière;

    3, l'efficacité est peu élevé, trop de niveaux de récursion peut causer un débordement de pile (mémoire exploser).

def calc (n):
     print (n)
     si int (n / 2) == 0:
         retour n
     retour calc (int (n / 2 )) 
calc ( 10) 
>>> 10 
      5 
      2 
      1

Exemple: demander

import temps 
liste = [ " pomme " , " banane " , " chat " , " chien " )
 def comme (liste):
     print ( " - " * 60 )
     si len (liste) == 0:
         print ( " 没人知道" ) 
    li = list.pop (0)
     si li == " chat " :
         print ( "% S dit: Je sais que la façon dont, dans le lac du Rhin" % Li)
     Imprimer ( " Salut,% S, vous savez le chemin où " % li)
     Imprimer ( " % S, je ne sais pas, je peux vous aider à demander S% " % (li, Liste)) 
    temps. SLEEP ( . 5 ) 
    RES = comme (Liste)
     retour RES     
RES = comme (Liste)
 Imprimer (RES) 

>>>

----------------------------------------
salut, Apple, savez - vous où la route aller à droite
pomme répondit: Je ne sais pas, je peux vous aider à demander [ « Banana », « CAT », « Dog »]
----------------------- -----------------
salut, la banane, vous savez où aller droit chemin
banane a répondu: Je ne sais pas, je peux vous aider à demander [ « chat », « chien » ]
----------------------------------------
CAT dit, je sais où le Rhin bord du lac

Exercice et examen

1, l'ensemble des valeurs suivantes [11,22,33,44,55,66,77,88,99,90 ...], toutes les valeurs supérieures à 66 seront enregistrés sur la première clé dans le dictionnaire, sera inférieur à 66 la valeur à une valeur mémorisée dans la seconde clé. 
C'est: { « k1 »: toutes les valeurs supérieures à 66, « K2 »: toutes les valeurs inférieures à 66}

a = [11,22,33,44,55,66,77,88,99,90 ] 
b = { " key1 " : [], " key2 " : []}
 pour i dans un:
      si i> = 66 : 
         b [ " key1 " ] .append (i)
     Elif i <66 : 
        b [ " key2 " ] .append (i)
 impression (b)

2, trouver la liste d'éléments, chaque élément est retiré de l'ébauche, et de trouver un début ou de fin avec A, et tous les éléments de c.

li = [ " alec " , " ARIC " , " Alex " , " Tony " , " pluie " ] 
tu = ( " alec " , " ARIC " , " Alex " , " Tony " , " pluie " ) 
dic = { ' k1 ' : " alex " ,' K2 ': ' Un ric ' ,   " k3 " : " Alex " , " K4 " : " Tony " } 

pour un dans plage (len (li)): 
    li [a] = li [a] .replace ( "  " , "" )
 impression (li) 

tu = liste (tu)
 pour b dans plage (len (tu)): 
    tu [b] = tu [b] .replace ( "  " , "")
tu = tuple(tu)
imprimer (tu) 

à c dans dic: 
    dic [c] = dic [c] .replace ( "  " , "" )
 imprimé (CIVD) 

pour a1 dans li:
     si (a1.startswith ( " a " ) ou a1.startswith ( " a " )) et a1.endswith ( " c " ):
     print (a1) 

pour b1 en tu:
     si (b1.startswith ( " a " ) oub1.startswith ( " A " )) et b1.endswith ( " c " ):
     print (b1) 

pour C1 à dic: 
    c2 = dic [c1]
     si (c2.startswith ( " a " ) ou c2.startswith ( " A " )) et c2.endswith ( " c " ):
     print (c2)

3, marchandise 
a = [ "téléphone", "ordinateur", 'tapis de souris', 'yacht']

pour I, A1 dans l'énumération (A ,. 1 ):
     impression (I, A1) 
B = INPUT ( " S'il vous plaît entrer le code de produit " ) 
B1 = int (B)
 d' impression (A [B1])

Au-dessus.