Python数据类型

之LIST：

序列中的每个元素都分配一个数字 - 它的位置，或索引，第一个索引是0，第二个索引是1，依此类推。

序列都可以进行的操作包括索引，切片，加，乘，检查成员

索引运算：[i]

切片运算：[i:j]

扩展运算：[i:j:stride]

a=[1,2,3,4,5,6]

a[1]

a[0:2]

 a[6:0:-1]

左侧数小于右侧：a[-1:-3]

[6, 5, 4, 3, 2]

a[0:6:2]

max(a) min(a) len(a) sum(a) all(a)

all(a) any(a)检查a中的所有、任意项是否都为真

s.replace("aa","new")替换一个字符串

s.plit([seq[,maxsplit]])使用sep作为分隔符对一个字符串进行划分，maxsplit是划分的最大次数

s.strip([chrs])删除chrs开头和结尾的空白或字符

s.upper()

列表操作：容器类型

任意对象的有序集合。通过索引访问其中的元素。支持异构，任意嵌套，可变对象，

列表支持在原处修改，列表可变是指内部的每个一个元素存储在对象里，不是修改对象本身，是对象的引用。

l1=[1,2,3,4]

>>> l1=[]

>>> print l1

[]

>>> id (l1)

48778696 ##此为列表的对象，内存的对象是唯一的

支持在原处修改：

修改制定的索引元素，修改指定的分片，删除语句,内置方法

l1=[1,2,3,4,5,6]

l4="adfdf"

l1[2]=33

l1[2]='adfd'#支持异构

l1[1:3]=[]

del(l1[1:])

l1.append(7):内置方法

l1.append(l4)

l1.count(5)#统计指定直出现次数

l1.extend(l4)：合并列表

l1.index(5):

l1.insert(1，333)#指定位置插入直

l1.pop()#弹出直，不给指定直，弹出最后一个

l1.pop(4)#弹出索引值是4的值

l1.remove()#删除指定的值，不是第三个元素，

l1.reverse()#在原处逆序

l1.sort()#原处排序

l1=[1,2,3] l2=['x','y','z']

l1+l2 #连接2个列表，进行合并，返回新的列表

字符串也是相同。

序列支持相乘

l1*3# 重复l1的次数为3

in：成员关系判断符：

2 in l1

列表可迭代

not in

2 not in l1

l1[1:]=['a','b','c']切片替换元素

range

xrange

列表解析：a=[for i in l1]

for i in [ i**2 for i   in range(1,11)]:print i/2

for i in [ i**2 for i   in range(1,11) if i%2==0]:print i/2

l1=l2

l1.append(6)

此时l1还是等于l2

指向同一个内存对象，不是真正复制。列表支持原处修改。 浅复制

要真正复制：为深度复制

l2=l1[:]

此时修改就不会相等。

import copy

l2=copy.deepcopy(l1)

list方法总结：

name=[]

name.extend(range(1000))

name.count(2)查询指定值的个数

name.append()

name.insert(3,'dfdf')

name.index()

name.pop()弹出最后一个

name.pop(1)弹出指定位置值

name.remove()删除具体值

name.reverse()反转

name.sort()排序

批量修改指定值

name.count('add')

for i in range(name.count('add')）:

    ibm_index=name.index('adddd')

    name[ibm_index]='ddfdf'

处理字符串改称列表 之间的转换使用join

a="dfdfdfdfdfdfdfdf"

b=list(a)

c=''.join(b)

判断文件是否打开状态：

避免打开文件忘记关闭可以使用：

with open('aa.txt','r') as f:

   for i in f.readlines():

     print i

删除列表的值：

remove(aa) 删除一个指定值

del a[6:11] 根据索引值删除

------dict:

字典：dict {key:value},键值一般为字符 加‘’

无序集合，通过key取值

在其他编程语言中，称关联数组或者散列表

在PYTHON中，是可变类型容器

通过实现元素存取，无序集合，可变类型容器，长度可变，支持异构，支持嵌套

｛｝:空字典

d1={'x':32,'y':2,'z':[1,2,3,4]}取值为d1['x']

d1['y'][1:]支持切片

len(d1)

d1['x']=333支持修改

d1.clear()

d1.copy()返回自己本身的值，深复制，创建新对象

d1.fromkeys()

d1.get('x')返回指定建,若返回没有建值，不会有异常

d1.has_key('a')是否有a这个建

d1.items()将字典转换称字典的列表方式

t1,t2=d1.items()#将d1值赋值给t1,t2##称变量解包

d1.iteritems#（K,V）迭代 a=d1.iteritems() a.next().....

d1.keys()#返回建列表

d1.values()值列表

d1.pop('x')#弹出指定建对应的元素

d1.popitem()#随机弹出

d1.update(d2)#字典合并，若有相同的值建，覆盖原来的指定键的值

d3=d1.iterkeys()

d3.next()返回键

itervalues()返迭代的回值

d1.viewitems()#返回一个列表的字典

d1.viewvalues()#返回字典的值

##################

zip('xyz','1234')#返回列表的字典

dict(zip('xyz','123'))#构造字典

不能对一个键赋多个值

可哈希的键才可用作键，一般都是字符串 可哈希对象，字典是不可哈希

--TUPLE:

表达式符合：（）  tuple

容器类型：任意对象的有序集合，通过索引访问其中的元素，不可变对象，长度固定，支持异构，嵌套

常见操作有：

定义空元组l2=()

l2=()

(1,)

（1，3）

某些特定情况下，可以省略括，

使用+号连接，合并

l1*N#支持重复N此

支持成员关系判断：1 in l1

元组本身不可变，但元组内部嵌套可变类型元素，那么此类元素的修改不会返回新对象l1=('x',[1,2,3])

l1=(1,2,3,4,5)

l1.index(3)

l1.count(2)返回在元组的次数

30 in l1是否在l1中

可以切片、分片

l1[1:]

l2='x','y','z'

l1+l2