Python程序设计基础——序列结构

        本篇将从Python的序列结构切入，通过对序列、元组、集合、字典以及字符串进行具体介绍，主要介绍序列结构的方法、函数以及其特性。

一、分类

        可变序列与不可变序列

        在序列内容的可变性上，我们可以将其分为可变序列和不可变序列，顾名思义，可变序列指其序列内元素可以改变，不可变序列指其元素，不能改变。

        可变序列：列表、字典、集合。

        不可变序列：元组、字符串。

        有序序列与无序序列

        在序列内容的顺序上，元素有无固定顺序，我们可以将其分为有序序列和无序序列，有固定顺序的序列称为有序序列，无固定顺序的称为无序序列。

        有序序列：列表、元组、字符串。

        无序序列：字典，集合。

二、列表

       （一）列表的创建:空列表[]，list（）创建一个新列表。

x = []
#创建空列表x
y = list()
#创建空列表
z = list(1,2,3)
#创建列表[1,2,3]

       （二） 列表的删除：del 列表名

x = [1,2,3]
del x
print(x)
#列表x已经被删除，抛出错误

       （三）列表的转化：使用list（）函数将其他序列结构转化为列表

x = (1,2,3)
x=list(x)
#将元组x转化为列表

       （四）元素访问：使用下标进行访问，列表名[下标]

x = [1,2,3]
print(x[1])
#输出结果2

       （五）列表方法：

       1. 增加元素：

        append（x）方法，可在列表的尾部进行追加x元素。

x = [1,2,3]
x.append(4)
print(x)
#输出[1,2,3,4]

        extend（L）方法，将可迭代对象里的元素接在列表尾部，相当于运算符“+”，将两个可迭代对象的内容进行加和，存放在原列表

A = [1,2,3]
B = [5,6,7]
C = A.extend(B)
print(c)
#输出[1,2,3,5,6,7]

        insert（index，x）方法，能够在固定位置插入元素，保证列表有序性，在index位置插入x。

x = [2,3,4]
x.insert(0,1)
print(x)
#输出[1,2,3,4]

        2.删除元素：

        remove（x) 删除列表中第一个值为x的元素，不存在则抛出错误。

        pop([index])删除index下标的值，并返回这个值，index默认-1（默认删掉最后一个元素）。

        3.索引

        index（x）返回第一个为x的值的下标，没有则抛出异常。

        4.计数

        count（x）返回x在列表中出现的次数。

        5.排序

        sort（key=None，reverse=布尔值）无规则，False升序，True逆序。

x = [1,4,5,2,3]
x=x.sort()
print(x)
#输出[1,2,3,4,5]

        6.翻转

        reverse（）对列表进行原地逆序，首尾交换。

x=[1,2,3,4,5]
x=x.reverse()
print(x)
#输出[5,4,3,2,1]

        （六）列表支持的运算符

        +        链接两个列表，将两个列表按照顺序链接。

A = [1,2,3]
B = [5,6,7]
C = A + B
print(c)
#输出[1,2,3,5,6,7]

        *        将列表内容重复。

x = [1,2,3]
x = x * 3
print(x)
#输出[1,2,3,1,2,3,1,2,3]

        in       测试列表中是否包含某元素，返回含有元组的列表,元组内容为（下标，元素）。       

x = [1,2,3]
print(1 in x)
#输出(0,1)

        关系运算符        比较两列表大小（逐一对比元素的 值）返回布尔值 测试列表中是否包含某元素，返回布尔值。

        （七）内置函数对列表操作

        random库中shuffle（）函数，可以打乱列表中元素。

        all（）函数，测试列表中所有元素都等于Ture，返回一个布尔值。

        any（）函数，测试列表中存在元素等于Ture，也返回一个布尔值。

        max（）函数，返回列表中的最大值，可定义比较规则，比如说比较Unicode码。

        min（）函数，返回列表中的最小值。

        sum（）函数，对列表内所有元素进行求和运算。

        len（）函数，返回列表元素的个数。

        zip（）函数，两个可迭代对象（列表）中的元素， 一对一组成元组放入列表中。

        enumerate（）函数，对可迭代对象作用，返回含有元组的列表,元组内容为（下标，元素）。

        （八）列表推导式

        能够实现短小语句快速操作

        使用：列表名=[追加变量 语句块 ]

        特殊：定界符方括号[]

a = [x*x for x in range(5)]
print(a)
#输出[1,4,9,16,25]

        （九）列表切片

        使用:列表名[start:end:step]

        作用：

        ①获取部分元素，配置start、end、step，将列表部分截断。

        ②增加元素，配置start=end,在任意位置增加元素。

        ③替换和修改元素，配置start、end、step，利用规则=新 列表赋值修改元素。

        ④删除元素，配置start、end、step，利用规则=赋 值[]删除元素。

        ⑤倒序，列表名[::-1],能够让列表内元素进行翻转。

三、字典

        （一）字典的创建：空字典{}，创建dict()

        （二）字典的删除：del 字典名

        （三）元素访问：

        字典名[键]返回其“键”对应的“值”，不存在此“键”则抛出异常（代码停止）。

        字典名.get（键）返回对应的“值”，不存在此“键”返回指定的默认值。

        items（）方法默认遍历元素的键，将键值一一遍历。

        keys（）方法遍历键，返回所有键值，其形式为   

        values（）方法遍历值

        （四）元素添加、修改

        1.字典名[键]=值

        ①不存在，添加 ②存在，修改。

        2.update（）方法

        可同时实现元素新增和修改。

        （五）元素删除

       1. pop（）方法，删除一个元素（键值对），弹出值。

        2.popitem（）方法，删除一个元素（键值对），默认最后一个，并弹出值。

四、集合

        （一）集合的创建：set（），空集合也用{}创键。

        （二）集合的删除：

        pop（）方法，删一个元素并返回其值。

        remove（x）方法，删一个x的值，不存在则抛出异常。

        discard（x）方法，删一个x的值，不存在不报错。

        clear（）方法，清空集合内所有元素。

        （三）操作与运算

        可使用可迭代对象函数，关系运算符对集合进行操作。

五、元组

        （一）元组的创建：空元组（），创建tuple（），若元组 中只有一个元素需要加上逗号。

        （二）元素访问：支持双向索引，使用方式为 元组名[下标]。

        （三）元组特点：

        ①不能更改元组内容。

        ②元组的切片用来访问。

        ③支持双向索引。

        ④不提供append（）方法、extend （）方法、insert（）方法。

        ⑤不支持del操作。

        ⑥可做字典键。

        （四）生成器表达式

       特点 

        ①定界符圆括号（）。

        ②惰性求值。

        ③__iter__（）方法返回可迭代对象本身，等价于next（）函 数。

        ④__next__（）返回可迭代对象下一个值。

        ⑤无法访问已经访问过的值。

g =  ((i+2)**2 for i in range(10))
#创建生成器表达式

六、序列解包

        一个语句，实现多个变量同时赋值。

        特点

        ①等号两边数量一致。

        ②当对字典元素进行序列解包时，需要用items（）方法或者是values（）方法说明。

        ③序列解包可遍历多个序列，循环变量数量取决于可迭代对象中的元素长度。

x = [1,2,3]
a,b,c = x
print(a)
#输出1
print(b)
#输出2
print(c)
#输出3