Tutoriel de base Python 2.7 : présentation-Tutoriel Python-php.cn

.. _tut-informel:

*********************************** ***** **************

Une introduction informelle à Python Introduction récapitulative de Python

********** ****** *************************************

Dans les exemples suivants, entrée et sortie se distinguent par la présence ou

absence d'invites (``>>>`` et ``...``) : pour répéter l'exemple, vous devez tapez

tout après l'invite, lorsque l'invite apparaît ; les lignes qui ne commencent pas

par une invite sont émises par l'interpréteur. Notez qu'une invite secondaire sur un

. la ligne seule dans un exemple signifie que vous devez taper une ligne vide ; ceci est utilisé pour

terminer une commande multiligne.

Dans l'exemple suivant, l'entrée et la sortie sont demandées par le supérieur au signe et au point respectivement ( ``> >>`` et

```...``` ) annotations. Si vous souhaitez reproduire ces exemples, saisissez les lignes de code qui ne contiennent pas l'invite après l'invite de l'interpréteur (après l'invite

caractères). Il est à noter que l'invite esclave rencontrée dans l'exercice signifie

Vous devez saisir une ligne vierge supplémentaire à la fin pour que l'interprète puisse savoir qu'il s'agit de la fin d'une commande multiligne.

De nombreux exemples de ce manuel, même ceux saisis à l'invite interactive

, incluent des commentaires. Les commentaires en Python commencent par le caractère dièse,

``#`. `, et s'étendre jusqu'à la fin de la ligne physique. Un commentaire peut apparaître au

début d'une ligne ou après un espace ou un code, mais pas dans une chaîne

un caractère de hachage. dans une chaîne littérale, il n'y a qu'un caractère de hachage.

Étant donné que les commentaires visent à clarifier le code et ne sont pas interprétés par Python, ils peuvent

être omis lors de la saisie d'exemples.

De nombreux exemples de ce manuel, y compris ceux comportant des invites interactives, contiennent des commentaires.

les commentaires en Python commencent par le caractère # et vont jusqu'à la fin de la ligne (Traduction - l'auteur original a utilisé

``ligne physique`` pour indiquer les sauts de ligne réels plutôt que d'éditer le retour à la ligne automatique du navigateur). Les commentaires peuvent commencer au début de la ligne

, ou après un espace ou un code, mais n'apparaissent pas dans la chaîne. Les caractères #

dans une chaîne de texte représentent simplement # . Les commentaires dans le code ne seront pas interprétés par Python. Vous pouvez

les ignorer lors de la saisie d'exemples.

Quelques exemples ::

# ceci est le premier commentaire

SPAM = 1 un tiers !

STRING = "# Ceci n'est pas un commentaire. "

.. _tut-calculator :

Utiliser Python comme calculatrice Utiliser Python comme calculatrice

=============== ================================= =

Essayons quelques commandes Python simples. et attendez l'invite principale, ``>>>`` (Cela ne devrait pas prendre longtemps.)

Essayons quelques commandes Python simples. Démarrez l'interpréteur et attendez que l'invite principale ``>>>``

apparaisse (cela ne prend pas longtemps).

.. _tut-numbers :

Nombres Valeurs numériques

------------

L'interprète agit comme un calculatrice simple : vous pouvez y taper une expression

et elle écrira la valeur. La syntaxe de l'expression est simple : les

opérateurs `` ``, ``-``, ``*. ` ` et ``/`` fonctionnent comme dans la plupart des autres langages

(par exemple, Pascal ou C) ; les parenthèses peuvent être utilisées pour le regroupement. Par exemple ::

représentation de l'interprète C'est. comme une simple calculatrice : vous pouvez y saisir quelques expressions et elle renverra une valeur

. La syntaxe de l'expression est simple : les opérateurs `` `` , ``-`` , ``*`` et ``/`` sont les mêmes que dans les autres langages (par exemple : Pascal ou C) ; utilisé pour le regroupement. Par exemple : :

>>> 2 2

>>> Ceci est un commentaire

.. .2 2

>>> 2 2 # et un commentaire sur la même ligne que le code

>> ; > (50-5*6)/4

>>> # La division entière renvoie la parole :

... 7/3

>>> 7/-3

-3

Le signe égal (``'='``) est utilisé pour attribuer une valeur à une variable. Ensuite, aucun

résultat n'est affiché avant la prochaine invite interactive ::

Le signe égal ( ``'='`` ) est utilisé pour attribuer une valeur à une variable. une valeur à une variable :

>>> largeur = 20

>>> hauteur = 5*9

>>> ; width * height

900

Une valeur peut être attribuée à plusieurs variables simultanément ::

>>> ; x = y = z = 0 # Zéro x, y et z

>>>

Les variables doivent être "définies" (attribuées à une valeur) avant de pouvoir être utilisées, sinon une

erreur se produira ::

Variables Il doit être "défini" (attribué) avant utilisation, sinon une erreur se produira ::

