本节是第五讲的第二小节，上节为大家介绍了Python发展历程、安装、以及开发工具IDLE的使用等。本节将为大家介绍Python语言的特点，共有8大特点（要素），帮助大家快速了解Python语言，由于内容较多，分为上、下两部分展示。

数据类型（Data Types）#要素1

Python提供了几种内置的数据类型，现在我们只关注其中的两种。Python使用int类型表示整数（正整数或负整数），使用str类型表示字符串（Unicode字符序列）。python所能表示的整数大小只受限于机器内存，而非固定数量的字节数。字符串可以使用双引号或单引号封装——只要字符串头尾使用的符号是对称的。空字符串则只是使用引号， 中间没有任何内容，如下所示：

-973

210624583337114373395836055367340864637790190801098222508621955072#2²¹⁷

0

"Infinitely Demanding"

'Simon Critchley'

''

Python使用方括号（[]）来存取字符串等序列中的某一项，比如，在Python Shell 中（交互式的解释器，或IDLE）,有如下的输入和输出信息。

>>> "Hard Times"[5]

T

>>> "giraffe"[0]

'g'

传统上，Python Shell使用>>>作为其提示符，当然这并非一成不变。方括号存取 这种语法适用于任意数据类型（只要构成一个序列）的数据项，比如字符串或列表。需要注意的是，Python语法中，索引位置是从0开始计数的。

在Python中，str类型与基本的数值类型（比如int）都是固定的——也就是说， 一旦设定，其值就不能改变。虽然可以使用方括号取回字符串中某给定索引位置处的字符，但是不能将其设置为新字符（注意，在Python中，字符就是指长度为1的字符串）。

>>> int(“45”)

45

>>> str(912)

'912'

int()转换可以允许头尾处带有空格，因此，int(" 45 ")也是正确的。str()转换几乎可以应用于所有数据项。如果转换失败，就会给出异常信息。

对象引用（Object Refrence）#要素2

定义了数据类型之后，接下来要做的事情就是定义存储某种类型数据的变量，但 Python没有这样的变量，而是使用“对象引用”。对固定对象(比如int与str)而言， 变量与对象引用之间没有差别。对于可变对象，则存在差别，但是在实际工作中很少有影响。

x = "blue"

y = "green"

z = x

执行上面的第一条语句时，Python会创建一 个str对象，其文本内容为“blue”，同时还创建了一个名为x的对象引用，x引用的就是这个str对象。出于实用性的目的，我们可以说“变量x已经被分配了 'blue'这一 字符串”；第二条语句是类似的；第三条语句创建了一个名为z的新对象引用，并将其设置为对象引用x所指向的相同对象(这里是包含文本“blue”的str对象)。

在Python中， “=”的作用是将对象引用与内存中的某对象进行绑定。如果对象引用已经存在，就简单地进行重绑定，以便引用“=”操作右面的对象；如果对象引用尚未存在，就由 “=”操作符创建对象引用。

print(x, y, z) # prints: blue green blue

z = y

print(x, y, z) # prints: blue green green

x = z

print(x, y, z) # prints: green green green

在语句(x=z)执行之后，所有3个对象引用实际上引用的都是同一个str。由于不存在更多的对字符串"blue"的对象引用，因此Python可以对其进行垃圾收集处理。

