__author__ = "Tang"

 """不要指望一下全背下来"""

 """必会的：join split find strip upper lower replace"""

 # capitalize() 首字母大写

 a = 'tang'

 b = a.capitalize()

 print(b) # Tang

 # casefold() 大写变小写

 a = 'TANg'

 b = a.casefold()

 print(b) # tang

 # lower() 大写变小写

 a = 'TANg'

 b = a.lower()

 print(b) # tang

 """

 casefold() & lower() 的比较

 1.都能大写变小写

 2.casefold 比较全面，像一些特殊语言的变换都可以

 3.lower 只能处理英文转换

 """

 # center() 字符串放中间

 # center(self, width, fillchar=None) width=总长度 fillchar=填充符号(一个字符)

 a = 'tang'

 b = a.center(20)

 c = a.center(20,'*')

 d = a.center(20,'唐')

 print(b) #         tang

 print(c) # ********tang********

 print(d) # 唐唐唐唐唐唐唐唐tang唐唐唐唐唐唐唐唐

 # count() 统计次数

 # count(self, sub, start=None, end=None) sub=要统计的字符 start=开始位置 end=结尾位置 以0开始计数 [start,end)

 a = 'tanglaoertanglaoer'

 b = a.count('a')

 c = a.count('ao')

 d = a.count('a',5,-1)

 e = a.count('r',0,-1)

 f = a.count('r',0)

 print(b) #

 print(c) #

 print(d) #

 print(e) #

 print(f) #

 # endswith() 判断以什么结尾

 # endswith(self, suffix, start=None, end=None) suffix=要判断的字符 start=开始位置 end=结尾位置 以0开始计数 [start,end)

 a = 'tanglaoer'

 b = a.endswith('er')

 print(b) # True

 # expandtabs() 每次取tabsize个，里面有\t的补后面的空格

 # expandtabs(self, tabsize=8)

 a = 'tanglaoer\t' # 这里补三个空格 第一次取tangla   第二次取oer\t

 b = a.expandtabs(6)

 print(b) # tanglaoer | | |

 print(len(b)) #

 # find() 寻找 返回所在位置,未找到返回-1

 # find(self, sub, start=None, end=None) sub=要查找的字符 start=开始位置 end=结尾位置 以0开始计数 [start,end)

 a = 'tanglaoer'

 b = a.find('a')

 c = a.find('a',3)

 e = a.find('p',3)

 print(b)#

 print(c)#

 print(e)# -1

 # format 格式化，占位符替换为指定的值

 # format(self, *args, **kwargs)

 a = 'i am {name}'

 print(a) # i am {name}

 b = a.format(name='tang')

 print(b) # i am tang

 a = 'i am {0},age {1}'

 print(a) # i am {0},age {1}

 b = a.format('tang','')

 print(b) # i am tang,age 22

 # format_map() 格式化

 # format_map(self, mapping) mapping=字典{}

 a = 'i am {name}'

 b = a.format_map({'name':'tang'}) # 传字典

 print(b) # i am tang

 # index() 寻找,找不到就报错

 # index(self, sub, start=None, end=None) sub=要查找的字符 start=开始位置 end=结尾位置 以0开始计数 [start,end)

 # a = 'tanglaoer'

 # b = a.index('a')

 # c = a.index('p')

 # print(b) # 1

 # print(c) # 报错

 """

 find() & index() 的比较

 1. 用find() 找不到不会报错

 """

 # isalnum() 字符串中是否只包含 字母（包括汉字）和数字

 a = 'tang8080唐'

 b = 'tang8080_'

 c = a.isalnum()

 d = b.isalnum()

 print(c) # True

 print(d) # False

 # isalpha() 字符串是否只包含字母 汉字

 a = "tanglaoer"

 b = '唐'

 c = a.isalpha()

 d = b.isalpha()

 print(c) # True

 print(d) # True

 # isdigest() isdecimal() 判断是否是数字

 a = ""

 b = "②"

 t = '二'

 c = a.isdecimal() # 只可以识别 这种"123" 用来判断计算就用这种

 d = a.isdigit()

 e = b.isdecimal()

 f = b.isdigit()

 g = t.isnumeric() # 可以识别中文数字

 print(c,d,e,f,g) # True True False True True

 """

 isdigit() & isdecimal() 比较

 1. 用isdigit() 范围更广

 """

 # swapcase() 大小写转换

 a = 'TangLaoEr'

 b = a.swapcase()

 print(b) # tANGlAOeR

 # isidentifier() 判断是否是标识符

 # 数字 字母 下划线 and 字母 下划线 开头

 # isprintable() 判断是否存在不可显示字符 \n \t ，注意：空格是可显示的

 a = "tang\tlao"

 b = a.isprintable()

 print(b) # False

 # isspace() 判断是否全部是空格，\t \n 都满足

 a = "tanglaoer"

 b = " "

 t = "\t"

 p = "\n"

 c = a.isspace()

 d = b.isspace()

 g = t.isspace()

 pp = p.isspace()

 print(c,d,g,pp) # False True True True

 # istitle() 判断是否是标题 每个单词首字母大写

 a = 'tang lao er'

 b = a.istitle()

 c = a.title()

 print(b)# False

 print(c)# Tang Lao Er

 # 这个很重要

 # join() 拼接字符串 每一个元素按照指定分隔符进行拼接

 a = "tanglaoer"

 c = '飞流直下三千尺'

 print(a)

 b = " ".join(a)

 d = "_".join(c)

 print(b) # t a n g l a o e r

 print(d) # 飞_流_直_下_三_千_尺

 # ljust() rjust() 指定宽度，字符串放一边 剩下的填充

 # ljust(self, width, fillchar=None)

 # rjust(self, width, fillchar=None)

 a = 'tang'

 b = a.ljust(20,'*')

 c = a.rjust(20,'*')

 print(b) # tang****************

 print(c) # ****************tang

 # zfill() 以0来填充

 a = "tang"

 b = a.zfill(20)

 print(b) # 0000000000000000tang

 # islower() 判断是否是小写

 a = 'Tang'

 b = a.islower()

 print(b) # False

 # isupper() 判断是否是大写

 a = 'Tang'

 b = a.isupper()

 print(b) # False

 # upper() 转换为大写

 a = 'Tang'

 b = a.upper()

 print(b) # TANG

 # 移除指定字符串

 #strip() 默认去除空格 \n \t ,可以指定匹配的子序列

 # strip(self, chars=None)

 a = " tang "

 b = a.lstrip()

 c = a.rstrip()

 d = a.strip()

 print(b)#tang

 print(c)# tang

 print(d)#tang

 # 注意：是子序列里面的都可以匹配掉

 a = 'axtangxa'

 b = a.lstrip('ax')

 c = a.rstrip('ax')

 d = a.strip('ax')

 print(b)#tangxa

 print(c)#axtang

 print(d)#tang

 # maketrans() translate() 自定义替换,两个函数配套使用

 st = "ajketjaeoijmdgajtyopayjhpaeg"

 a = str.maketrans("aeiou","") # a=1,e=2,i=3,o=4,u=5

 at = st.translate(a)

 print(at) # 1jk2tj1243jmdg1jty4p1yjhp12g

 # partition() 分割,分成三部分成元组，可以拿到sep

 # partition(self, sep)

 a = 'tanglaoer'

 b = a.partition('a')

 c = a.partition('ao')

 d = a.partition('r')

 print(b) # ('t', 'a', 'nglaoer')

 print(c) # ('tangl', 'ao', 'er')

 print(d) # ('tanglaoe', 'r', '')

 # split() lsplit() rsplit() # 分割,按sep分割成列表，不可以拿到sep

 # split(self, sep=None, maxsplit=-1) maxsplit=分割次数

 a = 'tanglaoer'

 b = a.split('a')

 c = a.rsplit('a',1)

 print(b) # ['t', 'ngl', 'oer']

 print(c) # ['tangl', 'oer']

 # splitlines() 分割

 # splitlines(self, keepends=None) keepends=True | False

 a = "aldgjal\najlkgjal\nalgladjg"

 b = a.splitlines(False)

 c = a.splitlines(True)

 print(b) # ['aldgjal', 'ajlkgjal', 'algladjg']

 print(c) # ['aldgjal\n', 'ajlkgjal\n', 'algladjg']

 # startswith() 以什么开头

 # startswith(self, prefix, start=None, end=None)

 a = "tanglaoer"

 b = a.startswith('a')

 c = a.startswith('a',1)

 print(b) # False

 print(c) # True

 # replace() 替换

 # replace(self, old, new, count=None) count=替换的次数

 a = "tanglaoer"

 b = a.replace("a","T")

 c = a.replace("a","T",1)

 print(b) #tTnglToer

 print(c) #tTnglaoer

 # ******************************以下必须知道的***************

 # 获取字符串中的某一个

 # 通过索引，下标

 a = 'tanglaoer'

 b = a[2]

 print(b) # n

 # 通过[M:n]切片 -1:表示最后一个

 a = 'tanglaoer'

 b = a[0:1] #[0,1)

 c = a[0:-1] #[0,-1)

 print(b) # t

 print(c) # tanglaoe

 # len() 求长度

 a = 'tanglaoer'

 c = '唐老二'

 b = len(a)

 d = len(c)

 print(b) #

 print(d) # 3 注意: 在python2中拿到的是9

 # for 循环取值

 a = 'tanglaoer'

 for i in a:

     print(i,end=' ') #t a n g l a o e r

 print()

 # 字符串拼接

 """

 内存理解： 字符串是不可变类型

 1.首先a申请一块内存存放"tanglaoer"

 2.b申请一块内存存放"18"

 3.c重新申请一块内存放"tanglaoer18"

 """

 a = "tanglaoer"

 b = ""

 c = a + b

 print(c) # tanglaoer18

