Python系列数据概述

数组

数组一种数据结构，用于存储和处理大量数据。将所有的数据存储在一个或多个数据中，然后通过索引下标访问并处理数组元素，可以实现复杂数据处理任务。Python语言并没有提供直接创建数组的功能，但可以使用其内置的系列数据类型（例如列表list），实现数组功能。

系列数据类型

系列数据类型是Python基础的数据结构，是一组有顺序的元素的集合。系列数据可以包含一个或多个元素（对象，元素也可以是其他系列数据），也可以是一个没有任何元素的空系列。

Pyrhon的内置系列数据类型包括：元组（tuple）、列表（list）、字符串（str）和字节数据（bytes和bytearray）

系列数据的基本操作

系列的长度，最大值，最小值，求和

通过内置函数len(),max(),min()可以获取系列的长度，系列中元素最大值，系列中最小值。内置函数sum()可获取列表或元组各元素之和；如果有非数值元素，则导致TypeError；对于字符串（str）和字节数据（bytes），也将导致TyprError。

系列中索引访问操作

系列表可以通过索引下表访问的可迭代对象、可以通过整数下表访问系列s的元素。
索引下标从0开始，第一个元素为s[0]，第二个元素为s[1]，以此类推，最后一个元素是s[len(s)-1]，如果索引下标越界，则导致IndexError；如果索引下标不是整数，则导致TypeError

系列的切片操作

通过切片操作，可以截取系列s的。切片操作的基本形式为：s[i:j] 或 s[i:j:k] 其中i为系列开始下标（包含s[i]）；j为系列结束下标（不包含s[j]）；k为步长。如果省略i，则从下标0开始；如果省略j，则直接系列到结束为止；如果省略k，则步长为1

注意：下标也可以为负数。如果截取范围内没有数据，则返回空元组；如果超过下标范围，不会报错

系列的连接和重复操作

通过连接操作符+，可以连接两个系列（s1和s2），形成一个新的系列对象，通过重复操作符*，可以重复一个系列n次（n为整数）。系列连接和重复操作的基本形式为：s1+s2或者s*n或者n*s

连接操作符+和重复操作符*也支持复合赋值运算，即：+=和*=

系列的成员关系操作

可以通过下列方式之一判断一个元素x是否在系列s中。

x in s                #如果为True，则表示存在
x not in s            #如果为True，则表示不存在
s.count(x)            #返回x在s（指定范围[start,end)）中出现的次数
s.index(x[,i[,j]])    #返回x在s(指定范围[i,j])中第一次出现的下标
#其中，指定范围[i,j)，从下标（包括，默认为0）开始，到下标j结束（不包括，默认认为len(s)）。
#对于s.index(value,[start,[stop]])方法，如果找不到时，则导致ValueError

系列的比较运算操作

两个系列支持比较运算符（<，<=，==，!=，>=，>），字符串比较运算顺序逐个元素进行比较

系列的排序操作

通过内置函数sorted()，可以返回系列的排序列表。通过类reversed构造函数，可以返回系列的反序列迭代器。形式如下：
sorted(iterable,key=None,reverse=False) #返回系列的排序列表 其中key适用于计算比较键值的函数（带一个参数），例如：key=str.lower如果reverse=True，则反向排序

内置函数all()和any()

通过内置函数all()和any()，可以判断系列的元素是否全部和部分为True

all(iterable)   #如果序列的所有值都为True，返回True，否则返回False
any(iterable)   #如果序列的任意值为True，返回True；否则，返回False

>>> any((1,2,3,0))
True
>>> any((0,0,0,0))
False
>>> all([1,2,3,0])
False
>>> all([1,2,3,4])
True

系列拆封

1. 变量个数和系列长度相等：使用赋值语句，可以将系列值拆封，然后赋值给多个变量；
   变量1,变量2,....,变量n = 系列或可迭代对象 变量个数和系列元素个数不一致时，将导致ValueError

>>> a,b,c=(1,2,3)
>>> a,b
(1, 2)
>>> a,b,c
(1, 2, 3)
>>> a,b,c=(7,'mochu',[7,77,777])
>>> a,b,c
(7, 'mochu', [7, 77, 777])
>>> c
[7, 77, 777]
>>> a,b,c=(1,2)
Traceback (most recent call last):
  File "<stdin>", line 1, in <module>
ValueError: not enough values to unpack (expected 3, got 2)
>>>

2. 变量个数和系列长度不等

由于系列长度未知，可使用*元组变量，将多个值作为元组赋值给元组变量。一个赋值语句，*变量只允许出现一次，否则导致SyntaxError

3. 使用临时变量_

如果只需要部分数据，系列其他位置可以使用临时变量_

>>> _,a,_,b=(1,2,3,4)
>>> _
3
>>> a,b
(2, 4)
>>>

元组

