列表和元组
1.列表基本操作
1.1 列表赋值
a = [1,2,3,4,5,6,7,8]
a[0] = 100 #the result ： [100, 2, 3, 4, 5, 6, 7, 8]
1.2 元素删除
a = [1,2,3,4,5,6,7,8]
del a[0] #the result ： [2, 3, 4, 5, 6, 7, 8]
1.3 分片赋值
a = [1,2,3,4,5,6,7,8]
a[::2] # [1, 3, 5, 7]
a[-2:] # [7, 8]
a[1:1] = [0,0,0] # the result : [1, 0, 0, 0, 2, 3, 4, 5, 6, 7, 8]
1.4 使用 for i in range(10,-1,-1) 生成列表
for i in range(10,-1,-1):
# 开始位置（10），结束位置（-1）， 步长（-1）
print i,
# 打印结果：10 9 8 7 6 5 4 3 2 1 0
# 从10开始，每次向后取一个值，直到遇到结束位置 -1
2.列表方法
2.1 append
作用：append用于在列表末尾追加新的对象
a = [1,2,3]
a.append(4) #the result ： [1, 2, 3, 4]
2.2 count
作用：count方法统计某个元素在列表中出现的次数
a =['aa','bb','cc','aa','aa']print(a.count('aa')) #the result ： 3
2.3 extend
作用：extend方法可以在列表的末尾一次性追加另一个序列中的多个值
a = [1,2,3]
b = [4,5,6]
a.extend(b) #the result ：[1, 2, 3, 4, 5, 6]
2.4 index
作用：index函数用于从列表中找出某个值第一个匹配项的索引位置
a = [1,2,3,1]``print(a.index(1)) #the result ： 0`
2.5 insert
作用： insert方法用于将对象插入到列表中
a = [1,2,3]``a.insert(0,``'aa'``) #the result : [``'aa'``, 1, 2, 3]`
2.6 pop
作用：pop方法会移除列表中的一个元素（默认是最后一个），并且返回该元素的值
a = [1,2,3]``a.pop() #the result ： [1, 2]``a.pop(0)`
2.7 remove
作用：remove方法用于移除列表中某个值的第一个匹配项
a = ['aa','bb','cc','aa']
a.remove('aa') #the result ： ['bb', 'cc', 'aa']
2.8 reverse
作用：reverse方法将列表中的元素反向存放
a = ['a','b','c']a.reverse() #the result ： ['c', 'b', 'a']
2.9 sort
作用：sort方法用于在原位置对列表进行排序，意味着改变原来的列表，让其中的元素按一定顺序排列
a = ['a','b','c',1,2,3]
a.sort() #the result ：[1, 2, 3, 'a', 'b', 'c']
2.10 enumrate
li = [11,22,33]
for k,v in enumerate(li, 1):
print(k,v)
2.11 range和xrange 指定范围，生成指定的数字
注：python3中的range类似python2中的xrange，比如a = range(1,4) : a返回的不是列表对象而是一个可迭代对象（<class ‘range’>）
#1、range根据start与stop指定的范围以及step设定的步长，生成一个序列：range([start,] stop[, step])``#2、xrange 用法与 range 完全相同，所不同的是生成的不是一个list对象，而是一个生成器for i in range(1,10,2):
print(i)`
2.12 列表去空
#方法1：
filter(None, your_list)
#方法2：
while '' in your_list:
your_list.remove('')
#方法3：
your_list = [x for x in your_list if x != '']
3.元组定义：元组和列表一样，也是一种序列，唯一的不同是元组不能修改。
3.1 创建元组举例
#1. 创建元组
a = (1,2,3,4,5,6)
#2. 将列表转换成元组
tuple([1,2,3,4]) #the result ： (1, 2, 3, 4)
4.列表和元组常用函数
com(x,y) 比较两个值
len(seq) 返回序列的长度
list(seq) 把序列转换成列表
max(args) 返回序列或者参数集合中得最大值
min(args) 返回序列或者参数集合中的最小值
reversed(seq) 对序列进行反向迭代
sorted(seq) 返回已经排列的包含seq 所有元素的列表
tuple(seq) 把序列转换成元组
字符串
1.字符串格式化
1.1 使用百分号（%）字符串格式化
num = 100
print("%d to hex is %x"%(num, num)) #100 to hex is 64
print("%d to hex is %#x"%(num, num)) #100 to hex is 0x64
1.2 使用format字符串格式化
#1. 位置参数
print("{0} is {1} years old"
.format("tom", 28))
#tom ``is` `28 years old``print(``"{} is {} years old"``.format(``"tom"``, 28)) #tom ``is` `28 years old``print(``"Hi, {0}! {0} is {1} years old"``.format(``"tom"``, 28)) #Hi, tom! tom ``is` `28 years old` `#2. 关键字参数``print(``"{name} is {age} years old"``.format(name = ``"tom"``, age = 28)) #tom ``is` `28 years old` `#3. 下标参数``li = [``"tom"``, 28]``print(``"{0[0]} is {0[1]} years old"``.format(li)) #tom ``is` `28 years old`
2.字符串方法
2.1 find方法
作用：find方法可以在一个较长的字符串中查找子串，他返回子串所在位置的最左端索引，如果没有找到则返回-1
a='abcdefghijk'
print(a.find('abc'))
#the result ： 0
print(a.find('abc',10,100)) #the result ： 11 指定查找的起始和结束查找位置
2.2 join方法
作用：join方法是非常重要的字符串方法，他是split方法的逆方法，用来连接序列中的元素，并且需要被连接的元素都必须是字符串。
a = [``'1'``,``'2'``,``'3'``]``print(``'+'``.``join``(a)) #the result ： 1+2+3
2.3 split方法
作用：这是一个非常重要的字符串，它是join的逆方法，用来将字符串分割成序列
print(``'1+2+3+4'``.split(``'+'``)) #the result ： [``'1'``, ``'2'``, ``'3'``, ``'4'``]
2.4 strip
作用：strip 方法返回去除首位空格（不包括内部）的字符串
print(``" test test "``.strip())
#the result ：“test test”
2.5 replace
作用：replace方法返回某字符串所有匹配项均被替换之后得到字符串
print(``"This is a test"``.replace(``'is'``,``'is_test'``))
#the result ： This_test is_test a test
2.6 首字母大写
>>> s = ``'aBdkndfkFFD'``>>> s.capitalize()``'Abdkndfkffd'`
2.7 Pinyin 模块，将汉字转换成拼音
from xpinyin import Pinyin
while True:
p = Pinyin()
fullname =raw_input('name：').strip() fullname = fullname.decode('utf8')
print(fullname)
xin = fullname[0]
ming = fullname[1:]
name = ming + ``'.'` `+ xin
username = p.get_pinyin(name, '')
print username
print username + '@yiducloud.cn
字典
1.字典基本使用
1.1 键类型：字典的键不一定为整形数据，键可以是任意的不可变类型，比如浮点型（实行），字符串或者元组。 ### 1.2 自动添加：即使键起初在字典中不存在，也可以为他赋值，这样字典就会建立新的项。而（在不适用append方法或者其他类似操作的情况下）不能将值关联到列表之外的索引上。
phonebook = {``'Tom'``:8777,``'Jack'``:9999,``'Fly'``:6666}
print(``"Tom's Phonenumber is %(Tom)s"` `% phonebook)
#Tom's Phonenumber ``is` `8777`
2.字典常用方法
2.1 clear
作用：clear方法清除字典中所有的项，这是一个原地操作，所以无返回值（或则说返回None）
d = {}``d[``'Tom'``]=8777``d[``'Jack'``]=9999``
print(d)
#the result : {``'Jack'``: 9999, ``'
Tom'``: 8777}``
d.clear()``print(d)
#the result : {}`
2.2 copy
作用：copy方法返回一个具有相同 ”键-值” 对的新字典，而不是副本
d = {'Tom':8777,'Fly':6666}
a = d.copy()
a['Tom'] = '改变后的值'
print(d)
#{``'Fly'``: 6666, ``'Tom'``: 8777}
print(a)
#{``'Fly'``: 6666, ``'Tom': '改变后的值'}
2.3 fromkeys
作用：fromkeys方法使用给定的键建立新的字典，每个键都对应一个默认的值None。
首先建造一个空字典，然后调用它的fromkeys方法，建立另一个字典
print({}.fromkeys(['name','age']))
#the result ： {``'age'``: None, ``'name'``: None}`
### 2.4 get
作用：get方法是个更宽松的访问字典项的方法，如果试图访问字典中不存在的项时不会报错仅会 返回：None
```python
d = {``'Tom'``:8777,``'Jack'``:8888,``'Fly'``:6666}
print(d.``get``(``'Tom'``))
#the result ： 8777``
print(d.``get``(``'not_exist'``))
#the result ： None`
2.5. for循环字典的三种方法
d = {`Tom':8777,'Jack':8888,'Fly':6666}
for` k,v in d.items():
print(k,v)
for` k in d.values():
print(k)
for` k in d.keys():
print(k)
2.6 pop
作用：pop方法用于获得对应与给定键的值，然后将这个”键-值”对从字典中移除
d = {'Tom':8777,'Jack':8888,'Fly':6666}
v = d.pop('Tom')
print(v)
#8777
2.7 popitem
① popitem方法类似于list.pop，list.pop会弹出列表的最后一个元素，但是popitem仅仅会弹出随机的项，因为字典没有”最后的元素”或则其他有关顺序的概念
② 所以想一个接一个的移除并处理字典中的项，popitem是非常有效的（因为不用获取键的列表）
③ 尽管popitem和列表的pop方法很类似，但是字典中没有与append等价的方法，因为字典是无序的，类似于append得方法是没有任何意义的
d = {'Tom':8777,'Jack':8888,'Fly':6666}
d.popitem()
2.8 setdefault
作用：setdefault方法在某种程度上类似于get方法，能够获得与给定键相关联的值，除此之外，setdefault还能在字典中不含有给定键的情况下设定相应的键值
d = {'Tom':8777,'Jack':8888,'Fly':6666}
d.setdefault(``'Tom'``)
#the result ： 8777
print(d.setdefault('Test'))
#the result ： None
print(d)
#{'Fly': 6666, 'Jack': 8888, 'Tom': 8777, 'Test': None}
2.9 update
作用：update方法可以利用一个字典项更新另一个字典，提供的字典中的项会被添加到旧的字典中，如有相同的键则会被覆盖
d = {'Tom':8777,'Jack':8888,'Fly':6666}``
a = {'Tom':110,'Test':119}
d.update(a)
prin t(d)
#the result ：{'Fly': 6666, 'Test': 119, 'Jack': 8888, 'Tom': 110}
2.10 将两个列表组合成字典
keys = ['a', 'b']
values = [1, 2]
#1、zip生成字典print(dict(zip(keys,values))) # {'a': 1, 'b': 2}
#2、for循环推倒字典
print({keys[i]: values[i]
for i in range(len(keys))})
# {'a': 1, 'b': 2}
集合
1.集合作用
1.1 去重
1.2 取两个列表的交集
1.3 取两个列表的并集
list_1 = [1,2,3,4,5,1,2]
#1、去重(去除list_1中重复元素1,2)
list_1 = set(list_1)
#去重： {1, 2, 3, 4, 5}
print(list_1)
list_2 = set([4,5,6,7,8])
#2、交集（在list_1和list_2中都有的元素4,5）
print(list_1.intersection(list_2))
#交集： {4, 5}`
#3、并集（在list_1和list_2中的元素全部打印出来，重复元素仅打印一次）
print(list_1.union(list_2))
#并集： {1, 2, 3, 4, 5, 6, 7, 8}
#4、差集
print(list_1.difference(list_2))
#差集：在list_1中有在list_2中没有： {1, 2, 3}
print(list_2.difference(list_1))
#差集：在list_1中有在list_2中没有： {8, 6, 7}
#5、子集
print(list_1.issubset(list_2))
#子集： False List_1中的元素是否全部在list2中
#6、父集
print(list_1.issuperset(list_2))
#父集： False List_1中是否包含list_2中的所有元素
#7、交集
print(list_1 & list_2)
#交集 {4, 5}
#8、union并集
print(list_1 | list_2)
#并集： {1, 2, 3, 4, 5, 6, 7, 8}
#9、difference差集
print(list_1 - list_2) #差集： {1, 2, 3}
#10、在集合中添加一个元素999
list_1.add(999)
print(list_1)
#Add()方法：
{1, 2, 3, 4, 5, 999}
#11、删除集合中任意一个元素不会打印删除的值
list_1.pop()
#Pop()方法：
无返回值
#12、discard删除集合中的指定元素，如过没有则返回None
print(list_1.discard("ddd"))
#Discard()方法： 删除指定的值，没有返回None