常用数据类型及其内置方法

一、数字类型

1、int类型和float类型定义

# int类型的定义
age = 18  # 本质上age = int(18)

# float类型的定义
salary = 20.5  # 本质上salary = float(20.5)

# 注意：名字 + 括号的意思就是调用某个功能，比如说：
print()  # 调用输出功能
input()  # 调用输入功能
int()  # 调用创建int类型的功能
float()  # 调用创建float类型的功能

2、int类型转换

1.数据类型转换

int类型可以将由纯整数构成的****str字符串*直接转换成*int类型****，一旦这个****str字符串****中包含其他任意非整数符号，转换则失败并且报错。（负号除外）

1)正确转换

s = '123'
res = int(s)
print(res)
print(type(s), type(res))

# 结果
123
<class 'str'> <class 'int'>

s = '-123'
res = int(s)
print(res)
print(type(s), type(res))

# 结果
-123
<class 'str'> <class 'int'>

2)错误转换

str字符串中包含了非整数符号

s = '123a'
res = int(s)

# 结果
Traceback (most recent call last):
  File "H:\云效\python-blog\python\python.py", line 2, in <module>
    res = int(s)
ValueError: invalid literal for int() with base 10: '123a'

2.int进制转换

s = int(16)
ss = bin(s)
sss = oct(s)
ssss = hex(s)
print(ss, sss, ssss)
print(type(s), type(ss), type(sss), type(ssss))

# 结果
0b10000 0o20 0x10
<class 'int'> <class 'str'> <class 'str'> <class 'str'>

转换成十进制

print(int('0b11', 2), int('0o11', 8), int('0x11', 16))

# 结果
3 9 17

3、float类型转换

s = '180.5'
res = float(s)
print(res)
print(type(s), type(res))

# 结果
180.5
<class 'str'> <class 'float'>

二、字符串类型

1、str定义

定义：使用单引号、双引号、三引号内包含的一串字符

name1 = 'tim'  # 本质：name1 = str('tim')
name2 = "cook"  # 本质：name2 = str("cook")
name3 = '''
        ------------info of tim------------
                name           tim
                age            60
                inc            apple
        ------------    end    ------------
'''  # 本质：name3 = str('''...''')
name4 = """apple"""  # 本质：name4 = str("""apple""")

2、str类型转换

str() 可以将任意类型的数据转换成str类型，请看如下代码示例：

lis1 = [1, 2, 3]
dic1 = {'name': 'tim', 'age': 60}
tp1 = (4, 5, 6)
set1 = {7, 8, 9, 10}

print(str(lis1), type(str(lis1)))
print(str(dic1), type(str(dic1)))
print(str(tp1), type(str(tp1)))
print(str(set1), type(str(set1)))

# 结果
[1, 2, 3] <class 'str'>
{'name': 'tim', 'age': 60} <class 'str'>
(4, 5, 6) <class 'str'>
{8, 9, 10, 7} <class 'str'>

3、str类型使用

1.按照索引取值

user_name = 'Tim Cook'
print(user_name[4]) # 正向取值
print(user_name[-1]) # 反向取值

# 结果
C
k

2.切片

（顾头不顾尾，步长）

1)顾头不顾尾

user_name = 'Tim Cook'
print(user_name[0:6]) # 取出索引为0到5的所有字符

# 结果
Tim Co

2)步长

# 0:9:2，第三个参数2代表步长，会从0开始，每次累加2，所以会取出索引0、2、4、6、8的字符
user_name = 'Tim Cook'
print(user_name[0::2])

# 结果
TmCo

3)反向切片

user_name = 'Tim Cook' # -1表示从右往左依次取值
print(user_name[::-1])

# 结果
kooC miT

3.长度 len

获取字符串的长度，即字符的个数。但凡存在于引号内的都算作字符，空格也是字符

user_name = 'Tim Cook'
print(len(user_name))

# 结果
8

4.成员运算 in 和 not in

in: 判断Cook是否在user_name中

not in: 判断tim是否不在user_name里面

user_name = 'Tim Cook'
print('Tim' in user_name)
print('cook' not in user_name)

5.strip移除字符串指定的字符

1）strip()移除首尾指定的字符

不指定参数，默认移除首尾的空白字符（空格、\n、\t）

参数内指定字符，移除首尾指定的字符

user_name = '      Tim Cook            '
print(user_name.strip())

