Introduction à l algorithmique et à la programmation DUT Informatique 1ère année, 2016 2017 Anthony Labarre Anthony.Labarre@u-pem.fr Cours 4 / 10
Plan d aujourd hui Les fonctions Structure d un programme Python Le module doctest Les chaînes de caractères
Python pas à pas Les fonctions
Présentation générale Exemple (définition d une fonction) def estpremier(n): if n < 2: return False for i in range(2, n): if n % i == 0: return False return True Une fonction est un bloc d instructions réutilisable ;
Présentation générale Exemple (définition d une fonction) def estpremier(n): if n < 2: return False for i in range(2, n): if n % i == 0: return False return True Une fonction est un bloc d instructions réutilisable ; Une fois bien testée, on s en ressert autant qu on veut ;
Présentation générale Exemple (définition d une fonction) def estpremier(n): if n < 2: return False for i in range(2, n): if n % i == 0: return False return True Une fonction est un bloc d instructions réutilisable ; Une fois bien testée, on s en ressert autant qu on veut ; Maintenance à effectuer à un seul endroit ;
Présentation générale Exemple (définition d une fonction) def estpremier(n): if n < 2: return False for i in range(2, n): if n % i == 0: return False return True Une fonction est un bloc d instructions réutilisable ; Une fois bien testée, on s en ressert autant qu on veut ; Maintenance à effectuer à un seul endroit ; On peut les regrouper dans un module pour les réutiliser ;
Présentation générale Exemple (définition d une fonction) def estpremier(n): if n < 2: return False for i in range(2, n): if n % i == 0: return False return True Une fonction est un bloc d instructions réutilisable ; Une fois bien testée, on s en ressert autant qu on veut ; Maintenance à effectuer à un seul endroit ; On peut les regrouper dans un module pour les réutiliser ; Idée fondamentale en programmation : découper un programme en sous-tâches pour gagner en lisibilité et en robustesse.
Définir et appeler une fonction On définit une fonction de la façon suivante : Syntaxe pour définir une fonction def nomfonction(): # instruction 1 de la fonction # instruction 2 de la fonction #... # instruction n de la fonction Important : lors de la définition d une fonction, le code n est pas exécuté ; À tout moment dans le programme ou dans une fonction on peut appeler la fonction avec la commande nomfonction()
Premier exemple Exemple (utilisation d une fonction) def appel(): print( - * 5, appel, - * 5) if name == " main ": print( bonjour ) appel() n = int(input( nombre = )) for i in range(n): appel() Chaque fois qu on utilise l instruction appel(), le programme interrompt le flot normal d instructions pour aller effectuer les instructions d appel() ;
Premier exemple Exemple (utilisation d une fonction) def appel(): print( - * 5, appel, - * 5) if name == " main ": print( bonjour ) appel() n = int(input( nombre = )) for i in range(n): appel() Chaque fois qu on utilise l instruction appel(), le programme interrompt le flot normal d instructions pour aller effectuer les instructions d appel() ; Une fois les instructions d appel() effectuées, le programme reprend là où il en était ;
Fonction avec paramètre(s) Exemple def affiche(s): print( * * (len(s) + 4)) print( * + s + * ) print( * * (len(s) + 4)) if name == " main ": affiche( bonjour ) texte = input("entrez un message:") affiche(texte) Une fonction peut avoir un ou plusieurs paramètres ; Ils sont nommés entre parenthèses dans la définition de la fonction ; Lorsque l on appelle la fonction, il faut passer les paramètres (le bon nombre) entre parenthèses ;
L instruction return L instruction return x interrompt l exécution de la fonction et renvoie la valeur x ;
L instruction return L instruction return x interrompt l exécution de la fonction et renvoie la valeur x ; x peut être de n importe quel type ;
L instruction return L instruction return x interrompt l exécution de la fonction et renvoie la valeur x ; x peut être de n importe quel type ; On récupère la valeur renvoyée normalement, par exemple par une affectation : y = mafonction(z)
L instruction return L instruction return x interrompt l exécution de la fonction et renvoie la valeur x ; x peut être de n importe quel type ; On récupère la valeur renvoyée normalement, par exemple par une affectation : y = mafonction(z) On peut aussi l utiliser dans une expression où elle est évaluée : y = mafonction(z) + 3 print(mafonction(z))
L instruction return L instruction return x interrompt l exécution de la fonction et renvoie la valeur x ; x peut être de n importe quel type ; On récupère la valeur renvoyée normalement, par exemple par une affectation : y = mafonction(z) On peut aussi l utiliser dans une expression où elle est évaluée : y = mafonction(z) + 3 print(mafonction(z)) Par défaut, s il n y a pas de return ou si on met return simplement sans argument après, la fonction renvoie None ;
Exemple de return Exemple def minimum(liste): if len(liste) == 0: return min_actuel = liste[0] for element in liste: if element < min_actuel: min_actuel = element return min_actuel if name == " main ": L = [4, 6, 12, 3, 1, 56] M = [5, 6, 11, 3] print(minimum(l) + minimum(m)) Le premier return n a pas d argument, il renvoie None et arrête la fonction. Le programme reprend là où il en était. Le second return renvoie le résultat du calcul ;
Portée des variables Attention il y a des subtilités ici, à bien travailler. Exemple def f(n): n = n + 1 if name == " main ": x = 3 print(f(n)) print( x vaut, x)
Portée des variables Attention il y a des subtilités ici, à bien travailler. Exemple def f(n): n = n + 1 if name == " main ": x = 3 print(f(n)) print( x vaut, x) Le programme produit une erreur!
Portée des variables Attention il y a des subtilités ici, à bien travailler. Exemple def f(n): n = n + 1 if name == " main ": x = 3 print(f(n)) print( x vaut, x) Le programme produit une erreur! à l appel de la fonction, la valeur du paramètre de f est affectée au n de la définition de f ;
Portée des variables Attention il y a des subtilités ici, à bien travailler. Exemple def f(n): n = n + 1 if name == " main ": x = 3 print(f(n)) print( x vaut, x) Le programme produit une erreur! à l appel de la fonction, la valeur du paramètre de f est affectée au n de la définition de f ;... mais n n existe pas dans le corps du programme ; [Visualisation sur PythonTutor]
Portée des variables Attention il y a des subtilités ici, à bien travailler. Exemple def f(n): n = n + 1 if name == " main ": n = 3 f(n) print( n vaut, n)
Portée des variables Attention il y a des subtilités ici, à bien travailler. Exemple def f(n): n = n + 1 if name == " main ": n = 3 f(n) print( n vaut, n) Le résultat est n vaut 3!
Portée des variables Attention il y a des subtilités ici, à bien travailler. Exemple def f(n): n = n + 1 if name == " main ": n = 3 f(n) print( n vaut, n) Le résultat est n vaut 3! à l appel de f, la valeur du n principal est affectée au n de la définition de f, qu on note n f ;
Portée des variables Attention il y a des subtilités ici, à bien travailler. Exemple def f(n): n = n + 1 if name == " main ": n = 3 f(n) print( n vaut, n) Le résultat est n vaut 3! à l appel de f, la valeur du n principal est affectée au n de la définition de f, qu on note n f ; Ce n est pas le même n : nf prend la valeur de n à l appel de f et augmente de 1. n ne change pas. [Visualisation sur PythonTutor]
Portée des variables Attention il y a des subtilités ici, à bien travailler. Exemple def f(x): n = 1 if name == " main ": n = 3 f(n) print( n vaut, n)
Portée des variables Attention il y a des subtilités ici, à bien travailler. Exemple def f(x): n = 1 if name == " main ": n = 3 f(n) print( n vaut, n) Le résultat est toujours n vaut 3!
Portée des variables Attention il y a des subtilités ici, à bien travailler. Exemple def f(x): n = 1 if name == " main ": n = 3 f(n) print( n vaut, n) Le résultat est toujours n vaut 3! à l appel de la fonction, la valeur du paramètre de f est affectée au x de la définition de f ;
Portée des variables Attention il y a des subtilités ici, à bien travailler. Exemple def f(x): n = 1 if name == " main ": n = 3 f(n) print( n vaut, n) Le résultat est toujours n vaut 3! à l appel de la fonction, la valeur du paramètre de f est affectée au x de la définition de f ; l affectation n = 1 crée une variable locale à f, notée nf ;
Portée des variables Attention il y a des subtilités ici, à bien travailler. Exemple def f(x): n = 1 if name == " main ": n = 3 f(n) print( n vaut, n) Le résultat est toujours n vaut 3! à l appel de la fonction, la valeur du paramètre de f est affectée au x de la définition de f ; l affectation n = 1 crée une variable locale à f, notée nf ; nf prend la valeur de 1 et le n principal ne change pas. [Visualisation sur PythonTutor]
Portée des variables Les paramètres de la définition de la fonction sont des variables locales, propres à la fonction ;
Portée des variables Les paramètres de la définition de la fonction sont des variables locales, propres à la fonction ; Les variables affectées dans la fonction sont aussi des variables locales, propres à la fonction ;
Portée des variables Les paramètres de la définition de la fonction sont des variables locales, propres à la fonction ; Les variables affectées dans la fonction sont aussi des variables locales, propres à la fonction ; Ces variables locales existent pendant l exécution de la fonction et n existent plus après ;
Portée des variables Les paramètres de la définition de la fonction sont des variables locales, propres à la fonction ; Les variables affectées dans la fonction sont aussi des variables locales, propres à la fonction ; Ces variables locales existent pendant l exécution de la fonction et n existent plus après ; Les variables affectées dans le corps du programme (hors fonctions) sont des variables globales ;
Portée des variables Les paramètres de la définition de la fonction sont des variables locales, propres à la fonction ; Les variables affectées dans la fonction sont aussi des variables locales, propres à la fonction ; Ces variables locales existent pendant l exécution de la fonction et n existent plus après ; Les variables affectées dans le corps du programme (hors fonctions) sont des variables globales ; elles sont lisibles dans tout le programme ;
Portée des variables Les paramètres de la définition de la fonction sont des variables locales, propres à la fonction ; Les variables affectées dans la fonction sont aussi des variables locales, propres à la fonction ; Ces variables locales existent pendant l exécution de la fonction et n existent plus après ; Les variables affectées dans le corps du programme (hors fonctions) sont des variables globales ; elles sont lisibles dans tout le programme ; elles ne sont pas modifiables dans une fonction : si on affecte une variable globale dans une fonction, on crée une variable locale avec le même nom ;
Portée des variables Les paramètres de la définition de la fonction sont des variables locales, propres à la fonction ; Les variables affectées dans la fonction sont aussi des variables locales, propres à la fonction ; Ces variables locales existent pendant l exécution de la fonction et n existent plus après ; Les variables affectées dans le corps du programme (hors fonctions) sont des variables globales ; elles sont lisibles dans tout le programme ; elles ne sont pas modifiables dans une fonction : si on affecte une variable globale dans une fonction, on crée une variable locale avec le même nom ; Pour modifier une variable globale x dans une fonction, il faut la déclarer avec le mot clé global ;
Exemple de portée Exemple (utilisation de global) def f(n): global k i = n k = 0 print(i, j, k) if name == " main ": i = 2 j = 4 k = 6 f(44) print(i, j, k) Dans le corps de la fonction n et i sont des variables locales ; k est une variable globale modifiable ; j est visible en tant que variable globale (mais non modifiable) ; [Visualisation sur PythonTutor]
Python pas à pas Structure d un programme Python
Structure d un programme Python Les programmes que vous écrirez deviendront de plus en plus complexes, d où l importance de les structurer pour qu ils soient lisibles et compréhensibles ; On a vu un modèle sur lequel se baser : #!/usr/bin/env python3 # -*- coding: utf-8 -*- Description de ce a quoi sert le module, ses fonctionnalites. # Autres commentaires generaux (auteur, date d ecriture, adresse e-mail, etc.) # Imports: inclusion des modules dont vous avez besoin ------------------------ #import os # exemple, a decommenter en cas de besoin #import sys # exemple, a decommenter en cas de besoin # Fonctions et variables globales --------------------------------------------- def mafonction(param1, param2): Explication de ce que fait la fonction, des resultats renvoyes le cas echeant, et de ce a quoi correspondent ses parametres. pass # on ne fait rien (a remplacer par ce qu il vous faut) # Le corps du programme: c est la qu on ecrit le code a executer quand le # module est passe a l interpreteur Python if name == main : # Inserez ici les tests de vos fonctions et les autres actions a executer pass # on ne fait rien (a remplacer par ce qu il vous faut)
Structure d un programme Python : explications Les deux premières lignes précisent : 1. où doit se trouver l interpréteur Python ; 2. l encodage du fichier source ; La troisième ligne est une docstring, qui décrit le module ; on en écrit une par module et une par fonction ; c est ce que python affiche quand on tape help(module) ou help(fonction) ; #!/usr/bin/env python3 # -*- coding: utf-8 -*- Description de ce a quoi sert le module, ses fonctionnalites. # Autres commentaires generaux (auteur, date d ecriture, adresse e-mail, etc.) # Imports: inclusion des modules dont vous avez besoin ------------------------ #import os # exemple, a decommenter en cas de besoin #import sys # exemple, a decommenter en cas de besoin # Fonctions et variables globales --------------------------------------------- def mafonction(param1, param2): Explication de ce que fait la fonction, des resultats renvoyes le cas echeant, et de ce a quoi correspondent ses parametres. pass # on ne fait rien (a remplacer par ce qu il vous faut)
Python pas à pas Le module doctest
Comment tester son programme? La découpe en fonctions et modules rend les tests unitaires plus simples ;
Comment tester son programme? La découpe en fonctions et modules rend les tests unitaires plus simples ; On teste chaque fonction de chaque module séparément, en comparant ses résultats à ce qu on attend ;
Comment tester son programme? La découpe en fonctions et modules rend les tests unitaires plus simples ; On teste chaque fonction de chaque module séparément, en comparant ses résultats à ce qu on attend ; On peut écrire des tests :
Comment tester son programme? La découpe en fonctions et modules rend les tests unitaires plus simples ; On teste chaque fonction de chaque module séparément, en comparant ses résultats à ce qu on attend ; On peut écrire des tests : soit dans la partie principale du programme ;
Comment tester son programme? La découpe en fonctions et modules rend les tests unitaires plus simples ; On teste chaque fonction de chaque module séparément, en comparant ses résultats à ce qu on attend ; On peut écrire des tests : soit dans la partie principale du programme ; soit dans les docstrings des fonctions à tester ;
Comparaison de deux fonctions Les cas les plus simples à tester sont ceux où l on dispose déjà d une fonction correcte f() ;
Comparaison de deux fonctions Les cas les plus simples à tester sont ceux où l on dispose déjà d une fonction correcte f() ; Pour que notre nouvelle fonction g() soit correcte, il faut qu elle donne toujours le même résultat que f() quand on fournit les mêmes paramètres aux deux fonctions ;
Comparaison de deux fonctions Les cas les plus simples à tester sont ceux où l on dispose déjà d une fonction correcte f() ; Pour que notre nouvelle fonction g() soit correcte, il faut qu elle donne toujours le même résultat que f() quand on fournit les mêmes paramètres aux deux fonctions ; Exemple (comparaison de résultats) if puissance(a, b)!= a ** b: print( Erreur: la fonction puissance ne marche pas pour a =, a,, b =, b)
Le mot-clé assert Le mot-clé assert permet de détecter des problèmes ;
Le mot-clé assert Le mot-clé assert permet de détecter des problèmes ; Il évalue une expression booléenne, et provoque une exception si cette expression est fausse ;
Le mot-clé assert Le mot-clé assert permet de détecter des problèmes ; Il évalue une expression booléenne, et provoque une exception si cette expression est fausse ; S il y a une erreur, le programme plante et on récupère la ligne où l assertion a échoué ;
Le mot-clé assert Le mot-clé assert permet de détecter des problèmes ; Il évalue une expression booléenne, et provoque une exception si cette expression est fausse ; S il y a une erreur, le programme plante et on récupère la ligne où l assertion a échoué ; Exemple (utilisation de assert) assert puissance(a, b) == a ** b,\ "puissance echoue pour a =" \ + str(a) + ", b = " + str(b)
Le mot-clé assert Le mot-clé assert permet de détecter des problèmes ; Il évalue une expression booléenne, et provoque une exception si cette expression est fausse ; S il y a une erreur, le programme plante et on récupère la ligne où l assertion a échoué ; Exemple (utilisation de assert) assert puissance(a, b) == a ** b,\ "puissance echoue pour a =" \ + str(a) + ", b = " + str(b) Quelles valeurs tester?
Le mot-clé assert Le mot-clé assert permet de détecter des problèmes ; Il évalue une expression booléenne, et provoque une exception si cette expression est fausse ; S il y a une erreur, le programme plante et on récupère la ligne où l assertion a échoué ; Exemple (utilisation de assert) assert puissance(a, b) == a ** b,\ "puissance echoue pour a =" \ + str(a) + ", b = " + str(b) Quelles valeurs tester? les valeurs sensibles ;
Le mot-clé assert Le mot-clé assert permet de détecter des problèmes ; Il évalue une expression booléenne, et provoque une exception si cette expression est fausse ; S il y a une erreur, le programme plante et on récupère la ligne où l assertion a échoué ; Exemple (utilisation de assert) assert puissance(a, b) == a ** b,\ "puissance echoue pour a =" \ + str(a) + ", b = " + str(b) Quelles valeurs tester? les valeurs sensibles ; (un grand nombre de) valeurs aléatoires ;
Le module doctest Le module doctest permet d exécuter des tests spécifiés dans les docstrings des fonctions ;
Le module doctest Le module doctest permet d exécuter des tests spécifiés dans les docstrings des fonctions ; Ces tests ne sont effectués que si le module est chargé ;
Le module doctest Le module doctest permet d exécuter des tests spécifiés dans les docstrings des fonctions ; Ces tests ne sont effectués que si le module est chargé ; Cela permet de ne pas polluer le code source avec des assert, des print ou d autres instructions de debug ;
Le module doctest Le module doctest permet d exécuter des tests spécifiés dans les docstrings des fonctions ; Ces tests ne sont effectués que si le module est chargé ; Cela permet de ne pas polluer le code source avec des assert, des print ou d autres instructions de debug ; Exemple (doctests de math.factorial) def factorial(n): """Return the factorial of n, an exact integer >= 0. >>> [factorial(n) for n in range(6)] [1, 1, 2, 6, 24, 120] >>> factorial(30) 265252859812191058636308480000000 >>> factorial(-1) Traceback (most recent call last):... ValueError: n must be >= 0 Factorials of floats are OK, but the float must be an exact integer: >>> factorial(30.1) Traceback (most recent call last):... ValueError: n must be exact integer
Le module doctest Pour exécuter ces tests, on insère ceci dans la partie principale :
Le module doctest Pour exécuter ces tests, on insère ceci dans la partie principale : if name == " main ": import doctest doctest.testmod()
Le module doctest Pour exécuter ces tests, on insère ceci dans la partie principale : if name == " main ": import doctest doctest.testmod() Si python3 tests.py n affiche rien, tout va bien ;
Le module doctest Pour exécuter ces tests, on insère ceci dans la partie principale : if name == " main ": import doctest doctest.testmod() Si python3 tests.py n affiche rien, tout va bien ; Pour plus d infos sur les tests : python3 tests.py -v
Derniers mots sur les tests On ne peut malheureusement pas tout tester, mais on peut minimiser les risques de problèmes ;
Derniers mots sur les tests On ne peut malheureusement pas tout tester, mais on peut minimiser les risques de problèmes ; Encore une fois, structurer son programme et suivre les recommandations déjà vues permet de réduire le risque de rencontrer des problèmes ;
Derniers mots sur les tests On ne peut malheureusement pas tout tester, mais on peut minimiser les risques de problèmes ; Encore une fois, structurer son programme et suivre les recommandations déjà vues permet de réduire le risque de rencontrer des problèmes ; On peut démontrer qu un algorithme est correct, mais cela ne nous dispense pas de faire attention à son implémentation ;
Derniers mots sur les tests On ne peut malheureusement pas tout tester, mais on peut minimiser les risques de problèmes ; Encore une fois, structurer son programme et suivre les recommandations déjà vues permet de réduire le risque de rencontrer des problèmes ; On peut démontrer qu un algorithme est correct, mais cela ne nous dispense pas de faire attention à son implémentation ; Pour écrire du code plus propre et plus professionnel : voir pep8 et pylint.
Python pas à pas Les chaînes de caractères
Déclaration de chaînes de caractères On peut déclarer une chaîne entre apostrophes comme on a fait jusqu ici : x = toto...
Déclaration de chaînes de caractères On peut déclarer une chaîne entre apostrophes comme on a fait jusqu ici : x = toto... Ou entre guillemets : x = "toto"
Déclaration de chaînes de caractères On peut déclarer une chaîne entre apostrophes comme on a fait jusqu ici : x = toto... Ou entre guillemets : x = "toto" Les deux sont valides, on peut par exemple utiliser la première quand il y a des guillemets dans la chaîne et la seconde quand il y a des apostrophes.
Déclaration de chaînes de caractères On peut déclarer une chaîne entre apostrophes comme on a fait jusqu ici : x = toto... Ou entre guillemets : x = "toto" Les deux sont valides, on peut par exemple utiliser la première quand il y a des guillemets dans la chaîne et la seconde quand il y a des apostrophes. Comment faire s il y a à la fois des et des? on utilise les caractères spéciaux \ et \ : s = il a dit : "à l\ abordage!"
Déclaration de chaînes de caractères On peut déclarer une chaîne entre apostrophes comme on a fait jusqu ici : x = toto... Ou entre guillemets : x = "toto" Les deux sont valides, on peut par exemple utiliser la première quand il y a des guillemets dans la chaîne et la seconde quand il y a des apostrophes. Comment faire s il y a à la fois des et des? on utilise les caractères spéciaux \ et \ : s = il a dit : "à l\ abordage!" Attention : \ est un seul caractère, de même pour \ (ce sont des caractères spéciaux) : len( d\ abord ) 7
Déclaration sur plusieurs lignes On peut déclarer une chaîne sur plusieurs lignes en utilisant des triples apostrophes ou triples guillemets comme délimiteurs : s = Ceci est une chaîne sur plusieurs lignes.
Déclaration sur plusieurs lignes On peut déclarer une chaîne sur plusieurs lignes en utilisant des triples apostrophes ou triples guillemets comme délimiteurs : s = Ceci est une chaîne sur plusieurs lignes. Les sauts de lignes seront encodés par le caractère \n ;
Déclaration sur plusieurs lignes On peut déclarer une chaîne sur plusieurs lignes en utilisant des triples apostrophes ou triples guillemets comme délimiteurs : s = Ceci est une chaîne sur plusieurs lignes. Les sauts de lignes seront encodés par le caractère \n ; On peut également utiliser juste un backslash \ avant la fin de ligne et continuer sur la ligne suivante : s = Ceci est une \ chaîne sur \ plusieurs lignes.
Caractères spéciaux Voici quelques caractères spéciaux utiles : \ apostrophe \" guillemet \n saut de ligne \t tabulation \\ antislash \b reculer d un Par exemple la chaîne x = toto\ba est une chaîne de longueur 6, si on fait print(x) il s affiche... >>> print(x) tota
Les chaînes sont non-modifiables Important : une chaîne n est pas modifiable ;
Les chaînes sont non-modifiables Important : une chaîne n est pas modifiable ; Si x contient une valeur de type str et que vous voulez la changer, il faut faire une nouvelle affectation de x : x = toto x[0] = p erreur : on ne peut pas modifier une chaîne x = poto on crée une nouvelle chaîne poto
Les chaînes sont non-modifiables Important : une chaîne n est pas modifiable ; Si x contient une valeur de type str et que vous voulez la changer, il faut faire une nouvelle affectation de x : x = toto x[0] = p erreur : on ne peut pas modifier une chaîne x = poto on crée une nouvelle chaîne poto Rappel : c est le contraire avec les listes : lst = [1,4,6,7] lst[0] = 3 lst vaut [3,4,6,7]
Opérations sur les chaînes On a déjà vu la concaténation + de deux chaînes et la multiplication par un entier
Opérations sur les chaînes On a déjà vu la concaténation + de deux chaînes et la multiplication par un entier On a accès au i-ème caractère de la chaîne s avec s[i] (les indices commencent à 0)
Opérations sur les chaînes On a déjà vu la concaténation + de deux chaînes et la multiplication par un entier On a accès au i-ème caractère de la chaîne s avec s[i] (les indices commencent à 0) len(s) renvoie la longueur de s
Opérations sur les chaînes On a déjà vu la concaténation + de deux chaînes et la multiplication par un entier On a accès au i-ème caractère de la chaîne s avec s[i] (les indices commencent à 0) len(s) renvoie la longueur de s Bien d autres opérations sur les chaînes sont disponibles sous la forme de méthodes, avec la notation s.fonction() :
Opérations sur les chaînes On a déjà vu la concaténation + de deux chaînes et la multiplication par un entier On a accès au i-ème caractère de la chaîne s avec s[i] (les indices commencent à 0) len(s) renvoie la longueur de s Bien d autres opérations sur les chaînes sont disponibles sous la forme de méthodes, avec la notation s.fonction() : s.lower() renvoie une nouvelle chaîne où les majuscules ont été changées en minuscules
Opérations sur les chaînes On a déjà vu la concaténation + de deux chaînes et la multiplication par un entier On a accès au i-ème caractère de la chaîne s avec s[i] (les indices commencent à 0) len(s) renvoie la longueur de s Bien d autres opérations sur les chaînes sont disponibles sous la forme de méthodes, avec la notation s.fonction() : s.lower() renvoie une nouvelle chaîne où les majuscules ont été changées en minuscules s.upper() renvoie une nouvelle chaîne où les minuscules ont été changées en majuscules
Opérations sur les chaînes On a déjà vu la concaténation + de deux chaînes et la multiplication par un entier On a accès au i-ème caractère de la chaîne s avec s[i] (les indices commencent à 0) len(s) renvoie la longueur de s Bien d autres opérations sur les chaînes sont disponibles sous la forme de méthodes, avec la notation s.fonction() : s.lower() renvoie une nouvelle chaîne où les majuscules ont été changées en minuscules s.upper() renvoie une nouvelle chaîne où les minuscules ont été changées en majuscules s.split(t), où t est une chaîne, renvoie une liste de chaînes obtenues en coupant s aux occurrences de t
Opérations sur les chaînes On a déjà vu la concaténation + de deux chaînes et la multiplication par un entier On a accès au i-ème caractère de la chaîne s avec s[i] (les indices commencent à 0) len(s) renvoie la longueur de s Bien d autres opérations sur les chaînes sont disponibles sous la forme de méthodes, avec la notation s.fonction() : s.lower() renvoie une nouvelle chaîne où les majuscules ont été changées en minuscules s.upper() renvoie une nouvelle chaîne où les minuscules ont été changées en majuscules s.split(t), où t est une chaîne, renvoie une liste de chaînes obtenues en coupant s aux occurrences de t...