《疯狂Python讲义》之常见模块

sys

sys模块中常用的属性和函数：

sys.argv：获取运行Python程序的命令行参数
sys.byteorder：显示本地字节序的指示符
sys.copyright：该属性返回与Python解释器有关的版权信息
sys.executable：该属性返回Python解释器在磁盘上的存储路径
sys.exit()：通过引发systemExit异常来退出程序
sys.flags：该只读属性返回运行Python命令时指定的旗标
sys.getfilesystemencoding ()：返回在当前系统中保存文件所用的字符集
sys.getrefcount(object)：返回指定对象的引用计数
sys.getrecursionlimit（）：返回Python解释器当前支持的递归深度，该属性可通过setrecursionlimit（）方法重新设置
sys.getswitchinterval()：返回在当前Python解释器中线程切换的时间间隔
sys.implementation()：返回当前Python解释器的实现
sys.maxsize：返回Python整数支持的最大值
sys.modules：返回模块名和载入模块对应关系的字典
sys.path：该属性指定Python查找模块的路径列表
sys.platform：返回Python解释器所在平台的标识符
sys.stdin：返回系统的标准输入流------一个类文件对象
sys.stdout：返回系统的标准输出流------一个类文件对象
sys.stderr：返回系统的错误输出流------一个类文件对象
sys.version：返回当前Python解释器的版本信息
sys.winver：返回当前Python解释器的主版本号

获取运行参数

通过sys模块的argv属性可获取运行Python程序的命令行参数，argv属性值是一个列表，其列表元素和运行参数的关系如图：

因此，如果需要获取运行Python程序时传入的参数，可以通过argv[1]、argv[2]…来获取。

如果某个参数本身包含了空格，则应该将该参数用双引号（""）括起来，否则，Python会把这个空格当成参数分隔符，而不是参数本身，列如：

python argv test.py ”Python Swift"

动态修改模块加载路径

sys.path用于在程序运行时为Python动态修改模块加载路径：

import sys
# 动态添加g:\fk_ext路径作为模块加载路径
sys.path.append('g:\\fk_ext')
# 加载g:\fk_ext路径下的hello模块
import hello

OS模块

os模块代表了程序所在的操作系统，主要用于获取程序运行所在操作系统的相关信息

import os
# 显示导入依赖模块的操作系统的名称
print(os.name)
# 获取PYTHONPATH环境变量的值
print(os.getenv('PYTHONPATH'))
# 返回当前系统的登录用户名
print(os.getlogin())
# 获取当前进程ID
print(os.getpid())
# 获取当前进程的父进程ID
print(os.getppid())
# 返回当前系统的CPU数量
print(os.cpu_count())
# 返回路径分隔符
print(os.sep)
# 返回当前系统的路径分隔符
print(os.pathsep)
# 返回当前系统的换行符
print(os.linesep)
# 返回适合作为加密使用的、最多3个字节组成的bytes
print(os.urandom(3))

在os模块下还包含各种进程管理函数，它们可以用于启动新进程、中止已有进程等：

os.abort()：生成一个SIGABRT信号给当前进程；
os.execl(path,arg0,arg1,…)：该函数使用参数列表arg0,arg1,…来执行path所代表的执行文件；
os.forkpty()：fork一个子进程
os.kill(pid,sig)：将sig信号发送到pid对应的进程，用于结束该进程
os.killpg(pgid,sig)：将sig信号发送到pgid对应的进程组
os.popen(cmd,mode=‘r’,buffeering=-1)：用于向cmd命令打开读写管道，buffering缓冲参数与内置的open()函数有相同的函数。该函数的文件对象用于读写字符串，而不是字节
os.spawnl(mode,path,…)：该函数用于在新进程中执行新程序
os.startfile(path[,operation])：对指定文件使用改文件关联的工具执行
os.system(command)：运行操作系统上的指定命令；

random

random模块主要包含生成伪随机数的各种功能变量和函数

['Random', 'seed', 'random', 'uniform', 'randint', 'choice',
'sample', 'randrange', 'shuffle', 'normalvariate', 'lognormvariate',
'expovariate', 'vonmisesvariate', 'gammavariate', 'triangular',
'gauss', 'betavariate', 'paretovariate', 'weibullvariate',
'getstate', 'setstate', 'getrandbits', 'choices', 'SystemRandom']