>>> # essayez d'accéder à une variable non définie

... n

Traceback (dernier appel le plus récent) :

Fichier "", ligne 1, dans

NameError : le nom 'n' n'est pas défini

Il existe une prise en charge complète de la virgule flottante ; les opérateurs avec des opérandes de type mixte

convertissent l'opérande entier en virgule flottante ::

Pointe flottante les nombres ont une prise en charge complète ; les opérateurs avec des opérandes de type mixte seront automatiquement convertis en nombre à virgule flottante ::

>>> ;>> 7.0/2

3.5

Les nombres complexes sont également pris en charge ; les nombres imaginaires sont écrits avec un suffixe

de ``j`` ou ``J ``. Les nombres complexes avec une composante réelle non nulle sont écrits comme

``(real imagj)``, ou peuvent être créés avec la fonction ``complex(real, imag)``.

Le pluriel est également pris en charge ; les nombres avec le suffixe ``j`` ou ``J`` sont traités comme imaginaires. Un nombre complexe

avec une partie réelle non nulle s'écrit ``(real imagj)``, ou peut être créé à l'aide de la fonction ``complex(real, imag)`` ::

> ;>> 1j * 1J

(-1 0j)

>>> -1 0j)

>>> 3 1j*3

(3 3j)

>>> >

(9 3j)

>>> (1 2j)/(1 1j)

(1,5 0,5j)

Les nombres complexes sont toujours représenté sous la forme de deux nombres à virgule flottante, la partie réelle

et la partie imaginaire Pour extraire ces parties d'un nombre complexe *z*, utilisez

``z.real`` et ``z. imag`` ::

Les parties réelles et imaginaires d'un nombre complexe sont toujours écrites sous forme de deux nombres à virgule flottante. Pour extraire les parties réelle et imaginaire d'un nombre complexe *z*, utilisez ``z.real`` et ``z.imag``. ::

>>> a=1,5 0,5j

>>> ;> a.imag

0.5

Les fonctions de conversion en virgule flottante et entier (:func:`float`,

:func:`int` et :func :`long`) ne fonctionne pas pour les nombres complexes --- il n'existe pas de

moyen correct pour convertir un nombre complexe en nombre réel. Utilisez ``abs(z)`` pour obtenir

sa grandeur (sous forme de flottant) ou ``z.real`` pour obtenir sa partie réelle ::

Fonction de conversion entre nombres à virgule flottante et entiers ( :func:`float` et : func:`int` et

:func:`long` ) ne peuvent pas être utilisés pour les nombres complexes. Il n’existe pas de façon correcte de convertir un nombre complexe en un nombre

réel. La fonction ``abs(z)`` est utilisée pour obtenir son module (nombre à virgule flottante) ou ``z.real`` pour obtenir sa partie réelle ::

>>> 3.0 4.0j

>>> float(a)

Traceback (dernier appel le plus récent) :

Fichier "", ligne 1, dans ?

TypeError : impossible de convertir le complexe en float ; utilisez abs(z)

>>> a.real

3.0

>> > a.imag

4.0

>>> 🎜>

5.0

En mode interactif, la dernière expression imprimée est affectée à la variable

``_`` Cela signifie que lorsque vous utilisez Python comme calculatrice de bureau, il est

Un peu plus simple de continuer les calculs, par exemple ::

En mode interactif, la valeur de la dernière expression est affectée à la variable ``_``. De cette façon, nous pouvons l'utiliser comme calculatrice de bureau, ce qui est très pratique pour les calculs continus, tels que ::

>>> taxe = 12,5 / 100

> >> prix = 100,50

>>> prix * taxes

12,5625

>>>

>>> round(_, 2)

113.06

Cette variable doit être traitée en lecture seule par l'utilisateur. Ne le faites pas explicitement

attribuez-lui une valeur --- vous créeriez une variable locale indépendante avec le

même nom masquant la variable intégrée avec son comportement magique.

Cette variable est lue -uniquement pour l'utilisateur. N'essayez pas de lui attribuer une valeur - vous créerez simplement une variable locale distincte portant le même nom, qui bloque l'effet magique des variables intégrées du système.

.. _tut-strings :

Strings Strings

--------------

Outre les nombres, Python peut également manipuler des chaînes, qui peuvent être exprimées en

de plusieurs manières. Ils peuvent être placés entre guillemets simples ou doubles ::

Par rapport aux nombres, Python fournit également des chaînes qui peuvent être transmises de plusieurs manières différentes. Ils peuvent être identifiés par

guillemets simples ou doubles : :

>>> 'œufs de spam'

'œufs de spam'

> ;>> 'ne/'t'

"ne fait pas"

>>> "ne fait pas"

"ne fait pas"

>>> '"Oui", a-t-il dit.'

'"Oui", a-t-il dit.'

>>> ,/" a-t-il dit."

'"Oui", a-t-il dit.'

>>> 🎜> '"N'est-ce pas", a-t-elle dit.'

