python-06-列表

01-字符串相关的操作

print('hello'.index('h'))

# 修改大小写

# capitalize 让第一个单词的首字母大写
print('hello world.good morning\nyes'.capitalize())

# upper 全大写
print('hello'.upper())  # HELLO

# lower 全小写
print('WoRLd'.lower())  # 面向对象里，我们称之为方法

# title 每个单词的首字母大写
print('good morning'.title())

# while True:
#     content = input('请输入内容，输入exit退出:')
#     print('您输入的内容是', content)
#     # if content.lower() == 'exit':
#     if content.upper() == 'EXIT':
#         break

# ljust(width,fillchar)
# width 长度   fillchar 填充字符，默认是空格
# 让字符串以指定长度显示，如果长度不够，默认在右边使用空格补齐
print('Monday'.ljust(10, '+'))
print('Tuesday'.rjust(12, '-'))
print('Wednesday'.center(20, '*'))

print('+++++apple+++'.lstrip('+'))
print('    pear     '.rstrip())
print('    banana     '.strip())

# 以某种固定格式显示的字符串，我们可以将它切割成为一个列表
x = 'zhangsan+lisi+wangwu+jack+tony+henry+chris'
names = x.split('+')
print(names)

# 将列表转换成为字符串
fruits = ['apple', 'pear', 'peach', 'banana', 'orange', 'grape']
print('-'.join(fruits))
print('*'.join('hello'))  # iterable可迭代对象
print('+'.join(('yes', 'ok')))

# print('*'.join({'name': 'zhangsan'}))

# 字符串的运算符
# 字符串和字符串之间可以使用加法运算，作用是拼接两个字符串
# 字符串和数字之间可以使用乘法运算，目的是将指定的字符串重复多次
# 字符串和数字之间做 == 运算结果是False,做 ！= 运算，结果是True
# 字符串之间做比较运算，会逐个比较字符串的编码值
# 不支持其他的运算符

python学习中strip()、rstrip()、lstrip()方法

本次记录的是python学习中strip()、rstrip()、lstrip()方法，具体使用记录如下：

功能：

Python中strip()方法可以去除字符串首尾指定的字符；

rstrip()方法可以去除字符串结尾指定的字符（r相当于right），并返回新字符串；

lstrip()方法可以去除字符串开头指定的字符（l相当于left），并返回新字符串；

语法：

str.strip([chars]);

str.lstrip([chars]);

str.rstrip([chars]);

参数说明：

str：需要进行操作的字符串；

chars：可选参数，需要被去除的字符串，默认为空格。

返回值：

python的strip()、rstrip()、lstrip()方法将会返回经过去除指定字符串的新字符串。

注意事项：

1、strip()该方法相当于lstrip()以及rstrip()的组合体。

实例说明：

>>> str=" hello world！ "

>>> str.strip()

输出值：hello world！

python学习过程中遇到的join()字符串方法函数

本次记录的是python学习过程中遇到的join()字符串方法函数，记录如下：

方法功能：

Python得join()方法是用来以指定的字符来序列化字符串序列的，也就是以指定的字符来连接字符序列从而生成新的字符串。

使用语法：

str.join(list)

参数说明：

str：指定的连接符

list:要连接的元素序列

返回值：

python的join()方法将会返回通过连接符连接元素序列后的字符串。

注意事项：

1、python的join()方法的str连接符可以为空但是不能省略，请注意！

实例说明：

>>>str = "-" #连接字符

>>>list= ("h", "e", "l", "l", "o"," ","w", "o", "r", "l", "d") # 字符串序列

>>>print (str.join(list))

h-e-l-l-o- -w-o-r-l-d

>>>str = "" #连接字符为空

>>>seq = ("h", "e", "l", "l", "o"," ","w", "o", "r", "l", "d") # 字符串序列

>>>print (str.join(list))

hello world

02-字符编码

# ASCII --> Latin1 --> Unicode编码
# 字符  -- > 数字编码存在一个对应的关系

# 使用内置函数  chr  和  ord 能够查看数字和字符的对应关系
# ord 获取字符对应的编码；  chr 根据编码获取对应的字符
print(ord('a'))  # 字符对应的编码是 97
print(chr(65))  # A

print(ord('こ'))
print(chr(12371))

print(ord('你'))  # 20320