user_name = '-------------Tim Cook -----------'
print(user_name.strip('-'))

# 结果
Tim Cook
Tim Cook 

2）lstrip()只移除左边的指定字符

user_name = '-------------Tim Cook -----------'
print(user_name.lstrip('-'))

# 结果
Tim Cook -----------

3）rstrip()只移除右边的指定字符

user_name = '-------------Tim Cook -----------'
print(user_name.rstrip('-'))

# 结果
-------------Tim Cook 

6.split切分

1.split(separator, max)

切分之后的数据类型是列表类型

参数内不指定字符，默认以空格作为切分符号

参数内指定字符，使用指定的字符切分字符串

max参数是分割几次

user_name = 'T1im Coo1k 6616 7177'
print(user_name.split())
print(user_name.split('1'))
print(user_name.split('1'，2))

# 结果
['T1im', 'Coo1k', '6616', '7177']
['T', 'im Coo', 'k 66', '6 7', '77']
['T', 'im Coo', 'k 6616 7177']

2.rsplit(separator, max)右切分

该方法用于将字符串拆分为列表，可以指定分隔符，默认是任何空白字符，max参数是分割几次

user_name = 'T1im Coo1k 6616 7177'
print(user_name.rsplit('1', 2))

# 结果
['T1im Coo1k 66', '6 7', '77']

3.splitlines(keeplinebreaks)

该方法用于将字符串拆分为列表，拆分在换行符处完成，参数规定输出是否包含换行符(True)或不包含(False)

string = 'hello\nworld\npython\napple\n'
print(string.split('\n'))
print(string.splitlines())
print(string.splitlines(True))

# 结果
['hello', 'world', 'python', 'apple', '']
['hello', 'world', 'python', 'apple']
['hello\n', 'world\n', 'python\n', 'apple\n']

7.for循环

user_name = 'T1im Coo1k 6616 7177'
for i in user_name:
    print(i)
    
# 结果
T
1
i
m
 
C
o
o
1
k
 
6
6
1
6
 
7
1
7
7

8.lower()将字符全部转换成小写

user_name = '-------------TiM CooK -----------'
print(user_name.lower())

# 结果
-------------tim cook -----------

9.upper()将字符全部转换成大写

user_name = '-------------TiM CooK -----------'
print(user_name.upper())

# 结果
-------------TIM COOK -----------

10.casefold()超.将字符全部转换成小写

此方法与lower()方法类似，但是casefold()方法更强大，更具有攻击性，这意味着它将更多的字符转换为小写字母

user_name = '-------------TiM CooK -----------'
print(user_name.casefold())

user_name = '-------------TiM CooK ß-----------'
print(user_name.lower())
print(user_name.casefold())

# 结果
-------------tim cook -----------
-------------tim cook ß-----------
-------------tim cook ss----------- # 德语中ß的小写实际上是ss

11.swapcase()大小写字母互相转换

user_name = '-------------TiM CooK ß-----------'
print(user_name.swapcase())

# 结果
-------------tIm cOOk SS-----------

12.startwith()判断一个字符串是否以指定字符开头，结果为True或False

user_name = 'TiM CooK'
print(user_name.startswith('TiM'))

# 结果
True

13.endswith()判断一个字符串是否以指定字符结尾，结果为True或False

user_name = 'TiM CooK'
print(user_name.endswith('ooK'))

# 结果
True

14.format()格式化输出

format括号在传递参数的时候完全可以打乱顺序，但是仍然可以指名道姓的为指定的参数传值，name='tim'就是传给{name}

str4 = 'my name is {name}, my age is {age}'.format(age=60, name='Tim')
print(str4)

str4 = 'my name is {name} {name} {name}, my age is {name}'.format(name='Tim')
print(str4)

# 结果
my name is Tim, my age is 60
my name is Tim Tim Tim, my age is Tim

format的其他使用方式

1）类似于%s的用法，传入的值会按照位置与{}一一对应

str4 = 'my name is {}, my age is {}!'.format('tim', 60)
print(str4)

# 结果
my name is tim, my age is 60!

2）把format传入的多个值当作一个列表，然后用{索引}取值

str4 = 'my name is {0}, my age is {2}!'.format('Tom', 'tim', 60)
print(str4)

# 结果
my name is Tom, my age is 60!

format_map

