Python的数据类型

一、基本数据类型

1数字

整形int

    Python中的整数属于int类型，默认用十进制表示，此外也支持二进制，八进制,十六进制表示方式，默认还是十进制。进制转换bin()十进制转二进制；oct()十进制转8进制；hex()十进制转16进制。

>>> bin(10)
'0b1010'
>>> oct(10)
'0o12'
>>> hex(10)
'0xa'

长整型long

    python3中长整型与整形int已经完全结合，在python2中（python3中没有长整形的概念）

>>> num=2L
>>> type(num)
<type 'long'>

浮点型float

    Python的浮点数就是数学中的小数，整数与浮点数运算的结果也是一个浮点数。

浮点数也就是小数，之所以称为浮点数，是因为按照科学记数法表示时， 一个浮点数的小数点位置是可变的，比如， 1.23*109和12.3*108是相等的。 浮点数可以用数学写法，如1.23，3.14，-9.01，等等。但是对于很大或很小的浮点数，就必须用科学计数法表示，把10用e替代： 1.23*109就是1.23e9，或者12.3e8，0.000012可以写成1.2e-5，等等。 整数和浮点数在计算机内部存储的方式是不同的，整数运算永远是精确的而浮点数运算则可能会有四舍五入的误差

    Python默认的是17位精度,也就是小数点后16位，尽管有16位，但是这个精确度却是越往后越不准的。首先，这个问题不是只存在在python中，其他语言也有同样的问题。其次，小数不精准是因为在转换成二进制的过程中会出现无限循环的情况，在约省的时候就会出现偏差。

    当我们的计算需要使用更高的精度（超过16位小数）的时候，可以借助decimal模块的方法来处理。

>>> a = 3.141592653513651054608317828332
>>> a
3.141592653513651
>>> from decimal import *
>>> getcontext()
Context(prec=50, rounding=ROUND_HALF_EVEN, Emin=-999999, Emax=999999, capitals=1, clamp=0, flags=[FloatOperation], traps=[InvalidOperation, DivisionByZero, Overflow])
>>> getcontext().prec = 50
>>> a = Decimal(1)／Decimal(3)#注，在分数计算中结果正确，如果直接定义超长精度小数会不准确
>>> a
Decimal('0.33333333333333333333333333333333333333333333333333')

>>> a = '3.141592653513651054608317828332'
>>> Decimal(a)
Decimal('3.141592653513651054608317828332')

#不推荐：字符串格式化方式，可以显示，但是计算和直接定义都不准确，后面的数字没有意义。
>>> a = ("%.30f" % (1.0/3))  
>>> a  
'0.333333333333333314829616256247'

2布尔类型

bool型只有两个值：True和False
也可以将bool值归类为数字，是因为我们也习惯用1表示True，0表示False。

>>> True + True
2
>>> True + False
1
>>> False == 0
True
>>> False + 0
0

3字符串

    字符串是一个有序的字符的集合，用于存储和表示基本的文本信息，' '或'' ''或''' '''中间包含的内容称之为字符串。如：name = 'tom'、name = "tom"、name = """tom"""。

特性

    1.按照从左到右的顺序定义字符集合，下标从0开始顺序访问，有序

    2.字符串的单引号和双引号都无法取消特殊字符的含义，如果想让引号内所有字符均取消特殊意义，在引号前面加r，如name＝r'l\thf'

    3.unicode字符串与r连用必需在r前面，如name＝ur'l\thf'

优先掌握的操作

1、按索引取值(正向取+反向取) ：只能取 2、切片(顾头不顾尾，步长) 3、长度len 4、成员运算in和not in 5、移除空白strip 6、切分split 7、循环

常用方法

strip,lstrip,rstrip	默认去掉左右的空格，可根据参数[chars]来定制，如strip('*'):删除左右的*号
lower,upper	字符串转大写或者小写
startswith,endswith	以什么字符串开始或者结尾
format的三种玩法	用于格式化
split,rsplit	split是左分割，rsplit是右分割，默认以空格来分。
join(sub)	以字符串作为分隔符，插入到参数中所有字符之间。例如："i".join("abc")结果为："aibic"
replace(old,new)	用新字符串代替旧字符串
isdigit	如果字符串只包含数字返回True，否则返回False

其他操作（了解）

1、find,rfind,index,rindex,count2、center,ljust,rjust,zfill3、expandtabs4、captalize,swapcase,title5、is数字系列6、is其他

二、容器数据类型

1列表

定义：[]内以逗号分隔，按照索引，存放各种数据类型，每个位置代表一个元素

列表的创建

list_test=[‘张三‘,‘李四’,'alex']
#或
list_test=list('alex')
#或
list_test=list([‘张三‘,‘李四’,'alex'])

特性

1.可存放多个值
2.按照从左到右的顺序定义列表元素，下标从0开始顺序访问，有序
3.可修改指定索引位置对应的值，可变

