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