# GBK  utf-8   BIG5
# 使用字符串的encode方法，可以将字符串转换成为指定编码集结果
# 如果有一个编码集的结果，想把它转换成为对应的字符，使用decode

# GBK编码，一个汉字占两个字节
print('你'.encode('gbk'))  # b'\xc4\xe3'  50403  11000100 11100011

# utf8编码，一个汉字占三个字节
print('你'.encode('utf8'))  # b'\xe4\xbd\xa0'   11100100 10111101 10100000

x = b'\xe4\xbd\xa0'
print(x.decode('utf8'))

# 把  `你好` 使用 gbk 编码
y = '你好'.encode('utf8')  # utf8一个汉字转换成为三个字节
print(y)  # b' \xe4\xbd\xa0   \xe5\xa5\xbd'

# gbk一个汉字占两个字节
print(y.decode('gbk'))  # 浣犲ソ   \xe4\xbd  \xa0\xe5  \xa5\xbd
print(y.decode('utf8'))  # txt 文本乱码，修改字符集

 目录

1、常用编码简介

2、使用encode()方法编码

3、使用decode()方法解码

4、Unicode和UTF-8的关系说明

我们在《Python中的基本数据类型》中，学习过：字符串就是连续的字符序列，可以是计算机能够表示的一切字符的集合。字符串属于不可变序列，通常用单引号（' '）、双引号（" "）或者三引号（''' '''或""" """）括起来。还提到了字符串常用的转义字符。今天主要来讲解一下字符串编码转换。

1、常用编码简介
1.1、ASCII，即美国标准信息交换码，1967年制定，主要用于美国和西欧，它仅对10个数字、26个大写英文字母、26个小写英文字母，以及一些其他符号进行了编码。ASCII码最多只能表示256个符号，每个字符占一个字节（bytes）。

1.2、GB2312，国家简体中文字符集，1980年制定，兼容ASCII。每个中文字符占两个字节。

1.3、Unicode，国际标准组织统一标准字符集，1991年制定。Unicode包含了跟全球所有国家编码的映射关系。每个字符占两个字节。

1.4、UTF-8，国际通用编码，制定于1992年，对全世界所有国家用到的字符都进行了编码。UTF-8采用一个字节表示英文字符，用三个字节表示中文。在Python3.x中默认的编码就是UTF-8编码，这就有效的解决了中文乱码的问题。

1.5、GBK，为GB2312的扩展字符集，兼容GB2312，支持繁体字，1995年制定。每个中文字符占两个字节。

在Python中，有两种常用的字符串类型，分别为str和bytes。其中，str表示Unicode字符（ASCII或者其他）；bytes表示二进制数据（包括编码的文本）。这两种类型的字符串不能拼接在一起使用。通常情况下，str在内存中以Unicode表示，一个字符对应若干个字节。但是如果在网络上传输，或者保存到磁盘上，就需要把str转换为字节类型，即bytes类型。

bytes类型的数据是带有b前缀的字符串（用单引号或双引号表示），例如，b'\xd2\xb0'和b'QQ'都是bytes类型的数据。

str和bytes之间可以通过encode()和decode()方法进行转换，这两个方法是互为逆过程。下面分别进行介绍。

2、使用encode()方法编码
encode()方法为str对象的方法，用于将字符串转换为二进制数据（即bytes），也称为“编码”，其语法格式如下：

 str.encode([encoding="utf-8"][,errors="strict"])

参数说明如下：

str：表示要进行转换的字符串。

encoding="utf-8"：可选参数，用于指定进行转码时采用的字符编码，默认为UTF-8，如果想使用简体中文，也可以设置为gb2312。当只有这一个参数时，也可以省略前面的“encoding=”，直接写编码。

errors="strict"：可选参数，用于指定错误处理方式，其可选择值可以是strict（遇到非法字符就抛出异常）、ignore（忽略非法字符）、replace（用“?”替换非法字符）或xmlcharrefreplace（使用XML的字符引用）等，默认值为strict。

说明

在使用encode()方法时，不会修改原字符串，如果需要修改原字符串，需要对其进行重新赋值。

例如，定义一个名称为a的字符串，内容为“星星之火可以燎原”，然后使用encode()方法将其采用GBK编码转换为二进制数，并输出原字符串和转换后的内容，代码如下：

