python类型

python数字


在python中数据采用了对象的形式
编写的所有python程序的基础就是对象
在基本类型中,Python提供了常用 的数字类型:支持整数,浮点数,以及相与之相关的语法和操作,


str和repr显示格式
    这两个函数都会把任意对象变换成它们的字符串表达:
    repr(也就是默认的交互模式回显)产生的结果看起来就像是它们是代码.
    str(也就是打印语句)变换得到一种对用户更加友好的格式.


动态类型


python缓存了不变的对象并对其进行复用.


每个对象都有两个标准的头部信息:一个类型标志符去标示这个对象的类型, 以及一个引用计数器, 用来决定是不是可以回收这个对象. 


类型属于对象, 而不是变量.
    在python中变量名没有类型. 
    python中的类型是与对象相关联的.


对象的垃圾收集
    在内部, python是通过保持用每个对象中的计数器记录引用指到这个对象上的次数的.一旦(并精确在同一时间)这个计数器被设置为零, 这个对象的内存空间就会自动回收.


共享引用
    >>> a = 3
    >>> b = a
    >>> a, b
    (3, 3)
    >>> a = 2
    >>> a , b
    (2, 3)
    从上结果中可以看到第二行python创建了变量b, 使用的是变量a, a 和b 都引用了相同的对象3, 这在python中称作是共享变量.
    当变量a 引用到对象2时, b 并没有随着a 而改变引用a
    在python中, 变量总是一个指向对象的指针, 而不是可改变的内在区域的标签: 给一变量赋一个新的值, 并不是替换了原始的对象, 而是让这个变量去引用完全不同的一个对象.
    
字符串
    严格来说, python的字符串被划分为不可变序列类别, 意味着这些字符串所包含的字符存在从左至右的位置顺序, 并且他们不可以在原处修改. 它是序列的代表.


>>> s = 'abcdef'
>>> s[::-2]
'fdb' 
>>> chr(65), ord('A')
('A', 65)
>>> 'That is %d %s bird!' % (1, 'dead')
'That is 1 dead bird!'
字符串格式化
    python在对字符串操作时定义了%二进制操作符,
    %操作符左侧放置一个需要进行格式化的字符串,其中嵌入多个以%开头的转换目标.
    %操作符的右侧旋转一个对象(或多个,在括号内)


基于字典的字符串格式化
>>> "%(n)d %(x)s" % {"n": 1, "x": "spam"}
'1 spam'
格式化字符串里(n) 和(x) 引用了右边字典中的键, 并提取他们相应的值.生成类似HTML或XML的程序往往利用这一技术.


>>> line = 'aaa bbb ccc'
>>> line.split()
['aaa', 'bbb', 'ccc']
如果没有给出分隔符，默认使用空格。


字符串是不可变的序列
Python中有三个类型
数字 : 支持加法和乘法
序列 : 支持索引,分片和合并
映射 : 支持通过键的索引
如果一个对象是不可变的,你就不能在原处修改它的值.
不可变类型有某种完整性,保证这个对象不被程序的其他部分改变.




列表与字典
    它们都可以在原处进行修改,也可以按需求增长或缩短, 而且可以包含任何各类的对象或者被嵌套.
    列表是python中最具灵活的有序集合对象 类型.它可以包含任何类型的对象.
>>> str([1, 2]) + '34'
'[1, 2]34'
>>> [1, 2] + list('34')
[1, 2, '3', '4']
    尽管列表的'+'操作符和字符串中的一样,然而值得重视的是'+'两边必须是相同类型的序列,否则运行时会出现类型错误.
    对列表进行分片时往往返回一个新的列表.
>>> l = ['spam', 'Spam', "SPAM!"]
>>> l[1] = 'eggs'
>>> l
['spam', 'eggs', 'SPAM!']
>>> l[0: 2] = ['eat', 'more'] #给切片赋值
>>> l
['eat', 'more', 'SPAM!']
    上面的l[0: 2] = ['eat', 'more']分片赋值可以分成两步来理解
    1. 删除,删除等号左边指定的分片
    2. 插入.将包含在等号右边对象中的片段插入旧分片被删除的位置.


字典
    如果把列看作是有序的对象集合,那么就可以把字典当成是无序的集合.不同的是字典当中的元素是通过键来存取的.而不是通过偏移存取.
    从本质上讲:字典是作为哈希表(支持快速检索的数据结构)来实现 的,一开始很小,并根据要求而增长.此外,python采用最优化的哈希算法来寻找 键,因此搜索是很快速的.


    字典的不同构造:
