Grammaire de base Python (divers)

2.7 base.

Type intégré

#entier
a = 10
i = -10
x = 0x55
b = 0x100110

#Fraction flottante
f = 2.73

#Booléen
a = True
b = False

#Chaîne de caractères (immuable)
s = 'python'

#Liste (variable)
a = ['p','y','t','h','o','n']

#Taple (immuable)
a = ('p','y','t','h','o','n')

#Dictionnaire (variable)
a = {'happy' : '(^^)', 'sad' : '(TT)'}
print a['happy']

Immuabilité et variabilité

Vous ne pouvez pas modifier une partie de la chaîne ou tapoter plus tard. Une réaffectation est possible. Les données qui ne sont plus référencées sont soumises à CG.

>>> a = ('p','y','t','h','o','n')
>>> a[0]
'p'
>>> a[0] = 'b'
Traceback (most recent call last):
  File "<stdin>", line 1, in <module>
TypeError: 'tuple' object does not support item assignment

#C'est acceptable
>>> a = ('b','y','t','h','o','n')

Arrondi des fractions flottantes

>>> a = 1.23456
>>> round(a)
1.0
>>> round(a, 1)
1.2
>>> round(a, 4)
1.2346

Obtenir la taille de base d'un entier (dépendant de l'environnement)

>>> import sys
>>> print sys.maxint
9223372036854775807
>>> print bin(sys.maxint)
0b111111111111111111111111111111111111111111111111111111111111111
>>> print hex(sys.maxint)
0x7fffffffffffffff

Chaîne

Index, tranche

>>> a = 'python'
>>> a[0]
'p'
>>> a[-1]
'n'

#Vous pouvez spécifier la plage de chaînes de caractères et de listes. "Spécifier par tranche"
>>> a[1:3]
'yt'
>>> a[1:]
'ython'
>>> a[:3]
'pyt'

Remplacer, concaténer, répéter

>>> a = 'python'
>>> a += ' python'
>>> a
'python python'
>>> a.replace('p', 'b')
'bython bython'

#Non détruit
>>> a
'python python'

>>> b = a * 3
>>> b
'python pythonpython pythonpython python'
>>> a
'python python'

len, find, in

#Longueur de chaine
>>> a = 'python'
>>> len(a)
6

#Existence: utiliser dans ou trouver
>>> 'py' in a
True
>>> 'pi' in a
False

>>> a = 'hello python!'
>>> a.find('py', 0, 3) # 0-Y a-t-il un troisième py?
-1
>>> a.find('py', 2) #Renvoie l'index si py existe entre la seconde et la fin
6

liste

Contrairement aux tableaux dans d'autres langues, ils peuvent avoir différents types

>>> a = [1, 2, 'python', 1.234]
>>> a[0]
1
>>> a[-1]
1.234
>>> a[2]
'python'

Liste imbriquée

>>> a = [1, 2, [3, 4, 5, 6]]
>>> a[2][2]
5

Spécification de tranche de liste

>>> a = [1, 2, 3, 4]
>>> a[0:2]
[1, 2]

#Naturellement, il revient sous forme de liste même si le nombre d'éléments est de 1.
>>> a[3:]
[4]

#Permuter des éléments avec des tranches
>>> a[0:2] = [0,0]
>>> a
[0, 0, 3, 4]

#Inséré même si le nombre d'éléments est supérieur à la plage spécifiée par tranche
>>> a[0:2] = [0,0,0,0]
>>> a
[0, 0, 0, 0, 3, 4]

append, extend, del, pop, reverse Toutes les méthodes destructives

>>> a = [0, 1, 2, 3]
>>> a.append(5)
>>> a
[0, 1, 2, 3, 5]

#Utilisez étendre pour en ajouter plusieurs
>>> a.extend([6,7])
>>> a
[0, 1, 2, 3, 5, 6, 7]

#Supprimer en spécifiant un index
>>> del a[2]
>>> a
[0, 1, 3, 5, 6, 7]

