组合数据类型---Python语言程序设计笔记6（北理工mooc）

Python语言程序设计笔记6（北理工mooc）

组合数据类型

集合类型及操作

集合指多个元素的无序组合，与数学中集合的概念一致，每个元素唯一，不存在相同数据，且每个元素均不能是可变数据类型。
集合用{}表示，元素间用逗号分隔，使用set()和{}均可建立集合类型，其中建立一个空集合必须使用set()。如：

>>> A = {"python", 123, ("python", 123)}
>>> A
{('python', 123), 123, 'python'}
>>> B = set("pypypyw")
>>> B
{'y', 'w', 'p'}

使用set()函数可以将参数按每一个字符分隔为元素，且在生成的集合中会去掉重复的元素，该函数的参数也必须为字符串。

集合操作符

增强操作符：

增强操作符一般用于更新一个集合，若不使用增强操作符则可以生成新的集合。同样的，对于集合数据类型，s -= v可以用s = s - v来进行代替。

集合处理方法

s.pop()方法会弹出返回的元素，更新后的s为去掉弹出元素的原s集合。

集合数据类型可以作为for循环的遍历结构，但其中的顺序是不确定的（实际上是确定的，但是顺序无法利用）。
数据类型的转换：

>>> b = [1, 2, 3, 3]
>>> c = set(b)  #将b转换为集合类型
>>> b = list(c)  #将c转换为列表类型
>>> b
[1, 2, 3]

利用该段代码可以完成数据去重的操作。

序列类型及操作

序列为一组具有先后关系的元素。序列是一种一维向量，其元素的类型可以不同，元素间由序号引导，可以通过序号访问特定的元素。
序列类型可以分为以下几种数据类型：

• 字符串类型
• 元组类型
• 列表类型
  序号也存在正向递增序号和反向递减序号两种，同前面章节字符串的索引方法。
  序列类型通用操作符：
  
  

元组类型及操作

元组是一种序列类型，创建后无法修改。使用()和tuple()创建，元素间用逗号分隔，元组可以使用小括号也可以不使用小括号，如

def func():
    return 1,2

上述代码中return返回的两个值实际上被python作为元组数据处理，尽管没有使用小括号。

>>> creature = "a", "b", "c"
>>> creature
('a', 'b', 'c')
>>> s = (1, 2, creature)
>>> s
(1, 2, ('a', 'b', 'c'))
>>>

从这里可以看出元组的定义可以不用小括号，且元组也可以作为元组的元素。
元组实质上就是将元素进行有序的排列，并用小括号组织，和另外两种类型一样，元组继承了序列的所有通用操作。由于元组类型不能修改，因此也没有针对元组的特殊操作。

列表类型及其操作

列表是一种序列类型，创建后可被任意修改，使用[]或list()定义，元素间用逗号分隔，且列表中元素的类型可以不同，无长度限制。

>>> ls = ["cat", 2, "dog"]
>>> ls
['cat', 2, 'dog']
>>> lt = ls
>>> lt
['cat', 2, 'dog']

一个新的列表只能用[]和list定义，当利用上方的方式将列表赋值给一个变量时，实际上没有创建一个新的列表，只是将这个列表付给了一个新的名称，两个变量指向的是同一个列表
列表类型操作方法：

对列表和元组中数据的遍历：

for item in ls:
    <语句块>
"---------------------"
for item in tp:
    <语句块>    

基本统计值的计算

def GetNum():
    num = []
    while True:
        a = input("请输入一个数字，回车键结束：")
        if a != "":
            num.append(eval(a))
        else:
            break
    return num


def GetMean(num):
    total = 0
    for item in num:
        total += item
    mean = total / len(num)
    return mean


def GetDev(num):
    total2 = 0
    for item in num:
        total2 += pow(item, 2)
    dev = total2 / len(num)
    return dev


def GetMidNum(num):
    num = sorted(num)
    if len(num) % 2 == 0:
        MidNum = (num[len(num)//2-1])/2 + (num[len(num)//2])/2
    else:
        MidNum = num[(len(num)-1)//2]
    return MidNum


NUM = GetNum()
print("该组数据平均值为{}，方差为{}，中位数为{}。".format(GetMean(NUM), GetDev(NUM), GetMidNum(NUM)))

在上述程序中，sorted()可以将列表中的元素按从小到大的顺序进行排序，如下：

>>> a=[1, 2, 3, 4, 5, 9, 8, 7, 6]
>>> a
[1, 2, 3, 4, 5, 9, 8, 7, 6]
>>> sorted(a)
[1, 2, 3, 4, 5, 6, 7, 8, 9]

关于//的使用，在列表序号的运算需处要使用整数除，否则会出错提示数据类型不对，这是因为普通的除法得出来的结果是浮点数，但列表的序号只允许整数类型的数据，除此之外，也可以使用int()函数将浮点数转化为整数。
列表中数据的批量生成：

a = [i for i in range(1,10)]
b = [i**2 for i in range(8)]
print(a)
print(b)
----------------------
[1, 2, 3, 4, 5, 6, 7, 8, 9]
[0, 1, 4, 9, 16, 25, 36, 49]

字典类型及操作

映射：一种键（索引）与数值（数据）的对应。在序列类型中整数0、1、2…是数据的默认索引，在映射类型中索引由用户来定义，字典类型是映射的体现。
在字典中：

• 键值对：即一对键与数值的组合，键是索引的扩展。
• 字典是键值对的集合，键值对之间无序
• 字典采用{}和dict()创建，键值对用冒号表示,键值对之间用逗号隔开。如

{<键1>:<值1>,<键2>:<值2>,...<键n>:<值n>}

在字典变量中，可以用[]，通过键获取到值，也可以用来向字典变量中增加元素，如下：

>>> bbb = dict({"e":1, "f":2})
>>> bbb
{'e': 1, 'f': 2}
>>> sss = {"a":1, "b":2, "c":3}
>>> sss
{'a': 1, 'b': 2, 'c': 3}
>>> sss["a"]
1
>>> sss["a"] = 3
>>> sss
{'a': 3, 'b': 2, 'c': 3}
>> sss
{'a': 3, 'b': 2, 'c': 3}
>>> sss["d"] = 4
>>> sss
{'a': 3, 'b': 2, 'c': 3, 'd': 4}
>>> aaa = {}
>>> type(aaa)
<class 'dict'>
>>> aaa
{}

补充:

• 键只能是一个非可变量，因此可以用"a"、1等形式，但不能直接用a、b作为键，这是因为a、b等字符会被识别为变量名。
• 字典和集合都是用{}来表示，空字典可以直接用{}定义，但集合不行。
• type()函数可以返回一个变量的类型。

字典类型操作方法及函数

>>> aaa = {"a":1, "b":2, "c":3}
>>> aaa
{'a': 1, 'b': 2, 'c': 3}
>>> aaa.keys()
dict_keys(['a', 'b', 'c'])
>>> aaa.values()
dict_values([1, 2, 3])
>>> aaa.items()
dict_items([('a', 1), ('b', 2), ('c', 3)])

d.keys()和d.values()返回的信息分别是字典的key类型和value类型，不是列表类型，不能当作列表类型处理，但可以使用for…in…来进行遍历，d.items()同理。

元素的遍历：

for k in d:
    <语句块>