__author__ = "Tang"

# 列表中的元素 数字，字符串，列表，布尔值...

li = [1, 'age', ['tang', ['lao', 'er']], True]

# 索引取值

print(li[1])  # age

print(li[2][0])  # tang

# 切片 取值

print(li[2:-1])  # [['tang', ['lao', 'er']]]

# for循环 while 循环 取值

# for item in li:

#     print(item)

# 列表元素，可以被修改 是可变类型

li = [1, 'age', ['tang', ['lao', 'er']], True]

# 索引修改

li[0] = 20

print(li[0])

#  删除

del li[1]

print(li)  # [20, ['tang', ['lao', 'er']], True]

# 切片 修改多个值

li = [1, 12, 9, 'age', ['tang', ['lao', 'er']], True]

li[1:3] = [120, 90]

print(li)  # [1, 120, 90, 'age', ['tang', ['lao', 'er']], True]

# 切片 删除多个值

li = [1, 12, 9, 'age', ['tang', ['lao', 'er']], True]

del li[2:6]

print(li)  # [1, 12]

# in 操作

li = [1, 12, 9, 'age', ['tang', ['lao', 'er']], True]

v = "age" in li

print(v)  # True

v = 'tang' in li

print(v)  # False

v = ['tang', ['lao', 'er']] in li

