Grundlegendes Python 2.7-Tutorial: Übersicht

.. _tut-informal:

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

Eine informelle Einführung in Python Zusammenfassung der Python-Einführung

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

In den folgenden Beispielen werden Eingabe und Ausgabe durch das Vorhandensein oder Fehlen von Eingabeaufforderungen („>>>“ und „...“) unterschieden: Um das Beispiel zu wiederholen: Sie müssen

alles nach der Eingabeaufforderung eingeben. Wenn die Eingabeaufforderung erscheint, werden vom Interpreter

eine sekundäre Eingabeaufforderung ausgegeben 🎜>Zeile allein bedeutet in einem Beispiel, dass Sie eine Leerzeile eingeben müssen; dies wird verwendet, um

einen mehrzeiligen Befehl zu beenden.

Im folgenden Beispiel werden Eingabe und Ausgabe aufgefordert ein Größer-als-Zeichen bzw. ein Punkt ( ``> >>`` und

```...``` ) Anmerkungen. Wenn Sie diese Beispiele reproduzieren möchten, geben Sie die Codezeilen, die die Eingabeaufforderung nicht enthalten, nach der Interpreter-Eingabeaufforderung ein (nach den Eingabeaufforderungszeichen

). Es ist zu beachten, dass die in der Übung angetroffene Slave-Eingabeaufforderung

bedeutet. Am Ende muss eine zusätzliche Leerzeile eingegeben werden, damit der Interpreter erkennt, dass dies das Ende eines mehrzeiligen Befehls ist.

Viele der Beispiele in diesem Handbuch, auch die, die an der interaktiven

Eingabeaufforderung eingegeben werden, enthalten Kommentare in Python, die mit dem Hash-Zeichen beginnen,

``#` ` und bis zum Ende der physischen Zeile reichen. Ein Kommentar kann am Anfang einer Zeile oder nach einem Leerzeichen oder Code erscheinen, jedoch nicht innerhalb einer Zeichenfolge.

Ein Hash-Zeichen innerhalb eines String-Literals ist nur ein Hash-Zeichen.

Da Kommentare der Verdeutlichung des Codes dienen und nicht von Python interpretiert werden, können sie

bei der Eingabe von Beispielen weggelassen werden.

Viele der Beispiele in diesem Handbuch – auch solche mit interaktiven Eingabeaufforderungen – enthalten Kommentare.

Kommentare in Python beginnen mit dem #-Zeichen und gehen bis zum tatsächlichen Ende der Zeile (Übersetzung – der ursprüngliche Autor hat

„physische Zeile“ verwendet, um tatsächliche Zeilenumbrüche anzuzeigen, anstatt sie zu bearbeiten der automatische Zeilenumbruch des Browsers). Kommentare können am Anfang der Zeile

oder nach Leerzeichen oder Code beginnen, erscheinen aber nicht in der Zeichenfolge. Die #

-Zeichen in einer Textzeichenfolge stellen einfach # dar. Kommentare im Code werden von Python nicht interpretiert. Sie können sie

ignorieren, wenn Sie Beispiele eingeben.

Einige Beispiele::

# Dies ist der erste Kommentar

SPAM = 1 ein Drittel!

STRING = "# Dies ist kein Kommentar. "

.. _tut-calculator:

Python als Taschenrechner verwenden Python als Taschenrechner verwenden

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

Lassen Sie uns einige einfache Python-Befehle ausprobieren und warten Sie auf die

Hauptaufforderung „>>>“ (Es sollte nicht lange dauern.)

Lassen Sie uns einige einfache Python-Befehle ausprobieren. Starten Sie den Interpreter und warten Sie, bis die Hauptaufforderung „>>>“

erscheint (es dauert nicht lange).

.. _tut-numbers:

Zahlen Numerische Werte

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

Der Dolmetscher fungiert als einfacher Rechner: Sie können dort einen Ausdruck eingeben

und er schreibt den Wert. Die Ausdruckssyntax ist unkompliziert: die

Operatoren „+“, „-“, „ * `` und ``/`` funktionieren wie in den meisten anderen Sprachen

(z. B. können Klammern zum Gruppieren verwendet werden)::

Interpreter Die Darstellung ist wie ein einfacher Taschenrechner: Sie können einen Ausdruck eingeben und er gibt einen

-Wert zurück. Die Ausdruckssyntax ist unkompliziert: Die Operatoren „+“, „-“, „*“ und „/“ sind die gleichen wie in anderen Sprachen (z. B. Pascal oder C); es werden Klammern verwendet zum Gruppieren. Zum Beispiel::

>>> 2+2

4

>>> # Dies ist ein Kommentar

. . 2+2

4

>>> und ein Kommentar in derselben Zeile wie Code

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

5

>>> # Ganzzahlige Division gibt den Boden zurück:

... 7 /3

2

>>> 7/-3

-3

