Chaînes de caractères

In [1]:
essai = "une chaîne de caractères\nsur deux lignes"
print(essai)

une chaîne de caractères
sur deux lignes

Pour ne pas interpréter les caractères spéciaux et retourner la chaîne brute, il faut utiliser le préfixe r

In [2]:
essai = r"une chaîne de caractères\nsur deux lignes"
print(essai)

une chaîne de caractères\nsur deux lignes

Les chaînes (presque) comme des listes non-modifiables

Quelques opérations standards

In [3]:
motlong = "anticonstitutionnellement"
print(len(motlong))
print(motlong[4])
print(motlong[3:18:2])
for c in motlong: print(c,end=' ')
print()
print(motlong + '!')
print( ((motlong+"-")*3)[:-1] )

25
c
iosiuine
a n t i c o n s t i t u t i o n n e l l e m e n t 
anticonstitutionnellement!
anticonstitutionnellement-anticonstitutionnellement-anticonstitutionnellement
In [4]:
#motlong[3] = "Z" # pas possible
print( motlong[:3]+'Z'+motlong[4:])
# ou bien on aurait pu faire (voir ci-après)
print(motlong.replace('i','Z',1))

antZconstitutionnellement
antZconstitutionnellement
In [5]:
s = "nomfichier.jpg"
print("nom:"+s[:-4],", extension:",s[-3:])

nom:nomfichier , extension: jpg
In [6]:
print("jpg" in s)

True

Conversions

In [7]:
s = "23453"
i = int(s)
print(i-120)
s = str(s)
print(type(s))
s = "1e-34"
f = float(s)
print(f**2)

23333
<class 'str'>
9.999999999999999e-69
In [8]:
L = [1.0,2.344,3]
print(str(L))  # affichage de la liste
print([ str(l) for l in L ])  # conversion des éléments en string

[1.0, 2.344, 3]
['1.0', '2.344', '3']

Quelques constantes utiles

In [9]:
from string import ascii_letters, digits
from random import randint
print(ascii_letters, digits)
mdp = [ ascii_letters[randint(0,len(ascii_letters))] for i in range(8) ]
print(mdp)

abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ 0123456789
['g', 'F', 'M', 'a', 'h', 'u', 'V', 'v']

Quelques méthodes utiles

In [10]:
print("-".join(['a','b','c']))  # prend un iterable comme argument
print("_".join("Bonjour"))  # une string est un iterable
print("".join(mdp)) # joint les mots de la liste

a-b-c
B_o_n_j_o_u_r
gFMahuVv
In [11]:
nom, prenom = "jean", "jacques"
print(nom.capitalize())

Jean
In [12]:
"nomfichier.jpg".endswith("jpg")
"nomfichier.jpeg".endswith("jpeg")
Out[12]:
True
In [13]:
ind = "nomfichier.jpg".find("jpg")
print(ind, "nomfichier.jpg"[ind:])

11 jpg
In [14]:
print("123423".isdigit())
print("1.232".isdigit())
print("Norbert".isalpha())
print("Norbert20".isalpha())
print("Quai12".isalnum())

True
False
True
False
True
In [15]:
Text = """
Maître Corbeau, sur un arbre perché,
Tenait en son bec un fromage.
Maître Renard, par l'odeur alléché,
Lui tint à peu près ce langage :"""
print(Text)
print(Text.replace("Maître","Monsieur"))

Maître Corbeau, sur un arbre perché,
Tenait en son bec un fromage.
Maître Renard, par l'odeur alléché,
Lui tint à peu près ce langage :

Monsieur Corbeau, sur un arbre perché,
Tenait en son bec un fromage.
Monsieur Renard, par l'odeur alléché,
Lui tint à peu près ce langage :
In [16]:
Text.count('un')
Out[16]:
2
In [17]:
print("Bien le bonjour".split())
print("1,2,3,4,5".split(','))

