【Python 学习手册笔记】介绍Python对象类型



在Python中，数据以对象的形式出现一一无论是Python提供的内置对象，还是使用Python或是像C扩展库这样的扩展语言工具创建的对象。对象无非是内存中的一部分，包含数值和相关操作的集合。
从更具体的视角来看. Python程序可以分解成模块、语句、表达式以及对象，如下所示：
1. 程序由模块构成。
2. 模块包含语句。
3. 语句包含表达式。
4. 表达式建立并处理对象。

为什么使用内置类型?
1、内置对象使程序更容易编写;
2、内置对象是扩展的组件;
3、内置对象往往比定制的数据结构更有效率;
4、内置对象是语言的标准的一部分。

Python 的核心数据类型
------------------------------------------------------------------------
表4-1 :内置对象       
对象类型                             例子常量/创建
数字                             1234, 3.1415, 3+4j, Decimal. Fraction
字符串                         'spam' , "guido's" ， b'a 飞xolc'
列表                              [1 , [2, 'three'] , 4]
字典                              {'food' :'spam' , 'taste' :'yum'}
元组                              (1, ' spam' , 4, 'U')
文件                              myfile=open('eggs ' ， γ)
集合                              set (' abc ' ) , {' a " 'b' , 'c'}
其他类型                      类型、None 、布尔型
编程单元类型               函数、模块、类(参见第四部分、第五部分和第六部分)
与实现相关的类型        编译的代码堆梭跟踪(参见第四部分和第七部分)
-------------------------------------------------------------------------
表4-1所列内容并不完整，因为在Python程序中处理的每样东西都是一种对象
Python 中没有类型声明，运行的表达式的语法决定了创建和使用的对象的类型。事实上，在Python语言中，诸如表4- 1 中的那些对象生成表达式就是这些类型起源的地方。

同等重要的是，一旦创建了一个对象，它就和操作集合绑定了一一只可以对字符串进行字符串相关的操作，对列表进行列表相关的操作。就像你将会学到的. Python是动态类型的(它自动地跟踪你的类型而不是要求声明代码) .但是它也是强类型语言(你只能对一个对象进行适合该类型的有效的操作)。

python 变量不需要提前声明。当给一个变量赋值的时候就创建了它，可能赋的是任何类型的对象，并且当变量出现在一个表达式中的时候，就会用其值替换它。在使用变量的值之前必须对其赋值。

一般来说，负的索引号会简单地与字符串的长度相加，因此，以下两个操作是等效的(尽管第一个要更容易编写并不容易发生错误):
>>>S[-1]           #Thelast itemin S
'm'
>>>S[len(S)-l]   # Negative indexing, thehard way
'm'

 

除了简单地从位置进行索引，序列也支持一种所谓分片(slice) 的操作；它们的一般形式为 X[I:J] ，表示"取出在X中从偏移量为I，直到但不包括偏移量为J的内容"。结果就是返回一个新的对象。在一个分片中，左边界默认为0，并且右边界默认为分片序列的长度。

 

注意加号( +)对于不同的对象有不同的意义:对于数字为加法，对于字符串为合并。这是Python的一 般特性，也就是我们将会在本书后面提到的多态。简而言之，一个操作的意义取决于被操作的对象。正如将在学习动态类型时看到的那样，这种多态的特性给Python代码带来了很大的简洁性和灵活性。由于类型并不受约束， Python 编写的操作通常可以自动地适用于不同类型的对象.只要它们支持一种兼容的接口(就像这里的+操作样)。这成为Python 中很重要的概念。

 

字符串在python 中具有不可变性一一在创建后不能就地改变;每个字符串都被定义为生成新的字符串作为其结果。

 

在Python 中的每一个对象都可以分为不可变性或者可变性。在核心类型中，数字、字符串和元组是不可变的；列表和字典不是这样(它们可以完全自由地改变)。在其他方面，这种不可变性可以用来保证在程序中保持一个对象固定不变。

 

一条简明的规则是这样的:可作用于多种类型的通用型操作都是以内置函数或表达式的形式出现的[例如，len(X) , X[0]，但是类型特定的操作是以方法调用的形式出现的[例如：aString.upper()]。

 

对于更多细节，你可以调用内置的dir函数，将会返一个列表，其中包含了对象的所有属性。由于方法是函数属性，它们也会
在这个列表中出现。假设S是一个字符串，这里是其在 Python 3.0 中的属性 (Python 2.6略有不同):
>>>dir(S)

一般来说，以双下划线开头并结尾的变量名是用来表示Python 的实现细节的命名模式。而这个列表中没有下划线的属性是字符串对象能够调用的方法。

 

dir 函数简单地给出了方法的名称。要查询它们是做什么的，你可以将其传递给 help函数。
>>>help(S.replace)

模式匹配
字符串对象的方法能够支持基于模式的文本处理。我们需要导入一个名为re的模块。这个模块
包含了类似搜索、分割和替换等调用，但是因为使用模式去定义子字符串，可以更通用一些.
>>> import re
>>> match = re.match('Hello[ \t]*(.*)world '，'Hello Pthon world')
>>> match.group(l)
' Python '
如果找到了这样的子字符串，与模式中括号包含的部分匹配的子字符串的对应部分保存为组.

列表
Python的列表对象是这个语言提供的最通用的序列。列表是一个任意类型的对象的位置相关的有序集合，它没有固定的大小。不像字符串， 其大小是可变的，通过对偏移量进行赋值以及其他各种列表的方法进行调用，确实能够修改列表的大小。

序列操作
由于列表是序列的一种，列表支持所有的我们对字符串所讨论过的序列操作。

因为列表是可变的，大多数列表的方法都会就地改变列表对象，而不是创建一个新的列表。

尽管列表没有固定的大小，Python仍不允许引用不存在的元素。超出列表末尾之外的索引总是会导致错误。

嵌套
Python核心数据类型的一个优秀的特性就是它们支持任意的嵌套。能够以任意的组合对其进行嵌套，并可以多个层次进行嵌套(例如，能够让一个列表包含一个字典，并在这个字典中包含另一个列表等)。这种特性的一个直接的应用就是实现矩阵，或者Python中的"多维数组"。

列表解析
处理序列的操作和列表的方法中，Python还包括了一个更高级的操作，称作列表解析表达式( list comprehension expression),列表解析源自集合的概念。它是一种通过对序列中的每一项运行一个表达式来创建一个新列表的方法，每次一个，从左至右。列表解析是编写在方括号中的(提醒你在创
建列表这个事实)。
内置函数map，产生对各项运行一个函数的结果；
在Python 3.0 中， 列表、集合和字典都可以用解析来创建。

字典
Python中的字典是完全不同的东西 :它们不是序列，而是一种映射(mapping)。映射是一个其他对象的集合，但是它们是通过键而不是相对位置来存
储的。实际上，映射并没有任何可靠的从左至右的顺序。它们简单地将键映射到值。字典是Python核心对象集合中的唯一的一种映射类型，也具有可变性——可以就地改变，并可以随需求增大或减小，就像列表那样。

作为常量编写时，字典编写在大括号中，并包含一系列的"键:值"对。

从技术来说， Pytbon具有一种叫做垃圾收集的特性，在程序运行时可以清理不再使用的内存，并将你从必须管理代码中这样的细节中解放出来。在Python中，一旦一个对象的最后一次引用被移除，空间将会立即回收。

in关系表达式允许我们查询字典中一个键是否存在，并可以通过使用Python的if语句对结果进行分支处理.

元组
元组对象(tuple ，发音为"toople" 或"tuhple" )基本上就像一个不可以改变的列表。就像列表一样，元组是序列，但是它具有不可变性，和字符串类似。从语怯上讲，它们编写在圆括号中而不是方括号中，它们支持任意类型、任意嵌套以及常见的序列操作。

元组提供了一种完整性的约束（不可变性），这对于比我们这里所编写的更大型的程序来说是方便的。

文件
文件对象是Python代码对电脑上外部文件的主要接口。虽然文件是核心类型，但是它有些特殊: 没有特定的常量语法能创建文件。要创建一个文件对象，需调用内置的open 函数以字符串的形式传递给它一个外部的文件名以及一个处理模式的字符息。
对脚本而言，文件的内容总是字符串，无论文件包含的数据是什么类型；
对于更高级的任务. Python还有额外的类文件工具: 管道、先进先出队列(FIFO)、套接字、通过键访问文件、对象持久、基于描述符的文件、关系数据库和面向对象数据库接口等。

内置函数type返回的类型对象是赋给该类型的另一个对象的一个对象，除了允许交互地探究对象.这个函数的实际应用是，允许编写代码来检查它所处理的对象的类型。

用户定义的类
用抽象的术语来说，类定义了新的对象类型，扩展了核心类型；就像函数那样去调用类，会生成我们新类型的实例，并且类的方法调用时，类的方法自动获取被处理的实例(其中的self参数)。
隐含的“self” 对象是我们把这叫做面向对象模型的原因，即一个类中的函数总有一个隐含的对象。一般来说，尽管这样，基于类的类型是建立在并使用了核心类型的。

Python脚本中能够处理的所有的事情都是某种类型的对象（在Python 中的每样东西都是一个"对象"）；

数字、字符串、罗IJ表、字典、元组、文件和集合一般被认为是核心对象(数据)类型。类型、None和布尔型有时也被定义在这样的分类中。还有多种数字类型(整数、浮点数、复数、分敬和十进制数) 和多种字符串类型；

"核心"类型是因为它们是Python语言自身的一部分，并且总是有效的，为了建立其他的对象，通常必须调用被导入模块的函数。大多数核心类型都有特定的语法去生成其对象:例如，'spam' 是一个创建字符串的表达式，而且决定了可以被应用的操作的集合。正是因为这一点，核心类型与Python的语法紧密地结合在一起。与之相比较，必须调用内置的open 函数去创建一个文件对象。

一个具有"不可变性"的对象是一个在其创建以后不能够被改变的对象。Python 中的数字、字符串和元组都属于这个分类。尽管无法就地改变一个不可变的对象，但是你总是可以通过运行一个表达式创建一个新的对象。

一个"序列"是一个对位置进行排序的对象的集合。字符串、列表和元组是Python中所有的序列。它们共同拥有一般的序列操作，例如，索引、合并以及分片，但又各自有自己的类型特定的方法调用。

术语"映射"，表示将键与相关值相互关联映射的对象。Python的字典是其核心类型集中唯一的映射类型。映射没有从左至右的位置顺序;它们支持通过键获取数据，并包含了类型特定的方法调用。

"多态"意味着一个操作符(如+)的意义取决于被操作的对象。这将变成使用好Python的关键思想之一(或许可以去掉之一吧) :不要把代码限制在特定的类型上，使代码自动适用于多种类型。