python中字符串常量可以用任意多个引号_Python对象类型

Python程序能够分解为模块、语句、表达式以及对象，以下所示：html

程序由模块构成python

模块包含语句git

语句包含表达式程序员

表达式创建并出口对象算法

1、Python类型的介绍：数据库

1.1 为何使用内置类型编程

Python提供了强大的对象类型做为语言的组成部分，事实上，除非有内置类型没法提供的特殊对象要处理，最好老是使用内置对象而不是使用本身的实现。下面是其缘由：api

内置对象使程序更容易编写：数组

对于简单的任务，内置类型每每可以表现问题领域的全部结构。例如，集合(列表)和搜索表(字典)能够立刻使用它们，仅使用python内置对象类型就能完成不少工做。网络

内置对象使扩展的组建：

对于较为复杂的任务，或许仍须要提供本身的对象，使用python的类或C语言的结构。例如，堆栈数据结构也许会实现为管理和定制内置列表的类。

内置对象每每比定制的数据结构更有效率：

在速度方面，python内置类型优化了用C实现数据结构算法。尽管能够实现属于本身的相似的数据类型，但每每很难达到内置数据类型所提供的性能水平。

内置对象是语言的标准的一部分：

python不但借鉴了依靠内置工具的语言(例如LISP)，并且吸收了那些依靠程序员去提供本身实现的工具或框架的语言(例如C++)的优势。尽管在Python中能够实现独一无二的对象类型，但在开始阶段并无必要这样作。此外，由于Python的内置工具是标准的，他们通常都是一致的。

1.2 Python的核心数据类型

python的内置对象类型和一些编写其常量(literal)所使用到的语法，也就是可以生成这些对象的表达式。

内置对象：

数字、字符串、列表、字典、元组、文件、集合、其余类型、编程单元类型、与实现相关的类型

上面所列内容并不完整，由于在python程序中处理的每样东西都是一种对象。例如，在python中进行文本模式匹配时，建立了模式对象，还有进行网络脚本编程时，使用了套接字对象，它们由def、class、import和lamba这样的语句和表达式建立，而且能够在脚本间自由地传递，存储在其余对象中等。

1.3数字

python的核心对象集合包括常规的类型：整数、浮点数以及更为少见的类型(有虚部的复数、固定精度的十进制数、带分子和分母的有理分数以及集合等)。

python的基本数字类型仍是至关基本的。python中数字支持通常的数学运算。其中**表示乘方。

>>> 12+33

45

>>> 1.5*4

6.0

>>> 2 ** 100

1267650600228229401496703205376

#注意这里的最后一个记过：当须要的时候，python 3.0的整数类型会自动提供额外的精度，以用于较大的数值。

1.4 字符串

就像任意字符的集合同样，字符串是用来记录文本信息的。从严格意义上来讲，字符串是单个字符的字符串的序列，其余类型的序列还包括列表和元组。

做为序列，字符串支持假设其中各个元素包含位置顺序的操做。例如，若是咱们有四个字符的字符串，咱们经过内置的len函数验证其长度并索引操做获得其各个元素。

>>> S = 'Spam'

>>>len(S)4

>>>S[0]'S'

>>> S[1]'p'

在Python中，索引是按照最前面的偏移量进行编码的，也就是从0开始，第一项索引为0，第二项索引为1，以此类推。

>>> S[-1]'m'

>>> S[-2]'a'

>>>

#在Python中，咱们可以反向索引，从最后一个开始(反向索引是从左边开始计算，反向索引是从右边开始计算)

>>> S[len(S)-1]'m'

#通常来讲，负的索引号会简单地与字符串的长度相加，所以，上面操做和S[-1]是等效的。

>>> S[1:3]'pa'

#除了简单的从位置进行索引，序列也支持一种所谓分片(slice)的操做，这是一种一步就可以提取整个分片(splice)的方法。

>>> S[1:]'pam'

>>> S[0:3]'Spa'

>>> S[:3]'Spa'

>>> S[:-1]'Spa'

>>>S[:]'Spam'

#在一个分片中，左边界默认为0，而且右边界默认为分片序列的长度。

>>> S+'xyz'

'Spamxyz'

>>> S*8

'SpamSpamSpamSpamSpamSpamSpamSpam'

#做为一个序列，字符串也支持使用加号进行合并(将两个字符串合成为一个新的字符串)，或者重复(经过再重复一次建立一个新的字符串)。

#注意加号(+)对于不一样的对象有不一样的意义：对于数字为加法，对于字符串为合并。这是Python的通常特性，也就是咱们将会在本书后面提到的多态。简而言之，一个操做的意义取决于被操做的对象。Python编写的操做一般自动地适用于不一样类型的对象。

#同时字符串还具备不可变性。如上面的例子

>>> S.find('pa')1

>>> S.find('pd')-1

>>> S.replace('pa','XYZ')'SXYZm'

>>>S'Spam'

#字符串的find方法是一个基本的字符串查找的操做(它将返回一个传入字符串的偏移量，或者没有找到的状况下返回-1)，而字符串的replace方法将会对全局进行搜索和替换。

#尽管这些字符串方法的命名有改变的含义，但在这里咱们都不会改变原始的字符串，而是会建立一个新的字符串做为结果------由于字符串具备不可变性。

>>> line='aaa,bbb,ccccc,dd'

>>> line.split(',')#以逗号为分隔符对字符串进行切片

['aaa', 'bbb', 'ccccc', 'dd']>>> S='spam'

>>>S.upper()#将小写转换成大写'SPAM'

>>>S.isalpha()#检测是不是字母组成，布尔值，不是的话返回false。

True>>> line='aaa,bbb,ccccc,dd\n'

>>> line=line.rstrip()#去掉两边的空格>>>line'aaa,bbb,ccccc,dd'

#还能实现经过分隔符将字符串拆分为子字符串(做为一种解析的简单形式)，大小写变换，测试字符串的内容(数字、字母或其余)，去掉字符串后的空格字符。

>>> 'name:%s,age:%s' %('chaishao','27')#这种就相似于位置参数，按位置将值传给前面的%s'name:chaishao,age:27'

>>> 'chaishao:{1},age:{0}'.format(27,'chaishao')#这种仍是定义位置，前面{1}和{0}表示要第二个位置的值和第一个位置的值'chaishao:chaishao,age:27'

