Python（可变不可变类型，list，tuple，dict，set）
补充：（可⽤操作技巧）
>>> x=900
>>> y=900
>>> x==y
True
>>> type(x) is type(y)
True
>>> x is y
False
>>> id(x)
3107344641872
>>> id(y)
3107344907216
#is 左边的是否是右边的，is⽐较的是id ⽽‘==’⽐较的是值
====================================================================
x=1 ⽆返回值
a=b=c=d=3
x,y两个变量交换值
x,y=y,x
增量赋值
x+=1
…
…
====================================================================python index函数
解压序列类型
s='hello'
a,b,c,d,e=s #将s[0]、s[1]……分别赋值给abcde
a,_,_,_,e=s  #_只⽤下划线，默认为：要丢弃的变量，所以只有a，e赋值。
print(a,e)
a,*_,e='alex'#只要第⼀个，最后⼀个
a,b,*_
*_,a,b
>>> s='aksjdfhkajsdfhksajdfhkasjdfh'
>>> a,*_,b=s
>>> print(a,b)
a h
>>> *_,a,b=s
>>> print(a,b)
f h
#_ 可以是任意变量名，但是需要时合法变量名
===============================================================
%s 可以跟任意类型。%d 跟的是数字，但是得到的都是字符串
================================================================
whil else
for else
===> 正常while执⾏完之后执⾏⼀次else （如果 break、continue 不跳过最后⼀次循环的话）
补充：（enumerate）
enumerate函数⽤于遍历序列中的元素以及它们的下标，多⽤于在for循环中得到计数,enumerate参数为可遍历的变量，如字符串，列表等⼀般情况下对⼀个列表或数组既要遍历索引⼜要遍历元素时，会这样写：
1 2for i in range(0,len(list)):  print i ,list[i]
但是这种⽅法有些累赘，使⽤内置enumerrate函数会有更加直接，优美的做法，先看看enumerate的定义：
1 2 3 4 5 6def enumerate(collection):
'Generates an indexed series: (0,coll[0]), (1,coll[1]) ...'  i =0
it =iter(collection)
while1:
yield(i, it.next())
6 7  yield(i, it.next())    i +=1
enumerate会将数组或列表组成⼀个索引序列。使我们再获取索引和索引内容的时候更加⽅便如下：
1 2for index，text in enumerate(list):  print index ,text
代码实例1：
1 2 3 4 5i =0
seq =['one', 'two', 'three'] for element in seq:
print i, seq[i]
i +=1
0 one
1 two
2 three
代码实例2：
1 2 3seq =['one', 'two', 'three']
for i, element in enumerate(seq):    print i, seq[i]
# prin i ，element效果⼀样
0 one
1 two
2 three
代码实例3：
1 2for i,j in enumerate('abc'):    print i,j
0 a
1 b
2 c
不可变对象
可变、不可变
可变/不可变类型，指的是：内存id不变，type也不变的前提下，value是否是可变的。int（）和str（）都是不可变类型
列表、字典是可变类型
对于可变对象，⽐如list，对list进⾏操作，list内部的内容是会变化的，⽐如：>>> a = ['c', 'b', 'a']
>>> a.sort()
>>> a
['a', 'b', 'c']
⽽对于不可变对象，⽐如str，对str进⾏操作呢：
>>> a = 'abc'
>>> a.replace('a', 'A')
'Abc'
>>> a
'abc'
虽然字符串有个replace()⽅法，也确实变出了'Abc'，但变量a最后仍是'abc'，应该怎么理解呢？
我们先把代码改成下⾯这样：
>>> a = 'abc'
>>> b = a.replace('a', 'A')
>>> b
'Abc'
>>> a
'abc'
要始终牢记的是，a是变量，⽽'abc'才是字符串对象！有些时候，我们经常说，对象a的内容是'abc'，但其实是指，a本⾝是⼀个变量，它指向的对象的内容才是'abc'：
当我们调⽤a.replace('a', 'A')时，实际上调⽤⽅法replace是作⽤在字符串对象'abc'上的，⽽这个⽅法虽然名字叫replace，但却没有改变字符串'abc'的内容。相反，replace⽅法创建了⼀个新字符串'Abc'并返回，如果我们⽤变量b指向该新字符串，就容易理解了，变量a仍指向原有的字符
串'abc'，但变量b却指向新字符串'Abc'了：
所以，对于不变对象来说，调⽤对象⾃⾝的任意⽅法，也不会改变该对象⾃⾝的内容。相反，这些⽅法会创建新的对象并返回，这样，就保证了不可变对象本⾝永远是不可变的。
各数据类型分类：
存放值的个数：
  ⼀个值：数字、字符串
  多个值（容器类型）：列表、元组、字典
取值⽅式：
  直接取值：数字
  序列类型：字符串、元组、列表
  映射类型：字典