Das Gleichheitszeichen (``'='' ` ) wird verwendet, um einer Variablen einen Wert zuzuweisen. Danach wird kein

Ergebnis vor der nächsten interaktiven Eingabeaufforderung angezeigt::

Das Gleichheitszeichen ( ``'='`` ) ist Wird zum Zuweisen der Variablenzuweisung verwendet::

>>> width = 20

>>> height = 5*9

>>> ; Breite * Höhe

900

Ein Wert kann mehreren Variablen gleichzeitig zugewiesen werden::

Ein Wert kann mehreren Variablen gleichzeitig zugewiesen werden::

> >> x = y = z = 0 # Null x, y und z

>>>

0

Variablen müssen „definiert“ (ein Wert zugewiesen) werden, bevor sie verwendet werden können, sonst tritt ein

Fehler auf ::

Variablen Es muss vor der Verwendung „definiert“ (zugewiesen) werden, sonst tritt ein Fehler auf::

>>> # Versuchen Sie, auf eine undefinierte Variable zuzugreifen

... n

Traceback (letzter Aufruf zuletzt):

Datei „“, Zeile 1, in

NameError : Name 'n' ist nicht definiert

Es gibt volle Unterstützung für Gleitkomma; Operatoren mit Operanden gemischten Typs

Konvertieren Sie den ganzzahligen Operanden in Gleitkomma::

Gleitkomma Zahlen haben volle Unterstützung; Operatoren mit Operanden gemischten Typs werden automatisch in Gleitkommazahlen konvertiert::

>>> ;>> 7.0 / 2

3.5

Komplexe Zahlen werden auch mit dem Suffix „j“ oder „J“ geschrieben ``. Komplexe Zahlen mit einer reellen Komponente ungleich Null werden als

``(real+imagj)`` geschrieben oder können mit der Funktion ``complex(real, imag)`` erstellt werden.

::

Plural Auch unterstützt; Zahlen mit dem Suffix „j“ oder „J“ werden als imaginär behandelt. Eine komplexe

-Zahl mit einem Realteil ungleich Null wird als „(real+imagj)“ geschrieben oder kann mit der Funktion „complex(real, imag)“::

>>> 1j * 1J

(-1+0j)

>>> 1j * complex(0,1)

(-1 +0j)

>>> 3+1j*3

(3+3j)

>>> 1j)*3

(9+3j)

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

(1,5+0,5j)

Komplexe Zahlen werden immer als zwei Gleitkommazahlen dargestellt, der Realteil

und der Imaginärteil. Um diese Teile aus einer komplexen Zahl *z* zu extrahieren, verwenden Sie

`` z.real` ` und ``z.imag`` ::

Der Real- und Imaginärteil einer komplexen Zahl werden immer als zwei Gleitkommazahlen aufgezeichnet. Um den Real- und Imaginärteil aus einer komplexen Zahl *z* zu extrahieren, verwenden Sie „z.real“ und „z.imag“. ::

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

>>> a.real

1,5

> >> a.imag

0.5

Die Konvertierungsfunktionen in Gleitkomma und Ganzzahl (:func:`float`,

:func:`int` und : func:`long`) funktionieren nicht für komplexe Zahlen --- es gibt keine

richtige Möglichkeit, eine komplexe Zahl in eine reelle Zahl umzuwandeln. Verwenden Sie „abs(z)“, um

seine Größe (als Float) oder „z.real“, um seinen Realteil zu erhalten::

Konvertierungsfunktion zwischen Gleitkommazahlen und ganzen Zahlen ( :func:`float` und :func:`int` und

:func:`long` ) können nicht für komplexe Zahlen verwendet werden. Es gibt keinen korrekten Weg, eine komplexe Zahl in eine reelle Zahl

umzuwandeln. Die Funktion „abs(z)“ wird verwendet, um seinen Modul (Gleitkommazahl) zu erhalten, oder „z.real“, um seinen Realteil zu erhalten::

>>> 3.0+4.0j

>>> float(a)

Traceback (letzter Aufruf zuletzt):

Datei „“, Zeile 1 , in ?

TypeError: Komplex kann nicht in Float konvertiert werden; verwende abs(z)

>>> a.real

3.0

>> ;> a.imag

4.0

>>> abs(a) # sqrt(a.real**2 + a.imag**2 )

5.0

Im interaktiven Modus wird der zuletzt gedruckte Ausdruck der Variablen zugewiesen

``_`` Dies bedeutet, dass Sie Python als Schreibtisch verwenden Rechner, es ist

Etwas einfacher, Berechnungen fortzusetzen, zum Beispiel::

Im interaktiven Modus wird der Wert des letzten Ausdrucks der Variablen „_“ zugewiesen. Auf diese Weise können wir ihn als Tischrechner verwenden, was für kontinuierliche Berechnungen sehr praktisch ist, wie zum Beispiel::

>>> Steuer = 12,5 / 100

> >> Preis = 100,50

>>> Preis * Steuer

12,5625

>>> Preis + _

113.0625

>>> Round(_, 2)

113.06

Diese Variable sollte vom Benutzer nicht explizit als schreibgeschützt behandelt werden

Weisen Sie ihm einen Wert zu --- Sie würden eine unabhängige lokale Variable mit dem

gleichen Namen erstellen, der die integrierte Variable mit ihrem magischen Verhalten maskiert.

Diese Variable ist Für den Benutzer schreibgeschützt. Versuchen Sie nicht, ihm einen Wert zuzuweisen – Sie erstellen lediglich eine separate lokale Variable mit demselben Namen, die den magischen Effekt der integrierten Variablen des Systems blockiert.

.. _tut-strings:

Strings Strings

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

Neben Zahlen kann Python auch Strings manipulieren, die ausgedrückt werden können in

auf verschiedene Arten. Sie können in einfache oder doppelte Anführungszeichen eingeschlossen werden::

Im Vergleich zu Zahlen bietet Python auch Zeichenfolgen, die auf verschiedene Arten übergeben werden können. Sie können durch

einfache oder doppelte Anführungszeichen::

>>> 'Spam-Eier'

