Python LanguagePython語言入門

備註

Python徽標
Python
是一種廣泛使用的編程語言。它是:

  • 高級 :Python自動執行內存管理等低級操作。它使程序員的控制能力降低,但具有許多優點,包括代碼可讀性和最少的代碼表達式。

  • 通用 :Python構建用於所有上下文和環境。非通用語言的一個示例是PHP:它專門設計為服務器端Web開發腳本語言。相比之下,Python 用於服務器端Web開發,也可用於構建桌面應用程序。

  • 動態類型化 :Python中的每個變量都可以引用任何類型的數據。單個表達式可以在不同時間評估不同類型的數據。因此,以下代碼是可能的:

    if something:
        x = 1
    else:
        x = 'this is a string'
    print(x)
    
  • 強類型 :在程序執行期間,不允許您執行任何與您正在使用的數據類型不兼容的操作。例如,沒有從字符串到數字的隱藏轉換;除非您明確轉換,否則由數字組成的字符串將永遠不會被視為數字:

    1 + '1'  # raises an error
    1 + int('1')  # results with 2
    
  • 初學者友好:) :Python的語法和結構非常直觀。它是高級別的,並提供用於在小規模和大規模上編寫清晰程序的結構。 Python支持多種編程範例,包括面向對象,命令式和函數式編程或程序樣式。它有一個大型,全面的標準庫和許多易於安裝的第三方庫。

它的設計原則在The Zen of Python中有所概述。

目前,Python有兩個主要的發布分支,它們有一些顯著的差異。 Python 2.x是遺留版本,但仍然廣泛使用。 Python 3.x進行了一組向後不兼容的更改,旨在減少功能重複。有關確定哪種版本最適合您的幫助,請參閱此文章

官方Python文檔也是一個全面而有用的資源,包含所有Python版本的文檔以及幫助您入門的教程。

Python.org提供了一種語言的官方實現,通常稱為CPython,以及其他運行時平台上該語言的幾種替代實現。這些包括IronPython (在.NET平台上運行Python), Jython (在Java運行時)和PyPy (在自身的子集中實現Python)。

版本

Python 3.x

發布日期
[3.7] 2017年5月8日
3.6 2016年12月23日
3.5 2015年9月13日
3.4 2014年3月17日
3.3 2012年9月29日
3.2 2011-02-20
3.1 2009-06-26
3.0 2008-12-03

Python 2.x

發布日期
2.7 2010-07-03
2.6 2008-10-02
2.5 2006-09-19
2.4 2004-11-30
2.3 2003-07-29
2.2 2001-12-21
2.1 2001年4月15日
2.0 2000年10月16日

入門

Python是一種廣泛使用的高級編程語言,用於通用編程,由Guido van Rossum創建並於1991年首次發布.Python具有動態類型系統和自動內存管理,支持多種編程範例,包括面向對象,命令式,函數式編程和過程樣式。它有一個龐大而全面的標準庫。

目前有兩個主要版本的Python正在使用中:

  • Python 3.x是當前版本,正在積極開發中。
  • Python 2.x是舊版本,直到2020年才會收到安全更新。不會實現任何新功能。請注意,許多項目仍然使用Python 2,儘管遷移到Python 3變得越來越容易。

您可以在此處下載並安裝任一版本的Python。有關它們之間的比較,請參閱Python 3與Python 2 。此外,一些第三方提供了重新打包的Python版本,它們添加了常用的庫和其他功能,以簡化常見用例的設置,例如數學,數據分析或科學使用。請參閱官方網站上的列表

驗證是否已安裝Python

要確認Python是否已正確安裝,您可以通過在您喜歡的終端中運行以下命令來驗證(如果您使用的是Windows操作系統,則需要在命令提示符中使用之前將python路徑添加到環境變量中):

$ python --version
 
Python 3.x 3.0

如果您安裝了Python 3 ,並且它是您的默認版本(請參閱疑難解答以獲取更多詳細信息),您應該看到如下內容:

$ python --version
Python 3.6.0
 
Python 2.x 2.7

如果您安裝了Python 2 ,並且它是您的默認版本(請參閱疑難解答以獲取更多詳細信息),您應該看到如下內容:

$ python --version
Python 2.7.13
 

如果你已經安裝了Python 3,但$ python --version 輸出了Python 2版本,那麼你也安裝了Python 2。在MacOS和許多Linux發行版中經常出現這種情況。使用$ python3 代替顯式使用Python 3解釋器。

你好,使用IDLE的Python世界


IDLE是一個簡單的Python編輯器,它與Python捆綁在一起。

如何在IDLE中創建Hello,World程序

  • 在您選擇的系統上打開IDLE。
    • 在舊版本的Windows中,可以在Windows菜單下的All Programs 找到它。
    • 在Windows 8+中,搜索IDLE 或在系統中存在的應用程序中找到它。
    • 在基於Unix的(包括Mac)系統上,您可以通過鍵入$ idle python_file.py 從shell打開它。
  • 它會在頂部打開一個帶有選項的shell。

在shell中,提示有三個直角括號:

>>>
 

現在在提示中編寫以下代碼:

>>> print("Hello, World")
 

按Enter鍵

>>> print("Hello, World")
Hello, World
 

Hello World Python文件

創建一個包含以下行的新文件hello.py

Python 3.x 3.0
print('Hello, World')
 
Python 2.x 2.6

您可以使用Python 2中的Python 3 print 函數使用以下import 語句:

from __future__ import print_function
 

Python 2具有許多功能,可以使用__future__ 模塊從Python 3中選擇性地導入,如此處所述

Python 2.x 2.7

如果使用Python 2,您也可以在下面輸入以下行。請注意,這在Python 3中無效,因此不推薦使用,因為它減少了跨版本代碼的兼容性。

print 'Hello, World'
 

在終端中,導航到包含文件hello.py 的目錄。

鍵入python hello.py ,然後按Enter鍵。

$ python hello.py
Hello, World
 

你應該看到Hello, World 打印到控制台。

您還可以將hello.py 替換為文件的路徑。例如,如果您的主目錄中有該文件,而您的用戶在Linux上是“user”,則可以鍵入python /home/user/hello.py

啟動交互式Python shell

通過在終端中執行(運行) python 命令,您將看到一個交互式Python shell。這也稱為Python解釋器或REPL(用於“讀取評估打印循環”)。

$ python
Python 2.7.12 (default, Jun 28 2016, 08:46:01) 
[GCC 6.1.1 20160602] on linux
Type "help", "copyright", "credits" or "license" for more information.
>>> print 'Hello, World'
Hello, World
>>>
 