print(v)  # True

# 取值操作

li = [1, 12, 9, 'age', ['tang', ['lao', 'er']], True]

print(li[3][1])  # g

print(li[4][1][0])  # lao

# 数字 字符串转换

a = ""

s = int(a)

print(s, type(s))  # 123 <class 'int'>

a = 123

s = str(a)

print(s, type(s))  # 123 <class 'str'>

# 字符串转换成列表

s = "tanglaoer"

new_li = list(s)  # 内部使用for循环

print(new_li)  # ['t', 'a', 'n', 'g', 'l', 'a', 'o', 'e', 'r']

# 列表转换成字符串

li = [11, 22, 33, "", "tang", True]

r = str(li)

print(r)  # [11, 22, 33, '123', 'tang', True]

# 列表转换成字符串 第一种 失败

li = [11, 22, 33, "", "tang", True]

s = ""

li = str(li)  # 每一个字符是一个元素 11就代表两个元素 包括[]号也是元素

for i in li:

    print(i)

    """

    [

1

1

,

2

2

,

3

3

,

'

1

2

3

'

,

'

t

a

n

g

'

,

T

r

u

e

]

"""

    s += i

print(s)  # [11, 22, 33, '123', 'tang', True]

# 列表转换成字符串 第二种 有点麻烦

li = [11, 22, 33, "", "tang", True]

s = ""

for i in li:

    s = s + str(i)

print(s)  # 112233123tangTrue

# 列表转换成字符串 第三种 完美

li = [11, 22, 33, "", "tang", True]

# 因为列表里面有整型 不能直接转换为字符串

