Python學習手記——Using the Python Interpreter

Using the Python Interpreter

2.1. Invoking the Interpreter¶

The Python interpreter is usually installed as /usr/local/bin/python on those machines where it is available; putting /usr/local/bin in your Unix shell’s search path makes it possible to start it by typing the command

python

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., /usr/local/python is a popular alternative location.)

On Windows machines, the Python installation is usually placed in C:\Python27, 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:

set path=%path%;C:\python27

Typing an end-of-file character (Control-D on Unix, 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().

The interpreter’s line-editing features usually aren’t very sophisticated. On Unix, whoever installed the interpreter may have enabled support for the GNU readline library, which adds more elaborate interactive editing and history features. Perhaps the quickest
check to see whether command line editing is supported is typing Control-P to the first Python prompt you get. If it beeps, you have command line editing; see Appendix
Interactive Input Editing and History Substitution 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.

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.

A second way of starting the interpreter is python -c command [arg] ..., which executes the statement(s) in
command, analogous to the shell’s
-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.

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.

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

-i before the script. (This does not work if the script is read from standard input, for the same reason as explained in the previous paragraph.)

2.1.1. Argument Passing¶

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

-c command is used, sys.argv[0] is set to '-c'. When
-m module is used, sys.argv[0] is set to the full name of the located module. Options found after

-c command or
-m module are not consumed by the Python interpreter’s option processing but left in sys.argv for the command or module to handle.

2.1.2. Interactive Mode¶

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:

python

Python 2.7 (#1, Feb 28 2010, 00:02:06)

Type "help", "copyright", "credits" or "license" for more information.

>>> 

Continuation lines are needed when entering a multi-line construct. As an example, take a look at this
if statement:

>>> the_world_is_flat = 1

>>> if the_world_is_flat:

...     print "Be careful not to fall off!"

...

Be careful not to fall off!

2.2. The Interpreter and Its Environment¶

2.2.1. Error Handling¶

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 except clause in a
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.

Typing the interrupt character (usually Control-C or DEL) to the primary or secondary prompt cancels the input and returns to the primary prompt.
[1] Typing an interrupt while a command is executing raises the

KeyboardInterrupt exception, which may be handled by a
try statement.

2.2.2. Executable Python Scripts¶

On BSD’ish Unix systems, Python scripts can be made directly executable, like shell scripts, by putting the line

#! /usr/bin/env python

(assuming that the interpreter is on the user’s 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.

The script can be given an executable mode, or permission, using the chmod command:

$ chmod +x myscript.py

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.

2.2.3. Source Code Encoding¶

It is possible to use encodings different than ASCII in Python source files. The best way to do it is to put one more special comment line right after the #! line to define the source file encoding:

# -*- coding: encoding -*-

With that declaration, all characters in the source file will be treated as having the encoding
encoding, and it will be possible to directly write Unicode string literals in the selected encoding. The list of possible encodings can be found in the Python Library Reference, in the section on

codecs.

For example, to write Unicode literals including the Euro currency symbol, the ISO-8859-15 encoding can be used, with the Euro symbol having the ordinal value 164. This script will print the value 8364 (the Unicode codepoint corresponding to the Euro symbol)
and then exit:

# -*- coding: iso-8859-15 -*-

 

currency = u"€"

print ord(currency)

If your editor supports saving files as UTF-8 with a UTF-8 byte order mark (aka BOM), you can use that instead of an encoding declaration. IDLE supports this capability if Options/General/Default Source Encoding/UTF-8 is set. Notice that this signature
is not understood in older Python releases (2.2 and earlier), and also not understood by the operating system for script files with #! lines (only used on Unix systems).

By using UTF-8 (either through the signature or an encoding declaration), characters of most languages in the world can be used simultaneously in string literals and comments. Using non-ASCII characters in identifiers is not supported. 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.

2.2.4. The Interactive Startup File¶

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
PYTHONSTARTUP to the name of a file containing your start-up commands. This is similar to the .profile feature of the Unix shells.

This file is only read in interactive sessions, not when Python reads commands from a script, and not when /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.

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'): execfile('.pythonrc.py'). If you want to use the startup file in a script, you
must do this explicitly in the script:

import os

filename = os.environ.get('PYTHONSTARTUP')

if filename and os.path.isfile(filename):

    execfile(filename)

Footnotes

[1]	A problem with the GNU Readline package may prevent this.

 

 

 

 

 

 

 

 

使用Python解譯器

2.1調用解譯器

Python 解譯器通常位於路徑/usr/local/bin/python下，在UNIX的命令列輸入python就能夠將其開啟。當然也可以將Python安裝在其它路徑下。在Windows作業系統中，Python常位於C:\Python27路徑下。

解譯器的編輯功能通常都不夠強大，而GNU readline library 能夠為編程人員提供更為強大的互動式編程工具。

確認是否支援命令列編輯的簡便方法是在你的第一個Python程式中點擊Ctrl+P，如果如果蜂鳴器響了，說明其支援命令列編輯模式。

Python解譯器的工作方式有點像Unix的指令碼程式：如果調用了標準輸入輸出，程式就會從命令列輸入輸出、資料；如果調用了以檔案名稱命名的變數或者直接掉偶那個了一個檔案，程式就讀取並運行該指令碼。

第二種開啟Python解譯器的方法是在命令列輸入：

python -c command [arg] ...

它通過命令列來運行指令碼。因為Python程式經常包含空格或者其它對解譯器來說非常特別的字元，因此強烈建議您使用單引號引用命令。

一些Python模組也能夠作為非常有用的指令碼。他們可以通過python -m module [arg] ...語句進行調用。

當調用一個指令檔的時候，有時通過互動式運行方法非常有用。它可以通過傳遞 -i參數來實現。(但如果程式使用的不是標準輸入輸出，互動式方法將無法實現。)

 

2.1.1 參數傳遞

當指令被解譯器檢測出來的時候，指令碼的名字和參數也被轉換成了一個字串的列表並且被賦值給了sys模組中的argv變數，你可以通過執行import sys來查看這個長度至少為1的列表。當沒有指令碼也沒有參數的時候，sys.argv[0]是一個空的字串。

 

2.1.2互動式模式

當命令是通過標準輸入輸出方式執行的時候，我們說它運行在互動式模式下。

python

Python 2.7 (#1, Feb 28 2010, 00:02:06)

Type "help", "copyright", "credits" or "license" for more information.

>>> 

 

>>> the_world_is_flat = 1

>>> if the_world_is_flat:

...     print "Be careful not to fall off!"

...

Be careful not to fall off!

 

2.2解譯器及其工作工作環境

2.2.1錯誤處理

       當錯誤發生的時候，解譯器列印一條錯誤資訊及其堆棧調用。在互動式模式下，它返回到主提示；在輸入來自檔案的時候，程式列印出堆棧調用情況之後返回一個非零值。(在這裡不把異常處理當做錯誤處理。)

所有的錯誤資訊都被寫入到standard output stream流。

在命令列引入中斷會引發KeyboardInterrupt exception，需要通過try處理。

2.2.2可執行檔Python指令碼

       在BSD UNIX作業系統中，Python指令碼能夠直接運行。在源檔案的開頭寫上

#! /usr/bin/env python

可以使該檔案具備直接啟動並執行能力。

使用chmod能夠使指令碼可運行。

$ chmod +x myscript.py

2.2.3 代碼編寫

在Python原始碼中可以使用與ASCII不同的編碼方式。最好的方法是在#!寫上注釋。

# -*- coding: encoding -*-

通過這種生命方法，源檔案中的所有字元都被當做encoding編碼方法處理，也可以直接使用UNICODE編碼方法。Python的所有支援編碼方法可以在the Python Library Reference,中查到。

2.2.4在互動模式下運行程式

當你在互動式模式下使用Python的時候，在解譯器運行是總會調用一些指令，你可以通過定義名為PYTHONSTARTUP環境變數來實現。它和UNIX中的.profile有些類似。

這種檔案只在互動式模式下進行讀取，而不再Python讀取指令檔時進行。他們執行在相同的命名空間之下，所以對象可以在互動式模式下使用。

       如果你希望在當前的目錄下讀取一個額外的開機檔案，你可以在全域開機檔案中這樣定義：

import os

filename = os.environ.get('PYTHONSTARTUP')

if filename and os.path.isfile(filename):

    execfile(filename)

 

【附】

GNU readline 是由 GNU 工程建立和維護的一個軟體包。它提供行編輯功能。例如，在 readline 授權的應用程式中，按下 C-b (CTRL-B) 將指標向後移到一個位置，然而 C-f 向前移動這個指標到一個位置；C-r 在曆史紀錄中搜尋；這些按鍵組合（這些是預設的，儘管像組合 vi's 是選擇性的）來自於 GNU 的最早和最流行的工程，文字編輯器 Emacs 。Readline 支援多種進階特徵，包括一個 kill ring（ 複製/粘貼剪下板的一種更靈活的版本）和 tab completion
。作為一個跨平台的庫，readline 允許多種系統上很多應用程式來展示行編輯表現方式。它是在 GNU 通用公用許可證(GPL)下的分發的一個自由包。