>>> 'chaishao:{name},age:{age}'.format(name='chaishao',age=27)#这种就是前面定义变量，后面给变量赋值'chaishao:chaishao,age:27'

#字符串还支持一个叫作格式化的高级替代操做，能够以一个表达式的形式和一个字符串方法调用。如上面的例子.

>>>dir(S)

['__add__', '__class__', '__contains__', '__delattr__', '__dir__', '__doc__', '__eq__', '__format__', '__ge__', '__getattribute__', '__getitem__', '__getnewargs__', '__gt__', '__hash__', '__init__', '__iter__', '_

_le__','__len__','__lt__','__mod__','__mul__','__ne__','__new__','__reduce__','__reduce_ex__','__repr__','__rmod__','__rmul__','__setattr__','__sizeof__','__str__','__subclasshook__','capitalize','casefold', 'center', 'count', 'encode', 'endswith', 'expandtabs', 'find', 'format', 'format_map', 'index', 'isalnum', 'isalpha', 'isdecimal', 'isdigit', 'isidentifier', 'islower', 'isnumeric', 'isprintable', 'iss

pace','istitle','isupper','join','ljust','lower','lstrip','maketrans','partition','replace','rfind','rindex','rjust','rpartition','rsplit','rstrip','split','splitlines','startswith','strip','sw

apcase','title','translate','upper','zfill']

#对于更多的细节，能够经过调用内置的dir函数，将会返回一个列表，其中包含了对象的全部属性。因为方法是函数属性，他们也会在这个列表中出现。上面那些变量名中有下划线的内容，它们表明了字符串对象的实现方式，并支持定制。通常来讲，以双下划线开头并结尾的变量名是用来表示Python实现细节的命名模式。而这个列表中没有下划线的属性是字符串对象可以调用的方法。

>>>help(S.replace)

Help on built-infunction replace:

replace(...) method of builtins.str instance

S.replace(old, new[, count])->str

Return a copy of S with all occurrences of substring

old replaced by new. If the optional argument countisgiven, only the first count occurrences are replaced.

#dir函数简单地给出了方法的名称。要查询它们是作什么的，能够将其传递给help函数。就像PyDoc同样(一个从对象中提取文档的工具)，help是一个随Python一块儿分发的面向系统代码的接口。

>>>help(S)

No Python documentation foundfor 'spam'.

Use help() to get the interactive help utility.

Use help(str)for help on the str class.>>>help(str)#能够查看str的全部help帮助说明

Help onclass str in module builtins:

#如上面能够直接查看全部的帮助说明就像查看man帮助同样，不过通常仍是针对某个特定的方法进行查看。

>>> S='A\nB\tC'

>>>len(S)#查看字符串的长度5

>>> ord('\n')#ord() 函数是 chr() 函数(对于8位的ASCII字符串)或 unichr() 函数(对于Unicode对象)的配对函数，它以一个字符(长度为1的字符串)做为参数，返回对应的 ASCII 数值，或者 Unicode 数值，若是所给的 Unicode 字符超出了你的 Python 定义范围，则会引起一个 TypeError 的异常。10

>>> S='A\0B\0C'

>>>len(S)5

#上面的反斜线转义序列表示特殊的字符。

>>> msg="""abc

... def'''ABC""BCD'HAHA"""

>>>msg'abc\ndef\'\'\'ABC""BCD\'HAHA'

>>> print(msg)

abcdef'''ABC""BCD'HAHA

#Python容许字符串包括在单引号或双引号中(他们表明着相同的东西)。它也容许在三个引号(单引号或双引号)中包括多行字符串常量。当采用这种形式的时候，全部的行都合并在一块儿，并在每一行的末尾增长换行符。在Python脚本中嵌入像HTML或XML这样的内容时，是很方便的。

1.5 列表

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

>>> L=[123,'spam',1.23]>>>len(L)3

>>>L[0]#查看列表的索引，下标从0开始。123

>>> L[:-1]#也能够对列表进行分片，这里就是[0:2]

[123, 'spam']>>> L + [4,5,6]#两个列表能够合并

[123, 'spam', 1.23, 4, 5, 6]>>>L

[123, 'spam', 1.23]

#因为列表是序列的一种，列表支持全部的咱们队字符串所讨论过得序列操做。惟一的区别就是其结果每每是列表而不是字符串。

#列表和其余语言中的数组有些相似，可是列表要强大不少，其中一点就是列表没有固定类型的约束。例如，上面的列表就包含了三个彻底不一样类型的对象(一个整数、一个字符串、以及一个浮点数)。此外，列表没有固定大小，也就是说可以按照须要增长或减小列表大小，来响应其特定的操做。

>>> L.append('NI') #在列表尾部添加一个NI

>>>L

[123, 'spam', 1.23, 'NI']>>> L.pop(2) #删除索引2也就是从左往右第三个元素

1.23

>>>L

[123, 'spam', 'NI']

>>> L.insert(1,'haha') #在索引1的位置插入haha对象

>>> L

[123, 'haha', 'spam', 'NI']

>>> L.remove(123) #删除123

>>> L

['haha', 'spam', 'NI']

#列表的append方法扩充了列表的大小并在列表的尾部插入一项；pop方法(或者等效的del语句)移除给定偏移量的一项，从而让列表减少。其余的列表方法能够在任意位置插入(insert)元素，按照值移除(remove)元素等。由于列表是可变的，大多数列表的方法都会就地改变列表对象，而不是建立一个新的列表。

>>> list1=['bb','aa','cc']>>> list1.sort() #对列表进行排序默认是按照升序排序>>>list1

['aa', 'bb', 'cc']>>>list1.reverse()#对列表进行翻转>>>list1

['cc', 'bb', 'aa']

#列表sort方法是对列表排序的意思，这些方法都会直接对列表进行改变。

>>> list1[1] #查找list1列表偏移量是1也就是第二个元素

'bb'

>>> list1[3] #超出边界直接会报错

Traceback (most recent call last):

File"", line 1, in IndexError: list index out of range

>>> list1[1]='BB' #对列表第二个元素从新赋值

>>> list1[3]='CC' #超出列表末尾范围以外赋值会报错

Traceback (most recent call last):

File "", line 1, in

IndexError: list assignment index out of range

>>> list1

['cc', 'BB', 'aa']

#尽管列表没有固定的大小，Python扔不容许引用不存在的元素。超出列表末尾以外的索引老是会致使错误，对列表末尾范围以外赋值也是如此。这是有意而为之的，因为去给一个列表边界外的元素赋值，每每会获得一个错误(而在C语言中状况比较糟糕，由于它不会像Python这样进行错误检查)。在Python中，并非默默的增大列表做为响应，而是会提示错误。为了让一个列表增大，能够调用相似于append这样的列表方法。

>>> M=[[1,2,3],[4,5,6],[7,8,9]]>>>M

[[1, 2, 3], [4, 5, 6], [7, 8, 9]]

>>> M[1] #获取第二个元素的值

[4, 5, 6]

>>> M[1][2] #获取第二个元素里面嵌套的列表的第三个元素的值

6

#Python核心数据类型的一个优秀的特性就是他们支持任意的嵌套。可以以任意的组合对其进行嵌套，并能够多个层次进行嵌套(例如，可以让一个列表包含一个字典，并在这个字典中包含另外一个列表等)。这种特性的一个直接的应用就是实现矩阵，或者Python中的“多维数组”，一个嵌套列表的列表就能完成这个基本的操做。上面咱们编写了一个包含3个其余列表的列表。其效果就是表现了一个3*3的数字矩阵。

>>> col2 = [row for row in M] #for row in M是一个for循环，那么row久表明了M里面的三个元素，因此col2的值就是M的值

>>>col2

[[1, 2, 3], [4, 5, 6], [7, 8, 9]]>>> col2=[row[1] for row in M] #这里row[1]就至关于取M[1]>>>col2

[2, 5, 8]

#列表解析，处理序列的操做和列表的方法中,Python还包括了一个更高级的操做，成为列表解析表达式，从而提供了一个处理像矩阵这样结构的强大工具。列表解析源自集合的概念。它是一种经过对序列中的每一项运行一个表达式来建立一个新列表的方法，每次一个，从左至右。列表解析是编写在方括号中的，而且由使用了同一个变量名的(这里是row)表达式和循环结构组成。上面的这个列表解析表达基本上就是它字面上所讲的，把矩阵M的每一个row中的row[1]放到一个新的列表中。

>>>col2

[2, 5, 8]>>> [row[1]+1 for row in M] #把它搜集到的每个元素都加1[3, 6, 9]>>> [row[1] for row in M if row[1] % 2 == 0] #使用if条件语句，经过使用%求余表达式(取余数)过滤告终果中的奇数。[2, 8]

>>> M

[[1, 2, 3], [4, 5, 6], [7, 8, 9]]

>>> diag = [M[i][i] for i in [0,1,2]] #M[i][i]就至关于M[0][0],M[1][1],M[2][2]

>>> diag

[1, 5, 9]

>>> doubles = [c*2 for c in 'spam'] #取出来的值*2

>>> doubles

['ss', 'pp', 'aa', 'mm']

>>> G = (sum(row) for row in M) #让row求和，由于是for循环嘛，这里的意思就至关于让M[0],M[1],M[2]分别求和

>>> next(G) #next() 返回迭代器的下一个项目

6

>>> next(G)

15

>>> next(G)

24

>>> list(map(sum,M)) #内置map能够作上面相似的事情，产生对各项运行一个函数的结果，在Python 3.0中，将其包装到列表中，会使其返回全部值。

[6, 15, 24]

>>> {sum(row) for row in M} #能够用解析语法来建立一个集合

{24, 6, 15}

>>> {i : sum(M[i]) for i in range(len(M))} #能够用解析语法来建立一个字典

{0: 6, 1: 15, 2: 24}

#实际应用中的列表解析能够更复杂，如上面。列表解析建立了新的列表做为结果，可是可以在任何可迭代的对象上进行迭代。

#列表解析以及相关的内容函数map和filter比较复杂，这里记录一下先。实际上，在python 3.0中，列表、集合和字典均可以用解析来建立。

1.6 字典

Python中的字典是彻底不一样的东西：它们不是序列，而是一种映射(mapping)。映射是一个其余对象的集合，可是它们是经过键而不是相对位置来存储的。实际上，映射并无任何可靠的从左至右的顺序。它们简单地将键映射到值。字典是Python核心对象集合中的惟一的一种映射类型，也具备可变性------能够就地改变，并能够随需求增大或减少、就像列表那样。

>>> D={'food':'Spam','quantity':4,'color':'pink'}#定义一个字典D>>> D['food']#字典food键的值'Spam'

>>> D['quantity'] += 1#字典quantity的值加1

>>>D

{'color': 'pink', 'food': 'Spam', 'quantity': 5}

#上面是映射操做，做为常量编写时候，字典编写在大括号中，并包含一系列的“键：值”对。在咱们须要将键与一系列值相关联(例如，为了表述某物的某属性)的时候，字典是颇有用的。上面的例子是一个包含了三个元素的字典(键分别为“food”、“quantity”和“color”)。经过键对字典进行索引来读取或改变键所关联的值。字典的索引操做使用的是和序列相同的语法，可是在方括号中的元素是键，而不是相对位置。上面就是使用大括号这种常量形式。

>>> D={}#先定义一个空字典>>> D['name']='chaishao'#经过给这种定义键值对的形式直接给字典赋值

>>> D['job']='dev'

>>> D['age']=27

>>>D

{'age': 27, 'name': 'chaishao', 'job': 'dev'}>>> print(D['name'])

chaishao

#上面就是一种建立空字典，而后每次以一个键来填写它的方式。与列表中禁止边界外的赋值不一样，对一个新的字典的键赋值会建立该键。

#上面最后一个例子，实际是使用字典的键来搜索对应的值，在别的应用中，字典能够用来执行搜索，经过键索引一个字典每每是Python中编写搜索的最快方法。

>>> rec = {'name':{'first':'chai','last':'shao'},#记录了姓和名，这就属于字典嵌套字典

... 'job':['dev','mgr'],#记录了职位和角色，这就是嵌套了列表

... 'age':27}

>>> rec

{'age': 27, 'name': {'last': 'shao', 'first': 'chai'}, 'job': ['dev', 'mgr']}

>>> rec['name'] #查找字典rec关于name键的值

{'last': 'shao', 'first': 'chai'}

>>> rec['name']['last'] #查找字典rec关于name键中的last键的值

'shao'

>>> rec['job']

['dev', 'mgr']

>>> rec['job'][-1]#查找rec字典中job键中列表最后一个元素的值

'mgr'

>>> rec['job'].append('CTO') #给rec字典中的job键中的列表加入一个CTO的值

>>> rec

{'age': 27, 'name': {'last': 'shao', 'first': 'chai'}, 'job': ['dev', 'mgr', 'CTO']}

#上面在顶层使用了三个键的字典(键分别是“name”、“job”和“age”)，可是值的状况变得复杂得多：一个嵌套的字典做为name的值，支持了多个部分，并用一个嵌套的列表做为job的值从而支持多个角色和将来的扩展。可以获取这个结构的组件，就像以前在矩阵中所做的那样，可是此次索引的是字典的键，而不是列表的偏移量。

#注意这里的最后一个操做是如何扩展嵌入job列表的。由于job列表是字典所包含的一部分独立的内存，它能够自由的增长和减小。

>>> rec=0>>>rec

0

#在Python中，当最后一次引用对象后(例如，将这个变量用其余的值进行赋值)，这个对象所占用的内存空间将会自动清理掉，相似于上面那种。从技术上来讲，Python具备一种叫作垃圾收集的特性，在程序运行时能够清理再也不使用的内存，并将你从必须管理代码中这样的细节中解放出来。在Python中，一旦一个对象的最后一次引用被移除，空间将会当即回收。

>>> D = {'a':1,'d':2,'c':3}>>> Ks = list(D.keys()) #将字典D的键作成列表赋值给Ks>>> Ks

['a', 'd', 'c']>>> Ks.sort() #进行一下排序>>>Ks

['a', 'c', 'd']>>> D = {'a':1,'c':2,'b':3}>>> D ##字典不是序列，它们并不包含任何可靠的从左至右的顺序，这意味着若是咱们创建一个字典，并将它打印出来，它的键也许会以与咱们输入时不一样的顺序出现。{'a': 1, 'b': 3, 'c': 2}

>>> Ks = list(D.keys())

>>> Ks.sort()>>> for key in Ks: #写个for循环... print(key,'=>',D[key]) #循环打印key的名称和D字典里key的值... #按一次回车是继续写，咱们要出结果因此须要按两次回车a => 1b=> 3c=> 2

#上面的例子若是一个字典的元素中，须要强调键的某种顺序的话，经常使用的解决办法就是经过字典的keys方法收集一个键的列表，而后使用列表的sort方法进行排序，而后使用Python的for循环逐个进行显示结果。

>>> for key insorted(D):

...print(key,'=>',D[key])#注意这里，要按个空格再打print啊，否则按回车要报错的。

...

a=> 1c=> 3d=> 2

#经过使用最新的sorted内置函数就能够一步完成上面对key的排序。sorted调用返回结果并对各类对象类型进行排序，上面的例子就是自动对字典的键排序。

>>> squares = [x ** 2 for x in [1,2,3,4,5]]>>>squares

[1, 4, 9, 16, 25]>>> squares1=[]>>> for x in [1,2,3,4,5]:#编写了一个等效的for循环，经过在运行时手动增长列表来建立最终的列表。

... squares1.append(x** 2)

...>>>squares

[1, 4, 9, 16, 25]

#迭代和优化，for循环是真正经过的迭代工具。事实上，它们都可以工做于遵照迭代协议(这是Python中无处不在的一个概念，表示在内存中物理存储的序列，或一个在迭代操做状况下每次产生一个元素的概念，表示在内存中物理存储的序列，或一个在迭代操做状况下每次产生一个元素的对象)的任意对象。若是一个对象在响应next以前先用一个对象对iter内置函数作出响应，那么它属于后一种状况。咱们在前面所见到生成器解析表达式就是这样的一个对象。

#从左到右扫描一个对象的每一个Python工具都使用迭代协议。这就是上上个例子介绍的sorted调用直接工做于字典之上，咱们没必要调用keys方法来获得一个序列，由于字典是可迭代的对象，能够用一个next返回后续的键。这也就一意味着像上面任何列表解析表达式均可以计算一列数字的平方。

#尽管这样，列表解析和相关的函数编程工具，如map和filter，一般运行得比for循环快：这是对有大数据集合的程序有重大影响的特性之一。在Python中性能测试是一个很难应付的任务，由于它在反复地优化。

#Python中的一个主要原则就是，首先为了简单和可读性去编写代码，在程序能够工做，并证实了确实有必要考虑性能后，再考虑该问题。更多的状况是代码自己就已经足够快了。若是确实须要提升代码的性能，那么Python提供了帮助你实现的工具，包括time以及timeit模块和profile模块。

>>>D

{'a': 1, 'd': 2, 'c': 3}>>> D['e'] = 99 #虽然可以经过给新的键值来扩展字典>>>D

{'a': 1, 'e': 99, 'd': 2, 'c': 3}>>> D['f'] #可是获取一个不存在的键值仍然是一个错误Traceback (most recent call last):

File"", line 1, in KeyError:'f'

>>> 'f' in D #编写程序时并非老是知道当前存在什么键，能够经过in关系表达式，来查询字典中的一个键是否存在。False>>> if not 'f' in D: #也能够经过使用Python的If语句对结果进行分支处理... print('missing')

...

missing

>>> value = D.get('x',0) #这是另一种方法，若是获取键失败就给赋值0

>>> value

0

>>> value = D['f'] if 'f' in D else 0 #这是跟if结合，若是f键存在就将f的值赋给value，不然赋值0

>>> value

0

#默认状况下，if语句也能够有else分句，以及一个或多个elif(else if)分句进行其余的测试。它是Python主要的选择工具，而且是脚本中编写逻辑的方法。

1.7 元组

元组对象(tuple)基本上就像一个不能够改变的列表。就像列表同样，元组是序列，可是它具备不可变性，和字符串相似。从语法上讲，它们编写在圆括号中而不是方括号中，它们支持任意类型、任意嵌套以及常见的序列操做。

>>> T = (1,2,3,4) #定义一个元组>>>len(T)4

>>> T + (5,6) #两个元组合并(1, 2, 3, 4, 5, 6)>>> T[1] #查找元组偏移量是1的也就是第二个元素2

>>> T.index(4) #查找元素4所在的索引位置3

>>> T.count(4) #查找4这个元素在元组中出现的次数1

>>> T[0] = 2 #元组是不可变的，若是想改变元组的值直接就报错了Traceback (most recent call last):

File"", line 1, in TypeError:'tuple' object does not support item assignment

#上面就是元组的经常使用操做以及不可变的演示。

>>> T = ('spam',3.0,[1,2,3]) #元组也支持混合的类型和嵌套

>>> T[1] #查找偏移量是1的值3.0

>>> T[2][2] #查找偏移2也就是最后的列表中的第三个元素3

>>> T.append(4) #元素不能增加或缩短，由于它们是不可变的Traceback (most recent call last):

File"", line 1, in AttributeError:'tuple' object has no attribute 'append'

#为何要用元组呢，它的关键是不可变性。若是在程序中以列表的形式传递一个对象的集合，它可能在任何地方改变；若是使用元组的话，则不能。

1.8 文件

文件对象是Python代码对电脑上外部文件的主要接口。虽然文件是核心类型，可是它有些特殊：没有特定的常量语法建立文件。要建立一个文件对象，需调用内置的open函数以字符串的形式传递给它一个外部的文件名以及一个处理模式的字符串。

>>> f = open('data.txt','w') #以写的方式打开文件>>> f.write('Hello\n') #写入Hello并换行6

>>> f.write('world\n') #写入world并换行6

>>> f.close() #关闭文件，就会把写的内容写入到文件

#例如上面，建立一个文本输出文件，能够传递其文件名以及‘w’处理模式字符串以写数据，这样就在当前文件夹下建立了一个文件，并向它写入文本(文件名能够是完整的路径)。

>>> f=open('data.txt')>>> text =f.read()>>>text'HelloHello\nworld\n'

>>> print(text)

HelloHello

world>>>text.split()

['HelloHello', 'world']

#上面的例子是打开文件，默认就是r类型，而后将文件的内容读至一个字符串，并显示它。对脚本而言，文件的内容老是字符串，不管文件包含的数据是什么类型。

#文化提供了多种读和写的方法(read能够接受一个字节大小的选项，readline每次读一行等)，以及其余的工具(seek移动到一个新的文件位置)。读取一个文件的最佳方式就是根本不读它，文件提供了一个迭代器(iterator)，它在for循环或其余环境中自动地一行一行地读取。

#其余文件类工具：open函数可以实如今Python中编写的绝大多数文件处理。尽管这样，对于更高级的任务，Python还有额外的类文件工具：管道、先进先出队列(FIFO)、套接字、经过键访问文件、对象持久、基于描述符的文件、关系数据库和面向对象数据库接口等。例如，描述符文件(descriptor file)支持文件锁定和其余的底层工具，而套接字提供网络和进程间通讯的接口。

1.9 其余核心类型

集合，它不是映射也不是序列，相反，它是惟一的不可变的对象的无序集合。集合能够经过调用内置set函数而建立，或者使用Python 3.0中新的集合常量和表达式建立，而且它支持通常的数学集合操做。

http://www.cnblogs.com/chaishao/p/5759436.html  #开头部分对集合的介绍和文件的介绍。

2、数字

2.1 数字类型介绍

Python的数字类型是至关典型的，在Python中，数字并非一个真正的对象类型，而是一组相似类型的分类。Python不只支持一般的数字类型(整数和浮点数)，并且可以经过常量直接建立数字以及处理数字的表达式。此外，Python为更高级的工做提供了不少高级数字编程支持和对象。Python数字类型的完整工具包括：

整形和浮点数、复数、固定精度的十进制数、有理分数、集合、布尔类型、无穷的整数精度、各类数字内置函数和模块。

数字常量:在基本类型中，Python提供了：整数(正整数和负整数)和浮点数(带小数部分的数字)。Python还容许咱们使用十六进制、八进制常量来表示整数，提供一个复数类型，而且容许整数具备无穷的精度(只要内存空间容许，它能够增加成任意位数的数字)。下面展现了Python数字类型在程序中的显示方式(做为常量)：

#通常来讲，Python的数字类型是很容易使用的，除了内置数字常量以外，Python还提供了一系列处理数字对象的工具：

表达式操做符：+、-、*、\、>>、**、&等

内置数学函数：pow、abs、round、int、hex、bin等

公用模块：random、math等

2.2 Python表达式操做符

表达式式处理数字的最基本的工具。当一个数字(或其余对象)与操做符想结合时，Python执行时将计算获得一个值。在Python中，表达式式使用一般的数学符号和操做符号写出来的。除了经常使用的是加减乘数，%是计算余数操做符、<

Python表达式操做符及程序：

下面是Python2.6和Python3中操做符的版本差别和最新添加：

1. 在python 2.6版中，值不相等能够写成X ！= Y或X <> Y.在python 3.0之中，后者会被移除，由于它是多余的。值不相等测试使用X != Y就好了。

2. 在Python 2.6中，一个后引号表达式‘X’和repr(X)的做用相同，转换对象以显示字符串。因为其很差理解，Python 3.0删除了这个表达式，使用更容易理解的str和repr内置函数。

3. 在Python 2.6和Python 3.0中，floor除法表达式(X // Y)老是会把余数小数部分去掉。在Python 3.0中，X / Y表达式执行真正的除法(保留余数)和Python 2.6中的传统除法(截除为整数)。

4. 列表语法([...])用于表示列表常量或列表解析表达式。后者是执行隐形循环，把表达式的结果收集到新的列表中。

5. (...)语法用于表示云组和表达式，以及生成器表达式，后者是产生所需结果的列表解析的一种形式，而不是构建一个最终的列表。

6. {...}语法表示字典常量，而且在Python 3.0中能够表示集合常量以及字典和集合解析。

7. yield和三元选择表达式和Python 2.5及其之后的版本中可用。前者返回生成器中的send(...)参数，后者是一个多行if语句的缩写形式。若是yield不是单独地位于一条赋值语句的右边的话，须要用圆括号。

8. 比较操做符能够连续使用：X

9. 在最近的Python中，分片表达式X[I:J:K]等同于同一个分片对象索引：X[slice(I,J,K)]。

10. 在Python 3.0中，对字典的大小比较也再也不支持(尽管支持相等性测试);比较sorted(dict.items())是一种可能的替代。

2.3 十六进制、八进制和二进制记数

Python证书可以以十六进制、八进制和二进制记数法来编写，做为通常的以10位基数的十进制记数法的补充。这些常量只是指定一个整数对象的值的一种替代方法，例如，Python 3.0和Python 2.6中的以下常量编码会产生具备3种进制的指定值的常规整数：

>>>0o1,0o20,0o377 #八进制

(1, 16, 255)>>> 0x01,0x10,0xFF #十六进制

(1, 16, 255)>>>0b1,0b100000,0b111111111 #二进制

(1, 32, 511)>>>0b1,0b10000,0b111111111

(1, 16, 511) #都表示十进制的数

>>> oct(255),hex(255),bin(255) #将十进制数字转变成对应的进制数

('0o377', '0xff', '0b11111111')

>>> int('255'),int('377',8),int('ff',16),int('11111111',2)

(255, 255, 255, 255)

>>> int('255'),int('0o377',8),int('0xff',16),int('0b11111111',2)

(255, 255, 255, 255)

#oct函数会将十进制数转换为八进制数，hex函数会将十进制转换为十六进制数、而bin会将十进制数转换为二进制。另外一种方式，内置的Int函数会将一个数字的字符串变换为一个整数，并能够经过定义的第二个参数来肯定变换后的数字的进制。

2.4 位操做

除了通常的数学运算(加法、减法等)，Python也支持C语言中大多数数学表达式。这包括哪些把整数当作二进制位串对待的操做。

>>> x = 1 #换算成二进制这就至关于0001>>> x << 2 #二进制逢2进位，0001左移动两位，变成了0100，就表示十进制的4了4

>>> x | 2 #这是二进制的或运算，前面的是0001后面的是0010，因此就是0001|0010=0011，换算成十进制就是3了3

>>> x & 1 #这个就是与的关系，就是0001&0001=0001，也就是11

>>> x & 2 #这个就是0001&0010=0000，也就是0

0

#像上面这样按位进行掩码的运算，使咱们能够对一个整数进行多个标志位和值进行编码。在这个领域里，Python 2.6 和Python 3.0中都支持的二进制和十六进制变得特别有用，它们容许咱们按照位字符串来编写和查看数字。若是Python代码必须与由C程序生成的网络包或封装了的二进制数打交道的话，它是很实用的。尽管这样，注意位操做在Python这样的高级语言中并不像在C这样的底层语言中那么重要。

2.5 其余的内置数学工具

除了核心对象类型之外，Python还支持用于数字处理的内置函数和内置模块。例如，内置函数pow和abs，分别计算幂和绝对值，这里有一些内置match模块(包含在C语言中math库中的绝大多数工具)的例子并有一些实际中的内置函数。

>>> importmath>>>math.pi,math.e

(3.141592653589793, 2.718281828459045)>>> math.sin(2 * math.pi / 180)0.03489949670250097

>>> math.sqrt(144),math.sqrt(2)

(12.0, 1.4142135623730951)>>> pow(2,4),2 ** 4(16, 16)>>> abs(-42.0),sum((1,2,3,4))

(42.0, 10)>>> min(3,1,2,4),max(3,1,2,4)

(1, 4)

>>> math.floor(2.567),math.floor(-2.567)

(2, -3)

>>> math.trunc(2.567),math.trunc(-2.567)

(2, -2)

>>> int(2.567),int(-2.567)

(2, -2)

>>> round(2.567),round(2.467),round(2.567,2)

(3, 2, 2.57)

>>> (1/3),round(1/3),('%.2f'%(1/3))

(0.3333333333333333, 0, '0.33')

>>> (1/3),round(1/3,2),('%.2f'%(1/3))

(0.3333333333333333, 0.33, '0.33')

>>> '%.1f' % 2.567, '{0:.2f}'.format(2.567)

('2.6', '2.57')

#这里展现的的sum函数做用于数字的一个序列，min和max函数接受一个参数序列或者单个的参数。有各类各样的方法能够删除一个浮点数的小数位。

#上线也介绍了截断和floor方法，也能够用round，无论是为了求值仍是为了显示。

#最后一个例子产生了咱们一般会打印出的字符串，而且它支持各类格式化选项。

>>> importmath>>> math.sqrt(144)12.0

>>> 144 ** .5

12.0

>>> pow(144, .5)12.0

>>> math.sqrt(1234567890)35136.41828644462

>>> 1234567890 ** .5

35136.41828644462

>>> pow(1234567890, .5)35136.41828644462

#在Python中有3种方法能够计算平方根：使用一个模块函数、一个表达式或者一个内置函数。注意内置math这样的模块必须先导入，可是abs这样的内置函数不须要导入就能够直接使用，换句话说，模块是外部的组件，而内置函数位于一个隐性的命名空间内，Python自动搜索程序的变量名。这个命名空间对应于Python 3.0中名为builtins的模块。

>>> importrandom>>>random.random() #选出一个0到1之间的任意浮点数0.7293494111854583

>>>random.random()0.7408299666488919

>>> random.randint(1,10) #选出1到10之间的随机整数6

>>> random.randint(11,100)37

>>> random.choice(['A','B','C']) #在一个序列中任意挑选一项'A'

>>> random.choice(['A','B','C'])'C'

#通常模块都是导入才能使用的，上面使用标准库中的random模块时必须导入。

2.6 其余数字类型

Python的核心数字类型：整数、浮点数和复数。对于绝大多数程序员来讲，须要进行的绝大多数数字处理都知足了。不过，Python还自带了一些更少见的数字类型。

小数数字：

比其余数据类型复杂一些，小数是经过一个导入的模块调用函数后建立的，而不是经过运行常量表达式建立的。从功能上来讲，小数对象就像浮点数，只不过它们由固定的位数和小数点，所以小数是有固定的精度的浮点值。例如，使用小数对象，咱们可以使用一个只保留两位小数位精度的浮点数。此外，可以定义如何省略和截断额外的小数数字，尽管它对日常的浮点数类型来讲带来了微小的性能损失，小数类型对表现固定精度的特性(例如，钱的总和)以及实现更好的数字精度是一个理想的工具。

>>> 0.1 + 0.1 + 0.1 - 0.3 #得出来的非0确实一个浮点数

5.551115123125783e-17

>>> print(0.1 + 0.1 + 0.1 - 0.3)5.551115123125783e-17

>>> from decimal importDecimal>>> Decimal('0.1') + Decimal('0.1') + Decimal('0.1') - Decimal('0.3')

Decimal('0.0')

#从上面的例子能够看出，浮点数缺少精确性，由于用来存储数值的空间有限。结果接近0可是却没有足够的位数去实现这样的精度。正如上面显示的，可以经过调用在decimal模块中的Decimal的构造函数建立一个小数对象，并传入一个字符串，这个字符串有咱们但愿在结果中显示的小数位数。当不一样的精度的小数在表达式中混编时，python自动升级为小数位数最多的。

>>> importdecimal>>> decimal.Decimal(1) / decimal.Decimal(7)

Decimal('0.1428571428571428571428571429')>>> decimal.getcontext().prec=4 #设置输出为小数点后4位

>>> decimal.Decimal(1) / decimal.Decimal(7)

Decimal('0.1429')>>> 1999 + 1.33

2000.33

>>> decimal.getcontext().prec=2

>>> pay = decimal.Decimal(str(1999 + 1.33))>>>pay

Decimal('2000.33')

#能够设置全局精度，decimal模块中的其余工具能够用来设置全部小数数值的精度、设置错误处理等。例如，这个模块中的一个上下文对象容许指定精度(小数位数)和舍入模式(舍去、进位等)。该精度全局性地适用于调用线程中建立的全部小数。

另外还有分数，能够用Fraction模块。

2.7 集合

Python 2.4引入了一种新的类型--集合(set)，这是一些惟一的、不可变的对象的一个无序集合(collection)，这些对象支持与数学集合理论相应的操做。根据定义，一个项在集合中只能出现一次，无论将它添加了多少次。一样，集合有着普遍的应用，尤为是在涉及数字和数据库的工做中。

由于它是其余对象的集合，所以，它具备列表和字典这样的对象的某些共同行为。例如集合是能够迭代的，能够根据须要增加或缩短，而且可以包含各类对象类型。将会看到，一个集合的行为很像一个无值的字典的键，可是，它还支持额外的操做。

然而因为集合是无序的，而且不会把键匹配到值，他们既不是序列也不是映射类型；它们是自成一体的类型。

>>> x = set('abcde') #经过用set的方式来建立集合

>>> y = set('bdxyz')>>> type(x) #能够查看一下x的类型

>>> x #输出一下能够看出集合是无序的{'a', 'd', 'e', 'c', 'b'}>>> 'e' in x #若是e在集合x中就为真True>>> x - y #求差集，在x中但没有在y中的元素{'a', 'c', 'e'}>>> x | y #x和y的并集{'a', 'b', 'd', 'c', 'e', 'x', 'z', 'y'}>>> x & y #x和y的交集{'d', 'b'}>>> x ^ y #对称差集，项目出如今x或者y中，可是不会同时出如今二者之中{'a', 'c', 'e', 'x', 'z', 'y'}>>> x > y, x < y #测试y中的元素是否都在x中，或者x的元素都在y中(False, False)

>>> x=set('abcd')

>>> y=set('abc')

>>> x > y, x < y

(True, False)

#集合经过表达式操做符支持通常的数学集合运算。注意，不能再通常序列上应用这些表达式，必须经过序列建立集合后才能使用这些工具。

>>> z = x.intersection(y) #返回一个新的集合，包含x和y中的公有的元素>>>z

{'a', 'c', 'b'}>>> z.add('SPAM') #将SPAM添加到z集合中>>>z

{'a', 'SPAM', 'c', 'b'}

>>> z.update(set(['X','Y'])) #在z集合中添加一个集合，不加set也能够里面添加列表什么的，也就是添加多个元素>>>z

{'a', 'X', 'SPAM', 'Y', 'c', 'b'}>>> z.remove('b') #删除z集合中的b元素

#除了表达式，集合对象还提供了对应这些操做的方法，以及更多的支持改变集合的方法，集合add方法插入一个项目、update是按位置求并集，remove根据值删除一个项目(在任何集合实例或集合类型名上运行dir来查看全部可用的方法)。

>>> for item in set('abc'): print(item *3) #支持for循环...

aaa

ccc

bbb>>> S = set([1,2,3])

>>> S | set([3,4])

{1, 2, 3, 4}>>> S | [3,4] #集合和列表是不能进行上面的那些差集之类的Traceback (most recent call last):

File"", line 1, in TypeError: unsupported operand type(s)for |: 'set' and 'list'

>>> S.union([3,4]) #返回一个新的集合，返回S和【3,4】中的相同元素之外的全部元素{1, 2, 3, 4}>>> S.intersection((1,3,5)) #这就是求S和(1,3,5)的交集{1, 3}>>> S.issubset(range(-5,5)) #判断S中的每个元素是否都在(-5,5)中True

#上面的例子能够看出，做为可迭代的容器，集合也能够用于len、for循环和列表解析这样的操做中。然而，因为它们都是无序的，因此不支持像索引和分片这样的操做，尽管上上面介绍的集合表达式一般须要两个集合，可是上面的例子能够看出，他们基于方法的对应形式每每对任何可迭代类型也有效。

#我这里用的是Python 3.0，能够看出集合输出的是一个字典的花括号的形式，这个语法是有意义的，由于集合基本上就像是无值的字典，集合的项是无序的、惟一的、不可改变的，所以，他们的行为和字典的键很像。因为字典键列表在Python 3.0中是视图对象，它支持像交集和并集这样的相似集合的行为这种类似性更加惊人。

#注意，在Python中{}仍然是一个字典。空的集合必须经过内置函数set来建立。

#不可变限制和冻结集合。集合是强大而灵活的对象，可是，它们只能包含不可变(便可散列)对象类型。所以，列表和字典不能嵌入到集合中，可是，若是须要存储复合值的话，元组是能够嵌入的。例如，集合中的元组能够用来表示日期、记录、IP地址等。集合自己也是不可改变的，所以，不能直接嵌入到其余集合中；若是须要在另外一个集合中存储一个集合，能够像调用set同样来调用frozenset，可是，它建立一个不可变的集合，该集合不可修改而且能够嵌套到其余集合中。

#为何使用集合？集合操做有各类各样常见的用途，其中一些比数字更加实用。例如，因为项在集合中只能存储一次，集合(set)能够用来把重复项从其余集合(collection)中过滤掉。直接把集合(collection)转换为一个集合(set)，而后再转换回来便可(由于集合是可迭代的，这里的list调用对其有效)：以下面的例子

>>> L = [1,2,1,3,2,4,5]>>>set(L)

{1, 2, 3, 4, 5}>>> L =list(set(L))>>>L

[1, 2, 3, 4, 5]>>>type(L)

#当遍历图形或其余的回环结构的时候，集合能够用来记录已经访问过的位置。当传递性模块重载和继承树列表程序实例，必须确保访问过的项再也不循环。尽管把访问状态做为键记录到字典中很搞笑，但集合提供了几乎等同的一种替代方式。

#最后在处理较大的数据集合的时候(例如，数据库查询结果)，两个集合的交集包含了两个领域中共有的对象，并集包含了两个集合中的全部项目。

2.8 布尔型

对于Python的布尔类型有一些争论，bool本来是一个数字，由于它有两个值True和False，不过是整数1和0以不一样的形式显示后的定制版本而已。

Python现在正式地有了一种明确的布尔型数据类型，叫作bool，其值为True和False，而且其值True和False是预先定义的内置的变量名。在内部在新的变量名True和False是bool的实例，实际上仅仅是内置的整数类型int的子类(以面向对象的观点来看)。True和False的行为和整数1和0是同样的，除了它们有特定的显示逻辑：它们是做为关键字True和False显示的，而不是数字1和0(从技术上来说，bool为它的两个对象从新定义了str和repr的字符串格式)。

因为这个定制，布尔表达式和交互提示模式的输出就做为关键字True和False来显示，而不是曾经的1和0.此外，布尔型让真值更精确。例如，一个无限循环如今可以编写成while True:而不是while 1:。相似地，经过使用flag = False，能够更清楚地设置标志位。

还有对于其余实际的用途，你可以将True和False看作是预约义的设置为整数1和0的变量。大多数程序员都曾把True和False预先赋值为1和0：由于True仅仅是定制了显示格式的整数1，在Python中True+4获得了5！

>>>type(True)

>>>isinstance(True,int)

True>>> True == 1True>>> True is 1False>>> True orFalse

True>>> True + 4

5

#上面的例子就是对上面介绍的一种展现.

3、动态类型

3.1 变量、对象和引用

当在Python中运行赋值语句a = 3时就属于：

变量建立：一个变量(也就是变量名)，就像a，当代码第一次给它赋值时就建立了它。以后的赋值将会改变已建立的变量名的值。

变量类型：变量永远不会有任何的和它有关联的类型信息或约束。类型的概念是存在对象中而不是变量名中，变量本来是通用的，它只是在一个特定的时间点，简单的引用一个特定的对象而已。

变量使用：当变量出如今表达式中时，它会立刻被当前引用的对象所代替，不管这个对象是什么错误。此外，全部的变量必须在使用前明确地赋值，使用未赋值的变量会产生错误。

总而言之，变量在赋值的时候才建立，它能够引用任何类型的对象，而且必须在引用以前赋值。

在Python中，每当一个变量名被赋予了一个新的对象，以前的那个对象站应用的空间就会被回收(若是它没有被其余的变量名或对象所引用的话)。这种自动回收对象的空间的技术叫作垃圾收集。

在内部，Python它在每一个对象中保持了一个计数器，计数器记录了当前指向该对象的引用数目。一旦(并精确在同一时间)这个计数器被设置为零，这个对象的内存空间就会自动回收。在前面的介绍中，假设每次x都被赋值给一个新的对象，而前一个对象的引用计数器为零，就会致使它的空间被回收。

3.2 共享引用

在交互模式下，引入另外一个变量，并看一下变量名和对象的变化：

>>> a = 3

>>> b =a>>>b3

#像上面那样，实际的效果是变量a和b都引用了相同的对象(也就是说指向了相同的内存空间)。这在Python中叫作共享引用--多个变量名引用了同一个对象。

>>> a = 3

>>> b =a>>> a = 'spam'

>>>b3

#从上面的例子能够看出，虽然a指向了新的对象，可是b仍是使用原来的变量也就是使用原来的内存空间。要想b跟着变化还得再来下b=a。

>>> L1 = [2,3,4]>>> L2 =L1>>> L1[0] = 24

>>>L1

[24, 3, 4]>>>L2

[24, 3, 4]

#上面的例子是共享引用和在原处修改的例子，上面的例子，没有改变L1，改变了L1所引用的对象的一个元素。这类修改会覆盖列表对象中的某部分。由于这个列表对象是与其余对象共享的(被其余对象引用)，那么一个像这样在原处的改变不只仅会对L1有影响。也就是说，必须意识到当作了这样的修改，它会影响程序的其余部分。这里也对L2产生影响，由于它与L1都引用了相同的对象。另外，咱们实际上并无改变L2，可是它的值将发生变化，由于它已经被修改了。

>>> L1 = [2,3,4]>>> L2 =L1[:]>>> L1[0] = 24

>>>L1

[24, 3, 4]>>>L2

[2, 3, 4]

#若是不想L1变化了L2也要跟着变化，须要Python拷贝对象，而不是建立引用。有不少种拷贝一个列表的办法，包括内置列表函数以及标准库的copy模块。上面的方式是一种从头至尾的分片方法。这里L1的修改不会影响L2，由于L2引用的是L1所引用对象的一个拷贝。也就是说，两个变量指向了不一样的内存区域。

#注意这种分片技术不会应用在其余的可变的核心类型(字典和集合，由于它们不是序列)上，复制一个字典或集合应该使用X.copy()方法调用。并且，注意标准库中的copy模块有一个通用的复制任意对象类型的调用，也有一个拷贝嵌套对象结构(例如，嵌套了一个列表的字典)的调用：

>>> L1=[1,2,3]>>> importcopy>>> X = copy.copy(L1) #浅copy

>>> X = copy.deepcopy(L1) #深copy