python中的集合，is和==的区别、深拷贝和浅拷贝、公共方法

集合

可变集合 ：    set 集合里面的内容可以被改变

不可变集合 ： frozenset 集合里面的内容不可以被改变

集合最大的功能 ：去重

test = 'hello' 
a = set(test) 
print(a)              # {'e', 'l', 'o', 'h'}

1、clear 清空

test = 'hello'
a = set(test)
a.clear()
print(a)            # set()

2、pop随机删除一个元素、discard()：# 删除指定数据，如果数据不存在不报错

test = 'hello'
a = set(test)
a.pop()              # 随机删除一个元素
print(a)

s1 = {10, 20, 30, 40, 50}
# discard()：# 删除指定数据，如果数据不存在不报错
s1.discard(10)
print(s1)

s1.discard(100)
print(s1)

3、remove 随机移除一个元素

test = 'hello'
a = set(test)
a.remove('l')
print(a)

4、copy拷贝

test = 'hello'
a = set(test)
b = a.copy()          # 拷贝赋值给到b这个变量
print(b)

5、add 随机位置，添加一个元素、update()： 增加的数据是序列

test = 'hello'
a = set(test)
a.add('666')          # add就是添加一个元素
print(a)
print(type(a))        # 数据类型是集合：<class 'set'>


# update()： 增加的数据是序列
s1 = {10, 20}
s1.update([10, 20, 30, 40, 50])
print(s1)       # {40, 10, 50, 20, 30}


# s1.update(100)  # 报错
# print(s1)

6、不可变集合 元素不能改表

test = 'hello'
a = frozenset(test)     # 不可变集合  元素不能改表
b = a.copy()
print(b)
print(a)
print(type(a))         # <class 'frozenset'>
​
不能进行任何操作
a.clear()            # 'frozenset' object has no attribute 'clear'
print(a)             # “frozenset”对象没有属性“clear”

7、集合作用：对列表进行去重

list1 = [1,1,1,22,8,999]
list2 = set(list1)
print(list2)          # {8, 1, 22, 999}
print(type(list2))
for i in list2:
    print(i)

8、in 或not in 判断

s1 = {10, 20, 30, 40, 50}

# in 或not in 判断数据10是否存在
print(10 in s1)

print(10 not in s1)

is和==的区别

        is和==都可以对两个对象进行比较，而且它们的返回值都是布尔类型，但是它们比较的内容是不同的。

is比较的是两个对象的地址值，也就是说两个对象是否为同一个实例对象；

而==比较的是对象的值是否相等，其调用了对象的__eq__()方法。

list1 = [1, 2, 3]
list2 = [1, 2, 3]


print(list1 == list2)      # True
print(list1 is list2)      # False

可变和不可变数据类型分类：

不可变：Number（数字）、String（字符串）、Tuple（元组）。
可以变：List（列表）、Dictionary（字典）、Set（集合）。

深拷贝和浅拷贝 

• 浅拷贝，指的是重新分配一块内存，创建一个新的对象，但里面的元素是原对象中各个子对象的引用。

改变原始对象中为可变类型的元素的值，会同时影响拷贝对象。
改变原始对象中为不可变类型的元素的值，不会响拷贝对象。

import copy

# 定义一个列表，其中第一个元素是可变类型。
list1 = [[1, 2], 'DCS', 66]

# 进行浅copy
list2 = copy.copy(list1)

# 对象地址不同。
print(id(list1))       # 2491842851656
print(id(list2))       # 2491842817032

# 第一个元素地址相同
print(id(list1[0]))    # 2491842729416
print(id(list2[0]))    # 2491842729416

# 第二个元素地址相同
print(id(list1[1]))    # 2491839709960
print(id(list2[1]))    # 2491839709960

# 改变第一个值,复制对象也发生变化
list1[0][0] = 2
print(list2)           # [[2, 2], 'DCS', 66]
print(list1)           # [[2, 2], 'DCS', 66]


# 改变第二个值,复制对象没发生变了
list1[1] = 'ge'
print(list2)           # [[2, 2], 'DCS', 66]
print(list1)           # [[2, 2], 'ge', 66]

• 深拷贝，是指重新分配一块内存，创建一个新的对象，并且将原对象中的元素，以递归的方式，通过创建新的子对象拷贝到新对象中。因此，新对象和原对象没有任何关联。

深拷贝，除了顶层拷贝，还对子元素也进行了拷贝。
经过深拷贝后，原始对象和拷贝对象所有的可变元素地址都没有相同的了。

import copy