['Bien', 'le', 'bonjour']
['1', '2', '3', '4', '5']
In [18]:
for x in range(1,11):
    print(str(x).rjust(2), str(x**2).rjust(3),end=' ')
    print(str(x**3).rjust(4))

 1   1    1
 2   4    8
 3   9   27
 4  16   64
 5  25  125
 6  36  216
 7  49  343
 8  64  512
 9  81  729
10 100 1000
In [19]:
# unicode encoding
print('\u03B1', '\u03B2', '\u03B3', '\u3FF0')
print('\xe4\xf6\xfc')

α β γ 㿰
äöü

Travailler avec des fichiers

modes d'ouverture (par défaut en mode rt)

  • r : lecture seule (par défaut)
  • w : écriture
  • a : append = on peut écrire à la suite
  • x : crée un nouveau fichier et écrit dedans
  • b : mode binaire
  • t : mode texte
  • +: pour mise à jour, en lecture et écriture

certains modes se combinent : par exemple wb => écrit en binaire

In [20]:
fichier = open('LeCorbeauEtRenard.txt', 'w')
print(fichier)

<_io.TextIOWrapper name='LeCorbeauEtRenard.txt' mode='w' encoding='cp1252'>
In [21]:
Text = """Maître Corbeau, sur un arbre perché,
Tenait en son bec un fromage.
Maître Renard, par l'odeur alléché,
Lui tint à peu près ce langage :"""
fichier.write(Text)
fichier.write("\n\n\tJean de la Fontaine\n")
Out[21]:
23
In [22]:
fichier.close()
In [23]:
fichier = open('LeCorbeauEtRenard.txt', 'r')
In [24]:
print(fichier.read())  # lit le fichier en entier dans une seule chaîne de caractère

Maître Corbeau, sur un arbre perché,
Tenait en son bec un fromage.
Maître Renard, par l'odeur alléché,
Lui tint à peu près ce langage :

	Jean de la Fontaine
In [25]:
# relancer la commande open avant d'exécuter les lignes ci-dessous
fichier = open('LeCorbeauEtRenard.txt', 'r')
for lettre in fichier.read():
    print(lettre,end=' ')

M a î t r e   C o r b e a u ,   s u r   u n   a r b r e   p e r c h é , 
 T e n a i t   e n   s o n   b e c   u n   f r o m a g e . 
 M a î t r e   R e n a r d ,   p a r   l ' o d e u r   a l l é c h é , 
 L u i   t i n t   à   p e u   p r è s   c e   l a n g a g e   : 
 
 	 J e a n   d e   l a   F o n t a i n e
In [26]:
fichier = open('LeCorbeauEtRenard.txt', 'r')
for ligne in fichier.readlines(): # lit bout par bout
    print(ligne,end='')

Maître Corbeau, sur un arbre perché,
Tenait en son bec un fromage.
Maître Renard, par l'odeur alléché,
Lui tint à peu près ce langage :

	Jean de la Fontaine
In [27]:
fichier = open('LeCorbeauEtRenard.txt', 'r')
for ligne in fichier.readlines():
    print(ligne.split())

['Maître', 'Corbeau,', 'sur', 'un', 'arbre', 'perché,']
['Tenait', 'en', 'son', 'bec', 'un', 'fromage.']
['Maître', 'Renard,', 'par', "l'odeur", 'alléché,']
['Lui', 'tint', 'à', 'peu', 'près', 'ce', 'langage', ':']
[]
['Jean', 'de', 'la', 'Fontaine']
In [28]:
fichier.close()
In [29]:
import numpy as np
x = np.linspace(0.0,10.0,101)
y = np.exp(-x)
for i in range(len(x))[:10]:
    print(x[i],y[i])