a = '星星之火可以燎原'
b = a.encode('gbk')      # 将gbk编码转换为二进制数据，不处理异常 
print('原字符串：',a)    # 输出原字符串 
print('转换后：',b)      # 输出转换后的二进制数据
上面的代码执行后，将显示以下内容。

原字符串： 星星之火可以燎原
转换后： b'\xd0\xc7\xd0\xc7\xd6\xae\xbb\xf0\xbf\xc9\xd2\xd4\xc1\xc7\xd4\xad'
>>> 
如果采用UTF-8编码，转换后的二进制数据为：

a = '星星之火可以燎原'
b = a.encode('utf-8')    # 将utf-8编码转换为二进制数据，不处理异常 
print('原字符串：',a)    # 输出原字符串 
print('转换后：',b)      # 输出转换后的二进制数据
原字符串： 星星之火可以燎原
转换后： b'\xe6\x98\x9f\xe6\x98\x9f\xe4\xb9\x8b\xe7\x81\xab\xe5\x8f\xaf\xe4\xbb\xa5\xe7\x87\x8e\xe5\x8e\x9f'
>>> 
3、使用decode()方法解码
decode()方法为bytes对象的方法，用于将二进制数据转换为字符串，即将使用encode()方法转换的结果再转换为字符串，也称为“解码”。

其语法格式如下：

bytes.decode([encoding="utf-8"][,errors="strict"])

参数说明如下：

bytes：表示要进行转换的二进制数据，通常是encode()方法转换的结果。

encoding="utf-8"：可选参数，用于指定进行解码时采用的字符编码，默认为UTF-8，如果想使用简体中文，也可以设置为gb2312。当只有这一个参数时，也可以省略前面的“encoding=”，直接写编码。

errors="strict"：可选参数，用于指定错误处理方式，其可选择值可以是strict（遇到非法字符就抛出异常）、ignore（忽略非法字符）、replace（用“?”替换非法字符）或xmlcharrefreplace（使用XML的字符引用）等，默认值为strict。

站长在线提醒您：在使用decode()方法时，不会修改原字符串，如果需要修改原字符串，需要对其进行重新赋值。

例如，将上面示例中编码后得到二进制数据（保存在变量b中）进行解码，可以使用下面的代码：

a = b'\xd0\xc7\xd0\xc7\xd6\xae\xbb\xf0\xbf\xc9\xd2\xd4\xc1\xc7\xd4\xad'
print('解码后：',a.decode("gbk"))  # 对进行制数据进行解码
上面的代码执行后，将显示以下内容：

解码后： 星星之火可以燎原
>>> 
同样的，我们选择utf-8的字符串也是可以的

a = b'\xe6\x98\x9f\xe6\x98\x9f\xe4\xb9\x8b\xe7\x81\xab\xe5\x8f\xaf\xe4\xbb\xa5\xe7\x87\x8e\xe5\x8e\x9f'
print('解码后：',a.decode("utf-8"))  # 对进行制数据进行解码
上面的代码执行后，将显示以下内容：

解码后： 星星之火可以燎原
>>> 
站长在线提醒您：在设置解码采用的字符编码时，需要与编码时采用的字符编码一致。



本文相关知识扩展阅读：

4、Unicode和UTF-8的关系说明
Unicode直接支持全球所有语言，包含了跟全球所有国家编码的映射关系。

Unicode解决了字符和二进制的对应关系，但是使用unicode的每一个字符，都占用了两个字节，太浪费空间。如unicode表示“Python”需要12个字节才能表示，比原来ASCII表示增加了1倍。

由于计算机的内存比较大，并且字符串在内容中表示时也不会特别大，所以内容可以使用unicode来处理，但是存储和网络传输时一般数据都会非常多，那就不能这样传输了。

为了解决存储和网络传输的问题，出现了Unicode Transformation Format，学术名UTF，即：对unicode中的进行格式转换，以便于在存储和网络传输时可以节省空间!

UTF-8： 使用1、2、3、4个字节表示所有字符；优先使用1个字符、无法满足则使增加一个字节，最多4个字节。英文占1个字节、欧洲语系占2个、东亚语系占3个，其它及特殊字符占4个。

UTF-16： 使用2、4个字节表示所有字符；优先使用2个字节，否则使用4个字节表示。

UTF-32： 使用4个字节表示所有字符。

