#Si vous souhaitez créer une longue chaîne de caractères à partir d'une petite chaîne de caractères, il existe une méthode pour la créer petit à petit comme suit.
>>> alphabet = ""
>>> alphabet +="abcdefg"
>>> alphabet +="hijklmnop"
>>> alphabet +="qrstuv"
>>> alphabet +="wxyz"
#Si vous utilisez des caractères continus, vous pouvez le créer en une seule étape sans le rendre difficile à voir.
>>> alphabet = "abcdefg" + \
... "hijklmnop" +\
... "qrstuv"+\
... "wxyz"
#La continuité de ligne est également requise lorsqu'une ligne s'étend sur plusieurs lignes.
>>> 1+2+
File "<stdin>", line 1
1+2+
^
SyntaxError: invalid syntax
>>> 1+2\
... 3
File "<stdin>", line 2
3
^
SyntaxError: invalid syntax
>>> 1+2+\
... 3
6
#Un programme qui vérifie le contenu de la catastrophe et affiche les commentaires appropriés
>>> disaster = True
>>> if disaster:
... print("Woe!")
... else:
... print("Whee!")
...
Woe!
>>> funny = True
>>> small = True
#Si si drôle vaut Vrai, entrez le test si petit.
>>> if funny:
... if small:
... print(" It is a cat.")
... else:
... print(" It is a bear!")
... else:
... if small:
... print(" It is a skink!")
... else:
... print(" It is a human.Or a hairless bear.")
...
It is a cat.
#Si le test est divisé en 3 types ou plus, si,elif(signifie autrement si),Utilisez autre chose.
>>> color ="puse"
>>> if color =="red":
... print(" It is a tomato")
... elif color =="green":
... print(" It is a green pepper")
... elif color =="bee purple":
... print("I don't know what it is,but only bees can see it")
... else:
... print("I've never heard of the color",color)
...
I've never heard of the color puse
>>> x =2
#Test d'équivalence
>>> x ==2
True
>>> x ==5
False
>>> 4 < x
False
>>> x<10
True
#L'opérateur booléen a une priorité inférieure à l'élément à comparer.
#L'opérateur booléen est exécuté une fois que l'élément à comparer a été calculé en premier.
>>> 1<x and x <10
True
>>> 1<x or x <10
True
>>> 1<x and x >10
False
>>> 1<x and not x >10
True
>>> 1<x<10
True
>>> 1<x<10<377
True
--Tout ce qui est listé ci-dessous est considéré comme faux.
| Ce qui est considéré comme faux | valeur |
|---|---|
| Valeur booléenne | False |
| null | None |
| Entier zéro | 0 |
| Zéro de flotteur | 0.0 |
| Chaîne vide | " " |
| Liste vide | [ ] |
| Taple vide | ( ) |
| Dictionnaire vide | { } |
| Ensemble vide | set() |
>>> some_list = []
>>> if some_list:
... print("There's something in here")
... else:
... print("Hey,it's empty!")
...
Hey,it's empty!
--Utilisez une boucle lorsque vous souhaitez faire la même chose plusieurs fois.
#Initialisation du comptage
#Comparez la valeur de count avec 5
#incrément de 1(Ajouter)
>>> count =1
>>> while count <=5:
... print(count)
... count+=1
...
1
2
3
4
5
--Utilisez break si vous voulez briser la boucle
#boucle infinie
#input()Utilisez une fonction pour lire la ligne d'entrée sur le clavier et l'assigner à des trucs
#Le caractère d'entrée est"q":Si tel est le cas, quittez la boucle.
#"q"Autre que ce qui précède, le premier caractère de la chaîne de caractères d'entrée est affiché en majuscule.
>>> while True:
... stuff=input("String to capitalize[type q to quit]:")
... if stuff == "q":
... break
... print(stuff.capitalize())
...
String to capitalize[type q to quit]:type
Type
String to capitalize[type q to quit]:untitarou
Untitarou
String to capitalize[type q to quit]:q
#input()Utilisez une fonction pour lire la ligne d'entrée sur le clavier et l'assigner à valeur
#Le caractère d'entrée est"q":Si tel est le cas, quittez la boucle.
#Définir la valeur sur le type int et l'attribuer au nombre
#S'il est pair, commencez l'itération suivante
>>> while True:
... value=input("Integer,please [q to quit]:")
... if value == "q":
... break
... number =int(value)
... if number %2==0:
... continue
... print(number,"squared is",number*number)
...
Integer,please [q to quit]:1
1 squared is 1
Integer,please [q to quit]:2
Integer,please [q to quit]:3
3 squared is 9
Integer,please [q to quit]:q
#Initialisation de la position variable
#Si même"Found even numbers"Et ce nombre est affiché et break quitte l'instruction while.
#La clause else est exécutée lorsque la partie while est terminée mais que l'objet souhaité n'est pas trouvé.(vérificateur de rupture)
>>> number =[1,3,5]
>>> position =0
>>> while position <len(number):
... numbers=number[position]
... if numbers%2 ==0:
... print("Found even numbers",numbers)
... break
... position+=1
... else:
... print("No even number found")
...
No even number found
Python utilise fréquemment des ** itérateurs (qui récupèrent et retournent des éléments un par un à partir de listes, de dictionnaires, etc. pour chaque itération) **. Parce que vous pouvez manipuler chaque élément de la structure de données sans connaître la structure de données.
#déclaration while
>>> rabbits =["a","b","c","d"]
>>> current=0
>>> while current<len(rabbits):
... print(rabbits[current])
... current +=1
...
a
b
c
d
#pour déclaration
>>> for rabbit in rabbits:
... print(rabbit)
...
a
b
c
d
** Objets itérables (correspondant aux itérateurs) ** en Python avec ** listes, chaînes, tapples, dictionnaires, ensembles, etc. **.
--Lorsque vous traitez un robinet ou une liste avec for, un élément est retiré à la fois. --Lorsque vous traitez une chaîne de caractères avec for, un caractère est généré à la fois, comme indiqué ci-dessous.
>>> word="cat"
>>> for letter in word:
... print(letter)
...
c
a
t
--La clé est renvoyée lorsque le dictionnaire est traité avec for.
>>> accusation ={"a":"ballroom","b":"weapon","c":"kowai"}
>>> for card in accusation:
... print(card)
...
a
b
c
--Si vous souhaitez parcourir les valeurs, utilisez la fonction values () du dictionnaire.
>>> for value in accusation.values():
... print(value)
...
ballroom
weapon
kowai
>>> for value in accusation.items():
... print(value)
...
('a', 'ballroom')
('b', 'weapon')
('c', 'kowai')
>>> for card,contents in accusation.items():
... print("Card",card,"has the contents",contents)
...
Card a has the contents ballroom
Card b has the contents weapon
Card c has the contents kowai
Si vous mettez une instruction break dans l'instruction for, vous pouvez arrêter la boucle de la même manière que while.
Si vous mettez continue dans l'instruction for, elle passera à l'itération suivante ainsi qu'à while.
Comme while, for a un autre optionnel pour vérifier s'il s'est terminé normalement. Si break n'est pas appelé, l'instruction else est exécutée.
>>> cheeses=[]
>>> for cheese in cheeses:
... print("This shop has some lovely",cheese)
... break
... else:
... print("This is not much of a cheese shop,is it?")
...
This is not much of a cheese shop,is it?
#Créer une liste
#Seuls les desserts sont plus longs que les autres listes. Personne ne reçoit de pudding à moins que les autres facteurs ne soient allongés.
>>> days =["Monday","Tuesday","Wednesday"]
>>> fruits=["coffee","tea","bear"]
>>> drinks=["coffee","tea","beer"]
>>> desserts=["tiamisu","ice cream","pie","pudding"]
#zip()Peut être utilisé pour créer un taple à partir d'éléments avec un décalage commun en traçant plusieurs séquences.
>>> for day,fruit,drink,dessert in zip(days,fruits,drinks,desserts):
... print(day,":drink",drink,"- eat",fruit,"-enjoy",dessert)
...
Monday :drink coffee - eat coffee -enjoy tiamisu
Tuesday :drink tea - eat tea -enjoy ice cream
Wednesday :drink beer - eat bear -enjoy pie
#zip()La valeur renvoyée n'est pas une taple ou une liste, mais une valeur itérable qui peut être exploitée ou répertoriée.
>>> english="Monday","Tuesday","Wednesday"
>>> french="Lundi","Mardi","Mercredi"
#liste
>>> list(zip(english,french))
[('Monday', 'Lundi'), ('Tuesday', 'Mardi'), ('Wednesday', 'Mercredi')]
#dictionnaire
>>> dict(zip(english,french))
{'Monday': 'Lundi', 'Tuesday': 'Mardi', 'Wednesday': 'Mercredi'}
#Créez une plage de 0 à 3
>>> for x in range(0,3):
... print(x)
...
0
1
2
#liste
>>> list(range(0,3))
[0, 1, 2]
#Créer une plage de 2 à 0
>>> for x in range(2,-1,-1):
... print(x)
...
2
1
0
#liste
>>> list(range(2,-1,-1))
[2, 1, 0]
#Retirez les nombres pairs de 0 à 10
>>> list(range(0,11,2))
[0, 2, 4, 6, 8, 10]
** La notation d'inclusion ** est un format qui vous permet de créer de manière compacte une structure de données Python à partir d'un ou plusieurs itérateurs.
Une liste d'entiers de 1 à 5 peut également être créée en ajoutant des éléments un par un comme indiqué ci-dessous.
#append()Est ajouté à la fin.
>>> number_list=[]
>>> number_list.append(1)
>>> number_list.append(2)
>>> number_list.append(3)
>>> number_list.append(4)
>>> number_list.append(5)
>>> number_list
[1, 2, 3, 4, 5]
#range()Il peut également être créé avec une fonction et pour.
>>> number_list=[]
>>> for number in range(1,6):
... number_list.append(number)
...
>>> number_list
[1, 2, 3, 4, 5]
#range()Vous pouvez également le créer en convertissant directement la sortie de.
>>> number_list = list(range(1,6))
>>> number_list
[1, 2, 3, 4, 5]
Le code utilisant la ** notation d'inclusion de liste ** est indiqué ci-dessous.
#[expression for item in iterable]Format de base de
#La première variable numérique est le nombre de résultats d'exécution de la boucle_Pour stocker dans la liste.
#Le deuxième numéro fait partie de l'instruction for
>>> number_list = [number for number in range(1,6)]
>>> number_list
[1, 2, 3, 4, 5]
#Vous pouvez voir que le premier nombre est une expression.
>>> number_list = [number-1 for number in range(1,6)]
>>> number_list
[0, 1, 2, 3, 4]
>>> a_list=[]
>>> for number in range (1,6):
... if number%2 ==1:
... a_list.append(number)
...
>>> a_list
[1, 3, 5]
#[expression for item in iterable if condition]Format
>>> a_list = [number for number in range(1,6) if number %2 ==1]
>>> a_list
[1, 3, 5]
>>> rows =range(1,4)
>>> cols=range(1,3)
>>> for row in rows:
... for col in cols:
... print(row,col)
...
1 1
1 2
2 1
2 2
3 1
3 2
#La notation d'inclusion peut également être imbriquée.
#Il est sorti sous forme de taple.
>>> rows =range(1,4)
>>> cols=range(1,3)
>>> cells = [(row,col) for row in rows for col in cols]
>>> for cell in cells:
... print(cell)
...
(1, 1)
(1, 2)
(2, 1)
(2, 2)
(3, 1)
(3, 2)
#ligne de taple lors de l'itération dans la liste des cellules,Retirez le col.
>>> for row,col in cells:
... print(row,col)
...
1 1
1 2
2 1
2 2
3 1
3 2
--Il existe également une notation d'inclusion dans le dictionnaire.
#"letters"Sortez les lettres une par une de"letters"Comptez combien sont inclus et écrivez la clé et le nombre de comptes_Stocker en nombre
>>> word ="letters"
>>> letter_counts={x:word.count(x)for x in word}
>>> letter_counts
{'l': 1, 'e': 2, 't': 2, 'r': 1, 's': 1}
#Essayons les mots comme un ensemble.
>>> word ="letters"
>>> letter_counts={x:word.count(x)for x in set(word)}
>>> letter_counts
{'e': 2, 'l': 1, 's': 1, 't': 2, 'r': 1}
--Format de base de {élément pour élément dans itérable}
>>> a_set={number for number in range(1,6) if number %3 ==1}
>>> a_set
{1, 4}
--Il n'y a pas de notation d'inclusion dans le tuple --Retourne un objet générateur lorsque vous créez une notation d'inclusion avec des parenthèses ordinaires ――Un générateur est l'une des méthodes pour fournir des données à un itérateur.
#Les éléments entre () sont des notations incluses dans le générateur
>>> number_thing = (number for number in range(1,6))
#Renvoie un objet générateur.
>>> type(number_thing)
<class'generator'>
#L'objet générateur peut être traité avec l'instruction for.
>>> for number in number_thing:
... print(number)
...
1
2
3
4
5
#Notation d'inclusion du générateur de liste()Si vous l'enveloppez dans un appel, il peut fonctionner comme une notation de notation incluse dans la liste.
>>> number_list=list(number_thing)
>>> number_list
[1, 2, 3, 4, 5]
#Le générateur ne peut fonctionner qu'une seule fois. Le générateur crée les valeurs une par une sur place et les transmet à l'itérateur, donc je ne me souviens pas des valeurs créées. Par conséquent, le générateur ne peut pas être utilisé ou sauvegardé à nouveau.
>>> number_list=list(number_thing)
>>>
>>> number_list
[]
Le programmeur peut faire deux choses avec la fonction.
--Définition de la fonction
Pour définir une fonction Python, tapez def, écrivez le nom de la fonction, mettez les arguments d'entrée de la fonction entre parenthèses et écrivez (:) à la fin.
#make_a_sound()Lorsque vous appelez une fonction, Python exécute le code dans la définition. Dans ce cas, il génère un mot et renvoie le contrôle au programme principal.
>>> def make_a_sound():
... print("quack")
...
>>> make_a_sound()
quack
#Une fonction qui n'a pas d'arguments mais qui renvoie une valeur
>>> def agree():
... return True
...
>>> agree()
True
#Testez la valeur de retour en utilisant if.
>>> if agree():
... print("Splendid!")
... else:
... print("That was unexpected.")
...
Splendid!
>>> def echo(anything):
... return anything+' '+anything
...
#echo()la fonction est"ss"Il est appelé avec l'argument réel.
#Cette valeur est un écho()Il est copié dans l'argument formel "anithing" et renvoyé à l'appelant.
>>> echo("ss")
'ss ss'
-Lors de l'appel d'une fonction avec ** argument **, ces valeurs sont copiées dans le ** paramètre ** correspondant de la fonction.
>>> def commtentary(color):
... if color == "red":
... return " It is a tomoato."
... elif color =="green":
... return " It is a green pepper"
... elif color =="bee purple":
... return "I don't know what it is,but only bees can see it."
... else:
... return "I've never heard of te color"+ color+"."
...
#"blue"Appelez la fonction de commentaire avec l'argument réel.
>>> comment=commtentary("blue")
>>> print(comment)
I've never heard of te colorblue.
--L'appelant reçoit None sauf si la fonction appelle explicitement return
>>> def do_nothing():
... pass
...
>>> print(do_nothing())
None
>>> def is_none(thing):
... if thing is None:
... print(" It is nothing")
... elif thing:
... print(" It is True")
... else:
... print(" It is False")
...
>>> is_none(None)
It is nothing
>>> is_none(True)
It is True
>>> is_none(False)
It is False
#Les nombres entiers et flottants nuls, les chaînes vides, les listes vides, les tapples vides, les dictionnaires vides, les ensembles vides sont faux, mais pas égaux à Aucun.
>>> is_none(0)
It is False
>>> is_none(0.0)
It is False
>>> is_none(())
It is False
>>> is_none([])
It is False
>>> is_none({})
It is False
>>> is_none(set())
It is False
>>> def menu(x,y,z):
... return{"wine":x,"entree":y,"dessert":z}
...
>>> menu("aaa","bbb","ccc")
{'wine': 'aaa', 'entree': 'bbb', 'dessert': 'ccc'}
--Spécifiez le nom de l'argument formel correspondant et spécifiez l'argument réel.
>>> def menu(x,y,z):
... return{"wine":x,"entree":y,"dessert":z}
...
>>> menu("beef","bagel","bordeaux")
{'wine': 'beef', 'entree': 'bagel', 'dessert': 'bordeaux'}
#Un argument formel est spécifié et un argument réel est spécifié.
>>> menu(y="beef",z="bagel",x="bordeaux")
{'wine': 'bordeaux', 'entree': 'beef', 'dessert': 'bagel'}
#Si vous souhaitez utiliser à la fois des arguments positionnels et des arguments de mot-clé, spécifiez d'abord l'argument positionnel.
>>> menu("frontenac",z="flan",y="fish")
{'wine': 'frontenac', 'entree': 'fish', 'dessert': 'flan'}
#Spécification de la valeur d'argument par défaut
>>> def menu(x,y,z="unchi"):
... return{"wine":x,"entree":y,"dessert":z}
...
#"dessert"Seul l'argument n'est pas spécifié, donc l'argument par défaut est entré.
>>> menu("dunkelfelder","chiken")
{'wine': 'dunkelfelder', 'entree': 'chiken', 'dessert': 'unchi'}
#Si vous spécifiez un argument, il sera utilisé à la place de la valeur par défaut.
>>> menu("dunkelfelder","duck","doughnut")
{'wine': 'dunkelfelder', 'entree': 'duck', 'dessert': 'doughnut'}
>>> def buggy(arg,result=[]):
... result.append(arg)
... print(result)
...
>>> buggy("a")
['a']
#['ab']je veux...
>>> buggy("ab")
['a', 'ab']
#buggy()Résultat à chaque appel d'une fonction[]Le but est de l'initialiser
>>> def buggy(arg):
... result=[]
... result.append(arg)
... return result
...
>>> buggy("a")
['a']
#A fonctionné correctement!!!!
>>> buggy("b")
['b']
#result=[]Le résultat est initialisé à l'aide de l'instruction if as.
>>> def nonbuggy(arg,result=None):
... if result is None:
... result = []
... result.append(arg)
... print(result)
...
>>> nonbuggy("a")
['a']
>>> nonbuggy("b")
['b']
>>> def print_args(*args):
... print("Positional argument tuple:",args)
...
>>> print_args()
Positional argument tuple: ()
#S'affiche comme args taple
>>> print_args(3,2,1,"wait!","uh...")
Positional argument tuple: (3, 2, 1, 'wait!', 'uh...')
#S'il y a un argument obligatoire, à la fin de l'argument positionnel*En écrivant des arguments, tous les arguments de position autres que les arguments requis peuvent être combinés en un seul.
>>> def print_more(x1,x2,*args):
... print("Need this one",x1)
... print("Need this one too",x2)
... print("All the rest",args)
...
>>> print_more("cap","gloves","scarf","monocle","mustache wax")
Need this one cap
Need this one too gloves
All the rest ('scarf', 'monocle', 'mustache wax')
>>> def print_kwargs(**kwargs):
... print("Keyward arguments:",kwargs)
...
>>> print_kwargs(x="xx",y="yy",z="zz")
Keyward arguments: {'x': 'xx', 'y': 'yy', 'z': 'zz'}
**4.7.6 docstring
--Fonction Vous pouvez ajouter un document à la définition de fonction en incorporant une chaîne de caractères au début du sujet principal. C'est ce qu'on appelle la fonction docstring.
>>> def echo(anything):
... 'echo renvoie l'argument d'entrée donné'
... return anything
...
#help()Lorsque la fonction est appelée, la docstring de la fonction s'affiche.
>>> help(echo)
Help on function echo in module __main__:
echo(anything)
echo renvoie l'argument d'entrée donné
(END)
>>> def answer():
... print(43)
...
>>> answer()
43
>>> def run_something(func):
... func()
...
#answer()Si vous passez la réponse à la place, vous utilisez la fonction comme type de données comme tout autre type de données.
>>> run_something(answer)
43
>>> def add_args(x1,x2):
... print(x1+x2)
...
>>> type(add_args)
<class'function'>
#exécuter avec func comme objet_something_with_Passé aux args.
>>> def run_something_with_args(func,arg1,arg2):
... func(arg1,arg2)
...
>>> run_something_with_args(add_args,5,9)
14
#Prenez n'importe quel nombre d'arguments positionnels et somme()La fonction calcule et renvoie leur somme.
>>> def sum_args(*args):
... return sum(args)
...
>>> def run_with_positional_args(func,*args):
... return func(*args)
...
>>> run_with_positional_args(sum_args,1,2,3,4)
10
>>> def outer(a,b):
... def inner(c,d):
... return c+d
... return inner(a,b)
...
>>> outer(4,7)
11
>>> def knights(s):
... def inner(q):
... return "%s" % q
... return inner(s)
...
>>> knights("Ni!")
'Ni!'
#inner2()Ne demande pas d'argument et utilise l'argument s directement pour la fonction externe.
#knights2()Renvoie le nom de la fonction au lieu d'appeler inner2.
#inner2 fonctionne comme une fermeture.
>>> def knights2(s):
... def inner2():
... return "%s" % s
... return inner2
...
>>> a= knights2("Duck")
>>> b= knights2("Hasenpfeffer")
>>> type(a)
<class'function'>
>>> type(b)
<class'function'>
#Ce sont des fonctions, mais ce sont aussi des fermetures.
>>> a
<function knights2.<locals>.inner2 at 0x1006d6ef0>
>>> b
<function knights2.<locals>.inner2 at 0x1006d60e0>
#Lorsqu'elles sont appelées, les deux fermetures se souviennent du contenu des s qu'elles fabriquaient dans knights2.
>>> a()
'Duck'
>>> b()
'Hasenpfeffer'
>>> def edit_story(words,func):
... for word in words:
... print(func(word))
...
>>> stairs = ["x","u","z","r"]
>>> def enliven(word):
... return word.capitalize()+"!"
...
#Chaque personnage est retiré de la liste et traité par enliven.
>>> edit_story(stairs,enliven)
X!
U!
Z!
R!
#enliven()La fonction est si courte que je la remplace par lambda.
#Ce lambda prend un argument, mot.
#":"La partie de jusqu'à la fin est une définition de fonction.
>>> edit_story(stairs,lambda word:word.capitalize()+"!")
X!
U!
Z!
R!
#La fonction de générateur renvoie la valeur dans une instruction yield au lieu de return.
>>> def my_range(first=0,last=10,step=1):
... number=first
... while number < last:
... yield number
... number +=step
...
#my_la plage est une fonction normale.
>>> my_range
<function my_range at 0x1009364d0>
>>> ranger=my_range(1,5)
#Renvoie un objet générateur.
>>> ranger
<generator object my_range at 0x100636ed0>
#Le traitement itératif par for peut être effectué sur l'objet générateur.
>>> for x in ranger:
... print(x)
...
1
2
3
4
>>> def document_it(func):
... def new_function(*args,**kwargs):
... print("Running function:",func.__name__)
... print("Positional arguments:",args)
... print("Keyword arguments:",kwargs)
... result =func(*args,**kwargs)
... print("Result:",result)
... return result
... return new_function
...
>>> def add_ints(a,b):
... return a+b
...
>>> add_ints(1,2)
3
>>> cooler_add_ints =document_it(add_ints)
>>> ccler_add_ints(1,2)
Traceback (most recent call last):
File "<stdin>", line 1, in <module>
NameError: name 'ccler_add_ints' is not defined
>>> cooler_add_ints(1,2)
Running function: add_ints
Positional arguments: (1, 2)
Keyword arguments: {}
Result: 3
3
#Juste avant la fonction que vous souhaitez décorer@decorator_Ajouter au format de nom.
>>> @document_it
... def add_ints(a,b):
... return a+b
...
>>> add_ints(1,2)
Running function: add_ints
Positional arguments: (1, 2)
Keyword arguments: {}
Result: 3
3
#Les valeurs des variables globales peuvent être référencées à partir de la fonction.
>>> animal="Z"
>>> def print_global():
... print("inside print_global:",animal)
...
>>> print("at the top level:",animal)
at the top level: Z
>>> print_global()
inside print_global: Z
#Une erreur se produit lorsque vous essayez d'obtenir la valeur d'une variable globale dans une fonction et de la réécrire.
>>> def changed_and_print_global():
... print("inside change_and_print_global:",animal)
... animal="wombat"
... print("after the change:",animal)
...
>>> changed_and_print_global()
Traceback (most recent call last):
File "<stdin>", line 1, in <module>
File "<stdin>", line 2, in changed_and_print_global
UnboundLocalError: local variable 'animal' referenced before assignment
#change_local()La fonction a également une variable appelée animal, qui existe dans l'espace de noms local de la fonction.
>>> animal="Z"
>>> def change_local():
... animal = "W"
... print("inside change_local:",animal,id(animal))
...
#change_local()On peut voir que la variable animale dans est différente de la variable animale dans le programme.
>>> change_local()
inside change_local: W 4564475440
>>> animal
'Z'
>>> id(animal)
4564751344
#Pour accéder à une variable globale, vous devez explicitement utiliser le mot clé global.
>>> animal="Z"
>>> def change_and_print_global():
... global animal
... animal = "wombat"
... print("inside change_and_print_global:",animal)
...
>>> animal
'Z'
>>> change_and_print_global()
inside change_and_print_global: wombat
>>> animal
'wombat'
#Si vous n'écrivez pas global dans la fonction, Python utilisera l'espace de noms local et les variables animales seront locales. Lorsque la fonction est terminée, les variables locales disparaissent et disparaissent.
>>> animal="Z"
>>> def change_local():
... animal = "wombat"
... print("locals:",locals())
...
>>> animal
'Z'
#Renvoie un dictionnaire affichant le contenu de l'espace de noms local.
>>> change_local()
locals: {'animal': 'wombat'}
#Renvoie un dictionnaire affichant le contenu de l'espace de noms global.
>>> print("globals:",globals())
globals: {'__name__': '__main__', '__doc__': None, '__package__': None, '__loader__': <class'_frozen_importlib.BuiltinImporter'>, '__spec__': None, '__annotations__': {}, '__builtins__': <module 'builtins' (built-in)>, 'document_it': <function document_it at 0x110146290>, 'add_ints': 3, 'square_it': <function square_it at 0x110146440>, 'animal': 'Z', 'print_global': <function print_global at 0x1101464d0>, 'changed_and_print_global': <function changed_and_print_global at 0x1101465f0>, 'change_local': <function change_local at 0x110146950>, 'change_and_print_global': <function change_and_print_global at 0x110146830>}
>>> animal
'Z'
>>> def amazing():
... '''C'est une excellente fonction
...Revoir'''
#Le nom de la fonction est la fonction de la variable système_name__(Format de base)
... print("Le nom de cette fonction:",amazing.__name__)
#docstring est une fonction de variable système_doc__(Format de base)
... print("docstring:",amazing.__doc__)
...
>>> amazing()
Le nom de cette fonction: amazing
docstring:C'est une excellente fonction
Revoir
#Arrêt forcé du programme
>>> short_list=[1,2,3]
>>> position = 5
>>> short_list[position]
Traceback (most recent call last):
File "<stdin>", line 1, in <module>
IndexError: list index out of range
#Vous devez utiliser try to enclose là où des exceptions sont susceptibles de se produire, et utiliser sauf pour gérer les exceptions.
#Le code du bloc try est exécuté et, si une erreur s'y produit, une exception est générée et le code du bloc except est exécuté. Si aucune exception ne se produit, le bloc except ne sera pas exécuté.
>>> short_list=[1,2,3]
>>> position = 5
>>> try:
... short_list[position]
... except:
... print("Need a position between 0 and",len(short_list)-1,"but got",position)
...
Need a position between 0 and 2 but got 5
#Utilisez sauf pour attraper toutes les exceptions.
#Si vous souhaitez connaître les informations détaillées, décrivez le format de base de sauf exceptiontype comme nom.
>>> short_list=[1,2,3]
>>> while True:
... value=input("Position[q to quit]?")
... if value =="q":
... break
... try:
... position=int(value)
... print(short_list[position])
... except IndexError as err:
... print("bad index:",position)
... except Exception as other:
... print("Something else broke:",other)
...
Position[q to quit]?1
2
Position[q to quit]?0
1
Position[q to quit]?2
3
Position[q to quit]?3
bad index: 3
Position[q to quit]?2
3
Position[q to quit]?two
Something else broke: invalid literal for int() with base 10: 'two'
Position[q to quit]?q
#C'est à la classe parente Exception de voir ce qu'il faut afficher lorsqu'une exception est générée.
>>> class OopsException(Exception):
... pass
...
>>> try:
... raise OopsException("panic")
... except OopsException as exc:
... print(exc)
...
panic
>>> if guess_me<7:
... print("too low")
... elif guess_me>7:
... print("too high")
... elif guess_me==7:
... print("just right")
...
just right
>>> while True:
... if start<guess_me:
... print("too low")
... elif start==guess_me:
... print("found it!")
... break
... elif start>guess_me:
... print("oops")
... break
... start+=1
...
too low
too low
too low
too low
too low
too low
found it!
>>> list=[3,2,1,0]
>>> for x in list:
... print(list[x])
...
0
1
2
3
>>> list=[number for number in range(10) if number%2==0]
>>> list
[0, 2, 4, 6, 8]
>>> squares={number:number*number for number in range(10)}
>>> squares
{0: 0, 1: 1, 2: 4, 3: 9, 4: 16, 5: 25, 6: 36, 7: 49, 8: 64, 9: 81}
>>> odd= {number for number in range(10) if number%2==1}
>>> odd
{1, 3, 5, 7, 9}
>>> for thing in ("Got %s" %number for number in range(10)):
... print(thing)
...
Got 0
Got 1
Got 2
Got 3
Got 4
Got 5
Got 6
Got 7
Got 8
Got 9
>>> def good():
... print(["H","R","Hermione"])
...
>>> good()
['H', 'R', 'Hermione']
#La fonction de générateur renvoie comme rendement.
>>> def get_odds():
... for x in range(1,10,2):
... yield x
...
#enumerate()En utilisant une fonction, le numéro d'index (nombre, ordre) peut être obtenu en même temps que les éléments d'un objet itérable tel qu'une liste (tableau) dans l'instruction for. Numéro d'index,Peut être obtenu dans l'ordre des éléments.
#Spécifiez le décalage à partir de 1.
>>> for count,number in enumerate(get_odds(),1):
... if count==3:
... print("The third number is",number)
... break
...
The third number is 5
>>> def test(func):
... def new_func(*args,**kwargs):
... print("start")
... result = func(*args,**kwargs)
... print("end")
... return result
... return new_func
...
>>> @test
... def greeting():
... print("Hello!")
...
>>> greeting()
start
Hello!
end
#Définition de OopseException
>>> class OopseException(Exception):
... pass
...
>>> raise OopseException()
Traceback (most recent call last):
File "<stdin>", line 1, in <module>
__main__.OopseException
>>> try:
... raise OopseException
... except OopseException:
... print("Caught an oops")
...
Caught an oops
>>> titles=["C","B","A"]
>>> plots=["D","W"]
>>> movies=dict(zip(titles,plots))
>>> movies
{'C': 'D', 'B': 'W'}
Il y avait beaucoup de volume de critiques dans le chapitre 4. Cela m'a pris un jour.
"Introduction à Python3 par Bill Lubanovic (publié par O'Reilly Japon)"
Recommended Posts