列表

Python中列表是可变的，这是它区别于字符串和元组的最重要的特点，一句话概括即：列表可以修改，而字符串和元组不能。

li = ['USA',True,123,[75,'Jess']]
print(li)

#list.append()
li.append('ECUST')
print(li)

#list.extend()
li1 = [1,2,3]
li.extend(li1)
print(li)

#list.insert()
li.insert(0,'Elephant')
print(li)

#list.remove()
li.remove(True)
print(li)

#list.pop()
li.pop(2)
print(li)

#list.clear()
li.clear()
print(li)
li = ['USA',True,123,[75,'Jess']]

#list.index()
print(li.index('USA'))

#list.count()
print(li.count(123))

#list.sort()
li2 = [2,5,8,1,13,2]
print(li2)
li2.sort()
print(li2)

#list.reverse()
li.reverse()
print(li)

#list.copy()
li3 = li.copy()
print(li3)

['USA', True, 123, [75, 'Jess']]
['USA', True, 123, [75, 'Jess'], 'ECUST']
['USA', True, 123, [75, 'Jess'], 'ECUST', 1, 2, 3]
['Elephant', 'USA', True, 123, [75, 'Jess'], 'ECUST', 1, 2, 3]
['Elephant', 'USA', 123, [75, 'Jess'], 'ECUST', 1, 2, 3]
['Elephant', 'USA', [75, 'Jess'], 'ECUST', 1, 2, 3]
[]
0
1
[2, 5, 8, 1, 13, 2]
[1, 2, 2, 5, 8, 13]
[[75, 'Jess'], 123, True, 'USA']
[[75, 'Jess'], 123, True, 'USA']

#将列表当作堆栈使用
'''
列表方法使得列表可以很方便的作为一个堆栈来使用，堆栈作为特定的数据结构，最先进入的元素最后一个被释放（后进先出）。用 append() 方法可以把一个元素添加到堆栈顶。用不指定索引的 pop() 方法可以把一个元素从堆栈顶释放出来。
'''
stack = [1,2,3,4]
print(stack)
stack.append(5)
print(stack)
stack.append(7)
print(stack)
stack.pop()
stack.pop()
print(stack)
stack.pop()
print(stack)

[1, 2, 3, 4]
[1, 2, 3, 4, 5]
[1, 2, 3, 4, 5, 7]
[1, 2, 3, 4]
[1, 2, 3]

#将列表当作队列使用
'''
也可以把列表当做队列用，只是在队列里第一加入的元素，第一个取出来；但是拿列表用作这样的目的效率不高。在列表的最后添加或者弹出元素速度快，然而在列表里插入或者从头部弹出速度却不快（因为所有其他的元素都得一个一个地移动）。
'''
from collections import deque

queue = deque([1,2,3,4])
print(queue)
queue.append('jess')
print(queue)
queue.popleft()
print(queue)
queue.popleft()
print(queue)

deque([1, 2, 3, 4])
deque([1, 2, 3, 4, 'jess'])
deque([2, 3, 4, 'jess'])
deque([3, 4, 'jess'])

#列表推导式

'''
列表推导式提供了从序列创建列表的简单途径。通常应用程序将一些操作应用于某个序列的每个元素，用其获得的结果作为生成新列表的元素，或者根据确定的判定条件创建子序列。

每个列表推导式都在 for 之后跟一个表达式，然后有零到多个 for 或 if 子句。返回结果是一个根据表达从其后的 for 和 if 上下文环境中生成出来的列表。如果希望表达式推导出一个元组，就必须使用括号。
'''
li = [7,8,9]
li2 = [3 * x for x in li]
print(li2)
li3 = [(12,x) for x in li]
print(li3)

#对序列里每一个元素逐个调用某方法
li = ['  USA ','  ECUST','Canada st   ']
print(li)
li1 = [weapon.strip() for weapon in li]
print(li1)

