Python 数据类型用法

目录

• 1：整数类型（int）
  • 1：用途
  • 2：定义方式
• 2：浮点数类型（float）
  • 1：用途
  • 2：定义方式
• 3：数据类型之间转换
• 4:字符串类型(str)
  • 1：用途
  • 2:定义方式
  • 3:str方法
    • 一:根据索引取值
    • 二:切片取值（左闭右开）
    • 三:长度
    • 四:成员运算（in，not in)
    • 5:非常重重要（split,strip)
    • 7：重要方法
    • 8：了解方法
• 5：列表类型
  • 1：用途
  • 2：定义方式
  • 3:类型转换
  • 4：常用操作和内置方法
    • 1：索引次数，取值（正向，方向):即可改也可取
    • 2:切片（顾头不顾尾巴，步长）
    • 3：长度
    • 4:成员运算in和not in
    • 5：追加
    • 6：删除
    • 7：循环
    • 8：重要方法
  • 5:总结
• 6:元组数据类型
  • 1、用途：元组就是一个不可变的列表
  • 3、常用操作+内置的方法
  • 优先掌握的操作：
• 7：字典数据类型
  • 1、用途
  • 2、定义方式：
  • 3:类型转换
  • 4:定义空
  • 5：常用操作+内置的方法
• 8：set数据类型
  • 1：引子
  • 2：用途：
  • 3：定义方式
  • 3、常用操作+内置的方法

1：整数类型（int）

1：用途

 int:记录年龄,等级,岁月等

2：定义方式

>>> x = 10
>>> id(x)
1489303616
>>> type(x)
<class 'int'>

2：浮点数类型（float）

1：用途

float:记录重量，工资等

2：定义方式

>>> x = 1.5
>>> y = 8.8
>>> type(x)
<class 'float'>

3：数据类型之间转换

>>> age = "134423"
>>> print(type(age))
<class 'str'>
>>> age = int(age)
>>> type(age)
<class 'int'>
警告
	纯数字类型字符串可以通过int方法转换成数字类型

>>> salary = "2.5"
>>> type(salary)
<class 'str'>
>>> salary=float(salary)
>>> salary
2.5
>>> type(salary)
<class 'float'>
>>>
警告
	纯浮点类型字符串可以通过float方法转换成浮点类型

4:字符串类型(str)

1：用途

主要是用来描述事物特征的

2:定义方式

x = 'x'
1 2  3
1:是变量名
2:是赋值符号
3:值用'content','''content''',"""content"""

3:str方法

一:根据索引取值

1:正向取值

>>>msg = 'hello小白兔'
>>>msg
'hello小白兔'
索引从0开始
>>>msg[0]
'h'
>>>msg[1]
'e'

2：反向取值
索引从-1开始

'hello小白兔'
>>> msg[-1]
'兔'
>>> msg
'hello小白兔'
>>> msg[-1:-6]
''
>>> msg[-3]
'小'
>>> msg[-13]
Traceback (most recent call last):
  File "<stdin>", line 1, in <module>
IndexError: string index out of range
超过范围，报错

3:步长

>>> msg
'hello小白兔'
>>> msg[0:5:2]
'hlo'
>>>
用步长方向取值
>>> msg[:]
'hello小白兔'
>>> msg[::-1]
'兔白小olleh'

二:切片取值（左闭右开）

1:正常从左向右

>>> msg
'hello小白兔'
>>> msg[2:]
'llo小白兔'
>>> msg[:]
'hello小白兔'
>>> msg[1:]
'ello小白兔'
>>> msg[1:4]
'ell'

2:反向取值

​ > msg

>>> msg[4:0:-1
... ]
'olle'
>>> msg[7:5:-1]
'兔白'
>>> msg[7:4:-1]
'兔白小'

三:长度

​ msg='hello小白兔'

>>> msg
'hello小白兔'
>>> len(msg)
8

四:成员运算（in，not in)

>>> msg
'hello小白兔'
>>> 'h' in msg
True
>>> 'aaa' in msg
False
>>> 'ee' in msg
False
>>> 'alex' in msg
False
>>> 'a' not in msg
True
>>>

5:非常重重要（split,strip)

split方法

>>> msg
'hello小白兔'
>>> msg.split('小')
['hello', '白兔']
>>> msg.split('o')
['hell', '小白兔']
>>> msg.split('l')
['he', '', 'o小白兔']
>>>