# s = "".join(li) # 报错 TypeError: sequence item 0: expected str instance, int found

s = "".join('%s' % i for i in li)

print(s)  # 112233123tangTrue

# 这个很重要 列表 元组 字符串 使用切片【M:N】取值 超出边界不报错

# 如果是根据【n】索引取值，就会报错

# li = [1,2,3,4,5,6,7]

# tt = li[10:]

# print(tt) # []

# print(tt[10]) # 报错

# st = "tanglaoer"

# st2 = st[10:]

# st3 = st[1:]

# print(st2) # 空格

# print(st3) # anglaoer

# print(st[20]) 报错

# tup = (1,2,3,4,5,)

# tup2 = tup[10:]

# tup3 = tup[10]

# print(tup2) # 空格

# print(tup3) # 报错

##############list 方法#################

# append() 追加

li = [11, 22, 33, 44]

v = li.append(55)

print(v)  # None

print(li)  # [11, 22, 33, 44, 55]

# clear() 清空

li = [11, 22, 33, 44]

v = li.clear()

print(v)  # None

print(li)  # []

# copy() 浅拷贝

li = [11, 22, 33, 44]

v = li.copy()

print(v)  # [11, 22, 33, 44]

print(li)  # [11, 22, 33, 44]

# count() 统计

li = [11, 22, 33, 44]

v = li.count(22)

print(v)  #

print(li)  # [11, 22, 33, 44]

# extend() 扩展

# extend(self, iterable) iterable=可迭代对象(字符串 列表 元组）

li = [11, 22, 33, 44]

v = li.extend(['a', 'b', 'c', 90, 50, 'tang'])

v2 = li.extend('tanglaoer')

print(v)  # None

print(li)  # [11, 22, 33, 44, 'a', 'b', 'c', 90, 50, 'tang', 't', 'a', 'n', 'g', 'l', 'a', 'o', 'e', 'r']

print(v2)  # None

"""

append() & extend() 的区别:

1. append() 参数如果是可迭代对象，不会循环取值，而是当做整体插入

2. extend() 循环取值，一个一个的插入

"""

# index() 寻找索引

# index(self, value, start=None, stop=None)

li = [11, 22, 33, 22, 44]

v = li.index(22)

v2 = li.index(22, 2)

print(v)  #

print(v2)  #

# insert() 在指定位置插入值

# insert(self, index, p_object)

li = [11, 22, 33, 44]

v = li.insert(3, 22)

print(v)  # None

print(li)  # [11, 22, 33, 22, 44]

# pop() 删除某索引并返回其位置的值 默认删除最后一个

# pop(self, index=None)

li = [11, 22, 33, 44]

v = li.pop(2)

v2 = li.pop()

print(v)  #

print(v2) #

print(li)  # [11, 22]

# remove() 删除某一个值

# remove(self, value)  左边优先

li = [11, 22, 33, 44]

v = li.remove(22)

print(v)  # None

print(li)  # [11, 33, 44]

# del() 删除

li = [11, 22, 33, 44]

del li[0]

print(li)  # [22, 33, 44]

del li[0:1]

print(li) # [33, 44]

"""

pop() & remove() & clear() & del

1. pop() 参数为索引下标

2. remove() 参数为值

3. clear() 清空所有

4. del 删除某指定的位置，也可以切片

"""

# reverse() 将当前列表进行反转

li = [11, 22, 33, 44]

v = li.reverse()

print(v) # None

print(li) # [44, 33, 22, 11]

# sort() 排序

# sort(self, key=None, reverse=False) 默认从小到大排序

li = [11, 22, 33, 44]

v = li.sort()

print(v) # None

print(li) # [11, 22, 33, 44]

v2 = li.sort(reverse=True) # 从大到小排序

print(v2) # None

print(li) # [44, 33, 22, 11]

# 查看地址

li = [11, 22, 33, 44]

print(li ,id(li)) # [11, 22, 33, 44] 50110832

li.append(55)

print(li,id(li)) # [11, 22, 33, 44, 55] 50110832

# 列表是可变类型

li = [11, 22, 33, 44]

print(li[0]) #

li[0] = 99

print(li[0]) #

# 字符串是不可变类型

s = "tanglaoer"

s[0] = 'B'

print(s[0]) # 报错