如果要從終端運行Python 3,請執行命令python3

$ python3
Python 3.6.0 (default, Jan 13 2017, 00:00:00) 
[GCC 6.1.1 20160602] on linux
Type "help", "copyright", "credits" or "license" for more information.
>>> print('Hello, World')
Hello, World
>>>
 

或者,啟動交互式提示並使用python -i <file.py> 加載文件。

在命令行中,運行:

$ python -i hello.py
"Hello World"
>>>
 

有多種方法可以關閉Python shell:

>>> exit()
 

要么

>>> quit()
 

或者, CTRL + D將關閉shell並將您放回終端的命令行。

如果要取消正在鍵入的命令並返回到干淨的命令提示符,同時保留在Interpreter shell中,請使用CTRL + C.

在線嘗試交互式Python shell

其他在線貝殼

各種網站提供對Python shell的在線訪問。

在線shell可用於以下目的:

  • 從缺少python安裝的機器(智能手機,平板電腦等)運行一個小代碼片段。
  • 學習或教授基本的Python。
  • 解決在線判斷問題。

例子:

免責聲明:文檔作者不隸屬於下列任何資源。

以字符串形式運行命令

Python可以作為shell中的字符串傳遞任意代碼:

$ python -c 'print("Hello, World")'
Hello, World
 

在shell中將腳本的結果連接在一起時,這非常有用。

貝殼和超越