#Pop le dernier élément
>>> a.pop()
7
>>> a
[0, 1, 3, 5, 6]

a.reverse()
>>> a
[6, 5, 3, 1, 0]

sort Trier par ASCII

>>> a = [2.4, 1, 'Python', 'A', 3]
>>> a.sort()
>>> a
[1, 2.4, 3, 'A', 'Python']

#Par ordre décroissant
>>> a.sort(reverse = True)
>>> a
['Python', 'A', 3, 2.4, 1]

Taple

Les parenthèses sont facultatives, mais doivent être écrites pour plus de lisibilité. L'accès imbriqué et découpé est similaire aux listes

a = ('p','y','t','h','o','n')
>>> a[0]
'p'
>>> a[-1]
'n'
>>> a[0:2]
('p', 'y')
>>> a[:3]
('p', 'y', 't')

#Les opérateurs de concaténation et de répétition sont similaires aux chaînes
>>> b = ('h', 'e', 'y')
>>> a + b
('p', 'y', 't', 'h', 'o', 'n', 'h', 'e', 'y')
>>> b * 3
('h', 'e', 'y', 'h', 'e', 'y', 'h', 'e', 'y')

Conversion de taple et de liste

>>> a = (1, 2, 3)
>>> b = list(a)
>>> b
[1, 2, 3]

>>> a = tuple(b)
>>> a
(1, 2, 3)

dictionnaire

Hash Desune.

>>> a = {'happy' : '(^^)', 'sad' : '(TT)'}
>>> a['happy']
'(^^)'

#Les clés sans valeur renvoient une erreur, pas NULL
>>> a['angry']
Traceback (most recent call last):
  File "<stdin>", line 1, in <module>
KeyError: 0

#Ajouter supprimer
>>> a['sleepy'] = '(=_=)'
>>> a
{'sad': '(TT)', 'sleepy': '(=_=)', 'happy': '(^^)'}

>>> del a['sad']
>>> a
{'sleepy': '(=_=)', 'happy': '(^^)'}

>>> a.pop('happy')
'(^^)'
>>> a
{'sleepy': '(=_=)'}

Format de chaîne

% Opérateur et méthode format ()

>>> a = 10.234
>>> '%d' % a
'10'
>>> '%.2f ' % a
10.23
>>> "%x" % a
'a'
>>> "%s" % a
'10.234'

#Lorsque vous insérez plusieurs données, passez-les sous forme de taple
>>> a = 7
>>> b = 'python'
>>> msg = '%d wonders of the %s' % (a, b)
>>> msg
'7 wonders of the python'

# '{}'Mettre la chaîne de spécification de format au format(variable)
>>> a = python
>>> '{:s}'.format(a) 
'python'

>>> '{}'.format(a)  #Aucun format spécifié
'python'

>>> a = 10.234
>>> '{:f}'.format(a)
'10.234000'
>>> '{:.2f}'.format(a)
'10.23'

#Erreur si le format est différent
>>> '{:d}'.format(a)
Traceback (most recent call last):
  File "<stdin>", line 1, in <module>
ValueError: Unknown format code 'd' for object of type 'float'

#Plusieurs variables sont des taples
>>> b = 4.444
>>> '{:.2f}, {:.3f}'.format(a,b)
'10.23, 4.444'

# {}La méthode de description de l'index comme nom de champ à l'intérieur est également utilisée. 0 depuis le début de l'argument,1,2,,Devient
>>> a = "Raspberry Pi"
>>> b = "Python"
>>> c = "in"
>>> '{1} {2} {0}'.format(a,b,c)
'Python in Raspberry Pi'

Objet nul

Aucun, pas NULL ou nul

>>> n
Traceback (most recent call last):
  File "<stdin>", line 1, in <module>
NameError: name 'nn' is not defined
>>> n = None
>>> n
#Rien ne s'affiche mais ce n'est plus une erreur