strip方法

>>> msg = ' hello小白兔'
>>> msg1 = 'hello小白兔 '
>>> msg3 = ' hello小白兔 '
>>> msg4 = ' hello 小白兔 '
>>> msg
' hello小白兔'
>>> msg1
'hello小白兔 '
>>> msg3
' hello小白兔 '
>>> msg4
' hello 小白兔 '
>>>
>>>
>>> msg1
'hello小白兔 '
>>> msg1.strip()
'hello小白兔'
>>> msg1
'hello小白兔 '

>>> msg3
' hello小白兔 '
>>> msg3.strip()
'hello小白兔'
>>> msg4
' hello 小白兔 '
>>> msg4.strip()
'hello 小白兔'
>>>

7：重要方法

1、strip,lstrip,rstrip

>>> msg = ' hellowstrip '
>>> msg.strip()
'hellowstrip'
>>> msg.lstrip()
'hellowstrip '
>>> msg.rstrip()
' hellowstrip'
>>>

2、lower,upper

>>> msg = 'Alex'
>>> msg.lower()
'alex'
>>> msg.upper()
'ALEX'
>>>

3、startswith,endswith

>>> msg
'Alex'
>>> msg.startswith('al')
False
>>> msg.startswith('A')
True
>>> msg
'Alex'
>>> msg.endswith('x')
True

>>> msg
'Alex'
>>> msg.endswith('x')
True
>>> msg.endswith('x', 1, 2)
False
>>> msg.endswith('e', 1, 2)
False
>>> msg.endswith('l', 1, 2)
True
>>> msg.endswith('l', 1, 2)
True
>>>


4、format

>>> 'hello word: {}'.format('strip')
'hello word: strip'
>>>
>>> "my name is {},age {}".format('Seven', 18)
'my name is Seven,age 18'
>>>



5、split,rsplit

>>> name = 'fdsfa '
>>> name
'fdsfa '
>>> name.split('s')
['fd', 'fa ']
>>>
>>> name.rsplit('f')
['', 'ds', 'a ']


6、join

>>> name = 'sfsaf'
>>> name
'sfsaf'
>>> '-'.join(name)
's-f-s-a-f'
>>> '*'.join(name)
's*f*s*a*f'
>>>

7、replace
>>> 'zero'.replace('o','8')
'zer8'
>>>


8、isdigit

>>> '100'.isdigit()
True
>>> 'afds'.isdigit()
False
>>> '110032fdf'.isdigit()
False
>>>

8：了解方法

1、find,rfind,index,rindex,count

>>> name = 'hello word'
>>> name.find('o',1,3) #  顾头不顾尾,找不到则返回-1不会报错,找到了则显示索引
-1
>>> name.index('o',1,3)  #  顾头不顾尾,找不到则报错,找到了则显示索引
Traceback (most recent call last):
  File "<stdin>", line 1, in <module>
ValueError: substring not found
>>> name.count('e',3,7) # 顾头不顾尾,如果不指定范围则查找所有
0
>>> name.count('o',3,7)
1
>>>



2、center,ljust,rjust,zfill

>>> 'alex'.center(50,'*')
'***********************alex***********************'
>>> 'alex'.ljust(50,'*')
'alex**********************************************'
>>> 'alex'.rjust(50, '*')
'**********************************************alex'
>>> 'alex'.zfill(50)
'0000000000000000000000000000000000000000000000alex'
>>>


3、expandtabs

>>> 'name	nihao'.expandtabs(2)
'name  nihao'
>>> 'name	nihao'.expandtabs()
'name    nihao'
>>> 'name	nihao'.expandtabs(3)
'name  nihao'
>>> 'name	nihao'.expandtabs(3)


4、captalize,swapcase,title

>>> name ='absfds'
>>> name.capitalize()
'Absfds'
>>> name.swapcase()
'ABSFDS'
>>> 'asfD'.swapcase()
'ASFd'
>>> 'hello word'.title()
'Hello Word'

5、is数字系列

#在python3中
num1=b'4' #bytes
num2=u'4' #unicode,python3中无需加u就是unicode
num3='四' #中文数字
num4='Ⅳ' #罗马数字