'Spam-Eier'

> identifiziert werden ;>> 'nicht'

"nicht"

>>> "nicht"

>>> '"Ja", sagte er.'

'"Ja", sagte er.'

>>> ,/“, sagte er.

„Ja“, sagte er 🎜> „Ist/nicht“, sagte sie die Zeile, die angibt, dass die

nächste Zeile eine logische Fortsetzung der Zeile ist::

Es gibt mehrere Möglichkeiten für String-Literale, in Zeilen aufzubrechen. Sie können einen Backslash als fortlaufende Zeichenfolge am Ende einer Zeile verwenden, um anzuzeigen, dass die nächste

-Zeile logischerweise die Fortsetzung dieser Zeile ist.

hello = "Dies ist eine ziemlich lange Zeichenfolge, die/n/

mehrere Textzeilen enthält, genau wie Sie es in C tun würden./n/

Beachten Sie, dass Leerzeichen bei Der Anfang der Zeile ist/

von Bedeutung.“

print hello

Beachten Sie, dass Zeilenumbrüche weiterhin mit „/n“ in die Zeichenfolge eingebettet werden müssen -- Die

Neuzeile nach dem abschließenden Backslash wird verworfen. Dieses Beispiel würde

Folgendes ausgeben:

Es ist zu beachten, dass Sie immer noch „/“ in die Zeichenfolge schreiben müssen n`` – Ein abschließender Backslash wird ignoriert. Das vorherige

reguläre Treffen wird wie folgt gedruckt:

.. code-block:: text

Dies ist eine ziemlich lange Zeichenfolge, die

mehrere Zeilen enthält von Text, genau wie Sie es in C tun würden.

Beachten Sie, dass Leerzeichen am Anfang der Zeile von Bedeutung sind.

Oder Zeichenfolgen können in ein Paar passender dreifacher Anführungszeichen eingeschlossen werden: ` `" ""`` oder