>>> keyslist = ['a','b']
>>> valslist = ['A', 'B']
>>> dict(zip(keyslist, valslist))
{'a': 'A', 'b': 'B'}
>>> dict([('name', 'mel'), ('age', 45)])
{'age': 45, 'name': 'mel'}
>>> dict(name='bob', age=43)
{'age': 43, 'name': 'bob'}
>>> dict.fromkeys(['a', 'b'])
{'a': None, 'b': None}
>>> {'spam': 2, 'ham': 1, 'eggs': 3}
{'eggs': 3, 'ham': 1, 'spam': 2}
>>> d = {'spam': 2, 'age': 32}
>>> d.get('sppm')
>>> 
键不存在时通过get方法能够返回默认值None或者用户定义的默认值,这是当键不存在时为了避免missing-key错误而填入默认值的一个简单方法
遍历: 
for key in dicts.keys():
    print(key, '\t', dicts[key])


元组，文件及其他
    元组与列表类似，只不过元组不能在原处修改(它们是不可变的).
    虽然元组不支持任何方法调用,但元组具有列表的大多数属性.
1 任意对象的有序集合.元组是一个有序的对象的集合.
  2 通过偏移存取. 同字符串,列表一样元组通过偏移来访问,
               支持所有的基于偏移的操作.
3 属于不可变序列类型, 元组是不可变的.是序列,不能在原处修改
4 固定长度,异构,任意嵌套. 元组可以包含其他的复合对象,
                 例如,列表字典和其他元组,因此支持嵌套.
5 对象引用的数组 元组最好被认为是对象引用的数组.
        对元组进行索引操作的速度相对较快.
    元组没有方法,然而,元组支持字符串和列表的一般序列操作.
    由于 圆括号也可以把表达式括起来,如果确实想得到一个元组,只要在这一单个元素之后,关闭圆括号之前加一个逗号就可以.
>>> x = (40)
>>> x
40
>>> y = (40,)
>>> y
(40,)
    如果想对元组进行排序,通常先得将它转换为列表才能获得使用排序方法调用权限,并将其变为一个可变对象.
>>> t = ('cc', 'aa', 'dd', 'bb')
>>> tmp = list(t)
>>> tmp.sort()
>>> tmp
['aa', 'bb', 'cc', 'dd']
>>> t = tuple(tmp)
>>> t
('aa', 'bb', 'cc', 'dd')
    列表解析也可用于元组的转换,它其实是序列的操作,它们总会创建新的列表.
    列表解析也可以用于遍历包括元组,字符串以及其他列表在内的任何序列对象
>>> t = (1, 2, 3, 4, 5)
>>> l = [x+20 for x in t]  #将元组中每个元素都加上20,并转换成列表l
>>> l
[21, 22, 23, 24, 25] 
    元组的不可变性只适用于元组本身顶层而并非其内容.
>>> t = (1, [2, 3], 4)
>>> t[1] = 'spam'
Traceback (most recent call last):
>>> t[1][0] = 'spam'
>>> t
(1, ['spam', 3], 4)
    一般把元组看作是简单对象组合,把列表看成是随时间改变的数据结构.
    然而,最佳解释似乎是元组的不可变性提供了某种完整性.


文件


>>> x , y, z = 41, 42, 43
>>> s = 'spam'
>>> d = {'a': 1, 'b': 2}
>>> l = [1, 2, 3]
>>> 
>>> f = open('c:\\datafile.txt', 'w')
>>> f.write(s + '\n')
>>> f.write('%s,%s,%s\n' % (x, y, z))
>>> f.write(str(l) + '$' + str(d) + '\n')
>>> f.close()
spam
41,42,43
[1, 2, 3]${'a': 1, 'b': 2}


>>> f = open('c:\\datafile.txt')
>>> line = f.readline()
>>> line
'spam\n'
>>> line = f.readline()
>>> line
'41,42,43\n'
>>> parts = line.split(',')
>>> parts
['41', '42', '43\n']
>>> int(parts[1])
42
>>> numbers = [int(p) for p in parts]
>>> numbers
[41, 42, 43]
>>> line = f.readline()
>>> line
"[1, 2, 3]${'a': 1, 'b': 2}\n"
>>> parts = line.split('$')
>>> parts
['[1, 2, 3]', "{'a': 1, 'b': 2}\n"]
>>> eval(parts[0]) #使用eval执行转换字符串为其表示的对象。
[1, 2, 3]
>>> objects = [eval(p) for p in parts]
>>> objects
[[1, 2, 3], {'a': 1, 'b': 2}]


