Python的数据类型

Python的数据类型

　　python 的数据类型主要有以下5种：数值型、字符串型、列表型、元组型、字典型

 

数字类型

　　分为：整型、浮点型、长整型、复数型

　　1.整数类型的范围是2**32，其中包含正数和负数（2的31次方个正和2的31次方的个负数）

　　所以它的范围是-2147483648 ——— 2147483648

In [1]: a=1
In [2]: type(a)
Out[2]: int
In [18]: type(2/1)
Out[18]: int

　　2.浮点型，就是带小数点的

In [3]: a=1.23
In [4]: type(a)
Out[4]: float
In [19]: type(2.0/1)
Out[19]: float

　　3.长整型，用l或L表示，当我们赋值的时候使用l可以把变量赋值为长整型

In [11]: a=1299999999999999999999999999999999999999999
In [12]: type(a)
Out[12]: long
In [13]: a
Out[13]: 1299999999999999999999999999999999999999999L
In [15]: a=123l
In [16]: type(a)
Out[16]: long
#只有python2.x中有长整型的概念，python3.x只有整型

　　4.复数型，用j表示，当我们赋值的时候使用j可以把变量赋值为复数型

　　python对复数提供内嵌支持。（其他大部分软件没有）

In [20]: type(123j)
Out[20]: complex

 

字符串类型

    有三种方法定义字符串类型：单引号，双引号，三引号

str='this is string'
str="this is string"
str='''this is string'''也可以是三个双引号，不能单双混合

    其中三重引号除了能定义字符串以外，还可以表示注释，也可以表示集合

    字符串是一个序列，可以通过索引和切片去操作

    1.索引（类似数组的下标）：

In [3]: a='1234567'
In [4]: a[0] -->#下标从0开始，0表示第一个数
Out[4]: '1'
In [5]: a[3] -->#表示第四个数
Out[5]: '4'

    2.切片（类似shell变量的截取）：

In [14]: a='abcd'
In [15]: a[0:2]
Out[15]: 'ab'
#从第0个开始截取2个字符，其中0可以省略
In [14]: a='abcd'
In [16]: a[:-1]
Out[16]: 'abc'
#默认是从左往右（前往后），带减号，表示从右往左（后往前），-1表示最后一个字符(a='abcd',-1的值是d，也就是3，顾a[:-1]，就等于a[0:3])
In [14]: a='abcd'
In [17]: a[1:]
Out[17]: 'bcd'
#从1开始截取到最后
In [14]: a='abcd'
In [20]: a[::2]
Out[20]: 'aceg'
#步长为2，表示从0开始步长为2，(取0,2,4,6)
In [26]: a
Out[26]: 'abcdefg'
In [27]: a[-5:-1]
Out[27]: 'cdef'
#表示倒着取，从倒数第五个取到倒数第一个（不包含倒数第一，要想取可以使用a[-5:]）
In [29]: a
Out[29]: 'abcdefg'
In [30]: a[0:5:1]
Out[30]: 'abcde'
In [31]: a[0:5:2]
Out[31]: 'ace'
#从0开始取到第5个，步长为1，步长为2
In [32]: a
Out[32]: 'abcdefg'
In [34]: a[-1::-1]
Out[34]: 'gfedcba'
#从后往前取，步长为-1，表示每次倒着取1个，由于没有指定结尾，默认到最后，所以就把数字逆了过来。
In [36]: a
Out[36]: 'abcdefg'
In [38]: a[::2][:2]
Out[38]: 'ac'
#表示先每隔2个取出来，然后从头开始取2个。

 

序列

    - 字符串、列表和元组都是序列的一种

    - 序列的两个主要特点是索引操作符和切片操作符

    - 索引操作符让我们可以从序列中抓取要给特定的项目

    - 切片操作符让我们能够获取序列的一个切片，即一部分操作

    1.len()计算字符串的长度

In [7]: a='123'
In [8]: len(a)
Out[8]: 3
In [9]: len('123')
Out[9]: 3

    2.+连接两个序列

