Python学习系列(五)——组合数据类型

Python学习系列(五)——基础语法终稿

——————————————————————————

    写完这章，Python的基本语法就搞定了，然而似乎python的重点在于它各种各样的库，接下来就是整理python常见的库开发了，以及，库和这些基本语法搭配起来一起使用，最好的去解决问题。

$1.$概述

    $1.1$ 序列类型：元素之间可以相同，但有先后顺序，通过序号来访问元素。

    $1.2$ 集合类型：就是高中学过的集合，元素之间无序，但元素有唯一性。

    $1.3$ 映射类型：表示为“键-值”对，比如对于$y=x^{2}$，$x$是键的话，当$x=2$时，被映射为$4$。

$2.$序列类型

    比较常见的序列类型有字符串、元组、列表，字符串在之前已经讲过了；对于元组，生成后是固定的，不能修改也不能替换；列表可以修改，使用较为灵活。但是，只要是序列类型，都会遵循索引规则，看下图：

    $2.1$元组类型。元组类型是一种不可修改的数据类型，因此在固定数据、函数多返回值、多变量同步赋值，循环遍历的情况下占有优势。

    示例1：

>>> Animal = "cat", "dog", "tiger","elephant"
>>> Animal
('cat', 'dog', 'tiger', 'elephant')
>>> Biology = "botany", "Animal"
>>> Biology
('botany', 'Animal')
>>> Biology = "botany", Animal
>>> Biology
('botany', ('cat', 'dog', 'tiger', 'elephant'))
>>> Biology[0]       #索引
'botany'
>>> Biology[-1][1]   #索引
'dog'

    示例2：

>>> def func(x):        #函数多返回值
    return x, x ** 2

>>> import math     #计算各点到原点距离
>>> for x, y in ((1,2),(2,3),(3,4)):
    print(math.hypot(x, y))

>>> a, b = b, a    #多变量赋值

    $2.2$ 列表类型。对于元组类型，列表是一种可修改的数据类型，使用相对灵活，可以用list()函数将元组和字符串转换为列表。

    示例1：入门操作

>>> str = "string"
>>> list(str)    #字符串转为列表
['s', 't', 'r', 'i', 'n', 'g']
>>> ls = [111, "BIT", [11, "CS"], 3.14]
>>> ls[2][-1][0]  #索引访问
'C'
>>> ls[0] = 0    #修改列表
>>> ls
[0, 'BIT', [11, 'CS'], 3.14]

>>> ls = [0, 1, 2, 3, 4, 5]
>>> len(ls)          #求列表长度
6
>>> 5 in ls         #判断
True
>>> ls[2] = "python"
>>> ls
[0, 1, 'python', 3, 4, 5]
>>> ls[3] = ["World", "Cup"]    #修改列表元素值
>>> ls
[0, 1, 'python', ['World', 'Cup'], 4, 5]

>>> for i in ls:         #循环遍历列表并输出
    print(i, end = "")
01python['World', 'Cup']45

    示例2：进阶操作

>>> ls = [0, 1, 2, 3, 4, 5, 6, 7, 8, 9]   #设置列表ls
>>> ls
[0, 1, 2, 3, 4, 5, 6, 7, 8, 9]

>>> ls[0] = ls[1]                      #修改列表的值
>>> ls
[1, 1, 2, 3, 4, 5, 6, 7, 8, 9]

>>> lt = [1]                       #对列表[i:j]的值进行修改，不包括j
>>> ls[0:4] = lt
>>> ls
[1, 4, 5, 6, 7, 8, 9]


>>> ls[0:1] = []                 #删除列表[i:j]的值，不包括j
>>> ls
[4, 5, 6, 7, 8, 9]

>>> lt = [10, 11, 12, 13, 14, 15]    #列表尾部添加列表
>>> ls.extend(lt)
>>> ls
[4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15]

>>> ls.append(16)              #列表尾部添加元素
>>> ls
[4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16]

>>> ls[3:-1] = []                #正反索引可以一起使用
>>> ls
[4, 5, 6, 16]

>>> ls *= 2                    #列表复制2次添加到尾部
>>> ls
[4, 5, 6, 16, 4, 5, 6, 16]

>>> lt = ls.copy()             #列表复制函数
>>> lt
[4, 5, 6, 16, 4, 5, 6, 16]

>>> ls.clear()                #列表清除函数
>>> ls
[]

>>> lt.insert(3, 10)        #列表插入函数，第3个位置插入10
>>> lt
[4, 5, 6, 10, 16, 4, 5, 6, 16]

>>> a = lt.pop()            #列表弹栈，没学过数据结构可以不用看这个
>>> a
16
>>> lt
[4, 5, 6, 10, 16, 4, 5, 6]

>>> a = lt.pop(4)         #弹出第4个元素，并删除
>>> a
16
>>> lt
[4, 5, 6, 10, 4, 5, 6]

>>> lt.remove(10)        #删除第一次出现的10
>>> lt
[4, 5, 6, 4, 5, 6]

>>> lt.reverse()         #列表反转
>>> lt
[6, 5, 4, 6, 5, 4]