eval可以把字符串转换成对象。
pickle模块是能够让我们直接在谁的中存储几乎任何python对象的高级工具。
也并不要求我们把字符串转来转去。
>>> d
{'a': 1, 'b': 2}
>>> f = open('c:\\datafile.txt', 'w')
>>> import pickle
>>> pickle.dump(d, f)
>>> f.close()
>>> 
>>> f = open('c:\\datafile.txt')
>>> e = pickle.load(f)
>>> e
{'a': 1, 'b': 2}
>>> open('c:\\datafile.txt').read()
"(dp0\nS'a'\np1\nI1\nsS'b'\np2\nI2\ns."
文件中打包二进制数据的存储和解析
>>> f = open('data.bin', 'wb')
>>> import struct
>>> bytes = struct.pack('>i4sh', 7, 'spam', 8)
>>> bytes
'\x00\x00\x00\x07spam\x00\x08'
#python生成一个我们通常写入文件的二进制数据字符串（主要由不可打印的字符组成，这些字符以十六进制转义的格式进行打印)
>>> f.write(bytes) 
>>> f.close()
>>> f = open('data.bin', 'rb')
#二进制文件处理模式'wb'和'rb'可用于处理更简单的二进制文件。例如，图片或音频文件是不需要解压他的内容的。
>>> data = f.read()
>>> data
'\x00\x00\x00\x07spam\x00\x08'
>>> values = struct.unpack('>i4sh', data) #解析炎普通python对象。
>>> values
(7, 'spam', 8)
对于文件更高级的还有一些方法，例如：
seek函数能够复位你在文件中的当前位置(下次读写将应用在该位置上），
flush能够强制性地将缓存输出写入磁盘(文件总会默认进行缓存)


总结：
对象类型 分类 是否可变
数字 数值 否
字符串 序列 否
列表 序列 是
字典 对应 是
元组 序列 否
文件 扩展 N/A


对象灵活性(复杂对象类型)
    因为python的复合对象类型支持任意结构.只要能够满足创建待处理数据 的模型的需要,嵌套多少层都是可以的.
    
引用与拷贝
    赋值操作总是储存对象的引用,而不是这些对象的拷贝.
>>>l[:]
>>>d.copy()
   注意:无条件值的分片以及字典copy方法只能做顶层复制.
        以上不能复制嵌套的数据结构,如果需要一个深层嵌套数据结构的完整的完全独立的拷贝,就要使用标准的copy模块,
>>>import copy
>>>x=copy.deepcopy(y)
比较,相等性和真值
    python的比较总是检查复合对象的所有部分,直到可以得出结果为止.
>>> L1 = [1, ('a', 3)]
>>> L2 = [1, ('a', 3)]
>>> L1 == L2, L1 is L2  
(True, False)
"=="操作符测试值的相等性,python运行相等测试,递归地比较所有内嵌对象.
"is"表达式测试对象的一致性, python测试二者是否是同一个对象(也就是说,在同一内存地址中)
一个有意思的测试,
>>> s1 = 'spam'
>>> s2 = 'spam'
>>> s1 == s2, s1 is s2
(True, True)
>>> s1 = 'a longer string'
>>> s2 = 'a longer string'
>>> s1 == s2, s1 is s2
(True, False)
这是因为在python内部暂时储存并重复使用短字符串作为最佳化,事实上内存里只有一个字符串'spam'供s1和s2分享


python中真和假
    整数0代表假, 整数1代表真
    python也把任意的空数据结构视为假, 把任意非空数据结构视为真.
    python还有一个特殊对象None 总是认为是假.
    None是python中和种特殊数据类型的唯一值, 一般都起到一个空的点位作用,与c语言的NULL指针类似.
    python中布尔类型bool,只是扩展了python中的真假的概念, 显示为True和False,当明确地用在真值测试时,True和False这些字就变成了真和假,因为它们的确只是整数1和整数0的定制版


本而已. 


在python中任何对象的类型都是类型为type的对象 .
即使是类型本身在python中也是对象类型--调用内置函数type(x)能够返回对象x的类型对象.


在python2.2后每个核心类型都有个新的内置名来支持面向对象子类的类型定制:
dict, list, str, tuple, int, long, float, complex, unicode, type, file(file是open的同义词)
用isinstance函数进行类型测试.
>>> isinstance([1],list)
True
>>> isinstance([1], tuple)
False
>>> type([1]) == list
True
>>> type([1])== type([])
True


Python中的其他类型
除了以上的核心对象之外,典型python的安装还有几十种其他可用的对象 类型,
允许作为C语言的扩展程序或是Python的类:
正则表达式对象, DBM文件, GUI组件, 网络套接字.