In [10]: a
Out[10]: '123'
In [11]: a + '4'
Out[11]: '1234'
#字符串和数字不能连接到一起

    3.*重复序列元素（字符串的时候）

In [18]: '#' * 10
Out[18]: '##########'
#当变量为数字的时候就为乘了。

    4.in 判断元素是否在序列中

In [23]: a = 'abcd'
In [24]: 'a' in a
Out[24]: True
#当字符串在某个序列中的时候返回真，否则返回假（not in表示不在）

    5.max(),min()求最大值和最小值

In [25]: max(a)
Out[25]: 'd'
In [26]: min(a)
Out[26]: 'a'
In [27]: a
Out[27]: 'abcd'

    6.cmp()比较两个序列是否相等

#若相等则返回0，若前大于后则返回正数，若后大于前则返回负数
In [30]: cmp("123","456")
Out[30]: -1
In [33]: cmp("789","456")
Out[33]: 1
In [34]: cmp("456","456")
Out[34]: 0
#注意cmp的比较是从左向右开始比对的，大于就返回1，小于就返回-1，等于就继续向后比对
In [43]: cmp('5','456')
Out[43]: 1
In [44]: cmp('45','456')
Out[44]: -1
In [45]: cmp('455','456')
Out[45]: -1
In [46]: cmp('457','456')
Out[46]: 1

 

元组概念

    元组（类型为 tuple）和列表十分相似

    元组和字符串一样是不可变的

    　　- 1.元组可以存储一系列的值

           - 2.使用括号来定义

           - 3.元组通常用在用户定义的函数能够安全的采用一组值的时候，即被使用的元组的值不会改变

           - 4.元祖也通常用来接收函数的返回值

    不可变的含义是：不能改变这个值中的某个字符。

In [8]: a='123456'
In [9]: a[-1]
Out[9]: '6'
In [10]: a[-1]=1
---------------------------------------------------------------------------
TypeError Traceback (most recent call last)
<ipython-input-10-1ad23d7f375d> in <module>()
----> 1 a[-1]=1
TypeError: 'str' object does not support item assignment
In [11]:
#变量a是可以被定义成任何值的，但是不能在定义之后，修改里面的值，如果想要修改就需要重新定义这个变量
In [11]: a='123451'
In [13]: a[-1]
Out[13]: '1'

    1.定义一个元组

    使用()来表示定义的是元组，但是如果元组里面的值只有一个的话，需要加在值后面加上，（逗号），表示是一个元组

    另外，元组中可以同时储存不同类型的数据，也可以引用其他元组

In [18]: t=(1)
In [19]: type(t)
Out[19]: int
In [20]: t=(1,)
In [21]: type(t)
Out[21]: tuple
#引用其他元组
In [22]: a=(1,2,3)
In [23]: t=('123',a)
In [24]: t
Out[24]: ('123', (1, 2, 3))
#通过索引只引用某一个值
In [27]: t=('123',a[1])
In [28]: t
Out[28]: ('123', 2)

    2.元祖的拆分

    通过变量去接收元组中的值

In [34]: a=('123','456')
In [35]: first,second=a -->定义first接收元组的第一个值，second接收元组的第二个值
In [36]: first
Out[36]: '123'
In [37]: second
Out[37]: '456'
#注意接收值的变量要与元组中的值的个数保持一致，若元组中有3个值，必须定义三个变量去接收，否则无法接收（当元组中有两个值的时候，用一个变量去接不会报错，但是也还是用元组的形式表达）

    3.元组的方法

    如果安装了ipython可以通过tab键查看元组的方法，如果没有安装，就需要使用dir(元组名)去查看了

In [49]: a.
a.count a.index
 
