forked from AFPy/python-docs-fr
5597 lines
208 KiB
Plaintext
5597 lines
208 KiB
Plaintext
# SOME DESCRIPTIVE TITLE.
|
|
# Copyright (C) 2001-2016, Python Software Foundation
|
|
# This file is distributed under the same license as the Python package.
|
|
# FIRST AUTHOR <EMAIL@ADDRESS>, YEAR.
|
|
#
|
|
#, fuzzy
|
|
msgid ""
|
|
msgstr ""
|
|
"Project-Id-Version: Python 3.6\n"
|
|
"Report-Msgid-Bugs-To: \n"
|
|
"POT-Creation-Date: 2016-10-17 21:44+0200\n"
|
|
"PO-Revision-Date: YEAR-MO-DA HO:MI+ZONE\n"
|
|
"Last-Translator: FULL NAME <EMAIL@ADDRESS>\n"
|
|
"Language-Team: LANGUAGE <LL@li.org>\n"
|
|
"MIME-Version: 1.0\n"
|
|
"Content-Type: text/plain; charset=UTF-8\n"
|
|
"Content-Transfer-Encoding: 8bit\n"
|
|
|
|
#: ../Doc/tutorial/appendix.rst:5
|
|
msgid "Appendix"
|
|
msgstr ""
|
|
|
|
#: ../Doc/tutorial/appendix.rst:11 ../Doc/tutorial/interpreter.rst:90
|
|
msgid "Interactive Mode"
|
|
msgstr ""
|
|
|
|
#: ../Doc/tutorial/appendix.rst:16
|
|
msgid "Error Handling"
|
|
msgstr ""
|
|
|
|
#: ../Doc/tutorial/appendix.rst:18
|
|
msgid ""
|
|
"When an error occurs, the interpreter prints an error message and a stack "
|
|
"trace. In interactive mode, it then returns to the primary prompt; when "
|
|
"input came from a file, it exits with a nonzero exit status after printing "
|
|
"the stack trace. (Exceptions handled by an :keyword:`except` clause in a :"
|
|
"keyword:`try` statement are not errors in this context.) Some errors are "
|
|
"unconditionally fatal and cause an exit with a nonzero exit; this applies to "
|
|
"internal inconsistencies and some cases of running out of memory. All error "
|
|
"messages are written to the standard error stream; normal output from "
|
|
"executed commands is written to standard output."
|
|
msgstr ""
|
|
|
|
#: ../Doc/tutorial/appendix.rst:28
|
|
msgid ""
|
|
"Typing the interrupt character (usually :kbd:`Control-C` or :kbd:`Delete`) "
|
|
"to the primary or secondary prompt cancels the input and returns to the "
|
|
"primary prompt. [#]_ Typing an interrupt while a command is executing raises "
|
|
"the :exc:`KeyboardInterrupt` exception, which may be handled by a :keyword:"
|
|
"`try` statement."
|
|
msgstr ""
|
|
|
|
#: ../Doc/tutorial/appendix.rst:38
|
|
msgid "Executable Python Scripts"
|
|
msgstr ""
|
|
|
|
#: ../Doc/tutorial/appendix.rst:40
|
|
msgid ""
|
|
"On BSD'ish Unix systems, Python scripts can be made directly executable, "
|
|
"like shell scripts, by putting the line ::"
|
|
msgstr ""
|
|
|
|
#: ../Doc/tutorial/appendix.rst:45
|
|
msgid ""
|
|
"(assuming that the interpreter is on the user's :envvar:`PATH`) at the "
|
|
"beginning of the script and giving the file an executable mode. The ``#!`` "
|
|
"must be the first two characters of the file. On some platforms, this first "
|
|
"line must end with a Unix-style line ending (``'\\n'``), not a Windows "
|
|
"(``'\\r\\n'``) line ending. Note that the hash, or pound, character, "
|
|
"``'#'``, is used to start a comment in Python."
|
|
msgstr ""
|
|
|
|
#: ../Doc/tutorial/appendix.rst:52
|
|
msgid ""
|
|
"The script can be given an executable mode, or permission, using the :"
|
|
"program:`chmod` command."
|
|
msgstr ""
|
|
|
|
#: ../Doc/tutorial/appendix.rst:59
|
|
msgid ""
|
|
"On Windows systems, there is no notion of an \"executable mode\". The "
|
|
"Python installer automatically associates ``.py`` files with ``python.exe`` "
|
|
"so that a double-click on a Python file will run it as a script. The "
|
|
"extension can also be ``.pyw``, in that case, the console window that "
|
|
"normally appears is suppressed."
|
|
msgstr ""
|
|
|
|
#: ../Doc/tutorial/appendix.rst:69
|
|
msgid "The Interactive Startup File"
|
|
msgstr ""
|
|
|
|
#: ../Doc/tutorial/appendix.rst:71
|
|
msgid ""
|
|
"When you use Python interactively, it is frequently handy to have some "
|
|
"standard commands executed every time the interpreter is started. You can "
|
|
"do this by setting an environment variable named :envvar:`PYTHONSTARTUP` to "
|
|
"the name of a file containing your start-up commands. This is similar to "
|
|
"the :file:`.profile` feature of the Unix shells."
|
|
msgstr ""
|
|
|
|
#: ../Doc/tutorial/appendix.rst:77
|
|
msgid ""
|
|
"This file is only read in interactive sessions, not when Python reads "
|
|
"commands from a script, and not when :file:`/dev/tty` is given as the "
|
|
"explicit source of commands (which otherwise behaves like an interactive "
|
|
"session). It is executed in the same namespace where interactive commands "
|
|
"are executed, so that objects that it defines or imports can be used without "
|
|
"qualification in the interactive session. You can also change the prompts "
|
|
"``sys.ps1`` and ``sys.ps2`` in this file."
|
|
msgstr ""
|
|
|
|
#: ../Doc/tutorial/appendix.rst:85
|
|
msgid ""
|
|
"If you want to read an additional start-up file from the current directory, "
|
|
"you can program this in the global start-up file using code like ``if os."
|
|
"path.isfile('.pythonrc.py'): exec(open('.pythonrc.py').read())``. If you "
|
|
"want to use the startup file in a script, you must do this explicitly in the "
|
|
"script::"
|
|
msgstr ""
|
|
|
|
#: ../Doc/tutorial/appendix.rst:102
|
|
msgid "The Customization Modules"
|
|
msgstr ""
|
|
|
|
#: ../Doc/tutorial/appendix.rst:104
|
|
msgid ""
|
|
"Python provides two hooks to let you customize it: :mod:`sitecustomize` and :"
|
|
"mod:`usercustomize`. To see how it works, you need first to find the "
|
|
"location of your user site-packages directory. Start Python and run this "
|
|
"code::"
|
|
msgstr ""
|
|
|
|
#: ../Doc/tutorial/appendix.rst:112
|
|
msgid ""
|
|
"Now you can create a file named :file:`usercustomize.py` in that directory "
|
|
"and put anything you want in it. It will affect every invocation of Python, "
|
|
"unless it is started with the :option:`-s` option to disable the automatic "
|
|
"import."
|
|
msgstr ""
|
|
|
|
#: ../Doc/tutorial/appendix.rst:116
|
|
msgid ""
|
|
":mod:`sitecustomize` works in the same way, but is typically created by an "
|
|
"administrator of the computer in the global site-packages directory, and is "
|
|
"imported before :mod:`usercustomize`. See the documentation of the :mod:"
|
|
"`site` module for more details."
|
|
msgstr ""
|
|
|
|
#: ../Doc/tutorial/appendix.rst:123 ../Doc/tutorial/classes.rst:952
|
|
#: ../Doc/tutorial/controlflow.rst:759 ../Doc/tutorial/datastructures.rst:707
|
|
#: ../Doc/tutorial/interpreter.rst:162 ../Doc/tutorial/introduction.rst:529
|
|
#: ../Doc/tutorial/modules.rst:550
|
|
msgid "Footnotes"
|
|
msgstr ""
|
|
|
|
#: ../Doc/tutorial/appendix.rst:124
|
|
msgid "A problem with the GNU Readline package may prevent this."
|
|
msgstr ""
|
|
|
|
#: ../Doc/tutorial/appetite.rst:5
|
|
msgid "Whetting Your Appetite"
|
|
msgstr ""
|
|
|
|
#: ../Doc/tutorial/appetite.rst:7
|
|
msgid ""
|
|
"If you do much work on computers, eventually you find that there's some task "
|
|
"you'd like to automate. For example, you may wish to perform a search-and-"
|
|
"replace over a large number of text files, or rename and rearrange a bunch "
|
|
"of photo files in a complicated way. Perhaps you'd like to write a small "
|
|
"custom database, or a specialized GUI application, or a simple game."
|
|
msgstr ""
|
|
|
|
#: ../Doc/tutorial/appetite.rst:13
|
|
msgid ""
|
|
"If you're a professional software developer, you may have to work with "
|
|
"several C/C++/Java libraries but find the usual write/compile/test/re-"
|
|
"compile cycle is too slow. Perhaps you're writing a test suite for such a "
|
|
"library and find writing the testing code a tedious task. Or maybe you've "
|
|
"written a program that could use an extension language, and you don't want "
|
|
"to design and implement a whole new language for your application."
|
|
msgstr ""
|
|
|
|
#: ../Doc/tutorial/appetite.rst:20
|
|
msgid "Python is just the language for you."
|
|
msgstr ""
|
|
|
|
#: ../Doc/tutorial/appetite.rst:22
|
|
msgid ""
|
|
"You could write a Unix shell script or Windows batch files for some of these "
|
|
"tasks, but shell scripts are best at moving around files and changing text "
|
|
"data, not well-suited for GUI applications or games. You could write a C/C++/"
|
|
"Java program, but it can take a lot of development time to get even a first-"
|
|
"draft program. Python is simpler to use, available on Windows, Mac OS X, "
|
|
"and Unix operating systems, and will help you get the job done more quickly."
|
|
msgstr ""
|
|
|
|
#: ../Doc/tutorial/appetite.rst:29
|
|
msgid ""
|
|
"Python is simple to use, but it is a real programming language, offering "
|
|
"much more structure and support for large programs than shell scripts or "
|
|
"batch files can offer. On the other hand, Python also offers much more "
|
|
"error checking than C, and, being a *very-high-level language*, it has high-"
|
|
"level data types built in, such as flexible arrays and dictionaries. "
|
|
"Because of its more general data types Python is applicable to a much larger "
|
|
"problem domain than Awk or even Perl, yet many things are at least as easy "
|
|
"in Python as in those languages."
|
|
msgstr ""
|
|
|
|
#: ../Doc/tutorial/appetite.rst:37
|
|
msgid ""
|
|
"Python allows you to split your program into modules that can be reused in "
|
|
"other Python programs. It comes with a large collection of standard modules "
|
|
"that you can use as the basis of your programs --- or as examples to start "
|
|
"learning to program in Python. Some of these modules provide things like "
|
|
"file I/O, system calls, sockets, and even interfaces to graphical user "
|
|
"interface toolkits like Tk."
|
|
msgstr ""
|
|
|
|
#: ../Doc/tutorial/appetite.rst:44
|
|
msgid ""
|
|
"Python is an interpreted language, which can save you considerable time "
|
|
"during program development because no compilation and linking is necessary. "
|
|
"The interpreter can be used interactively, which makes it easy to experiment "
|
|
"with features of the language, to write throw-away programs, or to test "
|
|
"functions during bottom-up program development. It is also a handy desk "
|
|
"calculator."
|
|
msgstr ""
|
|
|
|
#: ../Doc/tutorial/appetite.rst:50
|
|
msgid ""
|
|
"Python enables programs to be written compactly and readably. Programs "
|
|
"written in Python are typically much shorter than equivalent C, C++, or "
|
|
"Java programs, for several reasons:"
|
|
msgstr ""
|
|
|
|
#: ../Doc/tutorial/appetite.rst:54
|
|
msgid ""
|
|
"the high-level data types allow you to express complex operations in a "
|
|
"single statement;"
|
|
msgstr ""
|
|
|
|
#: ../Doc/tutorial/appetite.rst:57
|
|
msgid ""
|
|
"statement grouping is done by indentation instead of beginning and ending "
|
|
"brackets;"
|
|
msgstr ""
|
|
|
|
#: ../Doc/tutorial/appetite.rst:60
|
|
msgid "no variable or argument declarations are necessary."
|
|
msgstr ""
|
|
|
|
#: ../Doc/tutorial/appetite.rst:62
|
|
msgid ""
|
|
"Python is *extensible*: if you know how to program in C it is easy to add a "
|
|
"new built-in function or module to the interpreter, either to perform "
|
|
"critical operations at maximum speed, or to link Python programs to "
|
|
"libraries that may only be available in binary form (such as a vendor-"
|
|
"specific graphics library). Once you are really hooked, you can link the "
|
|
"Python interpreter into an application written in C and use it as an "
|
|
"extension or command language for that application."
|
|
msgstr ""
|
|
|
|
#: ../Doc/tutorial/appetite.rst:70
|
|
msgid ""
|
|
"By the way, the language is named after the BBC show \"Monty Python's Flying "
|
|
"Circus\" and has nothing to do with reptiles. Making references to Monty "
|
|
"Python skits in documentation is not only allowed, it is encouraged!"
|
|
msgstr ""
|
|
|
|
#: ../Doc/tutorial/appetite.rst:74
|
|
msgid ""
|
|
"Now that you are all excited about Python, you'll want to examine it in some "
|
|
"more detail. Since the best way to learn a language is to use it, the "
|
|
"tutorial invites you to play with the Python interpreter as you read."
|
|
msgstr ""
|
|
|
|
#: ../Doc/tutorial/appetite.rst:78
|
|
msgid ""
|
|
"In the next chapter, the mechanics of using the interpreter are explained. "
|
|
"This is rather mundane information, but essential for trying out the "
|
|
"examples shown later."
|
|
msgstr ""
|
|
|
|
#: ../Doc/tutorial/appetite.rst:82
|
|
msgid ""
|
|
"The rest of the tutorial introduces various features of the Python language "
|
|
"and system through examples, beginning with simple expressions, statements "
|
|
"and data types, through functions and modules, and finally touching upon "
|
|
"advanced concepts like exceptions and user-defined classes."
|
|
msgstr ""
|
|
|
|
#: ../Doc/tutorial/classes.rst:5
|
|
msgid "Classes"
|
|
msgstr ""
|
|
|
|
#: ../Doc/tutorial/classes.rst:7
|
|
msgid ""
|
|
"Compared with other programming languages, Python's class mechanism adds "
|
|
"classes with a minimum of new syntax and semantics. It is a mixture of the "
|
|
"class mechanisms found in C++ and Modula-3. Python classes provide all the "
|
|
"standard features of Object Oriented Programming: the class inheritance "
|
|
"mechanism allows multiple base classes, a derived class can override any "
|
|
"methods of its base class or classes, and a method can call the method of a "
|
|
"base class with the same name. Objects can contain arbitrary amounts and "
|
|
"kinds of data. As is true for modules, classes partake of the dynamic "
|
|
"nature of Python: they are created at runtime, and can be modified further "
|
|
"after creation."
|
|
msgstr ""
|
|
|
|
#: ../Doc/tutorial/classes.rst:17
|
|
msgid ""
|
|
"In C++ terminology, normally class members (including the data members) are "
|
|
"*public* (except see below :ref:`tut-private`), and all member functions are "
|
|
"*virtual*. As in Modula-3, there are no shorthands for referencing the "
|
|
"object's members from its methods: the method function is declared with an "
|
|
"explicit first argument representing the object, which is provided "
|
|
"implicitly by the call. As in Smalltalk, classes themselves are objects. "
|
|
"This provides semantics for importing and renaming. Unlike C++ and "
|
|
"Modula-3, built-in types can be used as base classes for extension by the "
|
|
"user. Also, like in C++, most built-in operators with special syntax "
|
|
"(arithmetic operators, subscripting etc.) can be redefined for class "
|
|
"instances."
|
|
msgstr ""
|
|
|
|
#: ../Doc/tutorial/classes.rst:28
|
|
msgid ""
|
|
"(Lacking universally accepted terminology to talk about classes, I will make "
|
|
"occasional use of Smalltalk and C++ terms. I would use Modula-3 terms, "
|
|
"since its object-oriented semantics are closer to those of Python than C++, "
|
|
"but I expect that few readers have heard of it.)"
|
|
msgstr ""
|
|
|
|
#: ../Doc/tutorial/classes.rst:37
|
|
msgid "A Word About Names and Objects"
|
|
msgstr ""
|
|
|
|
#: ../Doc/tutorial/classes.rst:39
|
|
msgid ""
|
|
"Objects have individuality, and multiple names (in multiple scopes) can be "
|
|
"bound to the same object. This is known as aliasing in other languages. "
|
|
"This is usually not appreciated on a first glance at Python, and can be "
|
|
"safely ignored when dealing with immutable basic types (numbers, strings, "
|
|
"tuples). However, aliasing has a possibly surprising effect on the "
|
|
"semantics of Python code involving mutable objects such as lists, "
|
|
"dictionaries, and most other types. This is usually used to the benefit of "
|
|
"the program, since aliases behave like pointers in some respects. For "
|
|
"example, passing an object is cheap since only a pointer is passed by the "
|
|
"implementation; and if a function modifies an object passed as an argument, "
|
|
"the caller will see the change --- this eliminates the need for two "
|
|
"different argument passing mechanisms as in Pascal."
|
|
msgstr ""
|
|
|
|
#: ../Doc/tutorial/classes.rst:55
|
|
msgid "Python Scopes and Namespaces"
|
|
msgstr ""
|
|
|
|
#: ../Doc/tutorial/classes.rst:57
|
|
msgid ""
|
|
"Before introducing classes, I first have to tell you something about "
|
|
"Python's scope rules. Class definitions play some neat tricks with "
|
|
"namespaces, and you need to know how scopes and namespaces work to fully "
|
|
"understand what's going on. Incidentally, knowledge about this subject is "
|
|
"useful for any advanced Python programmer."
|
|
msgstr ""
|
|
|
|
#: ../Doc/tutorial/classes.rst:63
|
|
msgid "Let's begin with some definitions."
|
|
msgstr ""
|
|
|
|
#: ../Doc/tutorial/classes.rst:65
|
|
msgid ""
|
|
"A *namespace* is a mapping from names to objects. Most namespaces are "
|
|
"currently implemented as Python dictionaries, but that's normally not "
|
|
"noticeable in any way (except for performance), and it may change in the "
|
|
"future. Examples of namespaces are: the set of built-in names (containing "
|
|
"functions such as :func:`abs`, and built-in exception names); the global "
|
|
"names in a module; and the local names in a function invocation. In a sense "
|
|
"the set of attributes of an object also form a namespace. The important "
|
|
"thing to know about namespaces is that there is absolutely no relation "
|
|
"between names in different namespaces; for instance, two different modules "
|
|
"may both define a function ``maximize`` without confusion --- users of the "
|
|
"modules must prefix it with the module name."
|
|
msgstr ""
|
|
|
|
#: ../Doc/tutorial/classes.rst:76
|
|
msgid ""
|
|
"By the way, I use the word *attribute* for any name following a dot --- for "
|
|
"example, in the expression ``z.real``, ``real`` is an attribute of the "
|
|
"object ``z``. Strictly speaking, references to names in modules are "
|
|
"attribute references: in the expression ``modname.funcname``, ``modname`` is "
|
|
"a module object and ``funcname`` is an attribute of it. In this case there "
|
|
"happens to be a straightforward mapping between the module's attributes and "
|
|
"the global names defined in the module: they share the same namespace! [#]_"
|
|
msgstr ""
|
|
|
|
#: ../Doc/tutorial/classes.rst:84
|
|
msgid ""
|
|
"Attributes may be read-only or writable. In the latter case, assignment to "
|
|
"attributes is possible. Module attributes are writable: you can write "
|
|
"``modname.the_answer = 42``. Writable attributes may also be deleted with "
|
|
"the :keyword:`del` statement. For example, ``del modname.the_answer`` will "
|
|
"remove the attribute :attr:`the_answer` from the object named by ``modname``."
|
|
msgstr ""
|
|
|
|
#: ../Doc/tutorial/classes.rst:90
|
|
msgid ""
|
|
"Namespaces are created at different moments and have different lifetimes. "
|
|
"The namespace containing the built-in names is created when the Python "
|
|
"interpreter starts up, and is never deleted. The global namespace for a "
|
|
"module is created when the module definition is read in; normally, module "
|
|
"namespaces also last until the interpreter quits. The statements executed "
|
|
"by the top-level invocation of the interpreter, either read from a script "
|
|
"file or interactively, are considered part of a module called :mod:"
|
|
"`__main__`, so they have their own global namespace. (The built-in names "
|
|
"actually also live in a module; this is called :mod:`builtins`.)"
|
|
msgstr ""
|
|
|
|
#: ../Doc/tutorial/classes.rst:100
|
|
msgid ""
|
|
"The local namespace for a function is created when the function is called, "
|
|
"and deleted when the function returns or raises an exception that is not "
|
|
"handled within the function. (Actually, forgetting would be a better way to "
|
|
"describe what actually happens.) Of course, recursive invocations each have "
|
|
"their own local namespace."
|
|
msgstr ""
|
|
|
|
#: ../Doc/tutorial/classes.rst:106
|
|
msgid ""
|
|
"A *scope* is a textual region of a Python program where a namespace is "
|
|
"directly accessible. \"Directly accessible\" here means that an unqualified "
|
|
"reference to a name attempts to find the name in the namespace."
|
|
msgstr ""
|
|
|
|
#: ../Doc/tutorial/classes.rst:110
|
|
msgid ""
|
|
"Although scopes are determined statically, they are used dynamically. At any "
|
|
"time during execution, there are at least three nested scopes whose "
|
|
"namespaces are directly accessible:"
|
|
msgstr ""
|
|
|
|
#: ../Doc/tutorial/classes.rst:114
|
|
msgid "the innermost scope, which is searched first, contains the local names"
|
|
msgstr ""
|
|
|
|
#: ../Doc/tutorial/classes.rst:115
|
|
msgid ""
|
|
"the scopes of any enclosing functions, which are searched starting with the "
|
|
"nearest enclosing scope, contains non-local, but also non-global names"
|
|
msgstr ""
|
|
|
|
#: ../Doc/tutorial/classes.rst:117
|
|
msgid "the next-to-last scope contains the current module's global names"
|
|
msgstr ""
|
|
|
|
#: ../Doc/tutorial/classes.rst:118
|
|
msgid ""
|
|
"the outermost scope (searched last) is the namespace containing built-in "
|
|
"names"
|
|
msgstr ""
|
|
|
|
#: ../Doc/tutorial/classes.rst:120
|
|
msgid ""
|
|
"If a name is declared global, then all references and assignments go "
|
|
"directly to the middle scope containing the module's global names. To "
|
|
"rebind variables found outside of the innermost scope, the :keyword:"
|
|
"`nonlocal` statement can be used; if not declared nonlocal, those variables "
|
|
"are read-only (an attempt to write to such a variable will simply create a "
|
|
"*new* local variable in the innermost scope, leaving the identically named "
|
|
"outer variable unchanged)."
|
|
msgstr ""
|
|
|
|
#: ../Doc/tutorial/classes.rst:127
|
|
msgid ""
|
|
"Usually, the local scope references the local names of the (textually) "
|
|
"current function. Outside functions, the local scope references the same "
|
|
"namespace as the global scope: the module's namespace. Class definitions "
|
|
"place yet another namespace in the local scope."
|
|
msgstr ""
|
|
|
|
#: ../Doc/tutorial/classes.rst:132
|
|
msgid ""
|
|
"It is important to realize that scopes are determined textually: the global "
|
|
"scope of a function defined in a module is that module's namespace, no "
|
|
"matter from where or by what alias the function is called. On the other "
|
|
"hand, the actual search for names is done dynamically, at run time --- "
|
|
"however, the language definition is evolving towards static name resolution, "
|
|
"at \"compile\" time, so don't rely on dynamic name resolution! (In fact, "
|
|
"local variables are already determined statically.)"
|
|
msgstr ""
|
|
|
|
#: ../Doc/tutorial/classes.rst:140
|
|
msgid ""
|
|
"A special quirk of Python is that -- if no :keyword:`global` statement is in "
|
|
"effect -- assignments to names always go into the innermost scope. "
|
|
"Assignments do not copy data --- they just bind names to objects. The same "
|
|
"is true for deletions: the statement ``del x`` removes the binding of ``x`` "
|
|
"from the namespace referenced by the local scope. In fact, all operations "
|
|
"that introduce new names use the local scope: in particular, :keyword:"
|
|
"`import` statements and function definitions bind the module or function "
|
|
"name in the local scope."
|
|
msgstr ""
|
|
|
|
#: ../Doc/tutorial/classes.rst:148
|
|
msgid ""
|
|
"The :keyword:`global` statement can be used to indicate that particular "
|
|
"variables live in the global scope and should be rebound there; the :keyword:"
|
|
"`nonlocal` statement indicates that particular variables live in an "
|
|
"enclosing scope and should be rebound there."
|
|
msgstr ""
|
|
|
|
#: ../Doc/tutorial/classes.rst:156
|
|
msgid "Scopes and Namespaces Example"
|
|
msgstr ""
|
|
|
|
#: ../Doc/tutorial/classes.rst:158
|
|
msgid ""
|
|
"This is an example demonstrating how to reference the different scopes and "
|
|
"namespaces, and how :keyword:`global` and :keyword:`nonlocal` affect "
|
|
"variable binding::"
|
|
msgstr ""
|
|
|
|
#: ../Doc/tutorial/classes.rst:185
|
|
msgid "The output of the example code is:"
|
|
msgstr ""
|
|
|
|
#: ../Doc/tutorial/classes.rst:194
|
|
msgid ""
|
|
"Note how the *local* assignment (which is default) didn't change *scope_test*"
|
|
"\\'s binding of *spam*. The :keyword:`nonlocal` assignment changed "
|
|
"*scope_test*\\'s binding of *spam*, and the :keyword:`global` assignment "
|
|
"changed the module-level binding."
|
|
msgstr ""
|
|
|
|
#: ../Doc/tutorial/classes.rst:199
|
|
msgid ""
|
|
"You can also see that there was no previous binding for *spam* before the :"
|
|
"keyword:`global` assignment."
|
|
msgstr ""
|
|
|
|
#: ../Doc/tutorial/classes.rst:206
|
|
msgid "A First Look at Classes"
|
|
msgstr ""
|
|
|
|
#: ../Doc/tutorial/classes.rst:208
|
|
msgid ""
|
|
"Classes introduce a little bit of new syntax, three new object types, and "
|
|
"some new semantics."
|
|
msgstr ""
|
|
|
|
#: ../Doc/tutorial/classes.rst:215
|
|
msgid "Class Definition Syntax"
|
|
msgstr ""
|
|
|
|
#: ../Doc/tutorial/classes.rst:217
|
|
msgid "The simplest form of class definition looks like this::"
|
|
msgstr ""
|
|
|
|
#: ../Doc/tutorial/classes.rst:226
|
|
msgid ""
|
|
"Class definitions, like function definitions (:keyword:`def` statements) "
|
|
"must be executed before they have any effect. (You could conceivably place "
|
|
"a class definition in a branch of an :keyword:`if` statement, or inside a "
|
|
"function.)"
|
|
msgstr ""
|
|
|
|
#: ../Doc/tutorial/classes.rst:230
|
|
msgid ""
|
|
"In practice, the statements inside a class definition will usually be "
|
|
"function definitions, but other statements are allowed, and sometimes useful "
|
|
"--- we'll come back to this later. The function definitions inside a class "
|
|
"normally have a peculiar form of argument list, dictated by the calling "
|
|
"conventions for methods --- again, this is explained later."
|
|
msgstr ""
|
|
|
|
#: ../Doc/tutorial/classes.rst:236
|
|
msgid ""
|
|
"When a class definition is entered, a new namespace is created, and used as "
|
|
"the local scope --- thus, all assignments to local variables go into this "
|
|
"new namespace. In particular, function definitions bind the name of the new "
|
|
"function here."
|
|
msgstr ""
|
|
|
|
#: ../Doc/tutorial/classes.rst:241
|
|
msgid ""
|
|
"When a class definition is left normally (via the end), a *class object* is "
|
|
"created. This is basically a wrapper around the contents of the namespace "
|
|
"created by the class definition; we'll learn more about class objects in the "
|
|
"next section. The original local scope (the one in effect just before the "
|
|
"class definition was entered) is reinstated, and the class object is bound "
|
|
"here to the class name given in the class definition header (:class:"
|
|
"`ClassName` in the example)."
|
|
msgstr ""
|
|
|
|
#: ../Doc/tutorial/classes.rst:253
|
|
msgid "Class Objects"
|
|
msgstr ""
|
|
|
|
#: ../Doc/tutorial/classes.rst:255
|
|
msgid ""
|
|
"Class objects support two kinds of operations: attribute references and "
|
|
"instantiation."
|
|
msgstr ""
|
|
|
|
#: ../Doc/tutorial/classes.rst:258
|
|
msgid ""
|
|
"*Attribute references* use the standard syntax used for all attribute "
|
|
"references in Python: ``obj.name``. Valid attribute names are all the names "
|
|
"that were in the class's namespace when the class object was created. So, "
|
|
"if the class definition looked like this::"
|
|
msgstr ""
|
|
|
|
#: ../Doc/tutorial/classes.rst:270
|
|
msgid ""
|
|
"then ``MyClass.i`` and ``MyClass.f`` are valid attribute references, "
|
|
"returning an integer and a function object, respectively. Class attributes "
|
|
"can also be assigned to, so you can change the value of ``MyClass.i`` by "
|
|
"assignment. :attr:`__doc__` is also a valid attribute, returning the "
|
|
"docstring belonging to the class: ``\"A simple example class\"``."
|
|
msgstr ""
|
|
|
|
#: ../Doc/tutorial/classes.rst:276
|
|
msgid ""
|
|
"Class *instantiation* uses function notation. Just pretend that the class "
|
|
"object is a parameterless function that returns a new instance of the class. "
|
|
"For example (assuming the above class)::"
|
|
msgstr ""
|
|
|
|
#: ../Doc/tutorial/classes.rst:282
|
|
msgid ""
|
|
"creates a new *instance* of the class and assigns this object to the local "
|
|
"variable ``x``."
|
|
msgstr ""
|
|
|
|
#: ../Doc/tutorial/classes.rst:285
|
|
msgid ""
|
|
"The instantiation operation (\"calling\" a class object) creates an empty "
|
|
"object. Many classes like to create objects with instances customized to a "
|
|
"specific initial state. Therefore a class may define a special method named :"
|
|
"meth:`__init__`, like this::"
|
|
msgstr ""
|
|
|
|
#: ../Doc/tutorial/classes.rst:293
|
|
msgid ""
|
|
"When a class defines an :meth:`__init__` method, class instantiation "
|
|
"automatically invokes :meth:`__init__` for the newly-created class "
|
|
"instance. So in this example, a new, initialized instance can be obtained "
|
|
"by::"
|
|
msgstr ""
|
|
|
|
#: ../Doc/tutorial/classes.rst:299
|
|
msgid ""
|
|
"Of course, the :meth:`__init__` method may have arguments for greater "
|
|
"flexibility. In that case, arguments given to the class instantiation "
|
|
"operator are passed on to :meth:`__init__`. For example, ::"
|
|
msgstr ""
|
|
|
|
#: ../Doc/tutorial/classes.rst:316
|
|
msgid "Instance Objects"
|
|
msgstr ""
|
|
|
|
#: ../Doc/tutorial/classes.rst:318
|
|
msgid ""
|
|
"Now what can we do with instance objects? The only operations understood by "
|
|
"instance objects are attribute references. There are two kinds of valid "
|
|
"attribute names, data attributes and methods."
|
|
msgstr ""
|
|
|
|
#: ../Doc/tutorial/classes.rst:322
|
|
msgid ""
|
|
"*data attributes* correspond to \"instance variables\" in Smalltalk, and to "
|
|
"\"data members\" in C++. Data attributes need not be declared; like local "
|
|
"variables, they spring into existence when they are first assigned to. For "
|
|
"example, if ``x`` is the instance of :class:`MyClass` created above, the "
|
|
"following piece of code will print the value ``16``, without leaving a "
|
|
"trace::"
|
|
msgstr ""
|
|
|
|
#: ../Doc/tutorial/classes.rst:334
|
|
msgid ""
|
|
"The other kind of instance attribute reference is a *method*. A method is a "
|
|
"function that \"belongs to\" an object. (In Python, the term method is not "
|
|
"unique to class instances: other object types can have methods as well. For "
|
|
"example, list objects have methods called append, insert, remove, sort, and "
|
|
"so on. However, in the following discussion, we'll use the term method "
|
|
"exclusively to mean methods of class instance objects, unless explicitly "
|
|
"stated otherwise.)"
|
|
msgstr ""
|
|
|
|
#: ../Doc/tutorial/classes.rst:343
|
|
msgid ""
|
|
"Valid method names of an instance object depend on its class. By "
|
|
"definition, all attributes of a class that are function objects define "
|
|
"corresponding methods of its instances. So in our example, ``x.f`` is a "
|
|
"valid method reference, since ``MyClass.f`` is a function, but ``x.i`` is "
|
|
"not, since ``MyClass.i`` is not. But ``x.f`` is not the same thing as "
|
|
"``MyClass.f`` --- it is a *method object*, not a function object."
|
|
msgstr ""
|
|
|
|
#: ../Doc/tutorial/classes.rst:354
|
|
msgid "Method Objects"
|
|
msgstr ""
|
|
|
|
#: ../Doc/tutorial/classes.rst:356
|
|
msgid "Usually, a method is called right after it is bound::"
|
|
msgstr ""
|
|
|
|
#: ../Doc/tutorial/classes.rst:360
|
|
msgid ""
|
|
"In the :class:`MyClass` example, this will return the string ``'hello "
|
|
"world'``. However, it is not necessary to call a method right away: ``x.f`` "
|
|
"is a method object, and can be stored away and called at a later time. For "
|
|
"example::"
|
|
msgstr ""
|
|
|
|
#: ../Doc/tutorial/classes.rst:368
|
|
msgid "will continue to print ``hello world`` until the end of time."
|
|
msgstr ""
|
|
|
|
#: ../Doc/tutorial/classes.rst:370
|
|
msgid ""
|
|
"What exactly happens when a method is called? You may have noticed that ``x."
|
|
"f()`` was called without an argument above, even though the function "
|
|
"definition for :meth:`f` specified an argument. What happened to the "
|
|
"argument? Surely Python raises an exception when a function that requires an "
|
|
"argument is called without any --- even if the argument isn't actually "
|
|
"used..."
|
|
msgstr ""
|
|
|
|
#: ../Doc/tutorial/classes.rst:376
|
|
msgid ""
|
|
"Actually, you may have guessed the answer: the special thing about methods "
|
|
"is that the object is passed as the first argument of the function. In our "
|
|
"example, the call ``x.f()`` is exactly equivalent to ``MyClass.f(x)``. In "
|
|
"general, calling a method with a list of *n* arguments is equivalent to "
|
|
"calling the corresponding function with an argument list that is created by "
|
|
"inserting the method's object before the first argument."
|
|
msgstr ""
|
|
|
|
#: ../Doc/tutorial/classes.rst:383
|
|
msgid ""
|
|
"If you still don't understand how methods work, a look at the implementation "
|
|
"can perhaps clarify matters. When an instance attribute is referenced that "
|
|
"isn't a data attribute, its class is searched. If the name denotes a valid "
|
|
"class attribute that is a function object, a method object is created by "
|
|
"packing (pointers to) the instance object and the function object just found "
|
|
"together in an abstract object: this is the method object. When the method "
|
|
"object is called with an argument list, a new argument list is constructed "
|
|
"from the instance object and the argument list, and the function object is "
|
|
"called with this new argument list."
|
|
msgstr ""
|
|
|
|
#: ../Doc/tutorial/classes.rst:397
|
|
msgid "Class and Instance Variables"
|
|
msgstr ""
|
|
|
|
#: ../Doc/tutorial/classes.rst:399
|
|
msgid ""
|
|
"Generally speaking, instance variables are for data unique to each instance "
|
|
"and class variables are for attributes and methods shared by all instances "
|
|
"of the class::"
|
|
msgstr ""
|
|
|
|
#: ../Doc/tutorial/classes.rst:421
|
|
msgid ""
|
|
"As discussed in :ref:`tut-object`, shared data can have possibly surprising "
|
|
"effects with involving :term:`mutable` objects such as lists and "
|
|
"dictionaries. For example, the *tricks* list in the following code should "
|
|
"not be used as a class variable because just a single list would be shared "
|
|
"by all *Dog* instances::"
|
|
msgstr ""
|
|
|
|
#: ../Doc/tutorial/classes.rst:444
|
|
msgid "Correct design of the class should use an instance variable instead::"
|
|
msgstr ""
|
|
|
|
#: ../Doc/tutorial/classes.rst:468
|
|
msgid "Random Remarks"
|
|
msgstr ""
|
|
|
|
#: ../Doc/tutorial/classes.rst:472
|
|
msgid ""
|
|
"Data attributes override method attributes with the same name; to avoid "
|
|
"accidental name conflicts, which may cause hard-to-find bugs in large "
|
|
"programs, it is wise to use some kind of convention that minimizes the "
|
|
"chance of conflicts. Possible conventions include capitalizing method "
|
|
"names, prefixing data attribute names with a small unique string (perhaps "
|
|
"just an underscore), or using verbs for methods and nouns for data "
|
|
"attributes."
|
|
msgstr ""
|
|
|
|
#: ../Doc/tutorial/classes.rst:479
|
|
msgid ""
|
|
"Data attributes may be referenced by methods as well as by ordinary users "
|
|
"(\"clients\") of an object. In other words, classes are not usable to "
|
|
"implement pure abstract data types. In fact, nothing in Python makes it "
|
|
"possible to enforce data hiding --- it is all based upon convention. (On "
|
|
"the other hand, the Python implementation, written in C, can completely hide "
|
|
"implementation details and control access to an object if necessary; this "
|
|
"can be used by extensions to Python written in C.)"
|
|
msgstr ""
|
|
|
|
#: ../Doc/tutorial/classes.rst:487
|
|
msgid ""
|
|
"Clients should use data attributes with care --- clients may mess up "
|
|
"invariants maintained by the methods by stamping on their data attributes. "
|
|
"Note that clients may add data attributes of their own to an instance object "
|
|
"without affecting the validity of the methods, as long as name conflicts are "
|
|
"avoided --- again, a naming convention can save a lot of headaches here."
|
|
msgstr ""
|
|
|
|
#: ../Doc/tutorial/classes.rst:493
|
|
msgid ""
|
|
"There is no shorthand for referencing data attributes (or other methods!) "
|
|
"from within methods. I find that this actually increases the readability of "
|
|
"methods: there is no chance of confusing local variables and instance "
|
|
"variables when glancing through a method."
|
|
msgstr ""
|
|
|
|
#: ../Doc/tutorial/classes.rst:498
|
|
msgid ""
|
|
"Often, the first argument of a method is called ``self``. This is nothing "
|
|
"more than a convention: the name ``self`` has absolutely no special meaning "
|
|
"to Python. Note, however, that by not following the convention your code "
|
|
"may be less readable to other Python programmers, and it is also conceivable "
|
|
"that a *class browser* program might be written that relies upon such a "
|
|
"convention."
|
|
msgstr ""
|
|
|
|
#: ../Doc/tutorial/classes.rst:504
|
|
msgid ""
|
|
"Any function object that is a class attribute defines a method for instances "
|
|
"of that class. It is not necessary that the function definition is "
|
|
"textually enclosed in the class definition: assigning a function object to a "
|
|
"local variable in the class is also ok. For example::"
|
|
msgstr ""
|
|
|
|
#: ../Doc/tutorial/classes.rst:521
|
|
msgid ""
|
|
"Now ``f``, ``g`` and ``h`` are all attributes of class :class:`C` that refer "
|
|
"to function objects, and consequently they are all methods of instances of :"
|
|
"class:`C` --- ``h`` being exactly equivalent to ``g``. Note that this "
|
|
"practice usually only serves to confuse the reader of a program."
|
|
msgstr ""
|
|
|
|
#: ../Doc/tutorial/classes.rst:526
|
|
msgid ""
|
|
"Methods may call other methods by using method attributes of the ``self`` "
|
|
"argument::"
|
|
msgstr ""
|
|
|
|
#: ../Doc/tutorial/classes.rst:540
|
|
msgid ""
|
|
"Methods may reference global names in the same way as ordinary functions. "
|
|
"The global scope associated with a method is the module containing its "
|
|
"definition. (A class is never used as a global scope.) While one rarely "
|
|
"encounters a good reason for using global data in a method, there are many "
|
|
"legitimate uses of the global scope: for one thing, functions and modules "
|
|
"imported into the global scope can be used by methods, as well as functions "
|
|
"and classes defined in it. Usually, the class containing the method is "
|
|
"itself defined in this global scope, and in the next section we'll find some "
|
|
"good reasons why a method would want to reference its own class."
|
|
msgstr ""
|
|
|
|
#: ../Doc/tutorial/classes.rst:550
|
|
msgid ""
|
|
"Each value is an object, and therefore has a *class* (also called its "
|
|
"*type*). It is stored as ``object.__class__``."
|
|
msgstr ""
|
|
|
|
#: ../Doc/tutorial/classes.rst:557
|
|
msgid "Inheritance"
|
|
msgstr ""
|
|
|
|
#: ../Doc/tutorial/classes.rst:559
|
|
msgid ""
|
|
"Of course, a language feature would not be worthy of the name \"class\" "
|
|
"without supporting inheritance. The syntax for a derived class definition "
|
|
"looks like this::"
|
|
msgstr ""
|
|
|
|
#: ../Doc/tutorial/classes.rst:570
|
|
msgid ""
|
|
"The name :class:`BaseClassName` must be defined in a scope containing the "
|
|
"derived class definition. In place of a base class name, other arbitrary "
|
|
"expressions are also allowed. This can be useful, for example, when the "
|
|
"base class is defined in another module::"
|
|
msgstr ""
|
|
|
|
#: ../Doc/tutorial/classes.rst:577
|
|
msgid ""
|
|
"Execution of a derived class definition proceeds the same as for a base "
|
|
"class. When the class object is constructed, the base class is remembered. "
|
|
"This is used for resolving attribute references: if a requested attribute is "
|
|
"not found in the class, the search proceeds to look in the base class. This "
|
|
"rule is applied recursively if the base class itself is derived from some "
|
|
"other class."
|
|
msgstr ""
|
|
|
|
#: ../Doc/tutorial/classes.rst:583
|
|
msgid ""
|
|
"There's nothing special about instantiation of derived classes: "
|
|
"``DerivedClassName()`` creates a new instance of the class. Method "
|
|
"references are resolved as follows: the corresponding class attribute is "
|
|
"searched, descending down the chain of base classes if necessary, and the "
|
|
"method reference is valid if this yields a function object."
|
|
msgstr ""
|
|
|
|
#: ../Doc/tutorial/classes.rst:589
|
|
msgid ""
|
|
"Derived classes may override methods of their base classes. Because methods "
|
|
"have no special privileges when calling other methods of the same object, a "
|
|
"method of a base class that calls another method defined in the same base "
|
|
"class may end up calling a method of a derived class that overrides it. "
|
|
"(For C++ programmers: all methods in Python are effectively ``virtual``.)"
|
|
msgstr ""
|
|
|
|
#: ../Doc/tutorial/classes.rst:595
|
|
msgid ""
|
|
"An overriding method in a derived class may in fact want to extend rather "
|
|
"than simply replace the base class method of the same name. There is a "
|
|
"simple way to call the base class method directly: just call ``BaseClassName."
|
|
"methodname(self, arguments)``. This is occasionally useful to clients as "
|
|
"well. (Note that this only works if the base class is accessible as "
|
|
"``BaseClassName`` in the global scope.)"
|
|
msgstr ""
|
|
|
|
#: ../Doc/tutorial/classes.rst:602
|
|
msgid "Python has two built-in functions that work with inheritance:"
|
|
msgstr ""
|
|
|
|
#: ../Doc/tutorial/classes.rst:604
|
|
msgid ""
|
|
"Use :func:`isinstance` to check an instance's type: ``isinstance(obj, int)`` "
|
|
"will be ``True`` only if ``obj.__class__`` is :class:`int` or some class "
|
|
"derived from :class:`int`."
|
|
msgstr ""
|
|
|
|
#: ../Doc/tutorial/classes.rst:608
|
|
msgid ""
|
|
"Use :func:`issubclass` to check class inheritance: ``issubclass(bool, int)`` "
|
|
"is ``True`` since :class:`bool` is a subclass of :class:`int`. However, "
|
|
"``issubclass(float, int)`` is ``False`` since :class:`float` is not a "
|
|
"subclass of :class:`int`."
|
|
msgstr ""
|
|
|
|
#: ../Doc/tutorial/classes.rst:618
|
|
msgid "Multiple Inheritance"
|
|
msgstr ""
|
|
|
|
#: ../Doc/tutorial/classes.rst:620
|
|
msgid ""
|
|
"Python supports a form of multiple inheritance as well. A class definition "
|
|
"with multiple base classes looks like this::"
|
|
msgstr ""
|
|
|
|
#: ../Doc/tutorial/classes.rst:630
|
|
msgid ""
|
|
"For most purposes, in the simplest cases, you can think of the search for "
|
|
"attributes inherited from a parent class as depth-first, left-to-right, not "
|
|
"searching twice in the same class where there is an overlap in the "
|
|
"hierarchy. Thus, if an attribute is not found in :class:`DerivedClassName`, "
|
|
"it is searched for in :class:`Base1`, then (recursively) in the base classes "
|
|
"of :class:`Base1`, and if it was not found there, it was searched for in :"
|
|
"class:`Base2`, and so on."
|
|
msgstr ""
|
|
|
|
#: ../Doc/tutorial/classes.rst:637
|
|
msgid ""
|
|
"In fact, it is slightly more complex than that; the method resolution order "
|
|
"changes dynamically to support cooperative calls to :func:`super`. This "
|
|
"approach is known in some other multiple-inheritance languages as call-next-"
|
|
"method and is more powerful than the super call found in single-inheritance "
|
|
"languages."
|
|
msgstr ""
|
|
|
|
#: ../Doc/tutorial/classes.rst:643
|
|
msgid ""
|
|
"Dynamic ordering is necessary because all cases of multiple inheritance "
|
|
"exhibit one or more diamond relationships (where at least one of the parent "
|
|
"classes can be accessed through multiple paths from the bottommost class). "
|
|
"For example, all classes inherit from :class:`object`, so any case of "
|
|
"multiple inheritance provides more than one path to reach :class:`object`. "
|
|
"To keep the base classes from being accessed more than once, the dynamic "
|
|
"algorithm linearizes the search order in a way that preserves the left-to-"
|
|
"right ordering specified in each class, that calls each parent only once, "
|
|
"and that is monotonic (meaning that a class can be subclassed without "
|
|
"affecting the precedence order of its parents). Taken together, these "
|
|
"properties make it possible to design reliable and extensible classes with "
|
|
"multiple inheritance. For more detail, see https://www.python.org/download/"
|
|
"releases/2.3/mro/."
|
|
msgstr ""
|
|
|
|
#: ../Doc/tutorial/classes.rst:660
|
|
msgid "Private Variables"
|
|
msgstr ""
|
|
|
|
#: ../Doc/tutorial/classes.rst:662
|
|
msgid ""
|
|
"\"Private\" instance variables that cannot be accessed except from inside an "
|
|
"object don't exist in Python. However, there is a convention that is "
|
|
"followed by most Python code: a name prefixed with an underscore (e.g. "
|
|
"``_spam``) should be treated as a non-public part of the API (whether it is "
|
|
"a function, a method or a data member). It should be considered an "
|
|
"implementation detail and subject to change without notice."
|
|
msgstr ""
|
|
|
|
#: ../Doc/tutorial/classes.rst:669
|
|
msgid ""
|
|
"Since there is a valid use-case for class-private members (namely to avoid "
|
|
"name clashes of names with names defined by subclasses), there is limited "
|
|
"support for such a mechanism, called :dfn:`name mangling`. Any identifier "
|
|
"of the form ``__spam`` (at least two leading underscores, at most one "
|
|
"trailing underscore) is textually replaced with ``_classname__spam``, where "
|
|
"``classname`` is the current class name with leading underscore(s) "
|
|
"stripped. This mangling is done without regard to the syntactic position of "
|
|
"the identifier, as long as it occurs within the definition of a class."
|
|
msgstr ""
|
|
|
|
#: ../Doc/tutorial/classes.rst:678
|
|
msgid ""
|
|
"Name mangling is helpful for letting subclasses override methods without "
|
|
"breaking intraclass method calls. For example::"
|
|
msgstr ""
|
|
|
|
#: ../Doc/tutorial/classes.rst:700
|
|
msgid ""
|
|
"Note that the mangling rules are designed mostly to avoid accidents; it "
|
|
"still is possible to access or modify a variable that is considered "
|
|
"private. This can even be useful in special circumstances, such as in the "
|
|
"debugger."
|
|
msgstr ""
|
|
|
|
#: ../Doc/tutorial/classes.rst:704
|
|
msgid ""
|
|
"Notice that code passed to ``exec()`` or ``eval()`` does not consider the "
|
|
"classname of the invoking class to be the current class; this is similar to "
|
|
"the effect of the ``global`` statement, the effect of which is likewise "
|
|
"restricted to code that is byte-compiled together. The same restriction "
|
|
"applies to ``getattr()``, ``setattr()`` and ``delattr()``, as well as when "
|
|
"referencing ``__dict__`` directly."
|
|
msgstr ""
|
|
|
|
#: ../Doc/tutorial/classes.rst:715
|
|
msgid "Odds and Ends"
|
|
msgstr ""
|
|
|
|
#: ../Doc/tutorial/classes.rst:717
|
|
msgid ""
|
|
"Sometimes it is useful to have a data type similar to the Pascal \"record\" "
|
|
"or C \"struct\", bundling together a few named data items. An empty class "
|
|
"definition will do nicely::"
|
|
msgstr ""
|
|
|
|
#: ../Doc/tutorial/classes.rst:731
|
|
msgid ""
|
|
"A piece of Python code that expects a particular abstract data type can "
|
|
"often be passed a class that emulates the methods of that data type "
|
|
"instead. For instance, if you have a function that formats some data from a "
|
|
"file object, you can define a class with methods :meth:`read` and :meth:`!"
|
|
"readline` that get the data from a string buffer instead, and pass it as an "
|
|
"argument."
|
|
msgstr ""
|
|
|
|
#: ../Doc/tutorial/classes.rst:742
|
|
msgid ""
|
|
"Instance method objects have attributes, too: ``m.__self__`` is the instance "
|
|
"object with the method :meth:`m`, and ``m.__func__`` is the function object "
|
|
"corresponding to the method."
|
|
msgstr ""
|
|
|
|
#: ../Doc/tutorial/classes.rst:750
|
|
msgid "Exceptions Are Classes Too"
|
|
msgstr ""
|
|
|
|
#: ../Doc/tutorial/classes.rst:752
|
|
msgid ""
|
|
"User-defined exceptions are identified by classes as well. Using this "
|
|
"mechanism it is possible to create extensible hierarchies of exceptions."
|
|
msgstr ""
|
|
|
|
#: ../Doc/tutorial/classes.rst:755
|
|
msgid ""
|
|
"There are two new valid (semantic) forms for the :keyword:`raise` statement::"
|
|
msgstr ""
|
|
|
|
#: ../Doc/tutorial/classes.rst:761
|
|
msgid ""
|
|
"In the first form, ``Class`` must be an instance of :class:`type` or of a "
|
|
"class derived from it. The first form is a shorthand for::"
|
|
msgstr ""
|
|
|
|
#: ../Doc/tutorial/classes.rst:766
|
|
msgid ""
|
|
"A class in an :keyword:`except` clause is compatible with an exception if it "
|
|
"is the same class or a base class thereof (but not the other way around --- "
|
|
"an except clause listing a derived class is not compatible with a base "
|
|
"class). For example, the following code will print B, C, D in that order::"
|
|
msgstr ""
|
|
|
|
#: ../Doc/tutorial/classes.rst:788
|
|
msgid ""
|
|
"Note that if the except clauses were reversed (with ``except B`` first), it "
|
|
"would have printed B, B, B --- the first matching except clause is triggered."
|
|
msgstr ""
|
|
|
|
#: ../Doc/tutorial/classes.rst:791
|
|
msgid ""
|
|
"When an error message is printed for an unhandled exception, the exception's "
|
|
"class name is printed, then a colon and a space, and finally the instance "
|
|
"converted to a string using the built-in function :func:`str`."
|
|
msgstr ""
|
|
|
|
#: ../Doc/tutorial/classes.rst:799
|
|
msgid "Iterators"
|
|
msgstr ""
|
|
|
|
#: ../Doc/tutorial/classes.rst:801
|
|
msgid ""
|
|
"By now you have probably noticed that most container objects can be looped "
|
|
"over using a :keyword:`for` statement::"
|
|
msgstr ""
|
|
|
|
#: ../Doc/tutorial/classes.rst:815
|
|
msgid ""
|
|
"This style of access is clear, concise, and convenient. The use of "
|
|
"iterators pervades and unifies Python. Behind the scenes, the :keyword:"
|
|
"`for` statement calls :func:`iter` on the container object. The function "
|
|
"returns an iterator object that defines the method :meth:`~iterator."
|
|
"__next__` which accesses elements in the container one at a time. When "
|
|
"there are no more elements, :meth:`~iterator.__next__` raises a :exc:"
|
|
"`StopIteration` exception which tells the :keyword:`for` loop to terminate. "
|
|
"You can call the :meth:`~iterator.__next__` method using the :func:`next` "
|
|
"built-in function; this example shows how it all works::"
|
|
msgstr ""
|
|
|
|
#: ../Doc/tutorial/classes.rst:840
|
|
msgid ""
|
|
"Having seen the mechanics behind the iterator protocol, it is easy to add "
|
|
"iterator behavior to your classes. Define an :meth:`__iter__` method which "
|
|
"returns an object with a :meth:`~iterator.__next__` method. If the class "
|
|
"defines :meth:`__next__`, then :meth:`__iter__` can just return ``self``::"
|
|
msgstr ""
|
|
|
|
#: ../Doc/tutorial/classes.rst:877
|
|
msgid "Generators"
|
|
msgstr ""
|
|
|
|
#: ../Doc/tutorial/classes.rst:879
|
|
msgid ""
|
|
":term:`Generator`\\s are a simple and powerful tool for creating iterators. "
|
|
"They are written like regular functions but use the :keyword:`yield` "
|
|
"statement whenever they want to return data. Each time :func:`next` is "
|
|
"called on it, the generator resumes where it left off (it remembers all the "
|
|
"data values and which statement was last executed). An example shows that "
|
|
"generators can be trivially easy to create::"
|
|
msgstr ""
|
|
|
|
#: ../Doc/tutorial/classes.rst:900
|
|
msgid ""
|
|
"Anything that can be done with generators can also be done with class-based "
|
|
"iterators as described in the previous section. What makes generators so "
|
|
"compact is that the :meth:`__iter__` and :meth:`~generator.__next__` methods "
|
|
"are created automatically."
|
|
msgstr ""
|
|
|
|
#: ../Doc/tutorial/classes.rst:905
|
|
msgid ""
|
|
"Another key feature is that the local variables and execution state are "
|
|
"automatically saved between calls. This made the function easier to write "
|
|
"and much more clear than an approach using instance variables like ``self."
|
|
"index`` and ``self.data``."
|
|
msgstr ""
|
|
|
|
#: ../Doc/tutorial/classes.rst:910
|
|
msgid ""
|
|
"In addition to automatic method creation and saving program state, when "
|
|
"generators terminate, they automatically raise :exc:`StopIteration`. In "
|
|
"combination, these features make it easy to create iterators with no more "
|
|
"effort than writing a regular function."
|
|
msgstr ""
|
|
|
|
#: ../Doc/tutorial/classes.rst:919
|
|
msgid "Generator Expressions"
|
|
msgstr ""
|
|
|
|
#: ../Doc/tutorial/classes.rst:921
|
|
msgid ""
|
|
"Some simple generators can be coded succinctly as expressions using a syntax "
|
|
"similar to list comprehensions but with parentheses instead of brackets. "
|
|
"These expressions are designed for situations where the generator is used "
|
|
"right away by an enclosing function. Generator expressions are more compact "
|
|
"but less versatile than full generator definitions and tend to be more "
|
|
"memory friendly than equivalent list comprehensions."
|
|
msgstr ""
|
|
|
|
#: ../Doc/tutorial/classes.rst:928
|
|
msgid "Examples::"
|
|
msgstr ""
|
|
|
|
#: ../Doc/tutorial/classes.rst:953
|
|
msgid ""
|
|
"Except for one thing. Module objects have a secret read-only attribute "
|
|
"called :attr:`~object.__dict__` which returns the dictionary used to "
|
|
"implement the module's namespace; the name :attr:`~object.__dict__` is an "
|
|
"attribute but not a global name. Obviously, using this violates the "
|
|
"abstraction of namespace implementation, and should be restricted to things "
|
|
"like post-mortem debuggers."
|
|
msgstr ""
|
|
|
|
#: ../Doc/tutorial/controlflow.rst:5
|
|
msgid "More Control Flow Tools"
|
|
msgstr ""
|
|
|
|
#: ../Doc/tutorial/controlflow.rst:7
|
|
msgid ""
|
|
"Besides the :keyword:`while` statement just introduced, Python knows the "
|
|
"usual control flow statements known from other languages, with some twists."
|
|
msgstr ""
|
|
|
|
#: ../Doc/tutorial/controlflow.rst:14
|
|
msgid ":keyword:`if` Statements"
|
|
msgstr ""
|
|
|
|
#: ../Doc/tutorial/controlflow.rst:16
|
|
msgid ""
|
|
"Perhaps the most well-known statement type is the :keyword:`if` statement. "
|
|
"For example::"
|
|
msgstr ""
|
|
|
|
#: ../Doc/tutorial/controlflow.rst:33
|
|
msgid ""
|
|
"There can be zero or more :keyword:`elif` parts, and the :keyword:`else` "
|
|
"part is optional. The keyword ':keyword:`elif`' is short for 'else if', and "
|
|
"is useful to avoid excessive indentation. An :keyword:`if` ... :keyword:"
|
|
"`elif` ... :keyword:`elif` ... sequence is a substitute for the ``switch`` "
|
|
"or ``case`` statements found in other languages."
|
|
msgstr ""
|
|
|
|
#: ../Doc/tutorial/controlflow.rst:43
|
|
msgid ":keyword:`for` Statements"
|
|
msgstr ""
|
|
|
|
#: ../Doc/tutorial/controlflow.rst:48
|
|
msgid ""
|
|
"The :keyword:`for` statement in Python differs a bit from what you may be "
|
|
"used to in C or Pascal. Rather than always iterating over an arithmetic "
|
|
"progression of numbers (like in Pascal), or giving the user the ability to "
|
|
"define both the iteration step and halting condition (as C), Python's :"
|
|
"keyword:`for` statement iterates over the items of any sequence (a list or a "
|
|
"string), in the order that they appear in the sequence. For example (no pun "
|
|
"intended):"
|
|
msgstr ""
|
|
|
|
#: ../Doc/tutorial/controlflow.rst:69
|
|
msgid ""
|
|
"If you need to modify the sequence you are iterating over while inside the "
|
|
"loop (for example to duplicate selected items), it is recommended that you "
|
|
"first make a copy. Iterating over a sequence does not implicitly make a "
|
|
"copy. The slice notation makes this especially convenient::"
|
|
msgstr ""
|
|
|
|
#: ../Doc/tutorial/controlflow.rst:81
|
|
msgid ""
|
|
"With ``for w in words:``, the example would attempt to create an infinite "
|
|
"list, inserting ``defenestrate`` over and over again."
|
|
msgstr ""
|
|
|
|
#: ../Doc/tutorial/controlflow.rst:88
|
|
msgid "The :func:`range` Function"
|
|
msgstr ""
|
|
|
|
#: ../Doc/tutorial/controlflow.rst:90
|
|
msgid ""
|
|
"If you do need to iterate over a sequence of numbers, the built-in function :"
|
|
"func:`range` comes in handy. It generates arithmetic progressions::"
|
|
msgstr ""
|
|
|
|
#: ../Doc/tutorial/controlflow.rst:102
|
|
msgid ""
|
|
"The given end point is never part of the generated sequence; ``range(10)`` "
|
|
"generates 10 values, the legal indices for items of a sequence of length "
|
|
"10. It is possible to let the range start at another number, or to specify "
|
|
"a different increment (even negative; sometimes this is called the 'step')::"
|
|
msgstr ""
|
|
|
|
#: ../Doc/tutorial/controlflow.rst:116
|
|
msgid ""
|
|
"To iterate over the indices of a sequence, you can combine :func:`range` "
|
|
"and :func:`len` as follows::"
|
|
msgstr ""
|
|
|
|
#: ../Doc/tutorial/controlflow.rst:129
|
|
msgid ""
|
|
"In most such cases, however, it is convenient to use the :func:`enumerate` "
|
|
"function, see :ref:`tut-loopidioms`."
|
|
msgstr ""
|
|
|
|
#: ../Doc/tutorial/controlflow.rst:132
|
|
msgid "A strange thing happens if you just print a range::"
|
|
msgstr ""
|
|
|
|
#: ../Doc/tutorial/controlflow.rst:137
|
|
msgid ""
|
|
"In many ways the object returned by :func:`range` behaves as if it is a "
|
|
"list, but in fact it isn't. It is an object which returns the successive "
|
|
"items of the desired sequence when you iterate over it, but it doesn't "
|
|
"really make the list, thus saving space."
|
|
msgstr ""
|
|
|
|
#: ../Doc/tutorial/controlflow.rst:142
|
|
msgid ""
|
|
"We say such an object is *iterable*, that is, suitable as a target for "
|
|
"functions and constructs that expect something from which they can obtain "
|
|
"successive items until the supply is exhausted. We have seen that the :"
|
|
"keyword:`for` statement is such an *iterator*. The function :func:`list` is "
|
|
"another; it creates lists from iterables::"
|
|
msgstr ""
|
|
|
|
#: ../Doc/tutorial/controlflow.rst:152
|
|
msgid ""
|
|
"Later we will see more functions that return iterables and take iterables as "
|
|
"argument."
|
|
msgstr ""
|
|
|
|
#: ../Doc/tutorial/controlflow.rst:158
|
|
msgid ""
|
|
":keyword:`break` and :keyword:`continue` Statements, and :keyword:`else` "
|
|
"Clauses on Loops"
|
|
msgstr ""
|
|
|
|
#: ../Doc/tutorial/controlflow.rst:160
|
|
msgid ""
|
|
"The :keyword:`break` statement, like in C, breaks out of the smallest "
|
|
"enclosing :keyword:`for` or :keyword:`while` loop."
|
|
msgstr ""
|
|
|
|
#: ../Doc/tutorial/controlflow.rst:163
|
|
msgid ""
|
|
"Loop statements may have an ``else`` clause; it is executed when the loop "
|
|
"terminates through exhaustion of the list (with :keyword:`for`) or when the "
|
|
"condition becomes false (with :keyword:`while`), but not when the loop is "
|
|
"terminated by a :keyword:`break` statement. This is exemplified by the "
|
|
"following loop, which searches for prime numbers::"
|
|
msgstr ""
|
|
|
|
#: ../Doc/tutorial/controlflow.rst:187
|
|
msgid ""
|
|
"(Yes, this is the correct code. Look closely: the ``else`` clause belongs "
|
|
"to the :keyword:`for` loop, **not** the :keyword:`if` statement.)"
|
|
msgstr ""
|
|
|
|
#: ../Doc/tutorial/controlflow.rst:190
|
|
msgid ""
|
|
"When used with a loop, the ``else`` clause has more in common with the "
|
|
"``else`` clause of a :keyword:`try` statement than it does that of :keyword:"
|
|
"`if` statements: a :keyword:`try` statement's ``else`` clause runs when no "
|
|
"exception occurs, and a loop's ``else`` clause runs when no ``break`` "
|
|
"occurs. For more on the :keyword:`try` statement and exceptions, see :ref:"
|
|
"`tut-handling`."
|
|
msgstr ""
|
|
|
|
#: ../Doc/tutorial/controlflow.rst:197
|
|
msgid ""
|
|
"The :keyword:`continue` statement, also borrowed from C, continues with the "
|
|
"next iteration of the loop::"
|
|
msgstr ""
|
|
|
|
#: ../Doc/tutorial/controlflow.rst:217
|
|
msgid ":keyword:`pass` Statements"
|
|
msgstr ""
|
|
|
|
#: ../Doc/tutorial/controlflow.rst:219
|
|
msgid ""
|
|
"The :keyword:`pass` statement does nothing. It can be used when a statement "
|
|
"is required syntactically but the program requires no action. For example::"
|
|
msgstr ""
|
|
|
|
#: ../Doc/tutorial/controlflow.rst:226
|
|
msgid "This is commonly used for creating minimal classes::"
|
|
msgstr ""
|
|
|
|
#: ../Doc/tutorial/controlflow.rst:232
|
|
msgid ""
|
|
"Another place :keyword:`pass` can be used is as a place-holder for a "
|
|
"function or conditional body when you are working on new code, allowing you "
|
|
"to keep thinking at a more abstract level. The :keyword:`pass` is silently "
|
|
"ignored::"
|
|
msgstr ""
|
|
|
|
#: ../Doc/tutorial/controlflow.rst:243
|
|
msgid "Defining Functions"
|
|
msgstr ""
|
|
|
|
#: ../Doc/tutorial/controlflow.rst:245
|
|
msgid ""
|
|
"We can create a function that writes the Fibonacci series to an arbitrary "
|
|
"boundary::"
|
|
msgstr ""
|
|
|
|
#: ../Doc/tutorial/controlflow.rst:265
|
|
msgid ""
|
|
"The keyword :keyword:`def` introduces a function *definition*. It must be "
|
|
"followed by the function name and the parenthesized list of formal "
|
|
"parameters. The statements that form the body of the function start at the "
|
|
"next line, and must be indented."
|
|
msgstr ""
|
|
|
|
#: ../Doc/tutorial/controlflow.rst:270
|
|
msgid ""
|
|
"The first statement of the function body can optionally be a string literal; "
|
|
"this string literal is the function's documentation string, or :dfn:"
|
|
"`docstring`. (More about docstrings can be found in the section :ref:`tut-"
|
|
"docstrings`.) There are tools which use docstrings to automatically produce "
|
|
"online or printed documentation, or to let the user interactively browse "
|
|
"through code; it's good practice to include docstrings in code that you "
|
|
"write, so make a habit of it."
|
|
msgstr ""
|
|
|
|
#: ../Doc/tutorial/controlflow.rst:277
|
|
msgid ""
|
|
"The *execution* of a function introduces a new symbol table used for the "
|
|
"local variables of the function. More precisely, all variable assignments "
|
|
"in a function store the value in the local symbol table; whereas variable "
|
|
"references first look in the local symbol table, then in the local symbol "
|
|
"tables of enclosing functions, then in the global symbol table, and finally "
|
|
"in the table of built-in names. Thus, global variables cannot be directly "
|
|
"assigned a value within a function (unless named in a :keyword:`global` "
|
|
"statement), although they may be referenced."
|
|
msgstr ""
|
|
|
|
#: ../Doc/tutorial/controlflow.rst:286
|
|
msgid ""
|
|
"The actual parameters (arguments) to a function call are introduced in the "
|
|
"local symbol table of the called function when it is called; thus, arguments "
|
|
"are passed using *call by value* (where the *value* is always an object "
|
|
"*reference*, not the value of the object). [#]_ When a function calls "
|
|
"another function, a new local symbol table is created for that call."
|
|
msgstr ""
|
|
|
|
#: ../Doc/tutorial/controlflow.rst:292
|
|
msgid ""
|
|
"A function definition introduces the function name in the current symbol "
|
|
"table. The value of the function name has a type that is recognized by the "
|
|
"interpreter as a user-defined function. This value can be assigned to "
|
|
"another name which can then also be used as a function. This serves as a "
|
|
"general renaming mechanism::"
|
|
msgstr ""
|
|
|
|
#: ../Doc/tutorial/controlflow.rst:304
|
|
msgid ""
|
|
"Coming from other languages, you might object that ``fib`` is not a function "
|
|
"but a procedure since it doesn't return a value. In fact, even functions "
|
|
"without a :keyword:`return` statement do return a value, albeit a rather "
|
|
"boring one. This value is called ``None`` (it's a built-in name). Writing "
|
|
"the value ``None`` is normally suppressed by the interpreter if it would be "
|
|
"the only value written. You can see it if you really want to using :func:"
|
|
"`print`::"
|
|
msgstr ""
|
|
|
|
#: ../Doc/tutorial/controlflow.rst:315
|
|
msgid ""
|
|
"It is simple to write a function that returns a list of the numbers of the "
|
|
"Fibonacci series, instead of printing it::"
|
|
msgstr ""
|
|
|
|
#: ../Doc/tutorial/controlflow.rst:331
|
|
msgid "This example, as usual, demonstrates some new Python features:"
|
|
msgstr ""
|
|
|
|
#: ../Doc/tutorial/controlflow.rst:333
|
|
msgid ""
|
|
"The :keyword:`return` statement returns with a value from a function. :"
|
|
"keyword:`return` without an expression argument returns ``None``. Falling "
|
|
"off the end of a function also returns ``None``."
|
|
msgstr ""
|
|
|
|
#: ../Doc/tutorial/controlflow.rst:337
|
|
msgid ""
|
|
"The statement ``result.append(a)`` calls a *method* of the list object "
|
|
"``result``. A method is a function that 'belongs' to an object and is named "
|
|
"``obj.methodname``, where ``obj`` is some object (this may be an "
|
|
"expression), and ``methodname`` is the name of a method that is defined by "
|
|
"the object's type. Different types define different methods. Methods of "
|
|
"different types may have the same name without causing ambiguity. (It is "
|
|
"possible to define your own object types and methods, using *classes*, see :"
|
|
"ref:`tut-classes`) The method :meth:`append` shown in the example is defined "
|
|
"for list objects; it adds a new element at the end of the list. In this "
|
|
"example it is equivalent to ``result = result + [a]``, but more efficient."
|
|
msgstr ""
|
|
|
|
#: ../Doc/tutorial/controlflow.rst:352
|
|
msgid "More on Defining Functions"
|
|
msgstr ""
|
|
|
|
#: ../Doc/tutorial/controlflow.rst:354
|
|
msgid ""
|
|
"It is also possible to define functions with a variable number of arguments. "
|
|
"There are three forms, which can be combined."
|
|
msgstr ""
|
|
|
|
#: ../Doc/tutorial/controlflow.rst:361
|
|
msgid "Default Argument Values"
|
|
msgstr ""
|
|
|
|
#: ../Doc/tutorial/controlflow.rst:363
|
|
msgid ""
|
|
"The most useful form is to specify a default value for one or more "
|
|
"arguments. This creates a function that can be called with fewer arguments "
|
|
"than it is defined to allow. For example::"
|
|
msgstr ""
|
|
|
|
#: ../Doc/tutorial/controlflow.rst:379
|
|
msgid "This function can be called in several ways:"
|
|
msgstr ""
|
|
|
|
#: ../Doc/tutorial/controlflow.rst:381
|
|
msgid ""
|
|
"giving only the mandatory argument: ``ask_ok('Do you really want to quit?')``"
|
|
msgstr ""
|
|
|
|
#: ../Doc/tutorial/controlflow.rst:383
|
|
msgid ""
|
|
"giving one of the optional arguments: ``ask_ok('OK to overwrite the file?', "
|
|
"2)``"
|
|
msgstr ""
|
|
|
|
#: ../Doc/tutorial/controlflow.rst:385
|
|
msgid ""
|
|
"or even giving all arguments: ``ask_ok('OK to overwrite the file?', 2, 'Come "
|
|
"on, only yes or no!')``"
|
|
msgstr ""
|
|
|
|
#: ../Doc/tutorial/controlflow.rst:388
|
|
msgid ""
|
|
"This example also introduces the :keyword:`in` keyword. This tests whether "
|
|
"or not a sequence contains a certain value."
|
|
msgstr ""
|
|
|
|
#: ../Doc/tutorial/controlflow.rst:391
|
|
msgid ""
|
|
"The default values are evaluated at the point of function definition in the "
|
|
"*defining* scope, so that ::"
|
|
msgstr ""
|
|
|
|
#: ../Doc/tutorial/controlflow.rst:402
|
|
msgid "will print ``5``."
|
|
msgstr ""
|
|
|
|
#: ../Doc/tutorial/controlflow.rst:404
|
|
msgid ""
|
|
"**Important warning:** The default value is evaluated only once. This makes "
|
|
"a difference when the default is a mutable object such as a list, "
|
|
"dictionary, or instances of most classes. For example, the following "
|
|
"function accumulates the arguments passed to it on subsequent calls::"
|
|
msgstr ""
|
|
|
|
#: ../Doc/tutorial/controlflow.rst:417
|
|
msgid "This will print ::"
|
|
msgstr ""
|
|
|
|
#: ../Doc/tutorial/controlflow.rst:423
|
|
msgid ""
|
|
"If you don't want the default to be shared between subsequent calls, you can "
|
|
"write the function like this instead::"
|
|
msgstr ""
|
|
|
|
#: ../Doc/tutorial/controlflow.rst:436
|
|
msgid "Keyword Arguments"
|
|
msgstr ""
|
|
|
|
#: ../Doc/tutorial/controlflow.rst:438
|
|
msgid ""
|
|
"Functions can also be called using :term:`keyword arguments <keyword "
|
|
"argument>` of the form ``kwarg=value``. For instance, the following "
|
|
"function::"
|
|
msgstr ""
|
|
|
|
#: ../Doc/tutorial/controlflow.rst:447
|
|
msgid ""
|
|
"accepts one required argument (``voltage``) and three optional arguments "
|
|
"(``state``, ``action``, and ``type``). This function can be called in any "
|
|
"of the following ways::"
|
|
msgstr ""
|
|
|
|
#: ../Doc/tutorial/controlflow.rst:458
|
|
msgid "but all the following calls would be invalid::"
|
|
msgstr ""
|
|
|
|
#: ../Doc/tutorial/controlflow.rst:465
|
|
msgid ""
|
|
"In a function call, keyword arguments must follow positional arguments. All "
|
|
"the keyword arguments passed must match one of the arguments accepted by the "
|
|
"function (e.g. ``actor`` is not a valid argument for the ``parrot`` "
|
|
"function), and their order is not important. This also includes non-"
|
|
"optional arguments (e.g. ``parrot(voltage=1000)`` is valid too). No argument "
|
|
"may receive a value more than once. Here's an example that fails due to this "
|
|
"restriction::"
|
|
msgstr ""
|
|
|
|
#: ../Doc/tutorial/controlflow.rst:481
|
|
msgid ""
|
|
"When a final formal parameter of the form ``**name`` is present, it receives "
|
|
"a dictionary (see :ref:`typesmapping`) containing all keyword arguments "
|
|
"except for those corresponding to a formal parameter. This may be combined "
|
|
"with a formal parameter of the form ``*name`` (described in the next "
|
|
"subsection) which receives a tuple containing the positional arguments "
|
|
"beyond the formal parameter list. (``*name`` must occur before ``**name``.) "
|
|
"For example, if we define a function like this::"
|
|
msgstr ""
|
|
|
|
#: ../Doc/tutorial/controlflow.rst:499
|
|
msgid "It could be called like this::"
|
|
msgstr ""
|
|
|
|
#: ../Doc/tutorial/controlflow.rst:507
|
|
msgid "and of course it would print:"
|
|
msgstr ""
|
|
|
|
#: ../Doc/tutorial/controlflow.rst:520
|
|
msgid ""
|
|
"Note that the list of keyword argument names is created by sorting the "
|
|
"result of the keywords dictionary's ``keys()`` method before printing its "
|
|
"contents; if this is not done, the order in which the arguments are printed "
|
|
"is undefined."
|
|
msgstr ""
|
|
|
|
#: ../Doc/tutorial/controlflow.rst:527
|
|
msgid "Arbitrary Argument Lists"
|
|
msgstr ""
|
|
|
|
#: ../Doc/tutorial/controlflow.rst:532
|
|
msgid ""
|
|
"Finally, the least frequently used option is to specify that a function can "
|
|
"be called with an arbitrary number of arguments. These arguments will be "
|
|
"wrapped up in a tuple (see :ref:`tut-tuples`). Before the variable number "
|
|
"of arguments, zero or more normal arguments may occur. ::"
|
|
msgstr ""
|
|
|
|
#: ../Doc/tutorial/controlflow.rst:541
|
|
msgid ""
|
|
"Normally, these ``variadic`` arguments will be last in the list of formal "
|
|
"parameters, because they scoop up all remaining input arguments that are "
|
|
"passed to the function. Any formal parameters which occur after the "
|
|
"``*args`` parameter are 'keyword-only' arguments, meaning that they can only "
|
|
"be used as keywords rather than positional arguments. ::"
|
|
msgstr ""
|
|
|
|
#: ../Doc/tutorial/controlflow.rst:558
|
|
msgid "Unpacking Argument Lists"
|
|
msgstr ""
|
|
|
|
#: ../Doc/tutorial/controlflow.rst:560
|
|
msgid ""
|
|
"The reverse situation occurs when the arguments are already in a list or "
|
|
"tuple but need to be unpacked for a function call requiring separate "
|
|
"positional arguments. For instance, the built-in :func:`range` function "
|
|
"expects separate *start* and *stop* arguments. If they are not available "
|
|
"separately, write the function call with the ``*``\\ -operator to unpack "
|
|
"the arguments out of a list or tuple::"
|
|
msgstr ""
|
|
|
|
#: ../Doc/tutorial/controlflow.rst:576
|
|
msgid ""
|
|
"In the same fashion, dictionaries can deliver keyword arguments with the "
|
|
"``**``\\ -operator::"
|
|
msgstr ""
|
|
|
|
#: ../Doc/tutorial/controlflow.rst:592
|
|
msgid "Lambda Expressions"
|
|
msgstr ""
|
|
|
|
#: ../Doc/tutorial/controlflow.rst:594
|
|
msgid ""
|
|
"Small anonymous functions can be created with the :keyword:`lambda` keyword. "
|
|
"This function returns the sum of its two arguments: ``lambda a, b: a+b``. "
|
|
"Lambda functions can be used wherever function objects are required. They "
|
|
"are syntactically restricted to a single expression. Semantically, they are "
|
|
"just syntactic sugar for a normal function definition. Like nested function "
|
|
"definitions, lambda functions can reference variables from the containing "
|
|
"scope::"
|
|
msgstr ""
|
|
|
|
#: ../Doc/tutorial/controlflow.rst:611
|
|
msgid ""
|
|
"The above example uses a lambda expression to return a function. Another "
|
|
"use is to pass a small function as an argument::"
|
|
msgstr ""
|
|
|
|
#: ../Doc/tutorial/controlflow.rst:623
|
|
msgid "Documentation Strings"
|
|
msgstr ""
|
|
|
|
#: ../Doc/tutorial/controlflow.rst:630
|
|
msgid ""
|
|
"Here are some conventions about the content and formatting of documentation "
|
|
"strings."
|
|
msgstr ""
|
|
|
|
#: ../Doc/tutorial/controlflow.rst:633
|
|
msgid ""
|
|
"The first line should always be a short, concise summary of the object's "
|
|
"purpose. For brevity, it should not explicitly state the object's name or "
|
|
"type, since these are available by other means (except if the name happens "
|
|
"to be a verb describing a function's operation). This line should begin "
|
|
"with a capital letter and end with a period."
|
|
msgstr ""
|
|
|
|
#: ../Doc/tutorial/controlflow.rst:639
|
|
msgid ""
|
|
"If there are more lines in the documentation string, the second line should "
|
|
"be blank, visually separating the summary from the rest of the description. "
|
|
"The following lines should be one or more paragraphs describing the object's "
|
|
"calling conventions, its side effects, etc."
|
|
msgstr ""
|
|
|
|
#: ../Doc/tutorial/controlflow.rst:644
|
|
msgid ""
|
|
"The Python parser does not strip indentation from multi-line string literals "
|
|
"in Python, so tools that process documentation have to strip indentation if "
|
|
"desired. This is done using the following convention. The first non-blank "
|
|
"line *after* the first line of the string determines the amount of "
|
|
"indentation for the entire documentation string. (We can't use the first "
|
|
"line since it is generally adjacent to the string's opening quotes so its "
|
|
"indentation is not apparent in the string literal.) Whitespace \"equivalent"
|
|
"\" to this indentation is then stripped from the start of all lines of the "
|
|
"string. Lines that are indented less should not occur, but if they occur "
|
|
"all their leading whitespace should be stripped. Equivalence of whitespace "
|
|
"should be tested after expansion of tabs (to 8 spaces, normally)."
|
|
msgstr ""
|
|
|
|
#: ../Doc/tutorial/controlflow.rst:656
|
|
msgid "Here is an example of a multi-line docstring::"
|
|
msgstr ""
|
|
|
|
#: ../Doc/tutorial/controlflow.rst:674
|
|
msgid "Function Annotations"
|
|
msgstr ""
|
|
|
|
#: ../Doc/tutorial/controlflow.rst:681
|
|
msgid ""
|
|
":ref:`Function annotations <function>` are completely optional metadata "
|
|
"information about the types used by user-defined functions (see :pep:`484` "
|
|
"for more information)."
|
|
msgstr ""
|
|
|
|
#: ../Doc/tutorial/controlflow.rst:685
|
|
msgid ""
|
|
"Annotations are stored in the :attr:`__annotations__` attribute of the "
|
|
"function as a dictionary and have no effect on any other part of the "
|
|
"function. Parameter annotations are defined by a colon after the parameter "
|
|
"name, followed by an expression evaluating to the value of the annotation. "
|
|
"Return annotations are defined by a literal ``->``, followed by an "
|
|
"expression, between the parameter list and the colon denoting the end of "
|
|
"the :keyword:`def` statement. The following example has a positional "
|
|
"argument, a keyword argument, and the return value annotated::"
|
|
msgstr ""
|
|
|
|
#: ../Doc/tutorial/controlflow.rst:707
|
|
msgid "Intermezzo: Coding Style"
|
|
msgstr ""
|
|
|
|
#: ../Doc/tutorial/controlflow.rst:712
|
|
msgid ""
|
|
"Now that you are about to write longer, more complex pieces of Python, it is "
|
|
"a good time to talk about *coding style*. Most languages can be written (or "
|
|
"more concise, *formatted*) in different styles; some are more readable than "
|
|
"others. Making it easy for others to read your code is always a good idea, "
|
|
"and adopting a nice coding style helps tremendously for that."
|
|
msgstr ""
|
|
|
|
#: ../Doc/tutorial/controlflow.rst:718
|
|
msgid ""
|
|
"For Python, :pep:`8` has emerged as the style guide that most projects "
|
|
"adhere to; it promotes a very readable and eye-pleasing coding style. Every "
|
|
"Python developer should read it at some point; here are the most important "
|
|
"points extracted for you:"
|
|
msgstr ""
|
|
|
|
#: ../Doc/tutorial/controlflow.rst:723
|
|
msgid "Use 4-space indentation, and no tabs."
|
|
msgstr ""
|
|
|
|
#: ../Doc/tutorial/controlflow.rst:725
|
|
msgid ""
|
|
"4 spaces are a good compromise between small indentation (allows greater "
|
|
"nesting depth) and large indentation (easier to read). Tabs introduce "
|
|
"confusion, and are best left out."
|
|
msgstr ""
|
|
|
|
#: ../Doc/tutorial/controlflow.rst:729
|
|
msgid "Wrap lines so that they don't exceed 79 characters."
|
|
msgstr ""
|
|
|
|
#: ../Doc/tutorial/controlflow.rst:731
|
|
msgid ""
|
|
"This helps users with small displays and makes it possible to have several "
|
|
"code files side-by-side on larger displays."
|
|
msgstr ""
|
|
|
|
#: ../Doc/tutorial/controlflow.rst:734
|
|
msgid ""
|
|
"Use blank lines to separate functions and classes, and larger blocks of code "
|
|
"inside functions."
|
|
msgstr ""
|
|
|
|
#: ../Doc/tutorial/controlflow.rst:737
|
|
msgid "When possible, put comments on a line of their own."
|
|
msgstr ""
|
|
|
|
#: ../Doc/tutorial/controlflow.rst:739
|
|
msgid "Use docstrings."
|
|
msgstr ""
|
|
|
|
#: ../Doc/tutorial/controlflow.rst:741
|
|
msgid ""
|
|
"Use spaces around operators and after commas, but not directly inside "
|
|
"bracketing constructs: ``a = f(1, 2) + g(3, 4)``."
|
|
msgstr ""
|
|
|
|
#: ../Doc/tutorial/controlflow.rst:744
|
|
msgid ""
|
|
"Name your classes and functions consistently; the convention is to use "
|
|
"``CamelCase`` for classes and ``lower_case_with_underscores`` for functions "
|
|
"and methods. Always use ``self`` as the name for the first method argument "
|
|
"(see :ref:`tut-firstclasses` for more on classes and methods)."
|
|
msgstr ""
|
|
|
|
#: ../Doc/tutorial/controlflow.rst:749
|
|
msgid ""
|
|
"Don't use fancy encodings if your code is meant to be used in international "
|
|
"environments. Python's default, UTF-8, or even plain ASCII work best in any "
|
|
"case."
|
|
msgstr ""
|
|
|
|
#: ../Doc/tutorial/controlflow.rst:753
|
|
msgid ""
|
|
"Likewise, don't use non-ASCII characters in identifiers if there is only the "
|
|
"slightest chance people speaking a different language will read or maintain "
|
|
"the code."
|
|
msgstr ""
|
|
|
|
#: ../Doc/tutorial/controlflow.rst:760
|
|
msgid ""
|
|
"Actually, *call by object reference* would be a better description, since if "
|
|
"a mutable object is passed, the caller will see any changes the callee makes "
|
|
"to it (items inserted into a list)."
|
|
msgstr ""
|
|
|
|
#: ../Doc/tutorial/datastructures.rst:5
|
|
msgid "Data Structures"
|
|
msgstr ""
|
|
|
|
#: ../Doc/tutorial/datastructures.rst:7
|
|
msgid ""
|
|
"This chapter describes some things you've learned about already in more "
|
|
"detail, and adds some new things as well."
|
|
msgstr ""
|
|
|
|
#: ../Doc/tutorial/datastructures.rst:13
|
|
msgid "More on Lists"
|
|
msgstr ""
|
|
|
|
#: ../Doc/tutorial/datastructures.rst:15
|
|
msgid ""
|
|
"The list data type has some more methods. Here are all of the methods of "
|
|
"list objects:"
|
|
msgstr ""
|
|
|
|
#: ../Doc/tutorial/datastructures.rst:22
|
|
msgid ""
|
|
"Add an item to the end of the list. Equivalent to ``a[len(a):] = [x]``."
|
|
msgstr ""
|
|
|
|
#: ../Doc/tutorial/datastructures.rst:28
|
|
msgid ""
|
|
"Extend the list by appending all the items in the given list. Equivalent to "
|
|
"``a[len(a):] = L``."
|
|
msgstr ""
|
|
|
|
#: ../Doc/tutorial/datastructures.rst:35
|
|
msgid ""
|
|
"Insert an item at a given position. The first argument is the index of the "
|
|
"element before which to insert, so ``a.insert(0, x)`` inserts at the front "
|
|
"of the list, and ``a.insert(len(a), x)`` is equivalent to ``a.append(x)``."
|
|
msgstr ""
|
|
|
|
#: ../Doc/tutorial/datastructures.rst:43
|
|
msgid ""
|
|
"Remove the first item from the list whose value is *x*. It is an error if "
|
|
"there is no such item."
|
|
msgstr ""
|
|
|
|
#: ../Doc/tutorial/datastructures.rst:50
|
|
msgid ""
|
|
"Remove the item at the given position in the list, and return it. If no "
|
|
"index is specified, ``a.pop()`` removes and returns the last item in the "
|
|
"list. (The square brackets around the *i* in the method signature denote "
|
|
"that the parameter is optional, not that you should type square brackets at "
|
|
"that position. You will see this notation frequently in the Python Library "
|
|
"Reference.)"
|
|
msgstr ""
|
|
|
|
#: ../Doc/tutorial/datastructures.rst:60
|
|
msgid "Remove all items from the list. Equivalent to ``del a[:]``."
|
|
msgstr ""
|
|
|
|
#: ../Doc/tutorial/datastructures.rst:66
|
|
msgid ""
|
|
"Return the index in the list of the first item whose value is *x*. It is an "
|
|
"error if there is no such item."
|
|
msgstr ""
|
|
|
|
#: ../Doc/tutorial/datastructures.rst:73
|
|
msgid "Return the number of times *x* appears in the list."
|
|
msgstr ""
|
|
|
|
#: ../Doc/tutorial/datastructures.rst:79
|
|
msgid ""
|
|
"Sort the items of the list in place (the arguments can be used for sort "
|
|
"customization, see :func:`sorted` for their explanation)."
|
|
msgstr ""
|
|
|
|
#: ../Doc/tutorial/datastructures.rst:86
|
|
msgid "Reverse the elements of the list in place."
|
|
msgstr ""
|
|
|
|
#: ../Doc/tutorial/datastructures.rst:92
|
|
msgid "Return a shallow copy of the list. Equivalent to ``a[:]``."
|
|
msgstr ""
|
|
|
|
#: ../Doc/tutorial/datastructures.rst:95
|
|
msgid "An example that uses most of the list methods::"
|
|
msgstr ""
|
|
|
|
#: ../Doc/tutorial/datastructures.rst:120
|
|
msgid ""
|
|
"You might have noticed that methods like ``insert``, ``remove`` or ``sort`` "
|
|
"that only modify the list have no return value printed -- they return the "
|
|
"default ``None``. [1]_ This is a design principle for all mutable data "
|
|
"structures in Python."
|
|
msgstr ""
|
|
|
|
#: ../Doc/tutorial/datastructures.rst:129
|
|
msgid "Using Lists as Stacks"
|
|
msgstr ""
|
|
|
|
#: ../Doc/tutorial/datastructures.rst:134
|
|
msgid ""
|
|
"The list methods make it very easy to use a list as a stack, where the last "
|
|
"element added is the first element retrieved (\"last-in, first-out\"). To "
|
|
"add an item to the top of the stack, use :meth:`append`. To retrieve an "
|
|
"item from the top of the stack, use :meth:`pop` without an explicit index. "
|
|
"For example::"
|
|
msgstr ""
|
|
|
|
#: ../Doc/tutorial/datastructures.rst:159
|
|
msgid "Using Lists as Queues"
|
|
msgstr ""
|
|
|
|
#: ../Doc/tutorial/datastructures.rst:163
|
|
msgid ""
|
|
"It is also possible to use a list as a queue, where the first element added "
|
|
"is the first element retrieved (\"first-in, first-out\"); however, lists are "
|
|
"not efficient for this purpose. While appends and pops from the end of list "
|
|
"are fast, doing inserts or pops from the beginning of a list is slow "
|
|
"(because all of the other elements have to be shifted by one)."
|
|
msgstr ""
|
|
|
|
#: ../Doc/tutorial/datastructures.rst:169
|
|
msgid ""
|
|
"To implement a queue, use :class:`collections.deque` which was designed to "
|
|
"have fast appends and pops from both ends. For example::"
|
|
msgstr ""
|
|
|
|
#: ../Doc/tutorial/datastructures.rst:187
|
|
msgid "List Comprehensions"
|
|
msgstr ""
|
|
|
|
#: ../Doc/tutorial/datastructures.rst:189
|
|
msgid ""
|
|
"List comprehensions provide a concise way to create lists. Common "
|
|
"applications are to make new lists where each element is the result of some "
|
|
"operations applied to each member of another sequence or iterable, or to "
|
|
"create a subsequence of those elements that satisfy a certain condition."
|
|
msgstr ""
|
|
|
|
#: ../Doc/tutorial/datastructures.rst:194
|
|
msgid "For example, assume we want to create a list of squares, like::"
|
|
msgstr ""
|
|
|
|
#: ../Doc/tutorial/datastructures.rst:203
|
|
msgid ""
|
|
"Note that this creates (or overwrites) a variable named ``x`` that still "
|
|
"exists after the loop completes. We can calculate the list of squares "
|
|
"without any side effects using::"
|
|
msgstr ""
|
|
|
|
#: ../Doc/tutorial/datastructures.rst:209
|
|
msgid "or, equivalently::"
|
|
msgstr ""
|
|
|
|
#: ../Doc/tutorial/datastructures.rst:213
|
|
msgid "which is more concise and readable."
|
|
msgstr ""
|
|
|
|
#: ../Doc/tutorial/datastructures.rst:215
|
|
msgid ""
|
|
"A list comprehension consists of brackets containing an expression followed "
|
|
"by a :keyword:`for` clause, then zero or more :keyword:`for` or :keyword:"
|
|
"`if` clauses. The result will be a new list resulting from evaluating the "
|
|
"expression in the context of the :keyword:`for` and :keyword:`if` clauses "
|
|
"which follow it. For example, this listcomp combines the elements of two "
|
|
"lists if they are not equal::"
|
|
msgstr ""
|
|
|
|
#: ../Doc/tutorial/datastructures.rst:225
|
|
msgid "and it's equivalent to::"
|
|
msgstr ""
|
|
|
|
#: ../Doc/tutorial/datastructures.rst:236
|
|
msgid ""
|
|
"Note how the order of the :keyword:`for` and :keyword:`if` statements is the "
|
|
"same in both these snippets."
|
|
msgstr ""
|
|
|
|
#: ../Doc/tutorial/datastructures.rst:239
|
|
msgid ""
|
|
"If the expression is a tuple (e.g. the ``(x, y)`` in the previous example), "
|
|
"it must be parenthesized. ::"
|
|
msgstr ""
|
|
|
|
#: ../Doc/tutorial/datastructures.rst:270
|
|
msgid ""
|
|
"List comprehensions can contain complex expressions and nested functions::"
|
|
msgstr ""
|
|
|
|
#: ../Doc/tutorial/datastructures.rst:277
|
|
msgid "Nested List Comprehensions"
|
|
msgstr ""
|
|
|
|
#: ../Doc/tutorial/datastructures.rst:279
|
|
msgid ""
|
|
"The initial expression in a list comprehension can be any arbitrary "
|
|
"expression, including another list comprehension."
|
|
msgstr ""
|
|
|
|
#: ../Doc/tutorial/datastructures.rst:282
|
|
msgid ""
|
|
"Consider the following example of a 3x4 matrix implemented as a list of 3 "
|
|
"lists of length 4::"
|
|
msgstr ""
|
|
|
|
#: ../Doc/tutorial/datastructures.rst:291
|
|
msgid "The following list comprehension will transpose rows and columns::"
|
|
msgstr ""
|
|
|
|
#: ../Doc/tutorial/datastructures.rst:296
|
|
msgid ""
|
|
"As we saw in the previous section, the nested listcomp is evaluated in the "
|
|
"context of the :keyword:`for` that follows it, so this example is equivalent "
|
|
"to::"
|
|
msgstr ""
|
|
|
|
#: ../Doc/tutorial/datastructures.rst:307
|
|
msgid "which, in turn, is the same as::"
|
|
msgstr ""
|
|
|
|
#: ../Doc/tutorial/datastructures.rst:320
|
|
msgid ""
|
|
"In the real world, you should prefer built-in functions to complex flow "
|
|
"statements. The :func:`zip` function would do a great job for this use case::"
|
|
msgstr ""
|
|
|
|
#: ../Doc/tutorial/datastructures.rst:326
|
|
msgid ""
|
|
"See :ref:`tut-unpacking-arguments` for details on the asterisk in this line."
|
|
msgstr ""
|
|
|
|
#: ../Doc/tutorial/datastructures.rst:331
|
|
msgid "The :keyword:`del` statement"
|
|
msgstr ""
|
|
|
|
#: ../Doc/tutorial/datastructures.rst:333
|
|
msgid ""
|
|
"There is a way to remove an item from a list given its index instead of its "
|
|
"value: the :keyword:`del` statement. This differs from the :meth:`pop` "
|
|
"method which returns a value. The :keyword:`del` statement can also be used "
|
|
"to remove slices from a list or clear the entire list (which we did earlier "
|
|
"by assignment of an empty list to the slice). For example::"
|
|
msgstr ""
|
|
|
|
#: ../Doc/tutorial/datastructures.rst:350
|
|
msgid ":keyword:`del` can also be used to delete entire variables::"
|
|
msgstr ""
|
|
|
|
#: ../Doc/tutorial/datastructures.rst:354
|
|
msgid ""
|
|
"Referencing the name ``a`` hereafter is an error (at least until another "
|
|
"value is assigned to it). We'll find other uses for :keyword:`del` later."
|
|
msgstr ""
|
|
|
|
#: ../Doc/tutorial/datastructures.rst:361
|
|
msgid "Tuples and Sequences"
|
|
msgstr ""
|
|
|
|
#: ../Doc/tutorial/datastructures.rst:363
|
|
msgid ""
|
|
"We saw that lists and strings have many common properties, such as indexing "
|
|
"and slicing operations. They are two examples of *sequence* data types "
|
|
"(see :ref:`typesseq`). Since Python is an evolving language, other sequence "
|
|
"data types may be added. There is also another standard sequence data type: "
|
|
"the *tuple*."
|
|
msgstr ""
|
|
|
|
#: ../Doc/tutorial/datastructures.rst:369
|
|
msgid ""
|
|
"A tuple consists of a number of values separated by commas, for instance::"
|
|
msgstr ""
|
|
|
|
#: ../Doc/tutorial/datastructures.rst:391
|
|
msgid ""
|
|
"As you see, on output tuples are always enclosed in parentheses, so that "
|
|
"nested tuples are interpreted correctly; they may be input with or without "
|
|
"surrounding parentheses, although often parentheses are necessary anyway (if "
|
|
"the tuple is part of a larger expression). It is not possible to assign to "
|
|
"the individual items of a tuple, however it is possible to create tuples "
|
|
"which contain mutable objects, such as lists."
|
|
msgstr ""
|
|
|
|
#: ../Doc/tutorial/datastructures.rst:398
|
|
msgid ""
|
|
"Though tuples may seem similar to lists, they are often used in different "
|
|
"situations and for different purposes. Tuples are :term:`immutable`, and "
|
|
"usually contain a heterogeneous sequence of elements that are accessed via "
|
|
"unpacking (see later in this section) or indexing (or even by attribute in "
|
|
"the case of :func:`namedtuples <collections.namedtuple>`). Lists are :term:"
|
|
"`mutable`, and their elements are usually homogeneous and are accessed by "
|
|
"iterating over the list."
|
|
msgstr ""
|
|
|
|
#: ../Doc/tutorial/datastructures.rst:406
|
|
msgid ""
|
|
"A special problem is the construction of tuples containing 0 or 1 items: the "
|
|
"syntax has some extra quirks to accommodate these. Empty tuples are "
|
|
"constructed by an empty pair of parentheses; a tuple with one item is "
|
|
"constructed by following a value with a comma (it is not sufficient to "
|
|
"enclose a single value in parentheses). Ugly, but effective. For example::"
|
|
msgstr ""
|
|
|
|
#: ../Doc/tutorial/datastructures.rst:421
|
|
msgid ""
|
|
"The statement ``t = 12345, 54321, 'hello!'`` is an example of *tuple "
|
|
"packing*: the values ``12345``, ``54321`` and ``'hello!'`` are packed "
|
|
"together in a tuple. The reverse operation is also possible::"
|
|
msgstr ""
|
|
|
|
#: ../Doc/tutorial/datastructures.rst:427
|
|
msgid ""
|
|
"This is called, appropriately enough, *sequence unpacking* and works for any "
|
|
"sequence on the right-hand side. Sequence unpacking requires that there are "
|
|
"as many variables on the left side of the equals sign as there are elements "
|
|
"in the sequence. Note that multiple assignment is really just a combination "
|
|
"of tuple packing and sequence unpacking."
|
|
msgstr ""
|
|
|
|
#: ../Doc/tutorial/datastructures.rst:437
|
|
msgid "Sets"
|
|
msgstr ""
|
|
|
|
#: ../Doc/tutorial/datastructures.rst:439
|
|
msgid ""
|
|
"Python also includes a data type for *sets*. A set is an unordered "
|
|
"collection with no duplicate elements. Basic uses include membership "
|
|
"testing and eliminating duplicate entries. Set objects also support "
|
|
"mathematical operations like union, intersection, difference, and symmetric "
|
|
"difference."
|
|
msgstr ""
|
|
|
|
#: ../Doc/tutorial/datastructures.rst:444
|
|
msgid ""
|
|
"Curly braces or the :func:`set` function can be used to create sets. Note: "
|
|
"to create an empty set you have to use ``set()``, not ``{}``; the latter "
|
|
"creates an empty dictionary, a data structure that we discuss in the next "
|
|
"section."
|
|
msgstr ""
|
|
|
|
#: ../Doc/tutorial/datastructures.rst:448
|
|
msgid "Here is a brief demonstration::"
|
|
msgstr ""
|
|
|
|
#: ../Doc/tutorial/datastructures.rst:473
|
|
msgid ""
|
|
"Similarly to :ref:`list comprehensions <tut-listcomps>`, set comprehensions "
|
|
"are also supported::"
|
|
msgstr ""
|
|
|
|
#: ../Doc/tutorial/datastructures.rst:484
|
|
msgid "Dictionaries"
|
|
msgstr ""
|
|
|
|
#: ../Doc/tutorial/datastructures.rst:486
|
|
msgid ""
|
|
"Another useful data type built into Python is the *dictionary* (see :ref:"
|
|
"`typesmapping`). Dictionaries are sometimes found in other languages as "
|
|
"\"associative memories\" or \"associative arrays\". Unlike sequences, which "
|
|
"are indexed by a range of numbers, dictionaries are indexed by *keys*, which "
|
|
"can be any immutable type; strings and numbers can always be keys. Tuples "
|
|
"can be used as keys if they contain only strings, numbers, or tuples; if a "
|
|
"tuple contains any mutable object either directly or indirectly, it cannot "
|
|
"be used as a key. You can't use lists as keys, since lists can be modified "
|
|
"in place using index assignments, slice assignments, or methods like :meth:"
|
|
"`append` and :meth:`extend`."
|
|
msgstr ""
|
|
|
|
#: ../Doc/tutorial/datastructures.rst:497
|
|
msgid ""
|
|
"It is best to think of a dictionary as an unordered set of *key: value* "
|
|
"pairs, with the requirement that the keys are unique (within one "
|
|
"dictionary). A pair of braces creates an empty dictionary: ``{}``. Placing a "
|
|
"comma-separated list of key:value pairs within the braces adds initial key:"
|
|
"value pairs to the dictionary; this is also the way dictionaries are written "
|
|
"on output."
|
|
msgstr ""
|
|
|
|
#: ../Doc/tutorial/datastructures.rst:503
|
|
msgid ""
|
|
"The main operations on a dictionary are storing a value with some key and "
|
|
"extracting the value given the key. It is also possible to delete a key:"
|
|
"value pair with ``del``. If you store using a key that is already in use, "
|
|
"the old value associated with that key is forgotten. It is an error to "
|
|
"extract a value using a non-existent key."
|
|
msgstr ""
|
|
|
|
#: ../Doc/tutorial/datastructures.rst:509
|
|
msgid ""
|
|
"Performing ``list(d.keys())`` on a dictionary returns a list of all the keys "
|
|
"used in the dictionary, in arbitrary order (if you want it sorted, just use "
|
|
"``sorted(d.keys())`` instead). [2]_ To check whether a single key is in the "
|
|
"dictionary, use the :keyword:`in` keyword."
|
|
msgstr ""
|
|
|
|
#: ../Doc/tutorial/datastructures.rst:514
|
|
msgid "Here is a small example using a dictionary::"
|
|
msgstr ""
|
|
|
|
#: ../Doc/tutorial/datastructures.rst:535
|
|
msgid ""
|
|
"The :func:`dict` constructor builds dictionaries directly from sequences of "
|
|
"key-value pairs::"
|
|
msgstr ""
|
|
|
|
#: ../Doc/tutorial/datastructures.rst:541
|
|
msgid ""
|
|
"In addition, dict comprehensions can be used to create dictionaries from "
|
|
"arbitrary key and value expressions::"
|
|
msgstr ""
|
|
|
|
#: ../Doc/tutorial/datastructures.rst:547
|
|
msgid ""
|
|
"When the keys are simple strings, it is sometimes easier to specify pairs "
|
|
"using keyword arguments::"
|
|
msgstr ""
|
|
|
|
#: ../Doc/tutorial/datastructures.rst:557
|
|
msgid "Looping Techniques"
|
|
msgstr ""
|
|
|
|
#: ../Doc/tutorial/datastructures.rst:559
|
|
msgid ""
|
|
"When looping through dictionaries, the key and corresponding value can be "
|
|
"retrieved at the same time using the :meth:`items` method. ::"
|
|
msgstr ""
|
|
|
|
#: ../Doc/tutorial/datastructures.rst:569
|
|
msgid ""
|
|
"When looping through a sequence, the position index and corresponding value "
|
|
"can be retrieved at the same time using the :func:`enumerate` function. ::"
|
|
msgstr ""
|
|
|
|
#: ../Doc/tutorial/datastructures.rst:579
|
|
msgid ""
|
|
"To loop over two or more sequences at the same time, the entries can be "
|
|
"paired with the :func:`zip` function. ::"
|
|
msgstr ""
|
|
|
|
#: ../Doc/tutorial/datastructures.rst:591
|
|
msgid ""
|
|
"To loop over a sequence in reverse, first specify the sequence in a forward "
|
|
"direction and then call the :func:`reversed` function. ::"
|
|
msgstr ""
|
|
|
|
#: ../Doc/tutorial/datastructures.rst:603
|
|
msgid ""
|
|
"To loop over a sequence in sorted order, use the :func:`sorted` function "
|
|
"which returns a new sorted list while leaving the source unaltered. ::"
|
|
msgstr ""
|
|
|
|
#: ../Doc/tutorial/datastructures.rst:615
|
|
msgid ""
|
|
"It is sometimes tempting to change a list while you are looping over it; "
|
|
"however, it is often simpler and safer to create a new list instead. ::"
|
|
msgstr ""
|
|
|
|
#: ../Doc/tutorial/datastructures.rst:632
|
|
msgid "More on Conditions"
|
|
msgstr ""
|
|
|
|
#: ../Doc/tutorial/datastructures.rst:634
|
|
msgid ""
|
|
"The conditions used in ``while`` and ``if`` statements can contain any "
|
|
"operators, not just comparisons."
|
|
msgstr ""
|
|
|
|
#: ../Doc/tutorial/datastructures.rst:637
|
|
msgid ""
|
|
"The comparison operators ``in`` and ``not in`` check whether a value occurs "
|
|
"(does not occur) in a sequence. The operators ``is`` and ``is not`` compare "
|
|
"whether two objects are really the same object; this only matters for "
|
|
"mutable objects like lists. All comparison operators have the same "
|
|
"priority, which is lower than that of all numerical operators."
|
|
msgstr ""
|
|
|
|
#: ../Doc/tutorial/datastructures.rst:643
|
|
msgid ""
|
|
"Comparisons can be chained. For example, ``a < b == c`` tests whether ``a`` "
|
|
"is less than ``b`` and moreover ``b`` equals ``c``."
|
|
msgstr ""
|
|
|
|
#: ../Doc/tutorial/datastructures.rst:646
|
|
msgid ""
|
|
"Comparisons may be combined using the Boolean operators ``and`` and ``or``, "
|
|
"and the outcome of a comparison (or of any other Boolean expression) may be "
|
|
"negated with ``not``. These have lower priorities than comparison "
|
|
"operators; between them, ``not`` has the highest priority and ``or`` the "
|
|
"lowest, so that ``A and not B or C`` is equivalent to ``(A and (not B)) or "
|
|
"C``. As always, parentheses can be used to express the desired composition."
|
|
msgstr ""
|
|
|
|
#: ../Doc/tutorial/datastructures.rst:653
|
|
msgid ""
|
|
"The Boolean operators ``and`` and ``or`` are so-called *short-circuit* "
|
|
"operators: their arguments are evaluated from left to right, and evaluation "
|
|
"stops as soon as the outcome is determined. For example, if ``A`` and ``C`` "
|
|
"are true but ``B`` is false, ``A and B and C`` does not evaluate the "
|
|
"expression ``C``. When used as a general value and not as a Boolean, the "
|
|
"return value of a short-circuit operator is the last evaluated argument."
|
|
msgstr ""
|
|
|
|
#: ../Doc/tutorial/datastructures.rst:660
|
|
msgid ""
|
|
"It is possible to assign the result of a comparison or other Boolean "
|
|
"expression to a variable. For example, ::"
|
|
msgstr ""
|
|
|
|
#: ../Doc/tutorial/datastructures.rst:668
|
|
msgid ""
|
|
"Note that in Python, unlike C, assignment cannot occur inside expressions. C "
|
|
"programmers may grumble about this, but it avoids a common class of problems "
|
|
"encountered in C programs: typing ``=`` in an expression when ``==`` was "
|
|
"intended."
|
|
msgstr ""
|
|
|
|
#: ../Doc/tutorial/datastructures.rst:677
|
|
msgid "Comparing Sequences and Other Types"
|
|
msgstr ""
|
|
|
|
#: ../Doc/tutorial/datastructures.rst:679
|
|
msgid ""
|
|
"Sequence objects may be compared to other objects with the same sequence "
|
|
"type. The comparison uses *lexicographical* ordering: first the first two "
|
|
"items are compared, and if they differ this determines the outcome of the "
|
|
"comparison; if they are equal, the next two items are compared, and so on, "
|
|
"until either sequence is exhausted. If two items to be compared are "
|
|
"themselves sequences of the same type, the lexicographical comparison is "
|
|
"carried out recursively. If all items of two sequences compare equal, the "
|
|
"sequences are considered equal. If one sequence is an initial sub-sequence "
|
|
"of the other, the shorter sequence is the smaller (lesser) one. "
|
|
"Lexicographical ordering for strings uses the Unicode code point number to "
|
|
"order individual characters. Some examples of comparisons between sequences "
|
|
"of the same type::"
|
|
msgstr ""
|
|
|
|
#: ../Doc/tutorial/datastructures.rst:699
|
|
msgid ""
|
|
"Note that comparing objects of different types with ``<`` or ``>`` is legal "
|
|
"provided that the objects have appropriate comparison methods. For example, "
|
|
"mixed numeric types are compared according to their numeric value, so 0 "
|
|
"equals 0.0, etc. Otherwise, rather than providing an arbitrary ordering, "
|
|
"the interpreter will raise a :exc:`TypeError` exception."
|
|
msgstr ""
|
|
|
|
#: ../Doc/tutorial/datastructures.rst:708
|
|
msgid ""
|
|
"Other languages may return the mutated object, which allows method chaining, "
|
|
"such as ``d->insert(\"a\")->remove(\"b\")->sort();``."
|
|
msgstr ""
|
|
|
|
#: ../Doc/tutorial/datastructures.rst:711
|
|
msgid ""
|
|
"Calling ``d.keys()`` will return a :dfn:`dictionary view` object. It "
|
|
"supports operations like membership test and iteration, but its contents are "
|
|
"not independent of the original dictionary -- it is only a *view*."
|
|
msgstr ""
|
|
|
|
#: ../Doc/tutorial/errors.rst:5
|
|
msgid "Errors and Exceptions"
|
|
msgstr ""
|
|
|
|
#: ../Doc/tutorial/errors.rst:7
|
|
msgid ""
|
|
"Until now error messages haven't been more than mentioned, but if you have "
|
|
"tried out the examples you have probably seen some. There are (at least) "
|
|
"two distinguishable kinds of errors: *syntax errors* and *exceptions*."
|
|
msgstr ""
|
|
|
|
#: ../Doc/tutorial/errors.rst:15
|
|
msgid "Syntax Errors"
|
|
msgstr ""
|
|
|
|
#: ../Doc/tutorial/errors.rst:17
|
|
msgid ""
|
|
"Syntax errors, also known as parsing errors, are perhaps the most common "
|
|
"kind of complaint you get while you are still learning Python::"
|
|
msgstr ""
|
|
|
|
#: ../Doc/tutorial/errors.rst:26
|
|
msgid ""
|
|
"The parser repeats the offending line and displays a little 'arrow' pointing "
|
|
"at the earliest point in the line where the error was detected. The error "
|
|
"is caused by (or at least detected at) the token *preceding* the arrow: in "
|
|
"the example, the error is detected at the function :func:`print`, since a "
|
|
"colon (``':'``) is missing before it. File name and line number are printed "
|
|
"so you know where to look in case the input came from a script."
|
|
msgstr ""
|
|
|
|
#: ../Doc/tutorial/errors.rst:37
|
|
msgid "Exceptions"
|
|
msgstr ""
|
|
|
|
#: ../Doc/tutorial/errors.rst:39
|
|
msgid ""
|
|
"Even if a statement or expression is syntactically correct, it may cause an "
|
|
"error when an attempt is made to execute it. Errors detected during "
|
|
"execution are called *exceptions* and are not unconditionally fatal: you "
|
|
"will soon learn how to handle them in Python programs. Most exceptions are "
|
|
"not handled by programs, however, and result in error messages as shown "
|
|
"here::"
|
|
msgstr ""
|
|
|
|
#: ../Doc/tutorial/errors.rst:58
|
|
msgid ""
|
|
"The last line of the error message indicates what happened. Exceptions come "
|
|
"in different types, and the type is printed as part of the message: the "
|
|
"types in the example are :exc:`ZeroDivisionError`, :exc:`NameError` and :exc:"
|
|
"`TypeError`. The string printed as the exception type is the name of the "
|
|
"built-in exception that occurred. This is true for all built-in exceptions, "
|
|
"but need not be true for user-defined exceptions (although it is a useful "
|
|
"convention). Standard exception names are built-in identifiers (not reserved "
|
|
"keywords)."
|
|
msgstr ""
|
|
|
|
#: ../Doc/tutorial/errors.rst:66
|
|
msgid ""
|
|
"The rest of the line provides detail based on the type of exception and what "
|
|
"caused it."
|
|
msgstr ""
|
|
|
|
#: ../Doc/tutorial/errors.rst:69
|
|
msgid ""
|
|
"The preceding part of the error message shows the context where the "
|
|
"exception happened, in the form of a stack traceback. In general it contains "
|
|
"a stack traceback listing source lines; however, it will not display lines "
|
|
"read from standard input."
|
|
msgstr ""
|
|
|
|
#: ../Doc/tutorial/errors.rst:74
|
|
msgid ""
|
|
":ref:`bltin-exceptions` lists the built-in exceptions and their meanings."
|
|
msgstr ""
|
|
|
|
#: ../Doc/tutorial/errors.rst:80
|
|
msgid "Handling Exceptions"
|
|
msgstr ""
|
|
|
|
#: ../Doc/tutorial/errors.rst:82
|
|
msgid ""
|
|
"It is possible to write programs that handle selected exceptions. Look at "
|
|
"the following example, which asks the user for input until a valid integer "
|
|
"has been entered, but allows the user to interrupt the program (using :kbd:"
|
|
"`Control-C` or whatever the operating system supports); note that a user-"
|
|
"generated interruption is signalled by raising the :exc:`KeyboardInterrupt` "
|
|
"exception. ::"
|
|
msgstr ""
|
|
|
|
#: ../Doc/tutorial/errors.rst:96
|
|
msgid "The :keyword:`try` statement works as follows."
|
|
msgstr ""
|
|
|
|
#: ../Doc/tutorial/errors.rst:98
|
|
msgid ""
|
|
"First, the *try clause* (the statement(s) between the :keyword:`try` and :"
|
|
"keyword:`except` keywords) is executed."
|
|
msgstr ""
|
|
|
|
#: ../Doc/tutorial/errors.rst:101
|
|
msgid ""
|
|
"If no exception occurs, the *except clause* is skipped and execution of the :"
|
|
"keyword:`try` statement is finished."
|
|
msgstr ""
|
|
|
|
#: ../Doc/tutorial/errors.rst:104
|
|
msgid ""
|
|
"If an exception occurs during execution of the try clause, the rest of the "
|
|
"clause is skipped. Then if its type matches the exception named after the :"
|
|
"keyword:`except` keyword, the except clause is executed, and then execution "
|
|
"continues after the :keyword:`try` statement."
|
|
msgstr ""
|
|
|
|
#: ../Doc/tutorial/errors.rst:109
|
|
msgid ""
|
|
"If an exception occurs which does not match the exception named in the "
|
|
"except clause, it is passed on to outer :keyword:`try` statements; if no "
|
|
"handler is found, it is an *unhandled exception* and execution stops with a "
|
|
"message as shown above."
|
|
msgstr ""
|
|
|
|
#: ../Doc/tutorial/errors.rst:114
|
|
msgid ""
|
|
"A :keyword:`try` statement may have more than one except clause, to specify "
|
|
"handlers for different exceptions. At most one handler will be executed. "
|
|
"Handlers only handle exceptions that occur in the corresponding try clause, "
|
|
"not in other handlers of the same :keyword:`try` statement. An except "
|
|
"clause may name multiple exceptions as a parenthesized tuple, for example::"
|
|
msgstr ""
|
|
|
|
#: ../Doc/tutorial/errors.rst:123
|
|
msgid ""
|
|
"The last except clause may omit the exception name(s), to serve as a "
|
|
"wildcard. Use this with extreme caution, since it is easy to mask a real "
|
|
"programming error in this way! It can also be used to print an error "
|
|
"message and then re-raise the exception (allowing a caller to handle the "
|
|
"exception as well)::"
|
|
msgstr ""
|
|
|
|
#: ../Doc/tutorial/errors.rst:142
|
|
msgid ""
|
|
"The :keyword:`try` ... :keyword:`except` statement has an optional *else "
|
|
"clause*, which, when present, must follow all except clauses. It is useful "
|
|
"for code that must be executed if the try clause does not raise an "
|
|
"exception. For example::"
|
|
msgstr ""
|
|
|
|
#: ../Doc/tutorial/errors.rst:156
|
|
msgid ""
|
|
"The use of the :keyword:`else` clause is better than adding additional code "
|
|
"to the :keyword:`try` clause because it avoids accidentally catching an "
|
|
"exception that wasn't raised by the code being protected by the :keyword:"
|
|
"`try` ... :keyword:`except` statement."
|
|
msgstr ""
|
|
|
|
#: ../Doc/tutorial/errors.rst:161
|
|
msgid ""
|
|
"When an exception occurs, it may have an associated value, also known as the "
|
|
"exception's *argument*. The presence and type of the argument depend on the "
|
|
"exception type."
|
|
msgstr ""
|
|
|
|
#: ../Doc/tutorial/errors.rst:165
|
|
msgid ""
|
|
"The except clause may specify a variable after the exception name. The "
|
|
"variable is bound to an exception instance with the arguments stored in "
|
|
"``instance.args``. For convenience, the exception instance defines :meth:"
|
|
"`__str__` so the arguments can be printed directly without having to "
|
|
"reference ``.args``. One may also instantiate an exception first before "
|
|
"raising it and add any attributes to it as desired. ::"
|
|
msgstr ""
|
|
|
|
#: ../Doc/tutorial/errors.rst:189
|
|
msgid ""
|
|
"If an exception has arguments, they are printed as the last part ('detail') "
|
|
"of the message for unhandled exceptions."
|
|
msgstr ""
|
|
|
|
#: ../Doc/tutorial/errors.rst:192
|
|
msgid ""
|
|
"Exception handlers don't just handle exceptions if they occur immediately in "
|
|
"the try clause, but also if they occur inside functions that are called "
|
|
"(even indirectly) in the try clause. For example::"
|
|
msgstr ""
|
|
|
|
#: ../Doc/tutorial/errors.rst:210
|
|
msgid "Raising Exceptions"
|
|
msgstr ""
|
|
|
|
#: ../Doc/tutorial/errors.rst:212
|
|
msgid ""
|
|
"The :keyword:`raise` statement allows the programmer to force a specified "
|
|
"exception to occur. For example::"
|
|
msgstr ""
|
|
|
|
#: ../Doc/tutorial/errors.rst:220
|
|
msgid ""
|
|
"The sole argument to :keyword:`raise` indicates the exception to be raised. "
|
|
"This must be either an exception instance or an exception class (a class "
|
|
"that derives from :class:`Exception`)."
|
|
msgstr ""
|
|
|
|
#: ../Doc/tutorial/errors.rst:224
|
|
msgid ""
|
|
"If you need to determine whether an exception was raised but don't intend to "
|
|
"handle it, a simpler form of the :keyword:`raise` statement allows you to re-"
|
|
"raise the exception::"
|
|
msgstr ""
|
|
|
|
#: ../Doc/tutorial/errors.rst:243
|
|
msgid "User-defined Exceptions"
|
|
msgstr ""
|
|
|
|
#: ../Doc/tutorial/errors.rst:245
|
|
msgid ""
|
|
"Programs may name their own exceptions by creating a new exception class "
|
|
"(see :ref:`tut-classes` for more about Python classes). Exceptions should "
|
|
"typically be derived from the :exc:`Exception` class, either directly or "
|
|
"indirectly."
|
|
msgstr ""
|
|
|
|
#: ../Doc/tutorial/errors.rst:249
|
|
msgid ""
|
|
"Exception classes can be defined which do anything any other class can do, "
|
|
"but are usually kept simple, often only offering a number of attributes that "
|
|
"allow information about the error to be extracted by handlers for the "
|
|
"exception. When creating a module that can raise several distinct errors, a "
|
|
"common practice is to create a base class for exceptions defined by that "
|
|
"module, and subclass that to create specific exception classes for different "
|
|
"error conditions::"
|
|
msgstr ""
|
|
|
|
#: ../Doc/tutorial/errors.rst:287
|
|
msgid ""
|
|
"Most exceptions are defined with names that end in \"Error,\" similar to the "
|
|
"naming of the standard exceptions."
|
|
msgstr ""
|
|
|
|
#: ../Doc/tutorial/errors.rst:290
|
|
msgid ""
|
|
"Many standard modules define their own exceptions to report errors that may "
|
|
"occur in functions they define. More information on classes is presented in "
|
|
"chapter :ref:`tut-classes`."
|
|
msgstr ""
|
|
|
|
#: ../Doc/tutorial/errors.rst:298
|
|
msgid "Defining Clean-up Actions"
|
|
msgstr ""
|
|
|
|
#: ../Doc/tutorial/errors.rst:300
|
|
msgid ""
|
|
"The :keyword:`try` statement has another optional clause which is intended "
|
|
"to define clean-up actions that must be executed under all circumstances. "
|
|
"For example::"
|
|
msgstr ""
|
|
|
|
#: ../Doc/tutorial/errors.rst:314
|
|
msgid ""
|
|
"A *finally clause* is always executed before leaving the :keyword:`try` "
|
|
"statement, whether an exception has occurred or not. When an exception has "
|
|
"occurred in the :keyword:`try` clause and has not been handled by an :"
|
|
"keyword:`except` clause (or it has occurred in an :keyword:`except` or :"
|
|
"keyword:`else` clause), it is re-raised after the :keyword:`finally` clause "
|
|
"has been executed. The :keyword:`finally` clause is also executed \"on the "
|
|
"way out\" when any other clause of the :keyword:`try` statement is left via "
|
|
"a :keyword:`break`, :keyword:`continue` or :keyword:`return` statement. A "
|
|
"more complicated example::"
|
|
msgstr ""
|
|
|
|
#: ../Doc/tutorial/errors.rst:347
|
|
msgid ""
|
|
"As you can see, the :keyword:`finally` clause is executed in any event. "
|
|
"The :exc:`TypeError` raised by dividing two strings is not handled by the :"
|
|
"keyword:`except` clause and therefore re-raised after the :keyword:`finally` "
|
|
"clause has been executed."
|
|
msgstr ""
|
|
|
|
#: ../Doc/tutorial/errors.rst:352
|
|
msgid ""
|
|
"In real world applications, the :keyword:`finally` clause is useful for "
|
|
"releasing external resources (such as files or network connections), "
|
|
"regardless of whether the use of the resource was successful."
|
|
msgstr ""
|
|
|
|
#: ../Doc/tutorial/errors.rst:360
|
|
msgid "Predefined Clean-up Actions"
|
|
msgstr ""
|
|
|
|
#: ../Doc/tutorial/errors.rst:362
|
|
msgid ""
|
|
"Some objects define standard clean-up actions to be undertaken when the "
|
|
"object is no longer needed, regardless of whether or not the operation using "
|
|
"the object succeeded or failed. Look at the following example, which tries "
|
|
"to open a file and print its contents to the screen. ::"
|
|
msgstr ""
|
|
|
|
#: ../Doc/tutorial/errors.rst:370
|
|
msgid ""
|
|
"The problem with this code is that it leaves the file open for an "
|
|
"indeterminate amount of time after this part of the code has finished "
|
|
"executing. This is not an issue in simple scripts, but can be a problem for "
|
|
"larger applications. The :keyword:`with` statement allows objects like files "
|
|
"to be used in a way that ensures they are always cleaned up promptly and "
|
|
"correctly. ::"
|
|
msgstr ""
|
|
|
|
#: ../Doc/tutorial/errors.rst:380
|
|
msgid ""
|
|
"After the statement is executed, the file *f* is always closed, even if a "
|
|
"problem was encountered while processing the lines. Objects which, like "
|
|
"files, provide predefined clean-up actions will indicate this in their "
|
|
"documentation."
|
|
msgstr ""
|
|
|
|
#: ../Doc/tutorial/floatingpoint.rst:9
|
|
msgid "Floating Point Arithmetic: Issues and Limitations"
|
|
msgstr ""
|
|
|
|
#: ../Doc/tutorial/floatingpoint.rst:14
|
|
msgid ""
|
|
"Floating-point numbers are represented in computer hardware as base 2 "
|
|
"(binary) fractions. For example, the decimal fraction ::"
|
|
msgstr ""
|
|
|
|
#: ../Doc/tutorial/floatingpoint.rst:19
|
|
msgid ""
|
|
"has value 1/10 + 2/100 + 5/1000, and in the same way the binary fraction ::"
|
|
msgstr ""
|
|
|
|
#: ../Doc/tutorial/floatingpoint.rst:23
|
|
msgid ""
|
|
"has value 0/2 + 0/4 + 1/8. These two fractions have identical values, the "
|
|
"only real difference being that the first is written in base 10 fractional "
|
|
"notation, and the second in base 2."
|
|
msgstr ""
|
|
|
|
#: ../Doc/tutorial/floatingpoint.rst:27
|
|
msgid ""
|
|
"Unfortunately, most decimal fractions cannot be represented exactly as "
|
|
"binary fractions. A consequence is that, in general, the decimal floating-"
|
|
"point numbers you enter are only approximated by the binary floating-point "
|
|
"numbers actually stored in the machine."
|
|
msgstr ""
|
|
|
|
#: ../Doc/tutorial/floatingpoint.rst:32
|
|
msgid ""
|
|
"The problem is easier to understand at first in base 10. Consider the "
|
|
"fraction 1/3. You can approximate that as a base 10 fraction::"
|
|
msgstr ""
|
|
|
|
#: ../Doc/tutorial/floatingpoint.rst:37 ../Doc/tutorial/floatingpoint.rst:41
|
|
msgid "or, better, ::"
|
|
msgstr ""
|
|
|
|
#: ../Doc/tutorial/floatingpoint.rst:45
|
|
msgid ""
|
|
"and so on. No matter how many digits you're willing to write down, the "
|
|
"result will never be exactly 1/3, but will be an increasingly better "
|
|
"approximation of 1/3."
|
|
msgstr ""
|
|
|
|
#: ../Doc/tutorial/floatingpoint.rst:49
|
|
msgid ""
|
|
"In the same way, no matter how many base 2 digits you're willing to use, the "
|
|
"decimal value 0.1 cannot be represented exactly as a base 2 fraction. In "
|
|
"base 2, 1/10 is the infinitely repeating fraction ::"
|
|
msgstr ""
|
|
|
|
#: ../Doc/tutorial/floatingpoint.rst:55
|
|
msgid ""
|
|
"Stop at any finite number of bits, and you get an approximation. On most "
|
|
"machines today, floats are approximated using a binary fraction with the "
|
|
"numerator using the first 53 bits starting with the most significant bit and "
|
|
"with the denominator as a power of two. In the case of 1/10, the binary "
|
|
"fraction is ``3602879701896397 / 2 ** 55`` which is close to but not exactly "
|
|
"equal to the true value of 1/10."
|
|
msgstr ""
|
|
|
|
#: ../Doc/tutorial/floatingpoint.rst:62
|
|
msgid ""
|
|
"Many users are not aware of the approximation because of the way values are "
|
|
"displayed. Python only prints a decimal approximation to the true decimal "
|
|
"value of the binary approximation stored by the machine. On most machines, "
|
|
"if Python were to print the true decimal value of the binary approximation "
|
|
"stored for 0.1, it would have to display ::"
|
|
msgstr ""
|
|
|
|
#: ../Doc/tutorial/floatingpoint.rst:71
|
|
msgid ""
|
|
"That is more digits than most people find useful, so Python keeps the number "
|
|
"of digits manageable by displaying a rounded value instead ::"
|
|
msgstr ""
|
|
|
|
#: ../Doc/tutorial/floatingpoint.rst:77
|
|
msgid ""
|
|
"Just remember, even though the printed result looks like the exact value of "
|
|
"1/10, the actual stored value is the nearest representable binary fraction."
|
|
msgstr ""
|
|
|
|
#: ../Doc/tutorial/floatingpoint.rst:80
|
|
msgid ""
|
|
"Interestingly, there are many different decimal numbers that share the same "
|
|
"nearest approximate binary fraction. For example, the numbers ``0.1`` and "
|
|
"``0.10000000000000001`` and "
|
|
"``0.1000000000000000055511151231257827021181583404541015625`` are all "
|
|
"approximated by ``3602879701896397 / 2 ** 55``. Since all of these decimal "
|
|
"values share the same approximation, any one of them could be displayed "
|
|
"while still preserving the invariant ``eval(repr(x)) == x``."
|
|
msgstr ""
|
|
|
|
#: ../Doc/tutorial/floatingpoint.rst:88
|
|
msgid ""
|
|
"Historically, the Python prompt and built-in :func:`repr` function would "
|
|
"choose the one with 17 significant digits, ``0.10000000000000001``. "
|
|
"Starting with Python 3.1, Python (on most systems) is now able to choose the "
|
|
"shortest of these and simply display ``0.1``."
|
|
msgstr ""
|
|
|
|
#: ../Doc/tutorial/floatingpoint.rst:93
|
|
msgid ""
|
|
"Note that this is in the very nature of binary floating-point: this is not a "
|
|
"bug in Python, and it is not a bug in your code either. You'll see the same "
|
|
"kind of thing in all languages that support your hardware's floating-point "
|
|
"arithmetic (although some languages may not *display* the difference by "
|
|
"default, or in all output modes)."
|
|
msgstr ""
|
|
|
|
#: ../Doc/tutorial/floatingpoint.rst:99
|
|
msgid ""
|
|
"For more pleasant output, you may wish to use string formatting to produce a "
|
|
"limited number of significant digits::"
|
|
msgstr ""
|
|
|
|
#: ../Doc/tutorial/floatingpoint.rst:111
|
|
msgid ""
|
|
"It's important to realize that this is, in a real sense, an illusion: you're "
|
|
"simply rounding the *display* of the true machine value."
|
|
msgstr ""
|
|
|
|
#: ../Doc/tutorial/floatingpoint.rst:114
|
|
msgid ""
|
|
"One illusion may beget another. For example, since 0.1 is not exactly 1/10, "
|
|
"summing three values of 0.1 may not yield exactly 0.3, either::"
|
|
msgstr ""
|
|
|
|
#: ../Doc/tutorial/floatingpoint.rst:120
|
|
msgid ""
|
|
"Also, since the 0.1 cannot get any closer to the exact value of 1/10 and 0.3 "
|
|
"cannot get any closer to the exact value of 3/10, then pre-rounding with :"
|
|
"func:`round` function cannot help::"
|
|
msgstr ""
|
|
|
|
#: ../Doc/tutorial/floatingpoint.rst:127
|
|
msgid ""
|
|
"Though the numbers cannot be made closer to their intended exact values, "
|
|
"the :func:`round` function can be useful for post-rounding so that results "
|
|
"with inexact values become comparable to one another::"
|
|
msgstr ""
|
|
|
|
#: ../Doc/tutorial/floatingpoint.rst:134
|
|
msgid ""
|
|
"Binary floating-point arithmetic holds many surprises like this. The "
|
|
"problem with \"0.1\" is explained in precise detail below, in the "
|
|
"\"Representation Error\" section. See `The Perils of Floating Point <http://"
|
|
"www.lahey.com/float.htm>`_ for a more complete account of other common "
|
|
"surprises."
|
|
msgstr ""
|
|
|
|
#: ../Doc/tutorial/floatingpoint.rst:139
|
|
msgid ""
|
|
"As that says near the end, \"there are no easy answers.\" Still, don't be "
|
|
"unduly wary of floating-point! The errors in Python float operations are "
|
|
"inherited from the floating-point hardware, and on most machines are on the "
|
|
"order of no more than 1 part in 2\\*\\*53 per operation. That's more than "
|
|
"adequate for most tasks, but you do need to keep in mind that it's not "
|
|
"decimal arithmetic and that every float operation can suffer a new rounding "
|
|
"error."
|
|
msgstr ""
|
|
|
|
#: ../Doc/tutorial/floatingpoint.rst:146
|
|
msgid ""
|
|
"While pathological cases do exist, for most casual use of floating-point "
|
|
"arithmetic you'll see the result you expect in the end if you simply round "
|
|
"the display of your final results to the number of decimal digits you "
|
|
"expect. :func:`str` usually suffices, and for finer control see the :meth:"
|
|
"`str.format` method's format specifiers in :ref:`formatstrings`."
|
|
msgstr ""
|
|
|
|
#: ../Doc/tutorial/floatingpoint.rst:152
|
|
msgid ""
|
|
"For use cases which require exact decimal representation, try using the :mod:"
|
|
"`decimal` module which implements decimal arithmetic suitable for accounting "
|
|
"applications and high-precision applications."
|
|
msgstr ""
|
|
|
|
#: ../Doc/tutorial/floatingpoint.rst:156
|
|
msgid ""
|
|
"Another form of exact arithmetic is supported by the :mod:`fractions` module "
|
|
"which implements arithmetic based on rational numbers (so the numbers like "
|
|
"1/3 can be represented exactly)."
|
|
msgstr ""
|
|
|
|
#: ../Doc/tutorial/floatingpoint.rst:160
|
|
msgid ""
|
|
"If you are a heavy user of floating point operations you should take a look "
|
|
"at the Numerical Python package and many other packages for mathematical and "
|
|
"statistical operations supplied by the SciPy project. See <https://scipy."
|
|
"org>."
|
|
msgstr ""
|
|
|
|
#: ../Doc/tutorial/floatingpoint.rst:164
|
|
msgid ""
|
|
"Python provides tools that may help on those rare occasions when you really "
|
|
"*do* want to know the exact value of a float. The :meth:`float."
|
|
"as_integer_ratio` method expresses the value of a float as a fraction::"
|
|
msgstr ""
|
|
|
|
#: ../Doc/tutorial/floatingpoint.rst:173
|
|
msgid ""
|
|
"Since the ratio is exact, it can be used to losslessly recreate the original "
|
|
"value::"
|
|
msgstr ""
|
|
|
|
#: ../Doc/tutorial/floatingpoint.rst:179
|
|
msgid ""
|
|
"The :meth:`float.hex` method expresses a float in hexadecimal (base 16), "
|
|
"again giving the exact value stored by your computer::"
|
|
msgstr ""
|
|
|
|
#: ../Doc/tutorial/floatingpoint.rst:185
|
|
msgid ""
|
|
"This precise hexadecimal representation can be used to reconstruct the float "
|
|
"value exactly::"
|
|
msgstr ""
|
|
|
|
#: ../Doc/tutorial/floatingpoint.rst:191
|
|
msgid ""
|
|
"Since the representation is exact, it is useful for reliably porting values "
|
|
"across different versions of Python (platform independence) and exchanging "
|
|
"data with other languages that support the same format (such as Java and "
|
|
"C99)."
|
|
msgstr ""
|
|
|
|
#: ../Doc/tutorial/floatingpoint.rst:195
|
|
msgid ""
|
|
"Another helpful tool is the :func:`math.fsum` function which helps mitigate "
|
|
"loss-of-precision during summation. It tracks \"lost digits\" as values are "
|
|
"added onto a running total. That can make a difference in overall accuracy "
|
|
"so that the errors do not accumulate to the point where they affect the "
|
|
"final total:"
|
|
msgstr ""
|
|
|
|
#: ../Doc/tutorial/floatingpoint.rst:209
|
|
msgid "Representation Error"
|
|
msgstr ""
|
|
|
|
#: ../Doc/tutorial/floatingpoint.rst:211
|
|
msgid ""
|
|
"This section explains the \"0.1\" example in detail, and shows how you can "
|
|
"perform an exact analysis of cases like this yourself. Basic familiarity "
|
|
"with binary floating-point representation is assumed."
|
|
msgstr ""
|
|
|
|
#: ../Doc/tutorial/floatingpoint.rst:215
|
|
msgid ""
|
|
":dfn:`Representation error` refers to the fact that some (most, actually) "
|
|
"decimal fractions cannot be represented exactly as binary (base 2) "
|
|
"fractions. This is the chief reason why Python (or Perl, C, C++, Java, "
|
|
"Fortran, and many others) often won't display the exact decimal number you "
|
|
"expect."
|
|
msgstr ""
|
|
|
|
#: ../Doc/tutorial/floatingpoint.rst:220
|
|
msgid ""
|
|
"Why is that? 1/10 is not exactly representable as a binary fraction. Almost "
|
|
"all machines today (November 2000) use IEEE-754 floating point arithmetic, "
|
|
"and almost all platforms map Python floats to IEEE-754 \"double precision"
|
|
"\". 754 doubles contain 53 bits of precision, so on input the computer "
|
|
"strives to convert 0.1 to the closest fraction it can of the form *J*/2**\\ "
|
|
"*N* where *J* is an integer containing exactly 53 bits. Rewriting ::"
|
|
msgstr ""
|
|
|
|
#: ../Doc/tutorial/floatingpoint.rst:229
|
|
msgid "as ::"
|
|
msgstr ""
|
|
|
|
#: ../Doc/tutorial/floatingpoint.rst:233
|
|
msgid ""
|
|
"and recalling that *J* has exactly 53 bits (is ``>= 2**52`` but ``< "
|
|
"2**53``), the best value for *N* is 56::"
|
|
msgstr ""
|
|
|
|
#: ../Doc/tutorial/floatingpoint.rst:239
|
|
msgid ""
|
|
"That is, 56 is the only value for *N* that leaves *J* with exactly 53 bits. "
|
|
"The best possible value for *J* is then that quotient rounded::"
|
|
msgstr ""
|
|
|
|
#: ../Doc/tutorial/floatingpoint.rst:246
|
|
msgid ""
|
|
"Since the remainder is more than half of 10, the best approximation is "
|
|
"obtained by rounding up::"
|
|
msgstr ""
|
|
|
|
#: ../Doc/tutorial/floatingpoint.rst:252
|
|
msgid ""
|
|
"Therefore the best possible approximation to 1/10 in 754 double precision "
|
|
"is::"
|
|
msgstr ""
|
|
|
|
#: ../Doc/tutorial/floatingpoint.rst:256
|
|
msgid ""
|
|
"Dividing both the numerator and denominator by two reduces the fraction to::"
|
|
msgstr ""
|
|
|
|
#: ../Doc/tutorial/floatingpoint.rst:260
|
|
msgid ""
|
|
"Note that since we rounded up, this is actually a little bit larger than "
|
|
"1/10; if we had not rounded up, the quotient would have been a little bit "
|
|
"smaller than 1/10. But in no case can it be *exactly* 1/10!"
|
|
msgstr ""
|
|
|
|
#: ../Doc/tutorial/floatingpoint.rst:264
|
|
msgid ""
|
|
"So the computer never \"sees\" 1/10: what it sees is the exact fraction "
|
|
"given above, the best 754 double approximation it can get::"
|
|
msgstr ""
|
|
|
|
#: ../Doc/tutorial/floatingpoint.rst:270
|
|
msgid ""
|
|
"If we multiply that fraction by 10\\*\\*55, we can see the value out to 55 "
|
|
"decimal digits::"
|
|
msgstr ""
|
|
|
|
#: ../Doc/tutorial/floatingpoint.rst:276
|
|
msgid ""
|
|
"meaning that the exact number stored in the computer is equal to the decimal "
|
|
"value 0.1000000000000000055511151231257827021181583404541015625. Instead of "
|
|
"displaying the full decimal value, many languages (including older versions "
|
|
"of Python), round the result to 17 significant digits::"
|
|
msgstr ""
|
|
|
|
#: ../Doc/tutorial/floatingpoint.rst:284
|
|
msgid ""
|
|
"The :mod:`fractions` and :mod:`decimal` modules make these calculations "
|
|
"easy::"
|
|
msgstr ""
|
|
|
|
#: ../Doc/tutorial/index.rst:5
|
|
msgid "The Python Tutorial"
|
|
msgstr ""
|
|
|
|
#: ../Doc/tutorial/index.rst:7
|
|
msgid ""
|
|
"Python is an easy to learn, powerful programming language. It has efficient "
|
|
"high-level data structures and a simple but effective approach to object-"
|
|
"oriented programming. Python's elegant syntax and dynamic typing, together "
|
|
"with its interpreted nature, make it an ideal language for scripting and "
|
|
"rapid application development in many areas on most platforms."
|
|
msgstr ""
|
|
|
|
#: ../Doc/tutorial/index.rst:13
|
|
msgid ""
|
|
"The Python interpreter and the extensive standard library are freely "
|
|
"available in source or binary form for all major platforms from the Python "
|
|
"Web site, https://www.python.org/, and may be freely distributed. The same "
|
|
"site also contains distributions of and pointers to many free third party "
|
|
"Python modules, programs and tools, and additional documentation."
|
|
msgstr ""
|
|
|
|
#: ../Doc/tutorial/index.rst:19
|
|
msgid ""
|
|
"The Python interpreter is easily extended with new functions and data types "
|
|
"implemented in C or C++ (or other languages callable from C). Python is also "
|
|
"suitable as an extension language for customizable applications."
|
|
msgstr ""
|
|
|
|
#: ../Doc/tutorial/index.rst:23
|
|
msgid ""
|
|
"This tutorial introduces the reader informally to the basic concepts and "
|
|
"features of the Python language and system. It helps to have a Python "
|
|
"interpreter handy for hands-on experience, but all examples are self-"
|
|
"contained, so the tutorial can be read off-line as well."
|
|
msgstr ""
|
|
|
|
#: ../Doc/tutorial/index.rst:28
|
|
msgid ""
|
|
"For a description of standard objects and modules, see :ref:`library-"
|
|
"index`. :ref:`reference-index` gives a more formal definition of the "
|
|
"language. To write extensions in C or C++, read :ref:`extending-index` and :"
|
|
"ref:`c-api-index`. There are also several books covering Python in depth."
|
|
msgstr ""
|
|
|
|
#: ../Doc/tutorial/index.rst:33
|
|
msgid ""
|
|
"This tutorial does not attempt to be comprehensive and cover every single "
|
|
"feature, or even every commonly used feature. Instead, it introduces many of "
|
|
"Python's most noteworthy features, and will give you a good idea of the "
|
|
"language's flavor and style. After reading it, you will be able to read and "
|
|
"write Python modules and programs, and you will be ready to learn more about "
|
|
"the various Python library modules described in :ref:`library-index`."
|
|
msgstr ""
|
|
|
|
#: ../Doc/tutorial/index.rst:40
|
|
msgid "The :ref:`glossary` is also worth going through."
|
|
msgstr ""
|
|
|
|
#: ../Doc/tutorial/inputoutput.rst:5
|
|
msgid "Input and Output"
|
|
msgstr ""
|
|
|
|
#: ../Doc/tutorial/inputoutput.rst:7
|
|
msgid ""
|
|
"There are several ways to present the output of a program; data can be "
|
|
"printed in a human-readable form, or written to a file for future use. This "
|
|
"chapter will discuss some of the possibilities."
|
|
msgstr ""
|
|
|
|
#: ../Doc/tutorial/inputoutput.rst:15
|
|
msgid "Fancier Output Formatting"
|
|
msgstr ""
|
|
|
|
#: ../Doc/tutorial/inputoutput.rst:17
|
|
msgid ""
|
|
"So far we've encountered two ways of writing values: *expression statements* "
|
|
"and the :func:`print` function. (A third way is using the :meth:`write` "
|
|
"method of file objects; the standard output file can be referenced as ``sys."
|
|
"stdout``. See the Library Reference for more information on this.)"
|
|
msgstr ""
|
|
|
|
#: ../Doc/tutorial/inputoutput.rst:22
|
|
msgid ""
|
|
"Often you'll want more control over the formatting of your output than "
|
|
"simply printing space-separated values. There are two ways to format your "
|
|
"output; the first way is to do all the string handling yourself; using "
|
|
"string slicing and concatenation operations you can create any layout you "
|
|
"can imagine. The string type has some methods that perform useful "
|
|
"operations for padding strings to a given column width; these will be "
|
|
"discussed shortly. The second way is to use :ref:`formatted string literals "
|
|
"<f-strings>`, or the :meth:`str.format` method."
|
|
msgstr ""
|
|
|
|
#: ../Doc/tutorial/inputoutput.rst:31
|
|
msgid ""
|
|
"The :mod:`string` module contains a :class:`~string.Template` class which "
|
|
"offers yet another way to substitute values into strings."
|
|
msgstr ""
|
|
|
|
#: ../Doc/tutorial/inputoutput.rst:34
|
|
msgid ""
|
|
"One question remains, of course: how do you convert values to strings? "
|
|
"Luckily, Python has ways to convert any value to a string: pass it to the :"
|
|
"func:`repr` or :func:`str` functions."
|
|
msgstr ""
|
|
|
|
#: ../Doc/tutorial/inputoutput.rst:38
|
|
msgid ""
|
|
"The :func:`str` function is meant to return representations of values which "
|
|
"are fairly human-readable, while :func:`repr` is meant to generate "
|
|
"representations which can be read by the interpreter (or will force a :exc:"
|
|
"`SyntaxError` if there is no equivalent syntax). For objects which don't "
|
|
"have a particular representation for human consumption, :func:`str` will "
|
|
"return the same value as :func:`repr`. Many values, such as numbers or "
|
|
"structures like lists and dictionaries, have the same representation using "
|
|
"either function. Strings, in particular, have two distinct representations."
|
|
msgstr ""
|
|
|
|
#: ../Doc/tutorial/inputoutput.rst:47 ../Doc/tutorial/introduction.rst:22
|
|
msgid "Some examples::"
|
|
msgstr ""
|
|
|
|
#: ../Doc/tutorial/inputoutput.rst:70
|
|
msgid "Here are two ways to write a table of squares and cubes::"
|
|
msgstr ""
|
|
|
|
#: ../Doc/tutorial/inputoutput.rst:102
|
|
msgid ""
|
|
"(Note that in the first example, one space between each column was added by "
|
|
"the way :func:`print` works: it always adds spaces between its arguments.)"
|
|
msgstr ""
|
|
|
|
#: ../Doc/tutorial/inputoutput.rst:105
|
|
msgid ""
|
|
"This example demonstrates the :meth:`str.rjust` method of string objects, "
|
|
"which right-justifies a string in a field of a given width by padding it "
|
|
"with spaces on the left. There are similar methods :meth:`str.ljust` and :"
|
|
"meth:`str.center`. These methods do not write anything, they just return a "
|
|
"new string. If the input string is too long, they don't truncate it, but "
|
|
"return it unchanged; this will mess up your column lay-out but that's "
|
|
"usually better than the alternative, which would be lying about a value. "
|
|
"(If you really want truncation you can always add a slice operation, as in "
|
|
"``x.ljust(n)[:n]``.)"
|
|
msgstr ""
|
|
|
|
#: ../Doc/tutorial/inputoutput.rst:115
|
|
msgid ""
|
|
"There is another method, :meth:`str.zfill`, which pads a numeric string on "
|
|
"the left with zeros. It understands about plus and minus signs::"
|
|
msgstr ""
|
|
|
|
#: ../Doc/tutorial/inputoutput.rst:125
|
|
msgid "Basic usage of the :meth:`str.format` method looks like this::"
|
|
msgstr ""
|
|
|
|
#: ../Doc/tutorial/inputoutput.rst:130
|
|
msgid ""
|
|
"The brackets and characters within them (called format fields) are replaced "
|
|
"with the objects passed into the :meth:`str.format` method. A number in the "
|
|
"brackets can be used to refer to the position of the object passed into the :"
|
|
"meth:`str.format` method. ::"
|
|
msgstr ""
|
|
|
|
#: ../Doc/tutorial/inputoutput.rst:140
|
|
msgid ""
|
|
"If keyword arguments are used in the :meth:`str.format` method, their values "
|
|
"are referred to by using the name of the argument. ::"
|
|
msgstr ""
|
|
|
|
#: ../Doc/tutorial/inputoutput.rst:147
|
|
msgid "Positional and keyword arguments can be arbitrarily combined::"
|
|
msgstr ""
|
|
|
|
#: ../Doc/tutorial/inputoutput.rst:153
|
|
msgid ""
|
|
"``'!a'`` (apply :func:`ascii`), ``'!s'`` (apply :func:`str`) and ``'!r'`` "
|
|
"(apply :func:`repr`) can be used to convert the value before it is "
|
|
"formatted::"
|
|
msgstr ""
|
|
|
|
#: ../Doc/tutorial/inputoutput.rst:162
|
|
msgid ""
|
|
"An optional ``':'`` and format specifier can follow the field name. This "
|
|
"allows greater control over how the value is formatted. The following "
|
|
"example rounds Pi to three places after the decimal."
|
|
msgstr ""
|
|
|
|
#: ../Doc/tutorial/inputoutput.rst:170
|
|
msgid ""
|
|
"Passing an integer after the ``':'`` will cause that field to be a minimum "
|
|
"number of characters wide. This is useful for making tables pretty. ::"
|
|
msgstr ""
|
|
|
|
#: ../Doc/tutorial/inputoutput.rst:181
|
|
msgid ""
|
|
"If you have a really long format string that you don't want to split up, it "
|
|
"would be nice if you could reference the variables to be formatted by name "
|
|
"instead of by position. This can be done by simply passing the dict and "
|
|
"using square brackets ``'[]'`` to access the keys ::"
|
|
msgstr ""
|
|
|
|
#: ../Doc/tutorial/inputoutput.rst:191
|
|
msgid ""
|
|
"This could also be done by passing the table as keyword arguments with the "
|
|
"'**' notation. ::"
|
|
msgstr ""
|
|
|
|
#: ../Doc/tutorial/inputoutput.rst:198
|
|
msgid ""
|
|
"This is particularly useful in combination with the built-in function :func:"
|
|
"`vars`, which returns a dictionary containing all local variables."
|
|
msgstr ""
|
|
|
|
#: ../Doc/tutorial/inputoutput.rst:201
|
|
msgid ""
|
|
"For a complete overview of string formatting with :meth:`str.format`, see :"
|
|
"ref:`formatstrings`."
|
|
msgstr ""
|
|
|
|
#: ../Doc/tutorial/inputoutput.rst:206
|
|
msgid "Old string formatting"
|
|
msgstr ""
|
|
|
|
#: ../Doc/tutorial/inputoutput.rst:208
|
|
msgid ""
|
|
"The ``%`` operator can also be used for string formatting. It interprets the "
|
|
"left argument much like a :c:func:`sprintf`\\ -style format string to be "
|
|
"applied to the right argument, and returns the string resulting from this "
|
|
"formatting operation. For example::"
|
|
msgstr ""
|
|
|
|
#: ../Doc/tutorial/inputoutput.rst:217
|
|
msgid ""
|
|
"More information can be found in the :ref:`old-string-formatting` section."
|
|
msgstr ""
|
|
|
|
#: ../Doc/tutorial/inputoutput.rst:223
|
|
msgid "Reading and Writing Files"
|
|
msgstr ""
|
|
|
|
#: ../Doc/tutorial/inputoutput.rst:229
|
|
msgid ""
|
|
":func:`open` returns a :term:`file object`, and is most commonly used with "
|
|
"two arguments: ``open(filename, mode)``."
|
|
msgstr ""
|
|
|
|
#: ../Doc/tutorial/inputoutput.rst:241
|
|
msgid ""
|
|
"The first argument is a string containing the filename. The second argument "
|
|
"is another string containing a few characters describing the way in which "
|
|
"the file will be used. *mode* can be ``'r'`` when the file will only be "
|
|
"read, ``'w'`` for only writing (an existing file with the same name will be "
|
|
"erased), and ``'a'`` opens the file for appending; any data written to the "
|
|
"file is automatically added to the end. ``'r+'`` opens the file for both "
|
|
"reading and writing. The *mode* argument is optional; ``'r'`` will be "
|
|
"assumed if it's omitted."
|
|
msgstr ""
|
|
|
|
#: ../Doc/tutorial/inputoutput.rst:250
|
|
msgid ""
|
|
"Normally, files are opened in :dfn:`text mode`, that means, you read and "
|
|
"write strings from and to the file, which are encoded in a specific "
|
|
"encoding. If encoding is not specified, the default is platform dependent "
|
|
"(see :func:`open`). ``'b'`` appended to the mode opens the file in :dfn:"
|
|
"`binary mode`: now the data is read and written in the form of bytes "
|
|
"objects. This mode should be used for all files that don't contain text."
|
|
msgstr ""
|
|
|
|
#: ../Doc/tutorial/inputoutput.rst:257
|
|
msgid ""
|
|
"In text mode, the default when reading is to convert platform-specific line "
|
|
"endings (``\\n`` on Unix, ``\\r\\n`` on Windows) to just ``\\n``. When "
|
|
"writing in text mode, the default is to convert occurrences of ``\\n`` back "
|
|
"to platform-specific line endings. This behind-the-scenes modification to "
|
|
"file data is fine for text files, but will corrupt binary data like that in :"
|
|
"file:`JPEG` or :file:`EXE` files. Be very careful to use binary mode when "
|
|
"reading and writing such files."
|
|
msgstr ""
|
|
|
|
#: ../Doc/tutorial/inputoutput.rst:269
|
|
msgid "Methods of File Objects"
|
|
msgstr ""
|
|
|
|
#: ../Doc/tutorial/inputoutput.rst:271
|
|
msgid ""
|
|
"The rest of the examples in this section will assume that a file object "
|
|
"called ``f`` has already been created."
|
|
msgstr ""
|
|
|
|
#: ../Doc/tutorial/inputoutput.rst:274
|
|
msgid ""
|
|
"To read a file's contents, call ``f.read(size)``, which reads some quantity "
|
|
"of data and returns it as a string (in text mode) or bytes object (in binary "
|
|
"mode). *size* is an optional numeric argument. When *size* is omitted or "
|
|
"negative, the entire contents of the file will be read and returned; it's "
|
|
"your problem if the file is twice as large as your machine's memory. "
|
|
"Otherwise, at most *size* bytes are read and returned. If the end of the "
|
|
"file has been reached, ``f.read()`` will return an empty string (``''``). ::"
|
|
msgstr ""
|
|
|
|
#: ../Doc/tutorial/inputoutput.rst:288
|
|
msgid ""
|
|
"``f.readline()`` reads a single line from the file; a newline character (``"
|
|
"\\n``) is left at the end of the string, and is only omitted on the last "
|
|
"line of the file if the file doesn't end in a newline. This makes the "
|
|
"return value unambiguous; if ``f.readline()`` returns an empty string, the "
|
|
"end of the file has been reached, while a blank line is represented by "
|
|
"``'\\n'``, a string containing only a single newline. ::"
|
|
msgstr ""
|
|
|
|
#: ../Doc/tutorial/inputoutput.rst:302
|
|
msgid ""
|
|
"For reading lines from a file, you can loop over the file object. This is "
|
|
"memory efficient, fast, and leads to simple code::"
|
|
msgstr ""
|
|
|
|
#: ../Doc/tutorial/inputoutput.rst:311
|
|
msgid ""
|
|
"If you want to read all the lines of a file in a list you can also use "
|
|
"``list(f)`` or ``f.readlines()``."
|
|
msgstr ""
|
|
|
|
#: ../Doc/tutorial/inputoutput.rst:314
|
|
msgid ""
|
|
"``f.write(string)`` writes the contents of *string* to the file, returning "
|
|
"the number of characters written. ::"
|
|
msgstr ""
|
|
|
|
#: ../Doc/tutorial/inputoutput.rst:320
|
|
msgid ""
|
|
"Other types of objects need to be converted -- either to a string (in text "
|
|
"mode) or a bytes object (in binary mode) -- before writing them::"
|
|
msgstr ""
|
|
|
|
#: ../Doc/tutorial/inputoutput.rst:328
|
|
msgid ""
|
|
"``f.tell()`` returns an integer giving the file object's current position in "
|
|
"the file represented as number of bytes from the beginning of the file when "
|
|
"in binary mode and an opaque number when in text mode."
|
|
msgstr ""
|
|
|
|
#: ../Doc/tutorial/inputoutput.rst:332
|
|
msgid ""
|
|
"To change the file object's position, use ``f.seek(offset, from_what)``. "
|
|
"The position is computed from adding *offset* to a reference point; the "
|
|
"reference point is selected by the *from_what* argument. A *from_what* "
|
|
"value of 0 measures from the beginning of the file, 1 uses the current file "
|
|
"position, and 2 uses the end of the file as the reference point. "
|
|
"*from_what* can be omitted and defaults to 0, using the beginning of the "
|
|
"file as the reference point. ::"
|
|
msgstr ""
|
|
|
|
#: ../Doc/tutorial/inputoutput.rst:351
|
|
msgid ""
|
|
"In text files (those opened without a ``b`` in the mode string), only seeks "
|
|
"relative to the beginning of the file are allowed (the exception being "
|
|
"seeking to the very file end with ``seek(0, 2)``) and the only valid "
|
|
"*offset* values are those returned from the ``f.tell()``, or zero. Any other "
|
|
"*offset* value produces undefined behaviour."
|
|
msgstr ""
|
|
|
|
#: ../Doc/tutorial/inputoutput.rst:358
|
|
msgid ""
|
|
"When you're done with a file, call ``f.close()`` to close it and free up any "
|
|
"system resources taken up by the open file. After calling ``f.close()``, "
|
|
"attempts to use the file object will automatically fail. ::"
|
|
msgstr ""
|
|
|
|
#: ../Doc/tutorial/inputoutput.rst:368
|
|
msgid ""
|
|
"It is good practice to use the :keyword:`with` keyword when dealing with "
|
|
"file objects. This has the advantage that the file is properly closed after "
|
|
"its suite finishes, even if an exception is raised on the way. It is also "
|
|
"much shorter than writing equivalent :keyword:`try`\\ -\\ :keyword:`finally` "
|
|
"blocks::"
|
|
msgstr ""
|
|
|
|
#: ../Doc/tutorial/inputoutput.rst:378
|
|
msgid ""
|
|
"File objects have some additional methods, such as :meth:`~file.isatty` and :"
|
|
"meth:`~file.truncate` which are less frequently used; consult the Library "
|
|
"Reference for a complete guide to file objects."
|
|
msgstr ""
|
|
|
|
#: ../Doc/tutorial/inputoutput.rst:386
|
|
msgid "Saving structured data with :mod:`json`"
|
|
msgstr ""
|
|
|
|
#: ../Doc/tutorial/inputoutput.rst:390
|
|
msgid ""
|
|
"Strings can easily be written to and read from a file. Numbers take a bit "
|
|
"more effort, since the :meth:`read` method only returns strings, which will "
|
|
"have to be passed to a function like :func:`int`, which takes a string like "
|
|
"``'123'`` and returns its numeric value 123. When you want to save more "
|
|
"complex data types like nested lists and dictionaries, parsing and "
|
|
"serializing by hand becomes complicated."
|
|
msgstr ""
|
|
|
|
#: ../Doc/tutorial/inputoutput.rst:397
|
|
msgid ""
|
|
"Rather than having users constantly writing and debugging code to save "
|
|
"complicated data types to files, Python allows you to use the popular data "
|
|
"interchange format called `JSON (JavaScript Object Notation) <http://json."
|
|
"org>`_. The standard module called :mod:`json` can take Python data "
|
|
"hierarchies, and convert them to string representations; this process is "
|
|
"called :dfn:`serializing`. Reconstructing the data from the string "
|
|
"representation is called :dfn:`deserializing`. Between serializing and "
|
|
"deserializing, the string representing the object may have been stored in a "
|
|
"file or data, or sent over a network connection to some distant machine."
|
|
msgstr ""
|
|
|
|
#: ../Doc/tutorial/inputoutput.rst:408
|
|
msgid ""
|
|
"The JSON format is commonly used by modern applications to allow for data "
|
|
"exchange. Many programmers are already familiar with it, which makes it a "
|
|
"good choice for interoperability."
|
|
msgstr ""
|
|
|
|
#: ../Doc/tutorial/inputoutput.rst:412
|
|
msgid ""
|
|
"If you have an object ``x``, you can view its JSON string representation "
|
|
"with a simple line of code::"
|
|
msgstr ""
|
|
|
|
#: ../Doc/tutorial/inputoutput.rst:418
|
|
msgid ""
|
|
"Another variant of the :func:`~json.dumps` function, called :func:`~json."
|
|
"dump`, simply serializes the object to a :term:`text file`. So if ``f`` is "
|
|
"a :term:`text file` object opened for writing, we can do this::"
|
|
msgstr ""
|
|
|
|
#: ../Doc/tutorial/inputoutput.rst:424
|
|
msgid ""
|
|
"To decode the object again, if ``f`` is a :term:`text file` object which has "
|
|
"been opened for reading::"
|
|
msgstr ""
|
|
|
|
#: ../Doc/tutorial/inputoutput.rst:429
|
|
msgid ""
|
|
"This simple serialization technique can handle lists and dictionaries, but "
|
|
"serializing arbitrary class instances in JSON requires a bit of extra "
|
|
"effort. The reference for the :mod:`json` module contains an explanation of "
|
|
"this."
|
|
msgstr ""
|
|
|
|
#: ../Doc/tutorial/inputoutput.rst:435
|
|
msgid ":mod:`pickle` - the pickle module"
|
|
msgstr ""
|
|
|
|
#: ../Doc/tutorial/inputoutput.rst:437
|
|
msgid ""
|
|
"Contrary to :ref:`JSON <tut-json>`, *pickle* is a protocol which allows the "
|
|
"serialization of arbitrarily complex Python objects. As such, it is "
|
|
"specific to Python and cannot be used to communicate with applications "
|
|
"written in other languages. It is also insecure by default: deserializing "
|
|
"pickle data coming from an untrusted source can execute arbitrary code, if "
|
|
"the data was crafted by a skilled attacker."
|
|
msgstr ""
|
|
|
|
#: ../Doc/tutorial/interactive.rst:5
|
|
msgid "Interactive Input Editing and History Substitution"
|
|
msgstr ""
|
|
|
|
#: ../Doc/tutorial/interactive.rst:7
|
|
msgid ""
|
|
"Some versions of the Python interpreter support editing of the current input "
|
|
"line and history substitution, similar to facilities found in the Korn shell "
|
|
"and the GNU Bash shell. This is implemented using the `GNU Readline`_ "
|
|
"library, which supports various styles of editing. This library has its own "
|
|
"documentation which we won't duplicate here."
|
|
msgstr ""
|
|
|
|
#: ../Doc/tutorial/interactive.rst:17
|
|
msgid "Tab Completion and History Editing"
|
|
msgstr ""
|
|
|
|
#: ../Doc/tutorial/interactive.rst:19
|
|
msgid ""
|
|
"Completion of variable and module names is :ref:`automatically enabled "
|
|
"<rlcompleter-config>` at interpreter startup so that the :kbd:`Tab` key "
|
|
"invokes the completion function; it looks at Python statement names, the "
|
|
"current local variables, and the available module names. For dotted "
|
|
"expressions such as ``string.a``, it will evaluate the expression up to the "
|
|
"final ``'.'`` and then suggest completions from the attributes of the "
|
|
"resulting object. Note that this may execute application-defined code if an "
|
|
"object with a :meth:`__getattr__` method is part of the expression. The "
|
|
"default configuration also saves your history into a file named :file:`."
|
|
"python_history` in your user directory. The history will be available again "
|
|
"during the next interactive interpreter session."
|
|
msgstr ""
|
|
|
|
#: ../Doc/tutorial/interactive.rst:36
|
|
msgid "Alternatives to the Interactive Interpreter"
|
|
msgstr ""
|
|
|
|
#: ../Doc/tutorial/interactive.rst:38
|
|
msgid ""
|
|
"This facility is an enormous step forward compared to earlier versions of "
|
|
"the interpreter; however, some wishes are left: It would be nice if the "
|
|
"proper indentation were suggested on continuation lines (the parser knows if "
|
|
"an indent token is required next). The completion mechanism might use the "
|
|
"interpreter's symbol table. A command to check (or even suggest) matching "
|
|
"parentheses, quotes, etc., would also be useful."
|
|
msgstr ""
|
|
|
|
#: ../Doc/tutorial/interactive.rst:45
|
|
msgid ""
|
|
"One alternative enhanced interactive interpreter that has been around for "
|
|
"quite some time is IPython_, which features tab completion, object "
|
|
"exploration and advanced history management. It can also be thoroughly "
|
|
"customized and embedded into other applications. Another similar enhanced "
|
|
"interactive environment is bpython_."
|
|
msgstr ""
|
|
|
|
#: ../Doc/tutorial/interpreter.rst:5
|
|
msgid "Using the Python Interpreter"
|
|
msgstr ""
|
|
|
|
#: ../Doc/tutorial/interpreter.rst:11
|
|
msgid "Invoking the Interpreter"
|
|
msgstr ""
|
|
|
|
#: ../Doc/tutorial/interpreter.rst:13
|
|
msgid ""
|
|
"The Python interpreter is usually installed as :file:`/usr/local/bin/"
|
|
"python3.6` on those machines where it is available; putting :file:`/usr/"
|
|
"local/bin` in your Unix shell's search path makes it possible to start it by "
|
|
"typing the command:"
|
|
msgstr ""
|
|
|
|
#: ../Doc/tutorial/interpreter.rst:21
|
|
msgid ""
|
|
"to the shell. [#]_ Since the choice of the directory where the interpreter "
|
|
"lives is an installation option, other places are possible; check with your "
|
|
"local Python guru or system administrator. (E.g., :file:`/usr/local/python` "
|
|
"is a popular alternative location.)"
|
|
msgstr ""
|
|
|
|
#: ../Doc/tutorial/interpreter.rst:26
|
|
msgid ""
|
|
"On Windows machines, the Python installation is usually placed in :file:`C:\\"
|
|
"\\Python36`, though you can change this when you're running the installer. "
|
|
"To add this directory to your path, you can type the following command into "
|
|
"the command prompt in a DOS box::"
|
|
msgstr ""
|
|
|
|
#: ../Doc/tutorial/interpreter.rst:33
|
|
msgid ""
|
|
"Typing an end-of-file character (:kbd:`Control-D` on Unix, :kbd:`Control-Z` "
|
|
"on Windows) at the primary prompt causes the interpreter to exit with a zero "
|
|
"exit status. If that doesn't work, you can exit the interpreter by typing "
|
|
"the following command: ``quit()``."
|
|
msgstr ""
|
|
|
|
#: ../Doc/tutorial/interpreter.rst:38
|
|
msgid ""
|
|
"The interpreter's line-editing features include interactive editing, history "
|
|
"substitution and code completion on systems that support readline. Perhaps "
|
|
"the quickest check to see whether command line editing is supported is "
|
|
"typing :kbd:`Control-P` to the first Python prompt you get. If it beeps, "
|
|
"you have command line editing; see Appendix :ref:`tut-interacting` for an "
|
|
"introduction to the keys. If nothing appears to happen, or if ``^P`` is "
|
|
"echoed, command line editing isn't available; you'll only be able to use "
|
|
"backspace to remove characters from the current line."
|
|
msgstr ""
|
|
|
|
#: ../Doc/tutorial/interpreter.rst:47
|
|
msgid ""
|
|
"The interpreter operates somewhat like the Unix shell: when called with "
|
|
"standard input connected to a tty device, it reads and executes commands "
|
|
"interactively; when called with a file name argument or with a file as "
|
|
"standard input, it reads and executes a *script* from that file."
|
|
msgstr ""
|
|
|
|
#: ../Doc/tutorial/interpreter.rst:52
|
|
msgid ""
|
|
"A second way of starting the interpreter is ``python -c command [arg] ...``, "
|
|
"which executes the statement(s) in *command*, analogous to the shell's :"
|
|
"option:`-c` option. Since Python statements often contain spaces or other "
|
|
"characters that are special to the shell, it is usually advised to quote "
|
|
"*command* in its entirety with single quotes."
|
|
msgstr ""
|
|
|
|
#: ../Doc/tutorial/interpreter.rst:58
|
|
msgid ""
|
|
"Some Python modules are also useful as scripts. These can be invoked using "
|
|
"``python -m module [arg] ...``, which executes the source file for *module* "
|
|
"as if you had spelled out its full name on the command line."
|
|
msgstr ""
|
|
|
|
#: ../Doc/tutorial/interpreter.rst:62
|
|
msgid ""
|
|
"When a script file is used, it is sometimes useful to be able to run the "
|
|
"script and enter interactive mode afterwards. This can be done by passing :"
|
|
"option:`-i` before the script."
|
|
msgstr ""
|
|
|
|
#: ../Doc/tutorial/interpreter.rst:66
|
|
msgid "All command line options are described in :ref:`using-on-general`."
|
|
msgstr ""
|
|
|
|
#: ../Doc/tutorial/interpreter.rst:72
|
|
msgid "Argument Passing"
|
|
msgstr ""
|
|
|
|
#: ../Doc/tutorial/interpreter.rst:74
|
|
msgid ""
|
|
"When known to the interpreter, the script name and additional arguments "
|
|
"thereafter are turned into a list of strings and assigned to the ``argv`` "
|
|
"variable in the ``sys`` module. You can access this list by executing "
|
|
"``import sys``. The length of the list is at least one; when no script and "
|
|
"no arguments are given, ``sys.argv[0]`` is an empty string. When the script "
|
|
"name is given as ``'-'`` (meaning standard input), ``sys.argv[0]`` is set "
|
|
"to ``'-'``. When :option:`-c` *command* is used, ``sys.argv[0]`` is set to "
|
|
"``'-c'``. When :option:`-m` *module* is used, ``sys.argv[0]`` is set to "
|
|
"the full name of the located module. Options found after :option:`-c` "
|
|
"*command* or :option:`-m` *module* are not consumed by the Python "
|
|
"interpreter's option processing but left in ``sys.argv`` for the command or "
|
|
"module to handle."
|
|
msgstr ""
|
|
|
|
#: ../Doc/tutorial/interpreter.rst:92
|
|
msgid ""
|
|
"When commands are read from a tty, the interpreter is said to be in "
|
|
"*interactive mode*. In this mode it prompts for the next command with the "
|
|
"*primary prompt*, usually three greater-than signs (``>>>``); for "
|
|
"continuation lines it prompts with the *secondary prompt*, by default three "
|
|
"dots (``...``). The interpreter prints a welcome message stating its version "
|
|
"number and a copyright notice before printing the first prompt:"
|
|
msgstr ""
|
|
|
|
#: ../Doc/tutorial/interpreter.rst:109
|
|
msgid ""
|
|
"Continuation lines are needed when entering a multi-line construct. As an "
|
|
"example, take a look at this :keyword:`if` statement::"
|
|
msgstr ""
|
|
|
|
#: ../Doc/tutorial/interpreter.rst:119
|
|
msgid "For more on interactive mode, see :ref:`tut-interac`."
|
|
msgstr ""
|
|
|
|
#: ../Doc/tutorial/interpreter.rst:125
|
|
msgid "The Interpreter and Its Environment"
|
|
msgstr ""
|
|
|
|
#: ../Doc/tutorial/interpreter.rst:131
|
|
msgid "Source Code Encoding"
|
|
msgstr ""
|
|
|
|
#: ../Doc/tutorial/interpreter.rst:133
|
|
msgid ""
|
|
"By default, Python source files are treated as encoded in UTF-8. In that "
|
|
"encoding, characters of most languages in the world can be used "
|
|
"simultaneously in string literals, identifiers and comments --- although the "
|
|
"standard library only uses ASCII characters for identifiers, a convention "
|
|
"that any portable code should follow. To display all these characters "
|
|
"properly, your editor must recognize that the file is UTF-8, and it must use "
|
|
"a font that supports all the characters in the file."
|
|
msgstr ""
|
|
|
|
#: ../Doc/tutorial/interpreter.rst:141
|
|
msgid ""
|
|
"It is also possible to specify a different encoding for source files. In "
|
|
"order to do this, put one more special comment line right after the ``#!`` "
|
|
"line to define the source file encoding::"
|
|
msgstr ""
|
|
|
|
#: ../Doc/tutorial/interpreter.rst:147
|
|
msgid ""
|
|
"With that declaration, everything in the source file will be treated as "
|
|
"having the encoding *encoding* instead of UTF-8. The list of possible "
|
|
"encodings can be found in the Python Library Reference, in the section on :"
|
|
"mod:`codecs`."
|
|
msgstr ""
|
|
|
|
#: ../Doc/tutorial/interpreter.rst:151
|
|
msgid ""
|
|
"For example, if your editor of choice does not support UTF-8 encoded files "
|
|
"and insists on using some other encoding, say Windows-1252, you can write::"
|
|
msgstr ""
|
|
|
|
#: ../Doc/tutorial/interpreter.rst:156
|
|
msgid ""
|
|
"and still use all characters in the Windows-1252 character set in the source "
|
|
"files. The special encoding comment must be in the *first or second* line "
|
|
"within the file."
|
|
msgstr ""
|
|
|
|
#: ../Doc/tutorial/interpreter.rst:163
|
|
msgid ""
|
|
"On Unix, the Python 3.x interpreter is by default not installed with the "
|
|
"executable named ``python``, so that it does not conflict with a "
|
|
"simultaneously installed Python 2.x executable."
|
|
msgstr ""
|
|
|
|
#: ../Doc/tutorial/introduction.rst:5
|
|
msgid "An Informal Introduction to Python"
|
|
msgstr ""
|
|
|
|
#: ../Doc/tutorial/introduction.rst:7
|
|
msgid ""
|
|
"In the following examples, input and output are distinguished by the "
|
|
"presence or absence of prompts (:term:`>>>` and :term:`...`): to repeat the "
|
|
"example, you must type everything after the prompt, when the prompt appears; "
|
|
"lines that do not begin with a prompt are output from the interpreter. Note "
|
|
"that a secondary prompt on a line by itself in an example means you must "
|
|
"type a blank line; this is used to end a multi-line command."
|
|
msgstr ""
|
|
|
|
#: ../Doc/tutorial/introduction.rst:14
|
|
msgid ""
|
|
"Many of the examples in this manual, even those entered at the interactive "
|
|
"prompt, include comments. Comments in Python start with the hash character, "
|
|
"``#``, and extend to the end of the physical line. A comment may appear at "
|
|
"the start of a line or following whitespace or code, but not within a string "
|
|
"literal. A hash character within a string literal is just a hash character. "
|
|
"Since comments are to clarify code and are not interpreted by Python, they "
|
|
"may be omitted when typing in examples."
|
|
msgstr ""
|
|
|
|
#: ../Doc/tutorial/introduction.rst:33
|
|
msgid "Using Python as a Calculator"
|
|
msgstr ""
|
|
|
|
#: ../Doc/tutorial/introduction.rst:35
|
|
msgid ""
|
|
"Let's try some simple Python commands. Start the interpreter and wait for "
|
|
"the primary prompt, ``>>>``. (It shouldn't take long.)"
|
|
msgstr ""
|
|
|
|
#: ../Doc/tutorial/introduction.rst:42
|
|
msgid "Numbers"
|
|
msgstr ""
|
|
|
|
#: ../Doc/tutorial/introduction.rst:44
|
|
msgid ""
|
|
"The interpreter acts as a simple calculator: you can type an expression at "
|
|
"it and it will write the value. Expression syntax is straightforward: the "
|
|
"operators ``+``, ``-``, ``*`` and ``/`` work just like in most other "
|
|
"languages (for example, Pascal or C); parentheses (``()``) can be used for "
|
|
"grouping. For example::"
|
|
msgstr ""
|
|
|
|
#: ../Doc/tutorial/introduction.rst:59
|
|
msgid ""
|
|
"The integer numbers (e.g. ``2``, ``4``, ``20``) have type :class:`int`, the "
|
|
"ones with a fractional part (e.g. ``5.0``, ``1.6``) have type :class:"
|
|
"`float`. We will see more about numeric types later in the tutorial."
|
|
msgstr ""
|
|
|
|
#: ../Doc/tutorial/introduction.rst:63
|
|
msgid ""
|
|
"Division (``/``) always returns a float. To do :term:`floor division` and "
|
|
"get an integer result (discarding any fractional result) you can use the ``//"
|
|
"`` operator; to calculate the remainder you can use ``%``::"
|
|
msgstr ""
|
|
|
|
#: ../Doc/tutorial/introduction.rst:77
|
|
msgid ""
|
|
"With Python, it is possible to use the ``**`` operator to calculate powers "
|
|
"[#]_::"
|
|
msgstr ""
|
|
|
|
#: ../Doc/tutorial/introduction.rst:84
|
|
msgid ""
|
|
"The equal sign (``=``) is used to assign a value to a variable. Afterwards, "
|
|
"no result is displayed before the next interactive prompt::"
|
|
msgstr ""
|
|
|
|
#: ../Doc/tutorial/introduction.rst:92
|
|
msgid ""
|
|
"If a variable is not \"defined\" (assigned a value), trying to use it will "
|
|
"give you an error::"
|
|
msgstr ""
|
|
|
|
#: ../Doc/tutorial/introduction.rst:100
|
|
msgid ""
|
|
"There is full support for floating point; operators with mixed type operands "
|
|
"convert the integer operand to floating point::"
|
|
msgstr ""
|
|
|
|
#: ../Doc/tutorial/introduction.rst:108
|
|
msgid ""
|
|
"In interactive mode, the last printed expression is assigned to the variable "
|
|
"``_``. This means that when you are using Python as a desk calculator, it "
|
|
"is somewhat easier to continue calculations, for example::"
|
|
msgstr ""
|
|
|
|
#: ../Doc/tutorial/introduction.rst:121
|
|
msgid ""
|
|
"This variable should be treated as read-only by the user. Don't explicitly "
|
|
"assign a value to it --- you would create an independent local variable with "
|
|
"the same name masking the built-in variable with its magic behavior."
|
|
msgstr ""
|
|
|
|
#: ../Doc/tutorial/introduction.rst:125
|
|
msgid ""
|
|
"In addition to :class:`int` and :class:`float`, Python supports other types "
|
|
"of numbers, such as :class:`~decimal.Decimal` and :class:`~fractions."
|
|
"Fraction`. Python also has built-in support for :ref:`complex numbers "
|
|
"<typesnumeric>`, and uses the ``j`` or ``J`` suffix to indicate the "
|
|
"imaginary part (e.g. ``3+5j``)."
|
|
msgstr ""
|
|
|
|
#: ../Doc/tutorial/introduction.rst:135
|
|
msgid "Strings"
|
|
msgstr ""
|
|
|
|
#: ../Doc/tutorial/introduction.rst:137
|
|
msgid ""
|
|
"Besides numbers, Python can also manipulate strings, which can be expressed "
|
|
"in several ways. They can be enclosed in single quotes (``'...'``) or "
|
|
"double quotes (``\"...\"``) with the same result [#]_. ``\\`` can be used "
|
|
"to escape quotes::"
|
|
msgstr ""
|
|
|
|
#: ../Doc/tutorial/introduction.rst:155
|
|
msgid ""
|
|
"In the interactive interpreter, the output string is enclosed in quotes and "
|
|
"special characters are escaped with backslashes. While this might sometimes "
|
|
"look different from the input (the enclosing quotes could change), the two "
|
|
"strings are equivalent. The string is enclosed in double quotes if the "
|
|
"string contains a single quote and no double quotes, otherwise it is "
|
|
"enclosed in single quotes. The :func:`print` function produces a more "
|
|
"readable output, by omitting the enclosing quotes and by printing escaped "
|
|
"and special characters::"
|
|
msgstr ""
|
|
|
|
#: ../Doc/tutorial/introduction.rst:175
|
|
msgid ""
|
|
"If you don't want characters prefaced by ``\\`` to be interpreted as special "
|
|
"characters, you can use *raw strings* by adding an ``r`` before the first "
|
|
"quote::"
|
|
msgstr ""
|
|
|
|
#: ../Doc/tutorial/introduction.rst:185
|
|
msgid ""
|
|
"String literals can span multiple lines. One way is using triple-quotes: ``"
|
|
"\"\"\"...\"\"\"`` or ``'''...'''``. End of lines are automatically included "
|
|
"in the string, but it's possible to prevent this by adding a ``\\`` at the "
|
|
"end of the line. The following example::"
|
|
msgstr ""
|
|
|
|
#: ../Doc/tutorial/introduction.rst:196
|
|
msgid ""
|
|
"produces the following output (note that the initial newline is not "
|
|
"included):"
|
|
msgstr ""
|
|
|
|
#: ../Doc/tutorial/introduction.rst:204
|
|
msgid ""
|
|
"Strings can be concatenated (glued together) with the ``+`` operator, and "
|
|
"repeated with ``*``::"
|
|
msgstr ""
|
|
|
|
#: ../Doc/tutorial/introduction.rst:211
|
|
msgid ""
|
|
"Two or more *string literals* (i.e. the ones enclosed between quotes) next "
|
|
"to each other are automatically concatenated. ::"
|
|
msgstr ""
|
|
|
|
#: ../Doc/tutorial/introduction.rst:217
|
|
msgid ""
|
|
"This only works with two literals though, not with variables or expressions::"
|
|
msgstr ""
|
|
|
|
#: ../Doc/tutorial/introduction.rst:227
|
|
msgid ""
|
|
"If you want to concatenate variables or a variable and a literal, use ``+``::"
|
|
msgstr ""
|
|
|
|
#: ../Doc/tutorial/introduction.rst:232
|
|
msgid ""
|
|
"This feature is particularly useful when you want to break long strings::"
|
|
msgstr ""
|
|
|
|
#: ../Doc/tutorial/introduction.rst:239
|
|
msgid ""
|
|
"Strings can be *indexed* (subscripted), with the first character having "
|
|
"index 0. There is no separate character type; a character is simply a string "
|
|
"of size one::"
|
|
msgstr ""
|
|
|
|
#: ../Doc/tutorial/introduction.rst:249
|
|
msgid ""
|
|
"Indices may also be negative numbers, to start counting from the right::"
|
|
msgstr ""
|
|
|
|
#: ../Doc/tutorial/introduction.rst:258
|
|
msgid "Note that since -0 is the same as 0, negative indices start from -1."
|
|
msgstr ""
|
|
|
|
#: ../Doc/tutorial/introduction.rst:260
|
|
msgid ""
|
|
"In addition to indexing, *slicing* is also supported. While indexing is "
|
|
"used to obtain individual characters, *slicing* allows you to obtain "
|
|
"substring::"
|
|
msgstr ""
|
|
|
|
#: ../Doc/tutorial/introduction.rst:268
|
|
msgid ""
|
|
"Note how the start is always included, and the end always excluded. This "
|
|
"makes sure that ``s[:i] + s[i:]`` is always equal to ``s``::"
|
|
msgstr ""
|
|
|
|
#: ../Doc/tutorial/introduction.rst:276
|
|
msgid ""
|
|
"Slice indices have useful defaults; an omitted first index defaults to zero, "
|
|
"an omitted second index defaults to the size of the string being sliced. ::"
|
|
msgstr ""
|
|
|
|
#: ../Doc/tutorial/introduction.rst:286
|
|
msgid ""
|
|
"One way to remember how slices work is to think of the indices as pointing "
|
|
"*between* characters, with the left edge of the first character numbered 0. "
|
|
"Then the right edge of the last character of a string of *n* characters has "
|
|
"index *n*, for example::"
|
|
msgstr ""
|
|
|
|
#: ../Doc/tutorial/introduction.rst:297
|
|
msgid ""
|
|
"The first row of numbers gives the position of the indices 0...6 in the "
|
|
"string; the second row gives the corresponding negative indices. The slice "
|
|
"from *i* to *j* consists of all characters between the edges labeled *i* and "
|
|
"*j*, respectively."
|
|
msgstr ""
|
|
|
|
#: ../Doc/tutorial/introduction.rst:302
|
|
msgid ""
|
|
"For non-negative indices, the length of a slice is the difference of the "
|
|
"indices, if both are within bounds. For example, the length of "
|
|
"``word[1:3]`` is 2."
|
|
msgstr ""
|
|
|
|
#: ../Doc/tutorial/introduction.rst:306
|
|
msgid "Attempting to use an index that is too large will result in an error::"
|
|
msgstr ""
|
|
|
|
#: ../Doc/tutorial/introduction.rst:313
|
|
msgid ""
|
|
"However, out of range slice indexes are handled gracefully when used for "
|
|
"slicing::"
|
|
msgstr ""
|
|
|
|
#: ../Doc/tutorial/introduction.rst:321
|
|
msgid ""
|
|
"Python strings cannot be changed --- they are :term:`immutable`. Therefore, "
|
|
"assigning to an indexed position in the string results in an error::"
|
|
msgstr ""
|
|
|
|
#: ../Doc/tutorial/introduction.rst:331
|
|
msgid "If you need a different string, you should create a new one::"
|
|
msgstr ""
|
|
|
|
#: ../Doc/tutorial/introduction.rst:338
|
|
msgid "The built-in function :func:`len` returns the length of a string::"
|
|
msgstr ""
|
|
|
|
#: ../Doc/tutorial/introduction.rst:349
|
|
msgid ":ref:`textseq`"
|
|
msgstr ""
|
|
|
|
#: ../Doc/tutorial/introduction.rst:348
|
|
msgid ""
|
|
"Strings are examples of *sequence types*, and support the common operations "
|
|
"supported by such types."
|
|
msgstr ""
|
|
|
|
#: ../Doc/tutorial/introduction.rst:353
|
|
msgid ":ref:`string-methods`"
|
|
msgstr ""
|
|
|
|
#: ../Doc/tutorial/introduction.rst:352
|
|
msgid ""
|
|
"Strings support a large number of methods for basic transformations and "
|
|
"searching."
|
|
msgstr ""
|
|
|
|
#: ../Doc/tutorial/introduction.rst:356
|
|
msgid ":ref:`f-strings`"
|
|
msgstr ""
|
|
|
|
#: ../Doc/tutorial/introduction.rst:356
|
|
msgid "String literals that have embedded expressions."
|
|
msgstr ""
|
|
|
|
#: ../Doc/tutorial/introduction.rst:359
|
|
msgid ":ref:`formatstrings`"
|
|
msgstr ""
|
|
|
|
#: ../Doc/tutorial/introduction.rst:359
|
|
msgid "Information about string formatting with :meth:`str.format`."
|
|
msgstr ""
|
|
|
|
#: ../Doc/tutorial/introduction.rst:362
|
|
msgid ":ref:`old-string-formatting`"
|
|
msgstr ""
|
|
|
|
#: ../Doc/tutorial/introduction.rst:362
|
|
msgid ""
|
|
"The old formatting operations invoked when strings and Unicode strings are "
|
|
"the left operand of the ``%`` operator are described in more detail here."
|
|
msgstr ""
|
|
|
|
#: ../Doc/tutorial/introduction.rst:369
|
|
msgid "Lists"
|
|
msgstr ""
|
|
|
|
#: ../Doc/tutorial/introduction.rst:371
|
|
msgid ""
|
|
"Python knows a number of *compound* data types, used to group together other "
|
|
"values. The most versatile is the *list*, which can be written as a list of "
|
|
"comma-separated values (items) between square brackets. Lists might contain "
|
|
"items of different types, but usually the items all have the same type. ::"
|
|
msgstr ""
|
|
|
|
#: ../Doc/tutorial/introduction.rst:380
|
|
msgid ""
|
|
"Like strings (and all other built-in :term:`sequence` type), lists can be "
|
|
"indexed and sliced::"
|
|
msgstr ""
|
|
|
|
#: ../Doc/tutorial/introduction.rst:390
|
|
msgid ""
|
|
"All slice operations return a new list containing the requested elements. "
|
|
"This means that the following slice returns a new (shallow) copy of the "
|
|
"list::"
|
|
msgstr ""
|
|
|
|
#: ../Doc/tutorial/introduction.rst:396
|
|
msgid "Lists also support operations like concatenation::"
|
|
msgstr ""
|
|
|
|
#: ../Doc/tutorial/introduction.rst:401
|
|
msgid ""
|
|
"Unlike strings, which are :term:`immutable`, lists are a :term:`mutable` "
|
|
"type, i.e. it is possible to change their content::"
|
|
msgstr ""
|
|
|
|
#: ../Doc/tutorial/introduction.rst:411
|
|
msgid ""
|
|
"You can also add new items at the end of the list, by using the :meth:`~list."
|
|
"append` *method* (we will see more about methods later)::"
|
|
msgstr ""
|
|
|
|
#: ../Doc/tutorial/introduction.rst:419
|
|
msgid ""
|
|
"Assignment to slices is also possible, and this can even change the size of "
|
|
"the list or clear it entirely::"
|
|
msgstr ""
|
|
|
|
#: ../Doc/tutorial/introduction.rst:438
|
|
msgid "The built-in function :func:`len` also applies to lists::"
|
|
msgstr ""
|
|
|
|
#: ../Doc/tutorial/introduction.rst:444
|
|
msgid ""
|
|
"It is possible to nest lists (create lists containing other lists), for "
|
|
"example::"
|
|
msgstr ""
|
|
|
|
#: ../Doc/tutorial/introduction.rst:460
|
|
msgid "First Steps Towards Programming"
|
|
msgstr ""
|
|
|
|
#: ../Doc/tutorial/introduction.rst:462
|
|
msgid ""
|
|
"Of course, we can use Python for more complicated tasks than adding two and "
|
|
"two together. For instance, we can write an initial sub-sequence of the "
|
|
"*Fibonacci* series as follows::"
|
|
msgstr ""
|
|
|
|
#: ../Doc/tutorial/introduction.rst:480
|
|
msgid "This example introduces several new features."
|
|
msgstr ""
|
|
|
|
#: ../Doc/tutorial/introduction.rst:482
|
|
msgid ""
|
|
"The first line contains a *multiple assignment*: the variables ``a`` and "
|
|
"``b`` simultaneously get the new values 0 and 1. On the last line this is "
|
|
"used again, demonstrating that the expressions on the right-hand side are "
|
|
"all evaluated first before any of the assignments take place. The right-"
|
|
"hand side expressions are evaluated from the left to the right."
|
|
msgstr ""
|
|
|
|
#: ../Doc/tutorial/introduction.rst:488
|
|
msgid ""
|
|
"The :keyword:`while` loop executes as long as the condition (here: ``b < "
|
|
"10``) remains true. In Python, like in C, any non-zero integer value is "
|
|
"true; zero is false. The condition may also be a string or list value, in "
|
|
"fact any sequence; anything with a non-zero length is true, empty sequences "
|
|
"are false. The test used in the example is a simple comparison. The "
|
|
"standard comparison operators are written the same as in C: ``<`` (less "
|
|
"than), ``>`` (greater than), ``==`` (equal to), ``<=`` (less than or equal "
|
|
"to), ``>=`` (greater than or equal to) and ``!=`` (not equal to)."
|
|
msgstr ""
|
|
|
|
#: ../Doc/tutorial/introduction.rst:497
|
|
msgid ""
|
|
"The *body* of the loop is *indented*: indentation is Python's way of "
|
|
"grouping statements. At the interactive prompt, you have to type a tab or "
|
|
"space(s) for each indented line. In practice you will prepare more "
|
|
"complicated input for Python with a text editor; all decent text editors "
|
|
"have an auto-indent facility. When a compound statement is entered "
|
|
"interactively, it must be followed by a blank line to indicate completion "
|
|
"(since the parser cannot guess when you have typed the last line). Note "
|
|
"that each line within a basic block must be indented by the same amount."
|
|
msgstr ""
|
|
|
|
#: ../Doc/tutorial/introduction.rst:506
|
|
msgid ""
|
|
"The :func:`print` function writes the value of the argument(s) it is given. "
|
|
"It differs from just writing the expression you want to write (as we did "
|
|
"earlier in the calculator examples) in the way it handles multiple "
|
|
"arguments, floating point quantities, and strings. Strings are printed "
|
|
"without quotes, and a space is inserted between items, so you can format "
|
|
"things nicely, like this::"
|
|
msgstr ""
|
|
|
|
#: ../Doc/tutorial/introduction.rst:517
|
|
msgid ""
|
|
"The keyword argument *end* can be used to avoid the newline after the "
|
|
"output, or end the output with a different string::"
|
|
msgstr ""
|
|
|
|
#: ../Doc/tutorial/introduction.rst:530
|
|
msgid ""
|
|
"Since ``**`` has higher precedence than ``-``, ``-3**2`` will be interpreted "
|
|
"as ``-(3**2)`` and thus result in ``-9``. To avoid this and get ``9``, you "
|
|
"can use ``(-3)**2``."
|
|
msgstr ""
|
|
|
|
#: ../Doc/tutorial/introduction.rst:534
|
|
msgid ""
|
|
"Unlike other languages, special characters such as ``\\n`` have the same "
|
|
"meaning with both single (``'...'``) and double (``\"...\"``) quotes. The "
|
|
"only difference between the two is that within single quotes you don't need "
|
|
"to escape ``\"`` (but you have to escape ``\\'``) and vice versa."
|
|
msgstr ""
|
|
|
|
#: ../Doc/tutorial/modules.rst:5
|
|
msgid "Modules"
|
|
msgstr ""
|
|
|
|
#: ../Doc/tutorial/modules.rst:7
|
|
msgid ""
|
|
"If you quit from the Python interpreter and enter it again, the definitions "
|
|
"you have made (functions and variables) are lost. Therefore, if you want to "
|
|
"write a somewhat longer program, you are better off using a text editor to "
|
|
"prepare the input for the interpreter and running it with that file as input "
|
|
"instead. This is known as creating a *script*. As your program gets "
|
|
"longer, you may want to split it into several files for easier maintenance. "
|
|
"You may also want to use a handy function that you've written in several "
|
|
"programs without copying its definition into each program."
|
|
msgstr ""
|
|
|
|
#: ../Doc/tutorial/modules.rst:16
|
|
msgid ""
|
|
"To support this, Python has a way to put definitions in a file and use them "
|
|
"in a script or in an interactive instance of the interpreter. Such a file is "
|
|
"called a *module*; definitions from a module can be *imported* into other "
|
|
"modules or into the *main* module (the collection of variables that you have "
|
|
"access to in a script executed at the top level and in calculator mode)."
|
|
msgstr ""
|
|
|
|
#: ../Doc/tutorial/modules.rst:22
|
|
msgid ""
|
|
"A module is a file containing Python definitions and statements. The file "
|
|
"name is the module name with the suffix :file:`.py` appended. Within a "
|
|
"module, the module's name (as a string) is available as the value of the "
|
|
"global variable ``__name__``. For instance, use your favorite text editor "
|
|
"to create a file called :file:`fibo.py` in the current directory with the "
|
|
"following contents::"
|
|
msgstr ""
|
|
|
|
#: ../Doc/tutorial/modules.rst:45
|
|
msgid ""
|
|
"Now enter the Python interpreter and import this module with the following "
|
|
"command::"
|
|
msgstr ""
|
|
|
|
#: ../Doc/tutorial/modules.rst:50
|
|
msgid ""
|
|
"This does not enter the names of the functions defined in ``fibo`` directly "
|
|
"in the current symbol table; it only enters the module name ``fibo`` there. "
|
|
"Using the module name you can access the functions::"
|
|
msgstr ""
|
|
|
|
#: ../Doc/tutorial/modules.rst:61
|
|
msgid ""
|
|
"If you intend to use a function often you can assign it to a local name::"
|
|
msgstr ""
|
|
|
|
#: ../Doc/tutorial/modules.rst:71
|
|
msgid "More on Modules"
|
|
msgstr ""
|
|
|
|
#: ../Doc/tutorial/modules.rst:73
|
|
msgid ""
|
|
"A module can contain executable statements as well as function definitions. "
|
|
"These statements are intended to initialize the module. They are executed "
|
|
"only the *first* time the module name is encountered in an import statement. "
|
|
"[#]_ (They are also run if the file is executed as a script.)"
|
|
msgstr ""
|
|
|
|
#: ../Doc/tutorial/modules.rst:78
|
|
msgid ""
|
|
"Each module has its own private symbol table, which is used as the global "
|
|
"symbol table by all functions defined in the module. Thus, the author of a "
|
|
"module can use global variables in the module without worrying about "
|
|
"accidental clashes with a user's global variables. On the other hand, if you "
|
|
"know what you are doing you can touch a module's global variables with the "
|
|
"same notation used to refer to its functions, ``modname.itemname``."
|
|
msgstr ""
|
|
|
|
#: ../Doc/tutorial/modules.rst:85
|
|
msgid ""
|
|
"Modules can import other modules. It is customary but not required to place "
|
|
"all :keyword:`import` statements at the beginning of a module (or script, "
|
|
"for that matter). The imported module names are placed in the importing "
|
|
"module's global symbol table."
|
|
msgstr ""
|
|
|
|
#: ../Doc/tutorial/modules.rst:90
|
|
msgid ""
|
|
"There is a variant of the :keyword:`import` statement that imports names "
|
|
"from a module directly into the importing module's symbol table. For "
|
|
"example::"
|
|
msgstr ""
|
|
|
|
#: ../Doc/tutorial/modules.rst:97
|
|
msgid ""
|
|
"This does not introduce the module name from which the imports are taken in "
|
|
"the local symbol table (so in the example, ``fibo`` is not defined)."
|
|
msgstr ""
|
|
|
|
#: ../Doc/tutorial/modules.rst:100
|
|
msgid "There is even a variant to import all names that a module defines::"
|
|
msgstr ""
|
|
|
|
#: ../Doc/tutorial/modules.rst:106
|
|
msgid ""
|
|
"This imports all names except those beginning with an underscore (``_``). In "
|
|
"most cases Python programmers do not use this facility since it introduces "
|
|
"an unknown set of names into the interpreter, possibly hiding some things "
|
|
"you have already defined."
|
|
msgstr ""
|
|
|
|
#: ../Doc/tutorial/modules.rst:111
|
|
msgid ""
|
|
"Note that in general the practice of importing ``*`` from a module or "
|
|
"package is frowned upon, since it often causes poorly readable code. "
|
|
"However, it is okay to use it to save typing in interactive sessions."
|
|
msgstr ""
|
|
|
|
#: ../Doc/tutorial/modules.rst:117
|
|
msgid ""
|
|
"For efficiency reasons, each module is only imported once per interpreter "
|
|
"session. Therefore, if you change your modules, you must restart the "
|
|
"interpreter -- or, if it's just one module you want to test interactively, "
|
|
"use :func:`importlib.reload`, e.g. ``import importlib; importlib."
|
|
"reload(modulename)``."
|
|
msgstr ""
|
|
|
|
#: ../Doc/tutorial/modules.rst:127
|
|
msgid "Executing modules as scripts"
|
|
msgstr ""
|
|
|
|
#: ../Doc/tutorial/modules.rst:129
|
|
msgid "When you run a Python module with ::"
|
|
msgstr ""
|
|
|
|
#: ../Doc/tutorial/modules.rst:133
|
|
msgid ""
|
|
"the code in the module will be executed, just as if you imported it, but "
|
|
"with the ``__name__`` set to ``\"__main__\"``. That means that by adding "
|
|
"this code at the end of your module::"
|
|
msgstr ""
|
|
|
|
#: ../Doc/tutorial/modules.rst:141
|
|
msgid ""
|
|
"you can make the file usable as a script as well as an importable module, "
|
|
"because the code that parses the command line only runs if the module is "
|
|
"executed as the \"main\" file:"
|
|
msgstr ""
|
|
|
|
#: ../Doc/tutorial/modules.rst:150
|
|
msgid "If the module is imported, the code is not run::"
|
|
msgstr ""
|
|
|
|
#: ../Doc/tutorial/modules.rst:155
|
|
msgid ""
|
|
"This is often used either to provide a convenient user interface to a "
|
|
"module, or for testing purposes (running the module as a script executes a "
|
|
"test suite)."
|
|
msgstr ""
|
|
|
|
#: ../Doc/tutorial/modules.rst:162
|
|
msgid "The Module Search Path"
|
|
msgstr ""
|
|
|
|
#: ../Doc/tutorial/modules.rst:166
|
|
msgid ""
|
|
"When a module named :mod:`spam` is imported, the interpreter first searches "
|
|
"for a built-in module with that name. If not found, it then searches for a "
|
|
"file named :file:`spam.py` in a list of directories given by the variable :"
|
|
"data:`sys.path`. :data:`sys.path` is initialized from these locations:"
|
|
msgstr ""
|
|
|
|
#: ../Doc/tutorial/modules.rst:171
|
|
msgid ""
|
|
"The directory containing the input script (or the current directory when no "
|
|
"file is specified)."
|
|
msgstr ""
|
|
|
|
#: ../Doc/tutorial/modules.rst:173
|
|
msgid ""
|
|
":envvar:`PYTHONPATH` (a list of directory names, with the same syntax as the "
|
|
"shell variable :envvar:`PATH`)."
|
|
msgstr ""
|
|
|
|
#: ../Doc/tutorial/modules.rst:175
|
|
msgid "The installation-dependent default."
|
|
msgstr ""
|
|
|
|
#: ../Doc/tutorial/modules.rst:178
|
|
msgid ""
|
|
"On file systems which support symlinks, the directory containing the input "
|
|
"script is calculated after the symlink is followed. In other words the "
|
|
"directory containing the symlink is **not** added to the module search path."
|
|
msgstr ""
|
|
|
|
#: ../Doc/tutorial/modules.rst:182
|
|
msgid ""
|
|
"After initialization, Python programs can modify :data:`sys.path`. The "
|
|
"directory containing the script being run is placed at the beginning of the "
|
|
"search path, ahead of the standard library path. This means that scripts in "
|
|
"that directory will be loaded instead of modules of the same name in the "
|
|
"library directory. This is an error unless the replacement is intended. See "
|
|
"section :ref:`tut-standardmodules` for more information."
|
|
msgstr ""
|
|
|
|
#: ../Doc/tutorial/modules.rst:193
|
|
msgid "\"Compiled\" Python files"
|
|
msgstr ""
|
|
|
|
#: ../Doc/tutorial/modules.rst:195
|
|
msgid ""
|
|
"To speed up loading modules, Python caches the compiled version of each "
|
|
"module in the ``__pycache__`` directory under the name :file:`module."
|
|
"{version}.pyc`, where the version encodes the format of the compiled file; "
|
|
"it generally contains the Python version number. For example, in CPython "
|
|
"release 3.3 the compiled version of spam.py would be cached as ``__pycache__/"
|
|
"spam.cpython-33.pyc``. This naming convention allows compiled modules from "
|
|
"different releases and different versions of Python to coexist."
|
|
msgstr ""
|
|
|
|
#: ../Doc/tutorial/modules.rst:203
|
|
msgid ""
|
|
"Python checks the modification date of the source against the compiled "
|
|
"version to see if it's out of date and needs to be recompiled. This is a "
|
|
"completely automatic process. Also, the compiled modules are platform-"
|
|
"independent, so the same library can be shared among systems with different "
|
|
"architectures."
|
|
msgstr ""
|
|
|
|
#: ../Doc/tutorial/modules.rst:208
|
|
msgid ""
|
|
"Python does not check the cache in two circumstances. First, it always "
|
|
"recompiles and does not store the result for the module that's loaded "
|
|
"directly from the command line. Second, it does not check the cache if "
|
|
"there is no source module. To support a non-source (compiled only) "
|
|
"distribution, the compiled module must be in the source directory, and there "
|
|
"must not be a source module."
|
|
msgstr ""
|
|
|
|
#: ../Doc/tutorial/modules.rst:215
|
|
msgid "Some tips for experts:"
|
|
msgstr ""
|
|
|
|
#: ../Doc/tutorial/modules.rst:217
|
|
msgid ""
|
|
"You can use the :option:`-O` or :option:`-OO` switches on the Python command "
|
|
"to reduce the size of a compiled module. The ``-O`` switch removes assert "
|
|
"statements, the ``-OO`` switch removes both assert statements and __doc__ "
|
|
"strings. Since some programs may rely on having these available, you should "
|
|
"only use this option if you know what you're doing. \"Optimized\" modules "
|
|
"have an ``opt-`` tag and are usually smaller. Future releases may change "
|
|
"the effects of optimization."
|
|
msgstr ""
|
|
|
|
#: ../Doc/tutorial/modules.rst:225
|
|
msgid ""
|
|
"A program doesn't run any faster when it is read from a ``.pyc`` file than "
|
|
"when it is read from a ``.py`` file; the only thing that's faster about ``."
|
|
"pyc`` files is the speed with which they are loaded."
|
|
msgstr ""
|
|
|
|
#: ../Doc/tutorial/modules.rst:229
|
|
msgid ""
|
|
"The module :mod:`compileall` can create .pyc files for all modules in a "
|
|
"directory."
|
|
msgstr ""
|
|
|
|
#: ../Doc/tutorial/modules.rst:232
|
|
msgid ""
|
|
"There is more detail on this process, including a flow chart of the "
|
|
"decisions, in PEP 3147."
|
|
msgstr ""
|
|
|
|
#: ../Doc/tutorial/modules.rst:239
|
|
msgid "Standard Modules"
|
|
msgstr ""
|
|
|
|
#: ../Doc/tutorial/modules.rst:243
|
|
msgid ""
|
|
"Python comes with a library of standard modules, described in a separate "
|
|
"document, the Python Library Reference (\"Library Reference\" hereafter). "
|
|
"Some modules are built into the interpreter; these provide access to "
|
|
"operations that are not part of the core of the language but are "
|
|
"nevertheless built in, either for efficiency or to provide access to "
|
|
"operating system primitives such as system calls. The set of such modules "
|
|
"is a configuration option which also depends on the underlying platform. "
|
|
"For example, the :mod:`winreg` module is only provided on Windows systems. "
|
|
"One particular module deserves some attention: :mod:`sys`, which is built "
|
|
"into every Python interpreter. The variables ``sys.ps1`` and ``sys.ps2`` "
|
|
"define the strings used as primary and secondary prompts::"
|
|
msgstr ""
|
|
|
|
#: ../Doc/tutorial/modules.rst:266
|
|
msgid ""
|
|
"These two variables are only defined if the interpreter is in interactive "
|
|
"mode."
|
|
msgstr ""
|
|
|
|
#: ../Doc/tutorial/modules.rst:268
|
|
msgid ""
|
|
"The variable ``sys.path`` is a list of strings that determines the "
|
|
"interpreter's search path for modules. It is initialized to a default path "
|
|
"taken from the environment variable :envvar:`PYTHONPATH`, or from a built-in "
|
|
"default if :envvar:`PYTHONPATH` is not set. You can modify it using "
|
|
"standard list operations::"
|
|
msgstr ""
|
|
|
|
#: ../Doc/tutorial/modules.rst:281
|
|
msgid "The :func:`dir` Function"
|
|
msgstr ""
|
|
|
|
#: ../Doc/tutorial/modules.rst:283
|
|
msgid ""
|
|
"The built-in function :func:`dir` is used to find out which names a module "
|
|
"defines. It returns a sorted list of strings::"
|
|
msgstr ""
|
|
|
|
#: ../Doc/tutorial/modules.rst:308
|
|
msgid ""
|
|
"Without arguments, :func:`dir` lists the names you have defined currently::"
|
|
msgstr ""
|
|
|
|
#: ../Doc/tutorial/modules.rst:316
|
|
msgid ""
|
|
"Note that it lists all types of names: variables, modules, functions, etc."
|
|
msgstr ""
|
|
|
|
#: ../Doc/tutorial/modules.rst:320
|
|
msgid ""
|
|
":func:`dir` does not list the names of built-in functions and variables. If "
|
|
"you want a list of those, they are defined in the standard module :mod:"
|
|
"`builtins`::"
|
|
msgstr ""
|
|
|
|
#: ../Doc/tutorial/modules.rst:359
|
|
msgid "Packages"
|
|
msgstr ""
|
|
|
|
#: ../Doc/tutorial/modules.rst:361
|
|
msgid ""
|
|
"Packages are a way of structuring Python's module namespace by using "
|
|
"\"dotted module names\". For example, the module name :mod:`A.B` designates "
|
|
"a submodule named ``B`` in a package named ``A``. Just like the use of "
|
|
"modules saves the authors of different modules from having to worry about "
|
|
"each other's global variable names, the use of dotted module names saves the "
|
|
"authors of multi-module packages like NumPy or the Python Imaging Library "
|
|
"from having to worry about each other's module names."
|
|
msgstr ""
|
|
|
|
#: ../Doc/tutorial/modules.rst:369
|
|
msgid ""
|
|
"Suppose you want to design a collection of modules (a \"package\") for the "
|
|
"uniform handling of sound files and sound data. There are many different "
|
|
"sound file formats (usually recognized by their extension, for example: :"
|
|
"file:`.wav`, :file:`.aiff`, :file:`.au`), so you may need to create and "
|
|
"maintain a growing collection of modules for the conversion between the "
|
|
"various file formats. There are also many different operations you might "
|
|
"want to perform on sound data (such as mixing, adding echo, applying an "
|
|
"equalizer function, creating an artificial stereo effect), so in addition "
|
|
"you will be writing a never-ending stream of modules to perform these "
|
|
"operations. Here's a possible structure for your package (expressed in "
|
|
"terms of a hierarchical filesystem):"
|
|
msgstr ""
|
|
|
|
#: ../Doc/tutorial/modules.rst:406
|
|
msgid ""
|
|
"When importing the package, Python searches through the directories on ``sys."
|
|
"path`` looking for the package subdirectory."
|
|
msgstr ""
|
|
|
|
#: ../Doc/tutorial/modules.rst:409
|
|
msgid ""
|
|
"The :file:`__init__.py` files are required to make Python treat the "
|
|
"directories as containing packages; this is done to prevent directories with "
|
|
"a common name, such as ``string``, from unintentionally hiding valid modules "
|
|
"that occur later on the module search path. In the simplest case, :file:"
|
|
"`__init__.py` can just be an empty file, but it can also execute "
|
|
"initialization code for the package or set the ``__all__`` variable, "
|
|
"described later."
|
|
msgstr ""
|
|
|
|
#: ../Doc/tutorial/modules.rst:416
|
|
msgid ""
|
|
"Users of the package can import individual modules from the package, for "
|
|
"example::"
|
|
msgstr ""
|
|
|
|
#: ../Doc/tutorial/modules.rst:421
|
|
msgid ""
|
|
"This loads the submodule :mod:`sound.effects.echo`. It must be referenced "
|
|
"with its full name. ::"
|
|
msgstr ""
|
|
|
|
#: ../Doc/tutorial/modules.rst:426
|
|
msgid "An alternative way of importing the submodule is::"
|
|
msgstr ""
|
|
|
|
#: ../Doc/tutorial/modules.rst:430
|
|
msgid ""
|
|
"This also loads the submodule :mod:`echo`, and makes it available without "
|
|
"its package prefix, so it can be used as follows::"
|
|
msgstr ""
|
|
|
|
#: ../Doc/tutorial/modules.rst:435
|
|
msgid ""
|
|
"Yet another variation is to import the desired function or variable "
|
|
"directly::"
|
|
msgstr ""
|
|
|
|
#: ../Doc/tutorial/modules.rst:439
|
|
msgid ""
|
|
"Again, this loads the submodule :mod:`echo`, but this makes its function :"
|
|
"func:`echofilter` directly available::"
|
|
msgstr ""
|
|
|
|
#: ../Doc/tutorial/modules.rst:444
|
|
msgid ""
|
|
"Note that when using ``from package import item``, the item can be either a "
|
|
"submodule (or subpackage) of the package, or some other name defined in the "
|
|
"package, like a function, class or variable. The ``import`` statement first "
|
|
"tests whether the item is defined in the package; if not, it assumes it is a "
|
|
"module and attempts to load it. If it fails to find it, an :exc:"
|
|
"`ImportError` exception is raised."
|
|
msgstr ""
|
|
|
|
#: ../Doc/tutorial/modules.rst:451
|
|
msgid ""
|
|
"Contrarily, when using syntax like ``import item.subitem.subsubitem``, each "
|
|
"item except for the last must be a package; the last item can be a module or "
|
|
"a package but can't be a class or function or variable defined in the "
|
|
"previous item."
|
|
msgstr ""
|
|
|
|
#: ../Doc/tutorial/modules.rst:460
|
|
msgid "Importing \\* From a Package"
|
|
msgstr ""
|
|
|
|
#: ../Doc/tutorial/modules.rst:464
|
|
msgid ""
|
|
"Now what happens when the user writes ``from sound.effects import *``? "
|
|
"Ideally, one would hope that this somehow goes out to the filesystem, finds "
|
|
"which submodules are present in the package, and imports them all. This "
|
|
"could take a long time and importing sub-modules might have unwanted side-"
|
|
"effects that should only happen when the sub-module is explicitly imported."
|
|
msgstr ""
|
|
|
|
#: ../Doc/tutorial/modules.rst:470
|
|
msgid ""
|
|
"The only solution is for the package author to provide an explicit index of "
|
|
"the package. The :keyword:`import` statement uses the following convention: "
|
|
"if a package's :file:`__init__.py` code defines a list named ``__all__``, it "
|
|
"is taken to be the list of module names that should be imported when ``from "
|
|
"package import *`` is encountered. It is up to the package author to keep "
|
|
"this list up-to-date when a new version of the package is released. Package "
|
|
"authors may also decide not to support it, if they don't see a use for "
|
|
"importing \\* from their package. For example, the file :file:`sound/"
|
|
"effects/__init__.py` could contain the following code::"
|
|
msgstr ""
|
|
|
|
#: ../Doc/tutorial/modules.rst:482
|
|
msgid ""
|
|
"This would mean that ``from sound.effects import *`` would import the three "
|
|
"named submodules of the :mod:`sound` package."
|
|
msgstr ""
|
|
|
|
#: ../Doc/tutorial/modules.rst:485
|
|
msgid ""
|
|
"If ``__all__`` is not defined, the statement ``from sound.effects import *`` "
|
|
"does *not* import all submodules from the package :mod:`sound.effects` into "
|
|
"the current namespace; it only ensures that the package :mod:`sound.effects` "
|
|
"has been imported (possibly running any initialization code in :file:"
|
|
"`__init__.py`) and then imports whatever names are defined in the package. "
|
|
"This includes any names defined (and submodules explicitly loaded) by :file:"
|
|
"`__init__.py`. It also includes any submodules of the package that were "
|
|
"explicitly loaded by previous :keyword:`import` statements. Consider this "
|
|
"code::"
|
|
msgstr ""
|
|
|
|
#: ../Doc/tutorial/modules.rst:498
|
|
msgid ""
|
|
"In this example, the :mod:`echo` and :mod:`surround` modules are imported in "
|
|
"the current namespace because they are defined in the :mod:`sound.effects` "
|
|
"package when the ``from...import`` statement is executed. (This also works "
|
|
"when ``__all__`` is defined.)"
|
|
msgstr ""
|
|
|
|
#: ../Doc/tutorial/modules.rst:503
|
|
msgid ""
|
|
"Although certain modules are designed to export only names that follow "
|
|
"certain patterns when you use ``import *``, it is still considered bad "
|
|
"practise in production code."
|
|
msgstr ""
|
|
|
|
#: ../Doc/tutorial/modules.rst:507
|
|
msgid ""
|
|
"Remember, there is nothing wrong with using ``from Package import "
|
|
"specific_submodule``! In fact, this is the recommended notation unless the "
|
|
"importing module needs to use submodules with the same name from different "
|
|
"packages."
|
|
msgstr ""
|
|
|
|
#: ../Doc/tutorial/modules.rst:514
|
|
msgid "Intra-package References"
|
|
msgstr ""
|
|
|
|
#: ../Doc/tutorial/modules.rst:516
|
|
msgid ""
|
|
"When packages are structured into subpackages (as with the :mod:`sound` "
|
|
"package in the example), you can use absolute imports to refer to submodules "
|
|
"of siblings packages. For example, if the module :mod:`sound.filters."
|
|
"vocoder` needs to use the :mod:`echo` module in the :mod:`sound.effects` "
|
|
"package, it can use ``from sound.effects import echo``."
|
|
msgstr ""
|
|
|
|
#: ../Doc/tutorial/modules.rst:522
|
|
msgid ""
|
|
"You can also write relative imports, with the ``from module import name`` "
|
|
"form of import statement. These imports use leading dots to indicate the "
|
|
"current and parent packages involved in the relative import. From the :mod:"
|
|
"`surround` module for example, you might use::"
|
|
msgstr ""
|
|
|
|
#: ../Doc/tutorial/modules.rst:531
|
|
msgid ""
|
|
"Note that relative imports are based on the name of the current module. "
|
|
"Since the name of the main module is always ``\"__main__\"``, modules "
|
|
"intended for use as the main module of a Python application must always use "
|
|
"absolute imports."
|
|
msgstr ""
|
|
|
|
#: ../Doc/tutorial/modules.rst:537
|
|
msgid "Packages in Multiple Directories"
|
|
msgstr ""
|
|
|
|
#: ../Doc/tutorial/modules.rst:539
|
|
msgid ""
|
|
"Packages support one more special attribute, :attr:`__path__`. This is "
|
|
"initialized to be a list containing the name of the directory holding the "
|
|
"package's :file:`__init__.py` before the code in that file is executed. "
|
|
"This variable can be modified; doing so affects future searches for modules "
|
|
"and subpackages contained in the package."
|
|
msgstr ""
|
|
|
|
#: ../Doc/tutorial/modules.rst:545
|
|
msgid ""
|
|
"While this feature is not often needed, it can be used to extend the set of "
|
|
"modules found in a package."
|
|
msgstr ""
|
|
|
|
#: ../Doc/tutorial/modules.rst:551
|
|
msgid ""
|
|
"In fact function definitions are also 'statements' that are 'executed'; the "
|
|
"execution of a module-level function definition enters the function name in "
|
|
"the module's global symbol table."
|
|
msgstr ""
|
|
|
|
#: ../Doc/tutorial/stdlib.rst:5
|
|
msgid "Brief Tour of the Standard Library"
|
|
msgstr ""
|
|
|
|
#: ../Doc/tutorial/stdlib.rst:11
|
|
msgid "Operating System Interface"
|
|
msgstr ""
|
|
|
|
#: ../Doc/tutorial/stdlib.rst:13
|
|
msgid ""
|
|
"The :mod:`os` module provides dozens of functions for interacting with the "
|
|
"operating system::"
|
|
msgstr ""
|
|
|
|
#: ../Doc/tutorial/stdlib.rst:23
|
|
msgid ""
|
|
"Be sure to use the ``import os`` style instead of ``from os import *``. "
|
|
"This will keep :func:`os.open` from shadowing the built-in :func:`open` "
|
|
"function which operates much differently."
|
|
msgstr ""
|
|
|
|
#: ../Doc/tutorial/stdlib.rst:29
|
|
msgid ""
|
|
"The built-in :func:`dir` and :func:`help` functions are useful as "
|
|
"interactive aids for working with large modules like :mod:`os`::"
|
|
msgstr ""
|
|
|
|
#: ../Doc/tutorial/stdlib.rst:38
|
|
msgid ""
|
|
"For daily file and directory management tasks, the :mod:`shutil` module "
|
|
"provides a higher level interface that is easier to use::"
|
|
msgstr ""
|
|
|
|
#: ../Doc/tutorial/stdlib.rst:51
|
|
msgid "File Wildcards"
|
|
msgstr ""
|
|
|
|
#: ../Doc/tutorial/stdlib.rst:53
|
|
msgid ""
|
|
"The :mod:`glob` module provides a function for making file lists from "
|
|
"directory wildcard searches::"
|
|
msgstr ""
|
|
|
|
#: ../Doc/tutorial/stdlib.rst:64
|
|
msgid "Command Line Arguments"
|
|
msgstr ""
|
|
|
|
#: ../Doc/tutorial/stdlib.rst:66
|
|
msgid ""
|
|
"Common utility scripts often need to process command line arguments. These "
|
|
"arguments are stored in the :mod:`sys` module's *argv* attribute as a list. "
|
|
"For instance the following output results from running ``python demo.py one "
|
|
"two three`` at the command line::"
|
|
msgstr ""
|
|
|
|
#: ../Doc/tutorial/stdlib.rst:75
|
|
msgid ""
|
|
"The :mod:`getopt` module processes *sys.argv* using the conventions of the "
|
|
"Unix :func:`getopt` function. More powerful and flexible command line "
|
|
"processing is provided by the :mod:`argparse` module."
|
|
msgstr ""
|
|
|
|
#: ../Doc/tutorial/stdlib.rst:83
|
|
msgid "Error Output Redirection and Program Termination"
|
|
msgstr ""
|
|
|
|
#: ../Doc/tutorial/stdlib.rst:85
|
|
msgid ""
|
|
"The :mod:`sys` module also has attributes for *stdin*, *stdout*, and "
|
|
"*stderr*. The latter is useful for emitting warnings and error messages to "
|
|
"make them visible even when *stdout* has been redirected::"
|
|
msgstr ""
|
|
|
|
#: ../Doc/tutorial/stdlib.rst:92
|
|
msgid "The most direct way to terminate a script is to use ``sys.exit()``."
|
|
msgstr ""
|
|
|
|
#: ../Doc/tutorial/stdlib.rst:98
|
|
msgid "String Pattern Matching"
|
|
msgstr ""
|
|
|
|
#: ../Doc/tutorial/stdlib.rst:100
|
|
msgid ""
|
|
"The :mod:`re` module provides regular expression tools for advanced string "
|
|
"processing. For complex matching and manipulation, regular expressions offer "
|
|
"succinct, optimized solutions::"
|
|
msgstr ""
|
|
|
|
#: ../Doc/tutorial/stdlib.rst:110
|
|
msgid ""
|
|
"When only simple capabilities are needed, string methods are preferred "
|
|
"because they are easier to read and debug::"
|
|
msgstr ""
|
|
|
|
#: ../Doc/tutorial/stdlib.rst:120
|
|
msgid "Mathematics"
|
|
msgstr ""
|
|
|
|
#: ../Doc/tutorial/stdlib.rst:122
|
|
msgid ""
|
|
"The :mod:`math` module gives access to the underlying C library functions "
|
|
"for floating point math::"
|
|
msgstr ""
|
|
|
|
#: ../Doc/tutorial/stdlib.rst:131
|
|
msgid "The :mod:`random` module provides tools for making random selections::"
|
|
msgstr ""
|
|
|
|
#: ../Doc/tutorial/stdlib.rst:143
|
|
msgid ""
|
|
"The :mod:`statistics` module calculates basic statistical properties (the "
|
|
"mean, median, variance, etc.) of numeric data::"
|
|
msgstr ""
|
|
|
|
#: ../Doc/tutorial/stdlib.rst:155
|
|
msgid ""
|
|
"The SciPy project <https://scipy.org> has many other modules for numerical "
|
|
"computations."
|
|
msgstr ""
|
|
|
|
#: ../Doc/tutorial/stdlib.rst:161
|
|
msgid "Internet Access"
|
|
msgstr ""
|
|
|
|
#: ../Doc/tutorial/stdlib.rst:163
|
|
msgid ""
|
|
"There are a number of modules for accessing the internet and processing "
|
|
"internet protocols. Two of the simplest are :mod:`urllib.request` for "
|
|
"retrieving data from URLs and :mod:`smtplib` for sending mail::"
|
|
msgstr ""
|
|
|
|
#: ../Doc/tutorial/stdlib.rst:186
|
|
msgid "(Note that the second example needs a mailserver running on localhost.)"
|
|
msgstr ""
|
|
|
|
#: ../Doc/tutorial/stdlib.rst:192
|
|
msgid "Dates and Times"
|
|
msgstr ""
|
|
|
|
#: ../Doc/tutorial/stdlib.rst:194
|
|
msgid ""
|
|
"The :mod:`datetime` module supplies classes for manipulating dates and times "
|
|
"in both simple and complex ways. While date and time arithmetic is "
|
|
"supported, the focus of the implementation is on efficient member extraction "
|
|
"for output formatting and manipulation. The module also supports objects "
|
|
"that are timezone aware. ::"
|
|
msgstr ""
|
|
|
|
#: ../Doc/tutorial/stdlib.rst:218
|
|
msgid "Data Compression"
|
|
msgstr ""
|
|
|
|
#: ../Doc/tutorial/stdlib.rst:220
|
|
msgid ""
|
|
"Common data archiving and compression formats are directly supported by "
|
|
"modules including: :mod:`zlib`, :mod:`gzip`, :mod:`bz2`, :mod:`lzma`, :mod:"
|
|
"`zipfile` and :mod:`tarfile`. ::"
|
|
msgstr ""
|
|
|
|
#: ../Doc/tutorial/stdlib.rst:240
|
|
msgid "Performance Measurement"
|
|
msgstr ""
|
|
|
|
#: ../Doc/tutorial/stdlib.rst:242
|
|
msgid ""
|
|
"Some Python users develop a deep interest in knowing the relative "
|
|
"performance of different approaches to the same problem. Python provides a "
|
|
"measurement tool that answers those questions immediately."
|
|
msgstr ""
|
|
|
|
#: ../Doc/tutorial/stdlib.rst:246
|
|
msgid ""
|
|
"For example, it may be tempting to use the tuple packing and unpacking "
|
|
"feature instead of the traditional approach to swapping arguments. The :mod:"
|
|
"`timeit` module quickly demonstrates a modest performance advantage::"
|
|
msgstr ""
|
|
|
|
#: ../Doc/tutorial/stdlib.rst:256
|
|
msgid ""
|
|
"In contrast to :mod:`timeit`'s fine level of granularity, the :mod:`profile` "
|
|
"and :mod:`pstats` modules provide tools for identifying time critical "
|
|
"sections in larger blocks of code."
|
|
msgstr ""
|
|
|
|
#: ../Doc/tutorial/stdlib.rst:264
|
|
msgid "Quality Control"
|
|
msgstr ""
|
|
|
|
#: ../Doc/tutorial/stdlib.rst:266
|
|
msgid ""
|
|
"One approach for developing high quality software is to write tests for each "
|
|
"function as it is developed and to run those tests frequently during the "
|
|
"development process."
|
|
msgstr ""
|
|
|
|
#: ../Doc/tutorial/stdlib.rst:270
|
|
msgid ""
|
|
"The :mod:`doctest` module provides a tool for scanning a module and "
|
|
"validating tests embedded in a program's docstrings. Test construction is "
|
|
"as simple as cutting-and-pasting a typical call along with its results into "
|
|
"the docstring. This improves the documentation by providing the user with an "
|
|
"example and it allows the doctest module to make sure the code remains true "
|
|
"to the documentation::"
|
|
msgstr ""
|
|
|
|
#: ../Doc/tutorial/stdlib.rst:288
|
|
msgid ""
|
|
"The :mod:`unittest` module is not as effortless as the :mod:`doctest` "
|
|
"module, but it allows a more comprehensive set of tests to be maintained in "
|
|
"a separate file::"
|
|
msgstr ""
|
|
|
|
#: ../Doc/tutorial/stdlib.rst:310
|
|
msgid "Batteries Included"
|
|
msgstr ""
|
|
|
|
#: ../Doc/tutorial/stdlib.rst:312
|
|
msgid ""
|
|
"Python has a \"batteries included\" philosophy. This is best seen through "
|
|
"the sophisticated and robust capabilities of its larger packages. For "
|
|
"example:"
|
|
msgstr ""
|
|
|
|
#: ../Doc/tutorial/stdlib.rst:315
|
|
msgid ""
|
|
"The :mod:`xmlrpc.client` and :mod:`xmlrpc.server` modules make implementing "
|
|
"remote procedure calls into an almost trivial task. Despite the modules "
|
|
"names, no direct knowledge or handling of XML is needed."
|
|
msgstr ""
|
|
|
|
#: ../Doc/tutorial/stdlib.rst:319
|
|
msgid ""
|
|
"The :mod:`email` package is a library for managing email messages, including "
|
|
"MIME and other RFC 2822-based message documents. Unlike :mod:`smtplib` and :"
|
|
"mod:`poplib` which actually send and receive messages, the email package has "
|
|
"a complete toolset for building or decoding complex message structures "
|
|
"(including attachments) and for implementing internet encoding and header "
|
|
"protocols."
|
|
msgstr ""
|
|
|
|
#: ../Doc/tutorial/stdlib.rst:326
|
|
msgid ""
|
|
"The :mod:`json` package provides robust support for parsing this popular "
|
|
"data interchange format. The :mod:`csv` module supports direct reading and "
|
|
"writing of files in Comma-Separated Value format, commonly supported by "
|
|
"databases and spreadsheets. XML processing is supported by the :mod:`xml."
|
|
"etree.ElementTree`, :mod:`xml.dom` and :mod:`xml.sax` packages. Together, "
|
|
"these modules and packages greatly simplify data interchange between Python "
|
|
"applications and other tools."
|
|
msgstr ""
|
|
|
|
#: ../Doc/tutorial/stdlib.rst:335
|
|
msgid ""
|
|
"The :mod:`sqlite3` module is a wrapper for the SQLite database library, "
|
|
"providing a persistent database that can be updated and accessed using "
|
|
"slightly nonstandard SQL syntax."
|
|
msgstr ""
|
|
|
|
#: ../Doc/tutorial/stdlib.rst:339
|
|
msgid ""
|
|
"Internationalization is supported by a number of modules including :mod:"
|
|
"`gettext`, :mod:`locale`, and the :mod:`codecs` package."
|
|
msgstr ""
|
|
|
|
#: ../Doc/tutorial/stdlib2.rst:5
|
|
msgid "Brief Tour of the Standard Library -- Part II"
|
|
msgstr ""
|
|
|
|
#: ../Doc/tutorial/stdlib2.rst:7
|
|
msgid ""
|
|
"This second tour covers more advanced modules that support professional "
|
|
"programming needs. These modules rarely occur in small scripts."
|
|
msgstr ""
|
|
|
|
#: ../Doc/tutorial/stdlib2.rst:14
|
|
msgid "Output Formatting"
|
|
msgstr ""
|
|
|
|
#: ../Doc/tutorial/stdlib2.rst:16
|
|
msgid ""
|
|
"The :mod:`reprlib` module provides a version of :func:`repr` customized for "
|
|
"abbreviated displays of large or deeply nested containers::"
|
|
msgstr ""
|
|
|
|
#: ../Doc/tutorial/stdlib2.rst:23
|
|
msgid ""
|
|
"The :mod:`pprint` module offers more sophisticated control over printing "
|
|
"both built-in and user defined objects in a way that is readable by the "
|
|
"interpreter. When the result is longer than one line, the \"pretty printer\" "
|
|
"adds line breaks and indentation to more clearly reveal data structure::"
|
|
msgstr ""
|
|
|
|
#: ../Doc/tutorial/stdlib2.rst:39
|
|
msgid ""
|
|
"The :mod:`textwrap` module formats paragraphs of text to fit a given screen "
|
|
"width::"
|
|
msgstr ""
|
|
|
|
#: ../Doc/tutorial/stdlib2.rst:53
|
|
msgid ""
|
|
"The :mod:`locale` module accesses a database of culture specific data "
|
|
"formats. The grouping attribute of locale's format function provides a "
|
|
"direct way of formatting numbers with group separators::"
|
|
msgstr ""
|
|
|
|
#: ../Doc/tutorial/stdlib2.rst:72
|
|
msgid "Templating"
|
|
msgstr ""
|
|
|
|
#: ../Doc/tutorial/stdlib2.rst:74
|
|
msgid ""
|
|
"The :mod:`string` module includes a versatile :class:`~string.Template` "
|
|
"class with a simplified syntax suitable for editing by end-users. This "
|
|
"allows users to customize their applications without having to alter the "
|
|
"application."
|
|
msgstr ""
|
|
|
|
#: ../Doc/tutorial/stdlib2.rst:78
|
|
msgid ""
|
|
"The format uses placeholder names formed by ``$`` with valid Python "
|
|
"identifiers (alphanumeric characters and underscores). Surrounding the "
|
|
"placeholder with braces allows it to be followed by more alphanumeric "
|
|
"letters with no intervening spaces. Writing ``$$`` creates a single escaped "
|
|
"``$``::"
|
|
msgstr ""
|
|
|
|
#: ../Doc/tutorial/stdlib2.rst:88
|
|
msgid ""
|
|
"The :meth:`~string.Template.substitute` method raises a :exc:`KeyError` when "
|
|
"a placeholder is not supplied in a dictionary or a keyword argument. For "
|
|
"mail-merge style applications, user supplied data may be incomplete and the :"
|
|
"meth:`~string.Template.safe_substitute` method may be more appropriate --- "
|
|
"it will leave placeholders unchanged if data is missing::"
|
|
msgstr ""
|
|
|
|
#: ../Doc/tutorial/stdlib2.rst:103
|
|
msgid ""
|
|
"Template subclasses can specify a custom delimiter. For example, a batch "
|
|
"renaming utility for a photo browser may elect to use percent signs for "
|
|
"placeholders such as the current date, image sequence number, or file "
|
|
"format::"
|
|
msgstr ""
|
|
|
|
#: ../Doc/tutorial/stdlib2.rst:125
|
|
msgid ""
|
|
"Another application for templating is separating program logic from the "
|
|
"details of multiple output formats. This makes it possible to substitute "
|
|
"custom templates for XML files, plain text reports, and HTML web reports."
|
|
msgstr ""
|
|
|
|
#: ../Doc/tutorial/stdlib2.rst:133
|
|
msgid "Working with Binary Data Record Layouts"
|
|
msgstr ""
|
|
|
|
#: ../Doc/tutorial/stdlib2.rst:135
|
|
msgid ""
|
|
"The :mod:`struct` module provides :func:`~struct.pack` and :func:`~struct."
|
|
"unpack` functions for working with variable length binary record formats. "
|
|
"The following example shows how to loop through header information in a ZIP "
|
|
"file without using the :mod:`zipfile` module. Pack codes ``\"H\"`` and ``\"I"
|
|
"\"`` represent two and four byte unsigned numbers respectively. The ``\"<"
|
|
"\"`` indicates that they are standard size and in little-endian byte order::"
|
|
msgstr ""
|
|
|
|
#: ../Doc/tutorial/stdlib2.rst:166
|
|
msgid "Multi-threading"
|
|
msgstr ""
|
|
|
|
#: ../Doc/tutorial/stdlib2.rst:168
|
|
msgid ""
|
|
"Threading is a technique for decoupling tasks which are not sequentially "
|
|
"dependent. Threads can be used to improve the responsiveness of "
|
|
"applications that accept user input while other tasks run in the "
|
|
"background. A related use case is running I/O in parallel with computations "
|
|
"in another thread."
|
|
msgstr ""
|
|
|
|
#: ../Doc/tutorial/stdlib2.rst:173
|
|
msgid ""
|
|
"The following code shows how the high level :mod:`threading` module can run "
|
|
"tasks in background while the main program continues to run::"
|
|
msgstr ""
|
|
|
|
#: ../Doc/tutorial/stdlib2.rst:197
|
|
msgid ""
|
|
"The principal challenge of multi-threaded applications is coordinating "
|
|
"threads that share data or other resources. To that end, the threading "
|
|
"module provides a number of synchronization primitives including locks, "
|
|
"events, condition variables, and semaphores."
|
|
msgstr ""
|
|
|
|
#: ../Doc/tutorial/stdlib2.rst:202
|
|
msgid ""
|
|
"While those tools are powerful, minor design errors can result in problems "
|
|
"that are difficult to reproduce. So, the preferred approach to task "
|
|
"coordination is to concentrate all access to a resource in a single thread "
|
|
"and then use the :mod:`queue` module to feed that thread with requests from "
|
|
"other threads. Applications using :class:`~queue.Queue` objects for inter-"
|
|
"thread communication and coordination are easier to design, more readable, "
|
|
"and more reliable."
|
|
msgstr ""
|
|
|
|
#: ../Doc/tutorial/stdlib2.rst:213
|
|
msgid "Logging"
|
|
msgstr ""
|
|
|
|
#: ../Doc/tutorial/stdlib2.rst:215
|
|
msgid ""
|
|
"The :mod:`logging` module offers a full featured and flexible logging "
|
|
"system. At its simplest, log messages are sent to a file or to ``sys."
|
|
"stderr``::"
|
|
msgstr ""
|
|
|
|
#: ../Doc/tutorial/stdlib2.rst:225
|
|
msgid "This produces the following output:"
|
|
msgstr ""
|
|
|
|
#: ../Doc/tutorial/stdlib2.rst:233
|
|
msgid ""
|
|
"By default, informational and debugging messages are suppressed and the "
|
|
"output is sent to standard error. Other output options include routing "
|
|
"messages through email, datagrams, sockets, or to an HTTP Server. New "
|
|
"filters can select different routing based on message priority: :const:"
|
|
"`~logging.DEBUG`, :const:`~logging.INFO`, :const:`~logging.WARNING`, :const:"
|
|
"`~logging.ERROR`, and :const:`~logging.CRITICAL`."
|
|
msgstr ""
|
|
|
|
#: ../Doc/tutorial/stdlib2.rst:240
|
|
msgid ""
|
|
"The logging system can be configured directly from Python or can be loaded "
|
|
"from a user editable configuration file for customized logging without "
|
|
"altering the application."
|
|
msgstr ""
|
|
|
|
#: ../Doc/tutorial/stdlib2.rst:248
|
|
msgid "Weak References"
|
|
msgstr ""
|
|
|
|
#: ../Doc/tutorial/stdlib2.rst:250
|
|
msgid ""
|
|
"Python does automatic memory management (reference counting for most objects "
|
|
"and :term:`garbage collection` to eliminate cycles). The memory is freed "
|
|
"shortly after the last reference to it has been eliminated."
|
|
msgstr ""
|
|
|
|
#: ../Doc/tutorial/stdlib2.rst:254
|
|
msgid ""
|
|
"This approach works fine for most applications but occasionally there is a "
|
|
"need to track objects only as long as they are being used by something else. "
|
|
"Unfortunately, just tracking them creates a reference that makes them "
|
|
"permanent. The :mod:`weakref` module provides tools for tracking objects "
|
|
"without creating a reference. When the object is no longer needed, it is "
|
|
"automatically removed from a weakref table and a callback is triggered for "
|
|
"weakref objects. Typical applications include caching objects that are "
|
|
"expensive to create::"
|
|
msgstr ""
|
|
|
|
#: ../Doc/tutorial/stdlib2.rst:289
|
|
msgid "Tools for Working with Lists"
|
|
msgstr ""
|
|
|
|
#: ../Doc/tutorial/stdlib2.rst:291
|
|
msgid ""
|
|
"Many data structure needs can be met with the built-in list type. However, "
|
|
"sometimes there is a need for alternative implementations with different "
|
|
"performance trade-offs."
|
|
msgstr ""
|
|
|
|
#: ../Doc/tutorial/stdlib2.rst:295
|
|
msgid ""
|
|
"The :mod:`array` module provides an :class:`~array.array()` object that is "
|
|
"like a list that stores only homogeneous data and stores it more compactly. "
|
|
"The following example shows an array of numbers stored as two byte unsigned "
|
|
"binary numbers (typecode ``\"H\"``) rather than the usual 16 bytes per entry "
|
|
"for regular lists of Python int objects::"
|
|
msgstr ""
|
|
|
|
#: ../Doc/tutorial/stdlib2.rst:308
|
|
msgid ""
|
|
"The :mod:`collections` module provides a :class:`~collections.deque()` "
|
|
"object that is like a list with faster appends and pops from the left side "
|
|
"but slower lookups in the middle. These objects are well suited for "
|
|
"implementing queues and breadth first tree searches::"
|
|
msgstr ""
|
|
|
|
#: ../Doc/tutorial/stdlib2.rst:329
|
|
msgid ""
|
|
"In addition to alternative list implementations, the library also offers "
|
|
"other tools such as the :mod:`bisect` module with functions for manipulating "
|
|
"sorted lists::"
|
|
msgstr ""
|
|
|
|
#: ../Doc/tutorial/stdlib2.rst:339
|
|
msgid ""
|
|
"The :mod:`heapq` module provides functions for implementing heaps based on "
|
|
"regular lists. The lowest valued entry is always kept at position zero. "
|
|
"This is useful for applications which repeatedly access the smallest element "
|
|
"but do not want to run a full list sort::"
|
|
msgstr ""
|
|
|
|
#: ../Doc/tutorial/stdlib2.rst:355
|
|
msgid "Decimal Floating Point Arithmetic"
|
|
msgstr ""
|
|
|
|
#: ../Doc/tutorial/stdlib2.rst:357
|
|
msgid ""
|
|
"The :mod:`decimal` module offers a :class:`~decimal.Decimal` datatype for "
|
|
"decimal floating point arithmetic. Compared to the built-in :class:`float` "
|
|
"implementation of binary floating point, the class is especially helpful for"
|
|
msgstr ""
|
|
|
|
#: ../Doc/tutorial/stdlib2.rst:361
|
|
msgid ""
|
|
"financial applications and other uses which require exact decimal "
|
|
"representation,"
|
|
msgstr ""
|
|
|
|
#: ../Doc/tutorial/stdlib2.rst:363
|
|
msgid "control over precision,"
|
|
msgstr ""
|
|
|
|
#: ../Doc/tutorial/stdlib2.rst:364
|
|
msgid "control over rounding to meet legal or regulatory requirements,"
|
|
msgstr ""
|
|
|
|
#: ../Doc/tutorial/stdlib2.rst:365
|
|
msgid "tracking of significant decimal places, or"
|
|
msgstr ""
|
|
|
|
#: ../Doc/tutorial/stdlib2.rst:366
|
|
msgid ""
|
|
"applications where the user expects the results to match calculations done "
|
|
"by hand."
|
|
msgstr ""
|
|
|
|
#: ../Doc/tutorial/stdlib2.rst:369
|
|
msgid ""
|
|
"For example, calculating a 5% tax on a 70 cent phone charge gives different "
|
|
"results in decimal floating point and binary floating point. The difference "
|
|
"becomes significant if the results are rounded to the nearest cent::"
|
|
msgstr ""
|
|
|
|
#: ../Doc/tutorial/stdlib2.rst:379
|
|
msgid ""
|
|
"The :class:`~decimal.Decimal` result keeps a trailing zero, automatically "
|
|
"inferring four place significance from multiplicands with two place "
|
|
"significance. Decimal reproduces mathematics as done by hand and avoids "
|
|
"issues that can arise when binary floating point cannot exactly represent "
|
|
"decimal quantities."
|
|
msgstr ""
|
|
|
|
#: ../Doc/tutorial/stdlib2.rst:385
|
|
msgid ""
|
|
"Exact representation enables the :class:`~decimal.Decimal` class to perform "
|
|
"modulo calculations and equality tests that are unsuitable for binary "
|
|
"floating point::"
|
|
msgstr ""
|
|
|
|
#: ../Doc/tutorial/stdlib2.rst:399
|
|
msgid ""
|
|
"The :mod:`decimal` module provides arithmetic with as much precision as "
|
|
"needed::"
|
|
msgstr ""
|
|
|
|
#: ../Doc/tutorial/venv.rst:6
|
|
msgid "Virtual Environments and Packages"
|
|
msgstr ""
|
|
|
|
#: ../Doc/tutorial/venv.rst:9
|
|
msgid "Introduction"
|
|
msgstr ""
|
|
|
|
#: ../Doc/tutorial/venv.rst:11
|
|
msgid ""
|
|
"Python applications will often use packages and modules that don't come as "
|
|
"part of the standard library. Applications will sometimes need a specific "
|
|
"version of a library, because the application may require that a particular "
|
|
"bug has been fixed or the application may be written using an obsolete "
|
|
"version of the library's interface."
|
|
msgstr ""
|
|
|
|
#: ../Doc/tutorial/venv.rst:17
|
|
msgid ""
|
|
"This means it may not be possible for one Python installation to meet the "
|
|
"requirements of every application. If application A needs version 1.0 of a "
|
|
"particular module but application B needs version 2.0, then the requirements "
|
|
"are in conflict and installing either version 1.0 or 2.0 will leave one "
|
|
"application unable to run."
|
|
msgstr ""
|
|
|
|
#: ../Doc/tutorial/venv.rst:23
|
|
msgid ""
|
|
"The solution for this problem is to create a :term:`virtual environment`, a "
|
|
"self-contained directory tree that contains a Python installation for a "
|
|
"particular version of Python, plus a number of additional packages."
|
|
msgstr ""
|
|
|
|
#: ../Doc/tutorial/venv.rst:27
|
|
msgid ""
|
|
"Different applications can then use different virtual environments. To "
|
|
"resolve the earlier example of conflicting requirements, application A can "
|
|
"have its own virtual environment with version 1.0 installed while "
|
|
"application B has another virtual environment with version 2.0. If "
|
|
"application B requires a library be upgraded to version 3.0, this will not "
|
|
"affect application A's environment."
|
|
msgstr ""
|
|
|
|
#: ../Doc/tutorial/venv.rst:36
|
|
msgid "Creating Virtual Environments"
|
|
msgstr ""
|
|
|
|
#: ../Doc/tutorial/venv.rst:38
|
|
msgid ""
|
|
"The module used to create and manage virtual environments is called :mod:"
|
|
"`venv`. :mod:`venv` will usually install the most recent version of Python "
|
|
"that you have available. If you have multiple versions of Python on your "
|
|
"system, you can select a specific Python version by running ``python3`` or "
|
|
"whichever version you want."
|
|
msgstr ""
|
|
|
|
#: ../Doc/tutorial/venv.rst:44
|
|
msgid ""
|
|
"To create a virtual environment, decide upon a directory where you want to "
|
|
"place it, and run the :mod:`venv` module as a script with the directory "
|
|
"path::"
|
|
msgstr ""
|
|
|
|
#: ../Doc/tutorial/venv.rst:49
|
|
msgid ""
|
|
"This will create the ``tutorial-env`` directory if it doesn't exist, and "
|
|
"also create directories inside it containing a copy of the Python "
|
|
"interpreter, the standard library, and various supporting files."
|
|
msgstr ""
|
|
|
|
#: ../Doc/tutorial/venv.rst:53
|
|
msgid "Once you've created a virtual environment, you may activate it."
|
|
msgstr ""
|
|
|
|
#: ../Doc/tutorial/venv.rst:55
|
|
msgid "On Windows, run::"
|
|
msgstr ""
|
|
|
|
#: ../Doc/tutorial/venv.rst:59
|
|
msgid "On Unix or MacOS, run::"
|
|
msgstr ""
|
|
|
|
#: ../Doc/tutorial/venv.rst:63
|
|
msgid ""
|
|
"(This script is written for the bash shell. If you use the :program:`csh` "
|
|
"or :program:`fish` shells, there are alternate ``activate.csh`` and "
|
|
"``activate.fish`` scripts you should use instead.)"
|
|
msgstr ""
|
|
|
|
#: ../Doc/tutorial/venv.rst:68
|
|
msgid ""
|
|
"Activating the virtual environment will change your shell's prompt to show "
|
|
"what virtual environment you're using, and modify the environment so that "
|
|
"running ``python`` will get you that particular version and installation of "
|
|
"Python. For example:"
|
|
msgstr ""
|
|
|
|
#: ../Doc/tutorial/venv.rst:87
|
|
msgid "Managing Packages with pip"
|
|
msgstr ""
|
|
|
|
#: ../Doc/tutorial/venv.rst:89
|
|
msgid ""
|
|
"You can install, upgrade, and remove packages using a program called :"
|
|
"program:`pip`. By default ``pip`` will install packages from the Python "
|
|
"Package Index, <https://pypi.python.org/pypi>. You can browse the Python "
|
|
"Package Index by going to it in your web browser, or you can use ``pip``'s "
|
|
"limited search feature:"
|
|
msgstr ""
|
|
|
|
#: ../Doc/tutorial/venv.rst:105
|
|
msgid ""
|
|
"``pip`` has a number of subcommands: \"search\", \"install\", \"uninstall\", "
|
|
"\"freeze\", etc. (Consult the :ref:`installing-index` guide for complete "
|
|
"documentation for ``pip``.)"
|
|
msgstr ""
|
|
|
|
#: ../Doc/tutorial/venv.rst:109
|
|
msgid ""
|
|
"You can install the latest version of a package by specifying a package's "
|
|
"name:"
|
|
msgstr ""
|
|
|
|
#: ../Doc/tutorial/venv.rst:120
|
|
msgid ""
|
|
"You can also install a specific version of a package by giving the package "
|
|
"name followed by ``==`` and the version number:"
|
|
msgstr ""
|
|
|
|
#: ../Doc/tutorial/venv.rst:131
|
|
msgid ""
|
|
"If you re-run this command, ``pip`` will notice that the requested version "
|
|
"is already installed and do nothing. You can supply a different version "
|
|
"number to get that version, or you can run ``pip install --upgrade`` to "
|
|
"upgrade the package to the latest version:"
|
|
msgstr ""
|
|
|
|
#: ../Doc/tutorial/venv.rst:146
|
|
msgid ""
|
|
"``pip uninstall`` followed by one or more package names will remove the "
|
|
"packages from the virtual environment."
|
|
msgstr ""
|
|
|
|
#: ../Doc/tutorial/venv.rst:149
|
|
msgid "``pip show`` will display information about a particular package:"
|
|
msgstr ""
|
|
|
|
#: ../Doc/tutorial/venv.rst:166
|
|
msgid ""
|
|
"``pip list`` will display all of the packages installed in the virtual "
|
|
"environment:"
|
|
msgstr ""
|
|
|
|
#: ../Doc/tutorial/venv.rst:178
|
|
msgid ""
|
|
"``pip freeze`` will produce a similar list of the installed packages, but "
|
|
"the output uses the format that ``pip install`` expects. A common convention "
|
|
"is to put this list in a ``requirements.txt`` file:"
|
|
msgstr ""
|
|
|
|
#: ../Doc/tutorial/venv.rst:190
|
|
msgid ""
|
|
"The ``requirements.txt`` can then be committed to version control and "
|
|
"shipped as part of an application. Users can then install all the necessary "
|
|
"packages with ``install -r``:"
|
|
msgstr ""
|
|
|
|
#: ../Doc/tutorial/venv.rst:207
|
|
msgid ""
|
|
"``pip`` has many more options. Consult the :ref:`installing-index` guide "
|
|
"for complete documentation for ``pip``. When you've written a package and "
|
|
"want to make it available on the Python Package Index, consult the :ref:"
|
|
"`distributing-index` guide."
|
|
msgstr ""
|
|
|
|
#: ../Doc/tutorial/whatnow.rst:5
|
|
msgid "What Now?"
|
|
msgstr ""
|
|
|
|
#: ../Doc/tutorial/whatnow.rst:7
|
|
msgid ""
|
|
"Reading this tutorial has probably reinforced your interest in using Python "
|
|
"--- you should be eager to apply Python to solving your real-world problems. "
|
|
"Where should you go to learn more?"
|
|
msgstr ""
|
|
|
|
#: ../Doc/tutorial/whatnow.rst:11
|
|
msgid ""
|
|
"This tutorial is part of Python's documentation set. Some other documents "
|
|
"in the set are:"
|
|
msgstr ""
|
|
|
|
#: ../Doc/tutorial/whatnow.rst:14
|
|
msgid ":ref:`library-index`:"
|
|
msgstr ""
|
|
|
|
#: ../Doc/tutorial/whatnow.rst:16
|
|
msgid ""
|
|
"You should browse through this manual, which gives complete (though terse) "
|
|
"reference material about types, functions, and the modules in the standard "
|
|
"library. The standard Python distribution includes a *lot* of additional "
|
|
"code. There are modules to read Unix mailboxes, retrieve documents via HTTP, "
|
|
"generate random numbers, parse command-line options, write CGI programs, "
|
|
"compress data, and many other tasks. Skimming through the Library Reference "
|
|
"will give you an idea of what's available."
|
|
msgstr ""
|
|
|
|
#: ../Doc/tutorial/whatnow.rst:24
|
|
msgid ""
|
|
":ref:`installing-index` explains how to install additional modules written "
|
|
"by other Python users."
|
|
msgstr ""
|
|
|
|
#: ../Doc/tutorial/whatnow.rst:27
|
|
msgid ""
|
|
":ref:`reference-index`: A detailed explanation of Python's syntax and "
|
|
"semantics. It's heavy reading, but is useful as a complete guide to the "
|
|
"language itself."
|
|
msgstr ""
|
|
|
|
#: ../Doc/tutorial/whatnow.rst:31
|
|
msgid "More Python resources:"
|
|
msgstr ""
|
|
|
|
#: ../Doc/tutorial/whatnow.rst:33
|
|
msgid ""
|
|
"https://www.python.org: The major Python Web site. It contains code, "
|
|
"documentation, and pointers to Python-related pages around the Web. This "
|
|
"Web site is mirrored in various places around the world, such as Europe, "
|
|
"Japan, and Australia; a mirror may be faster than the main site, depending "
|
|
"on your geographical location."
|
|
msgstr ""
|
|
|
|
#: ../Doc/tutorial/whatnow.rst:39
|
|
msgid "https://docs.python.org: Fast access to Python's documentation."
|
|
msgstr ""
|
|
|
|
#: ../Doc/tutorial/whatnow.rst:41
|
|
msgid ""
|
|
"https://pypi.python.org/pypi: The Python Package Index, previously also "
|
|
"nicknamed the Cheese Shop, is an index of user-created Python modules that "
|
|
"are available for download. Once you begin releasing code, you can register "
|
|
"it here so that others can find it."
|
|
msgstr ""
|
|
|
|
#: ../Doc/tutorial/whatnow.rst:46
|
|
msgid ""
|
|
"https://code.activestate.com/recipes/langs/python/: The Python Cookbook is a "
|
|
"sizable collection of code examples, larger modules, and useful scripts. "
|
|
"Particularly notable contributions are collected in a book also titled "
|
|
"Python Cookbook (O'Reilly & Associates, ISBN 0-596-00797-3.)"
|
|
msgstr ""
|
|
|
|
#: ../Doc/tutorial/whatnow.rst:51
|
|
msgid ""
|
|
"http://www.pyvideo.org collects links to Python-related videos from "
|
|
"conferences and user-group meetings."
|
|
msgstr ""
|
|
|
|
#: ../Doc/tutorial/whatnow.rst:54
|
|
msgid ""
|
|
"https://scipy.org: The Scientific Python project includes modules for fast "
|
|
"array computations and manipulations plus a host of packages for such things "
|
|
"as linear algebra, Fourier transforms, non-linear solvers, random number "
|
|
"distributions, statistical analysis and the like."
|
|
msgstr ""
|
|
|
|
#: ../Doc/tutorial/whatnow.rst:59
|
|
msgid ""
|
|
"For Python-related questions and problem reports, you can post to the "
|
|
"newsgroup :newsgroup:`comp.lang.python`, or send them to the mailing list at "
|
|
"python-list@python.org. The newsgroup and mailing list are gatewayed, so "
|
|
"messages posted to one will automatically be forwarded to the other. There "
|
|
"are hundreds of postings a day, asking (and answering) questions, suggesting "
|
|
"new features, and announcing new modules. Mailing list archives are "
|
|
"available at https://mail.python.org/pipermail/."
|
|
msgstr ""
|
|
|
|
#: ../Doc/tutorial/whatnow.rst:67
|
|
msgid ""
|
|
"Before posting, be sure to check the list of :ref:`Frequently Asked "
|
|
"Questions <faq-index>` (also called the FAQ). The FAQ answers many of the "
|
|
"questions that come up again and again, and may already contain the solution "
|
|
"for your problem."
|
|
msgstr ""
|