random.seed(a=None,version=2)：指定种子来初始化伪随机数生成器
random.randrange(start,stop[,step])：返回从start开始到stop结束，步长为step的随机数，其实相当于choice(range(start,stop,step))
random.randint(a,b)：生成一个范围为a≤N≤b的随机数
random.choice(seq)：从seq中随机抽取一个元素
random.choices(seq,weights=None,*,cum_weights=None,k=1)：从seq序列中抽取k个元素，还可通过weights指定各元素被抽取的权重
random.shuffle(x[,random])：对x序列执行洗牌“随机排列”操作
random.sample(population,k)：从population序列中随机抽取k个独立的元素
random.random()：生成一个从0.0到1.0之间的伪随机浮点数
random.uniform(a,b)：生成一个范围a≤N≤b的随机数
random.expovariate(lambd)：生成呈指数分布的随机数。

time

time模块主要包含各种提供日期、时间功能的类和函数。该模块既提供了把日期、时间格式化为字符串的功能，也提供了从字符串恢复日期、时间的功能。

在time模块内提供了一个time.struct_time类，该类代表一个时间对象，它主要包含9个属性：

字段名	字段含义	值
tm_year	年	如2017、2018等
tm_mon	月	范围1~12
tm_mday	日	范围1~31
tm_hour	时	范围0~23
tm_min	分	范围0~59
tm_sec	秒	范围0~59
tm_wday	周	范围0~6
tm_yday	一年内第几天	范围1~366
tm_isdst	夏令时	0/1或-1

import time
# 将当前时间转换为时间字符串
print(time.asctime())
# 将指定时间转换时间字符串，时间元组的后面3个元素没有设置
print(time.asctime((2018, 2, 4, 11, 8, 23, 0, 0 ,0))) # Mon Feb  4 11:08:23 2018
# 将以秒数为代表的时间转换为时间字符串
print(time.ctime(30)) # Thu Jan  1 08:00:30 1970
# 将以秒数为代表的时间转换为struct_time对象。
print(time.gmtime(30))
# 将当前时间转换为struct_time对象。
print(time.gmtime())
# 将以秒数为代表的时间转换为代表当前时间的struct_time对象
print(time.localtime(30))
# 将元组格式的时间转换为秒数代表的时间
print(time.mktime((2018, 2, 4, 11, 8, 23, 0, 0 ,0))) # 1517713703.0
# 返回性能计数器的值
print(time.perf_counter())
# 返回当前进程使用CPU的时间
print(time.process_time())
#time.sleep(10)
# 将当前时间转换为指定格式的字符串
print(time.strftime('%Y-%m-%d %H:%M:%S'))
st = '2018年3月20日'
# 将指定时间字符串恢复成struct_time对象。
print(time.strptime(st, '%Y年%m月%d日'))
# 返回从1970年1970年1月1日0点整到现在过了多少秒。
print(time.time())
# 返回本地时区的时间偏移，以秒为单位
print(time.timezone) # 在国内东八区输出-28800

time模块中的strftime()和strptime()两个函数互为逆函数，其中strftime()用于将struct_time对象或时间元组转换为时间字符串；而strptime()函数用于将时间字符串转换为struct_time对象。

JSON支持

JSON的基本知识

JSON主要有如下两种数据结构：

由key-value对组成的数据结构
有序集合

使用JSON语法创建对象

创建对象object时，总以"{“开始，以”}"结束，对象的每个属性名和属性值之间以英文冒号(:)隔开，多个属性定义之间以英文逗号(,)隔开，语法格式如下：

object =
{propertyName1:propertyValue1,propertyName2:propertyValue2,...
}

使用JSON语法创建数组
使用JSON创建数组的语法格式如下：

arr = [value1,value2 ...]

Python的JSON支持

json模块提供了对JSON的支持，它既包含了将JSON字符串恢复成Python对象的函数，也提供了将Python对象转换成JSON字符串的函数

JSON类型	Python类型
对象（object）	字典（dict）
数组（array）	列表（list）
字符串（string）	字符串（str）
整数（number(int)）	整数（int）
实数（number(real)）	浮点数（float）
true	True
false	False
null	None

json模块所包含的全部属性和函数如下：

['dump', 'dumps', 'load', 'loads', 'JSONDecoder', 'JSONDecodeError',
'JSONEncoder']