>>> dir(a)
['__add__', '__class__', '__contains__', '__delattr__', '__doc__', '__eq__', '__format__', '__ge__', '__getattribute__', '__getitem__', '__getnewargs__', '__getslice__', '__gt__', '__hash__', '__init__', '__iter__', '__le__', '__len__', '__lt__', '__mul__', '__ne__', '__new__', '__reduce__', '__reduce_ex__', '__repr__', '__rmul__', '__setattr__', '__sizeof__', '__str__', '__subclasshook__', 'count', 'index']
>>>
#会列出一些内饰的属性，和方法
使用help查看使用方法
In [3]: help(a.count)
count(...)
T.count(value) -> integer -- return number of occurrences of value
a.count(value) 用来统计value在元组中出现的次数，不存在返回0。
In [4]: a=('1','2','3')
In [7]: a.count("4")
Out[7]: 0
In [8]: a.count("1")
Out[8]: 1
 
a.index(value) 用来返回value在元组中的索引，如果value不在元组中，则会报错。如果有多个，默认返回第一个（可以指定从哪个索引开始查找到某个索引结束，指定范围区间）
In [4]: a=('1','2','3')
In [9]: a.index('1')
Out[9]: 0
In [10]: a.index('3')
Out[10]: 2
>>> t1
('a', 'b', 'a', 'b', 'a', 'b', 'a', 'b')
>>> t1.index('a',5,7)
6
 

     4.元祖的拆分

     假如元祖中有三个元素，那么我们可以定义3个变量来接受元祖的值，如果元祖中有4个元素，那么我们只能通过定义1个或者定义4个来接受，定义1个就等于元祖复制，定义4个才表示接受元素

 

列表

    - 列表(类型为 list)是处理一组有序项目的数据结构，即可以在列表中存储一个序列的项目。

    - 列表是可变类型的数据

    - 创建列表使用[]中括号

    1.创建一个空的列表

list1 = []
list2 = list()
创建列表并赋值
list3 = ['a',1,2]
列表可以包含变量，元组，列表等
In [15]: a=123
In [16]: b=['123',a,(1,),["hello","python"]]
In [17]: b
Out[17]: ['123', 123, (1,), ['hello', 'python']]
In [24]: len(b)
Out[24]: 4
#一共有4个变量
列表的值是可以改变的
In [25]: b
Out[25]: ['123', 123, (1,), ['hello', 'python']]
In [26]: b[0]
Out[26]: '123'
In [27]: b[0]=456
In [29]: b
Out[29]: [456, 123, (1,), ['hello', 'python']]

    2.列表的追加

In [30]: a=[]
In [31]: type(a)
Out[31]: list
In [32]: a.append("linux")
In [33]: a
Out[33]: ['linux']

    3.列表的组合

In [34]: b + a
Out[34]: [456, 123, (1,), ['hello', 'python'], 'linux']
In [35]: (b + a) * 2 --->重复2次
Out[35]:
[456,
123,
(1,),
['hello', 'python'],
'linux',
456,
123,
(1,),
['hello', 'python'],
'linux']

    4.列表的删除

In [39]: b.remove('love')
In [40]: b
Out[40]: [456, 123, (1,), ['hello', 'python']]
#直接移出元素名，如果有两个，则默认删除匹配的第一个。
In [55]: b
Out[55]: [123, 456, ['hello', 'python'], '123', (1,)]
In [56]: del b[0]
In [57]: b
Out[57]: [456, ['hello', 'python'], '123', (1,)]
#如果知道变量的索引可以直接通过del来进行删除，del还可以直接删除变量

    5.列表的反转

In [42]: b.reverse()
In [43]: b
Out[43]: [['hello', 'python'], (1,), 123, 456]

    6.列表的插入

In [47]: b
Out[47]: [456, 123, (1,), ['hello', 'python']]
In [48]: b.insert(0,'123')
In [49]: b
Out[49]: ['123', 456, 123, (1,), ['hello', 'python']]

    7.查找列表中变量

In [62]: b
Out[62]: [456, ['hello', 'python'], '123', (1,)]
In [63]: '123' in b
Out[63]: True
In [65]: "a" in b
Out[65]: False

    8.变量的修改