__author__ = "Tang"

# 元组 元素不可被修改

tu = (111, 22, 33, 44,)

# tu[0] = 999 # 报错

# del tu[0] # 报错

print(tu)  # (111, 22, 33, 44)

# 在最后多加一个逗号 区别于方法 整型 不加也不报错

l = (11)

print(l)  # 11  整型

l2 = (11,)

print(l2)  # (11,) 元组

tu = (111, 'tang', (1, 2, 3), [4, 5, 6], True, 45)

print(tu)  # (111, 'tang', (1, 2, 3), [4, 5, 6], True, 45)

# 索引取值

tu = (111, 'tang', (1, 2, 3), [4, 5, 6], True, 45)

v = tu[0]

print(v) #

# 切片取值

tu = (111, 'tang', (1, 2, 3), [4, 5, 6], True, 45)

v = tu[0:3]

print(v) # (111, 'tang', (1, 2, 3))

# 循环取值 是可迭代对象

# tu = (111, 'tang', (1, 2, 3), [4, 5, 6], True, 45)

# for i in tu:

#     print(i)

"""

111

tang

(1, 2, 3)

[4, 5, 6]

True

45

"""

# 元组转列表

tu = (111, 'tang', (1, 2, 3), [4, 5, 6], True, 45)

tu = list(tu)

print(tu) # [111, 'tang', (1, 2, 3), [4, 5, 6], True, 45]

# 列表转元组

li = [111, 'tang', (1, 2, 3), [4, 5, 6], True, 45]

tu = tuple(li)

print(tu) # (111, 'tang', (1, 2, 3), [4, 5, 6], True, 45)

# 字符串转元组

s = "tanglaoer"

tu = tuple(s)

print(tu) # ('t', 'a', 'n', 'g', 'l', 'a', 'o', 'e', 'r')

# 元组转字符串第一种 元组不仅仅是字符串 只能自己写for循环

tu = (111, 'tang', (1, 2, 3), [4, 5, 6], True, 45)

v = "".join("%s"%str(i) for i in tu)

print(v,type(v)) # 111tang(1, 2, 3)[4, 5, 6]True45 <class 'str'>

# 元组转字符串第二种 元组都是字符串

tu = ('tang','lao','er',)

v = "".join(tu)

print(v) # tanglaoer

# 元组 列表都是有序的

tu = (111, 'tang', (1, 2, 3), [4, 5, 6], True, 45)

v = tu[2][2]

print(v) #

# 元组里面的一级元素不可以修改/删除/增加  二级元素可以修改

tu = (111, 'tang', (1, 2, 3), [4, 5, 6,(33,44)], True, 45)

print(tu[3][0]) #

tu[3][0] = 14

print(tu[3][0]) #

print(tu[3][3]) # (33, 44)

tu[3][3] = 8989

print(tu[3][3]) #

##########################tuple  方法##########

# count() 获取指定元素的个数

tu = (111, 'tang', (1, 2, 3), [4, 5, 6,(33,44)], True, 45, 45,65,45)

v = tu.count(45)

print(v) #

# index() 获取指定元素的索引下标

# index(self, value, start=None, stop=None)

tu = (111, 'tang', (1, 2, 3), [4, 5, 6,(33,44)], True, 45, 45,65,45)

v = tu.index(45)

print(v) #

__author__ = "Tang"

# 键值对 dict

a = {

    'a': 1,

    'b': 2,

    'c': 3

}

print(a)  # {'a': 1, 'b': 2, 'c': 3}

info = {

    "key0": True,

    "key1": 10,

    "key2": 20,

    "key3": 30,

    "key4": [11, 22, 33],

    "key5": (44, 55, 66,),

    "key6": {'k0': 'v0', 'k1': 'v1', 'k2': 'v2'}

}

print(info)

"""

{'key0': True, 'key1': 10, 'key2': 20, 'key3': 30, 'key4': [11, 22, 33], 'key5': (44, 55, 66), 'key6': {'k0': 'v0', 'k1': 'v1', 'k2': 'v2'}}

"""

# 通过上面例子可以知道 value 可以是任意类型

# 字典的key 可以是整型 字符串 元组 布尔 而列表跟字典可变数据类型不可以当key

tt = {

    2: '',

    'st': 'st',

    True: "",

    (11, 22,): (11, 22)

}