#可以用 if 子句作为过滤器
li = [7,5,3,111,22,3]
print(li)
li1 = [2 * x for x in li if x % 3 == 0]
print(li1)
li2 = [7 + x for x in li if not x > 100]
print(li2)

#关于循环和其他技巧
l1 = [1,2,3,4]
l2 = [3,4,7,8]
l3 = [[x,y,x * y]for x in l1 for y in l2]
print(l3)
l4 = [l1[i] * l2[i] for i in range(len(l1))]
print(l4)

#列表推导式可以使用复杂表达式或嵌套函数
li = [str(round(355/113,i))for i in range(10)]
print(li)

[21, 24, 27]
[(12, 7), (12, 8), (12, 9)]
['  USA ', '  ECUST', 'Canada st   ']
['USA', 'ECUST', 'Canada st']
[7, 5, 3, 111, 22, 3]
[6, 222, 6]
[14, 12, 10, 29, 10]
[[1, 3, 3], [1, 4, 4], [1, 7, 7], [1, 8, 8], [2, 3, 6], [2, 4, 8], [2, 7, 14], [2, 8, 16], [3, 3, 9], [3, 4, 12], [3, 7, 21], [3, 8, 24], [4, 3, 12], [4, 4, 16], [4, 7, 28], [4, 8, 32]]
[3, 8, 21, 32]
['3.0', '3.1', '3.14', '3.142', '3.1416', '3.14159', '3.141593', '3.1415929', '3.14159292', '3.14159292']

#嵌套列表解析
matrix = [
    [1,2,3,4],
    [2,3,4,5],
    [4,5,6,7]
]

#矩阵转置
m1 = [[row[i] for row in matrix]for i in range(4)]
print(m1)

#另一种方法
transposed = []
for i in range(4):
    transposed.append([row[i] for row in matrix])
    
print(transposed)

#另另一种方法
transposed = []
for i in range(4):
    transposed_row = []
    for row in matrix:
        transposed_row.append(row[i])
    transposed.append(transposed_row)
    
print(transposed)

[[1, 2, 4], [2, 3, 5], [3, 4, 6], [4, 5, 7]]
[[1, 2, 4], [2, 3, 5], [3, 4, 6], [4, 5, 7]]
[[1, 2, 4], [2, 3, 5], [3, 4, 6], [4, 5, 7]]

#del语句
#使用 del 语句可以从一个列表中依索引而不是值来删除一个元素。这与使用 pop() 返回一个值不同。可以用 del 语句从列表中删除一个切割，或清空整个列表（我们以前介绍的方法是给该切割赋一个空列表）。

li = [x for x in range(10)]
print(li)

del(li[0])
print(li)
del(li[2:4])
print(li)
del(li[:])
print(li)
del li
print(li)

[0, 1, 2, 3, 4, 5, 6, 7, 8, 9]
[1, 2, 3, 4, 5, 6, 7, 8, 9]
[1, 2, 5, 6, 7, 8, 9]
[]



---------------------------------------------------------------------------

NameError                                 Traceback (most recent call last)

<ipython-input-76-1b3796e5a005> in <module>()
     12 print(li)
     13 del li
---> 14 print(li)


NameError: name 'li' is not defined

元祖和序列

t = 123,456,679
print(t)
t1 = t,23456
print(t1)

(123, 456, 679)
((123, 456, 679), 23456)

集合

集合是一个无序不重复元素的集。基本功能包括关系测试和消除重复元素。

可以用大括号({})创建集合。注意：如果要创建一个空集合，你必须用 set() 而不是 {} ；后者创建一个空的字典，下一节我们会介绍这个数据结构。

basket = {'apple', 'orange', 'apple', 'pear', 'orange', 'banana'}
print(basket)
if 'orange' in basket:
    print('yes')
    
a = set('ashdfsaihdAL')
b = set('sdaygassaduihf')
print(a)
print(b)
print(a&b)
print(a-b)
print(a|b)
print(a^b)