bool（布尔值）
布尔值
bool（）
条件判断⾃⾏调⽤bool（）函数，将数据转为bool值
#只有 0、none、空的bool值为FALSE
list（列表）
列表常⽤操作
索引
切⽚
l[2:5]
追加
l.append()  #最后追加
插⼊
l.insert(0,'alex')  (位置，加⼊的东西）
删除
l.pop()  #pop(索引）索引为整数，没参数默认删除最后⼀个
pop（）有返回值，返回的是刚刚删除的元素
  del l[索引]
长度
len()  #不能统计数字长度，只能统计序列类型的数据的长度
切⽚
循环
包含
in：
l=['a','b','c']
a in l
msg = 'abcdf'
d in msg
>>> msg = 'aksjdfhaksjdfh'
>>> a in msg
True
>>> 'sjd'in msg
True
>>>
l.sort()  #从⼩到⼤排序，直接操作列表，⽆返回值，reverse=True，从⼤到⼩
===================================================
去重：
l=list(set(l))
利⽤集合去重，这样会改变列表顺序
如何不改变顺序：
空集合 l_2=[]
遍历 l ，如果元素不在 l_2 中，就append
Python内置的⼀种数据类型是列表：list。list是⼀种有序的集合，可以随时添加和删除其中的元素。
⽐如，列出班⾥所有同学的名字，就可以⽤⼀个list表⽰：
>>> classmates = ['Michael', 'Bob', 'Tracy']
>>> classmates
['Michael', 'Bob', 'Tracy']
变量classmates就是⼀个list。⽤len()函数可以获得list元素的个数：
>>> len(classmates)
3
⽤索引来访问list中每⼀个位置的元素，记得索引是从0开始的：
>>> classmates[0]
'Michael'
>>> classmates[1]
'Bob'
>>> classmates[2]
'Tracy'
>>> classmates[3]
Traceback (most recent call last):
File "<stdin>", line 1, in <module>
IndexError: list index out of range
当索引超出了范围时，Python会报⼀个IndexError错误，所以，要确保索引不要越界，记得最后⼀个元素的索引是len(classmates) - 1。如果要取最后⼀个元素，除了计算索引位置外，还可以⽤-1做索引，直接获取最后⼀个元素：
>>> classmates[-1]
'Tracy'
以此类推，可以获取倒数第2个、倒数第3个：
>>> classmates[-2]
'Bob'
>>> classmates[-3]
'Michael'
>>> classmates[-4]
Traceback (most recent call last):
File "<stdin>", line 1, in <module>
IndexError: list index out of range
当然，倒数第4个就越界了。
list是⼀个可变的有序表，所以，可以往list中追加元素到末尾：
>>> classmates.append('Adam')
>>> classmates
['Michael', 'Bob', 'Tracy', 'Adam']
也可以把元素插⼊到指定的位置，⽐如索引号为1的位置：
>>> classmates.insert(1, 'Jack')
>>> classmates
['Michael', 'Jack', 'Bob', 'Tracy', 'Adam']
要删除list末尾的元素，⽤pop()⽅法：
>>> classmates.pop()
'Adam'
>>> classmates
['Michael', 'Jack', 'Bob', 'Tracy']
要删除指定位置的元素，⽤pop(i)⽅法，其中i是索引位置：
>>> classmates.pop(1)
'Jack'
>>> classmates
['Michael', 'Bob', 'Tracy']
要把某个元素替换成别的元素，可以直接赋值给对应的索引位置：
>>> classmates[1] = 'Sarah'
>>> classmates
['Michael', 'Sarah', 'Tracy']
list⾥⾯的元素的数据类型也可以不同，⽐如：
>>> L = ['Apple', 123, True]
list元素也可以是另⼀个list，⽐如：
>>> s = ['python', 'java', ['asp', 'php'], 'scheme']
>>> len(s)
4
要注意s只有4个元素，其中s[2]⼜是⼀个list，如果拆开写就更容易理解了：
>>> p = ['asp', 'php']
>>> s = ['python', 'java', p, 'scheme']
要拿到'php'可以写p[1]或者s[2][1]，因此s可以看成是⼀个⼆维数组，类似的还有三维、四维……数组，不过很少⽤到。
如果⼀个list中⼀个元素也没有，就是⼀个空的list，它的长度为0：
>>> L = []
>>> len(L)
tuple（元组）
元组常⽤操作
t.index  #查索引
索引
切⽚
t.[2:5]
循环
长度
包含
另⼀种有序列表叫元组：tuple。tuple和list⾮常类似，但是tuple⼀旦初始化就不能修改，⽐如同样是列出同学的名字：
>>> classmates = ('Michael', 'Bob', 'Tracy')
现在，classmates这个tuple不能变了，它也没有append()，insert()这样的⽅法。其他获取元素的⽅法和list是⼀样的，你可以正常地使⽤classmates[0]，classmates[-1]，但不能赋值成另外的元素。
不可变的tuple有什么意义？因为tuple不可变，所以代码更安全。如果可能，能⽤tuple代替list就尽量⽤tuple。
tuple的陷阱：当你定义⼀个tuple时，在定义的时候，tuple的元素就必须被确定下来，⽐如：
>>> t = (1, 2)
>>> t
(1, 2)
如果要定义⼀个空的tuple，可以写成()：
>>> t = ()
>>> t
()
但是，要定义⼀个只有1个元素的tuple，如果你这么定义：
>>> t = (1)
>>> t