总结：UTF 是为unicode编码 设计 的一种在存储和传输时节省空间的编码方案。

03-成员运算符

# in 和 not in 运算符
# 用来判断一个内容在可迭代对象里是否存在

word = 'hello'
x = input('请输入一个字符:')

# 判断用户输入的字符在字符串里是否存在
# for c in word:
#     if x == c:
#         print('您输入的内容存在')
#         break
# else:
#     print('您输入的内容不存在')

# if word.find(x) == -1:
#     print('您输入的内容不存在')
# else:
#     print('存在')

# if x in word:
#     print('存在')
# else:
#     print('不存在')

if x not in word:
    print('不存在')
else:
    print('存在')

# in 和 not in 运算符
# 用来判断一个内容在可迭代对象里是否存在

04-格式化打印字符串

# 可以使用 % 占位符来表示格式化一个字符串
name = 'zhangsan'
age = 18
print('大家好，我的名字是', name, '我今年', age, '岁了', sep='')

# 在字符串里可以使用 %占位符
# %s ==> 表示的是字符串的占位符
# %d ==> 表示的整数的占位符
#  %nd  ==> 打印时，显示n位，如果不够，在前面使用空格补齐
# %f ==> 表示的浮点数的占位符
# %.nf ==> 保留小数点后n位
# %x ==> 将数字使用十六进制输出
# %% ==> 输出一个 %
print('大家好，我的名字是%s,我今年%d岁了,我今天挣了%f元钱' % (name, age, 3.14))

print('大家好，我是%3d号男嘉宾' % 15)
print('大家好，我是%-3d号男嘉宾' % 15)
print('大家好，我是%03d号男嘉宾' % 15)
print('我今天挣了%.2f元钱' % 3.14592653)

a = 255
print('%x' % a)  # ff
print('%X' % a)  # FF

# 我是%s
print('大家好，我是%%s,我今年%d岁了' % 19)

# 在字符串里可以使用 %占位符
# %s ==> 表示的是字符串的占位符
# %d ==> 表示的整数的占位符
#  %nd  ==> 打印时，显示n位，如果不够，在前面使用空格补齐
# %f ==> 表示的浮点数的占位符
# %.nf ==> 保留小数点后n位
# %x ==> 将数字使用十六进制输出
# %% ==> 输出一个 %

#%r ==》这个好像是代表任意类型

05-字符串format方法的使用

# {} 也可以进行占位

# {} 什么都不写，会读取后面的内容，一一对应填充
x = '大家好，我是{},我今年{}岁了'.format('张三', 18)
print(x)

# {数字} 根据数字的顺序来进行填入。数字从 0 开始
y = '大家好，我是{1},我今年{0}岁了'.format(20, 'jerry')
print(y)

# {变量名}
z = '大家好，我是{name},我今年{age}岁了,我来自{addr}'.format(age=18, name='jack', addr='襄阳')
print(z)

# 混合使用  {数字}  {变量}
a = '大家好，我是{name},我今年{1}岁了,我来自{0}'.format('泰国', 23, name='tony')
print(a)

# {}什么都不写  {数字} 不能混合使用

d = ['zhangsan', 18, '上海', 180]
# b = '大家好，我是{},我今年{}岁了,我来自{},身高{}cm'.format(d[0], d[1], d[2], d[3])
b = '大家好，我是{},我今年{}岁了,我来自{},身高{}cm'.format(*d)
print(b)

info = {'name': 'chris', 'age': 23, 'addr': '北京', 'height': 190}
c = '大家好，我是{name},我来自{addr},身高{height}cm,我今年{age}岁了'.format(**info)
print(c)

这个和%和类似，就是一直输出的格式问题

06-列表的基本使用

# 当我们有多个数据需要按照一定的顺序保存的时候，我们可以考虑列表
# name1 = '张三'
# name2 = '李四'
# name3 = '王五'
# name4 = 'jack'

# 使用 [] 来表示一个列表，列表里的每一个数据我们称之为元素
# 元素之间使用逗号进行分割
names = ['张三', '李四', '王五', 'jack', '张飞', '关羽', '马超', '王昭君', '蔡文姬']

# 和字符串一样，都可以使用下标来获取元素和对元素进行切片
# 同时，我们还可以使用下标来修改列表里的元素
print(names[3])
names[3] = '花木兰'
print(names)