Les chaînes littérales peuvent s'étendre sur plusieurs lignes de plusieurs manières. Les lignes de continuation peuvent

être utilisées, avec une barre oblique inverse comme dernier caractère. la ligne indiquant que la

ligne suivante est une suite logique de la ligne ::

Il existe plusieurs façons pour les chaînes littérales de se diviser en lignes. Vous pouvez utiliser une barre oblique inverse comme chaîne continue en fin de ligne, ce qui indique que la ligne

suivante est logiquement la suite de cette ligne.

hello = "Ceci est une chaîne assez longue contenant/n/

plusieurs lignes de texte comme vous le feriez en C./n/

Notez que les espaces à le début de la ligne est/

significatif."

print hello

Notez que les nouvelles lignes doivent toujours être intégrées dans la chaîne en utilisant ``/n`` -- la

nouvelle ligne suivant la barre oblique inverse finale est supprimée. Cet exemple afficherait

ce qui suit :

Il convient de noter que vous devez toujours écrire ``/ dans la chaîne. n`` - Une barre oblique inverse finale est ignorée. La

réunion régulière précédente s'imprime comme suit :

.. code-block :: text

Il s'agit d'une chaîne assez longue contenant

plusieurs lignes de texte comme vous le feriez en C.

Notez que les espaces au début de la ligne sont significatifs.

Ou, les chaînes peuvent être entourées d'une paire de guillemets triples correspondants : ` `" ""`` ou

``'''``. Les fins de lignes n'ont pas besoin d'être échappées lors de l'utilisation de guillemets triples, mais

elles seront incluses dans la chaîne . : :

De plus, les chaînes peuvent être identifiées entre une paire de guillemets triples : ``"""`` ou ``'''``. Entre guillemets triples,

ne nécessite pas d'échappement d'attribut de ligne, ils sont déjà inclus dans la chaîne ::

