Python基本数据类型

Python基本数据类型

一、Python基本数据类型

1. int ==> 整数. 主要⽤来进⾏数学运算

2. str ==> 字符串, 可以保存少量数据并进⾏相应的操作

3. bool==>判断真假, True, False

4. list==> 存储⼤量数据.⽤[ ]表⽰

5. tuple=> 元组, 不可以发⽣改变 ⽤( )表⽰

6. dict==> 字典, 保存键值对, ⼀样可以保存⼤量数据

7. set==> 集合, 保存⼤量数据. 不可以重复. 其实就是不保存value的dict

二、整数（int）

在Python 3 中所有的整数都是int类型，但在Python 2 中如果数据量较大则会采用 long类型，而在Python 3 中没有long类型。

常用方法：

​ 1、bit_length()：计算整数在计算机中占用的二进制数的长度。

三、布尔值（bool）

取值只有True和False。

转换问题：

1. str ==> int int(str)
2. int ==> str str(int)
3. int ==> bool bool(int) 0为False，非0位True
4. bool ==> int int(bool) True为1，False为0
5. str ==> bool bool(str) 空为False，非空为True
6. bool ==> str str(bool) 把bool值转换成相应的"值"

四、字符串（str）

字符串：把字符连成串. 在python中⽤', ", ''', """引起来的内容被称为字符串.

1. 索引和切片

   索引：索引指的就是下标，索引从0开始。

   切片：截取字符串指定部分的内容。

   ​ 语法：str[起始位置，结束位置，步长]

   ​ 规则：“顾头不顾尾”，即包含起始位置，但不包含结束位置。

   ​ 步长：如果是整数，则从左往右取，如果是负数，则从右往左取，默认是1。

   content = "生活不止眼前的苟且，以后还有一大堆的苟且。"
   例：截取“眼前的苟且，以后还有”
   print(content[4:14])
   例：截取“生不眼的且以还一堆苟”
   print(content[::2])
   例：将内容翻转
   print(content[::-1])
   例：截取“一有还后以，且苟的前”
   print(content[14:4:-1])
   例：截取“止眼前的苟且，以后还有一大堆的苟且。”
   print(content[3:])
   
   

2. 字符串其它相关方法

   注意：切记, 字符串是不可变的对象, 所以任何操作对原字符串是不会有任何影响的。

   1. 字符串中的字母全部大写

      content = “dogfa is a verv beautiful boy!”
      content = content.upper()
      print(content)
      ==>"DOGFA IS A VERV BEAUTIFUL BOY!"
      

   2. 字符串中的字母全部小写

      content = “DOGFA IS A VERV BEAUTIFUL BOY!”
      content = content.lower()
      print(content)
      ==>"dogfa is a verv beautiful boy!"
      

   3. 英文首字母大写

      content = “dogfa is a verv beautiful boy!”
      content = content.capitalize()
      print(content)
      ==>"Dogfa is a verv beautiful boy!"
      

   4. 大小写转换

      content = “dOgfA iS A verv beautiful boy!”
      content = content.swapcase()
      print(content)
      ==>"DoGFa Is a VERV BEAUTIFUL BOY!"
      

   5. 每个被特殊字符隔开的单词首字母大写

      content = "dogfa is a verv beautiful boy!"
      content = content.title()
      print(content)
      ==>"Dogfa Is A Verv Beautiful Boy!"
      

   6. 居中

      content = "欢迎光临~"
      content = content.center(15, "*")		#将长度拉长为15，两边用‘*’填充
      print(content)
      ==> "*****欢迎光临~*****"
      

   7. 清除空格

      content = "   其实世上本没有路，走的人多了也就成了路     "
      content = content.strip()		#清楚两端空格
      print(content)
      ==> "其实世上本没有路，走的人多了也就成了路"
      
      str.lstrip()		# 清除左端空格
      str.rstrip()		# 清楚右端空格
      str.strip("明")	    # 清除左右两端的“明”
      
      content = "明天到操场操到天明"
      content = content.strip("明")
      print(content)
      ==> "天到操场操到天"
      
      

   8. 字符串替换

      content = "明天到操场操到天明"
      content = content.replace("操", "*")
      print(content)
      ==> "明天到*场*到天明"
      
      str.replace("需要替换的字符串", "替换为的字符串", "替换数量")	# 替换数量默认为全部替换
      content = content.replace("操", "*", 1)
      print(content)
      ==> "明天到*场操到天明"
      

   9. 字符串切割

      content = "清明时节雨纷纷，路上行人欲断魂，借问酒家何处有，牧童遥指杏花村"
      content = content.split("，")
      print(content)
      ==> "['清明时节雨纷纷', '路上行人欲断魂', '借问酒家何处有', '牧童遥指杏花村']"
      
      content = content.split("清")
      print(content)
      ==> "['', '明时节雨纷纷，路上行人欲断魂，借问酒家何处有，牧童遥指杏花村']"
      
      注意：如果切割点在开头或者结尾，都将会在列表的开头或结尾产生一个空字符串。
      

   10. 格式化输出

       例：要求输入以下内容
       *********Welcome~*********
       name: dogfa
       age: 80
       job: piaoke
       hobby: piaochang
       **************************
       
       我们可以这样：
       info = '''*********Welcome~*********
       name: {0}
       age: {1}
       job: {2}
       hobby: {3}
       **************************'''
       name = "dogfa"
       age = 80
       job = "piaoke"
       hobby = "piaochang"
       print(info.format(name, age, job, hobby))
       
       我们也可以这样：
       info = '''*********Welcome~*********
       name: {name}
       age: {age}
       job: {job}
       hobby: {hobby}
       **************************'''
       name2 = "dogfa"
       age2 = 80
       job2 = "piaoke"
       hobby2 = "piaochang"
       print(info.format(name=name2, age=age2, job=job2, hobby=hobby2))
       
       

   11. 查找

       content = "明天到操场操到天明"
       content = content.find("操")
       print(content)
       ==> 3（返回的是下标）
       
       str.find("查找内容", "起始位置", "结束位置")		# 切片查找
       content = content.find("操", 4, 7)
       print(content)
       ==> 5
       
       注意：只能查找到第一个内容的索引，查找不到时将会返回"-1"。
       
       
       
       str.index("查找内容")
       content = content.index("操")
       print(content)
       ==> 3
       
       注意：查找不到内容时将会直接抛出异常。建议使用find()。
       
       
       str.startswith("明")		# 判断字符串是否以“明”开头
       str.endswith("明")		# 判断字符串是否以“明”结尾
       content = content.startswith("明")
       ==> True
       content = content.endswith("明")
       ==> True
       

   12. 条件判断

       # 判断是否为纯数字
       str.isdigit()
       content = "123456"
       content = content.isdigit()
       print(content)
       ==> True
       
       content = "123456abc"
       content = content.isdigit()
       print(content)
       ==> False
       
       # 判断是否为纯英文
       str.isalpha()
       content = "abcde"
       content = content.isalpha()
       print(content)
       ==> True
       
       content = "123456abc"
       content = content.isalpha()
       print(content)
       ==> False
       
       # 判断是否由数字和字母组成
       str.isalnum()
       content = "abcde123456"
       content = content.isalnum()
       print(content)
       ==> True
       
       content = "@123avb"
       content = content.isalnum()
       print(content)
       ==> False
       
       
       # 其它
       str.isdecimal()
       str.isnumeric()		# 这个可以判断中文
       content = "壹仟伍佰"
       content = content.isnumeric()
       print(content)
       ==> True
       

   13. 计算字符串的长度

       content = "你猜我有多长？"
       print(len(content))
       ==> 7
       
       注意：注意: len()是python的内置函数. 所以访问⽅式也不⼀样。
       

   14. 字符串的拼接

       content = "嘿嘿嘿"
       content = "_".join(content)
       print(content)		# 嘿_嘿_嘿
       

   15. 迭代

       for "变量" in "可迭代对象":
       	pass
       	
        
       content = "喜欢唱跳rap篮球"
       for item in content:
           print(item)
           
       ==> 喜
           欢
           唱
           跳
           r
           a
           p
           篮
           球
       
        
       可迭代对象：简单来说就是可以一个一个往外取值的对象，如str, list, tuple。
       

五、列表（list）

1、列表的介绍

列表：列表是Python的基础数据类型之⼀ ,其他编程语⾔也有类似的数据类型. 比如JS中的数
组, java中的数组等等. 它是以[ ]括起来, 每个元素⽤' , '隔开⽽且可以存放各种数据类型:

例：

lst = ["嘿嘿", "吼吼", ["我是", "列表"], ("I'm", "tuple"), {"dict": "我是字典"}, {"set", "我是集合呀"}, 2]

列表相比于字符串可以存取更多类型的数据，而且可以存放大量的数据。列表是有序的，可以通过索引对列表进行切片取值等操作。

2、列表的索引和切片

列表和字符串一样拥有索引

lst = ["孙悟空", "猪八戒", "沙僧", "唐僧"]
print(lst[0])		# 孙悟空
print(lst[1])		# 猪八戒
print(lst[2])		# 沙僧
print(lst[3])		# 唐僧

lst[0] = "齐天大圣"		# 注意：列表是可变类型，可以直接发生改变，和字符串不一样哈
print(lst)		# ["齐天大圣", "猪八戒", "沙僧", "唐僧"]
temp = "天蓬元帅"
temp[0] = "地"
print(temp)		# TypeError: 'str' object does not support item assignment (不可变类型)

列表的切片

lst = ["孙悟空", "猪八戒", "沙僧", "唐僧"]
print(lst[0:2])		# ["孙悟空", "猪八戒", "沙僧"]
print(lst[::2])		# ["孙悟空", "沙僧"]
print(lst[::-1])	# ['唐僧', '沙僧', '猪八戒', '孙悟空']
print(lst[-1:1:-1])	# ["唐僧", "沙僧"]

3、列表的增删该查

注意：列表是可变类型，所以可以直接对列表中的元素进行操作。

1. 增

   lst = ["name", "age", "job", "hobby"]
   lst.append("gender")
   print(lst)		# ["name", "age", "job", "hobby", "gender"]
   
   lst = ["name", "age", "job", "hobby"]
   lst.insert(1, "gender")
   print(lst)		# ["name", "gneder", "age", "job", "hobby"]  按照索引进行插入
   
   lst = ["name", "age", "job", "hobby"]
   lst.extend(["gender", "salary"])
   print(lst)		# ["name", "age", "job", "hobby", "gender", "salary"]  将可迭代对象进行迭代添加
   lst = ["name", "age", "job", "hobby"]
   lst.extend("hello")
   print(lst)		# ['name', 'age', 'job', 'hobby', 'h', 'e', 'l', 'l', 'o']
   

2. 删

   lst = ["鬼剑士", "神枪手", "召唤师", "圣职者", "格斗家"]
   ret1 = lst.pop()		# 默认删除列表最后一个元素，并且可以取得被删除的元素的值
   ret2 = lst.pop(1)		# 也可以指定索引删除
   print(ret1)		# 格斗家
   print(ret2)		# 神枪手
   print(lst)		# ["鬼剑士", "召唤师", "圣职者"]
   
   lst = ["鬼剑士", "神枪手", "召唤师", "圣职者", "格斗家"]
   lst.remove("圣职者")		# 指定列表中的元素名称进行删除，删除不存在的元素会报错
   print(lst)		# ["鬼剑士", "神枪手", "召唤师", 格斗家"]
   
   lst = ["鬼剑士", "神枪手", "召唤师", "圣职者", "格斗家"]
   del lst[2]		# 使用del删除指定的列表元素，只能使用索引或者切片进行删除
   print(lst)		# ["鬼剑士", "神枪手",  "圣职者", "格斗家"]
   
   lst = ["鬼剑士", "神枪手", "召唤师", "圣职者", "格斗家"]
   lst.clear()		# 清空列表
   print(lst)		# []
   

3. 改

   lst = ["马云", "马化腾", "马良", "马蓉", "马克思"]
   lst[1] = "麻花藤"
   print(lst)		# ["马云", "麻花藤", "马良", "马蓉", "马克思"]
   
   lst = ["马云", "马化腾", "马良", "马蓉", "马克思"]
   lst[1:4] = "hello"
   print(lst)		# ["马云", "h", "e", "l", "l", "o", "马克思"]
   

4. 查

   列表是一个可迭代对象，所以可以使用for循环查询

   for ele in list:
   	print(i)
   

5. 其它操作

   # 计算"行者孙"在列表中出现的次数
   lst = ["孙行者", "行者孙", "者行孙", "行者孙"]
   print(lst.count("行者孙"))		# 2
   
   # 计算列表的长度
   lst = ["孙行者", "行者孙", "者行孙", "行者孙"]
   print(len(lst))		# 4
   
   # 对列表元素进行翻转
   lst = ["孙行者", "行者孙", "者行孙", "行者孙"]
   lst.reverse()
   print(lst)	# ["行者孙", "者行孙", "行者孙", "孙行者"]
   
   # 对列表进行排序
   lst = [10,2,45,64,4,16,8]
   lst.sort()		# 默认从小到大排序
   print(lst)		# [2, 4, 8, 10, 16, 45, 64] 
   
   lst.sort(reverse=True)	# 加上参数reverse=True变成从大到小排序
   print(lst2)		# [64, 45, 16, 10, 8, 4, 2]	
   

4、列表的嵌套

lst = [1, "夸父", "dogfa", ["jack ma", ["康帅博"], "麻辣干子"]]
# 找到"夸父"
print(lst[1])

# 找到“夸父“和”dogfa”
print(lst[1:3])

# 将"夸父“替换成”夸母”
lst[1] = lst[1].replace("父", "母")
print(lst)

# 将”jack ma“各个首字母大写
lst[3][0] = lst[3][0].title()
print(lst)

# 将”康帅博“替换成”康师傅“
lst[3][1][0] = lst[3][1][0].replace("帅博", "师傅")
print(lst)

# 将”dogfa“首字母大写
lst[2] = lst[2].capitalize()
print(lst)

5、循环删除列表中的元素（注意）

lst = ["鬼剑士", "神枪手", "召唤师", "圣职者", "格斗家"]
for  i in lst:
	lst.remove(i)
print(lst)		# ['神枪手', '圣职者']
# 为什么我们进行for循环时没有将列表中的元素全部删除？因为for循环每循环一次内部索引会加1，而删除了列表中的元素之后，后面的元素会前移，导致删除错乱。
# 第一次循环： ["神枪手", "召唤师", "圣职者", "格斗家"] 删除索引0对应的元素，后面的元素前移
# 第二次循环： ["神枪手", "圣职者", "格斗家"] 删除索引1对应的元素，后面的元素前移
# 第三次循环： ["神枪手", "圣职者"] 删除索引2对应的元素，后面的元素前移

# 解决办法1
for i in range(len(lst)):
    lst.pop()
print(lst)		# []

# 解决办法2
lst2 = []
for i in lst:
    lst2.append(i)
    
for el in lst2:
    lst.remove(el)
print(lst)		# []

六、元祖（tuple）

元组: 俗称不可变的列表.⼜被成为只读列表, 元组也是python的基本数据类型之⼀, ⽤⼩括
号括起来, ⾥⾯可以放任何数据类型的数据, 查询可以. 循环也可以. 切片也可以. 但就是不能
改.

tu = ("name", "age", "gender")
print(tu)		# ("name", "age", "gender")
print(tu[0])	# name
print(tu[2])	# gender
print(tu[0:2])	# 元祖切片之后还是元祖

# for循环遍历元祖
for ele in tu:
	print(ele)
	
# 尝试修改元祖
tu[0] = "我就是要改变你"	# TypeError: 'tuple' object does not support item assignment （元祖中的元素不支持被修改）

# 再次尝试修改元祖
tu = ("你改不了我的", [], "你也改不了我的", "我们中出了一个叛徒")
tu[1] = "我是叛徒"	# 再次修改失败
tu[1].append("我是叛徒")		# 修改成功
print(tu)	# ("你改不了我的", ["我是叛徒"], "你也改不了我的", "我们中出了一个叛徒")

# 通过以上结论，我们可以得出：元祖的不可变指的是元祖内的子元素不可变，而子元素的子元素可不可变取决于是否是可变类型的对象。
# 注意：当元祖中只有一个元素时，必须在元素后面加上一个逗号，否则就不是元祖，例：tu = ("name",)
# 元祖同样含有len(), index(), count()方法。

七、字典（dict）

1、字典的简单介绍

字典(dict)是Python中唯⼀的⼀个映射类型.他是以{ }括起来的键值对组成. 在dict中key是
唯⼀的. 在保存的时候, 根据key来计算出⼀个内存地址. 然后将key-value保存在这个地址中.
这种算法被称为hash算法, 所以, 切记, 在dict中存储的key-value中的key'必须是可hash的。

可hash的数据类型：int，str，bool，tuple

不可hash的数据类型：list，dict，set

语法：{key: value, key2: value2 ...}

注意: key必须是可哈希(不可变类型)的. value没有要求.可以保存任意类型的数据

# 以下为正确字典格式
dic = {1: 123, "name": "oldniu", False: True, (1, 2, 3): (11, 22, 33)}
print(dic[1])
print(dic["name"])
print(dic[False])
print(dic[(1, 2, 3)])

# 以下是不正确的字典格式
dic = {[1, 2]: "我咋就不合法呢"}	# TypeError: unhashable type: 'list'
dic = {{"name": "dogfa"}: "兄嘚我也是不合法的"}	# TypeError: unhashable type: 'dict'
dic = {{"age", "hobby"}: "想不到吧，我也是不合法的"}	# TypeError: unhashable type: 'set'

注意：dict保存的数据不是按照我们添加进去的顺序保存的. 是按照hash表的顺序保存的. ⽽hash表
不是连续的. 所以不能进⾏切片⼯作. 它只能通过key来获取dict中的数据

2、字典的其它相关操作

1. 增

   dic = {"age": 18}
   dic["name"] = "李白"
   print(dic)		# {"name": "李白", "age": 18}
   dic["age"] = 20
   print(dic)		# {"name": "李白", "age": 20}
   # 如果key不存在，则是执行添加操作，如果key存在，则是执行修改操作
   
   dic = {"age": 18}
   print(dic.setdefault("name", "杜甫"))		# 杜甫
   print(dic)		# {"age": 18, "name": "杜甫"}
   print(dic.setdefault("age", 20))		 # 18
   print(dic)		# {"age": 18, "name": "杜甫"}
   # setdefault()的第一个参数为key，第二个参数为value。如果key不存在，则执行添加操作并返回对应的value，如果key存在，则执行查询操作返回字典中对应的key的value。
   

2. 删

   dic = {"name": "Jack Ma", "age": 38, "gender": "man"}
   print(dic.pop("name")) 		# Jack Ma
   print(dic)			# {"age": 38, "gender": "man"}
   # 因为dict在存储时不是连续的，所以pop在删除时不能指定索引，须指定key进行删除并会返回当前值。
   
   dic = {"name": "Jack Ma", "age": 38, "gender": "man"}
   del dic["name"]
   print(dic)		# {"age": 38, "gender": "man"}
   
   dic.popitem()	# 随机删除
   dic.clear()		# 清空字典
   

3. 改

   dic1 = {"id": 1, "name": "马云", "salary": 100000000}
   dic2 = {"age": 38, "name": "马化腾"}
   dic1.update(dic2)		# 将dict2中的内容更新值dict1中，如果key存在则覆盖，key不存在则添加
   print(dic1)		# {'id': 1, 'name': '马化腾', 'salary': 100000000, 'age': 38}
   print(dic2)		# {'age': 38, 'name': '马化腾'}
   

4. 查

   dic = {"id": 1, "name": "电视机", "price": 1000}
   print(dic["price"])		# 1000
   print(dic["age"])		# 报错
   print(dic.get("name"))	# 电视机
   print(dic.get("age"))	# None
   print(dic.get("age", 20))	# 20
   # 当直接对字典通过key取值时，如果存在key，可以取出对应的值，如果不存在key，则会报错。所以建议使用get（）方法，当key不存在时，它会返回一个None，你也可以在下一个参数指定key不存在时的返回值。
   
   print(dic.setdefault("name"))	# 电视机
   

5. 其它相关操作

   dic = {"id": 1, "fruit": "apple", "price": 10}
   print(dic.keys())		# dict_keys(['id', 'fruit', 'price'])
   for key in dic.keys():
   	print(key)
   	
   print(dic.values())		# dict_values([1, 'apple', 10])
   for value in dic.values():
   	print(value)
   # dic.keys()和dic.values()得到的值和列表很像，但是不是列表，但可以当做列表来进行for循环使用。
   
   for i in dic:
   	print(i,dic[i])			
   	# id 1
   ==>	# fruit apple
   	# price 10
   # 当对字典进行for循环时，得到的元素是key。
   
   print(dic.items())		# dict_items([('id', 1), ('fruit', 'apple'), ('price', 10)])
   for k,v in dic.items():
       print(k,v) 
   	# id 1
   ==>	# fruit apple
   	# price 10
   # dic.items()得到的是类似列表里面嵌套元祖的格式，对dic.items()进行for循环时，得到了里面的元祖。
   # 由于 a, b = (1, 2)可以推出 k, v = ("id", 1),所以k，v 分别对应字典中的key和value。
   

6. 字典的嵌套

   dic = {
   	"id": 9527,
   	"name": "周星星",
   	"age": 40,
   	"movies": ["功夫", "少林足球", "算死草", "逃学威龙"],
   	"partner": {
   		"name": "逼王达",
   		"age": 45,
   		"children": ["老大", "老二", "老三"]
   	},
   	"desc": "别人笑我太疯癫，我笑他人看不穿"
   }
   
   # 获取"别人笑我太疯癫，我笑他人看不穿"
   print(dic["desc"])
   
   # 获取周星星的合作伙伴名字
   print(dic.get("partner").get("name"))
   
   # 获取“逃学威龙”
   print(dic.get("movies")[3])
   
   # 获取逼王达的第二个孩子名字
   print(dic.get("partner").get("children")[1])
   

7. 字典中的fromkeys()（注意）

   dic = dict.fromkeys(["dogfa", "oldniu"], (1, 2))
   print(dic)	# {"dogfa": (1, 2), "oldniu": (1, 2)}
   # fromkeys()用于重新生成一个新的字典，第一个参数中的每一项都会作为新的字典的key，第二个参数作为value。
   
   dic = dict.fromkeys(["dogfa", "oldniu"], [1, 2])
   dic.get("dogfa").append(3)
   print(dic)	# {"dogfa": [1, 2, 3], "oldniu": [1, 2, 3]}
   

八、集合（set）

set集合是python的⼀个基本数据类型. ⼀般不是很常⽤. set中的元素是不重复的.⽆序的.⾥
⾯的元素必须是可hash的(int, str, tuple,bool), 我们可以这样认为， set就是dict类型的数据但
是不保存value, 只保存key. set也⽤{}表⽰。

注意：set中的元素必须是可hash的，但是set本身不是可hash的，set是可变类型数据。

set = {1, "2", True, [1, 2]}	# TypeError: unhashable type: 'list'
set = {1, "2", True, {1: 2}}	# TypeError: unhashable type: 'dict'
set = {1, "2", True, {1, 2}}	# TypeError: unhashable type: 'set'

由于set中的元素是不重复的，无序的，所以我们可以利用这个特性对列表进行去重操作。

lst = ["哈哈哈", 1, "嘿嘿嘿", "哈哈哈", "dsb", True, 1]
print(list(set(lst)))	# [1, 'dsb', '嘿嘿嘿', '哈哈哈']

set的相关操作

1. 增

   s = {1, 2, 3}
   s.add(4)
   print(s)	# {1, 2, 3, 4}
   
   s = {1, 2, 3}
   s.update([4, 5, 6])		# 迭代更新
   print(s)	# {1, 2, 3, 4, 5, 6}
   # 已存在的元素将不会被添加进去
   

2. 删

   s = {1, 2, 3}
   s1 =s.pop()		# 随机删除
   print(s)	# {2, 3}
   print(s1)	# 1
   
   s = {1, 2, 3}
   s.remove(2)
   print(s)	# {1, 3}
   # 对不存在的元素进行删除时将会报错
   
   s = {1, 2, 3}
   s.clear()
   print(s)	# set()
   # 清空之后打印输出的是set()，是为了和dict区分开
   

3. 改

   # 由于集合是没有索引，无序的，所以我们对几个进行删除时不能通过索引的方式来删除
   # 修改方法1：首先通过remove()删掉需要修改的的元素,然后add()添加新元素。
   s = {1, 2, 3}	# 将1改成10
   s.remove(1)
   s.add(10)
   print(s)	# {10, 2, 3}
   
   # 修改方法2：将集合通过list()转换成列表，再通过对列表进行修改操作。
   

4. 查

   for i in s:
   	print(i)
   

5. 其它常用操作

   # 求两个集合中的交集
   s1 = {"狗法", "oldniu", "djb"}
   s2 = {"狗法", "oldniu", "djb", "dsb"}
   print(s1.intersection(s2))	# {"狗法", "oldniu", "djb"}
   print(s1 & s2)	# {"狗法", "oldniu", "djb"}
   
   # 求两个集合中的并集
   s1 = {"狗法", "oldniu", "djb"}
   s2 = {"狗法", "oldniu", "djb", "dsb"}
   print(s1.union(s2))	# {"狗法", "oldniu", "djb", "dsb"}
   print(s1 | s2)	# {"狗法", "oldniu", "djb", "dsb"}