# 定义一个列表，其中第一个元素是可变类型。
list1 = [[1, 2], 'fei', 66]
# 进行深copy
list2 = copy.deepcopy(list1)

# 对象地址是不同的。
print(id(list1))          # 1863611741192
print(id(list2))          # 1863611706568

# 第一个元素地址不同。
print(id(list1[0]))       # 1863611614728
print(id(list2[0]))       # 1863611741128

# 第二个元素地址相同
print(id(list1[1]))       # 1863608599304
print(id(list2[1]))       # 1863608599304

# 改变第一个值,复制对象没发生变了
list1[0][0] = 2
print(list2)              # [[1, 2], 'fei', 66]
print(list1)              # [[2, 2], 'fei', 66]

# 改变第二个值,复制对象没发生变了
list1[1] = 'ge'
print(list2)              # [[1, 2], 'fei', 66]
print(list1)              # [[2, 2], 'ge', 66]

python 公共方法  

str1 = 'aa'
str2 = 'bb'

list1 = [1, 2]
list2 = [10, 20]

t1 = (1, 2)
t2 = (10, 20)

dict1 = {'name': 'Python'}
dict2 = {'age': 30}

# +: 合并
print(str1 + str2)               # aabb
print(list1 + list2)             # [1, 2, 10, 20]
print(t1 + t2)                   # (1, 2, 10, 20)

# print(dict1 + dict2)  # 报错：字典不支持合并运算

str1 = 'a'
list1 = ['hello']
t1 = ('world',)

# *:复制
print(str1 * 5)             # aaaaa

# 打印10个-：
print('-' * 10)             # ----------

print(list1 * 5)            # ['hello', 'hello', 'hello', 'hello', 'hello']

print(t1 * 5)               # ('world', 'world', 'world', 'world', 'world')

str1 = 'abcd'
list1 = [10, 20, 30, 40]
t1 = (100, 200, 300, 400)
dict1 = {'name': 'Python', 'age': 30}

# in 和 not in
# 1. 字符a是否存在
print('a' in str1)
print('a' not in str1)

# 2. 数据10是否存在
print(10 in list1)
print(10 not in list1)

# 3. 100是否存在
print(100 not in t1)
print(100 in t1)

# 4. name是否存在
print('name' in dict1)
print('name' not in dict1)
print('name' in dict1.keys())
print('name' in dict1.values())

len 函数

str1 = 'abcdefg'
list1 = [10, 20, 30, 40, 50]
t1 = (10, 20, 30, 40, 50)
s1 = {10, 20, 30, 40, 50}
dict1 = {'name': 'TOM', 'age': 18}

print(len(str1))
print(len(list1))
print(len(t1))
print(len(s1))
print(len(dict1))

del 函数

str1 = 'abcdefg'
list1 = [10, 20, 30, 40, 50]
t1 = (10, 20, 30, 40, 50)
s1 = {10, 20, 30, 40, 50}
dict1 = {'name': 'TOM', 'age': 18}

# del 目标 或del(目标)
del str1
print(str1)

del(list1)
print(list1)
del(list1[0])
print(list1)

del s1
print(s1)

del dict1
print(dict1)
del dict1['name']
print(dict1)

max 和 min 函数

str1 = 'abcdefg'
list1 = [10, 20, 30, 40, 50]

# max() : 最大值
print(max(str1))
print(max(list1))

# min() ： 最小值
print(min(str1))
print(min(list1))

enumerate 返回结果是元组，元组第一个数据是原迭代对象的数据对应的下标，元组第二个数据是原迭代对象的数据

list1 = ['a', 'b', 'c', 'd', 'e']

# enumerate 返回结果是元组，元组第一个数据是原迭代对象的数据对应的下标，元组第二个数据是原迭代对象的数据
for i in enumerate(list1):
    print(i)

for i in enumerate(list1, start=1):
    print(i)

数据转换

list1 = [10, 20, 30, 20, 40, 50]
s1 = {100, 300, 200, 500}
t1 = ('a', 'b', 'c', 'd', 'e')

# tuple(): 转换成元组
print(tuple(list1))       # (10, 20, 30, 20, 40, 50)
print(tuple(s1))          # (200, 100, 500, 300)

# list()：转换成列表
print(list(s1))          # [200, 100, 500, 300]
print(list(t1))          # ['a', 'b', 'c', 'd', 'e']

# set()：转换成集合
print(set(list1))        # {40, 10, 50, 20, 30}
print(set(t1))           # {'e', 'a', 'b', 'd', 'c'}