方法仅用于当字符串格式中可变数据参数来源于字典等映射关系时才可以使用

info = {'name': '苹果', 'id': '2020'}

# 以下是使用format()方法
print('品牌：{dic[name]}，ID：{dic[id]}'.format(dic=info))

# 以下是使用format_map
print('品牌：{name}，ID：{id}'.format_map(info))

# 结果
品牌：苹果，ID：2020
品牌：苹果，ID：2020

15.join()

从可迭代对象中取出多个字符串，然后按照指定的分隔符进行拼接，拼接的结果为字符串，我们会在拼接路径的时候频繁使用此方法

print('-'.join('hello'))  # 从字符串'hello'中取出多个字符串，然后按照-作为分隔符进行拼接操作
print('|'.join(['tim', '60', 'apple']))  # 从列表中取出多个字符串，然后按照｜作为分隔符进行拼接操作

info = {'name': '苹果', 'id': '2020'}
print('*'.join(info))# 在使用字典作为迭代器时，返回的值是键，而不是值

# 结果
h-e-l-l-o
tim|60|apple
name*id

16.replace()

用新的字符串替换字符串中旧的字符

语法：replace('旧内容', '新内容' ,'替换次数')，该方法不会改变原数据，会生成一个新的数据，需要赋值给一个新的变量接收

str1 = 'my name is tim, my age is 60!' 
str2 = str1.replace('60', '18') # 将tim的年龄由60岁改成18岁
str3 = str1.replace('my', 'My', 1) # 可以指定修改的个数
print(str2)
print(str3)

# 结果
my name is tim, my age is 18!
My name is tim, my age is 60!

17.isdigit()

判断字符串是否是纯阿拉伯数字组成，返回结果为True或False

str1 = '123456'
print(str1.isdigit())
str1 = '123jjj123'
print(str1.isdigit())

# 结果
True
False

三、列表类型

1、list类型定义

在[]内，使用逗号进行分隔的多个任意数据类型的值

lis1 = [1, 'a', [1, 2]]  # 本质：lis1 = list([1, 'a', [1, 2]])

2、list类型转换

但凡能够被for循环遍历的数据类型都可以传给list()转换成列表类型，list()会跟着for循环一样遍历出数据类型中包含的每一个元素然后放到列表中

aaa = list('apple')
print(aaa)

bbb = list([1, 2, 3])
print(bbb)

ccc = list({'name': 'tim', 'age': 60})
print(ccc)

ddd = ((1, 2, 3))
print(ddd)

eee = ({1, 2, 3, 4})
print(eee)

# 运行结果
['a', 'p', 'p', 'l', 'e']
[1, 2, 3]
['name', 'age']
(1, 2, 3)
{1, 2, 3, 4}

3、list类型使用

1.按照索引存取值

my_friends = ['tim', 'jack', 'tom', 'jerry', 'cook']

# 正向取
print(my_friends[2])
# 反向取
print(my_friends[-1])
# 存值
my_friends[2]='hahhah'
print(my_friends)

# 运行结果
tom
cook
['tim', 'jack', 'hahhah', 'jerry', 'cook']

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

my_friends = ['tim', 'jack', 'tom', 'jerry', 'cook']

print(my_friends[2:4])
print(my_friends[0:4:2])

# 运行结果
['tom', 'jerry']
['tim', 'tom']

3.长度

my_friends = ['tim', 'jack', 'tom', 'jerry', 'cook']

print(len(my_friends))

# 运行结果
5

4.成员运算

my_friends = ['tim', 'jack', 'tom', 'jerry', 'cook']

print('jack' in my_friends)
print('aaaa' not in my_friends)

# 运行结果
True
True

5.添加元素

1) append(object)

该方法用于在列表末尾添加新的对象，无返回值，直接修改原列表

my_friends = ['tim', 'jack', 'tom', 'jerry', 'cook']
my_friends.append('trevor')
print(my_friends)

# 运行结果
['tim', 'jack', 'tom', 'jerry', 'cook', 'trevor']

2）insert(index, object)

该方法用于将指定的对象插入到指定的位置，无返回值，直接插入进原列表

my_friends = ['tim', 'jack', 'tom', 'jerry', 'cook']
my_friends.insert(2, 'trevor')
print(my_friends)

# 运行结果
['tim', 'jack', 'trevor', 'tom', 'jerry', 'cook']

