数据类型| 表示形式 | 是否有序列 | 对象是否可变|访问顺序 |取值
数字 | 1234 | 没有下标 | 不可变 | 直接访问 |
字符串| 'asd3234'| 有下标 | 不可变 | 序列访问|str[i]
元组 tuple |(1，'abc',[1,3] )|有下标 | 不可变 | 序列访问[] | tuple[i]
列表 list | [1，'abc',(1,3),[2,3]] | 有下标 | 可变 | 序列访问 | list[i]
字典 dict | {'key1'：'values','key2':'very good'} | 没有下标| 可变 | 映射访问<乱序> | dict['key1'],dict['values']
集合 set|{1，'abc',(1,3)} |没有下标 | 不可变 | | 乱序，不易取值 | 不可取单个值
解释：
1.是否有序列，即：按照从左到右的顺序定义列表元素，下标从0开始顺序访问，有序。
2.是否为可变对象，即值是否可变，而ID/S数据类型是不变的。（对于数据来说，一个对象有ID_数据类型_变量值），身份/类型比较用is， 值比较用 ==.
3.列表/元组/字典可存储各种数据类型。字典允许一种key，同一种key只保留一个。
4.元组与列表唯一的区别就是不可变
5.集合的作用：1.关系运算 2.去重
特性：1.集合内的元素必须唯一 2.集合内的元素必须可hash，即不可变对象。 3.集合是无序的，也就说没有索引
6.针对数据类型，可以从“增” “删“ ”改” “查” 四个方面去理解/
7.所有数据类型自带布尔（bool）值，只有0 或 None，空的布尔值为False
--------------------------------------------------------------------------------------------------------------------------------------------------------------
S=[1,2,[3,4],8,9] #以列表数据类型举例；
遍历的两种方式： 1. for i in S: 2. for i in range(len(S)) #遍历(Traversal)，是指沿着某条搜索路线，依次对树中每个结点均做一次且仅做一次访问。
格式化的两种方式：1.%s 例如：res="Name:%s" %'egon' 2.S.format(*args, **kwargs)
#格式化字符串 # msg='Name:{},age:{},sex:{}' # print(msg) #Name:{},age:{},sex:{} # print(msg.format('egon',18,'male'))
-------------------------------------------------------------------------------------------------------------------------------------------------------------
1.字符串常用操作str()
#msg='hello'
#取值 msg[i]
#移除空白 msg.strip()
#分割msg.split('|')
#长度len(msg)
#索引msg[3] msg[-1]
#切片msg[0:5:2] #0 2 4
2.tuple 元组 tuple()
1.元组的元素可以是任意数据类型
2.元组的特性是不可变
常用操作：
t=('a',1,'b',1,(3,4))
# 索引 t.index('b')
# 切片 t[0:4]
# 循环
# 长度 len(t)
# 包含 'a' in t
取值操作：
t=('a',1,'b',1,(3,4)) # print(t[a]) #取元组元素的值 #print(t[4][0]) #取元祖中元素的元祖的值
修改元祖的值：
# t=(1,2,['a','b']) # t[2][0]='aaaaaaa' # t[1]=3 # t[2][0]=123123123123 #修改元祖中的值 # print(t) # print(id(t),type(t),t)
3.list 列表 list()
#定义列表 # l=[1,'a',[3,4]] #l=list([1,'a',[3,4]])
取值操作：
# l=[1,2,[['a','b'],'c']] # print(l[0]) #取值1 # print(l[1]) #取值2 # print(l[2][0][1]) #取a
常用操作：
l=[1,2,3,[4,5]]
#列表常用操作
# 索引 l.index(3)
# 切片 l[1:3:2] #切片操作是读操作，并不会修改原来的数据，2为步长，1-3为取值范围
# 插入 l.insert(0,'first')
# 删除 dek l[0]
l.pop(0)
l.remove(1)
# 长度 len(l)
# 包含 'a' in l
list是一个使用方括号 [ ] 括起来的有序元素集合;可以容纳Python中的任何对象。
List 可以作为以 0 下标开始的数组,任何一个非空 list 的第一个元素总是 L[0],负数索引从 list 的尾部开始向前计数来存取元素。任何一个非空的 list 最后一个元素总是 L[-1];
有分片功能，两个list可以相加；
append --------------->> 向 list 的末尾追加单个元素；
insert --------------->>将单个元素插入到 list 中；
extend ---------------->>用来连接 list，使用一个 list 参数进行调用；
append---------------->> 接受一个参数, 这个参数可以是任何数据类型, 并且简单地追加到 list 的尾部；
index------------------>> 在 list 中查找一个值的首次出现并返回索引值；
要测试一个值是否在 list 内, 使用 in, 如果值存在, 它返回 True, 否则返为 False ；
remove ------------->>从 list 中删除一个值的首次出现；
pop --------------->>可以删除 list 的最后一个元素, 然后返回删除元素的值，用索引删除制定位置的值；
队列与堆栈：
#队列：先进先出 l=[] #append与pop(0) #入队列 # l.append('people1') # l.append('people2') # l.append('people3') # print(l) #出队列 # print(l.pop(0)) # print(l.pop(0)) # print(l.pop(0)) #insert(0,item) #入队 l.insert(0,'people1') l.insert(0,'people2') l.insert(0,'people3') # print(l) #出队 # print(l.pop()) # print(l) # print(l.pop()) # print(l) # print(l.pop()) #堆栈：先进后出,或者说后进的先出 #append与 # l=[] # l.append('people1') # l.append('people2') # l.append('people3') # print(l) # print(l.pop()) # print(l.pop()) # print(l.pop())
4.dict 字典 dict()
http://blog.csdn.net/stven_king/article/details/32952577
#字典定义的基本形式：key:value #可以通过 key 得到value, 但不能通过vaule获取 key；整个元素集合用大括号 { } 括起来，有序集合； # d={'name':'egon','age':18} #d=dict({'name':'egon','age':18}) #dict定义了键和值之间的一一对应关系，每个元素都是一个key-value对；键不可变，无法修改；值可修改，可以是任何对象。
在一个 dict中不能有重复的 key, 并且 key 是大小写敏感的；
#定义字典需要注意的问题：key必须是不可变类型，或者说是可hash类型 # print(hash(1)) # print(hash('xxxxxx')) # print(hash((1,2,3)))
取值操作：
d={1:'id','a':1,'b':2,'name':'egon',(1,2):'aaaaaaaa'}
#字典的取值,字典是无序的
# print(d[1])
# print(d['name']) #根据字典的key--->'name'取值
# print(d[(1,2)])
# d={'name':'alex','age':18}
# print(d['name'])
# d['name']='aaaaasb' #修改字典的值
# print(d)
d={'name':'alex','age':18,'sex':'male','height':130,'weight':200}
# print(d.keys()) #取字典中的key的值
# print(d.values()) #去字典中的values的值
# print(type(d.keys()))
快速产生字典的几种方式：
d3=dict(x=1,y=2,z=3) #产生字典的三种方式 print(d3) d4=dict({'x':1,'y':2,'z':3}) print(d4) d5=dict([('x',1),('y',2),('z',3)]) print(d5)
# d6={}.fromkeys(['name','age'],None)
# print(d6)
#
# d7={}.fromkeys(['name','age'],['egon',18])
# print(d7)
# d={'name':'alex','sex':'male'}
#
# d1={'name':'alexsb','age':50}
# d.update(d1) #d1个更新d里面的内容
# print(d)
字典的常用方法：
d={'x':1,}
# d.clear() #清除内容
# 删除
# d.pop('x')
# d.popitem()
# 键、值、键值对
# d.keys()
# d.values()
# d.items()
# 循环
# 长度
#
# d={'x':1,'u':2}
# print(len(d))
# #成员运算
# d={'x':1,'u':2}
#
# print('x' in d)
# print(1 in d.values())
d={'x':1,'y':2,'c':1}
d2={'x':100,'d':1}
# d['key']=1213 #增加元素
# print(d.setdefault('z',12)) #增加元素，但不覆盖已有的元素
# d.update(d2) #将d2中的元素更新d中，如果有则替换，如果没有则增加
# d.pop('x') #删除元素
# d.popitem() #随机删除键值对
# del d['x'] #删除字典的元素
# d['x']=3 #修改元素的值
# d.keys() #获取字典所有的key
# d.values() #获取字典所有的value
# d.get('x') #获取value的值，如果访问的字典不存在则返回None
# print(dict.fromkeys(("x","y","z","d"),19)) #批量创建新的字典，key可以多个但value固定.
5.集合 set
集合的作用：
1.关系运算
#关系运算 python_s={'egon','alex','钢蛋','老王'} linux_s={'alex','钢蛋','欧德博爱','艾里科四'} #取共同部分：交集 # print(python_s & linux_s) # # # #取老男孩所有报名学习的学生：并集 # print(python_s | linux_s) # # #取只报名了python课程的学生：差集 # print(python_s - linux_s) #取只报名了linux课程的学生：差集 # print(linux_s - python_s) #取没有同时报名python和linux课程的学：对称差集 # print(linux_s ^ python_s)
2.去重--->(集合内的元素必须唯一)
# 去掉重复 # names=['egon','alex','egon','wupeiqi'] # print(list(set(names)))
#定义集合：
# 集合内的元素必须是唯一的；
# 集合内的元素必须是可hash的，也是就不可变类型；
# 集合是无序的
# s={'egon',123,'egon','1'} #s=set({'egon',123,'egon','1'} )
# print(s,type(s))
集合的方法：
#集合方法 # python_s={'egon','alex','钢蛋','老王'} # linux_s={'alex','钢蛋','欧德博爱','艾里科四'} # print(python_s.intersection(linux_s))# 交集：python_s & linux_s # print(python_s.union(linux_s))#并集:| # print(python_s.difference(linux_s)) #python_s-linux_s # print(python_s.symmetric_difference(linux_s))# 对称差集，python_s ^ linux_s # python_s={'egon','alex','钢蛋','老王'} # linux_s={'alex','钢蛋','欧德博爱','艾里科四'} # python_s.difference_update(linux_s) # print(python_s)
s1={'a','b'}
s2={'c','d'}
print(s1.isdisjoint(s2)) #没有交集返回True
----------------------------------------------------------------------------------------------------------------------
while 与 else
# count=1 # while count < 10: # print(count) # continue # count+=1 # else: #在循环正常结束后执行：1 循环结束， 2 没有被break打断 # print('=========>')
变量的赋值：
# x=1 # a=10 # b=10 # #链式赋值 # a=b=c=d=e=f=10 # print(a,b,c,d,e,f) #多元赋值 #方式一 x=1 y=2 # # z=x #z=1 # x=y #x=2 # y=z #y=1 # print(x,y) #方式二：python特有 # x,y=y,x # print(x,y) #增量赋值 # x=10 # x+=1 #x=x+1 # print(x) #解压序列类型 s='hello' # a=s[0] # b=s[1] # c=s[2] # d=s[3] # e=s[4] # print(a,b,c,d,e) # a,b,c,d,e=s # print(a,b,c,d,e) # a,_,_,_,e='alexs' # print(a,e) # print(_) # a,*_,e='alexs' # print(a,e) # m,n,*_='alexs' # print(m,n) *_,m,n='alexs' print(m,n)