#集合也支持推导式
a = {x for x in 'afgaosifsahudua' if x not in 'aaifgsafh'}
print(a)

{'orange', 'pear', 'banana', 'apple'}
yes
{'d', 'A', 'a', 'f', 'i', 'L', 'h', 's'}
{'d', 'g', 'y', 'a', 'i', 'f', 'h', 'u', 's'}
{'d', 'a', 'i', 'f', 'h', 's'}
{'L', 'A'}
{'d', 'g', 'A', 'y', 'a', 'f', 'i', 'L', 'h', 'u', 's'}
{'g', 'y', 'A', 'L', 'u'}
{'d', 'u', 'o'}

字典

另一个非常有用的 Python 内建数据类型是字典。

序列是以连续的整数为索引，与此不同的是，字典以关键字为索引，关键字可以是任意不可变类型，通常用字符串或数值。

理解字典的最佳方式是把它看做无序的键=>值对集合。在同一个字典之内，关键字必须是互不相同。

一对大括号创建一个空的字典：{}。

tel = {'XUhuan':123,'Zheng':333,'He':555}
print(tel)

tel['Feng'] = 777
print(tel)

tel['He'] = 888
print(tel)

print(tel['Zheng'])

del tel['Zheng']
print(tel)

l = list(tel.keys())
print(l)
l = tuple(tel.keys())
print(l)

print(sorted(tel.values()))

if 'He' in tel:
    print('yes')
    
#构造函数 dict() 直接从键值对元组列表中构建字典。
x = dict([('Xu',True),['He',123]])
print(x)

#字典推导可以用来创建任意键和值的表达式词典
t = {x:y for x in 'abs' for y in [1,2,3]}
print(t)

#如果关键字只是简单的字符串，使用关键字参数指定键值对有时候更方便
dict(sape=4139, guido=4127, jack=4098)
s = {'sape': 4139, 'jack': 4098, 'guido': 4127}
print(s)

{'XUhuan': 123, 'Zheng': 333, 'He': 555}
{'XUhuan': 123, 'Zheng': 333, 'He': 555, 'Feng': 777}
{'XUhuan': 123, 'Zheng': 333, 'He': 888, 'Feng': 777}
333
{'XUhuan': 123, 'He': 888, 'Feng': 777}
['XUhuan', 'He', 'Feng']
('XUhuan', 'He', 'Feng')
[123, 777, 888]
yes
{'Xu': True, 'He': 123}
{'a': 3, 'b': 3, 's': 3}
{'sape': 4139, 'jack': 4098, 'guido': 4127}

#遍历技巧

#在字典中遍历时，关键字和对应的值可以使用 items() 方法同时解读出来
tel = {'XU':123,'HE':234,'Feng':284}
for k,v in tel.items():
    print(k,v)
    
#在序列中遍历时，索引位置和对应值可以使用 enumerate() 函数同时得到
x = [123,True,'Xuhuan',[1,2,3]]
for i,v in enumerate(x):
    print(i,v)
    
#同时遍历两个或更多的序列，可以使用 zip() 组合
questions = ['name','quest','favorite color']
answers = ['lancelot','the holy grail','blue']
for q,a in zip(questions,answers):
    print(q,a)
    print('What is your {0}? It is {1}'.format(q,a))
    
#要反向便利一个序列，首先指定这个序列，然后调用reversed()函数
for i in reversed(x):
    print(i)
    
#要按顺序遍历一个序列，使用 sorted() 函数返回一个已排序的序列，并不修改原值
x = [2,5,8,4.2,5.3,7,5,8]
for i in sorted(x):
    print(i)

XU 123
HE 234
Feng 284
0 123
1 True
2 Xuhuan
3 [1, 2, 3]
name lancelot
What is your name? It is lancelot
quest the holy grail
What is your quest? It is the holy grail
favorite color blue
What is your favorite color? It is blue
[1, 2, 3]
Xuhuan
True
123
2
4.2
5
5
5.3
7
8
8