3）extend(iterable)

该方法用于在列表末尾追加一个序列中的多个值

my_friends = ['tim', 'jack', 'tom', 'jerry', 'cook']
ls = ['apple', 'Tim Cook']
my_friends.extend(ls)
print(my_friends)

# 运行结果
['tim', 'jack', 'tom', 'jerry', 'cook', 'apple', 'Tim Cook']

6.删除元素

1) del ls(index)

该方法属于通用方法，并不是列表类型独有的方法

my_friends = ['tim', 'jack', 'tom', 'jerry', 'cook']
del my_friends[1]
print(my_friends)

# 结果
['tim', 'tom', 'jerry', 'cook']

2）remove(value)

该方法用于移除列表中的某一个元素，如果由多个相同的元素，那么只会移除多个重复元素中的第一个元素

my_friends = ['tim', 'jack', 'tom', 'jerry', 'cook', 'jerry', 'cook']
my_friends.remove('cook')
print(my_friends)

# 结果
['tim', 'jack', 'tom', 'jerry', 'jerry', 'cook']

3）pop(index)

该方法用于删除指定索引位置并返回该索引位置的元素，如不指定，则默认是最后一个元素

my_friends = ['tim', 'jack', 'tom', 'jerry', 'cook', 'jerry', 'cook']
ret = my_friends.pop(3)
print(f'删除的元素为：{ret}，列表变为：{my_friends}')

# 结果
删除的元素为：jerry，列表变为：['tim', 'jack', 'tom', 'cook', 'jerry', 'cook']

4）clear()

该方法用于清空整个列表

my_friends = ['tim', 'jack', 'tom', 'jerry', 'cook', 'jerry', 'cook']
my_friends.clear()
print(my_friends)

# 结果
[]

7.查找元素

1）index(value, start, stop)

该方法用于查询某元素在列表中的第一次出现的索引位置，并且可以指定索引范围，该方法返回查找元素的索引位置，如果未找到该元素则抛出异常

my_friends = ['tim', 'jack', 'tom', 'jerry', 'cook', 'jerry', 'cook']
aaa = my_friends.index('tom')
print(aaa)

# 结果
2

2）count(value)

该方法用于查询某元素在列表中出现的次数

my_friends = ['tim', 'jack', 'tom', 'jerry', 'cook', 'jerry', 'cook']
aaa = my_friends.count('tom')
print(aaa)

# 结果
1

8.其他

1）copy()

该方法用于复制整个列表并返回一个新列表，该方法属于浅拷贝，同ls[::]，copy.copy()也是浅拷贝

ls = ['Apple', 'Tim Cook']
new_ls = ls.copy()
print(new_ls)
print(id(ls), id(new_ls))

new_ls_2 = ls[::]
print(id(ls), id(new_ls_2))

import copy
new_ls_3 = copy.copy(ls)
print(id(ls), id(new_ls_3))

# 结果
['Apple', 'Tim Cook']
2395574614016 2395576022080
2395574614016 2395575345024
2395574614016 2395576020864

2）sort(key, reverse)

该方法用于对列表进行排序，reverse = True降序，reverse = False升序（默认）

# 获取列表的第二个元素
def take_second(elem):
    return elem[1]

ls = [(2, 2), (3, 4), (4, 1), (1, 3)]

# 指定第二个元素排序
ls.sort(key=take_second)
print('排序列表：', ls)

# 结果
排序列表： [(4, 1), (2, 2), (1, 3), (3, 4)]

或者

ls = [(2, 2), (3, 4), (4, 1), (1, 3)]

ls.sort(key=lambda x: x[1])

print(ls)

# 结果
[(4, 1), (2, 2), (1, 3), (3, 4)]

3）reverse()

该函数用于反转列表，直接修改原列表

ls = [(2, 2), (3, 4), (4, 1), (1, 3)]

ls.reverse()

print(ls)

# 结果
[(1, 3), (4, 1), (3, 4), (2, 2)]

四、元组类型

​ tuple元组与list列表类似，同样可以保存多个任意类型的元素，但是与list的不同之处在于tuple的元素不能修改，即元组相当于不可变的列表，用于记录多个固定不允许修改的值，单纯用于取数据。

1、定义

# 在()内使用逗号分隔开多个任意类型的值
countries = ('中国', '美国', '英国')  # 本质：countries = tuple('中国', '美国', '英国')