json模块中常用的函数和类的功能如下：

json.dump(obj,fp)：将obj对象转换成JSON字符串输出到fp流中，fp是一个支持write()方法的类文件对象
json.dumps(obj)：将obj对象转换为JSON字符串，并返回该JSON字符串
json.load(fp)：从fp流读取JSON字符串，将其恢复成JSON对象，fp是一个支持write()方法的类文件对象
json.loads(s)：将JSON字符串s恢复成JSON对象

import json
# 将Python对象转JSON字符串（元组会当成数组）
s = json.dumps(['yeeku', {'favorite': ('coding', None, 'game', 25)}])
print(s) # ["yeeku", {"favorite": ["coding", null, "game", 25]}]
# 简单的Python字符串转JSON
s2 = json.dumps("\"foo\bar")
print(s2) #"\"foo\bar"
# 简单的Python字符串转JSON
s3 = json.dumps('\\')
print(s3) #"\\"
# Python的dict对象转JSON，并对key排序
s4 = json.dumps({"c": 0, "b": 0, "a": 0}, sort_keys=True)
print(s4) #{"a": 0, "b": 0, "c": 0}
# 将Python列表转JSON，
# 并指定JSON分隔符：逗号和冒号之后没有空格（默认有空格）
s5 = json.dumps([1, 2, 3, {'x': 5, 'y': 7}], separators=(',', ':'))
# 输出的JSON字符串中逗号和冒号之后没有空格
print(s5) # '[1,2,3,{"4":5,"6":7}]'
# 指定indent为4，意味着转换的JSON字符串有缩进
s6 = json.dumps({'Python': 5, 'Kotlin': 7}, sort_keys=True, indent=4)
print(s6)
# 使用JSONEncoder的encode方法将Python转JSON
s7 = json.JSONEncoder().encode({"names": ("孙悟空", "齐天大圣")})
print(s7) # {"names": ["\u5b59\u609f\u7a7a", "\u9f50\u5929\u5927\u5723"]}
f = open('a.json', 'w')
# 使用dump()函数将转换得到JSON字符串输出到文件
json.dump(['Kotlin', {'Python': 'excellent'}], f)

正则表达式

Python的正则表达式支持

re模块所包含的全部属性和函数：

re.compile(pattern,flags=0)：该函数用于将正则表达式字符串编译成_sre.SRE_Pattern对象，该对象代表了正则表达式编译之后在内存中的对象，可以缓存并复用正则表达式字符串；
re.match(pattern,string,flags=0)：尝试从字符串的开始位置来匹配正则表达式，如果开始位置匹配不成功，match()函数就返回None。其中pattern参数代表正则表达式，string代表被匹配的字符串，flags代表正则表达式的匹配旗标；
re.search(pattern,string,flags=0)：扫描整个字符串，并返回字符串中第一处匹配pattern的匹配对象；
re.findall(pattern,string,flags=0)：扫描整个字符串，并返回字符串中所有匹配pattern的子串组成的列表；
re.finditer(pattern,string,flags=0)：扫描整个字符串，并返回字符串中所有匹配pattern的子串组成的迭代器；
re.fullmatch(pattern,string,flags=0)：该函数要求整个字符串能匹配pattern，如果匹配则返回包含匹配信息的_sre.SRE_Match对象；否则返回None；
re.sub(pattern,repl,string,count=0,flags=0)：该函数用于将string字符串中所有匹配pattern的内容替换成repl;repl是被替换的字符串，也可以是一个函数；count参数控制最多替换多少次，如果指定为0，则表示全部替换；
re.split(pattern,string,maxsplit=0,flags=0)：使用pattern对string进行分割，该函数返回分割得到的多个子串组成的列表，其中maxsplit参数控制最多分割几次。
re.purge()：清除正则表达式缓存
re.escape(pattern)：对模式中除ASCII字符、数值、下画线之外的其他字符进行转义

re模块中_sre.SRE_Match对象包含以下方法或属性：

match.group([group1,…])：获取该匹配对象中指定组所匹配的字符串
match.__getitem __(g)：这是match.group(g)的简化写法
match.groups(default=None)：返回match对象中所有组所匹配的字符串组成的元组
match.groupdic(default=None)：返回match对象中所有组所匹配的字符串组成的字典
match.start([group])：获取该匹配对象中指定组所匹配的字符串的开始位置
match.end([group])：获取该匹配对象中指定组所匹配的字符串的结束位置
match.span([group])：获取该匹配对象中指定组所匹配的字符串的开始位置和结束位置