``'''``. Zeilenenden müssen bei Verwendung von dreifachen Anführungszeichen nicht maskiert werden, werden aber

in die Zeichenfolge eingefügt : :

Darüber hinaus können Zeichenfolgen durch ein Paar dreifacher Anführungszeichen identifiziert werden: „“““`` oder „“““``. In dreifachen Anführungszeichen erfordert

kein Zeilenattribut-Escape, sie sind bereits in der Zeichenfolge enthalten::

print """

Verwendung: thingy [OPTIONS]

                                                                                                                                                                                                                                                       :

-h -H Zeigt diese Nutzungsmeldung an

-H Hostname               Hostname, mit dem eine Verbindung hergestellt werden soll

Wenn wir das String-Literal zu einem „rohen“ String machen, sind „/n“-Sequenzen nicht

in Zeilenumbrüche konvertiert, aber der Backslash am Ende der Zeile und das Zeilenumbruchzeichen

in der Quelle sind beide als Daten in der Zeichenfolge enthalten:

Wenn wir eine „rohe“ Zeichenfolge generieren, wird die n-Sequenz „/“ nicht maskiert, und der umgekehrte Schrägstrich

am Ende der Zeile und das Zeilenumbruchzeichen im Quellcode wird Teil der Daten in der Zeichenfolge, also das folgende Beispiel::

hello = r"Dies ist eine ziemlich lange Zeichenfolge, die/n/

mehrere Textzeilen enthält, ähnlich wie Sie würde in C ausreichen.“

print hello

würde drucken:

würde drucken:

.. code-block:: text

Dies ist eine ziemlich lange Zeichenfolge, die/n/

mehrere Textzeilen enthält, ähnlich wie Sie es in C tun würden.

Der Interpreter gibt das Ergebnis von Zeichenfolgenoperationen auf die gleiche Weise aus wie diese

werden zur Eingabe eingegeben: in Anführungszeichen und mit Anführungszeichen und anderen lustigen Zeichen

durch Backslashes maskiert, um den genauen Wert anzuzeigen. Die Zeichenfolge ist in doppelte Anführungszeichen eingeschlossen Wenn die Zeichenfolge ein einfaches Anführungszeichen und keine doppelten Anführungszeichen enthält, wird sie andernfalls in einfache Anführungszeichen gesetzt (die :keyword:`print`-Anweisung, beschrieben

kann später zum Schreiben von Zeichenfolgen ohne Anführungszeichen oder Escapezeichen verwendet werden.) Der

-Interpreter gibt die Ergebnisse von Zeichenfolgenoperationen genau so aus, wie sie eingegeben wurden: in Klammern, einschließlich Backslashes

Bar-Escapezeichen interessante Zeichen, um den genauen Wert anzuzeigen. Wenn eine Zeichenfolge einfache Anführungszeichen und keine doppelten Anführungszeichen

enthält, wird sie durch doppelte Anführungszeichen identifiziert. Andernfalls wird es durch einfache Anführungszeichen gekennzeichnet. (Die später eingeführte Anweisung

:keyword:`print` kann Zeichenfolgen ohne Identifizierung und Escape ausgeben.)

Zeichenfolgen können mit dem Operator „+“ und verkettet (zusammengeklebt) werden

wiederholt mit „*“::

Zeichenfolgen können durch den „+“-Operator verbunden (zusammengeklebt) werden und durch „*“ verbunden (zusammengeklebt) werden. `` Wiederholen:

>>> Wort = 'Hilfe' + 'A'

>>> Wort

'HilfeA'

>>> '<' + Wort*5 + '>'

''

Zwei String-Literale nebeneinander verkettet; die erste

Zeile oben hätte auch „word = ‚Help‘ ‚A‘“ geschrieben werden können; dies funktioniert nur

mit zwei Literalen, nicht mit beliebigen String-Ausdrücken:

Zwei benachbarte Zeichenfolgentexte werden automatisch miteinander verbunden. Die vorherige Codezeile kann auch als

``word ='Help' 'A'' geschrieben werden, was nur für zwei verwendet wird String-Literal, kann nicht in String-Ausdrücken verwendet werden.

>>> 'str' 'ing' # <- Das ist in Ordnung

'string'

'str' + 'ing ' # <- Das ist in Ordnung

'string'

>>> 'str'.strip() 'ing' # <- Das ist ungültig

  Datei „“, Zeile 1, in ?

  'str'.strip() 'ing'

            ^

SyntaxError: ungültige Syntax

Strings können tiefgestellt (indiziert) werden; wie in C hat das erste Zeichen eines Strings

den Index (Index) 0. Es gibt keinen separaten Zeichentyp; ein Zeichen ist

einfach eine Zeichenfolge der Größe eins. Teilzeichenfolgen können mit der

*Slice-Notation* angegeben werden: zwei durch einen Doppelpunkt getrennte Indizes ::

Zeichenfolgen können auch abgefangen werden (. abgerufen). Ähnlich wie bei C wird das erste Zeichen einer Zeichenfolge mit 0 indiziert. Für

gibt es keinen eigenständigen Zeichentyp, ein Zeichen ist eine Zeichenfolge der Länge 1. Ähnlich wie bei Icon können Sie die Methode

*Slicing Annotation* verwenden, um Zeichenfolgen abzufangen: Kopien, die durch zwei Indizes geteilt werden. ::

>>> Wort[4]

'A'

>>> > 'He'

>>> word[2:4]

'lp'

Slice-Indizes haben nützliche Standardwerte; , ein

ausgelassener zweiter Index entspricht standardmäßig der Größe der Zeichenfolge, die geschnitten wird::

Index-Slices können Standardwerte haben. Wenn der erste Index ignoriert wird, ist der Standardwert 0 . Der zweite

-Index wird ignoriert und standardmäßig auf die Länge der Zeichenfolge gesetzt. (Tatsächlich gibt es einen dritten Parameter, der die Slicing-Schrittgröße darstellt. Der Standardwert ist

1, und der vollständige Slicing-Vorgang ist Wort[2:4:1] - Übersetzer) ::

>>> Wort[:2] # Die ersten beiden Zeichen

'Er'

>>> Alles außer dem ersten zwei Zeichen

'lpA'

Im Gegensatz zu einem C-String können Python-Strings nicht geändert werden. Die Zuweisung zu einer indizierten

Position im String führt zu einem Fehler::

Im Gegensatz zu C-Strings sind Python-Strings unveränderlich. Das Zuweisen eines Werts zu einem Index eines Zeichenfolgenliterals führt dazu, dass

einen Fehler ausgibt::

>>> word[0] = 'x'

Traceback (letzter Aufruf zuletzt):

Datei „“, Zeile 1, in ?

TypeError: Objekt unterstützt keine Elementzuweisung

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

Traceback (letzter Aufruf zuletzt):

Datei „“, Zeile 1, in ?

TypeError: Objekt unterstützt keine Slice-Zuweisung

Das Erstellen einer neuen Zeichenfolge mit dem kombinierten Inhalt ist jedoch einfach und effizient::

Das Kombinieren von Textinhalten zum Generieren eines neuen Textes ist jedoch einfach und effizient::

>>> 'x' + Wort[1:]

'xelpA'

>>> [4]

'SplatA'

Hier ist eine nützliche Invariante von Slice-Operationen: ``s[:i] + s[i:]`` entspricht ``s``.

::

Die Slicing-Operation hat eine nützliche Invariante: „s[:i] + s[i:]“ ist gleich „s“. ::

>>> Wort[:2] + Wort[2:]

'HelpA'

>>> ] + Wort[3:]

'HelpA'

Entartete Slice-Indizes werden ordnungsgemäß behandelt: Ein zu großer Index wird

durch die String-Größe, einen oberen, ersetzt Die Grenze, die kleiner als die Untergrenze ist, gibt

eine leere Zeichenfolge zurück::

Der degenerierte Schnittabruf ist sehr elegant: Wenn die Obergrenze zu groß ist, wird sie durch die Textlänge ersetzt, wenn Die Obergrenze ist kleiner als die Untergrenze, leer

String. ::

>>> Wort[1:100]

'elpA'

>>> 🎜> ''

>>> Wort[2:1]

''

Indizes können negative Zahlen sein, um von rechts zu zählen Beispiel::

Der Index kann eine negative Zahl sein. In diesem Fall beginnt die Messung am rechten Ende. Zum Beispiel::

>>> das letzte Zeichen

'A'

>>> ] # Das vorletzte Zeichen

'p'

>>> # Die letzten beiden Zeichen

'pA'

>>> word[:-2] # Alles außer den letzten beiden Zeichen

'Hel'

Aber beachten Sie, dass -0 eigentlich dasselbe ist wie 0 , es zählt also nicht von rechts!

::

Aber es sollte beachtet werden, dass -0 tatsächlich 0 ist, es zählt also nicht von rechts!

>>> Wort[-0] # (da -0 gleich 0 ist)

'H'

Negative Slice-Indizes, die außerhalb des Bereichs liegen, werden abgeschnitten , aber versuchen Sie dies nicht für

Einzelelement-(Nicht-Slice-)Indizes::

Negative Index-Slices werden außerhalb der Grenzen abgeschnitten, versuchen Sie nicht, es für Single-Elemente zu verwenden -element (nicht-slice) ) Suche::

>>> Wort[-100:]

'HelpA'

>>> word[-10] # Fehler

Traceback (letzter Aufruf zuletzt):

Datei „“, Zeile 1, in ?

IndexError: String-Index außerhalb des zulässigen Bereichs

Eine Möglichkeit, sich daran zu erinnern, wie Slices funktionieren, besteht darin, sich die Indizes so vorzustellen, dass sie

*zwischen* Zeichen zeigen, wobei der linke Rand des ersten Zeichens mit 0 nummeriert ist.

Dann hat der rechte Rand des letzten Zeichens einer Zeichenfolge von *n* Zeichen einen

Index *n*, zum Beispiel::

Es gibt eine Möglichkeit, sich leicht zu merken, wie das Slicing funktioniert : beim Slicing Der Index liegt zwischen den beiden Zeichen

*. Der Index des ersten Zeichens auf der linken Seite ist 0, und das letzte Zeichen

in einer Zeichenfolge mit der Länge *n* hat einen rechtsgebundenen Index von *n* . Zum Beispiel:

+---+---+---+---+---+

| >

+---+---+---+---+---+

0 1 2 3 4 5

-5 -4 -3 - 2 -1

Die erste Zahlenreihe gibt die Position der Indizes 0...5 in der Zeichenfolge an;

die zweite Reihe gibt die entsprechenden negativen Indizes von *i* an. bis

*j* besteht aus allen Zeichen zwischen den mit *i* und *j* bezeichneten Kanten

jeweils.

Die erste Zahlenzeile im Text gibt die an string Indexpunkte 0...5 in . Die zweite Zeile gibt den entsprechenden negativen Index an.

Der Slice besteht aus allen Zeichen zwischen den beiden numerischen Grenzen von *i* bis *j*.

Bei nicht-negativen Indizes ist die Länge eines Segments die Differenz der

Indizes, wenn beide innerhalb der Grenzen liegen. Zum Beispiel die Länge von „word[1:3]“. `` ist

2.

Wenn bei nicht-negativen Indizes sowohl der obere als auch der untere Wert innerhalb der Grenzen liegen, unterscheidet sich die Slice-Länge vom Index. Beispielsweise ist

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

Die integrierte Funktion :func:`len` gibt die Länge einer Zeichenfolge zurück::

Die integrierte Funktion :func:`len` gibt die Länge einer Zeichenfolge zurück::

>>> s = 'supercalifragilisticexpialidocious'

>>> len(s)

34

.. siehe auch: :

:ref:`typesseq`

Strings und die im nächsten Abschnitt beschriebenen Unicode-Strings sind

Beispiele für *Sequenztypen* ​​und unterstützen die allgemeinen Operationen unterstützt

von solchen Typen.

:ref:`string-methods`

Sowohl Strings als auch Unicode-Strings unterstützen eine große Anzahl von Methoden für

Basic Transformationen und Suchen.

   :ref:`new-string-formatting`

      Informationen zur String-Formatierung mit :meth:`str.format` werden

      hier beschrieben.

   :ref :`string-formatting`

      Die alten Formatierungsvorgänge, die aufgerufen werden, wenn Strings und Unicode-Strings

      der linke Operand des „%“-Operators sind, werden hier ausführlicher beschrieben.

.. _tut-unicodestrings:

Unicode Strings Unicode 文本

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

.. Abschnittsautor: Marc-Andre Lemburg

Ab Python 2.0 steht ein neuer Datentyp zum Speichern von Textdaten zur Verfügung

der Programmierer: das Unicode-Objekt. Es kann zum Speichern und Bearbeiten

Unicode-Daten (siehe http://www.unicode.org/) verwendet werden und lässt sich gut in die vorhandenen

String-Objekte integrieren und bietet bei Bedarf automatische Konvertierungen .

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

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

http://www.unicode.org/ ) 🎜>Unicode hat der Vorteil, für jedes Zeichen in jedem

Skript, das in modernen und alten Texten verwendet wird, eine Ordnungszahl bereitzustellen. Bisher gab es nur 256

mögliche Ordnungszahlen für Skriptzeichen. Texte waren normalerweise an eine Codeseite gebunden, die die Ordnungszahlen den Skriptzeichen zuordnete. Dies führte zu großer

Verwirrung, insbesondere im Hinblick auf die Internationalisierung (normalerweise geschrieben als

„i18n“ --- „i“ + 18 Zeichen + „n“) ''``) von Software.  Unicode löst

diese Probleme durch die Definition einer Codepage für alle Skripte.

Unicode每一个字符都

提供了统一的序列号.之前，文字系统中的字符只能有 256 >码页分界映射.文本绑定到映射文字系统的代码页。这在软件国际化的时候尤其

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

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

Das Erstellen von Unicode-Strings in Python ist genauso einfach wie das Erstellen normaler

Strings: :

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

   >>> u'Hello World !'

   u'Hello World !'

Das kleine „u“ vor dem Anführungszeichen zeigt an, dass es sich um eine Unicode-Zeichenfolge handelt

soll entstehen. Wenn Sie Sonderzeichen in die Zeichenfolge einfügen möchten,

können Sie dies tun, indem Sie die Python-Kodierung *Unicode-Escape* verwenden. Das folgende Beispiel zeigt, wie: 🎜>

含特殊字符，可以使用 Python 的 *Unicode-Escape* （Unicode 转义——译者。

请看下面的例子 ::

  . >> ;> u'Hello/u0020World !'

   u'Hello World !'

Für Experten gibt es auch einen Raw-Modus genau wie den für normale Strings. Sie

müssen dem Eröffnungszitat „ur“ voranstellen, damit ungleichmäßigPython die

*Raw-Unicode-Escape*-Codierung verwendet. Die obige ``/uXXXX``

Konvertierung wird nur angewendet, wenn vor dem kleinen

'u' eine ungerade Anzahl von Backslashes steht. ::

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

“ur”，Python. 会采用 *Raw-Unicode-Escape*-Datei （原始 Unicode 转义 转义 转义 译

者。 如果 有 前缀 为 为 '/u' 的 数 值 ， 也 只 会 为 为 `` ``/uxxxx``。: ;>> ur'Hello/u0020World !'

   u'Hello World !'

   >>> ur'Hello//u0020World !'

   u'Hello////u0020World !'

Der Raw-Modus ist am nützlichsten, wenn Sie wie möglich viele Backslashes eingeben müssen

in regulären Ausdrücken notwendig sein.

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

的.

Abgesehen von diesen Standardkodierungen bietet Python eine ganze Reihe anderer Möglichkeiten

zum Erstellen von Unicode-Strings auf der Grundlage einer bekannten Kodierung.

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

串的整套方法.

.. index::builtin: unicode

Die integrierte Funktion :func:`unicode ` bietet Zugriff auf alle registrierten Unicode

Codecs (COders und DECoders). Einige der bekannteren Kodierungen, die diese

Codecs, die konvertieren können, sind *Latin-1*, *ASCII*, *UTF-8* und *UTF-16*.

sind Codierungen mit variabler Länge, in denen jedes Unicode-Zeichen gespeichert wird ein oder mehrere

Bytes. Die Standardkodierung ist normalerweise auf ASCII eingestellt, das

Zeichen im Bereich von 0 bis 127 durchlässt und alle anderen Zeichen mit einem Fehler zurückweist.

Wenn eine Unicode-Zeichenfolge gedruckt, in eine Datei geschrieben oder mit

:func:`str` konvertiert wird, erfolgt die Konvertierung mit dieser Standardkodierung ::

Eingebaute Funktion: func: „unicode“ kann alle registrierten Unicode-Kodierungen (COders und

DECoders) verwenden. Wie wir alle wissen, können Kodierungen der

-Klassen von *Latin-1*, *ASCII*, *UTF-8* und *UTF-16* ineinander konvertiert werden (Latin-1 stellt einen kleinen Wert dar). Satz lateinischer Sprachsymbole. In Übereinstimmung mit der ASCII-Basis

kann es eigentlich nicht zur Darstellung eines großen Satzes östlicher Sprachzeichen verwendet werden (Übersetzer). Bei den letzten beiden handelt es sich um Kodierungscodes mit variabler Länge

, die jedes Uniocde-Zeichen als ein oder mehrere Bytes speichern. Die Standardkodierung ist normalerweise ASCII. Diese

-Kodierung akzeptiert Kodierungen im Bereich von 0 bis 127, andernfalls wird ein Fehler gemeldet. Wenn Sie eine Unicode-Zeichenfolge

drucken oder in eine Datei schreiben oder :func:`str` zum Konvertieren verwenden, verwendet der Konvertierungsvorgang dies als Standardkodierung. ::

>>> u"abc"

u'abc'

>>> str(u"abc")

'abc'

>>> u"ü"

u'/xe4/xf6/xfc'

>>> (u"ü")

Traceback (letzter Aufruf zuletzt):

Datei „“, Zeile 1, in ?

UnicodeEncodeError: 'ascii' Codec kann Zeichen an Position 0-2 nicht kodieren: Ordinalzahl nicht im Bereich (128)

Um eine Unicode-Zeichenfolge in eine 8-Bit-Zeichenfolge mit einer bestimmten Kodierung zu konvertieren,

Unicode-Objekte bieten eine :func:`encode`-Methode, die ein Argument, den

Namen der Kodierung, verwendet. Kleinbuchstaben für Kodierungen werden bevorzugt::

Um einen Unicode-String als Zeichen zu schreiben, verwenden Sie eine 8 -Bit-Zeichenfolge für eine bestimmte Kodierung. Das Unicode-Objekt stellt eine

:func:`encode`-Methode bereit, die den Kodierungsnamen als Parameter akzeptiert. Codierungsnamen sollten in Kleinbuchstaben geschrieben werden. ::

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

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

Wenn Sie Daten in einer bestimmten Kodierung haben und daraus einen entsprechenden

Unicode-String erzeugen möchten, können Sie die Funktion :func:`unicode` mit dem

Kodierungsnamen as verwenden ::

Wenn Sie Daten in einer anderen Kodierung haben und daraus eine Unicode-Zeichenfolge generieren möchten, können Sie die Funktion :func:`unicode`

verwenden, die den Kodierungsnamen als akzeptiert zweiter Parameter. ::

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

u'/xe4/xf6/ xfc'

.. _tut-lists:

Lists list

----------

Python kennt eine Reihe von * zusammengesetzte* Datentypen, die zum Gruppieren anderer

Werte verwendet werden. Am vielseitigsten ist die *Liste*, die als Liste von

durch Kommas getrennten Werten (Elementen) geschrieben werden kann. zwischen eckigen Klammern. Listenelemente müssen nicht alle

den gleichen Typ haben::

Python verfügt über mehrere *zusammengesetzte* Datentypen zum Klammern anderer Werte. Am allgemeinsten ist *list* (Liste der Spalten

), die als Liste von durch Kommas getrennten Werten in eckigen Klammern geschrieben werden kann. Die Elemente einer Liste müssen nicht vom gleichen Typ sein. ::

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

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

Wie String-Indizes beginnen auch Listenindizes bei 0, und Listen können in Scheiben geschnitten,

verkettet usw. werden::

Genau wie bei der String-Indizierung wird die Liste beginnend bei 0 abgerufen. Listen können aufgeteilt und verkettet werden::

>>> a[0]

'spam'

>>> ]

1234

>>> a[-2]

100

>>> ]

['Eier', 100]

>>> a[:2] + ['Speck', 2*2]

['Spam ', 'eier', 'speck', 4]

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

['spam', ' egg', 100, 'spam', 'eggs', 100, 'spam', 'eggs', 100, 'Boo!']

Alle Slice-Operationen geben eine neue Liste mit den angeforderten Elementen zurück

bedeutet, dass das folgende Slice eine flache Kopie der Liste *a* zurückgibt::

Alle Slicing-Vorgänge geben eine neue Liste mit den berechneten Elementen zurück. Das bedeutet, dass der folgende Slicing-Vorgang

eine flache Kopie der Liste *a* ::

zurückgibt

>>> a[:]

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

Im Gegensatz zu Strings, die *unveränderlich* sind, ist es möglich um einzelne

Elemente einer Liste zu ändern::

Im Gegensatz zu *unveränderlichen* Zeichenfolgen ermöglichen Listen die Änderung von Elementen::

>>>

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

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

> >> ; a

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

Eine Zuordnung zu Slices ist ebenfalls möglich, wodurch sich sogar die Größe der

Liste ändern kann oder ganz löschen::

Sie können den Slices auch Werte zuweisen. Mit diesem Vorgang können Sie die Größe der Liste ändern oder sie löschen::

>>> einige Elemente:

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

>>> 1234]

>>> # Einige entfernen:

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

>>> 🎜>

[123, 1234]

>>> # Fügen Sie einige ein:

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

>>> a

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

>>> von) selbst am Anfang

>>> a[:0] = a

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

>>> # Liste löschen: Alle Elemente durch eine leere Liste ersetzen

> ;> ;> a[:] = []

>>> a

[]

Die integrierte Funktion :func:`len` gilt auch für Listen::

Eingebaute Funktion: func:`len` kann auch für Listen verwendet werden::

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

>>> len(a)

4

Es ist möglich, Listen zu verschachteln (Listen mit zu erstellen). andere Listen), zum Beispiel:

example::

ermöglicht verschachtelte Listen (Erstellen einer Liste mit anderen Listen), zum Beispiel::

>>> [2, 3 ]

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

>>> len(p)

3

>>> p[1]

[2, 3]

>>> p[1][0]

2

>>> p[1].append('xtra') # Siehe Abschnitt 5.1

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

>>> q

[2, 3, 'xtra']

Beachten Sie, dass in Im letzten Beispiel beziehen sich „p[1]“ und „q“ tatsächlich auf dasselbe

Objekt! Auf die *Objektsemantik* kommen wir später zurück.

Hinweis Im letzten Beispiel zeigen „p[1]“ und „q“ tatsächlich auf dasselbe Objekt! Wir werden die Diskussion in der *Objektsemantik* hinter

fortsetzen.

.. _tut-firststeps:

Erste Schritte zur Programmierung Der erste Schritt der Programmierung

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

Natürlich können wir Python für kompliziertere Aufgaben verwenden, als zwei und zwei hinzuzufügen

Zusammen können wir zum Beispiel eine erste Teilsequenz der *Fibonacci*-Reihe wie folgt schreiben::

Natürlich können wir Python verwenden, um das Verhältnis zu vervollständigen von zwei plus zwei Komplexere Aufgaben. Zum Beispiel können wir ein

Programm schreiben, das *Fibonacci*-Teilfolgen wie folgt generiert::

>>> die Summe zweier Elemente definiert das nächste

... a, b = 0, 1

>>> während b < . print b

... a, b = b, a+b

...

1

1

2

3

5

8

Dieses Beispiel führt mehrere neue Funktionen ein.

Dieses Beispiel führt mehrere neue Funktionen ein.

* Die erste Zeile enthält eine *Mehrfachzuweisung*: Die Variablen „a“ und „b“

erhalten gleichzeitig die neuen Werte 0 und 1. In der letzten Zeile wird dies erneut verwendet,

um zu zeigen, dass alle Ausdrücke auf der rechten Seite ausgewertet werden

zuerst, bevor eine der Zuweisungen erfolgt. Die Ausdrücke auf der rechten Seite

werden von links nach rechts ausgewertet.

Die erste Zeile enthält eine *Mehrfachzuweisung*: Die Variablen „a“ und „b“ erhalten beide den neuen Wert 0

und 1 . Die letzte Zeile wird erneut verwendet. In dieser Demonstration wird vor der Variablenzuweisung zunächst die Berechnung von

auf der rechten Seite abgeschlossen. Der Ausdruck rechts wird von links nach rechts ausgewertet.

* Die :keyword:`while`-Schleife wird ausgeführt, solange die Bedingung (hier: „b < 10“)

in Python wie in C wahr bleibt Ein ganzzahliger Wert ungleich Null ist wahr; Null ist

falsch. Die Bedingung kann auch ein String- oder Listenwert sein, tatsächlich jede Sequenz;

alles mit einer Länge ungleich Null ist wahr. Leere Sequenzen sind falsch. Der im Beispiel verwendete Test

ist ein einfacher Vergleich. Die Standardvergleichsoperatoren

werden genauso geschrieben wie in C: „<“ (kleiner als) , „>“ (größer als), „==“

(gleich), „<=“ (kleiner oder gleich), „>=“. ` (größer oder gleich)

und ``!=`` (ungleich).

Wenn die Bedingung (hier ist „b < 10“) wahr ist , :keyword:`while`-Schleifenausführung. In

Python ist, ähnlich wie in C, jede Ganzzahl ungleich Null wahr, 0 ist falsch. Die Bedingung kann auch eine Zeichenfolge oder eine Liste sein. Tatsächlich kann es sich um eine beliebige Sequenz handeln. Alle Längen ungleich Null sind wahr, leere Sequenzen

sind falsch. Der Test im Beispiel ist ein einfacher Vergleich. Die Standardvergleichsoperatoren sind die gleichen wie in C:

``<`` (kleiner als), ``>`` (größer als), ``==`` (gleich), ``<=` ` (kleiner oder gleich

in), ``>=`` (größer oder gleich) und ``!=`` (ungleich).

* Der *Körper* der Schleife ist *eingerückt*: Einrückung ist Pythons Art, Anweisungen zu gruppieren

Python bietet (noch!) keine intelligente Eingabezeilenbearbeitung

Funktion, Sie müssen also für jede eingerückte Zeile einen Tabulator oder ein Leerzeichen eingeben. In

Übungen bereiten Sie kompliziertere Eingaben für Python mit einem Texteditor vor;

die meisten Texte Editoren verfügen über eine automatische Einrückungsfunktion. Wenn eine zusammengesetzte Anweisung

interaktiv eingegeben wird, muss ihr eine Leerzeile folgen, um die

-Vervollständigung anzuzeigen (da der Parser nicht erraten kann, wann Sie die eingegeben haben). letzte Zeile).

Beachten Sie, dass jede Zeile innerhalb eines Basisblocks um den gleichen Betrag eingerückt werden muss.

Der Schleifenkörper ist *eingerückt*: Einrückung ist Python ist eine Python-Organisationsanweisungsmethode .

Python bietet (noch) keine integrierte Zeilenbearbeitung, daher müssen Sie für jede eingerückte Zeile TAB

oder ein Leerzeichen eingeben. In der Praxis empfiehlt es sich, einen Texteditor zu finden, um komplexe Python-Programme einzugeben. Die meisten Texteditoren bieten eine automatische Einrückung. Wenn Sie zusammengesetzte Anweisungen interaktiv eingeben, müssen Sie am Ende eine Leerzeile eingeben, um das Ende von

zu markieren (da der Interpreter nicht erraten kann, welche Zeile Sie als letzte eingegeben haben).

Anweisungsblöcke innerhalb desselben Anweisungsblocks müssen um die gleiche Anzahl an Leerzeichen eingerückt werden.

* Die :keyword:`print`-Anweisung schreibt den Wert des/der Ausdruck(e), der(n) angegeben ist

Es unterscheidet sich davon, nur den Ausdruck zu schreiben, den Sie schreiben möchten (wie wir es getan haben

weiter oben in den Taschenrechner-Beispielen) in der Art und Weise, wie mehrere Ausdrücke

und Zeichenfolgen verarbeitet werden, und zwischen den Elementen wird ein Leerzeichen eingefügt

Formatieren Sie die Dinge gut, etwa so::

Keyword:keyword:`print`-Anweisung gibt den Wert eines bestimmten Ausdrucks aus. Es steuert mehrere Ausdrücke und

Zeichenfolgen, die als gewünschte Zeichenfolge ausgegeben werden (genau wie wir es im vorherigen Taschenrechnerbeispiel getan haben). Beim Drucken einer Zeichenfolge

ist es nicht nötig, sie in Anführungszeichen zu setzen, und zwischen den beiden Unterelementen wird jeweils ein Leerzeichen eingefügt, sodass Sie das Format

sehr schön gestalten können, etwa so: :

  >>> i = 256*256

  >>> print 'Der Wert von i ist', i

  Der Wert von i ist 65536

Ein abschließendes Komma vermeidet den Zeilenumbruch nach der Ausgabe::

Verwenden Sie ein Komma am Ende, um die Ausgabe eines Zeilenumbruchs zu verhindern::

>>> , B = 0, 1

…

...

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

Beachten Sie, dass die der Der Interpreter fügt eine neue Zeile ein, bevor er die nächste Eingabeaufforderung ausgibt, wenn

die letzte Zeile nicht abgeschlossen wurde.

Beachten Sie hier, dass der Interpreter

ausgibt, wenn die letzte Zeile nicht vollständig ausgegeben wird fügt eine neue Zeile ein, bevor die nächste Eingabeaufforderung gedruckt wird.

Das Obige ist die Zusammenfassung des grundlegenden Tutorials von Python 2.7. Weitere verwandte Inhalte finden Sie auf der chinesischen PHP-Website (www.php.cn).