0.0 1.0
0.1 0.904837418036
0.2 0.818730753078
0.3 0.740818220682
0.4 0.670320046036
0.5 0.606530659713
0.6 0.548811636094
0.7 0.496585303791
0.8 0.449328964117
0.9 0.406569659741
In [30]:
fichier = open('Exponentielle.txt', 'w')
for i in range(len(x)):
    fichier.write( str(x[i])+'\t'+str(y[i])+'\n')
fichier.close()
In [31]:
x, y = [],[]
fichier = open('Exponentielle.txt', 'r')
for line in fichier.readlines():
    L = line.split()
#    print L
    if len(L) == 2:
        x += [ float(L[0]) ]
        y += [ float(L[1]) ]
fichier.close()
for i in range(len(x))[:10]:
    print(x[i],y[i])

0.0 1.0
0.1 0.904837418036
0.2 0.818730753078
0.3 0.740818220682
0.4 0.670320046036
0.5 0.606530659713
0.6 0.548811636094
0.7 0.496585303791
0.8 0.449328964117
0.9 0.406569659741

Utilisation du module pickle

idéal pour écrire et surtout relire n'importe quel objet, en particulier des nombres.

In [32]:
import pickle
fichier=open("parametres.txt",'wb') # noter 'wb' => écriture en binaire
x = 324
pickle.dump(x,fichier)
pickle.dump(49281,fichier)
fichier.close()
In [33]:
fichier=open("parametres.txt",'rb') # noter 'rb' => lecture en binaire
x = pickle.load(fichier)
print(x, type(x))
y = pickle.load(fichier)
print(y, type(y))
fichier.close()

324 <class 'int'>
49281 <class 'int'>

Il est plus transparent d'utiliser des dictionnaires pour des paramètres

In [34]:
param = {}
param['N'] = 20
param['L'] = 12
param['x'] = 1.2342
fichier=open("parametres.txt",'wb')
pickle.dump(param,fichier)
fichier.close()
In [35]:
fichier =open("parametres.txt",'rb')
param = pickle.load(fichier)
fichier.close()
print(param)

{'N': 20, 'L': 12, 'x': 1.2342}

Sauvegarde des tableaux avec numpy

In [36]:
import numpy as np
x = np.linspace(0.0,10.0,1024)
print(x)
np.savetxt('expnumpy.txt',x)
xp = np.loadtxt('expnumpy.txt')
print(xp)

[  0.00000000e+00   9.77517107e-03   1.95503421e-02 ...,   9.98044966e+00
   9.99022483e+00   1.00000000e+01]
[  0.00000000e+00   9.77517107e-03   1.95503421e-02 ...,   9.98044966e+00
   9.99022483e+00   1.00000000e+01]
In [37]:
import numpy as np
x = np.linspace(0.0,10.0,1024)
np.savetxt('expnumpy.txt',x)
xp = np.loadtxt('expnumpy.txt')
print(xp)

[  0.00000000e+00   9.77517107e-03   1.95503421e-02 ...,   9.98044966e+00
   9.99022483e+00   1.00000000e+01]

Fichiers binaires : utilise l'extension npy

In [38]:
np.save('expbinary.npy',x)
xp = np.load('expbinary.npy')
print(xp)

[  0.00000000e+00   9.77517107e-03   1.95503421e-02 ...,   9.98044966e+00
   9.99022483e+00   1.00000000e+01]

Fichiers binaires compressés : utilise l'extension npz

In [39]:
x = np.linspace(0.0,10.0,1024)
y = np.exp(-x)
np.savez('expbinary.npz',datx=x,daty=y)
data = np.load('expbinary.npz') # récupère un dictionnaire
print(data.keys())
xp, yp = data['datx'], data['daty']
print(xp)
print(yp)

['datx', 'daty']
[  0.00000000e+00   9.77517107e-03   1.95503421e-02 ...,   9.98044966e+00
   9.99022483e+00   1.00000000e+01]
[  1.00000000e+00   9.90272451e-01   9.80639526e-01 ...,   4.62962470e-05
   4.58458980e-05   4.53999298e-05]