重点强调，如果一个元组内只有一个元素，那么必须要添加一个逗号，否则()就只是包含的意思，而不是定义一个元组

countries = ('中国',)  
print(type(countries))
countries = ('中国')
print(type(countries))

# 结果
<class 'tuple'>
<class 'str'>

2、转换

但凡能够被for循环遍历的数据类型都可以传给tuple()转换成元组类型

tuple()会跟for循环一样遍历出数据类型中包含的每一个元素然后放到元组中

print(tuple('apple'))
print(tuple([1, 2, 3]))
print(({'name': 'tim', 'age': 18}))
print(tuple((1, 2, 3)))
print(tuple({1, 2, 3, 4}))

# 结果
('a', 'p', 'p', 'l', 'e')
(1, 2, 3)
{'name': 'tim', 'age': 18}
(1, 2, 3)
(1, 2, 3, 4)

3、tuple类型使用

tp = ('tim', 60, 'male', 'apple', 'USA')
print(tp[0])  # 正向取值
print(tp[-2])  # 反向取值
print(tp[0:6:2])  # 步长
print(len(tp))  # 长度
print('tim' in tp)  # 成员运算
for item in tp:  # 循环
    print(item)

# 结果
tim
apple
('tim', 'male', 'USA')
5
True
tim
60
male
apple
USA

五、字典类型

1、定义

# 定义：在{}内用逗号分隔开多个元素，每一个元素都是key:value的形式，其中value可以是任意类型的数据，然而key必须是不可变类型，具体什么是不可变类型，接下里会讲述。通常key是str类型的，因为我们知道，str类型具有描述性的作用
info = {'name': 'tim', 'age': 18, 'gender': 'male'}  # 本质：info = dict({...})

# 定义字典的第二种方式
info = dict(name='tim', age=18, gender='male')  # info = {'name': 'tim', 'age': 18, 'gender': 'male'}

2、转换

lis1 = [['name', 'tim'], ('age', 60)]  # 列表类型的数据
print(dict(lis1))

# 结果
{'name': 'tim', 'age': 60}

fromkeys会从元组中取出每个值当作key，然后与None组成key:value放到字典中

print({}.fromkeys(('name', 'age', 'gender')))

# 结果
{'name': None, 'age': None, 'gender': None}

3、使用

<<<<<<< HEAD

1.按key存取值：可存可取

1)取值

dic = {
    'name': 'xxx',
    'age': 18,
    'hobbies': ['play game', 'basketball']
}

print(dic['name'], dic['hobbies'][1])

# 结果
xxx basketball

2）赋值：如果key原先不存在于字典，则会新增key:value

dic = {
    'name': 'xxx',
    'age': 18,
    'hobbies': ['play game', 'basketball']
}

dic['gender'] = 'male'

print(dic)

# 结果
{'name': 'xxx', 'age': 18, 'hobbies': ['play game', 'basketball'], 'gender': 'male'}

3）赋值：如果key原先存在于字典，则会修改对应value的值

dic = {
    'name': 'xxx',
    'age': 18,
    'hobbies': ['play game', 'basketball']
}

dic['gender'] = 'male'
dic['name'] = 'trevor'
print(dic)

# 结果
{'name': 'trevor', 'age': 18, 'hobbies': ['play game', 'basketball'], 'gender': 'male'}

2.长度len

dic = {
    'name': 'xxx',
    'age': 18,
    'hobbies': ['play game', 'basketball']
}

print(len(dic))
# 结果
3

3.成员运算in和not in

dic = {
    'name': 'xxx',
    'age': 18,
    'hobbies': ['play game', 'basketball']
}

print('name' in dic)
# 结果
True

4.更新update(new_dic)

该方法用于把新字典的键值对更新到原字典中，如果新字典中的key在原字典中已存在，则修改原字典中的key对应的value

dic_1 = {'name': 'Tim Cook', 'gender': 'male'}
dic_2 = {'addr': 'USA', 'corporation': 'Apple'}
dic_1.update(dic_2)

print(dic_1)
# 结果
{'name': 'Tim Cook', 'gender': 'male', 'addr': 'USA', 'corporation': 'Apple'}

5.删除del dic[key]

该方法是通用方法，并不是字典类型中独有的，该方法用于根据key删除键值对