正则表达式旗标

Python支持的正则表达式旗标都使用该模块中的属性来代替：

re.A或re.ASCII：该旗标控制\w,\W,\b,\B,\d,\D,\s和\S只匹配ASCII字符，而不匹配所有的Unicode字符
re.DEBUG：显示编译正则表达式的debug信息
re.I或re.IGNORECASE：使用正则表达式匹配时不区分大小写
re.L或re.LOCALE：根据当前区域设置使用正则表达式匹配时不区分大小写
re.M或re.MULTILINE：多行模式的旗标
re.S或s.DOTALL：让点(.)能匹配包括换行符在内的所有字符
re.U或re.Unicode：该旗标控制\w,\W,\b,\B,\d,\D,\s和\S能匹配所有的Unicode字符
re.X或re.VERBOSE：通过该旗标允许分行写正则表达式

创建正则表达式

正则表达式就是一个用于匹配字符串的模板，它可以匹配一批字符串，所以创建正则表达式就是创建一个特殊的字符串。

正则表达式所支持的合法字符

字符	解释
x	字符x
\uhhhh	十六进制值0xhhhh所表示的Unicode字符
\t	制表符
\n	新行符
\r	回车符
\f	换页符
\a	报警符
\e	Escape符
\cx	x对应的控制符

正则表达式中的特殊字符

特殊字符	说明
$	匹配一行的结尾，要匹配$字符本身，请使用\$
^	匹配一行的开头，要匹配^{字符本身，请使用\}^
()	标记子表达式的开始位置和结束位置，要匹配这些字符，请使用$和$
[]	用于确定中括号表达式的开始位置和结束位置，要匹配这些字符，请使用\[和\]
{}	用于标记前面子表达式的出现频度，要匹配这些字符，请使用\{和\}
*	指定前面子表达式可以出现0次或多次，要匹配字符本身，请使用\
+	指定前面子表达式可以出现一次或多次，要匹配+字符本身，请使用\+
?	指定前面子表达式可以出现0次或一次，要匹配?字符本身，请使用\?
.	匹配除换行符\n之外的任意单个字符，要匹配.字符本身，请使用\.
\	用于转义下一个字符，要匹配\字符，请使用\\
\|	指定在两项之间任选一项，要匹配\|字符本身，请使用\\|

正则表达式中，通配符是可以匹配多个字符的特殊字符，称为“预定义字符”。

正则表达式所支持的预定义字符

预定义字符	说明
.	默认可匹配除换行符之外的任意字符
\d	匹配0~9的所有数字
\D	匹配非数字
\s	匹配所有的空白字符，包括空格、制表符、回车符、换页符、换行符等
\S	匹配所有的非空白字符
\w	匹配所有的单词字符，报警0~9的数字，26个英文字母和下画线
\W	匹配所有的非单词字符

方括号表达式

方括号表达式	说明
表示枚举	例如[abc]，表示a、b、c其中任意一个字符
表示范围	例如[a-f]，表示a~f范围内的任意字符
表示求否：^	例如[^abc]，表示非a、b、c的任意字符

边界匹配符

边界匹配符	说明
^	行的开头
$	行的结尾
\b	单词的边界，即只能匹配单词前后的空白
\B	非单词的边界，即只能匹配不在单词前后的空白
\A	只能匹配字符串的开头
\Z	只能匹配字符串的结尾

子表达式

正则表达式支持圆括号表达式，用于将多个表达式组成一个子表达式，在圆括号中可以使用或运算符(|)，子表达式支持如下用法：

