一、字符串
定义：它是一个有序的字符的集合，用于存储和表示基本的文本信息，' '或" "中间包含的内容称之为字符串
特性：
1.只能存放一个值
2.不可变
3.按照从左到右的顺序定义字符集合，下标从0开始顺序访问，有序
补充：
1.字符串的单引号和双引号都无法取消特殊字符的含义，如果想让引号内所有字符均取消特殊意义，在引号前面加r，如name＝r'l\thf'
2.unicode字符串与r连用必需在r前面，如name＝ur'l\thf'
字符串的创建：
"hello world"
字符串常用操作：
1、移除空白：
name = " michael,egon,jack"
print(name.strip()) #去掉行头和尾部的空格
"michael,egon,jack" #输出结果
2、分割：
name = "michael,egon,jack"
print(name.split(",")) #分割，以","为分隔符把一个字符串分割成列表
['michael', 'egon', 'jack'] #输出结果
3、长度：
name = "michael,egon,jack"
print(len(name)) #统计字符串的长度
17 #输出结果
4、索引：
name = "michael,egon,jack"
print(name.index("a")) #索引
4 #输出结果，找到第一个对应的值的下标返回值
5、切片：
name = "michael,egon,jack"
print(name[0:7]) #取出第一个名字，就是在[]里以":"分割左右分别写出元素对应的下标，默认从左往右取。记住“顾头不顾尾”
michael #输出结果
print(name[8:12]) #取出第二个名字
egon #输出结果
print(name[-4:]) #取出最后一个名字，从后面往前面数元素的下标，有几个元素，就写-（几个） 注意：要记住“顾头不顾尾”
jack #输出结果
6、步长：
string[start:end:step]的序列切片中，第一个“:”隔离了 起始索引 和 结束索引，第二个“：”隔离了 结束索引 和 步长
- step为正，则从左到右切片，如果start > end，则为空
- step为负，则从右到左切片，如果start < end，则为空
- start和end非同时为空，前者表示最开始的一个位，后者表示一直到最后一个，同时为空的时候，表示取所有。至于方向，还是取决于step的值。
可以总结一句规律：step为正表示从左到右切片，反之为从右到左，然后根据index依次切片。
name = "michael,egon,jack"
print(name[::3]) #取所有，step为3
mhlg,c #输出结果
print(name[12:3:-3]) #取索引3---12的元素，从右到左切片step为3 注意：记住“顾头不顾尾”
,gl #输出结果
二、列表
定义：[]内以逗号分隔，按照索引，存放各种数据类型，每个位置代表一个元素
特性：
1.可存放多个值
2.可修改指定索引位置对应的值，可变
3.按照从左到右的顺序定义列表元素，下标从0开始顺序访问，有序
列表的创建：
list_test=[’afg‘,12,'ok']
或
list_test=list('abc')
或
list_test=list([’afg‘,12,'ok'])
列表的常用操作：
1、索引：
names = ["michael","egon","jack","alex","tom"]
print(names.index("jack")) #检索“jack”的下标值
2 #输出结果
2、切片：
names = ["michael","egon","jack","alex","tom"]
print(names[0:4])#通过下标找出列表中的元素0---3给切出来
['michael', 'egon', 'jack', 'alex'] #输出结果
3、追加：
names = ["michael","egon","jack","alex","tom"]
names.append("rose") #追加内容
print(names) #输出列表names
['michael', 'egon', 'jack', 'alex', 'tom', 'rose'] #输出结果，最后一个位追加的内容
还有一种追加的方式：insert() 函数用于将指定对象插入列表的指定位置。
注意：该方法没有返回值，但会在列表指定位置插入对象。
names = ["michael","egon","jack","alex","tom"]
names.insert(2,"jerry") #可以在指定位置添加元素，因为没有返回值，所以此时不用打印输出
print(names) #打印输出结果
['michael', 'egon', 'jerry', 'alex', 'jack', 'tom'] #输出结果
4、删除：
第一种方法：pop() 函数用于移除列表中的一个元素（默认最后一个元素），并且返回该元素的值。
names = ["michael","egon","jack","alex","tom"]
print(names.pop(3)) #删除，指定删除下标位为3的元素
alex #输出结果
print(names.pop()) #默认删除最后一个
tom #输出结果
第二种方法：remove() 函数用于移除列表中某个值的第一个匹配项。该方法没有返回值但是会移除两种中的某个值的第一个匹配项。
names = ["michael","egon","jack","alex","tom","egon"]
print(names.remove("egon")) #删除egon，匹配列表中第一个对应的元素，后面的不会影响
None #输出结果
print(names.remove("rose")) #删除rose，因为列表没有这个元素，so，会报错“rose”没在列表中
print(names) #输出删除后的names的值
['michael', 'jack', 'alex', 'tom', 'egon'] #输出的结果
第三种方法：使用 del 语句来删除列表的的元素。
names = ["michael","egon","jack","alex","tom",'egon']
del names[3:5] #实际删除下标位3到5的元素，注意：最后一个5删不了，记住“顾头不顾尾”
['michael', 'egon', 'jack', 'egon'] #输出结果
del names[-3:] #删除倒数第三至最后一个
['michael', 'egon', 'jack'] #输出结果
还有一种 clear() 函数用于清空列表，该方法没有返回值，类似于del list[:]。
names = ["michael","egon","alex","jack","tom"]
names.clear() #清空列表names
print("清空后的列表:",names) #输出打印结果
清空后的列表: [] #注意：此时列表names里的元素被清空了，但是列表names还是存在的
5、长度：
len() 方法返回列表元素个数。
names = ["michael","egon","jack","alex","tom"]
print(len(names)) #统计列表的元素个数
5 #输出结果
6、循环：
第一种：这个迭代names,并且每次迭代取names的值到 i 这个变量里。
names = ["michael","egon","jack","alex","tom"]
for i in names:
print(i)
michael #以下这几个都是列表里的值
egon
jack
alex
tom
第二种：这个也是类似,只是每次迭代取索引的值到 i 这个变量里。
names = ["michael","egon","jack","alex","tom"]
for i in range(len(names)):
print(i,names[i])
0 michael
1 egon
2 jack
3 alex
4 tom
总结：这两种用起来区别不大,用第一个的话是用不到索引的时候用,后面这个是用到索引的时候用,其他的实际用那个看个人需求了。
7、包含：在python中可以通过in和not in关键字来判读一个list中是否包含一个元素。
names = ["michael","egon","jack","alex","tom"]
if "michael" in names: #判断“michael”是否在names列表里
print("%s in the names"%("michael")) #在的话，打印输出结果
if "rose" not in names: #判断“rose”是否在names列表里
print("%s is not in the names"%("rose")) #不在的话，打印输出结果
michael in the names #输出结果
rose is not in the names #输出结果
三、元组
定义：与列表类似，只不过［］改成（）。
特性：
1、可存放多个值
2、不可变
3、按照从左到右的顺序定义元组元素，下标从0开始顺序访问，有序
元组的创建： （注意：元组中只包含一个元素时，需要在元素后面添加逗号）
ages = (11, 22, 33, 44, 55)
或
ages = tuple((11, 22, 33, 44, 55))
print(ages)
(11, 22, 33, 44, 55) #输出结果
a = (11,) #只有一个元素的时候，后面要加“,”标识
print(a)
(11,) #输出结果
元组常用操作：
1、索引：
ages = (11,22,33,"a","b","c")
print(ages.index("a")) #索引"a"元素的下标
3 #输出结果
2、切片：
ages = (11,22,33,"a","b","c") #注意：在取值的时候一定要记住“顾头不顾尾”
print(ages[:3]) #取元组的最开始到下标索引为2的元素
(11, 22, 33) #输出结果
print(ages[2:4]) #取下标索引为2到3的元素
(33, 'a') #输出结果
print(ages[-3:]) #取元组的后三个元素
('a', 'b', 'c') #输出结果
print(ages[-3:-1]) #取从元组的倒数第三个元素开始取到倒数第一个（不包含最后一个）
('a', 'b') #输出结果
3、循环：
同上列表的循环
4、长度
len() 方法返回元组元素个数。
ages = (11,22,33,"a","b","c")
print(len(ages)) #统计元组元素的个数
6 #输出结果
5、包含：（同列表一样）
ages = (11,22,33,"a","b","c")
if 22 in ages: #判断22是否在names列表里
print("%s in the ages"%(22)) #在的话，打印输出结果
if "e" not in ages: #判断“e”是否在names列表里
print("%s is not in the names"%("e")) #不在的话，打印输出结果
22 in the ages #输出结果
e is not in the names #输出结果
6、删除：
ages = (11,22,33,"a","b","c")
del ages #删除元组
print(ages) #打印输出元组
NameError: name 'ages' is not defined #输出报错，此元组不存在
四、字典
定义：字典是另一种可变容器模型，且可存储任意类型对象。键必须是唯一的，但值则不必。值可以取任何数据类型，但键必须是不可变的，如字符串，数字或元组。
｛key1:value1,key2:value2｝,key-value结构，key必须可hash
特性：
1.可存放多个值
2.可修改指定key对应的值，可变
3.无序
字典的创建：
person = {"name": "michael", 'age': 18}
person = dict(name='michael', age=18)
person = dict({"name": "michael", 'age': 18})
person = dict((['name','michael'],['age',18]))
{}.fromkeys(seq,100) #不指定100默认为None
注意：
dic = {}.fromkeys(["k1","k2"],11) #创建字典dic
{'k1': 11, 'k2': 11} #输出结果
字典的常用操作：
- len(d)返回d中项（键-值对）的数量；
- d[k]返回关联到k上的值；
- d[k]=v将值v关联到键k上；
- del d[k]删除键为k的项；
- k in d检查d中是否有含键为k的项。
1、clear
clear方法清除字典中所有的项，这是个原地操作，无返回值（或者说返回none）。
dic = {"k1":"v1","k2":"v2","k3":"v3"}
dic.clear() #清空字典
print(dic) #打印输出
{} #输出结果
2、cope
copy方法返回一个具有相同键-值对的新字典（这个方法实现的是浅复制，因为值本身是相同的，而不是副本）
在副本中替换值时，原始字典不受影响，但是如果修改了某个值，原始字典会改变。
>>> x = {'a':1,'b':[2,3,4]}
>>> y = x.copy()
>>> y['a'] = 5 #替换key对应value值
>>> y['b'].remove(3) #修改了“b”对应的value值
>>> y
{'a':5,'b':[2,4]} #被修改的字典
>>> x
{'a':1,'b':[2,4]} #原字典输出的结果，替换的值没变，修改的变了
避免这个问题的方法是使用深度复制-deepcopy()，复制其包含所有的值。
>>> x = {'a':1,'b':[2,3,4]}
>>> y = x.copy()
>>> z = x.deepcopy() #x深cope成z
>>> x['a'].append(5) #对原文件进行操作
>>> y
{'a':1,5,'b':[2,3.4]} #浅cope的值发生了改变
>>> z
{'a':1,'b':[2,3,4]} #深cope的值没有发生改变
3、get：
get方法是个更宽松的访问字典项的方法。当使用get访问一个不存在的键时，会得到None值。还可以自定义“默认”值，替换None。
>>> d = {}
>>> print d.get('name') #默认为None
None
>>> d.get("name",'N/A') #自定义为'N/A'
'N/A'
>>> d[''name] = 'Eric' #给字典d赋值
>>> d.get('name') #当键存在，输出键对应的值
'Eric' #输出结果
4、has_key
has_key方法可以检查字典中是否含有给出的键。d.has_key(k)
>>> d = {}
>>> d.has_key('name')
False
5、items和iteritems
items方法将所有的字典项以列表方式返回，但是列表中的每一项(键,值)返回时并没有特殊的顺序。
iteritems方法的作用大致相同，但是会返回一个迭代器对象而不是列表：
>>> d = {'a':1,'b':2,'c':3}
>>>d.items
[('a',1),('b',2),('c',3)]
>>> it = d.iteritems()
>>> it
<dictionary-iteritems object at 169050>
>>> list(it)
[('a',1),('b',2),('c',3)]
6、pop
pop方法用来获得对应给定键的值，然后将这个键-值对从字典中移除。
>>> d = {'a':1,'b':2,'c':3}
>>> d.pop('a') #删除a及对应的值
>>> d
{'b':2,'c':3} #输出结果
7、popitem
popitem方法会弹出随机项，并没有顺序的概念。若想一个接一个地移除并处理项，这个方法就非常有效了。
>>> d = {'a':1,'b':2,'c':3}
>>> d.popitem() #随机删除一个键、值
>>> d
{'a':1,'c':3} #输出结果
8、setdefault
setdefault方法在某种程度上类似于get方法，就是能够获得与给定键相关联的值，还能在字典中不含有给定键的情况下设定相应的键值。
>>> d = {}
>>> d.setdefault('name','N/A')
'N/A'
>>> d
{'name': 'N/A'}
>>> d.setdefault('name',A)
'N/A'
9、update
update方法可以利用一个字典项更新另一个字典。提供的字典项会被添加到旧的字典中，若有相同的键则会进行覆盖。
>>> d = {'a':1,'b':2,'c':3}
>>> x = {'a':5,'d':6}
>>> d.update(x)
>>> d
{'a': 5, 'c': 3, 'b': 2, 'd': 6} #遇到相同的键会覆盖对应的value的值
10、values
values方法以列表的形式返回字典中的值（itervalues返回值的迭代器），与返回键的列表不同的是，返回值列表中可以包含重复的元素。
>>> d = {}
>>> d[1]=1
>>> d[2]=2
>>> d[3]=3
>>> d[4]=1
>>> d
{1: 1, 2: 2, 3: 3, 4: 1}
>>> d.values()
[1, 2, 3, 1] #值可以重复
五、集合
定义：由不同元素组成的集合，集合中是一组无序排列的可hash值，可以作为字典的key
基本功能：是进行成员关系测试和删除重复元素。
特性：集合的目的是将不同的值存放到一起，不同的集合间用来做关系运算，无需纠结于集合中单个值
可以使用大括号({})或者 set()函数创建集合，注意：创建一个空集合必须用 set() 而不是 { }，因为 { } 是用来创建一个空字典。
集合分类：可变集合、不可变集合
可变集合(set)：可添加和删除元素，非可哈希的，不能用作字典的键，也不能做其他集合的元素
不可变集合(frozenset)：与上面恰恰相反
集合的创建：
由于集合没有自己的语法格式，只能通过集合的工厂方法set()和frozenset()创建
{1,2,3,1}
或
定义可变集合set
>>> set_test=set('hello')
>>> set_test
{'l', 'o', 'e', 'h'}
改为不可变集合frozenset
>>> f_set_test=frozenset(set_test)
>>> f_set_test
frozenset({'l', 'e', 'h', 'o'})
访问集合：
由于集合本身是无序的，所以不能为集合创建索引或切片操作，只能循环遍历或使用in、not in来访问或判断集合元素。
student = ({'Tom', 'Jim', 'Mary', 'Tom', 'Jack', 'Rose'})
print("Tom" in student) #判断“Tom”是否在集合student中
True #真，在集合student里
print("Egon" in student) #判断“Egon”是否在集合student中
False #假，不在集合student里
for i in student: #循环输出集合student中的所有元素
print(i) #以下是输出结果
Mary
Jim
Tom
Jack
Rose
集合常用操作：关系运算
1、in 和 not in：
student = ({'Tom', 'Jim', 'Mary', 'Tom', 'Jack', 'Rose'})
print(student) # 输出集合，重复的元素被自动去掉
{'Mary', 'Rose', 'Tom', 'Jim', 'Jack'} #输出结果
# 成员测试
if('Rose' in student) :
print('Rose 在集合中')
else :
print('Rose 不在集合中')
2、等于（==）和不等于（!=）:
a = {1,2,3}
b = {1,2,3,4,5}
print(a == b)
False
print(a != b)
True
3、大于(>)与小于(<)和大于等于(>=)于小于等于(<=)：注意：小于（用函数表示 .issubset()） 大于（用函数表示 .issuperset()）
a = {1,2,3}
b = {1,2,3,4,5}
print(a <= b) #判断a小于或等于b
True
print(a < b) #判断a小于b
print(a.issubset(b)) #a是b的子集
print(b.issuperset(a)) #b是a的超集True
print(a >= b) #判断a大于或等于b
False
print(a > b) #判断a大于b
False
4、交集：intersection()，简写符(&)
a = {1,2,3}
b = {1,2,3,4,5}
print(a.intersection(b)) #交集
print(a & b) #交集的简写
{1, 2, 3} #输出a与b的交集
5、并集：union()，简写符( | )
a = {1,2,3}
b = {1,2,3,4,5}
print(a.union(b)) #并集 两个合在一起
print(a | b) #并集的简写
{1, 2, 3, 4, 5} #输出a与b的并集
6、差集：difference()，简写符（-）
a = {1,2,3}
b = {1,2,3,4,5}
print(a.difference(b)) #差集 a相对于b不一样的打印出a有b没有的
print(a - b) #差集的简写
set() #因为a不包含b，so，为空
print(b.difference(a)) #差集 b相对于a不一样的打印出b有a没有的
print(b - a) #差集的简写
{4, 5} #打印出相差的部分
7、对称差分：symmetric_difference()，简写符（^）
a = {1,2,3,6,7}
b = {1,2,3,4,5}
print(a.symmetric_difference(b)) #对称差分 把a和b中不在的都打印出来
print(a ^ b) #对称差分的简写
{4, 5, 6, 7} #输出结果
注意：集合之间and,or
a = {1,2,3,6,7}
b = {1,2,3,4,5}
print(a and b) #取b的值
{1, 2, 3, 4, 5}
print(a or b) #取a的值
{1, 2, 3, 6, 7}
8、子集和超集： .issubset() 和 .issuperset()
a = {1,2,3}
b = {1,2,3,4,5}
print(a.issubset(b)) #a是b的子集 ，是真为True，反之亦然。
True
print(a.issuperset(b)) #b是a的超集， 是假为False，反之亦然。
False
集合更新：
可使用以下内建方法来更新：注意：只有可变集合才能更新。
- a.add()
- a.update()
- a.remove()
- a.discard()
- a.pop()
a = {1,2,3,6,7}
a.add(8) #在集合a里添加一个元素“8”
print(a) #打印输出
{1, 2, 3, 6, 7, 8} #输出结果
a = {1,2,3,6,7}
c = {6,,7,8,9}
a.update(c) #更新a集合，将c集合的元素添加到a中，注意：集合是天然去重的。
print(a)
{1, 2, 3, 6, 7, 8, 9}
a = {1,2,3,6,7}
a.remove(6) #移除集合a中的元素“6”，如果被移除的元素不存在时，会报错。
print(a)
{1, 2, 3, 7}
a = {1,2,3,6,7}
a.discard(9) #删除指定元素，但是如果要删除的不在集合里不会报错。
print(a)
{1, 2, 3, 7}
a = {1,2,3,6,7}
print(a.pop()) #随机删除
1 #随机删除的结果