#isdigt:bytes,unicode
print(num1.isdigit()) #True
print(num2.isdigit()) #True
print(num3.isdigit()) #False
print(num4.isdigit()) #False

#isdecimal:uncicode
#bytes类型无isdecimal方法
print(num2.isdecimal()) #True
print(num3.isdecimal()) #False
print(num4.isdecimal()) #False

#isnumberic:unicode,中文数字,罗马数字
#bytes类型无isnumberic方法
print(num2.isnumeric()) #True
print(num3.isnumeric()) #True
print(num4.isnumeric()) #True

#三者不能判断浮点数
num5='4.3'
print(num5.isdigit())
print(num5.isdecimal())
print(num5.isnumeric())
'''
总结:
    最常用的是isdigit,可以判断bytes和unicode类型,这也是最常见的数字应用场景
    如果要判断中文数字或罗马数字,则需要用到isnumeric
'''

6、is其他
print('===>')
name='egon123'
print(name.isalnum()) #字符串由字母或数字组成
print(name.isalpha()) #字符串只由字母组成

print(name.isidentifier())
print(name.islower())
print(name.isupper())
print(name.isspace())
print(name.istitle())

5：列表类型

1：用途

按照位置存放多个值

2：定义方式

在[]内用逗号分隔开多个任意类型的值
l = [111, 3.1, 'abc', []] #l = list(......)
print(type(l))

3:类型转换

list(传入的是可迭代数据类型)

>>> list('hello')
['h', 'e', 'l', 'l', 'o']
>>> list(14234)
Traceback (most recent call last):
  File "<stdin>", line 1, in <module>
TypeError: 'int' object is not iterable
>>> list('asfsf'
... )
['a', 's', 'f', 's', 'f']
>>>

4：常用操作和内置方法

1：索引次数，取值（正向，方向):即可改也可取

>>> l = [11, 22, 33, 44, 55]
>>> l
[11, 22, 33, 44, 55]
>>> l[::-1]
[55, 44, 33, 22, 11]
>>> l[2:]
[33, 44, 55]
>>> l[1:3]
[22, 33]
>>>
>>> l[5]
Traceback (most recent call last):
  File "<stdin>", line 1, in <module>
IndexError: list index out of range

2:切片（顾头不顾尾巴，步长）

>> l = [1, 2, 3, 4, 5]
>>> l
[1, 2, 3, 4, 5]
>>> l[:]
[1, 2, 3, 4, 5]
>>> l[0:3]
[1, 2, 3]
>>> l[0]
1

>>> l[4]
5
>>>

3：长度

>>> l
[11, 22, 33, 44, 55]
>>> len(l)
5

4:成员运算in和not in

>>> l
[11, 22, 33, 44, 55]
>>> len(l)
5
>>> 11 in l
True
>>> 11 not in l
False
>>> 77 in l
False

5：追加

>
>>> l= [11, 22, 33, 44, 55]
>>> l
[11, 22, 33, 44, 55]
>>> l.append('66')
>>> l.append('abc')
>>> l
[11, 22, 33, 44, 55, '66', 'abc']

1:往指定位置插入值

>>> l
[11, 22, 33, 44, 55, '66', 'abc']
>>> l.insert(0,'aa')
>>> l
['aa', 11, 22, 33, 44, 55, '66', 'abc']
>>> l.insert(3,'bb')
>>> l
['aa', 11, 22, 'bb', 33, 44, 55, '66', 'abc']
>>>

6：删除

del　删除是通用的，不是列表专属
>>> ll = [111, 222, 333, 444]
>>> ll
[111, 222, 333, 444]
>>> del ll[0]
>>> ll
[222, 333, 444]
>>>

1:pop方法

pop没有参数默认从索引-1开始删除，
>>> ll = [1, 2, 3, 4, 5, 6]
>>> ll
[1, 2, 3, 4, 5, 6]
>>> ll.pop()
6
>>> ll
[1, 2, 3, 4, 5]
>>> ll.pop()
5
>>> ll
[1, 2, 3, 4]
>>> ll.pop(0)
1
>>> ll
[2, 3, 4]
>>>

2：remove用法

>>> ll = [1, 2, 3, 4, 5, 6]
>>> ll
[1, 2, 3, 4, 5, 6]
>>> ll.remove(1)
>>> ll
[2, 3, 4, 5, 6]
>>> ll.remove(5)
>>>

7：循环