dic_1 = {'name': 'Tim Cook', 'gender': 'male', 'addr': 'USA', 'corporation': 'Apple'}
del dic_1['gender']

print(dic_1)
# {'name': 'Tim Cook', 'addr': 'USA', 'corporation': 'Apple'}

6.删除pop(key, default)

该方法用于删除字典给定键以及对应的值，返回值为被删除的值，如果key不存在，则返回default

dic_1 = {'name': 'Tim Cook', 'gender': 'male', 'addr': 'USA', 'corporation': 'Apple'}

print(dic_1.pop('gender', '该键值不存在'))
print(dic_1.pop('trevor', '该键值不存在'))

print(dic_1)

# 结果
male
该键值不存在
{'name': 'Tim Cook', 'addr': 'USA', 'corporation': 'Apple'}

7.删除popitem()

dic_1 = {'name': 'Tim Cook', 'gender': 'male', 'addr': 'USA', 'corporation': 'Apple'}

print(dic_1.popitem())

print(dic_1)

# 结果
('corporation', 'Apple')
{'name': 'Tim Cook', 'gender': 'male', 'addr': 'USA'}

8.清空键值对clear()

该方法用于清空整个字典中的键值对

dic_1 = {'name': 'Tim Cook', 'gender': 'male', 'addr': 'USA', 'corporation': 'Apple'}

print(dic_1.clear())

print(dic_1)

# 结果
None
{}

9.返回指定键的值get(key, default)

该方法用于返回指定键的值，如果键不存在返回default参数

dic_1 = {'name': 'Tim Cook', 'gender': 'male', 'addr': 'USA', 'corporation': 'Apple'}

print(dic_1.get('age', '该键值不存在'))
print(dic_1.get('name', '该键值不存在'))

print(dic_1)

# 结果
该键值不存在
Tim Cook
{'name': 'Tim Cook', 'gender': 'male', 'addr': 'USA', 'corporation': 'Apple'}

10.返回指定键的值setdefault(key, default)

该方法和get()方法类似，但是区别在于，如果键不存在，将会添加键并将值设置为默认值

dic_1 = {'name': 'Tim Cook', 'gender': 'male', 'addr': 'USA', 'corporation': 'Apple'}

print(dic_1.setdefault('age', '该键值不存在'))
print(dic_1.setdefault('name', '该键值不存在'))

print(dic_1)

# 结果
该键值不存在
Tim Cook
{'name': 'Tim Cook', 'gender': 'male', 'addr': 'USA', 'corporation': 'Apple', 'age': '该键值不存在'}

11.创建新的字典fromkeys(seq, value)

seq = ('Google', 'Apple', 'NASA')
dic_1 = dict.fromkeys(seq)

print(dic_1)
# 结果
{'Google': None, 'Apple': None, 'NASA': None}

12.获取所有的键keys()

seq = ('Google', 'Apple', 'NASA')
dic_1 = dict.fromkeys(seq)

print(dic_1.keys())
# 结果
dict_keys(['Google', 'Apple', 'NASA'])

13.获取所有的值values()

该方法用于获取字典中所有的值

seq = ('Google', 'Apple', 'NASA')
dic_1 = dict.fromkeys(seq)

print(dic_1.values())
# 结果
dict_values([None, None, None])

14.获取字典中的键值对

seq = ('Google', 'Apple', 'NASA')
dic_1 = dict.fromkeys(seq)

print(dic_1.items())
# 结果
dict_items([('Google', None), ('Apple', None), ('NASA', None)])

六、set类型

1、定义

定义：在 {} 内使用逗号分隔开多个元素，集合具备以下三个特点：

1.每个元素必须是不可变类型

2.集合内没有重复的元素

3.集合内的元素是没有顺序的

s = {1, 2, 3, 4}  # 本质 s = set({1, 2, 3, 4})

注意1：列表list类型是索引对应值，字典dict类型是key对应值，均可以取得单个指定的值，然而集合类型既没有索引也没有key与值对应，所以无法取得单个的值，而且对于集合来说，主要用于去重以及关系运算，如果想要取出单个指定的值，就不要使用set类型来存储数据

注意2：{}符号即可以用于定义dict字典类型也可以用于定义set集合类型，但是字典内的元素必须是key:value的格式，现在我们想要定义一个空字典和空集合，该如何准确去定义两者呢？