元组是一组有序系列，包含零个或多个对象引用。元组和列表十分类似，但元组是不可变对象，即不能修改、添加或删除元组中的项目，但可以访问元组中的项目。

使用元组字面量创建元组实例对象

使用元组字面量，可以创建元组实例对象。元组字面量采用圆括号中用逗号分隔的项目定义。圆括号可以省略。其基本形式如下：x1,[x2,...,xn]或者(x1,[x2,...,xn])，其中x1,x2,…,xn为任意对象

注意，如果元组中有一个项目时，后面的逗号不能省略，这是因为Python解释器把(x1)解释为x1，例如。(1)为整数1，(1,)解释为元组。

使用tuple对象创建元组实例对象

也可以通过创建tuple对象来创建元组。其基本形式为：

tuple()     #创建一个空列表
tuple(iterable)     #创建一个列表，包含的项目为可枚举对象iterable中的元素

元组的系列操作

元组支持系列的基本操作，包括索引访问、切片操作、连接操作、重复操作、成员关系操作、比较运算操作，以及len(),max(),sum()，求元组长度、最大值。最小值等

列表

列表是一组有序项目的数据结构。创建一个列表后，可以访问，修改，添加或删除列表中的项目。即列表示可变数据类型，Python没有数组，可以使用列表代替

使用列表字面量创建列表实例对象

使用列表字面量，可以创建列表实例对象。列表字面量列表采用方括号中用逗号分隔的项目定义。其基本形式：[x1,x2,...,xn]

使用list对象创建元组实例对象

也可以通过创建list对象来创建列表。其基本形式为：

list()           #创建一个空列表
list(iterable)   #创建一个空列表，包含项目为可枚举对象iterable中的元素

列表的系列操作

列表支持系列的基本操作，包括索引访问、切片操作、连接操作、重复操作、成员关系操作、比较运算操作，以及求列表长度，最大值，最小值等

列表是可变对象，故可以改变列表对象中的值，也可以通过del删除某元素

s[下标]=x      #设置列表元素，x为任意对象
del x[下标]    #删除列表元素

列表是可变对象，故可以改变切片的值，也可以通过del删除切片

s[i:j]=x       #设置列表内容，x为任意对象，也可以是元组、列表
del s[i:j]     #移去列表中一系列元素，等同于s[i:j]=[]
s[i:j]=[]      #移去列表一系列元素

list对象的方法

对象是可变对象，其包含的主要方法如下图所示，s=[1,3,2]

列表解析表达式

使用列表解析式，可以简单高效地处理一个可迭代对象，并生成结果列表。列表解析表达式的形式如下：

[expr for i₁ in 序列1…for i_N in 序列N]：迭代所有内容，并生成计算列表
[expr for i₁ i in 序列1…for i_N in 序列N if cond_expr]：按条件迭代，并生成计算列表

表达式expr使用每次迭代内容 i₁…i_N，计算生成一个列表。如果指定了条件表达式cond_expr，则只有满足条件的元素参与迭代

>>> [i**2 for i in range(10)]
[0, 1, 4, 9, 16, 25, 36, 49, 64, 81]
>>> [(i,i**2) for i in range(10)]
[(0, 0), (1, 1), (2, 4), (3, 9), (4, 16), (5, 25), (6, 36), (7, 49), (8, 64), (9, 81)]
>>> [i for i in range(10) if i%2==0]
[0, 2, 4, 6, 8]
>>> [(x,y,x*y) for x in range(1,4) for y in range(1,4) if x>=y]
[(1, 1, 1), (2, 1, 2), (2, 2, 4), (3, 1, 3), (3, 2, 6), (3, 3, 9)]
>>>

字符串

字符串实现为有序的字符合集，即字符系列。str对象是不可变对象。

字符串系列操作

字符串支持系列的基本操作，包括索引访问、切片操作、连接操作、重复操作、成员关系操作符、比较运算操作，以及求字符串长度、最大值、最小值等。

通过len(s)，可以获取字符串s的长度；如果其长度为0，则为空字符串

字符串编码

默认情况下，Python字符串采用UTF-8编码。创建字符串，也可以指定编码方式
str(object=b'',encoding='utf-8',errors='strict') #指定编码，根据字节码对应编码的字符串 其中，objec为字节码对象（bytes或bytearray）；encoding为编码；error为错误控制、该构造函数的结果，等同于bytes对象b的对象方法: b.encode(encoding,error) #把字节码对象b解码为对应编码的字符串 对应的，也可以把字符串对象s编码为字节对象：

>>> s1='是末初呀'
>>> s2=s1.encode(encoding='cp936')
>>> s2
b'\xca\xc7\xc4\xa9\xb3\xf5\xd1\xbd'
>>> s2.decode(encoding='cp936')
'是末初呀'
>>>

字符串格式化

1. %元算符形式