>>> ll = [1, 2, 3, 4, 5, 6]
>>> ll
[1, 2, 3, 4, 5, 6]
>>> for i in ll:
...     print(i)
...
1
2
3
4
5
6
>>>

8：重要方法

# 需要掌握的操作

#count
>>> ll = [11, 22, 33, 44, 55]
>>> ll.count(11)
1
>>> ll.append(11)
>>> ll.count(11)
2
>>> ll
[11, 22, 33, 44, 55, 11]

## sort
>>>
>>> ll = [10, -1, 3, 2, 11, 7]
>>> ll.sort()
>>> ll
[-1, 2, 3, 7, 10, 11]
>>> ll.sort(reverse=True)
>>> ll
[11, 10, 7, 3, 2, -1]
>>>

##clear
>>> ll
[11, 10, 7, 3, 2, -1]
>>> ll
[11, 10, 7, 3, 2, -1]
>>> ll.clear()
>>>

#reverse

>>> ll = ['a','c',1,4]
>>> ll
['a', 'c', 1, 4]
>>> ll.reverse()
>>> ll
[4, 1, 'c', 'a']
>>>

# extend
>>>
>>> ll = [11, 22, 33]
>>> ll.extend(['a', 'b', 'c'])
>>> ll
[11, 22, 33, 'a', 'b', 'c']

>>> ll.append(['hehe', 'good'])
>>> ll
[11, 22, 33, 'a', 'b', 'c', ['hehe', 'good']]

## copy
l1=[11,22,33]
# l1列表内存存储
# 索引0 值11的内存地址
# 索引1 值22内存地址
# 索引2 值33内存地址

# l2=l1.copy() # 等同于l4=l1[:]
# l2列表内存存储
# 索引0 值11的内存地址
# 索引1 值22内存地址
# 索引2 值33内存地址
# l2[0]=4444
# print(l2) # [4444, 22, 33]
# print(l1) # [11, 22, 33]

>>> l1 = [11, 22, 33]
>>> l1
[11, 22, 33]
>>> id(l1)
53887432
>>> l2 = l1.copy() or l2 = l1[:]
>>> id(l2)
53887944
>>> l3 = l1
>>> id(l3)
53887432


# l3=l1
# l3[0]=4444
# print(l3)
# print(l1)

5:总结

list是能存储多个值，有序，可变

6:元组数据类型

1、用途：元组就是一个不可变的列表

2、定义方式: 在小括号()内用逗号分隔开多个任意类型的值

l = [1, 2, 3]
t = (1, 2, 3)  # t = tuple((111,222,333)) or t = tuple(1,)
print(type(t))

类型转换
tuple(可迭代数据类型)  # ===> 元组
list(可迭代数据类型)  # ===> 列表

l1 = ['a', 'b', 'c', 'd']
s1 = 'abcedfghijk'
print(tuple(l1))
print(tuple(s1))

3、常用操作+内置的方法

优先掌握的操作：

1、按索引取值(正向取+反向取)：只能取
l2 = (1, 2, 3, 4, 5, 6, 7, 8, 9)
print(l2)
print(l2[0])
print(l2[-1:1:-1])

2、切片(顾头不顾尾，步长)
t = (1, 2, 3)
print(t[0:2])
print(t)

3、长度
t = (1, 222, 333)
print(len(t))

4、成员运算in和not in

t = (1, 2, 3, 4)
print(4 in t)

5、循环

t = [0, 1, 2, 3, 4]
for i in t:
    print(i)

需要掌握的内置方法
index根据参数找索引
count统计参数出现的次数
t = (4, 3, 2, 4, 2, 1, 5, 8, 11, 19, 1)
print(t.index(1))
print(t.index(8)) # 找不到则报错

print(t.count(1))

7：字典数据类型

1、用途

存多个不同属性的值，用key对应value，key必修是不可变类型，key通常应该是

​ 字符串类型，因为字符串类型对值value会有解释说明的效果

2、定义方式：

在{}内用逗号分隔开多个key:value元素，其中key必须是不可变类型，并且key不同重复

而value可以是任意类型

dic = {'k1': 1, 'k2': 2, 'k3': 3}  # dic = dict({'k1': 1, 'k2': 2, 'k3':3})
print(type(dic))

d = {'k1': 1, 'k2': 2, 'k3': 3}
print(d)