$3.$集合类型

    集合类型和数学中的集合类型概念一致，元素无序但唯一。集合里面的数据类型只能是固定数据类型，比如整数、浮点数、字符串、元组，列表、字典、集合是可变数据类型，因此不能在集合元素中出现。

    示例1：基础操作

>>> S = {1, 3.4, "Python", (10, "test")}    #集合
>>> S
{1, 3.4, (10, 'test'), 'Python'}

>>> S = set("banana")   #set函数转换为集合，去除重复元素
>>> S
{'a', 'b', 'n'}
>>> list(S)             #去重后转换回列表
['a', 'b', 'n']


>>> S = {1, 2, 3, 4, 5}
>>> S.add(6)                  #添加元素
>>> S
{1, 2, 3, 4, 5, 6}

>>> S.pop()          #随机删除一个元素并返回
1
>>> S
{2, 3, 4, 5, 6}

>>> S.discard(5)    #删除元素，如果有就删除，如果没有不报错
>>> S
{2, 3, 4, 6}

>>> S.remove(7)       #删除元素，如果有就删除，如果没有会报错
Traceback (most recent call last):
  File "<pyshell#89>", line 1, in <module>
    S.remove(7)
KeyError: 7

>>> T = {6, 7, 8, 9}   #两个集合如果有相同元素，返回false，没有相同元素返回true
>>> S.isdisjoint(T)
False

>>> len(S)            #集合个数
4
>>> 3 in S            #判断
True

    示例2：数学操作
    前面已经说了，Python的集合和数学的集合是一个感念，在数学领域，集合有交、并、补这些概念，同样，在Python里面也有这些概念。

>>> S = {0, 1, 2, 3, 4, 5, 6}
>>> T = {4, 5, 6, 7, 8, 9, 10}
>>> ST = S - T            #集合相减，减去相同元素
>>> ST
{0, 1, 2, 3}

>>> ST = S & T             #集合的交集
>>> ST
{4， 5， 6}

>>> ST = S | T            #集合的并
>>> ST
{0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10}

>>> ST = S ^ T           #集合的对称差，俗称A并B减去A交B
>>> ST
{0, 1, 2, 3, 5, 6, 7, 8, 9, 10}

>>> S = {0, 1} 
>>> T = {0, 1, 2}
>>> S <= T              #判断是否为子集
True
>>> T >= S
True

$4.$映射类型

    映射类型是“键-值”对的组合，每个元素都是一个键值对(key,value)，key表示属性，value是是属性的值。在python中，键值对的主要表达形式为字典。键值对的概念在实际生活中也比较常见，比如，在学生管理系统中，查询一个学生的信息肯定不是搜索学生的名字，而是搜索学生的ID进行查找，这就是一种最常见的键值对的应用。

>>> Country = {"中国":"北京",  "法国":"巴黎", "英国":"伦敦"}   #创建
>>> print(Country)
{'中国': '北京', '法国': '巴黎', '英国': '伦敦'}

>>> Country["中国"]           #访问
'北京'

>>> Country["中国"] = "BeiJing"    #修改
>>> print(Country)
{'中国': 'BeiJing', '法国': '巴黎', '英国': '伦敦'}

>>> Country["美国"] = "华盛顿"      #添加
>>> print(Country)

    集合、字典都用大括号创建是不是有点晕？但是他们还是有区别的，字典中有冒号”:”，S = {}表示创建空字典，而不是空集合，创建空集合的形式是A = set（）。

S = {}  #空字典
S = set()  #空集合

    因为字典的索引是通过键进行的，因此键具有唯一性，但是值不一定，通俗的说就是学号一定不一样，姓名可能会相同。

>>> S = {"1":"1", "2":"1", "3":"1"}      #学号不同，姓名相同
>>> S
{'1': '1', '2': '1', '3': '1'}

>>> S = {"1":"1", "1":"2", "1":"3"}     #键相同的被修改，保持唯一性
>>> S
{'1': '3'}

    字典进阶操作：

>>> Country    #先看一眼字典
{'中国': 'BeiJing', '法国': '巴黎', '英国': '伦敦', '美国': '华盛顿'}

>>> Country.keys()      #返回所有键的信息
dict_keys(['中国', '法国', '英国', '美国'])

>>> Country.values()    #返回所有值的信息
dict_values(['BeiJing', '巴黎', '伦敦', '华盛顿'])

>>> Country.items()     #泛会所有键值信息
dict_items([('中国', 'BeiJing'), ('法国', '巴黎'), ('英国', '伦敦'), ('美国', '华盛顿')])

>>> Country.popitem()   #随机返回一个键值对
('美国', '华盛顿')

>>> "法国" in Country      #判断
True

>>> del Country['美国']    #删除信息
>>>> Country
{'中国': 'BeiJing', '法国': '巴黎', '英国': '伦敦'}


>>> for key in Country:
         print(key)  
中国
法国
英国

>>> for key in Country:
         print(Country[key]) 
北京
巴黎
伦敦

    基本语法到此结束，是不是觉得自己啥都不会，其实我也是，之后整理一下Python的库，可能到时候就会觉得Python的强大了吧。