In [68]: b
Out[68]: [456, ['hello', 'python'], '123', (1,)]
In [69]: b[0]='123'
In [70]: b
Out[70]: ['123', ['hello', 'python'], '123', (1,)]

    9.列表里面嵌入列表，并插入数据

In [71]: b=[] -->定义一个空列表
In [72]: a=[b,'123','456']
In [73]: a
Out[73]: [[], '123', '456']
In [74]: a[0].append("linux") -->向空列表中插入数据
In [75]: a
Out[75]: [['linux'], '123', '456']

    10.删除并列出列表中的某个值，（不加下标，表示删除并打印最后一个值）

In [75]: a
Out[75]: [['linux'], '123', '456']
In [76]: a.pop(1)
Out[76]: '123'
In [77]: a
Out[77]: [['linux'], '456']

    11.添加可迭代的值（可迭代，可以理解为可以使用for循环等，挨个取出的值的列表，列表，字符串，序列，元组 都属于可迭代的对象）

In [125]: a
Out[125]: [1, 3, 5, 7, 9]
In [126]: a.extend('2468')
In [127]: a
Out[127]: [1, 3, 5, 7, 9, '2', '4', '6', '8']
In [128]: b=(1,2,3,4)
In [129]: a.extend(b)
In [130]: a
Out[130]: [1, 3, 5, 7, 9, '2', '4', '6', '8', 1, 2, 3, 4]
In [131]:
In [131]: c=123
In [132]: a.extend(c)
---------------------------------------------------------------------------
TypeError Traceback (most recent call last)
<ipython-input-132-49130b702eb2> in <module>()
----> 1 a.extend(c)
TypeError: 'int' object is not iterable
In [133]: --->c不是可迭代的，所以会报错。

    12.列表的组合

zip()，可以把两个列表组合成一个，前一个列表去一个，后列表取一个
In [5]: list1=['Name','age']
In [6]: list2=['Tom',20]
In [7]: zip(list1,list2)
Out[7]: [('Name', 'Tom'), ('age', 20)]

 

字典

    使用大括号定义

    字典是Python中唯一的映射类型（哈希表）

    字典对象是可变的，但是字典的键必须使用不可变对象，一个字典中可以使用不同类型的key。

　　- 像元组，字符串等都是不可变的，都可以作为key。而列表是可变的，无法作为key。key是唯一的

 

字典的方法

　　- keys() 获取字典的key

　　- values() 获取字典中所有的values

　　- items() 把字典转换成列表

　　- get() 如果字典中有该key，则返回key值，如果没有，则返回空，也可以自己定义返回值

　　- dic.get('Name','python')，如果存在name，则返回values，否则返回Python

　　- has_key('key') 判断key的是否存在，存在返回True，否则返回False

　　- dic1 = dic.copy() 拷贝字典到一个新的字典中去

　　- clear() 清除字典中的元素

　　- pop() 删除一个key，同时打印该key的value，如果key不存在，则返回keyerror，或者指定返回值 dic.pop('name',True)

　　- update() 把一个字典更新（添加）到另一个字典中

　　- fromkeys(s,value) 把序列s，作为字典的key，如果不给value，则默认是none，如果指定value，那么所有key对应的值都为value

 

　　1.创建字典

- dic={}
- a=dict()
- dict(x=10,y=20)
- dict([('a',10),('b',20)])
必须是以元组的形式创建。

　　2.把数据存入字典

- d1['name']='tom' 即可存入

　　3.for 循环打印字典

for i in d1:print i,d1[i]
取出字典中的key，同时可以根据key来取出value
for k,v in d1.items():print k,v
把字典的值转换为列表，然后利用k和v来接受列表中元组的key和value

 

字典练习

    读取键盘输入，存入到字典中，并打印

#!/usr/bin/env python
 
info = dict()
name = raw_input('Please input name: ')
age = raw_input('Please input age: ')
sex = raw_input('Please input sex: ')
info['name'] = name
info['age'] = age
info['sex'] = sex
print info.items()
for k,v in info.items():
　　print "%s:%s " % (k,v)