3:类型转换

d = [('name', 'egon'), ['age', 18], ('gender', 'male')]
print(d)
print(dict(d))
res=dict(x=1,y=2,z=3)
print(res)

4:定义空

 定义空
 d={} # 定义空字典
 print(type(d))
 d = dict()

 s=''
 print(type(s))

 l=[]
 print(type(l))

 t=()
 print(type(t))
 t=("abc",) # 当元组内只有一个元素时，必须加逗号
 print(t)
 print(type(t))

# s=set() # 定义空集合

5：常用操作+内置的方法

优先掌握的操作：
1、按key存取值：可存可取
d={'name':'egon','age':18, 'salary':4}
l=[1,2,3]

print(d['name'])
print(l[0])

d['gender']='male' # 可以通过不存在的key完成赋值操作来达到为字典添加值的效果
print(d)
l[3]=4 # 列表不行

2、长度len
d={'name':'egon','age':18, 'gender': 'male'}
print(len(d))
3、成员运算in和not in:判断的是字典的key
d={'name':'egon','age':18}
print("name" in d) # 判断的字典的key
print("egon" in d) # 判断的不是value，结果为False

4、删除
a：通用删除法
d={'name':'egon','age':18, 'gender': 'male'}
del d['gender']
print(d)

b:删除-》取走
res=d.popitem() # 随机删除，返回一个删除元素的小元组
print(res)

res=d.pop('name') # 返回key对应的那一个值
print(res)

print(d)

#5、键keys()，值values()，键值对items()
'''
Python 2.7.18 (v2.7.18:8d21aa21f2, Apr 19 2020, 20:48:48) 
[GCC 4.2.1 Compatible Apple LLVM 6.0 (clang-600.0.57)] on darwin
Type "help", "copyright", "credits" or "license" for more information.
# >>> d={'name':'egon','age':18}
# >>> 
# >>> d.keys()
# ['age', 'name']
# >>> d.values()
# [18, 'egon']
# >>> d.items()
[('age', 18), ('name', 'egon')]
'''
#6、循环
d={'name':'egon','age':18, 'gender': 'male'}

for k in d.keys():
     print(k)

for k in d:
	print(k)


for v in d.values():
	print(v)

for k,v in d.items(): # k,v=('age', 18)
 	print(k,v)


字典需要掌握的内置方法
clear
d={'name':'egon','age':18, 'gender': 'male'}
d.clear()
print(d)

update
d.update(age=19,gender='male')
d.update({'age':19,"gender":"male"})
print(d)

get
print(d.get('nama')) # key不存在不会报错，会返回None
print(d["nama"]) # key不存在则报错

了解**
快速初始化好一个字典
d={}.fromkeys(["name","age","gender"],None)
print(d)

d={'age':18}

保证字典中肯定有一个key是"name"
if "name" not in d:
 d["name"]="egon"
d["name"]


val=d.setdefault("name","egon")
print(d)
print(val)

8：set数据类型

1：引子

friends1=["zero","kevin","jason","egon"]
friends2=["jy","ricky",'jason',"egon"]

l=[]
for name in friends1:
    if name not in friends2:
        l.append(name)
print(l)

2：用途：

去重，关系运算

3：定义方式

在{}内用逗号分隔开多个元素，元素的特点如下：

1：无序
s1={'aaa',111,'ddd'}
print(s1)
print(s1)
print(s1)

2：元素必须是不可变类型
s1={1,2.2,"abc",(1,2),[]}

3: 集合内元素不能重复
s1={1,1,1,1,1,1,1,1,1,1,1,} # s1=set(...)
print(s1)
print(type(s1))
s2=set()
print(type(s2))

4：类型转换

set(可迭代数据类型)
res=set("hello")
print(res)
print("".join(res))

res=set([111,222,333,444,111,111])
print(res)
print(list(res))

去重
res=set([111,[222],[222],333,444,111,111])

src_l=[
    {'name':'lili','age':18,'sex':'male'},
    {'name':'jack','age':73,'sex':'male'},
    {'name':'tom','age':20,'sex':'female'},
    {'name':'lili','age':18,'sex':'male'},
    {'name':'lili','age':18,'sex':'male'},
]
new_l=[]
for dic in src_l:
    if dic not in new_l:
        new_l.append(dic)