(exp)：匹配exp表达式并捕获一个自动命名的组，后面可通过"\1"引用第一个捕获组所匹配的子串，通过"\2"引用第二个捕获组所匹配的子串…以此类推
(?Pexp)：匹配exp表达式并捕获成命名组，该组名字为name，后面可通过(?P=name)来引用前面捕获的组
(?P=name)：引用name命名组所匹配的子串
(?:exp)：匹配exp表达式并且不捕获
(?<=exp)：括号中的子模式必须出现在匹配内容的左侧，但exp不作为匹配的一部分
(?=exp)：括号中的子模式必须出现在匹配内容的右侧，但exp不作为匹配的一部分
(?<!exp)：括号中的子模式必须不出现在匹配内容的左侧，但exp不作为匹配的一部分
(?!exp)：括号中的子模式必须不出现在匹配内容的右侧，但exp不作为匹配的一部分
(?#comment)：注释组
(?aiLmsux)：旗标组，用于为整个正则表达式添加行内旗标
(?imsx-imsx:exp)：只对当前组起作用的旗标

贪婪模式与勉强模式

*：限定前面的子表达式可出现0~N次
+：限定前面的子表达式可出现1~N次
？：限定前面的子表达式出现0~1次
{n,m}：n和m均为非负整数，其中n≤m，限定前面的子表达式出现n~m次
{n,}：n是一个非负整数，限定前面的子表达式至少出n次
{,m}：m是一个非负整数，限定前面的子表达式至多出现m次
{n}：n是一个非负整数，限定前面的子表达式必须出现n次

容器相关类

set和frozenset

set集合有如下两个特征：

set不记录元素的添加顺序
元素不允许重复

set集合是可变容器，程序可以改变容器中的元素；与set对应的还有frozenset集合，是set的不可变版本，它的元素时不可变的。

方法名	语法格式	功能
add()	set.add()	向set集合添加元素
clear()	set.clear()	清空set集合中所有元素
copy()	set2 = set1.copy()	拷贝 set1 集合给 set2
difference()	set3 = set1.difference(set2)	将 set1 中有而 set2 没有的元素给 set3
difference_update()	set1.difference_update(set2)	从 set1 中删除与 set2 相同的元素
discard()	set1.discard(elem)	删除 set1 中的 elem 元素
intersection()	set3 = set1.intersection(set2)	取 set1 和 set2 的交集给 set3
intersection_update()	set1.intersection_update(set2)	取 set1和 set2 的交集，并更新给 set1
isdisjoint()	set1.isdisjoint(set2)	判断 set1 和 set2 是否没有交集，有交集返回 False；没有交集返回 True
issubset()	set1.issubset(set2)	判断 set1 是否是 set2 的子集
issuperset()	set1.issuperset(set2)	判断 set2 是否是 set1 的子集
pop()	a = set1.pop()	取 set1 中一个元素，并赋值给 a
remove()	set1.remove(elem)	移除 set1 中的 elem 元素
symmetric_difference()	set3 = set1.symmetric_difference(set2)	取 set1 和 set2 中互不相同的元素，给 set3
symmetric_difference_update()	set1.symmetric_difference_update(set2)	取 set1 和 set2 中互不相同的元素，并更新给 set1
union()	set3 = set1.union(set2)	取 set1 和 set2 的并集，赋给 set3
update()	set1.update(elem)	添加列表或集合中的元素到 set1

双端队列(deque)

栈是一种特殊的线性表，它只允许在一段进行插入、删除操作，这一段称为栈顶(top)，另一端称为栈底(bottom)。从栈顶插入一个元素称为进栈，从栈顶删除一个元素称为出栈。

队列也是一种特殊的线性表，它只允许在表的前端进行删除操作，在表的后端进行插入操作。进行插入操作的端称为队尾，进行删除操作的端称为队头。

双端队列代表一种特殊的队列，可以在两端同时进行插入、删除操作。

append和appendleft：在deque的右边或左边添加元素
pop和popleft：在deque的右边或左边弹出元素
extend和extendleft：在deque的右边或左边添加多个元素
rotate()：将队列的队尾元素移动到队头，使之首尾相连

Python的堆操作

Python直接把列表当作堆处理，提供heapq包中有一些函数，当程序用这些函数来操作列表时，表现出“堆”的行为。

heappush(heap,item)：将item元素加入堆
heappop(heap)：将堆中最小元素弹出
heapify(heap)：将堆属性应用到列表中
heapreplace(heap,x)：将堆中最小元素弹出，并将元素x入堆
merge(*iterables,key=None,reverse=False)：将多个有序的堆合并成一个大的有序堆，然后再输出
heappushpop(heap,item)：将item入堆，然后弹出并返回堆中最小的元素
nlargest(n,iterable,key=None)：返回堆中最大的n个元素
nsmallest(n,iterable,key=None)：返回堆中最小的n个元素

collections下的容器支持

ChainMap对象

ChainMap相当于把多个dict合并成一个大的dict，但实际上底层并未真正合并这些dict，ChainMap是一种“假”合并，但实际用起来又具有较好的效果。当多个dict中具有重复的key时，排在“链”前面的dict中key具有更高的优先级

Counter对象

Counter自动统计容器中各元素出现的次数。

Counter的本质是一个特殊的dict，只不过它的key都是其所包含的元素，而它的value则记录了该key出现的次数。因此，如果通过Counter并不存在的key访问value，将会输出0。

Counter还提供了如下常用的方法：

elements()：返回该Counter所包含的全部元素组成的迭代器
most_common([n])：返回Counter中出现最多的n各元素
subtract([iterable-or-mapping])：计算Counter的减法，其实就是计算减去之后各元素出现的次数

此外，对于Counter对象还有一些常用的操作，比如把Counter对象转换成set、list、dict等，还可对Counter执行加、减、交、并运算，对Counter进行求正、求负运算等。具体如下：

加：将两个Counter对象中各key出现的次数相加，且只保留出现次数为正的元素
减：将两个Counter对象中各key出现的次数相减，且只保留出现次数为正的元素
交：取两个Counter对象中都初夏的key且各key对应的次数的最小数
并：取两个Counter对象中各key对应的出现次数的最大数
求正：只保留Counter对象中出现次数为0或证书的key-value对
求负：只保留Counter对象中出现次数为负数的key-value对，并将出现系数改为正数

defaultdict对象

defaultdict是dict的子类，因此defaultdict可以当成dict来使用；与dict的区别在于：程序根据不存在的key来访问dict对应的value，则会引发KeyError异常，而defaultdict提供一个default_factory属性，该属性所指定的函数负责为不存在的key来生成value。

namedtuple工厂函数

namedtuple()是一个工厂函数，使用该函数可以创建一个tuple类的子类，该子类可以为tuple的美俄元素都指定字段名，就可以根据字段名来访问namedtuple的各元素。语法格式如下：

namedtuple(typename,field_names,*,verbose=False,rename=False,module=None)

typename：指定所创建的tuple子类的类名
field_names：一个字符串序列
rename：如果该参数设为True，那么无效的字段名将会被自动替换为位置名
verbose：如果该参数设为True，那么当该子类被创建之后，该类定义就会被立即打印出来
module：如果设置了该参数，那么该类将位于该模块下

OrderedDict对象

OrderedDict也是dict的子类，它可以“维护”添加key-value对的顺序。

由于OrderedDict是有序的，因此Python为之提供了2个方法：

popitem(last=True)：默认弹出并返回最右边的key-value对，如果将last参数设为False，则弹出并返回最左边的key-value对；
move_to_end(key,last=True)：默认将指定的key-value对移动到最右边；如果将last改为False，则将指定的key-value对移动到最左边。

函数相关模块

itertools模块的功能函数

在itertools模块中主要包含了一些用于生成迭代器的函数。

count(start,[step])：生成start，start+step的迭代器
cycle§：对序列p生成无限循环p0,p1,…p0,p1…的迭代器
repeat(elem,[,n])：生成无限个elem元素重复的迭代器
accumulate(p[,func])：默认生成根据序列p元素累加的迭代器，p0,p0+p1,p0+p1+p2,…序列，如果指定了func函数，则用func函数计算下一个元素的值
chain(p,q,…)将多个序列里的元素“链”在一起生成新的序列
compress(data,selectors)：根据selectors序列的值对data序列的元素进行过滤
dropwhile(pred,seq)：使用pred函数对seq序列进行过滤，从seq中第一个使用pred函数计算为False的元素开始，保留从该元素到序列结束的全部元素
takewhile(pred,seq)：该函数和上一个函数恰好相反
filterfalse(pred,seq)：使用pred函数对seq序列进行过滤，保留seq中使用pred计算为True的元素
islice(seq,[start,]stop[,step])：其功能类似于序列的slice方法，实际上就是返回seq[start:stop:step]的结果
starmap(func,seq)：使用func对seq序列的每个元素进行计算，将计算结果作为新的序列元素
zip_longest(p,q,…)：将p、q等序列中的元素按所有合并成元组，这些元组将作为新序列的元素