MOOC —— Python语言基础与应用 by 北京大学 第四章 数据类型（二）

这章内容有点多，但大同小异。多练习几次就好

16、列表和元组

列表（list）：中括号括起来的， []， [1,2,3]，[‘abc’，(1,2,3),4,5]
元组(tuple)：小括号括起来的，()，(1,)只有一个元素时，要加逗号，(1,2,[1,2])
假设这里有个元组 atuple = (1,2,3,4,5,6), 它的索引如下

元组( tuple)	1,	2 ,	3,	4,	5,	6
索引正向	0	1	2	3	4	5
索引反向	-6	-5	-4	-3	-2	-1

len()：求列表元组大小, 如 len(atuple) = 6
切片：a[start: end :step]，如atuple[2:5:2] = (3, 5)

查找：
x in list/tuple：判断某个元素是否 存在于列表/元组中, 如3 in atuple = True
list.index(x)：指定的数据 x 在列表/元组的哪个位置，如 atuple.index(4) = 3
list.count(x)：指定的数据在列表/元组里出现了几次，如 atuple.count(4) = 1

计算：
sum：将元素相加, 如 sum(atuple) = 28
min/max：返回最小/最大的元素，字符根据acsii码比较大小

删除：
pop（i=n）：默认为0时，删除最后一个元素或当（i=n）时，删除第n个元素，并返回其值
remove(x)：将列表里的第一个 x 删除
clear：a.clear()，清空列表
del list[i]：删除第 i 个元素

>>> a = ['狼人','预言家','平民','女巫','狼人','平民','狼人']
>>> a.pop()              # 此时a = ['狼人','预言家','平民','女巫','狼人','平民']
'狼人'
>>> a.pop(2)             # 此时a = ['狼人', '预言家', '女巫', '狼人', '平民']
'平民'
>>> a.remove('狼人')      # 此时a = ['预言家', '女巫', '狼人', '平民']
>>> del a[2]             # 此时a = ['预言家', '女巫', '平民']
>>> a.clear()            # 此时a = []

增加：
append(x)：追加单个元素
insert(index,x)：在索引处插入元素
extend([3,4])：追加另一个列表

>>> a = [1,2]
>>> a.append(3)
>>> a
[1, 2, 3]

>>> a.extend([3,4])
>>> a
[1, 2, 3, 3, 4]

>>> a.insert(1,9)
>>> a
[1, 9, 2, 3, 3, 4]

替换：
给索引赋值即可

>>> a = [1,2,3]    # 注意里面的数字没带引号，数据类型为int，都是整型
>>> a[-1] = 'K'
>>> a
[1,2,'K']

重排：
reverse: 将列表中元素反转排列

>>> a = [1,6,7,9,2]
>>> a.reverse()
>>> a
[2, 9, 7, 6, 1]

sort(): 把列表中的元素按大小顺序排列，可选参数reverse=True，将排序后的列表再反转排列

>>> a = [1,6,7,9,2]
>>> a.sort()
>>> a
[1, 2, 6, 7, 9]
>>> a.sort(reverse=True)
>>> a
[9, 7, 6, 2, 1]

---

reversed（<序列>）：反转列表并生成新的列表，原列表不变，返回的是一个叫迭代器的东西， 这东西先记住，简单来说就是这个器里面装的是可以被for…in…进行遍历的可迭代对象。
sorted（<可迭代对象>）：按大小排序并生成新的列表，原列表不变

>>> a = [2,5,1,4,3]
>>> reversed(a)
<list_reverseiterator object at 0x00000242B110C470>
>>> list(reversed(a))    # 把可迭代对象变成列表
[3, 4, 1, 5, 2]
>>> tuple(reversed(a))
(3, 4, 1, 5, 2)          # 把可迭代对象变成元组
>>> sorted(a)
[1, 2, 3, 4, 5]
>>> a                    # 无论 reserverd 还是 sorted，a 还是原来的样子
[2, 5, 1, 4, 3]

合并：
+：加法是合并两个列表/元组，生成新列表/元组
*：列表的乘法是复制的意思，生成新列表/元组

>>> a = [1,2]
>>> b = [3,4]
>>> a + b
[1, 2, 3, 4]
>>> a
[1, 2]
>>> a*3
[1, 2, 1, 2, 1, 2]
>>> a
[1, 2]
>>> 

---

17、字典

字典用的是大括号，这点必须 记住
dict = {key:value,key1:value1…}
其中key 是键，value是对应key的值，他们是一一对应关系，用冒号连接，用key来索引value
字典是可变的，我们可以进行增加，删除等操作
我们先定义以下字典

student = {'大哥': '玄德','二哥':'云长','三弟':'翼德'}
teacher = {'军师':'孔明'}

增加字典
update，或直接添加，key=value方式

>>> student.update(teacher)
>>> student
{'大哥': '玄德', '二哥': '云长', '三弟': '翼德', '军师': '孔明'}
>>> student['凤雏']='庞统'
>>> student
{'大哥': '玄德', '二哥': '云长', '三弟': '翼德', '军师': '孔明', '凤雏': '庞统'}

访问字典：
dict[key]：标签索引访问
get(key)：标签索引访问
keys()：返回字典中的所有标签
values()：返回字典中的所有数据值
items()：将每个数据项表示为二元元组，返回 所有的数据项。

>>> student['大哥']
'玄德'
>>> student.get('军师')
'孔明'
>>> student.keys()
dict_keys(['大哥', '二哥', '三弟', '军师', '凤雏'])
>>> student.values()
dict_values(['玄德', '云长', '翼德', '孔明', '庞统'])
>>> student.items()
dict_items([('大哥', '玄德'), ('二哥', '云长'), ('三弟', '翼德'), ('军师', '孔明'), ('凤雏', '庞统')])