print(new_l)
print(id(src_l[0]))
print(id(src_l[-1]))

3、常用操作+内置的方法

​ 1：关系运算

>>> f1 = {1, 2, 3, 4}
>>> f2 = {3, 4, 5, 6}
1,交集:两个都有的
>>> f1 & f2
{3, 4}

2,并集:两个集合的包含
>>> f1 | f2
{1, 2, 3, 4, 5, 6}

3,取第一个人独有的元素：差集
>>> f1 = {1, 2, 3, 4}
>>>f2 = {3, 4, 5, 6}
>>> f2-f1
{5, 6}
>>> f1-f2
{1, 2}


4、求两个集合独有的（即去掉共有的元素）:对称差集/交叉补集
>> f1 = {1, 2, 3, 4}
>>>f2 = {3, 4, 5, 6}
>>> fs1 = f2-f1
{5, 6}
>>>fs2 = f1-f2
{1, 2}
>>>fs1|fs2
{1, 2, 5, 6}
>>> f1^f2
{1, 2, 5, 6}

5、父子集：一个集合包含另外一个集合，他们才有父子集的关系
>> f1 = {1, 2, 3, 4}
>>>f2 = {3, 4, 5, 6}
>>> f1>f2
False
>>> f2>f1
False
>>> f2==f1
False


集合1>集合2 结果True时，意味着集合1内的元素完全包含了集合2的元素
f1={1,2,3}
f2={1,2}

>>> f1={1, 2, 3}
>>> f2={1, 2}
>>> f1>f2
True
# 结果True，代表f1是f2的父集
>>>f2 < f1 # 结果True，代表s2是s1的子集
False

f1 = {1, 2, 3, 4}
f2 = {3, 2, 1, 4}
>>> f1 = {1, 2, 3, 4}
>>> f2 = {3, 2, 1, 4}
>>> f1==f2 #集合f1于f2互为父集
True

2:内置方法

1:集合for循环
>>> s = {'a', 1, 2, 4, 5, 3, 'z','qq'}
>>> for i in s:
...     print(i)
...
1
2
3
4
5
z
a

1,s.update()
>>> id(s)
19712456
>>> s.update({7, 8 ,11})
>>> s
{1, 2, 3, 4, 5, 7, 8, 'z', 11, 'a', 'qq'}
>>> id(s)
19712456
>>>

2、s.clear()
>>> s
{1, 2, 3, 4, 5, 7, 8, 'z', 11, 'a', 'qq'}
>>> s.clear()
>>> s
set()


3、s1.pop()
>>> s = {'a', 1, 'z', 'dd', 'qq'}
>>> s.pop()
1
>>> s.pop()
'dd'
>>>
# 随机删除，把元素取走，有返回删除元素

4、s.remove() # 只是删除，没有返回元素
>>> s = {'a', 'b', 'c', 1, '3', 4}
{1, 4, 'b', 'a', '3', 'c'}

>>> s.remove('aaa')
Traceback (most recent call last):
  File "<stdin>", line 1, in <module>
KeyError: 'aaa'
>>> s.remove(1)
>>> s
{4, 'b', 'a', '3', 'c'}
>>> s.remove('3')
>>> s
{4, 'b', 'a', 'c'}

5、s.discard() # 与s.remove一样都是指定元素删除
不一样的地方：当删除的元素不存在时，s.discard不会报错，
而s.remove会报错
>>> s = {'a', 'b', 'c', 1, '3', 4}
>>> s.discard('ssssssssss') # 指定元素不存在则报错
>>> s
{1, 4, 'b', 'a', '3', 'c'}
>>> s.discard('a')
>>> s
{1, 4, 'b', '3', 'c'}
>>> s.discard('3')
>>>

s.add()
>>> s
{1, 4, 'b', 'c'}
>>> s.add('a')
>>> s.add('bb')
>>> s
{1, 4, 'bb', 'b', 'a', 'c'}
>>>

s.isdisjoint(s1) # 如果s1与s2没有共同的元素则返回True

>> s
{1, 4, 'bb', 'b', 'a', 'c'}
>>> s1 = {1, 4, 'bb', 'b', 'a'}
>>> s1
{1, 4, 'bb', 'b', 'a'}
>>> s1.isdisjoint(s)
False
>>>

总结集合set：
存多个值
无序
set集合是可变类型