包管理 - PyPA推薦的用於安裝Python包的工具是PIP 。要安裝,請在命令行上執行pip install <the package name> 。例如, pip install numpy 。 (注意:在Windows上,您必須將pip添加到PATH環境變量。要避免這種情況,請使用python -m pip install <the package name>

Shell - 到目前為止,我們已經討論了使用Python的本機交互式shell運行代碼的不同方法。 Shell利用Python的解釋力實時驗證代碼。替代shell包括IDLE - 預先捆綁的GUI, IPython - 以擴展交互式體驗而聞名等。

程序 - 對於長期存儲,您可以將內容保存到.py文件,並使用外部工具(如shell, IDE (如PyCharm ), Jupyter筆記本等)將其編輯/執行為腳本或程序。中級用戶可以使用這些工具;但是,這裡討論的方法足以開始使用。

Python教程允許您逐步執行Python代碼,以便可視化程序的流程,並幫助您了解程序出錯的位置。

PEP8定義了格式化Python代碼的指南。格式化代碼非常重要,因此您可以快速閱讀代碼的功能。

阻止縮進

Python使用縮進來定義控件和循環結構。這有助於Python的可讀性,但是,它需要程序員密切關注空白的使用。因此,編輯器錯誤校準可能導致代碼以意想不到的方式運行。

Python使用冒號( : )和縮進表示在代碼塊的開始和結束(如果你來自其他語言,不以某種方式被相關混淆三元運算符 )。也就是說,Python中的塊,例如函數,循環, if 子句和其他構造,沒有結束標識符。所有塊都以冒號開頭,然後在其下方包含縮進的行。

例如:

def my_function():    # This is a function definition. Note the colon (:)
    a = 2             # This line belongs to the function because it's indented
    return a          # This line also belongs to the same function
print(my_function())  # This line is OUTSIDE the function block
 

要么

if a > b:             # If block starts here
    print(a)          # This is part of the if block
else:                 # else must be at the same level as if
    print(b)          # This line is part of the else block
 

只包含一個單行語句的塊可以放在同一行,但這種形式通常不被認為是好的樣式:

if a > b: print(a)
else: print(b)  
 

試圖與多條語句將無法工作更要做到這一點:

if x > y: y = x
    print(y) # IndentationError: unexpected indent

if x > y: while y != z: y -= 1  # SyntaxError: invalid syntax
 

空塊導致IndentationError 。如果您的塊沒有內容,請使用pass (不執行任何操作的命令):

def will_be_implemented_later():
    pass
 

空格與標籤

簡而言之: 始終使用4個空格進行縮進。

可以使用製表符,但PEP 8 (Python代碼的樣式指南)聲明空格是首選。

Python 3.x 3.0

Python 3不允許混合使用製表符和空格來縮進。在這種情況下,會生成編譯時錯誤: Inconsistent use of tabs and spaces in indentation ,程序將無法運行。

Python 2.x 2.7

Python 2允許在縮進中混合製表符和空格;這是非常沮喪的。製表符將前一個縮進完成8個空格倍數 。由於編輯器通常配置為將選項卡顯示為4個空格的多個,因此這可能會導致細微的錯誤。

引用PEP 8

當使用-t 選項調用Python 2命令行解釋器時,它會發出有關非法混合製表符和空格的代碼的警告。使用-tt 這些警告會出錯。強烈推薦這些選項!

許多編輯器都有“標籤到空格”配置。在配置編輯器時,應該區分製表 ('\ t')和Tab鍵。

  • 選項卡字符應配置為顯示8個空格,以匹配語言語義 - 至少在(偶然)混合縮進可能的情況下。編輯器還可以自動將製表符轉換為空格。
  • 但是,配置編輯器可能會有所幫助,以便按Tab鍵將插入4個空格,而不是插入製表符。

使用選項卡和空格混合編寫的Python源代碼,或者使用非標準數量的縮進空間,可以使用autopep8使用pep8 -conformant。 (大多數Python安裝都有一個不太強大的替代方案: reindent.py

內置模塊和功能

模塊是包含Python定義和語句的文件。函數是執行某些邏輯的一段代碼。

>>> pow(2,3)    #8
 

要檢查python中的內置函數,我們可以使用dir(). 如果在沒有參數的情況下調用,則返回當前範圍中的名稱。否則,返回一個按字母順序排列的名稱列表,其中包含(某些)給定對象的屬性以及可從中獲取的屬性。

>>> dir(__builtins__)
[
    'ArithmeticError', 
    'AssertionError', 
    'AttributeError', 
    'BaseException', 
    'BufferError', 
    'BytesWarning', 
    'DeprecationWarning', 
    'EOFError', 
    'Ellipsis', 
    'EnvironmentError', 
    'Exception', 
    'False', 
    'FloatingPointError', 
    'FutureWarning', 
    'GeneratorExit', 
    'IOError', 
    'ImportError', 
    'ImportWarning', 
    'IndentationError', 
    'IndexError', 
    'KeyError', 
    'KeyboardInterrupt', 
    'LookupError', 
    'MemoryError', 
    'NameError', 
    'None', 
    'NotImplemented', 
    'NotImplementedError', 
    'OSError', 
    'OverflowError', 
    'PendingDeprecationWarning', 
    'ReferenceError', 
    'RuntimeError', 
    'RuntimeWarning', 
    'StandardError', 
    'StopIteration', 
    'SyntaxError', 
    'SyntaxWarning', 
    'SystemError', 
    'SystemExit', 
    'TabError', 
    'True', 
    'TypeError', 
    'UnboundLocalError', 
    'UnicodeDecodeError', 
    'UnicodeEncodeError', 
    'UnicodeError', 
    'UnicodeTranslateError', 
    'UnicodeWarning', 
    'UserWarning', 
    'ValueError', 
    'Warning', 
    'ZeroDivisionError', 
    '__debug__', 
    '__doc__', 
    '__import__', 
    '__name__', 
    '__package__', 
    'abs', 
    'all', 
    'any', 
    'apply', 
    'basestring', 
    'bin', 
    'bool', 
    'buffer', 
    'bytearray', 
    'bytes', 
    'callable', 
    'chr', 
    'classmethod', 
    'cmp', 
    'coerce', 
    'compile', 
    'complex', 
    'copyright', 
    'credits', 
    'delattr', 
    'dict', 
    'dir', 
    'divmod', 
    'enumerate', 
    'eval', 
    'execfile', 
    'exit', 
    'file', 
    'filter', 
    'float', 
    'format', 
    'frozenset', 
    'getattr', 
    'globals', 
    'hasattr', 
    'hash', 
    'help', 
    'hex', 
    'id', 
    'input', 
    'int', 
    'intern', 
    'isinstance', 
    'issubclass', 
    'iter', 
    'len', 
    'license', 
    'list', 
    'locals', 
    'long', 
    'map', 
    'max', 
    'memoryview', 
    'min', 
    'next', 
    'object', 
    'oct', 
    'open', 
    'ord', 
    'pow', 
    'print', 
    'property', 
    'quit', 
    'range', 
    'raw_input', 
    'reduce', 
    'reload', 
    'repr', 
    'reversed', 
    'round', 
    'set', 
    'setattr', 
    'slice', 
    'sorted', 
    'staticmethod', 
    'str', 
    'sum', 
    'super', 
    'tuple', 
    'type', 
    'unichr', 
    'unicode', 
    'vars', 
    'xrange', 
    'zip'
]
 

要了解任何函數的功能,我們可以使用內置函數help

>>> help(max)
Help on built-in function max in module __builtin__:
max(...)
    max(iterable[, key=func]) -> value
    max(a, b, c, ...[, key=func]) -> value
    With a single iterable argument, return its largest item.
    With two or more arguments, return the largest argument.
 

內置模塊包含額外的功能。例如,要獲得數字的平方根,我們需要包含math 模塊。

>>> import math
>>> math.sqrt(16) # 4.0
 

要了解模塊中的所有函數,我們可以將函數列表分配給變量,然後打印變量。

>>> import math
>>> dir(math)

   ['__doc__', '__name__', '__package__', 'acos', 'acosh', 
   'asin', 'asinh', 'atan', 'atan2', 'atanh', 'ceil', 'copysign', 
   'cos', 'cosh', 'degrees', 'e', 'erf', 'erfc', 'exp', 'expm1', 
   'fabs', 'factorial', 'floor', 'fmod', 'frexp', 'fsum', 'gamma', 
   'hypot', 'isinf', 'isnan', 'ldexp', 'lgamma', 'log', 'log10', 
   'log1p', 'modf', 'pi', 'pow', 'radians', 'sin', 'sinh', 'sqrt', 
   'tan', 'tanh', 'trunc']
 

似乎__doc__ 對於在函數中提供一些文檔很有用

>>> math.__doc__
'This module is always available.  It provides access to the\nmathematical
 functions defined by the C standard.'
 

除功能外,還可以在模塊中提供文檔。所以,如果你有一個名為helloWorld.py 的文件,如下所示:

"""This is the module docstring."""

def sayHello():
    """This is the function docstring."""
    return 'Hello World'
 

您可以像這樣訪問其文檔字符串:

>>> import helloWorld
>>> helloWorld.__doc__
'This is the module docstring.'
>>> helloWorld.sayHello.__doc__
'This is the function docstring.'
 
  • 對於任何用戶定義的類型,其屬性,其類的屬性,以及遞歸地使用dir()可以檢索其類的基類的屬性
>>> class MyClassObject(object):
...     pass
... 
>>> dir(MyClassObject)
['__class__', '__delattr__', '__dict__', '__doc__', '__format__', '__getattribute__', '__hash__', '__init__', '__module__', '__new__', '__reduce__', '__reduce_ex__', '__repr__', '__setattr__', '__sizeof__', '__str__', '__subclasshook__', '__weakref__']
 

可以使用名為str 的內置函數將任何數據類型簡單地轉換為字符串。當數據類型傳遞給print 時,默認情況下會調用此函數

>>> str(123)    # "123"
 

集合類型

Python中有許多集合類型。雖然intstr 等類型包含單個值,但集合類型包含多個值。

清單

list 類型可能是Python中最常用的集合類型。儘管它的名字,列表更像是其他語言中的數組,主要是JavaScript。在Python中,列表只是有效Python值的有序集合。可以通過在方括號中用逗號分隔值來創建列表:

int_list = [1, 2, 3]
string_list = ['abc', 'defghi']
 

列表可以為空:

empty_list = []
 

列表的元素不限於單個數據類型,這是合理的,因為Python是一種動態語言:

mixed_list = [1, 'abc', True, 2.34, None]
 

列表可以包含另一個列表作為其元素:

nested_list = [['a', 'b', 'c'], [1, 2, 3]]
 

可以通過索引或其位置的數字表示來訪問列表的元素。 Python中的列表是零索引的,這意味著列表中的第一個元素位於索引0處,第二個元素位於索引1處,依此類推:

names = ['Alice', 'Bob', 'Craig', 'Diana', 'Eric']
print(names[0]) # Alice
print(names[2]) # Craig
 

指數也可以是負數,這意味著從列表的末尾開始計數( -1 是最後一個元素的索引)。因此,使用上面示例中的列表:

print(names[-1]) # Eric
print(names[-4]) # Bob
 

列表是可變的,因此您可以更改列表中的值:

names[0] = 'Ann'
print(names)
# Outputs ['Ann', 'Bob', 'Craig', 'Diana', 'Eric']
 

此外,可以從列表中添加和/或刪除元素:

使用L.append(object) 將對象附加到列表L.append(object) ,返回None

names = ['Alice', 'Bob', 'Craig', 'Diana', 'Eric']
names.append("Sia")
print(names) 
# Outputs ['Alice', 'Bob', 'Craig', 'Diana', 'Eric', 'Sia']
 

在特定索引處添加要列出的新元素。 L.insert(index, object)

names.insert(1, "Nikki")
print(names)
# Outputs ['Alice', 'Nikki', 'Bob', 'Craig', 'Diana', 'Eric', 'Sia']
 

使用L.remove(value) 刪除第一個出現的L.remove(value) ,返回None

names.remove("Bob")
print(names) # Outputs ['Alice', 'Nikki', 'Craig', 'Diana', 'Eric', 'Sia']
 

獲取值為x的第一個項目列表中的索引。如果沒有這樣的項目,它將顯示錯誤。

name.index("Alice")
0
 

計算列表的長度

len(names)
6
 

計算列表中任何項目的出現次數

a = [1, 1, 1, 2, 3, 4]
a.count(1)
3
 

翻轉清單

a.reverse()
[4, 3, 2, 1, 1, 1]
# or
a[::-1]
[4, 3, 2, 1, 1, 1]
 

使用L.pop([index]) 刪除並返回索引處的項目(默認為最後一項L.pop([index]) ,返回該項目

names.pop() # Outputs 'Sia'
 

您可以迭代列表元素,如下所示:

for element in my_list:
    print (element)
 

元組

tuple 類似於列表,除了它是固定長度和不可變的。因此,元組中的值不能更改,也不能將值添加到元組或從元組中刪除。元組通常用於不需要更改的小型值集合,例如IP地址和端口。元組用括號表示而不是方括號:

ip_address = ('10.20.30.40', 8080)
 

列表的相同索引規則也適用於元組。元組也可以嵌套,值可以是任何有效的Python有效。

必須以這種方式定義只有一個成員的元組(注意逗號):

one_member_tuple = ('Only member',)
 

要么

one_member_tuple = 'Only member',   # No brackets
 

或者只是使用tuple 語法

one_member_tuple = tuple(['Only member'])
 

字典

Python中的dictionary 是鍵值對的集合。字典被花括號包圍。每對用逗號分隔,鍵和值用冒號分隔。這是一個例子:

state_capitals = {
    'Arkansas': 'Little Rock',
    'Colorado': 'Denver',
    'California': 'Sacramento', 
    'Georgia': 'Atlanta'
}
 

要獲取值,請通過其鍵引用它:

ca_capital = state_capitals['California']
 

您還可以獲取字典中的所有鍵,然後迭代它們:

for k in state_capitals.keys():
    print('{} is the capital of {}'.format(state_capitals[k], k))
 

字典非常類似於JSON語法。 Python標準庫中的本機json 模塊可用於在JSON和字典之間進行轉換。

set 是一組元素,沒有重複,沒有插入順序,但排序順序。它們用於以下情況:將某些事物組合在一起非常重要,而不是包含它們的順序。對於大型數據組,檢查元素是否在set 要比對list 執行相同操作要快得多。

定義set 與定義dictionary 非常相似:

first_names = {'Adam', 'Beth', 'Charlie'}
 

或者您可以使用現有list 構建set

my_list = [1,2,3]
my_set = set(my_list)
 

使用in 檢查set 成員資格:

if name in first_names:
    print(name)
 

您可以像列表一樣遍歷set ,但請記住:值將以任意實現定義的順序進行。

defaultdict

defaultdict 是一個具有鍵默認值的字典,因此可以無錯誤地訪問未明確定義任何值的鍵。當字典中的值是集合(列表,字符串等)時, defaultdict 特別有用,因為每次使用新密鑰時都不需要初始化它。

defaultdict 永遠不會引發KeyError。任何不存在的鍵都會返回默認值。

例如,請考慮以下字典

>>> state_capitals = {
    'Arkansas': 'Little Rock',
    'Colorado': 'Denver',
    'California': 'Sacramento', 
    'Georgia': 'Atlanta'
}
 

如果我們嘗試訪問一個不存在的鍵,python會返回一個錯誤,如下所示

>>> state_capitals['Alabama']
Traceback (most recent call last):

  File "<ipython-input-61-236329695e6f>", line 1, in <module>
    state_capitals['Alabama']

KeyError: 'Alabama'
 

讓我們嘗試一下defaultdict 。它可以在collections模塊中找到。

>>> from collections import defaultdict
>>> state_capitals = defaultdict(lambda: 'Boston')
 

我們在這裡做的是設置一個默認值( 波士頓 ),以防Give鍵不存在。現在像以前一樣填充dict:

>>> state_capitals['Arkansas'] = 'Little Rock'
>>> state_capitals['California'] = 'Sacramento'
>>> state_capitals['Colorado'] = 'Denver'
>>> state_capitals['Georgia'] = 'Atlanta'
 

如果我們嘗試使用不存在的密鑰訪問dict,python將返回默認值,即Boston

>>> state_capitals['Alabama']
'Boston'
 

並返回現有鍵的創建值,就像普通dictionary

>>> state_capitals['Arkansas']
'Little Rock'
 

創建一個模塊

模塊是包含定義和語句的可導入文件。

可以通過創建.py 文件來創建模塊。

# hello.py
def say_hello():
    print("Hello!")
 

可以通過導入模塊來使用模塊中的功能。

對於您創建的模塊,它們需要與您將其導入的文件位於同一目錄中。 (但是,您也可以使用預先包含的模塊將它們放入Python lib目錄中,但如果可能,應該避免使用它們。)

$ python
>>> import hello
>>> hello.say_hello()
=> "Hello!"
 

模塊可以由其他模塊導入。

# greet.py
import hello
hello.say_hello()
 

可以導入模塊的特定功能。

# greet.py
from hello import say_hello
say_hello()
 

模塊可以別名。

# greet.py
import hello as ai
ai.say_hello()
 

模塊可以是獨立的可運行腳本。

# run_hello.py
if __name__ == '__main__':
    from hello import say_hello
    say_hello()
 

運行!

$ python run_hello.py
=> "Hello!"
 

如果模塊位於目錄中並且需要由python檢測,則該目錄應包含名為__init__.py 的文件。

創建變量並分配值

要在Python中創建變量,您需要做的就是指定變量名稱,然後為其賦值。

<variable name> = <value>
 

Python使用= 為變量賦值。不需要提前聲明變量(或為其分配數據類型),為變量本身賦值並聲明並使用該值初始化變量。如果沒有為變量賦值,則無法聲明變量。

# Integer
a = 2
print(a)
# Output: 2

# Integer    
b = 9223372036854775807
print(b)
# Output: 9223372036854775807

# Floating point
pi = 3.14
print(pi)
# Output: 3.14

# String
c = 'A'
print(c)
# Output: A

# String    
name = 'John Doe'
print(name)
# Output: John Doe

# Boolean    
q = True
print(q)
# Output: True

# Empty value or null data type
x = None
print(x)
# Output: None
 

變量賦值從左到右。因此,以下內容將為您提供語法錯誤。

0 = x
=> Output: SyntaxError: can't assign to literal
 

您不能將python的關鍵字用作有效的變量名。您可以通過以下方式查看關鍵字列表:

import keyword
print(keyword.kwlist)
 

變量命名規則:

  1. 變量名稱必須以字母或下劃線開頭。
 x  = True   # valid
 _y = True   # valid

 9x = False  # starts with numeral 
 => SyntaxError: invalid syntax   

 $y = False #  starts with symbol 
 => SyntaxError: invalid syntax
 
  1. 變量名的其餘部分可能包含字母,數字和下劃線。
has_0_in_it = "Still Valid" 
 
  1. 名稱區分大小寫。
x = 9  
y = X*5   
=>NameError: name 'X' is not defined
 

儘管在Python中聲明變量時不需要指定數據類型,但在內存中為變量分配必要的區域時,Python解釋器會自動為其選擇最合適的內置類型

a = 2
print(type(a))
# Output: <type 'int'>

b = 9223372036854775807
print(type(b))
# Output: <type 'int'>

pi = 3.14
print(type(pi))
# Output: <type 'float'>

c = 'A'
print(type(c))
# Output: <type 'str'>

name = 'John Doe'
print(type(name))
# Output: <type 'str'>

q = True
print(type(q))
# Output: <type 'bool'>

x = None
print(type(x))
# Output: <type 'NoneType'>
 

現在您已經了解了賦值的基礎知識,讓我們在python中獲得關於賦值的精妙之處。

當您使用= 進行賦值操作時, = 左側的內容是右側對象名稱 。最後,what = does將右側對象的引用分配給左側的名稱

那是:

a_name = an_object  # "a_name" is now a name for the reference to the object "an_object"
 

因此,從上述許多分配的例子,如果我們選擇pi = 3.14 ,則pi一個 名稱 (而不是名字,因為一個對象可以有多個名字)為對象3.14 。如果您對下面的內容不了解,請回到這一點並再次閱讀!此外,您可以查看此內容以便更好地理解。


您可以在一行中為多個變量分配多個值。請注意, = 運算符的右側和左側必須有相同數量的參數:

a, b, c = 1, 2, 3
print(a, b, c)
# Output: 1 2 3

a, b, c = 1, 2
=> Traceback (most recent call last):
=>   File "name.py", line N, in <module>
=>     a, b, c = 1, 2
=> ValueError: need more than 2 values to unpack

a, b = 1, 2, 3
=> Traceback (most recent call last):
=>   File "name.py", line N, in <module>
=>     a, b = 1, 2, 3
=> ValueError: too many values to unpack
 

通過將剩餘值分配給相等數量的任意變量,可以避免最後一個示例中的錯誤。這個虛擬變量可以有任何名稱,但通常使用下劃線( _ )來分配不需要的值:

a, b, _ = 1, 2, 3
print(a, b)
# Output: 1, 2
 

請注意,_的數量和剩餘值的數量必須相等。否則,如上所述拋出“解壓錯誤的值太多”:

a, b, _ = 1,2,3,4
=>Traceback (most recent call last):
=>File "name.py", line N, in <module>
=>a, b, _ = 1,2,3,4
=>ValueError: too many values to unpack (expected 3)
 

您還可以同時為多個變量分配單個值。

a = b = c = 1
print(a, b, c)
# Output: 1 1 1
 

當使用這種級聯賦值時,重要的是要注意所有三個變量abc 引用內存中的同一個對象 ,一個值為1的int 對象。換句話說, abc 是三個不同的名稱給同一個int對象。之後為其中一個分配不同的對像不會改變其他對象,就像預期的那樣:

a = b = c = 1    # all three names a, b and c refer to same int object with value 1
print(a, b, c)
# Output: 1 1 1
b = 2            # b now refers to another int object, one with a value of 2
print(a, b, c)
# Output: 1 2 1  # so output is as expected.
 

以上對於可變類型(如listdict 等)也是如此,就像對於不可變類型(如intstringtuple 等)一樣:

x = y = [7, 8, 9]   # x and y refer to the same list object just created, [7, 8, 9]
x = [13, 8, 9]      # x now refers to a different list object just created, [13, 8, 9]
print(y)            # y still refers to the list it was first assigned
# Output: [7, 8, 9]
 

到現在為止還挺好。當級聯賦值用於可變類型時,在修改對象時(與名稱分配給不同的對象,我們在上面做過)相比,情況有所不同。看看下面,你會看到它的第一手:

x = y = [7, 8, 9]     # x and y are two different names for the same list object just created, [7, 8, 9]
x[0] = 13             # we are updating the value of the list [7, 8, 9] through one of its names, x in this case
print(y)              # printing the value of the list using its other name
# Output: [13, 8, 9]  # hence, naturally the change is reflected
 

嵌套列表在python中也有效。這意味著列表可以包含另一個列表作為元素。

x = [1, 2, [3, 4, 5], 6, 7] # this is nested list
print x[2]
# Output: [3, 4, 5]
print x[2][1]
# Output: 4
 

最後,Python中的變量不必保持與它們最初定義的類型相同 - 您可以簡單地使用= 為變量分配新值,即使該值屬於不同類型。

a = 2 
print(a)
# Output: 2

a = "New value"
print(a)
# Output: New value
 

如果這讓你感到困擾,那就考慮一下這個事實,即= 左邊的內容只是一個對象的名字。首先調用int 值為2的對象a ,那麼你就改變了主意,決定給名字a 一個string 對象,其價值的“新價值”。簡單吧?

數據類型

內置類型

布爾

bool :布爾值為TrueFalse 。可以對布爾值執行andor not 執行邏輯運算。

x or y    # if x is False then y otherwise x 
x and y   # if x is False then x otherwise y
not x     # if x is True then False, otherwise True
 

在Python 2.x和Python 3.x中,布爾值也是一個intbool 類型是int 類型的子類, TrueFalse 是它的唯一實例:

issubclass(bool, int) # True

isinstance(True, bool) # True
isinstance(False, bool) # True
 

如果在算術運算中使用布爾值,則它們的整數值( TrueFalse10 )將用於返回整數結果:

True + False == 1 # 1 + 0 == 1
True * True  == 1 # 1 * 1 == 1
 

數字

  • int :整數

    a = 2
    b = 100
    c = 123456789
    d = 38563846326424324
     

    Python中的整數具有任意大小。

    注意:在舊版本的Python中,可以使用long 類型,這與int 不同。這兩個已經統一了。

  • float :浮點數;精度取決於實現和系統架構,對於CPython, float 數據類型對應於C double。

    a = 2.0
    b = 100.e0
    c = 123456789.e1
     
  • complex :複數

    a = 2 + 1j
    b = 100 + 10j
     

當任何操作數是複數時, <<=>>= 運算符將引發TypeError 異常。

字符串

Python 3.x 3.0
  • str :一個unicode字符串'hello' 的類型
  • bytes :一個字節字符串b'hello' 的類型
Python 2.x 2.7
  • str :一個字節串'hello' 的類型
  • bytesstr 同義詞
  • unicode :一個unicode字符串u'hello' 的類型

序列和集合

Python區分有序序列和無序集合(例如setdict )。

  • 字符串( strbytesunicode )是序列

  • reversed :的相反順序strreversed 函數

    a = reversed('hello')
     
  • tuple :任意類型的n 值的有序集合( n >= 0 )。

    a = (1, 2, 3)
    b = ('a', 1, 'python', (1, 2))
    b[2] = 'something else' # returns a TypeError
     

    支持索引;不可改變的;如果其所有成員都可以清洗,則可以清洗

  • listn 值的有序集合( n >= 0

    a = [1, 2, 3]
    b = ['a', 1, 'python', (1, 2), [1, 2]]
    b[2] = 'something else' # allowed
     

    不可洗;可變的。

  • set :唯一值的無序集合。物品必須是可清洗的

    a = {1, 2, 'a'}
     
  • dict :無序的唯一鍵值對集合;鑰匙必須是可以清洗的

    a = {1: 'one',
         2: 'two'}
    
    b = {'a': [1, 2, 3],
         'b': 'a string'}
     

如果一個對象具有一個在其生命週期內永遠不會改變的哈希值(它需要__hash__() 方法),並且可以與其他對象進行比較(它需要__eq__() 方法),則該對__hash__() 。比較相等性的Hashable對象必須具有相同的哈希值。

內置常量

結合內置數據類型,內置命名空間中有少量內置常量:

  • True :內置式bool 的真正價值
  • False :內置類型bool 的false值
  • None :用於表示缺少值的單個對象。
  • Ellipsis... :在Python3 +核心中使用,在Python2.7 +中作為數組表示法的一部分使用有限。 numpy 和相關的包使用它作為數組中的“包含所有”引用。
  • NotImplemented :用於向Python指示特殊方法不支持特定參數的單例,如果可用,Python將嘗試替代方法。
a = None # No value will be assigned. Any valid datatype can be assigned later
 
Python 3.x 3.0

None 任何自然順序。不再支持使用排序比較運算符( <<=>=> )並引發TypeError

Python 2.x 2.7

None 始終小於任何數字( None < -32 計算結果為True )。

測試變量的類型

在python中,我們可以使用內置函數type 檢查對象的數據type

a = '123'
print(type(a))
# Out: <class 'str'>
b = 123
print(type(b))
# Out: <class 'int'>
 

在條件語句中,可以使用isinstance 測試數據類型。但是,通常不鼓勵依賴變量的類型。

i = 7
if isinstance(i, int):
    i += 1
elif isinstance(i, str):
    i = int(i)
    i += 1
 

有關type()isinstance() 之間差異的信息,請閱讀: Python中isinstance和type之間的差異

要測試某些東西是否為NoneType

x = None
if x is None:
    print('Not a surprise, I just defined x as None.')
 

在數據類型之間轉換

您可以執行顯式數據類型轉換。

例如,'123'是str 類型,可以使用int 函數將其轉換為整數。

a = '123'
b = int(a)
 

可以使用float 函數從浮點字符串(例如'123.456')轉換。

a = '123.456'
b = float(a)
c = int(a)    # ValueError: invalid literal for int() with base 10: '123.456'
d = int(b)    # 123
 

您還可以轉換序列或集合類型

a = 'hello'
list(a)  # ['h', 'e', 'l', 'l', 'o']
set(a)   # {'o', 'e', 'l', 'h'}
tuple(a) # ('h', 'e', 'l', 'l', 'o')
 

文字定義的顯式字符串類型

在引號前面有一個字母標籤,您可以知道要定義的字符串類型。

  • b'foo bar' :Python 3中的結果bytes ,Python 2中的str
  • u'foo bar' :Python 3中的結果str ,Python 2中的unicode
  • 'foo bar' :結果str
  • r'foo bar' :結果所謂的原始字符串,其中不需要轉義特殊字符,所有內容都是在您輸入時逐字記錄的
normal  = 'foo\nbar'   # foo
                       # bar
escaped = 'foo\\nbar'  # foo\nbar   
raw     = r'foo\nbar'  # foo\nbar
 

可變和不可變數據類型

如果可以更改對象,則稱為mutable 。例如,當您將列表傳遞給某個函數時,可以更改列表:

def f(m):
    m.append(3)  # adds a number to the list. This is a mutation.

x = [1, 2]
f(x)
x == [1, 2]  # False now, since an item was added to the list
 

如果無法以任何方式更改對象,則該對象稱為不可變 。例如,整數是不可變的,因為沒有辦法改變它們:

def bar():
    x = (1, 2)
    g(x)
    x == (1, 2)  # Will always be True, since no function can change the object (1, 2)
 

請注意, 變量本身是可變的,因此我們可以重新分配變量 x ,但這不會更改x 先前指向的對象。它只使x 指向一個新對象。

實例可變的數據類型稱為可變數據類型 ,類似於不可變對象和數據類型。

不可變數據類型的示例:

  • intlongfloatcomplex
  • str
  • bytes
  • tuple
  • frozenset

可變數據類型的示例:

  • bytearray
  • list
  • set
  • dict

幫助工具

Python在解釋器中內置了幾個函數。如果要獲取關鍵字,內置函數,模塊或主題的信息,請打開Python控制台並輸入:

>>> help()
 

您將直接輸入關鍵字來接收信息:

>>> help(help)
 

在實用程序內:

help> help
 

這將顯示一個解釋:

Help on _Helper in module _sitebuiltins object:

class _Helper(builtins.object)
 |  Define the builtin 'help'.
 |  
 |  This is a wrapper around pydoc.help that provides a helpful message
 |  when 'help' is typed at the Python interactive prompt.
 |  
 |  Calling help() at the Python prompt starts an interactive help session.
 |  Calling help(thing) prints help for the python object 'thing'.
 |  
 |  Methods defined here:
 |  
 |  __call__(self, *args, **kwds)
 |  
 |  __repr__(self)
 |  
 |  ----------------------------------------------------------------------
 |  Data descriptors defined here:
 |  
 |  __dict__
 |      dictionary for instance variables (if defined)
 |  
 |  __weakref__
 |      list of weak references to the object (if defined)
 

您還可以請求模塊的子類:

help(pymysql.connections)
 

您可以使用幫助來訪問已導入的不同模塊的文檔字符串,例如,嘗試以下操作:

>>> help(math)
 

你會收到一個錯誤

>>> import math
>>> help(math)
 

現在,您將獲得模塊中可用方法的列表,但僅在您導入它之後。

quit 關閉幫助程序

IDLE - Python GUI

IDLE是Python的集成開發和學習環境,是命令行的替代品。顧名思義,IDLE對於開發新代碼或學習python非常有用。在Windows上,這帶有Python解釋器,但在其他操作系統中,您可能需要通過包管理器安裝它。

IDLE的主要目的是:

  • 具有語法突出顯示,自動完成和智能縮進的多窗口文本編輯器
  • 具有語法突出顯示的Python shell
  • 集成調試器,具有步進,持久斷點和調用堆棧可見性
  • 自動縮進(對於初學者學習Python的縮進很有用)
  • 將Python程序保存為.py文件並運行它們,稍後使用IDLE編輯它們。

在IDLE中,點擊F5run Python Shell 以啟動解釋器。使用IDLE對於新用戶來說可以是更好的學習體驗,因為代碼被解釋為用戶寫入。

請注意,有很多替代方案,請參閱此討論此列表

故障排除

  • 視窗

    如果您使用的是Windows,則默認命令為python 。如果收到"'python' is not recognized" 錯誤,最可能的原因是Python的位置不在系統的PATH 環境變量中。右鍵單擊“我的電腦”並選擇“屬性”或通過“控制面板”導航到“系統”即可訪問此項。單擊“高級系統設置”,然後單擊“環境變量...”。編輯PATH 變量以包含Python安裝目錄,以及Script文件夾(通常為C:\Python27;C:\Python27\Scripts )。這需要管理權限,可能需要重新啟動。

    在同一台機器上使用多個版本的Python時,可能的解決方案是重命名其中一個python.exe 文件。例如,命名一個版本python27.exe 會導致python27 成為該版本的Python命令。

    您還可以使用Python Launcher for Windows,它可以通過安裝程序獲得,默認情況下也可以使用。它允許您使用py -[xy] 而不是python[xy] 來選擇要運行的Python版本。您可以通過運行帶有腳本使用最新版本的Python 2的py -2 ,並通過運行腳本的最新版本的Python 3的py -3

  • 於Debian / Ubuntu / MacOS的

    本節假定已將python 可執行文件的位置添加到PATH 環境變量中。

    如果您使用的是Debian / Ubuntu / MacOS,請打開終端並輸入python for Python 2.x或python3 for Python 3.x.

    鍵入which python 以查看將使用哪個Python解釋器。

  • Arch Linux

    Arch Linux(及其後代)上的默認Python是Python 3,因此對Python 3.x使用pythonpython3 ,對Python 2.x使用python2

  • 其他系統

    Python 3有時綁定到python 而不是python3 。要在安裝它的這些系統上使用Python 2,您可以使用python2

安裝Python 2.7.x和3.x.

注意 :以下說明是針對Python 2.7編寫的(除非另有說明):Python 3.x的說明類似。

視窗

首先,從官方網站( https://www.python.org/downloads/)下載最新版本的Python 2.7。版本作為MSI包提供。要手動安裝,只需雙擊該文件即可。

默認情況下,Python安裝到目錄:

 C:\Python27\
 

警告:安裝不會自動修改PATH環境變量。

假設您的Python安裝在C:\ Python27中,請將其添加到PATH中:

C:\Python27\;C:\Python27\Scripts\
 

現在檢查Python安裝是否有效寫入cmd:

python --version
 

Python 2.x和3.x Side-By-Side

要在Windows機器上並排安裝和使用Python 2.x和3.x:

  1. 使用MSI安裝程序安裝Python 2.x.

    • 確保為所有用戶安裝了Python。
    • 可選:將Python添加到PATH ,以便使用python 從命令行調用Python 2.x.
  2. 使用各自的安裝程序安裝Python 3.x.

    • 同樣,確保為所有用戶安裝Python。
    • 可選:將Python添加到PATH 以使用python 從命令行調用Python 3.x.這可能會覆蓋Python 2.x PATH 設置,因此請仔細檢查您的PATH 並確保將其配置為您的首選項。
    • 確保為所有用戶安裝py launcher

Python 3將安裝Python啟動程序,可用於從命令行交替啟動Python 2.x和Python 3.x:

P:\>py -3
Python 3.6.1 (v3.6.1:69c0db5, Mar 21 2017, 17:54:52) [MSC v.1900 32 bit (Intel)] on win32
Type "help", "copyright", "credits" or "license" for more information.
>>>

C:\>py -2
Python 2.7.13 (v2.7.13:a06454b1afa1, Dec 17 2016, 20:42:59) [MSC v.1500 32 Intel)] on win32
Type "help", "copyright", "credits" or "license" for more information.
>>>
 

要為特定Python版本使用相應版本的pip ,請使用:

C:\>py -3 -m pip -V
pip 9.0.1 from C:\Python36\lib\site-packages (python 3.6)

C:\>py -2 -m pip -V
pip 9.0.1 from C:\Python27\lib\site-packages (python 2.7)
 

LINUX

最新版本的CentOS,Fedora,Redhat Enterprise(RHEL)和Ubuntu都附帶Python 2.7。

要手動在Linux上安裝Python 2.7,只需在終端中執行以下操作:

wget --no-check-certificate https://www.python.org/ftp/python/2.7.X/Python-2.7.X.tgz
tar -xzf Python-2.7.X.tgz  
cd Python-2.7.X
./configure  
make  
sudo make install
 

還要在PATH環境變量中添加新python的路徑。如果新的python在/root/python-2.7.X 則運行export PATH = $PATH:/root/python-2.7.X

現在檢查Python安裝是否有效寫入終端:

python --version
 

Ubuntu(來源)

如果您需要Python 3.6,可以從源代碼安裝它,如下所示(Ubuntu 16.10和17.04在通用存儲庫中有3.6版本)。 Ubuntu 16.04及更低版本必須遵循以下步驟:

sudo apt install build-essential checkinstall
sudo apt install libreadline-gplv2-dev libncursesw5-dev libssl-dev libsqlite3-dev tk-dev libgdbm-dev libc6-dev libbz2-dev
wget https://www.python.org/ftp/python/3.6.1/Python-3.6.1.tar.xz
tar xvf Python-3.6.1.tar.xz 
cd Python-3.6.1/
./configure --enable-optimizations
sudo make altinstall
 

蘋果系統

正如我們所說,macOS隨Python 2.7.10一起安裝,但是這個版本已經過時,並且從常規Python中略有修改。

OS X附帶的Python版本非常適合學習,但它對開發不利。 OS X附帶的版本可能與官方當前的Python版本已過時,後者被認為是穩定的生產版本。 ( 來源

安裝Homebrew

/usr/bin/ruby -e "$(curl -fsSL https://raw.githubusercontent.com/Homebrew/install/master/install)"
 

安裝Python 2.7:

brew install python
 

對於Python 3.x,請使用brew install python3 命令。

使用pip安裝外部模塊

當您需要從python包索引(PyPI)中提供的眾多選項中安裝任何包時, pip 是您的朋友。如果您使用從python.org下載的Python 2> = 2.7.9或Python 3> = 3.4,則已經安裝了pip 。對於運行Linux的計算機或具有本機程序包管理器的其他* nix,通常必須手動安裝 pip

在安裝了Python 2和Python 3的實例上, pip 通常是指Python 2, pip3 指向Python 3.使用pip 只會安裝Python 2的包,而pip3 只會安裝Python 3的包。

查找/安裝包

搜索包就像打字一樣簡單

$ pip search <query>
# Searches for packages whose name or summary contains <query>
 

安裝包就像輸入一樣簡單(在終端/命令提示符中,而不是在Python解釋器中)

$ pip install [package_name]           # latest version of the package

$ pip install [package_name]==x.x.x    # specific version of the package

$ pip install '[package_name]>=x.x.x'  # minimum version of the package
 

其中xxx 是要安裝的軟件包的版本號。

當您的服務器位於代理服務器後面時,可以使用以下命令安裝軟件包:

$ pip --proxy http://<server address>:<port> install
 

升級已安裝的軟件包

當出現新版本的已安裝軟件包時,它們不會自動安裝到您的系統中。要了解已安裝的軟件包已過時的概述,請運行:

$ pip list --outdated
 

升級特定包使用

$ pip install [package_name] --upgrade
 

更新所有過時的軟件包不是pip 的標準功能。

升級點子

您可以使用以下命令升級現有的pip安裝

  • 在Linux或macOS X上:

    $ pip install -U pip
     

    您可能需要在某些Linux系統上使用帶有pip的sudo

  • 在Windows上:

    py -m pip install -U pip
     

    要么

    python -m pip install -U pip
     

有關pip的更多信息,請閱讀此處

字符串函數 - str()和repr()

有兩個函數可用於獲取對象的可讀表示。

repr(x) 調用x.__repr__()x 的表示。 eval 通常會將此函數的結果轉換回原始對象。

str(x) 調用x.__str__() :描述對象的人類可讀字符串。這可能會忽略一些技術細節。


再版()

對於許多類型,此函數嘗試返回一個字符串,該字符串在傳遞給eval() 時會產生具有相同值的對象。否則,表示是包含在尖括號中的字符串,其中包含對像類型的名稱以及其他信息。這通常包括對象的名稱和地址。

STR()

對於字符串,這將返回字符串本身。 this和repr(object) 之間的區別在於str(object) 並不總是嘗試返回eval() 可接受的字符串。相反,它的目標是返回可打印或“人類可讀”的字符串。如果沒有給出參數,則返回空字符串''


例1:

s = """w'o"w"""
repr(s) # Output: '\'w\\\'o"w\''  
str(s)  # Output: 'w\'o"w'
eval(str(s)) == s  # Gives a SyntaxError 
eval(repr(s)) == s # Output: True
 

例2:

import datetime
today = datetime.datetime.now()
str(today)  # Output: '2016-09-15 06:58:46.915000'
repr(today) # Output: 'datetime.datetime(2016, 9, 15, 6, 58, 46, 915000)'
 

編寫類時,可以覆蓋這些方法來執行任何操作:

class Represent(object):

    def __init__(self, x, y):
        self.x, self.y = x, y

    def __repr__(self):
        return "Represent(x={},y=\"{}\")".format(self.x, self.y)

    def __str__(self):
        return "Representing x as {} and y as {}".format(self.x, self.y)
 

使用上面的類我們可以看到結果:

r = Represent(1, "Hopper")
print(r)  # prints __str__
print(r.__repr__)  # prints __repr__: '<bound method Represent.__repr__ of Represent(x=1,y="Hopper")>'
rep = r.__repr__()  # sets the execution of __repr__ to a new variable
print(rep)  # prints 'Represent(x=1,y="Hopper")'
r2 = eval(rep) # evaluates rep
print(r2)  # prints __str__ from new object
print(r2 == r)  # prints 'False' because they are different objects
 

用戶輸入

互動輸入

要從用戶那裡獲得輸入,請使用input 函數( 注意 :在Python 2.x中,該函數被稱為raw_input ,儘管Python 2.x有自己的input 版本完全不同):

Python 2.x 2.3
name = raw_input("What is your name? ")
# Out: What is your name? _
 

安全性備註不要在Python2中使用input() - 輸入的文本將被評估為Python表達式(相當於Python3中的eval(input()) ),這可能很容易成為漏洞。有關使用此功能的風險的詳細信息,請參閱此文章

Python 3.x 3.0
name = input("What is your name? ")
# Out: What is your name? _
 

本示例的其餘部分將使用Python 3語法。

該函數接受一個字符串參數,該參數將其顯示為提示並返回一個字符串。上面的代碼提供了一個提示,等待用戶輸入。

name = input("What is your name? ")
# Out: What is your name?
 

如果用戶鍵入“Bob”並按Enter鍵,變量name 將分配給字符串"Bob"

name = input("What is your name? ")
# Out: What is your name? Bob
print(name)
# Out: Bob
 

請注意, input 始終為str 類型,如果您希望用戶輸入數字,這很重要。因此,在嘗試將str 用作數字之前,需要轉換str

x = input("Write a number:")
# Out: Write a number: 10
x / 2
# Out: TypeError: unsupported operand type(s) for /: 'str' and 'int'
float(x) / 2
# Out: 5.0
 

注意:建議在處理用戶輸入時使用try / except捕獲異常 。例如,如果您的代碼想要將raw_input 轉換為int ,並且用戶寫入的內容是uncastable,則會引發ValueError

* args和** kwargs