查找：
in: 判断是否在字典的key里，注意是key，不是value,要看是否在value，要配合values函数

>>> '大哥'in student
True
>>> '玄德' in student
False
>>> '玄德' in student.values()
True

缩减字典
del：删除指定标签的数据项
pop: 删除指定标签的数据项并返回值
popitem: 删除并返回最后一个数据项
clear：清空字典

>>> del student['凤雏']
>>> student
{'大哥': '玄德', '二哥': '云长', '三弟': '翼德', '军师': '孔明'}
>>> student.pop('军师')
'孔明'
>>> student.popitem()
('三弟', '翼德')
>>> student.clear()
>>> student
{}

18、集合

集合最大的特点：不重复，无序，利用这特性，经常用于去除重复的数据项
创建用 {} 或者 set()，可以把列表，元组转换成集合
我们先定义如下集合

aset = {1,2,3}
bset = {'a','b','c'}

增长集合：add/update

>>> aset.add(4)
>>> aset
{1, 2, 3, 4}
>>> aset.update(bset)
>>> aset
{1, 2, 3, 4, 'c', 'a', 'b'}

缩减集合：
remove：删除指定元素，如果元素不在集合中，会报错
discard：删除指定元素，如果元素不在集合中，不报错
pop：删除任意数据并返回
clear：清空集合

>>> aset.remove('b')   
>>> aset.discard('c')   # 如果元素不在集合中，不报错
>>> aset
{1, 2, 3, 4, 'a'}
>>> aset.pop()
1
>>> aset.clear()
>>> aset
set()

访问集合，跟列表大同小异，就不多说了
in
pop

迭代循环
for a in aset:

集合的运算：
这里引用嵩天老师的Ppt，跟我一样，数学都丢了的看看

操作符及应用	描述
S | T	并，返回一个新集合，包括在集合S和T中的所有元素
S - T	差，返回一个新集合，包括在集合S但不在T中的元素
S & T	交，返回一个新集合，包括同时在集合S和T中的元素
S ^ T	补，返回一个新集合，包括集合S和T中的非相同元素
S <= T 或 S < T	返回True/False，判断S和T的子集关系
S >= T 或 S > T	返回True/False，判断S和T的包含关系

19、可变类型与不可变类型

不可变类型： 整数、浮点数、复数、字符串、逻辑值、元组
可变：列表、字典、集合。注意如果b = 可变类型，那么b会跟着可变类型里元素的改变而改变

>>> a = [1,2,3,4]
>>> b = a
>>> a[0]='hello'
>>> b
['hello', 2, 3, 4]

20、建立复杂的数据结构

都可以通过[]访问列表，元组和字典的元素，其中对于字典，[]里对应的是key，返回的是value
可以通过嵌套列表元组和字典，建立大型数据结构，如地图坐标

>>> poi = {(100，100)：'北京'，(200,200):'上海',(300,300):'深圳'}
>>> poi[(100,100)]
'北京'

21、 输入与输出

input() : 由用户输入，返回的是字符串，字符串，字符串！
print([object,…][,sep=’’][,end=’\n’][,file=sys.stdout])：
sep: 表示变量之间用什么字符串隔开，缺省是空格
end: 表示以这个字符结尾，缺省为换行
file：指定了文本将要发送到的文件、标准流或其它类似文件的对象，默认是sys.stdout
格式化字符串： ‘%d %s’ % (value1,value2)

22、上机练习

列表、元组基本操作练习：
+, *, len(), [], in

列表、元组高级操作练习：
mylist=[1,2,3,4,5] 切片：获得[2,3,4]，获得[3,4,5]，获得[3,2,1]， 获得[1,3,5]
mytpl=(1,2,3,4,5)同上操作
t=‘Mike and Tom’
用split拆分、join合成为’Mike/and/Tom’

集合基本操作：
a=set([1,2,3,4,5])
b=set([2,4,6,8,10])
并、交、差、异或、子集
添加、删除、是否空集

字典基本操作：
mydict={1:‘Mon’, ‘line1’:3332}
添加、删除、是否空字典
取字典所有的key／value
判断key是否存在

测验题

1、

a=[3] 
alist=[1,2,3,4,5] 
print(a in alist)

上述代码的运行结果是（）。

A. False
B. 1
C. True
D. 0

2、

alist=sorted([1,2,3],reverse=True)
blist=reversed([1,2,3])
print(alist==blist)

上述代码的运行结果是（）。

A. 1
B. True
C. False
D. 0

3、

dict={'1':1,'2':2}
theCopy=dict
dict['1']=5 
sum=dict['1']+theCopy['1']
print(sum)

上述代码的输出结果是（）。

A. 6
B. 7
C. 10
D. 2

填空题
4、任意长度的Python列表、元组和字符串中最后一个元素的下标为____。

5、

alist=[1,2,3]
blist=alist*3
print(blist)

上述代码的输出结果是____。

6、

alist=[3,4,5,7,9,12,13,15,17]
blist=alist[3:7:2]
print(blist)

上述代码的输出结果是____。

7、

x={1:2}
x[2]=3
print(x)

上述代码的输出结果是____。

8、

x=[[]]*3
x[0].append(1)
print(x)

上述代码的输出结果是____。

9、

x=([1],[2])
x[0].append(1)
print(x)

上述代码的输出结果是____。

10、

alist=[1,1,2,3]
b=set(alist)
print(b)

上述代码的输出结果是____。

---

答案：

1. A
2. C
3. C
4. -1
5. [1, 2, 3, 1, 2, 3, 1, 2, 3]
6. [7, 12]
7. {1: 2, 2: 3}
8. [[1], [1], [1]]
9. ([1, 1], [2])
10. {1, 2, 3}