常用操作

增加   append()：向列表末尾增加一个元素   extend()：向列表末尾添加多个元素   insert(下标,元素值)：在指定位置插入一个元素 修改   a[0] = 'tom'   调换位置： >>> name = ['张三','李四','王五','赵六'] >>> name[0],name[2] = name[2],name[0] >>> name ['王五', '李四', '张三', '赵六'] 删除   del(name[0])   a.remove('张三')   name.pop()：删除最后一个元素 列表分片   [起始索引:结束索引:步长]，其中包含头不包含尾   列表分片不会修改原列表的值，只是copy了一份新的列表 >>> li = ['a','b','c','d','e','f'] >>> li[0:2] ['a', 'b'] >>> li[2:4] ['c', 'd'] >>> li[:] ['a', 'b', 'c', 'd', 'e', 'f'] >>> li[:4:2] ['a', 'c'] >>> li[::2] ['a', 'c', 'e'] 操作符   list1+list2：结果为两个列表进行连接；   list * 2：结果为复制自身若干次   list1 > list2：通过俩个列表的第一个元素先进行比较大小，不同类型不能比较   in 或者 not in来判断元素是否在列表中，只能判断一个层次的成员关系 常用方法 index(element,[start,[end)：返回元素element的索引,start很end用于限定查找范围，找不到，会抛出异常 count(element)：计算参数在列表中出现的次数 reverse()：反转列表 sort()：用指定的方式对列表成员进行从小到大排序，默认不需要参数 sort(reverse = True)：从大到小排序 clear()：清空一个列表 copy()：拷贝一份新的列表

2元组

元组和列表最大的区别就是：可以任意修改删除插入列表里的元素，但是对元组是不行的。

定义

    与列表类似，只不过［］改成（）

创建

ages = (11, 22, 33, 44, 55)
#或
ages = tuple((11, 22, 33, 44, 55))

特性

1.可存放多个值
2.不可变
3.按照从左到右的顺序定义元组元素，下标从0开始顺序访问，有序

常用操作

    元组获取、切片同列表一样，虽然元组不能被修改，但是可以通过切片来变相删除、修改元素。

注意

如果元组中只有一个值
t = (1,)
t = (1)   #<==>t = 1
元组本身不可变，如果元组中还包含其他可变元素，这些可变元素可以改变

3字典

字典是Python语言中唯一的映射类型。

定义

key1:value1,key2:value2｝
1、键与值用冒号“：”分开；
2、项与项用逗号“，”分开；

特性

1.key-value结构
2.key必须可hash、且必须为不可变数据类型、必须唯一
3.可存放任意多个值、可修改、可以不唯一
4.无序

常用操作

创建 empyt = {} 创建一个空字典 students = {"name":"张三","age":24,"phone":"123"} students = dict((("name","张三"),("age",24),("phone","123"))) students = dict(name = "张三",age = 24,phone = "123") empty['name'] = "张三" 通过赋值来创建字典，如果键存在则修改，不存在，则添加 a = dict(one = 1,two = 2) b = dict([("one",1),("two",2)]) c = dict(zip(["one","two"],[1,2])) d = {"one":1,"two":2} e = dict({"two":2,"one":1}) a == b == c == d == e 获取   用下标的方式去获取，如果不存在会报错。a={"name":"张三","age":15},a["age"]   用get方式去获取，不存在，返回一个None。a.get("age")   setdefaut()方法和get()类似，在字典中找不到，则会添加 修改、增加 >>> student={"name":"张三","age":15,'phone':'123'} >>> student['name'] = '李四' >>> student {'name': '李四', 'age': 15, 'phone': '123'} >>> student['addr'] = '北京' >>> student {'name': '李四', 'age': 15, 'phone': '123', 'addr': '北京'} >>> student.update(age = 20) >>> student {'name': '李四', 'age': 20, 'phone': '123', 'addr': '北京'} 删除   pop()：给定键弹出对应的值，如果键不存在，则抛出一个错误   popitem()：随机弹出一个项   用del删除 >>> student {'name': '李四', 'age': 20, 'phone': '123', 'addr': '北京'} >>> student.pop('email') Traceback (most recent call last): File "<pyshell#27>", line 1, in <module> student.pop('email') KeyError: 'email' >>> student.pop('age') 20 >>> student {'name': '李四', 'phone': '123', 'addr': '北京'} >>> student.popitem() ('addr', '北京') >>> student {'name': '李四', 'phone': '123'} >>> del student['phone'] >>> student {'name': '李四'}

循环

1、for k in dic.keys()
2、for k,v in dic.items()
3、for k in dic

其他方法

formkeys()：用于创建并返回一个新字典 >>> dict1 = {} >>> dict1.fromkeys((1,2,3)) {1: None, 2: None, 3: None} >>> dict1.fromkeys((1,2,3),'hello') {1: 'hello', 2: 'hello', 3: 'hello'} >>> dict1.fromkeys((1,2,3),('hello','world')) {1: ('hello', 'world'), 2: ('hello', 'world'), 3: ('hello', 'world')} keys()返回字典中的键；values()返回字典中的值；items()返回字典中所有的项 >>> student = {'name': '李四', 'age': 20, 'phone': '123', 'addr': '北京'} >>> student.keys() dict_keys(['name', 'age', 'phone', 'addr']) >>> student.values() dict_values(['李四', 20, '123', '北京']) >>> student.items() dict_items([('name', '李四'), ('age', 20), ('phone', '123'), ('addr', '北京')]) in 或者 not in 来判断一个键是否在字典中 clear()：清空一个字典 copy()：复制一个字典，跟列表的复制功能一样 update()：更新字典 >>> student = {'name':'tom','age':18,'addr':'beijing'} >>> student.update(age = 20) >>> student {'name': 'tom', 'age': 20, 'addr': 'beijing'} >>> student.update(phone = '110') >>> student {'name': 'tom', 'age': 20, 'addr': 'beijing', 'phone': '110'} >>> student.update({'hobby':'girl'}) >>> student {'name': 'tom', 'age': 20, 'addr': 'beijing', 'phone': '110', 'hobby': 'girl'}

4集合

定义

可以包含多个元素，用逗号分割，
集合的元素遵循三个原则：
1：每个元素必须是不可变类型(可hash，可作为字典的key)
2:没有重复的元素
3：无序

常用操作

创建

>>> a = {1,2,3,4,3}
>>> a
{1, 2, 3, 4}
>>> b = set(['s','a','d','a'])
>>> b
{'d', 's', 'a'}

增加

>>> b.add('c')
>>> b
{'d', 's', 'a', 'c'}

获取

只能通过迭代去获取
>>> b
{'d', 's', 'a', 'c'}
>>> for each in b:
	print(each)	
d
s
a
c

其他方法

frozenset()：定义不可变集合

>>> name = {'haha','hehe','heihei'}
>>> newname = frozenset(name)
>>> newname.add('hiahia')
Traceback (most recent call last):
  File "<pyshell#17>", line 1, in <module>
    newname.add('hiahia')
AttributeError: 'frozenset' object has no attribute 'add'

in、not in 判断一个元素是否在集合当中

内置方法

集合（s）.方法名	等价符号	方法说明
s.issubset(t)	s <= t	子集测试（允许不严格意义上的子集）：s 中所有的元素都是 t 的成员
	s < t	子集测试（严格意义上）：s != t 而且 s 中所有的元素都是 t 的成员
s.issuperset(t)	s >= t	超集测试（允许不严格意义上的超集）：t 中所有的元素都是 s 的成员
	s > t	超集测试（严格意义上）：s != t 而且 t 中所有的元素都是 s 的成员
s.union(t)	s | t	合并操作：s "或" t 中的元素
s.intersection(t)	s & t	交集操作：s "与" t 中的元素
s.difference	s - t	差分操作：在 s 中存在，在 t 中不存在的元素
s.symmetric_difference(t)	s ^ t	对称差分操作：s "或" t 中的元素，但不是 s 和 t 共有的元素
s.copy()		返回 s 的拷贝（浅复制）
以下方法仅适用于可变集合
s.update	s |= t	将 t 中的元素添加到 s 中
s.intersection_update(t)	s &= t	交集修改操作：s 中仅包括 s 和 t 中共有的成员
s.difference_update(t)	s -= t	差修改操作：s 中包括仅属于 s 但不属于 t 的成员
s.symmetric_difference_update(t)	s ^= t	对称差分修改操作：s 中包括仅属于 s 或仅属于 t 的成员
s.add(obj)		加操作：将 obj 添加到 s
s.remove(obj)		删除操作：将 obj 从 s 中删除，如果 s 中不存在 obj，将引发异常
s.discard(obj)		丢弃操作：将 obj 从 s 中删除，如果 s 中不存在 obj，也没事儿^_^
s.pop()		弹出操作：移除并返回 s 中的任意一个元素
s.clear()		清除操作：清除 s 中的所有元素

三、数据类型总结

按存储空间的占用分（从低到高）

数字
字符串
集合：无序，即无序存索引相关信息
元组：有序，需要存索引相关信息，不可变
列表：有序，需要存索引相关信息，可变，需要处理数据的增删改
字典：无序，需要存key与value映射的相关信息，可变，需要处理数据的增删改

按存值个数区分

标量／原子类型
  数字，字符串
容器类型
  列表，元组，字典

按可变不可变区分

可变 
  列表，字典
不可变
  数字，字符串，元组

按访问顺序区分

直接访问
  数字
顺序访问（序列类型）
  字符串，列表，元组
key值访问（映射类型）
  字典