print """

Utilisation : thingy [OPTIONS]

Afficher cette utilisation message :

obtenir le résultat suivant ::

.. bloc de code : texte

Utilisation : truc [OPTIONS]

-h -H Afficher ce message d'utilisation

-H nom d'hôte Nom d'hôte auquel se connecter

Si nous faisons de la chaîne littérale une chaîne "brute", les séquences ``/n`` sont non converti

en nouvelles lignes, mais la barre oblique inverse à la fin de la ligne et le caractère de nouvelle ligne

dans la source sont tous deux inclus dans la chaîne en tant que données. Ainsi, l'exemple :

Si nous générons une chaîne "brute", ``/ La séquence n`` ne sera pas échappée, et la barre oblique inverse

à la fin de la ligne et le caractère de nouvelle ligne dans le le code source fait partie des données de la chaîne, donc l'exemple suivant ::

hello = r"Ceci est une chaîne assez longue contenant/n/

plusieurs lignes de texte autant que vous ferait en C."

imprimer bonjour

imprimerait :

.. bloc de code : texte

Il s'agit d'une chaîne assez longue contenant/n/

plusieurs lignes de texte, un peu comme vous le feriez en C.

L'interpréteur imprime le résultat des opérations sur les chaînes de la même manière qu'ils

sont saisis pour la saisie : entre guillemets, et avec des guillemets et autres caractères amusants

échappés par des barres obliques inverses, pour afficher la valeur précise. La chaîne est entourée de

guillemets doubles. si la chaîne contient un guillemet simple et aucun guillemet double, sinon

elle est entourée de guillemets simples (l'instruction :keyword:`print`, décrite

plus tard, peut être utilisé pour écrire des chaînes sans guillemets ni échappements.) L'interpréteur

imprime les résultats des opérations sur les chaînes exactement tels qu'ils ont été saisis : entre parenthèses, y compris les barres obliques inverses

Barres d'échappement caractères intéressants pour afficher la valeur exacte. Si une chaîne contient des guillemets simples et ne contient pas de guillemets doubles

, elle est identifiée par des guillemets doubles. Sinon, il est identifié par des guillemets simples. (L'instruction

:keyword:`print` introduite plus tard peut générer des chaînes sans identification ni échappement.)

Les chaînes peuvent être concaténées (collées ensemble) avec l'opérateur `` ``, et

répété avec ``*``::

Les chaînes peuvent être connectées (collées ensemble) par l'opérateur `` ``, et peuvent être répétées par ``*``: :

>>> mot = 'Aide' 'A'

>>> mot

'Aide'

> ;> > '<' word*5 '>'

Deux chaînes littérales l'une à côté de l'autre sont automatiquement concaténées ; la ligne ci-dessus aurait également pu être écrite ``word = 'Help' 'A'`` ; cela ne fonctionne qu'

avec deux littéraux, pas avec des expressions de chaîne arbitraires ::

phase Deux chaînes adjacentes les textes sont automatiquement connectés entre eux. La ligne de code précédente peut également être écrite sous la forme

``word ='Help' 'A'`` Elle n'est utilisée que pour deux textes de chaîne et ne peut pas être utilisée pour les expressions de chaîne.

>>> 'str' 'ing' # <- C'est ok

'string'

'str' strip() 'ing'. # <- C'est ok

'string'

>>> 'str'.strip() 'ing' # <- Ceci n'est pas valide

Fichier "", ligne 1, dans ?

'str'.strip() 'ing'

SyntaxError : syntaxe invalide

Les chaînes peuvent être indicées (indexé) ; comme en C, le premier caractère d'une chaîne

a un indice (index) 0. Il n'y a pas de type de caractère distinct ; un caractère est

simplement une chaîne de taille un. Comme dans Icon, les sous-chaînes peuvent être spécifiées avec la

*slice notation* : deux indices séparés par deux points ::

caractères. Les chaînes peuvent également être interceptées (récupérées). Semblable à C , le premier caractère d'une chaîne est indexé 0 . Il n'existe pas de type de caractère indépendant pour

, un caractère est une chaîne de longueur 1. Semblable à Icon, vous pouvez utiliser la méthode

*slicing annotation* pour intercepter des chaînes : copies divisées par deux indices. ::

>>> mot[4]

'A'

>>> > 'He'

>>> word[2:4]

'lp'

Les indices de tranche ont des valeurs par défaut utiles, un premier index omis est par défaut égal à zéro ; , un deuxième index omis a par défaut la taille de la chaîne à découper ::

Les tranches d'index peuvent avoir des valeurs par défaut lors du découpage, si le premier index est ignoré, la valeur par défaut est 0. . Le deuxième index

est ignoré et prend par défaut la longueur de la chaîne. (En fait, il existe un troisième paramètre, qui représente la taille du pas de découpage. Sa valeur par défaut est

1, et l'opération de découpage complète est word[2:4:1] - Traducteur) ::

>>> word[:2] # Les deux premiers caractères

'Il'

>>> deux caractères

'lpA'

Contrairement à une chaîne C, les chaînes Python ne peuvent pas être modifiées. L'attribution à une position indexée

dans la chaîne entraîne une erreur ::

Contrairement aux chaînes C, les chaînes Python sont immuables. L'attribution d'une valeur à un index d'une chaîne littérale entraînera

l'émission d'une erreur ::

>>> word[0] = 'x'

Traceback (dernier appel le plus récent) :

Fichier "", ligne 1, dans ?

TypeError : l'objet ne prend pas en charge l'affectation d'éléments

>> ;> word[:1] = 'Splat'

Traceback (dernier appel le plus récent) :

Fichier "", ligne 1, dans ?

TypeError : l'objet ne prend pas en charge l'affectation des tranches

Cependant, créer une nouvelle chaîne avec le contenu combiné est simple et efficace ::

Cependant, combiner le contenu du texte pour générer un nouveau texte est facile et efficace ::

>>> mot 'x'[1:]

'xelpA'

>>> ]

'SplatA'

Voici un invariant utile des opérations de tranche : ``s[:i] s[i:]`` est égal à ``s``.

L'opération de découpage a un invariant utile : ``s[:i] s[i:]`` est égal à ``s``. ::

>>> mot[:2] mot[2:]

'AideA'

>>> word[3:]

'HelpA'

Les indices de tranche dégénérés sont gérés avec élégance : un index trop grand est

remplacé par la taille de la chaîne, une limite supérieure plus petite que la limite inférieure renvoie

une chaîne vide. ::

La récupération de coupe dégénérée est très élégante : si la limite supérieure est trop grande, elle sera remplacée par la longueur du texte, si la limite supérieure est trop grande. la limite est plus petite que la limite inférieure, un

vide sera renvoyé

String. ::

>>> mot[1:100]

'elpA'

>>> 🎜> ''

>>> word[2:1]

Les indices peuvent être des nombres négatifs, pour commencer à compter à partir de la droite. exemple ::

L'indice peut être un nombre négatif, auquel cas la mesure commence par l'extrémité droite. Par exemple : :

>>> mot[-1] # Le dernier caractère

'A'

>>> ] # L'avant-dernier caractère

'p'

>>> mot[-2:] # Les deux derniers caractères

'pA'

>>> word[:-2] # Tout sauf les deux derniers caractères

'Hel'

Mais notez que -0 est vraiment la même chose que 0 , donc ça ne compte pas à partir de la droite !

Mais il faut noter que -0 est en fait 0, donc ça ne compte pas à partir de la droite !

>>> word[-0] # (puisque -0 est égal à 0)

'H'

Les indices de tranche négatifs hors plage sont tronqués , mais n'essayez pas ceci pour

index à élément unique (sans tranche) ::

Les tranches d'index négatives seront tronquées hors limites, n'essayez pas de l'utiliser pour un seul élément -element (non-slice) ) Recherche ::

>>> word[-100:]

'HelpA'

>>> word[-10] # erreur

Traceback (dernier appel le plus récent) :

Fichier "", ligne 1, dans ?

IndexError : index de chaîne hors de portée

Une façon de se rappeler comment fonctionnent les tranches est de considérer les indices comme pointant

*entre* caractères, avec le bord gauche du premier caractère numéroté 0.

Ensuite, le bord droit du dernier caractère d'une chaîne de *n* caractères a

index *n*, par exemple ::

Il existe un moyen de se rappeler facilement comment fonctionne le découpage : lors du découpage L'index est entre les deux caractères

*. L'index du premier caractère à gauche est 0, et le dernier caractère

caractère dans une chaîne de longueur *n* a un index de la limite droite de *n* . Par exemple : :

--- --- --- ---

| H | - --- --- --- ---

0 1 2 3 4 5

-5 -4 -3 -2 -1

La première rangée de nombres donne la position des indices 0...5 dans la chaîne ;

la deuxième ligne donne les indices négatifs correspondants La tranche de *i* à

*j* est constituée de. tous les caractères entre les bords étiquetés *i* et *j*,

respectivement.

La première ligne de chiffres dans le texte donne les points d'index 0...5 dans la chaîne. La deuxième ligne donne l'indice négatif correspondant.

La tranche est composée de tous les caractères compris entre les deux limites numériques de *i* à *j*.

Pour les indices non négatifs, la longueur d'une tranche est la différence des

indices, si les deux sont dans les limites. Par exemple, la longueur du « mot[1:3] ». `` est

Pour les index non négatifs, si le haut et le bas sont tous deux dans les limites, la longueur de la tranche est différente de l'index. Par exemple,

``word[1:3]`` vaut 2 .

La fonction intégrée :func:`len` renvoie la longueur d'une chaîne ::

>>> s = 'supercalifragilisticexpialidocious'

>>> len(s)

.. voir aussi : :

:ref:`typesseq`

Les chaînes et les chaînes Unicode décrites dans la section suivante sont

des exemples de *types de séquence* et prennent en charge les opérations courantes pris en charge

par de tels types.

:ref:`string-methods`

Les chaînes et les chaînes Unicode prennent en charge un grand nombre de méthodes pour

de base transformations et recherche.

:ref:`new-string-formatting`

Des informations sur le formatage des chaînes avec :meth:`str.format` sont décrites

ici.

:ref :`string-formatting`

Les anciennes opérations de formatage invoquées lorsque les chaînes et les chaînes Unicode sont

l'opérande gauche de l'opérateur ``%`` sont décrites plus en détail ici.

.. _tut-unicodestrings:

Chaînes Unicode Unicode 文本

------------------------- ---

.. sectionauthor:: Marc-Andre Lemburg

À partir de Python 2.0, un nouveau type de données pour stocker des données texte est disponible pour

le programmeur : l'objet Unicode. Il peut être utilisé pour stocker et manipuler

données Unicode (voir http://www.unicode.org/) et s'intègre bien aux objets chaîne

existants, fournissant des conversions automatiques si nécessaire .

Pour Python 2.0 起，程序员们有了一个新的，用来存储文本数据的类型： Unicode

对象。它可以用：于存储和维护 Unicode 数据（参见

http://www.unicode.org/ ），并且与现有的字符串对象有良好的集成，必要

时提供自动转换。

Unicode a l'avantage de fournir un ordinal pour chaque caractère dans chaque

écriture utilisée dans les textes modernes et anciens. Auparavant, il n'y avait que 256

ordinaux possibles pour les caractères de script. Les textes étaient généralement liés à une page de code

qui mappait les ordinaux aux caractères de script. Cela a conduit à beaucoup

confusion, notamment en ce qui concerne l'internationalisation (généralement écrit comme

``i18n`` --- ``'i'`` 18 caractères ``'n'` `) du logiciel. Unicode résout

ces problèmes en définissant une page de codes pour tous les scripts.

Unicode的每一个字符都

码页分界映射。文本绑定到映射文字系统的代码页。这在软件国际化的时候尤其

麻烦（通常写作 ``i18n`` —— ``'i'`` 18 个字符 ``'n'`` ）。 Unicode

解决了为所有的文字系统设置一个独立代码页的难题。

Créer des chaînes Unicode en Python est aussi simple que créer des

chaînes normales ::

在 Python 中创建 Unicode 字符串和创建普通的字符串一样简单 ::

>>> u'Hello World !'

u'Hello World !'

Le petit ``'u'`` devant la citation indique qu'une chaîne Unicode est

censé être créé. Si vous souhaitez inclure des caractères spéciaux dans la chaîne,

vous pouvez le faire en utilisant l'encodage Python *Unicode-Escape*. L'exemple suivant

montre comment ::

引号前的 `` 'u' '表示这会创建一个 Unicode 字符串。如果想要在字符串中包

u'Hello World !'

Pour les experts, il existe également un mode brut tout comme celui des cordes normales. Vous

devez préfixer le guillemet d'ouverture avec 'ur' pour qu'unevenPython utilise l'encodage

*Raw-Unicode-Escape*. Il n'appliquera la conversion ``/uXXXX``

ci-dessus que s'il y a un nombre impair de barres obliques inverses devant le petit

'u'. ::

特别的，和普通字符串一样， Unicode 字符串也有原始模式。可以在引号前加

"ur", Python 会Voir *Raw-Unicode-Escape* ci-dessous （原始 Unicode 转义 —— 译

者）。如果有前缀为 '/ u' 的数值，它也只会显示为 `` / uxxxx``。 ::

& gt ;>> ur'Bonjour/u0020Monde !'

u'Bonjour Tout le monde !'

>>> ur'Hello//u0020World !'

u'Hello////u0020World !'

Le mode brut est plus utile lorsque vous devez saisir de nombreuses barres obliques inverses, comme c'est le cas

être nécessaire dans les expressions régulières.

如果你需要大量输入反斜杠，原始模式非常有用，这在正则表达式中几乎是必须

的。

Outre ces encodages standards, Python propose tout un ensemble d'autres moyens

de créer des chaînes Unicode sur la base d'un encodage connu.

所为这些编码标准的一部分，Python 提供了基于已知编码来创建 Unicode 字符

串的整套方法。

.. index:: intégré: unicode

La fonction intégrée :func:`unicode ` donne accès à tous les codecs Unicode

enregistrés (COders et DECoders). Certains des encodages les plus connus que ceux-ci

les codecs pouvant être convertis sont *Latin-1*, *ASCII*, *UTF-8* et *UTF-16*. Ces deux derniers

sont des encodages de longueur variable qui stockent chaque caractère Unicode dans. un ou plusieurs

octets. Le codage par défaut est normalement défini sur ASCII, qui passe par

caractères compris entre 0 et 127 et rejette tout autre caractère avec une erreur.

Lorsqu'une chaîne Unicode est imprimée, écrite dans un fichier ou convertie avec

:func:`str`, la conversion a lieu en utilisant cet encodage par défaut ::

Fonction intégrée : func : `unicode` peut utiliser tous les encodages Unicode enregistrés (COders et

DECoders). Comme nous le savons tous, les encodages des classes

de *Latin-1*, *ASCII*, *UTF-8* et *UTF-16* peuvent être convertis les uns aux autres (Latin-1 représente un petit ensemble de symboles de langue latine, cohérent avec la base ASCII

, il ne peut pas réellement être utilisé pour représenter un vaste ensemble de caractères de langue orientale - Traducteur). Les deux derniers sont des codes

de codage de longueur variable, qui stockent chaque caractère Uniocde sous la forme d'un ou plusieurs octets. L'encodage par défaut est généralement ASCII. Cet encodage

accepte les encodages compris entre 0 et 127, sinon une erreur sera signalée. Lors de l'impression d'une chaîne Unicode

ou de son écriture dans un fichier, ou de l'utilisation de :func:`str` pour la convertir, l'opération de conversion l'utilise comme encodage par défaut. ::

>>> u"abc"

u'abc'

>>>

'abc'

>>> u"ü"

u'/xe4/xf6/xfc'

>>> (u"ü")

Traceback (dernier appel le plus récent) :

Fichier "", ligne 1, dans ?

UnicodeEncodeError : 'ascii' le codec ne peut pas encoder les caractères en position 0-2 : ordinal hors plage (128)

Pour convertir une chaîne Unicode en chaîne de 8 bits à l'aide d'un encodage spécifique,

Les objets Unicode fournissent une méthode :func:`encode` qui prend un argument, le

nom de l'encodage. Les noms minuscules pour les encodages sont préférés ::

Pour écrire une chaîne Unicode comme utilisation An 8. Chaîne -bit pour un encodage spécifique L'objet Unicode fournit une méthode

:func:`encode`, qui accepte le nom de l'encodage comme paramètre. Les noms d’encodage doivent être en minuscules. ::

>>> u"ü".encode('utf-8')

'/xc3/xa4/xc3/xb6/xc3/xbc'

Si vous avez des données dans un encodage spécifique et que vous souhaitez produire une

chaîne Unicode correspondante à partir de celle-ci, vous pouvez utiliser la fonction :func:`unicode` avec le

nom d'encodage comme ::

Si vous avez des données dans un autre encodage et souhaitez générer une chaîne Unicode à partir de celles-ci, vous pouvez utiliser la fonction :func:`unicode`

, qui accepte le nom de l'encodage comme deuxième paramètre. ::

>>> unicode('/xc3/xa4/xc3/xb6/xc3/xbc', 'utf-8')

u'/xe4/xf6/ xfc'

.. _tut-lists:

Liste des listes

----------

Python connaît un certain nombre de * Types de données composés*, utilisés pour regrouper d'autres

valeurs. La plus polyvalente est la *list*, qui peut être écrite sous la forme d'une liste de

valeurs (éléments) séparées par des virgules. entre crochets. Les éléments de la liste n'ont pas besoin que tous

aient le même type ::

Python a plusieurs types de données *composites* pour mettre entre crochets d'autres valeurs. Le plus général est *list* (liste de colonnes

), qui peut être écrite sous la forme d'une liste de valeurs séparées par des virgules entre crochets. Les éléments d'une liste ne doivent pas nécessairement être du même type. ::

>>> a = ['spam', 'oeufs', 100, 1234]

>>> spam', 'eggs', 100, 1234]

Comme les indices de chaîne, les indices de liste commencent à 0 et les listes peuvent être découpées,

concaténées et ainsi de suite ::

Tout comme l'indexation de chaînes, la liste est récupérée à partir de 0. Les listes peuvent être découpées et concaténées ::

>>> a[0]

'spam'

>>> ]

1234

>>>a[-2]

100

>>> ]

['œufs', 100]

>>> a[:2] ['bacon', 2*2]

['spam' , 'œufs', 'bacon', 4]

>>> 3*a[:3] ['Boo!']

['spam', 'œufs' , 100 , 'spam', 'eggs', 100, 'spam', 'eggs', 100, 'Boo!']

Toutes les opérations de tranche renvoient une nouvelle liste contenant les éléments demandés This

signifie que la tranche suivante renvoie une copie superficielle de la liste *a*::

Toutes les opérations de découpage renverront une nouvelle liste contenant les éléments calculés. Cela signifie que l'opération de découpage suivante

renvoie une copie superficielle de la liste *a* ::

>>> a[:]

['spam', 'eggs', 100, 1234]

Contrairement aux chaînes, qui sont *immuables*, il est possible pour modifier des

éléments individuels d'une liste ::

Contrairement aux chaînes *immuables*, les listes permettent la modification des éléments ::

>>>

['spam', 'oeufs', 100, 1234]

>>> a[2] = a[2] 23

>> ;> a

['spam', 'eggs', 123, 1234]

L'affectation aux tranches est également possible, et cela peut même changer la taille de la

liste ou effacez-le entièrement ::

Vous pouvez également attribuer des valeurs aux tranches, ce qui peut modifier la taille de la liste ou l'effacer ::

>>> :

... a[0:2] = [1, 12]

>>> a

[1, 12, 123, 1234]

>>> # Supprimer certains :

... a[0:2] = []

>>>

[123, 1234]

>>> # Insérez-en :

... a[1:1] = ['bletch', 'xyzzy']

>>> a

[123, 'bletch', 'xyzzy', 1234]

>>> lui-même au début

>>> a[:0] = a

>>> xyzzy ', 1234, 123, 'bletch', 'xyzzy', 1234]

>>> # Effacer la liste : remplacez tous les éléments par une liste vide

>> ; > a[:] = []

>>> a

[]

La fonction intégrée :func:`len` s'applique également to lists::

Fonction intégrée : func:`len` peut également être utilisée pour les listes ::

>>> , 'c' , 'd']

>>> len(a)

Il est possible d'imbriquer des listes (créer des listes contenant d'autres listes ), par

exemple ::

permet des listes imbriquées (créer une liste contenant d'autres listes), par exemple ::

>>> , 3]

>>> p = [1, q, 4]

>>>

>>> p[1]

[2, 3]

>>>

>>> p[1].append('xtra') # Voir la section 5.1

>>> 2, 3 , 'xtra'], 4]

>>> q

[2, 3, 'xtra']

Notez que dans le dernier exemple, ` `p[1]`` et ``q`` font vraiment référence au même

objet ! Nous reviendrons sur la *sémantique des objets* plus tard.

Notez que dans le dernier exemple, ``p[1]`` et ``q`` pointent en fait vers le même objet ! Nous continuerons la discussion dans la *sémantique des objets* derrière

.. _tut-firststeps :

Premiers pas vers la programmation La première étape de la programmation

================= ==========================

Bien sûr, nous pouvons utiliser Python pour des tâches plus compliquées que d'ajouter deux et deux

ensemble. Par exemple, nous pouvons écrire une sous-séquence initiale de la série *Fibonacci*

comme suit ::

Bien sûr, nous pouvons utiliser Python pour compléter le rapport. de deux plus deux Tâches plus complexes. Par exemple, nous pouvons écrire un programme

qui génère des sous-séquences *Fibonacci* comme suit : :

>>> # Série de Fibonacci :

... # la somme de deux éléments définit le suivant

... a, b = 0, 1

>>> tandis que b < .imprimer b

... a, b = b, a b

...

Cet exemple introduit plusieurs nouvelles fonctionnalités.

* La première ligne contient une *affectation multiple* : les variables ``a`` et ``b``

obtiennent simultanément les nouvelles valeurs 0 et 1. Sur la dernière ligne, ceci est utilisé à nouveau,

démontrant que les expressions du côté droit sont toutes évaluées

avant que l'une des affectations n'ait lieu

<. 🎜> sont évalués de gauche à droite.

La première ligne comprend une *affectation multiple* : les variables ``a`` et ``b`` obtiennent toutes deux la nouvelle valeur 0

et 1 . La dernière ligne est à nouveau utilisée. Dans cette démonstration, avant l'affectation des variables, le calcul de

est terminé en premier sur le côté droit. L'expression de droite est évaluée de gauche à droite.

* La boucle :keyword:`while` s'exécute tant que la condition (ici : ``b < 10``)

reste vraie. En Python, comme en C, any. une valeur entière non nulle est vraie ; zéro est

faux. La condition peut également être une valeur de chaîne ou de liste, en fait n'importe quelle séquence ;

tout ce qui a une longueur non nulle est vrai, les séquences vides sont fausses. Le test

utilisé dans l'exemple est une simple comparaison. Les opérateurs de comparaison standards

sont écrits de la même manière qu'en C : ``<`` (inférieur à) , ``>`` (supérieur à), ``==``

(égal à), ``<=`` (inférieur ou égal à), ``>=` ` (supérieur ou égal à)

et ``!=`` (différent de).

Lorsque la condition (ici ``b < 10`` ) est vraie , :keyword:`while` exécution de la boucle. En

Python, similaire au C, tout entier non nul est vrai ; 0 est faux. La condition peut aussi être une chaîne ou une liste, en fait il peut s'agir de n'importe quelle séquence ; toutes les longueurs non nulles sont vraies, les séquences vides

sont fausses. Le test de l'exemple est une simple comparaison. Les opérateurs de comparaison standards sont les mêmes qu'en C :

``<`` (inférieur à), ``>`` (supérieur à), ``==`` (égal à), ``<=` ` (inférieur ou égal à

po), ``>=`` (supérieur ou égal à) et ``!=`` (différent de).

* Le *corps* de la boucle est *indenté* : l'indentation est la manière dont Python regroupe les

instructions. Python ne fournit pas (encore !) une édition intelligente des lignes d'entrée

<.> installation, vous devez donc taper une tabulation ou des espaces pour chaque ligne en retrait. Dans

pratique, vous préparerez une saisie plus compliquée pour Python avec un éditeur de texte ;

la plupart du texte. Les éditeurs disposent d'une fonction d'indentation automatique. Lorsqu'une instruction composée est

saisie de manière interactive, elle doit être suivie d'une ligne vide pour indiquer l'achèvement de

(puisque l'analyseur ne peut pas deviner quand vous avez tapé l'instruction). dernière ligne).

Notez que chaque ligne d'un bloc de base doit être indentée du même montant.

Le corps de la boucle est *indenté* : L'indentation est Python est la méthode de déclaration d'organisation Python. .

Python ne propose pas (encore) d'édition de ligne intégrée, il faut donc saisir TAB

ou un espace pour chaque ligne en retrait. En pratique, il est recommandé de trouver un éditeur de texte pour saisir des programmes Python complexes. La plupart des éditeurs de texte

proposent une indentation automatique. Lorsque vous saisissez des instructions composées de manière interactive, vous devez saisir une ligne vide à la fin pour marquer la fin de

(car l'interprète ne peut pas deviner quelle ligne vous avez saisie est la dernière ligne).

Les blocs d'instructions au sein d'un même bloc d'instructions doivent être indentés du même nombre d'espaces.

* L'instruction :keyword:`print` écrit la valeur de la ou des expressions qui lui sont

données. Cela diffère de la simple écriture de l'expression que vous souhaitez écrire (comme nous l'avons fait<.>

plus tôt dans les exemples de calculatrice) dans la façon dont elle gère plusieurs expressions

et les chaînes sont imprimées sans guillemets, et un espace est inséré

entre les éléments, afin que vous puissiez. formatez bien les choses, comme ceci ::

Keyword:keyword:`print` affiche la valeur d'une expression donnée. Il contrôle plusieurs expressions et chaînes

à afficher sous la forme de chaîne souhaitée (tout comme nous l'avons fait dans l'exemple de calculatrice précédent). La chaîne

n'est pas entourée de guillemets lors de l'impression, et un espace est inséré entre chaque deux sous-éléments, vous pouvez donc rendre le format

très beau, comme ceci ::

>>> i = 256*256

>>> imprimer 'La valeur de i est', i

La valeur de i est 65536

Une virgule de fin évite la nouvelle ligne après la sortie ::

Utilisez une virgule à la fin pour interdire la nouvelle ligne de sortie ::

>>> , 1

> ...

1 1 2 3 5 13 21 34 55 89 144 233 377 610 987

Notez que l'interprète insère une nouvelle ligne avant d'imprimer l'invite suivante si

la dernière ligne n'était pas terminée

Notez qu'ici, si la dernière ligne n'est pas complètement sortie, l'interpréteur

insérera une nouvelle ligne avant elle. imprime l'invite suivante.

Ce qui précède est le résumé du didacticiel de base de Python 2.7. Pour plus de contenu connexe, veuillez faire attention au site Web PHP chinois (www.php.cn) !