# coding=utf8
 __author__ = 'SummerChill'
 #list 有序的列表、元素可以是不同类型的，元素值可以重复

 #list的初始化
 l=list()
 l=[]
 l=[1,2,3,'crxy',[1,2,3]]
 l=['a','b','c','d','b','b','e']

 #增加元素
 #追加元素list的末尾
 l.append('new')
 #添加元素到指定的索引位置
 l.insert(2,'Two')

 #删除元素
 #根据索引删除 如果索引缺省则会删除末尾的元素
 l.pop()
 l.pop(1)
 #根据value删除 只会删除第一个出现的value为'b'的元素
 l.remove('b')

 #修改元素
 l[3]='Three'

 #查询 如果index为整数表示索引，如果是负数表示取倒数第几个
 # print(l[2])
 # print(l[-2])

 # 最终打印的结果
 # c
 # b

 #tuple 元组 和list类似 只是一旦初始化在不能修改 只能查询和遍历
 #主要用作函数的返回值
 t=()
 t=tuple()
 t=(1,2,3,'a','b')

 #t[1]='new'  #NO!!!!!
 # TypeError: 'tuple' object does not support item assignment

 # print(t[1])
 # print(t[-1])

 #########字符串的操作返回一个副本
 data='str'
 result=data.upper()
 print(data,result)#('str', 'STR')

 #########list的操作作用在list本身
 l=[1,2,3]
 result=l.append(4)
 print(l,result)#([1, 2, 3, 4], None)#返回None说明append没有返回值
 ###############################################

 print(l)
 #拓展list 在list的尾部扩展增加新的集合
 l.extend(['as','s','a','b'])
 print(l)#[1, 2, 3, 4, 'as', 's', 'a', 'b']

 #统计list中某个元素的出现的次数

 #统计list中某个元素的出现的index 返回第一个匹配的元素的索引

 #指定区间的查找 start stop 包含start 不包含stop
 #查不到报错不在list中。
 #print(l.index('a',2,5))#ValueError: 'a' is not in list

 #反转 倒叙排列
 l.reverse()
 print(l)#['b', 'a', 's', 'as', 4, 3, 2, 1]
 l.sort()
 print(l)#[1, 2, 3, 4, 'a', 'as', 'b', 's']

 #排序需求：按照元素的长度来排序
 #通过key指定的函数来查找要排序的依据。key_fun(item)
 #将key_fun(item)的返回值，传入 cmp_fun(x,y) 进行比较并排序。
 #cmp_fun(x,y)返回值决定了排序的位置。如果 cmp_fun(x1 ,x2) <0 x1排在x2的前面。
 l=['b','a','c','one','two','three','four']
 def key_fun(item):
     return len(item)
 #如果item是int类型的,是不能调用len()方法的.
 #TypeError: object of type 'int' has no len()

 def cmp_fun(x,y):
     return x-y

 #自定义排序
 l.sort(key=key_fun,cmp=cmp_fun)
 print(l)#['b', 'a', 'c', 'one', 'two', 'four', 'three']

 #lamda表达式 起到了函数速写的功能,允许在代码内嵌入一个函数的定义。类似于匿名函数
 l.sort(key=lambda item:len(item),cmp=lambda x,y:x-y)
 print(l)#['b', 'a', 'c', 'one', 'two', 'four', 'three']

 t=('a','b','c','a')
 #count value的出现次数
 print(t.count('a'))
 # 查找tuple中value的index 如果不存在则报错 ValueError: tuple.index(x): x not in tuple
 print(t.index('c'))

 # coding=utf8
 __author__ = 'SummerChill'

 #L[m:n]表示，从索引m开始取，直到索引n 但包含索引n；
 #L[m:n:p]表示：从索引m开始到索引n取数据，但包含索引n，每p个取一个。

 l=['a','b','c','d','e','f','g']

 #L[m:n]表示，从索引m开始取，直到索引n 但包含索引n；
 print(l[1:5])#['b', 'c', 'd', 'e']
 #L[m:n:p]表示：从索引m开始到索引n取数据，但包含索引n，每p个取一个。
 print(l[1:5:3])#['b', 'e']

 # m n p 可以为负数
 #m、n为负数表示倒数第几个  前面包含后面不包含
 print(l[-5:-1])#['c', 'd', 'e', 'f']
 #p<0 从尾部向首部取元素
 print(l[5:1:-1])#['f', 'e', 'd', 'c']

 print(l[-1:-4:-2])#['g', 'e']

 #m n p 可以缺省
 #m不写从头开始取  n不写取到尾部 p不写默认为1
 print(l[::])#['a', 'b', 'c', 'd', 'e', 'f', 'g']
 print(l[:5:2])#['a', 'c', 'e']
 print(l[1::2])#['b', 'd', 'f']
 print(l[1:5])#['b', 'c', 'd', 'e']
 print(l[5:1])#[]

 # coding=utf8
 __author__ = 'SummerChill'

 #初始化字典
 dic=dict()
 dic={'a':'A','b':'B','c':'C'}

 #增加和修改
 dic['c']='New'
 dic['d']='D'
 #删除指定的key
 dic.pop('b')
 print(dic)#{'a': 'A', 'c': 'New', 'd': 'D'}

 #查询 dic['g'] 如果key不存在则会报错 dic.get(key,defaultvalue)
 #如果有默认值在key不存在的情况下会返回默认值
 #print(dic['g'])#报错  KeyError: 'g'

 print(dic.get('g','defalut'))#defalut
 print(dic.get('a','defalut'))#A
 print(dic.get('g'))#None

 #判断是否包含key
 print(dic.has_key('g'))#False

 #list中的元素为tuple类型。
 print(dic.items())#[('a', 'A'), ('c', 'New'), ('d', 'D')]
 #list 其中的元素就是key或者value本身
 print(dic.keys())#['a', 'c', 'd']
 print(dic.values())#['A', 'New', 'D']

 ##############set  元素不能重复  重复的会自动过滤
 s=set()
 s=set([1,2,3,4,1,2,3])
 print(s)#set([1, 2, 3, 4])

 #增加元素
 s.add(6)
 #删除元素
 s.remove(2)

 #print(s[1]) NO !!!!!!!!!!!!!
 # 'set' object does not support indexing

 #想把2改为6 分两步
 # s.remove(2)  s.add(6)
 print(s)#set([1, 3, 4, 6])
 #set 转为list
 l=list(s)
 print(l)#[1, 3, 4, 6]
 #list 转为set
 s=set(l)
 print(s)#set([1, 3, 4, 6])

 #遍历set的元素
 for i in s:
     print(i)# 1  3  4  6

 s.clear()

 # coding=utf8
 __author__ = 'SummerChill'

 sl=[1,2,3]
 sd={'a':'A','b':'B'}

 #列表生成式  从一个或者多个集合中遍历得到元素然后再筛选计算得到一个新的list
 #for   if
 #sl中元素分别平方组成新的元素
 l=[x*x for x in sl if x%2==0]
 print(l)#[4]
 l2=[x*x for x in sl]
 print(l2)#[1, 4, 9]
 #sd 里面的key和value组合成一个list。key value组合['a A','b B']
 l=[ k+' '+v for k,v in sd.items()]
 print(l)#['a A', 'b B']
 print(sd.items())#[('a', 'A'), ('b', 'B')]

 #复合循环
 l=[x*y for x in sl for y in sl if x+y>=3]
 print(l)#[2, 3, 2, 4, 6, 3, 6, 9]

 l=[x*x for x in [1,2,3,4,5,6]]
 print(l)#[1, 4, 9, 16, 25, 36]

 ###列表生成器 并没有生成一个列表
 g=(x*x for x in [1,2,3,4,5,6])
 #用next(g) 读取生成器的元素 但是如果遍历到末尾再查询会报错
 #print(next(g))#1
 #print(next(g))#4
 #print(next(g))#9
 #print(next(g))#16
 #print(next(g))#25
 #print(next(g))#36
 #print(next(g))#到这个地方报错...g中的元素都找完了.

 for i in g:
     print(i) # 1  4  9  16  25  36

 l=[1,2,3]
 t=(1,2,3)
 d={'a':'A','b':'B'}
 s=set([1,2,3])

 #默认的遍历
 #遍历元素本身
 for i in l:
     print(i)#1  2  3
 for i in t:
     print(i)#1  2  3
 for i in s:
     print(i)#1  2  3
 #对于字典 默认遍历的是key
 for i in d:
     print(i)#a b

 for k,v in d.items():
     print(k,v)#('a', 'A') ('b', 'B')
 for k in d.keys():
     print(k)#a b
 for v in d.values():
     print(v)#A B
 ###############################
 #迭代
 #dict
 # d.iteritems()
 # d.iterkeys()
 # d.itervalues()
 for k ,v in d.iteritems():
     print(k,v)#('a', 'A') ('b', 'B')
 for k in d.iterkeys():
     print(k)#a b
 for v in d.itervalues():
     print(v)#A B

 ##其他的集合：使用iter函数构造一个迭代器
 print(l)#[1, 2, 3]
 for i in iter(l):
     print(i)#1 2 3

 print(t)#(1, 2, 3)
 for i in iter(t):
     print(i)#1 2 3

 print(s)#set([1, 2, 3])
 for i in iter(s):
     print(i)#1 2 3

 #遍历时候加上索引 通过enumerate
 print(l)#[1, 2, 3]
 for i,v in enumerate(l):
     print(i,v)#(0, 1) (1, 2) (2, 3)

 print(t)#(1, 2, 3)
 for i,v in enumerate(t):
     print(i,v)#(0, 1) (1, 2) (2, 3)

 print(s)#set([1, 2, 3])
 for i,v in enumerate(s):
     print(i,v)#(0, 1) (1, 2) (2, 3)

 #dict 遍历的是key
 print(d)#{'a': 'A', 'b': 'B'}
 for i,k in enumerate(d):
     print(i,k,d.get(k))#(0, 'a', 'A') (1, 'b', 'B')

 #for i in range(10)类似与for(int i=0;i<10;i++;)