dic1 = {}  # 默认是空字典
set1 = set()  # 如果想要定义空集合则必须使用这种方式

2、set类型转换

但凡能够被for循环遍历的数据类型（强调：遍历出每个值必须是不可变类型）都可以传给set()转换成集合类型

s = set([1, 2, 3, 4])
s1 = set((1, 2, 3, 4))
s2 = set({'name': 'apple'})
s3 = set('tim')

3、set类型使用

1.关系运算

我们定义两个集合 hobbies1 与 hobbies2 来分别存放两个人的爱好，然后以这两个集合为例讲解集合的关系运算

hobbies1 = {'dancing', 'singing', 'drinking', 'writing'}
hobbies2 = {'singing', 'dancing', 'playing', 'reading'}

1) 并集

两个人的所有爱好（重复爱好只留下一个）

hobbies1 = {'dancing', 'singing', 'drinking', 'writing'}
hobbies2 = {'singing', 'dancing', 'playing', 'reading'}

print(hobbies1 | hobbies2)

print(hobbies1.union(hobbies2))

# 结果
{'singing', 'writing', 'drinking', 'dancing', 'reading', 'playing'}
{'singing', 'writing', 'drinking', 'dancing', 'reading', 'playing'}

2）交集

两个人共同的爱好

hobbies1 = {'dancing', 'singing', 'drinking', 'writing'}
hobbies2 = {'singing', 'dancing', 'playing', 'reading'}

print(hobbies1 & hobbies2)

print(hobbies1.intersection(hobbies2))

# 结果
{'singing', 'dancing'}
{'singing', 'dancing'}

3）差集

用户1独有爱好

hobbies1 = {'dancing', 'singing', 'drinking', 'writing'}
hobbies2 = {'singing', 'dancing', 'playing', 'reading'}

print(hobbies1 - hobbies2)

print(hobbies1.difference(hobbies2))

# 结果
{'writing', 'drinking'}
{'writing', 'drinking'}

4）对称差集

两个用户独有的爱好(即去掉共同的爱好)

hobbies1 = {'dancing', 'singing', 'drinking', 'writing'}
hobbies2 = {'singing', 'dancing', 'playing', 'reading'}

print(hobbies1 ^ hobbies2)

print(hobbies1.symmetric_difference(hobbies2))

# 结果
{'drinking', 'playing', 'reading', 'writing'}
{'drinking', 'playing', 'reading', 'writing'}

5) 值是否相等

hobbies1 = {'dancing', 'singing', 'drinking', 'writing'}
hobbies2 = {'singing', 'dancing', 'playing', 'reading'}

print(hobbies1 == hobbies2)

# 结果
False

6）父集

一个集合是否包含另外一个集合

包含返回：True

不包含返回：False

print({1,2,3} > {1,2})
print({1,2,3} >= {1,2})

# 结果
True
True

7）子集

print({1,2,3} < {1,2})
print({1,2,3} < {1,2,3,4})
print({1,2,3} <= {1,2,3,4})

2.去重

集合的去重具有很大的局限性

• 只能针对不可变的数据类型

• 集合本身是无序的，因此去重之后无法保持原来的顺序

lis = ['a', 'b', 1, 'a', 'a']
s = set(lis)

print(s)

new_list = list(s)

print(new_list)

# 结果
{'a', 1, 'b'}
['a', 1, 'b']

针对不可变类型，并且保证顺序则需要我们自己写代码实现，例如

lis = [
    {'name': 'tom', 'age': 18, 'gender': 'male'},
    {'name': 'tom', 'age': 18, 'gender': 'male'},
    {'name': 'jack', 'age': 20, 'gender': 'male'},
    {'name': 'cook', 'age': 25, 'gender': 'male'},
    {'name': 'tom', 'age': 18, 'gender': 'male'},
]

new_lis = []

for item in lis:
    if item not in new_lis:
        new_lis.append(item)
import json
print(json.dumps(new_lis, indent=4, sort_keys=True))

# 结果
[
    {
        "age": 18,
        "gender": "male",
        "name": "tom"
    },
    {
        "age": 20,
        "gender": "male",
        "name": "jack"
    },
    {
        "age": 25,
        "gender": "male",
        "name": "cook"
    }
]

3.其他

s = {'a', 'b', 'c'}

# 长度
print(len(s))

# 成员运算
print('c' in s)

# 循环
for item in s:
    print(item)