用于对象引用的名称(称为“标识符”)有一些限制，尤其是不能与任何Python 关键字相同，并且必须以字母或下划线开头，其后跟随0个或多个非空格字符、下划 线或数字。标识符没有长度限制，字母与数字指的是Unicode编码中所定义的，也就 是说，包含但不仅仅限于ASCII编码定义的字母与数字(“a”、"b”、……、"z”、“A”、 “B”、……、"Z”、“0”、"1”、……、"9”)。此外，Python标识符是大小写敏感的，因此，LIMIT, Limit与limit是3个不同的标识符。

Python使用“动态类型”机制，也就是说，在任何时刻，只要需要，某个对象引用都可以重新引用一个不同的对象(可以是不同的数据类型)。这里我们创建了一个称为route的对象引用，并将其设置为引用一个新的int型数值866，之后，我们重用route这一对象引用，并用其引用一个新的str变量，值为“North", int对象将进入垃圾收集流程，这是因为没有对象引用再对其进行引用。type()函数会返回给定数据项的数据类型（也称为“类”）在测试与调试时， 这一功能是非常有用的。

route = 866

print(route, type(route)) # prints: 866 <class 'Int'>

route = "North"

print(route, type(route)) # prints: North <class 'str'>

组合数据类型（Collection Data Types）#要素3

Python提供了几种组合数据类型，包括关联数组(associative arrays)与集合(sets)等类型，这里我们只讨论其中的两种：元组(tuple)与列表(list)。Python 元组与列表可用于存储任意数量、任意类型的数据项。元组是固定的，创建之后就不能改变；列表是可变的，在需要的时候，可以插入或移除数据项。

>>> "Denmark","Finland", "Norway", "Sweden"

('Denmark', 'Finland', ’Norway‘ 'Sweden')

>>> "one",

('one',)

在输出元组时，Python使用圆括号将其封装在一起。很多程序员模仿这种机制， 总是将自己定义的元组常值包括在圆括号中。如果某个元组只有一个数据项，又需要使用圆括号，就仍然必须使用逗号，比如（1,）。空元组则使用空的()创建。逗号还可以用于在函数调用时分隔参数，因此，如果需要将元组常值作为参数传递，就必须使用括号对其进行封装，以免混淆。

[11,4, 9,16,25,36, 49]

['alpha', 'bravo', 'charlie1, 'delta', 'echo']

['zebra', 49, -879, 'aardvark', 200]

[]

列表可以使用方括号（[]）创建，就像上面这些实例，第四个实例展示的是一个空列表。后面我们会看到，还有其他一些创建列表的方法。

实质上，列表与元组并不真正存储数据项，而是存放对象引用。创建列表与元组时，实际上是使用其给定的对象引用的副本。在字面意义项（比如整数或字符串）的情况下，会在内存中创建适当数据类型的对象，而存放在列表或元组中的才是对象引用。

与Python中的其他内容一样，组合数据类型也是对象，因此，可以将某种组合数据类型嵌套在其他组合数据类型中，比如，创建一个列表，其中的每个元素也是列表, 不拘形式。列表、元组以及大多数Python的其他组合数据类型存储的是对象引用，而非对象本身。

一个常用的Python函数是len()函数，该函数以某个单独的数据项作为参数，并返回该数据项的“长度”(int类型)。

>>> len(('one',))

1

>>> len([3, 5, 1, 2, "pause", 5])

6

>>> len(“automatically")

13

所有Python数据项都是某种特定数据类型（也称之为“类”）的“对象”（也称之 为“实例”），我们将交替地使用术语“数据类型”与“类”。对象与有些其他语言（比 如，C++或Java的内置数值类型）提供的数据项的关键区别在于，对象可以有“方法”。 实质上，简单地说，方法就是某特定对象可以调用的函数。比如，数据类型list有一个append方法，借助于该方法，可以以如下方式添加对象：

>>> x = [“zebra”, 49, -879, “aardvark”, 200]

>>> x.append(“more”)

>>> x

['zebra', 49, -879, 'aardvark', 200, 'more']

>>> list.append(x, "extra")

>>> x

['zebra', 49, -879, 'aardvark', 200, 'more', 'extra']

我们指定了数据类型以及该数据类型的方法，并将要调用该方法的数据项本身作为第一个参数，其后跟随其他一些参数。(在涉及到继承时，两种语法存在微妙的语义差别，第一种形式在实际中应用的更加广泛。)

Python有一种常规的函数调用方式functionName(arguments)，方法调用方式objectName.methodName(arguments)。点（“存取属性"）操作符用于存取对象的某个属性。虽然到目前为止，我们展示的只有方法属性，但是属性可以是任意类型的对象。由于属性可以是对象，该对象包含某些属性，这些属性又可以包含其他属性，依此类推，因此，可以根据需要使用多级嵌套的点操作符来存取特定的属性。

list类型有很多其他方法，包括insert方法，该方法用于在某给定的索引位置插入数据项；remove方法，该方法用于移除某给定索引位置上的数据项。如前面所说的，Python索引总是以0开始。

>>> x[0]

'zebra'

>>> x[4]

200

>>> x[1] = "forty nine"

>>> x

['zebra', 'forty nine', -879, 'aardvark', 200, 'more', 'extra']

前面曾经提及，我们可以使用方括号操作符从字符串中获得某个字符，并且该操作符可用于任意序列。列表本身也是一种序列，元组也是一种序列，因此，如果x是一个元组，我们也可以以完全同样的方式使 用方括号取回项目，就像对x列表一样。但是，由于列表是可变的（不像字符串与元组是固定的），因此我们也可以使用方括号操作符来设置列表元素。

逻辑操作符（Logical Operations）#要素4

>>> a = ["Retention", 3, None]

>>> b = ["Retention", 3, None]

>>> a is b

False

>>> b = a

>>> a is b

True

由于所有的Python变量实际上都是对象引用，有时，询问两个或更多的对象引用是否都指向相同的对象是有意义的。身份操作符is是一个二元操作符，如果其左端的对象引用与右端的对象引用指向的是同一个对象，则会返回true。在前面的实例中,虽然a与b在最初设置为同样的列表值，但是列表本身是以单独的list对象存储的，因此，在第一次使用时，is操作符将返回false。

最常见的使用is的情况是将数据项与内置的空对象None进行比较，None通常用作位置标记值，指示“未知”或“不存在”。

>>> a = "Something"

>>> b = None

>>> a is not None, b is None

(True, True)

Python提供了二进制比较操作符的标准集合，每个操作符带有期待中的语义：< 表示小于，<=表示小于或等于，==表示等于。！=表示不等于，>=表示大于或等于，> 表示大于。这些操作符对对象值进行比较，也就是对象引用在比较中指向的具体对象。

>>> a = 2

>>> b = 6

>>> a == b

False

>>> a < b

True

>>> a <= b, a != b, a >= b, a > b

(True, True, False, False)

>>> a = "many paths"

>>> b = "many paths"

>>> a is b

False

>>> a ==b

True

从上面的实例可以看出，虽然a与b是不同的对象(有不同的身份)，但是具有相同的值，因此比较的结果是相等的。需要注意的是，因为Python使用Unicode编码表示字符串，与简单的ASCII字符串比较相比，对包含非ASCII字符的字符串进行比较可能更微妙、更复杂。

Python比较操作符的一个特别好用的特性是可以进行结链（chained）比较。对给定数据项取值在某个范围内的情况，这种测试方式提供了很多便利，不再需要使用逻辑运算符and进行两次单独的比较操作(大多数其他语言都需要如此)。这种方式的另一个附加的好处是只需要对数据项进行一次评估(因为数据项在表达式中只出现一次)，如果数据项值的计算需要耗费大量时间或存取数据项会带来一些副作用， 这种优势就会更加明显。

>>> a = 9

>>> 0 <= a <= 10

True

>>> "three"<4

Traceback (most recent call last):

File "<pyshell#42>", line 1, in <module>

"three"<4

TypeError: '<' not supported between instances of 'str' and 'int'

归功于Python动态类型机制的“强大”，进行无意义的比较会导致异常，出现异常而又未得到处理时，Python会输出该异常错误消息的回溯与追踪信息。

对序列(sequences)或集合(collections)这一类数据类型，比如字符串、列表或元组，我们可以使用操作符 in来测试成员关系，用not in来测试非成员关系。

>>> P = (4, "frog", 9, -33, 9, 2)

>>> 2 in p

True

>>> "dog" not in p

True

>>>phrase = "Wild Swans by Jung Chang"

>>> ”J" in phrase

True

>>> “han" in phrase

True

对列表与元组，in操作符使用线性搜索，对非常大的组合类型(包含数万个或更多的数据项），速度可能会较慢；而对字典或集合，in操作可以非常快。对字符串数据类型，使用成员运算符可以很方便地测试任意长度的子字符串。

Python提供了 3个逻辑运算符：and、or与not。and与or都使用short-circuit逻 辑，并返回决定结果的操作数——而不是返回布尔值（除非实际上就是布尔操作数）。如果逻辑表达式本身出现在布尔上下文中，那么结果也为布尔值，因此，前面的表达式结果将变为True、True与False,比如，if语句。

>>> five = 5

>>> two = 2

>>> zero = 0

>>> five and two

2

>>> two and five

5

>>> five and zero

0

>>> nought = 0

>>> five or two

5

>>> two or five

2

>>> zero or five

5

>>> zero or nought

0

or操作符是类似的，这里，在布尔上下文中，结果应该为True. True. True与False。 not单一操作符在布尔上下文中评估其参数，并总是返回布尔型结果，对前面的实例，not(zero or nought)的结果为 True, not two 的结果为 False。

以上内容部分摘自视频课程05后端编程Python-2快速了解(上)，更多实操示例请参照视频讲解。跟着张员外讲编程，学习更轻松，不花钱还能学习真本领。