print(tt)  # {2: '1', 'st': 'st', True: '123', (11, 22): (11, 22)}

# 字典是无序的 不可以通过索引取值 切片

# dt = {'a': 1, 'b': 2, 'c': 3}

# print(dt[1]) # 报错

# 通过key取值

dt = {'a': 1, 'b': 2, 'c': 3}

print(dt['a'])  #

#  删除

dt = {'a': 1, 'b': 2, 'c': 3}

del dt['a']

print(dt)  # {'b': 2, 'c': 3}

# 循环取值

info = {

    "key0": True,

    "key1": 10,

    "key2": 20,

    "key3": 30,

    "key4": [11, 22, 33],

    "key5": (44, 55, 66,),

    "key6": {'k0': 'v0', 'k1': 'v1', 'k2': 'v2'}

}

for item in info:  # 默认是取键

    print(item)

    """

key0

key1

key2

key3

key4

key5

key6

    """

for item in info.keys():  # 取键

    print(item)

for item in info.values():  # 取值

    print(item)

for k, v in info.items():  # 取键 & 值

    print(k, v)

# 字典的键要唯一 如果重复只显示第一个 注意：True=1 False=0

test = {1: '', True: ''}

print(test)  # {1: '1'}

test = {2: '', True: ''}

print(test)  # {2: '1', True: '1'}

################# dict 的方法

# fromkeys() 类的静态方法

# fromkeys(*args, **kwargs)

v = dict.fromkeys([11, 22, 33])

print(v)  # {11: None, 22: None, 33: None}

v = dict.fromkeys([11, 22, 33], ['a', 'b'])

print(v)  # {11: ['a', 'b'], 22: ['a', 'b'], 33: ['a', 'b']}

# 通过索引取值，如果键不存在就报错

# 用get函数取值，不存在不报错，并且可以指定默认值

# get() 取值

dt = {'a': 1, 'b': 2, 'c': 3}

v = dt.get('a',99)

print(v) #

v = dt.get('z',99) # 如果不存在，取第二个参数的值

print(v) #

# pop() 删除

dt = {'a': 1, 'b': 2, 'c': 3}

v = dt.pop('a',99)

print(v) #

v = dt.pop('z',99) # 键不存在 得到默认值

print(v) #

# popitem() 随机删除一个

dt = {'a': 1, 'b': 2, 'c': 3}

v = dt.popitem() # 删除并返回一个元组

print(v) # ('c', 3)

k,v = dt.popitem()

print(k,v) # b 2

# setdefault() 键已经存在，不设置并获取已存在的值，键不存在，就设置并取当前设置的值

dt = {'a': 1, 'b': 2, 'c': 3}

v = dt.setdefault('a','')

print(v) #

print(dt) # {'a': 1, 'b': 2, 'c': 3}

v = dt.setdefault('z','')

print(v) #

print(dt) # {'a': 1, 'b': 2, 'c': 3, 'z': '10'}

# update() 更新

dt = {'a': 1, 'b': 2, 'c': 3}

dt.update({'a':'','z':''})

print(dt) # {'a': '10', 'b': 2, 'c': 3, 'z': '100'}

dt.update(k=123,k2=456,k3="")

print(dt) # {'a': '10', 'b': 2, 'c': 3, 'z': '100', 'k': 123, 'k2': 456, 'k3': '789'}

"""

必会： keys() values() get() update() items()

"""

__author__ = "Tang"

"""

集合

1.不同元素组成

2.无序

3.集合中元素必须是不可变类型

"""

s = {1,2,3,4,5}

print(s) # {1, 2, 3, 4, 5}

# 自动去重

s = {1,2,3,4,5,3,3,2,1}

print(s) # {1, 2, 3, 4, 5}

# 无序的

s = {'hello','world','tang'}

for i in s:

    print(i,end=" ") # hello tang world

# 元素必须是不可变类型

# s = {[1,2,3],"tang"}

# print(s) # 报错

# 字符串转集合

s = set('hello')

print(s,end=" ") # {'l', 'h', 'o', 'e'}

# 列表转集合

s = set(['tang','lao','er'])

print(s) # {'er', 'tang', 'lao'}

##############set 方法##############

# add()添加

s = {1,2,3,4,5,6}