Python支持类似C语言的printf格式化输出，采用如下形式：
格式化字符串 % (值1,值2,...) #兼容Python2的格式，不建议使用 格式化字符串与C语言的printf格式化字符串基本相同。格式化字符串由固定和格式说明符混合组成。格式说明符的语法如下：
%[(key)][flags][width][.precision][Length]type 其中，key（可选）为映射键（适用于映射的格式化，例如%(lang)s）；flags（可选）为修改输出格式的字符集；width（可选）为最小宽度，如果为*，则使用下一个参数值；percision（可选）为精度，如果为*，则使用下一参数值；Length为修饰符（h、l或L，可选），Python忽略该字符；type为格式化类型字符。例如：

>>> '结果：%f'%88
'结果：88.000000'
>>> '姓名：%s，年龄：%d，体重：%3.2f'%('末初',19,60)
'姓名：末初，年龄：19，体重：60.00'
>>> '%(lang)s has %(num)03d quote types.'%{'lang':'Python','num':2}
'Python has 002 quote types.'
>>> '%0*.*f'%(10,5,88)
'0088.00000'
>>>

2. format内置函数

内置函数基本形式如下：

format(value)             #等同于str(value)
format(value,format_spec) #等同于type(value)._format__(format_scpec)

格式化说明符(format_spec)的基本格式如下：

[[fill]align][sign][#][0][width][,][.percision][type] 其中，fill(可选)为填充字符，可以为除{}外的任何字符；align为对齐方式，包括：<左对齐，>右对齐，=填充位于符号和数字之间，^居中对齐，sign(可选)为符号字符，包括+（正数）、-（负数）、(正数带空格)，width(可选)是最小宽度；percision(可选)是精度；type是格式化类型字符，如下：

3.字符串的format方法h

字符串format方法的基本形式如下：

str.format(格式化字符串,值1,值2,...)   #类方法
格式化字符串.format(值1,值2,...)       #对象方法
格式化字符串.format_map(mapping)

格式化字符串由固定文本和格式化说明符混合组成。格式说明符的语法如下：
{[索引和键]:formati_spec} 其中，可选索引对应于要格式化参数值的位置，可选键对应于要格式化映射的键；格式化说明符(format_spec)同format内置函数

字节系列

字节系列是由8位字节数据组成的系列数据类型，即0<=x<256的整数系列。Python内置的字节系列数据类型包括：bytes（不可变对象）、bytearray(可变对象)和memoryview

bytes常量

使用字母b加单引号或双引号括起来的内容，是bytes常量，Python解释器自动创建bytes型对象实例。bytes常量与字符串定义方式类似

1. 单引号（b’ '）,包含在单引号中的字符串，其中可以包含双引号
2. 双引号（b" "），包含在双引号中字符串，其中可以包含单引号
3. 三单引号（b’’’ ‘’’），包含在三单引号中的字符串，可以跨行
4. 三双单引号（b""" “”“）,包含在三双引号中的字符串，可以跨行

注意：引号只能包含ASCII码字符，否则导致SyntaxError

>>> b'末初'
  File "<stdin>", line 1
SyntaxError: bytes can only contain ASCII literal characters.
>>>

创建bytes对象

创建bytes类型的对象实例基本形式如下：

bytes()           #创建空bytes对象
bytes(n)          #创建长度为n（整数）的bytes对象，各字节为0
bytes(iterable)   #创建bytes对象，使用iterable中字节整数
bytes(object)     #创建bytes对象，使用iterable中的字节整数
bytes(source[,enconding[,errors]])   #创建bytes对象

注意：如果iterable中包含非0<=x<256的整数，则导致ValueError

创建bytearray对象

创建bytearray类型的对象实例的基本形式为：

bytearray()              #创建空bytearrat()对象
bytearray(n)             #创建长度为n(整数)的bytearray()对象，各字节为0
bytearray(iterable)      #创建bytearray对象，使用iterable中的字节整数
bytearray（object）       #创建bytearray对象，赋值object字节数据
bytearray([source[,encoding[,errors]]])   #创建bytearray()对象

如果iterable中包含非0<=x<256的整数，则导致ValueError

bytes和bytearray的系列操作

byte和bytearray支持系列的基本操作，包括索引访问、切片操作、连接操作、重复操作、成员关系操作、比较运算操作。以及求系列长度、最大值、最小值等

bytes和bytearray一般基于ASCII字符串，故bytes和bytearray基本上支持str对象的类似方法。但不支持str.encode()（把字符串转换为bytes对象）、str.format()/str.format_map()（字符串格式化）、str.isidentifier()/str.isunmeric()/str.isdecimal()/str.isprintable()（判断这些无意义）

注意：bytes和bytearray()的方法不接受字符串参数，只接受bytes和bytearray参数，否则导致TypeError

字节编码和解码

字符串可以通过str.encode()方法编码为字节码；通过bytes和bytearray的decode()方法解码为字符串