列表是Python最常用的数据类型，是以一个方括号内的逗号分隔值出现，列表内的数据项不必相同。
如果我们收到一个"Give Me 5!“的字符串信息。O(∩_∩)O.
s = "Give Me 5!"
以下代码会为我们生成一个与之相关的列表。
列表推导式 s1=[x for x in s] 生成 ['G', 'i', 'v', 'e', ' ', 'M', 'e', ' ', '5', '!'] 从这我们可以看到列表内的元素确实可以不同。
列表推导式是从另外一个列表经过处理生成新列表的方法，这个方法由自己选用。
例1： s = [2017, 600776, 2592, 2811, 600775]
s1 = [str(x).zfill(6) for x in s] 生成 ['002017', '600776', '002592', '002811', '600775]
例2：s = [1,2, 3, 4, 5],s1 = ['a','b','c','d','e']
s2 =[(x,y) for x,y in zip(s,s1)] 生成 [(1, 'a'), (2, 'b'), (3, 'c'), (4, 'd'), (5, 'e')]
例3: s = os.listdir(os.getcwd())
s1=[x for x in s if x.endswith(".ipynb") ] 生成 ['thskp.ipynb', 'ths.ipynb', 'caa.ipynb']
这其实是当前文件夹下文件类型是.ipynb的文件列表，是不是很有趣呢。
例4: s=['hoooyannn','luuuwooo']
s1 = ['163.com','qq.com']
s2 = [m+"@"+n for m in s for n in s1] 生成 ['hoooyannn@163.com', 'hoooyannn@qq.com', 'luuuwooo@163.com', 'luuuwooo@qq.com']
这里实际上是两层循环，生成了两个列表列表项的组合，试试吧。
例5：s1= [1,2, 3, 4, 5] s2= [3, 4, 5,6,7]
s = [x for x in s1 if x not in s2]
这实际上是s1和s2的差集
例6：s1= [1,2, 3, 4, 5] s2= [3, 4, 5,6,7]
s = [x for x in s1 if x in s2]
这实际上是s1和s2的交集
内置函数str.split s2 = s.split(" ") 生成 ['Give', 'Me', '5!'] split()中的参数是分割的标志，这里是以空格为分割。
内置函数list() 可以把其它可迭代元素转换成一个列表
假如我们有如下一个Series对象 s = pd.Series(data=['002017', '600776', '002592', '002811', '600775'],name='code')
0 002017
1 600776
2 002592
3 002811
4 600775
Name: code, dtype: object
将它转换为一个列表对象 s = list(s) 将生成 ['002017', '600776', '002592', '002811', '600775']
可以用来转换任何可迭代的对象，如元组，字典，集合都是常见的可迭代对象。
当前也可以直接定义列表对象。 s =['I','Love','Python'] ，一对方括号内定义逗号分隔的不同项，就是列表类型。
列表常用操作
append：
s= ['Give', 'Me', '5!']
s.append("Thanks!")
那么会得到 s= ['Give', 'Me', '5!', 'Thanks!']
insert:
s= ['Give', 'Me', '5!']
s.insert(0,"Please")
s.insert(-1,"best")
那么会得到 s=['Please', 'Give', 'Me', 'best', '5!']
remove:
s = ['hoooyannn@163.com', 'hoooyannn@qq.com', 'luuuwooo@163.com', 'luuuwooo@qq.com']
s2 = ['luuuwooo@163.com', 'luuuwooo@qq.com']
for x in s2:
s.remove(s2)
那么会得到s = ['hoooyannn@163.com', 'hoooyannn@qq.com']
pop:
s= ['Give', 'Me', '5!']
m = s.pop()
会得到 s=['Give', 'Me'] m= '5!'
可利用该特性使用列表定义一个堆栈。
extend:
s1 = ['luuuwooo@163.com', 'luuuwooo@qq.com']
s2 = ['hoooyannn@163.com', 'hoooyannn@qq.com']
s1.extend(s2)
会得到 s1=['luuuwooo@163.com', 'luuuwooo@qq.com', 'hoooyannn@163.com', 'hoooyannn@qq.com']
s2不变。
index：
s= ['Please','Give', 'Me', '5!']
m = s.index(‘Give')
会得到 m = 1 该列表中’Give'出现的位置索引。如果参数项在列表中不存在，会出现异常，所以最好先用in,
not in，或者s.count('Give')先做判断。
reverse:
s=['Enough','is','enough']
s.reverse()
得到s=['enough', 'is', 'Enough']
总结起来就是，如果想删除列表末尾项，用pop,删除指定项，用remove，获取指定项的索引用index。
使插入的元素在列表末尾用append，指定插入元素的位置用insert，如果增加来自另外一个列表的
列表项用extend。
改变现有列表可用reverse反转。
列表扩展
使用列表构造一个堆栈，堆栈具有后进先出(LIFO)的特征。
class Stack():
"""
stack is a last in first out
data structure
"""
def __init__(self,size):
"""
A stack is a last in first out
data structure
:type size:int
"""
self.size = size
self.stack=[]
self.top=-1
# Getter function
@property
def size(self):
return self._size
# Setter function
@size.setter
def size(self, value):
if not isinstance(value, int):
raise TypeError('Expected a int')
if not value > 0:
raise ValueError('Expected value bigger than zero')
self._size= value
# Deleter function
@size.deleter
def size(self):
raise AttributeError("Can't delete attribute")
def push(self,x):
"""
push an object to stack
the object is placed at the last position
:type x: an object that is to be pushed to the stack
"""
if self.isfull():
raise Exception("the stack is full now")
else:
self.stack.append(x)
def pop(self):
"""
return the last pushed objected from stack
and delete it from the stack
"""
if self.isempty():
raise KeyError("the stack is empty")
else:
self.top = self.top -1
self.stack.pop()
def peek(self):
"""
return the item at the top of the stack
raise keyerror if the stack is empty
"""
if self.isempty():
raise KeyError("the stack is empty")
return self.stack[len(self.stack)-1]
def isfull(self):
"""
if the stack is full with object return True
otherwise return False
"""
return self.top +1 == self.size
def isempty(self):
"""
if no object in the stack return True
otherwise return False
"""
return self.top -1 == -1
def show(self):
"""
display the objects in stack
"""
print (self.stack)
def clear(self):
"""
delete all objects from the stack
"""
self.stack=[]
self.top=-1
def __iter__(self):
"""
visit items from top to bottom of stack
"""
length = len(self.stack)
for i in range(length):
yield self.stack[length-i-1]
在这里实现了固定大小的堆栈，并且在初始化时检查参数类型。
实验一下：
s = Stack(10)
for i in range(5):
s.push(i)
s.show() 显示 [0, 1, 2, 3, 4]
m = iter(s)
for i in range(len(s)):
print(next(m))
列表和字符串的转换：
l= ['Please','Give', 'Me', '5!']
s = " ".join(l)
这样我们将列表还原成了字符串，实际生成s="Please Give Me 5!"
列表的并集，差集，交集：
有如下两个list:
listA=["apple","banana","pears","tomato"]
listB=["tomato","chilli"]
交集：
inte = list(set(listA).intersection(set(listB)))
并集:
uni = list(set(listA).union(set(listB)))
差集:
diff = list(set(listA).difference(set(listB)))