s.add('s')

print(s) # {1, 2, 3, 4, 5, 6, 's'}

# clear() 清空

s = {1,2,3,4,5,6}

s.clear()

print(s) # set()

# copy() 拷贝

s = {1,2,3,4,5,6}

s1 = s.copy()

print(s1) # {1, 2, 3, 4, 5, 6}

# pop() 随机删除一个并返回其值

s = {1,2,3,4,5,6}

s1 = s.pop()

print(s) # {2, 3, 4, 5, 6}

print(s1) #

# remove() 指定删除，如果不存在就报错

s = {1,2,3,4,5,6}

s1 = s.remove(1)

# s.remove('s') # 报错

print(s) # {2, 3, 4, 5, 6}

print(s1) # None

# discard() 指定删除,不存在也不会报错

s = {1,2,3,4,5,6}

s1 = s.discard(1)

s.discard('s') # 不报错

print(s) # {2, 3, 4, 5, 6}

print(s1) # None

# 集合去重不会遵守原来序列的顺序

a = ['a','t','b','a','t','g','h']

a = set(a)

print(a) # {'g', 'a', 't', 'h', 'b'}

a = list(a)

print(a) # ['g', 'a', 't', 'h', 'b']

# 交集 intersection()  &

a = ['tang','lao','er']

b = ['tang','chen','lao','er','san']

p_a = set(a)

p_b = set(b)

a_and_b = p_a.intersection(p_b)

print(a_and_b) # {'lao', 'tang', 'er'}

a_and_b2 = p_a & p_b

print(a_and_b2) # {'lao', 'tang', 'er'}

# 并集 union() |

a = ['tang','lao','er']

b = ['tang','chen','lao','er','san']

p_a = set(a)

p_b = set(b)

a_or_b = p_a.union(p_b)

print(a_or_b) # {'san', 'lao', 'tang', 'er', 'chen'}

a_or_b2 = p_a | p_b

print(a_or_b) # {'san', 'lao', 'tang', 'er', 'chen'}

# 差集 difference() -

a = ['tang','lao','er','susu']

b = ['tang','chen','lao','er','san']

p_a = set(a)

p_b = set(b)

a_b = p_a.difference(p_b)

print(a_b) # {'susu'}

a_b2 = p_a - p_b

print(a_b2) # {'susu'}

# 交叉补集 总的减去共同的部分  symmetric_difference() ^

a = ['tang','lao','er','susu']

b = ['tang','chen','lao','er','san']

p_a = set(a)

p_b = set(b)

a_b = p_a.symmetric_difference(p_b)

print(a_b) # {'san', 'chen', 'susu'}

a_b = p_a ^ p_b

print(a_b) # {'san', 'chen', 'susu'}

# difference_update() 删除相同的 留下不同的

a = ['tang','lao','er','susu']

b = ['tang','chen','lao','er','san']

p_a = set(a)

p_b = set(b)

a_b = p_a.difference_update(p_b) # 减去相同的 并更新赋值

print(a_b) # None

print(p_a) # {'susu'}

# isdisjoint() 判断是否为无共同部分的

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

b = {'e','f'}

print(a.isdisjoint(b)) # True

# issubset() 判断是否为子集

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

b = {'a','b'}

print(b.issubset(a)) # True

print(a.issubset(b)) # False

# issuperset() 判断是否为父集

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

b = {'a','b'}

print(b.issuperset(a)) # False

print(a.issuperset(b)) # True

# update() 更新多个值，元组，列表，集合都可以

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

b = {'e','f'}

b.update(a)

print(b) # {'b', 'e', 'c', 'f', 'a'}

b.update((1,2,3))

print(b) # {'c', 1, 2, 'a', 3, 'b', 'e', 'f'}

b.update([4,5,6])

print(b) # {1, 2, 3, 4, 5, 6, 'f', 'c', 'a', 'b', 'e'}

"""

update() 与 add() 比较：

1.update() 可以添加多个值，参数可以是可迭代数据类型

2.add() 只能添加一个元素

可迭代类型:

可以for循环遍历的就是可迭代类型

"""

# frozenset() 定义为不可变集合

s = frozenset('hello')

print(s) # frozenset({'l', 'o', 'h', 'e'})

for i in s:

    print(i,end=" ") # h o e l