# 也可以通过下标来实现切片
print(names[3:7])

# x = 'hello'
# print(x[1])
# x[0] = 'm'  # 字符串只能获取，不能修改，字符串是不可变数据类型

# 可以使用 list(可迭代对象) 将可迭代对象转换成为一个列表
# names = list(('兰陵王', '东皇太一', '王昭君', '程咬金'))
# print(names)

# 当我们有多个数据需要按照一定的顺序保存的时候，我们可以考虑列表

# 使用 [] 来表示一个列表，列表里的每一个数据我们称之为元素
# 元素之间使用逗号进行分割

# 和字符串一样，都可以使用下标来获取元素和对元素进行切片
# 同时，我们还可以使用下标来修改列表里的元素

# 可以使用 list(可迭代对象) 将可迭代对象转换成为一个列表

07-列表增加元素

# 列表是用来保存多个数据的，是有序可变的
# 操作列表，一般都包含增加数据、删除数据、修改数据以及查询数据
# 增删改查

heros = ['阿珂', '嬴政', '韩信', '露娜', '后羿', '亚瑟', '李元芳']
# 添加元素的方法  append  insert extend
heros.append('黄忠')
print(heros)  # append在列表的最后面追加一个数据

# insert(index,object)  需要两个参数
# index 表示下标，在哪个位置插入数据
# object 表示对象，具体插入哪个数据
heros.insert(3, '李白')
print(heros)

x = ['马可波罗', '米莱迪', '狄仁杰']
# extend(iterable)  需要一个可迭代对象
# A.extend(B) ==> 将可迭代对象 B 添加到 A 里
heros.extend(x)
print(heros)
print(x)

# 列表是用来保存多个数据的，是有序可变的
# 操作列表，一般都包含增加数据、删除数据、修改数据以及查询数据
# 增删改查

# 添加元素的方法  append  insert extend

# append在列表的最后面追加一个数据

# insert(index,object)  需要两个参数
# index 表示下标，在哪个位置插入数据
# object 表示对象，具体插入哪个数据

# extend(iterable)  需要一个可迭代对象（可理解为一次可以加很多，直接加一个列表）
# A.extend(B) ==> 将可迭代对象 B 添加到 A 里

08-列表删除修改和查询元素

masters = ['王昭君', '甄姬', '貂蝉', '妲己', '小乔', '大乔']

# 删除数据有三个相关的方法   pop   remove  clear
# pop 方法默认会删除列表里最后一个数据,并且返回这个数据
# pop还可以传入index参数，用来删除指定位置上的数据
x = masters.pop(3)
print(masters)  # ['王昭君', '甄姬', '貂蝉', '小乔', '大乔']

# remove用来删除指定的元素
masters.remove('小乔')
# masters.remove('妲己')  如果数据在列表中不存在，会报错
print(masters)

# 使用del 也可以删除一个数据
del masters[2]
print(masters)

# clear 用来清空一个列表
masters.clear()
print(masters)

# a = 100
# del a
# print(a)


tanks = ['亚瑟', '程咬金', '盾山', '张飞', '廉颇', '程咬金']
# 查询相关的方法
print(tanks.index('盾山'))  # 2
# print(tanks.index('庄周'))  如果元素不存在，会报错
print(tanks.count('程咬金'))  # 2
# in 运算符
print('张飞' in tanks)  # True
print('苏烈' in tanks)  # False

# 修改元素
# 使用下标可以直接修改列表里的元素
tanks[5] = '铠'
print(tanks)

# 删除数据有三个相关的方法   pop   remove  clear
# pop 方法默认会删除列表里最后一个数据,并且返回这个数据
# pop还可以传入index参数，用来删除指定位置上的数据

# remove用来删除指定的元素
masters.remove('小乔')
# masters.remove('妲己')  如果数据在列表中不存在，会报错

# clear 用来清空一个列表
masters.clear()

# 使用del 也可以删除一个数据（补充）
del masters[2]
print(masters)

09-列表的遍历

# 遍历: 将所欲的数据都访问一遍。遍历针对的是可迭代对象
# while循环遍历  / for...in 循环遍历
killers = ['李白', '兰陵王', '韩信', '赵云', '阿珂', '孙悟空']

# for...in循环的本质就是不断的调用迭代器的 next 方法查找下一个数据
for k in killers:
    print(k)

i = 0
while i < len(killers):
    print(killers[i])
    i += 1

# 遍历: 将所欲的数据都访问一遍。遍历针对的是可迭代对象
# while循环遍历  / for...in 循环遍历

# for...in循环的本质就是不断的调用迭代器的 next 方法查找下一个数据

10-交换两个变量的值

a = 13
b = 20

# 方法一:使用第三个变量实现
# c = b
# b = a
# a = c

# 方法二:使用运算符来实现.只能是数字
# a = a + b
# b = a - b
# a = a - b

# 方法三:使用异或运算符
# a = a ^ b
# b = a ^ b
# a = a ^ b

# 方法四:使用Python特有
a, b = b, a

print(a)  # 20
print(b)  # 13

# 方法四:使用Python特有
a, b = b, a

11-冒泡排序

nums = [6, 5, 3, 1, 8, 7, 2, 4]

# 冒泡排序思想:
# 让一个数字和它相邻的下一个数字进行比较运算
# 如果前一个数字大于后一个数字，交换两个数据的位置

# nums[0]  nums[1]
# nums[1]  nums[2]
# ... ...
# nums[n]  nums[n+1]
# ... ...
# nums[length - 2] nums[length - 1]

# 每一趟比较次数的优化
# 总比较趟数的优化
i = 0
while i < len(nums) - 1:
    i += 1
    n = 0

    while n < len(nums) - 1:
        if nums[n] > nums[n + 1]:
            nums[n], nums[n + 1] = nums[n + 1], nums[n]
        n += 1

    print(nums)

# 有一个列表names，保存了一组姓名names=['zhangsan','lisi','chris','jerry','henry']
# 再让用户输入一个姓名，如果这个姓名在列表里存在，提示用户姓名已存在；
# 如果这个姓名在列表里不存在，就将这个姓名添加到列表里。

冒泡排序：两个循环，第一个循环循环排的次数，第二个循环循环哪两个排

12-列表的排序和反转

nums = [6, 5, 3, 1, 8, 7, 2, 4]

# 调用列表的 sort 方法可以直接对列表进行排序
# 直接对原有的列表进行排序

# nums.sort(reverse=True)
# print(nums)

# 内置函数sorted,不会改变原有的列表数据，会生成一个新的有序数据
x = sorted(nums)
print(nums)
print(x)

names = ['zhangsan', 'lisi', 'wangwu']
names.reverse()
print(names)

print(names[::-1])

# 内置函数sorted,不会改变原有的列表数据，会生成一个新的有序数据

# 函数reverse()，反转列表元素的顺序

13-列表的复制

x = [100, 200, 300]

# x 和  y 指向了同一个内存空间，会相互影响
y = x  # 等号是内存地址的赋值

# 调用copy方法，可以复制一个列表
# 这个新列表和原有的列表内容一样，但是指向不同的内存空间
z = x.copy()

x[0] = 1

print(z)

# 除了使用列表自带的 copy 方法以外，还可以使用copy模块实现拷贝

import copy

a = copy.copy(x)  # 效果等价于 x.copy(),都是一个浅拷贝
# 深拷贝

# 切片其实就是一个浅拷贝
names1 = ['张三', '李四', '王五', '杰克']
names2 = names1[::]
names1[0] = 'jerry'
print(names2)

# x 和  y 指向了同一个内存空间，会相互影响
y = x  # 等号是内存地址的赋值

# 调用copy方法，可以复制一个列表
# 这个新列表和原有的列表内容一样，但是指向不同的内存空间
z = x.copy()

# 除了使用列表自带的 copy 方法以外，还可以使用copy模块实现拷贝

import copy
a = copy.copy(x)  # 效果等价于 x.copy(),都是一个浅拷贝
# 深拷贝
# 切片其实就是一个浅拷贝

浅拷贝可以理解为，前一个改变了。后面的浅拷贝内容会改变的，是浅拷贝

一、深拷贝是什么？

1.概念： 创建一个新的对象和数组，将原对象的各项属性的“值”（数组的所有元素）拷贝过来，是“值”而不是“引用”，新对象跟原对象不共享内存，修改新对象不会改到原对象

为什么使用深拷贝

我们希望在改变新的数组（对象）的时候，不会改变原数组（对象）