标准数据类型
Python3 中有六个标准的数据类型：
- Number（数字）分别包括：
- int、
- float
- bool
- complex（复数）
- String（字符串）
- List（列表）
- Tuple（元组）
- Set（集合）
- Dictionary（字典）
string、list 和 tuple 都属于 sequence（序列）
Python3 的六个标准数据类型中：
- 不可变数据（3 个）：Number、String、Tuple；
- 可变数据（3 个）：List、Dictionary、Set。
# 各类型的定义格式 deposit = 0 salary = 23.55 name = \'xiyang\' house = [\'天津\',\'河北\'] family = (\'老妈\',\'老爸\',\'老公\',\'老弟\') # 不可变 job = {\'work\':\'软件测试\',\'time\':\'早9晚6\'} age = set(\'18\') # 不可重复 print(type(deposit),type(salary),type(name),type(house),type(family),type(job),type(age)) # <class \'int\'> <class \'float\'> <class \'str\'> <class \'list\'> <class \'tuple\'> <class \'dict\'> <class \'set\'> #追加格式 house.append(\'北京\') job.setdefault(\'price\',22.33) age.add(20) print(house,job,age)
int（整型）
简介：
通常被称为整型或整数，是正或负整数，不带小数点。python3中整型是没有限制大小的，可以当做Long类型使用，所有python3中没有Long类型
语法：
age = 18 num = -22
a,b,c = 0,1,2# 一次给多个变量赋值 print(age) print(num)
print(a,b,c)
float（浮点型）
简介：
浮点类型由整数部分与小数部分组成，浮点型也可以使用科学计数法表示（2.5e2 = 2.5 *10次方 = 250 ），浮点型也就是带有小数点的数，其精度和机器有关。
语法：
score = 82.342 num = -022.1 print(score) print(num)
complex（复数）
简介：
Python还支持复数，复数由实数部分和虚数部分构成，可以用 a + bj,或者 complex(a,b) 表示， 复数的实部 a 和虚部 b 都是浮点型。
语法：
pass
boole（布尔类型）
简介：
在 Python2 中是没有布尔型的，它用数字 0 表示 False，用 1 表示 True。到 Python3 中，把 True 和 False 定义成关键字了，但它们的值还是 1 和 0，它们可以和数字相加。
和其他编程语言一样，Python布尔类型也是用于逻辑运算，有两个值：True（真）和False（假）
语法：
age = 18 print(age > 19) print(age < 19) #>>>False #>>>True
string（字符串类型）
简介：
字符串是 Python 中最常用的数据类型。我们可以使用引号( \'\' 或 "" )来创建字符串。
Python中的字符串有两种数据类型，分别是str类型和unicode类型，str类型采用的ASCII编码，无法表示中文，unicode类型采用unicode编码，能够表示任意字符，包括中文和其他语言。
创建字符串很简单，只要为变量分配一个值即可。
实例：
字符串定义
var1=\'xiyang\' addr = \'北京\'
字符串更新
var2=\'Hello xiyang\'
# 截取字符串的一部分并与其他字段拼接
print(\'已更新的字符串：\',var2[:6]+\'python\')
print(\'已更新的字符串：\',\'Hi\'+var2[-7:])
字符串常用方法：
查找
# Python 不支持单字符类型，单字符在 Python 中也是作为一个字符串使用。 # Python 访问子字符串，可以使用方括号 [] 来截取字符串，字符串的截取的语法格式如下
var1 = \'Hello World!\' var2 = "Python" print(var1[0]) # 打印字符串var1中下标为0的元素 print(var2[1:5]) # 打印字符串var2中下标从1-5的元素（前包后不包） print(str.index(\'x\')) # 根据元素查找下标。如果下标不存在，报错ValueError: substring not found。不推荐使用 str = \'Hi xiyang\' print(str.find(\'x\')) # 根据元素查找下标。如果下标不存在，返回-1。推荐使用 print(str.count(\'i\')) # 统计字符串中某个出现的次数
去空格
s = \' a bc \' print(s.strip()) # 去掉字符串两边的空格和换行符 print(s.rstrip())# 只去掉右边的空格和换行符 print(s.lstrip()) # 只去掉左边的空格和换行符 print(s.replace(\'a\',\'A\')) # 替换，将前边的替换为后边的 print(s.replace(\' \',\'\')) # # 去中间空格，该方法可以替换中间的空格，将空格替换为空
大小写转换
s1 = \'Python\' print(s1.upper())# 把所有的字母都变成大写 print(s1.lower())# 把所有的字母都变成小写 print(s1.capitalize())# 把首字符变为大写 print(s1.center(50,\'*\'))# 设置等长为50，若不足50用指定字符在两边填充
判断字符格式
s2 = \'A!TD22. 3\' print(s2.isupper())# 出现的字母，是不是都是大写字母 print(s2.islower())# 出现的字母，是不是都是小写字母 print(s2.isalpha())# 是字母或汉字，返回True print(s3.isalnum())# 只有数字或者字母或汉字会返回True，其他的都返回False
判断是否是整数
s4 = \'123\' print(s.isdigit())# s = \'-1\'s中不只有整数，还有符号-，所以返回False print(s4.isdigit())# s2 = \'0\'s2中是整数，所以返回True print(s4.zfill(5))# 前面补0，这里设置的5为补0后的总长度（该方法仅支持字符串类型）
判断是否以指定字符开头或结尾。返回布尔值True和False
print(s1.startswith(\'a\')) # 判断开头 print(s1.endswith(\'.jpg\')) # 判断结尾
分割（拆分）字符串 split
str = \'hello \npython \nhi\' print(str.split(\' \')) # 以空格分隔，包含\n #>>>输出结果：[\'hello\', \'\npython\', \'\nhi\'] print(str.split(\' \',1)) # 以第一个空格分隔，分隔为两个 #>>>输出结果：[\'hello\', \'\npython \nhi\'] str = \'my..name..is..xiyang\' print(str.split(\'..\'))# 使用..拆分 [\'my\', \'name\', \'is\', \'xiyang\'] print(str.split(\'..\',-1))# 等价于str.split [\'my\', \'name\', \'is\', \'xiyang\'] print(str.split(\'..\',0))# 和没拆分一样 [\'my..name..is..xiyang\'] print(str.split(\'..\',1))# 以第一个..拆分，拆分为两个 [\'my\', \'name..is..xiyang\'] print(str.split(\'..\',2))# 以第一个..拆分，拆分为三个 [\'my\', \'name\', \'is..xiyang\'
连接字符串 join（和split效果相反）
str1 = [\'my\', \'name\', \'is\', \'xiyang\'] print(\' \'.join(str1)) # 将str1中的list使用空格连接 print(\'_\'.join(str1)) # 将str1中的list使用下划线连接 print(\'\'.join(str1)) # 将str1中的list使用空连接，也就是将连接符都去掉
字符串格式化：%s、%d、%f
# 占位符：%s ，是万能占位符，可以跟字符串、整数、小数。如：\'欢迎【%s】登录，今天的日期是:%s\' # 占位符：%d ，代表整数占位符。如：\'你的年龄是：%d\'。如果是%d，后边一定是要跟int类型，因为input接收的都是字符串类型，所以要在input时转换成int类型 # 占位符：%f ，代表小数占位符。如：\'你的成绩是：%.2f\' 。如果是%f，后边一要跟float类型，float默认保留小数点后6位，如果想保留2位则写为：%.2f，想保留几位就写%.xf # 只有一个变量的写法 for i in range(3): username = input(\'请输入你的名字：\') welcome = \'欢迎【%s】登录\' % username # welcome2 = \'欢迎\'+username+\'登录\'# 简单粗暴的方式，用+号连接，不推荐 print(welcome) age = int(input(\'请输入你的年龄：\')) a1 = \'你的年龄是：%d\' % age print(a1) score = float(input(\'请输入你的成绩：\')) s1 = \'你的成绩是：%.2f\' % score print(s1) print(\'==================开始多个变量的写法===================\') # 多个变量的写法 import datetime # 导入datetime包 today = datetime.datetime.today()# 获取当前日期 for i in range(3): username = input(\'请输入你的名字：\') age = int(input(\'请输入你的年龄：\')) score = float(input(\'请输入你的成绩：\')) welcome = \'欢迎【%s】登录，今天的日期是：%s，你的年龄是：%d，你的成绩是：%.2f\' % (username,today,age,score)# 如果是多个%s，后面就要跟多个变量，多个变量要使用括号括起来 # welcome2 = \'欢迎\' + username + \'登录,\'+\'今天的日期是：\' + str(today)# 字符串拼接的方式，需要是相同类型，所以需要将today转换为字符串格式。用+号连接，不推荐 print(welcome)
字符串格式化：format、format_map
# format方法和format_map方法是做字符串格式化的，用{}占位，区别在于format_map方法传的是字典格式。同%s，两种都是做字符串格式化，用哪个都可以，数据多的时候推荐用该方法 s5 = \'今天是{},欢迎{}登录\' print(s5.format(\'2020-04-08\',\'xiyang\')) # 举例 s6 = \'insert into stu(id,name,email,phone,addr) value({id},{name},{email},{phone},{addr})\' # .format{}方法，直接在可变的值中定义好名字，传值时不需要按顺序传值，也可以正确插入 print(s6.format(phone = \'17611111111\',name = \'xiyang\',id = 1,email = \'1366625010@qq.com\',addr = \'北京市\')) # .format_map print(s6.format_map({\'phone\':\'17611111111\',\'name\':\'xiyang\',\'id\':1,\'email\':\'1366625010@qq.com\',\'addr\':\'北京市\'}))
# 演示三种写法（%s、format、format_map）的区别 s6 = \'insert into stu(id,name,email,phone,addr) value({id},{name},{email},{phone},{addr})\' id = input(\'请输入id：\') name = input(\'请输入name：\') phone = input(\'请输入phone：\') addr = input(\'请输入addr：\') email = input(\'请输入email：\') # %s方式 print(\'insert into stu(id,name,email,phone,addr) value(%s,%s,%s,%s,%s)\' % (phone,id,addr,name,email)) # format方式 print(s.format(phone=phone,addr=addr,id=id,name=name,email=email)) # format_map方式 print(s.format_map({\'phone\':phone,\'name\':name,\'id\':id,\'email\':email,\'addr\':addr})) # 结论：%s的方式，当数据多时，如果顺序传混了，那么存值也就存混了，如id在前方，我传了phone在前方，系统就会把我输入的phone的值，放到id中
list（列表、数组）
简介：
List（列表） 是 Python 中使用最频繁的数据类型。
列表可以完成大多数集合类的数据结构实现。列表中可以放任何数据类型，它支持数字，字符串甚至可以包含列表（所谓嵌套）。
列表是写在方括号 [] 之间、用逗号分隔开的元素列表。
和字符串一样，列表同样可以被索引和截取，列表被截取后返回一个包含所需元素的新列表。
可对列表进行创建、查找、切片、增加、修改、删除、循环和排序操作。
索引值以 0 为开始值，-1 为从末尾的开始位置。
语法格式：
list = [元素1,元素2,元素...] # 字符串类型的需要用引号括起来，数字类型的则不用
实例：
创建
list = [123,1.56,\'python\',\'java\',\'!@#\']
list = [] # 创建一个空列表
查询
print(list) # 输出完整的列表，即[123, 1.56, \'python\',\'java\',\'!@#\'] print(list[0]) # 输出第一个元素，即123 print(list[1:4]) # 输出从第二个元素开始，到第四个元素，即[1.56, \'python\', \'java\'] print(list[2:]) # 输出从第三个元素（第二个下标）开始的所有元素，即[\'python\',\'java\',\'!@#\'] print(list[:-3]) # 输出倒数第三个元素之前的所有元素，即[123, 1.56] print(list * 2) # 输出两次列表，即[123, 1.56, \'python\',\'java\',\'!@#\', 123, 1.56, \'python\',\'java\',\'!@#\']
新增
mobile = [\'oppo\',\'小米\',\'三星\',\'vivo\'] mobile.append(\'华为\') # append方法是在列表的末尾增加一个元素 print(mobile)
mobile.insert(1,\'一加\') # insert方法是在列表的指定位置增加一个元素 print(mobile)
修改
mobile[1] = \'苹果\' print(mobile)
删除
mobile = [\'oppo\',\'小米\',\'小米\',\'三星\',\'vivo\',\'华为\',\'一加\'] mobile.pop(1) # pop是指定下标删除，下标不存在会报错，未指定下标时，默认删除最后一个元素 print(mobile) mobile.remove(\'vivo\') # remove方法是删除第一个值为 x 的元素，元素不存在会报错 print(mobile) mobile = [\'oppo\',\'小米\',\'三星\',\'vivo\',\'华为\',\'一加\'] # del语句可以通过切片的方式进行移除元素 del mobile[2:4] # 删除第2和第3个元素，即\'三星\',\'vivo\' print(mobile) del mobile[0] # 删除第一个元素，即\'oppo\' print(mobile) del mobile[:] # 删除整个列表中的元素 print(mobile) del mobile # 此后，再引用 a 就会报错（直到为它赋与另一个值）
列表常用方法
num = [33,1,3,45.67,99,1093,44,32,67,1] num1 = [9,8,7] print(num.count(1)) # 查找参数出现的次数 print(num.index(44)) # 查找元素的下标
print(len(num)) # 打印num数组中的元素个数 # print(num.clear()) # 清空列表，相当于del a[:] num.extend(num1) # 合并列表，合并后产生一个新列表
num2 = num + num1 # 用加号拼接列表，也可达到合并列表的目的
num.sort() # 排序，默认升序 num.sort(reverse=True) # 倒序排序 num.reverse() # 反转，即把最后一个展示在前面，前面的展示到最后，和排序是有区别的 print(num) # 您可能已经注意到，方法sort、reverse只修改列表，没有返回值，它们返回的默认 None。这是Python中所有可变数据结构的设计原则。所以如果直接使用print(num.sort)输出的是None
多维数组 创建 & 取值
array = [\'1\',\'2\',\'3\',\'4\',[\'a\',\'b\',\'c\',\'d\']] # 二维数组 array1 = [1,2,3,4,[\'A\',\'B\',\'C\',\'D\',[\'!\',\'@\',\'#\',\'$\']]] # 三维数组 array2 = [1,2,3,[\'A\',\'B\',\'C\',\'D\',\'E\',[\'!\',\'@\',\'#\',\'$\',[\'2\',3,\'P\',\'T\']]]] # 四维数组
print(array1[4][4][1])# 取值@ print(array2[3][5][4][2])# 取值P
嵌套列表
arr1 = [\'a\',\'b\',\'c\',\'d\'] arr2 = [1,2,3,4] arr3 = [\'你\',\'好\'] arr = [arr1,arr2,arr3] print(arr) # >>> [[\'a\', \'b\', \'c\', \'d\'], [1, 2, 3, 4], [\'你\', \'好\']]
实现堆栈--后进先出（可用列表形式轻松实现）
# 使用列表的append()和pop()两个函数组合即可轻松实现 stack = [1,2,3] stack.append(4) print(stack) stack.pop() print(stack)
实现队列--先进先出（使用列表形式实现队列很慢，因为所有其他元素都必须移动一位，这里不推荐使用），实现队列最好用 collections.deque，可以快速从两端添加或删除元素
from collections import deque queue = deque(["Eric", "John", "Michael"]) queue.append("Terry") # 在列表的最后方增加元素 print(queue) queue.popleft() # 在列表的最前方删除元素 print(queue)
tuple（元组）
简介：
元组与列表类似，不同之处在于元组的元素不能修改，所以不支持append、inster、pop等方法。
元组写在小括号 () 里，元素之间用逗号隔开。
元组中的元素类型也可以不相同。
注意构造包含 0 或 1 个元素的元组的特殊语法规则。
实例：
元组创建 & 查找
tuple = (1,1,2.53,\'!@#\',\'oppo\',\'小米\',\'三星\',\'vivo\') tuple1 = (\'苹果\',\'华为\') tuple2 = () # 创建一个空元组
tuple3 = (20,) # 一个元素，需要在元素后面添加逗号
print(tuple) # 打印tuple元组 print(tuple[2]) # 打印出元组中下标为2的元素 print(tuple[:4]) # 打印元组中下标为4之前的所有元素（不包含下标4） print(tuple[2:]) # 打印元组中从下标2开始，之后的所有元素（包含下标2） print(tuple[3:6]) # 打印元组中从下标3开始（包含下标3），到下标6之前的元素（不包含下标6） print(tuple * 2) # 输出两次元组 print(tuple + tuple1) # 合并元组，元组不支持extend的方式合并 print(tuple.index(\'oppo\')) # 查找某个元素的下标 print(tuple.count(1)) # 统计某个元素出现的次数 print(len(tuple)) # 打印出元组中元素的个数
多维元组 / 元组嵌套
tuple = (1,1,2.53,\'!@#\',\'oppo\',\'小米\',\'三星\',\'vivo\',(\'苹果\',\'华为\'),[\'锤子\',\'一加\']) print(tuple[-3:])
# 虽然tuple的元素不可改变，但它可以包含可变的对象，比如list列表。
dictionary（字典）
简介：
字典是一种键值对的集合，是Python中除列表以外，另一个非常有用和灵活的内置数据类型。
列表是有序的对象集合，字典是无序的对象集合。两者之间的区别在于：字典当中的元素是通过键来存取的，而不是通过偏移存取。
字典是一种映射类型，字典用 { } 标识，它是一个无序的 键(key) : 值(value) 的集合。
字典的key必须使用不可变类型。
在同一个字典中，键(key)必须是唯一的。
实例：
创建
info1 = {} # 创建一个空字典
info2 = {
\'moble\':\'iphone 12 pro max\'
}
info = {
\'name\': \'溪洋\',
\'num\':13412345678,
\'qq\':1361111,
\'email\':\'1361111@qq.com\',
\'addr\':\'北京\'
} # 创建一个有内容的字典
查询
print(info[\'name\']) # 输出key为name的value,取不存在的key，会报错。不推荐使用 print(info.get(\'addr\')) # 输出key为name的value,取不存在的key，返回None。推荐使用
print(info.keys()) # 输出字典中所有的key，注意字典是无序的 print(info.values()) # 输出字典中所有的value，注意字典是无序的 info.update(info2) # 合并字典 print(info) # 输出完整的字典
新增
info.setdefault(\'sex\',\'女\') # 该写法如果新增的key在原列表中存在，对其不做处理 info [\'age\'] = 18 # 该写法如果新增的key在原列表中存在，会对原有值进行修改
修改
info [\'num\'] = \'133\' # 通过key修改value
删除
info.pop(\'email\') # 删除指定key，和del的两种写法没区别 del info[\'num\'] # 删除指定key，和pop的两种写法没区别 info.popitem() # 随机删除指定key，该功能基本用不到 # info.clear() # 清空字典 print(info)
常用方法
info = { \'name\': \'溪洋\', \'num\':13412345678, \'qq\':1361111, \'email\':\'1361111@qq.com\', \'addr\':\'北京\' } # 创建一个有内容的字典 print(len(info)) # 计算字典元素个数，即键的总数。 print(type(info)) # 返回输入的变量类型，如果变量是字典就返回字典类型。 print(\'name\' in info) # 判断键。如果键在字典dict里返回true，否则返回false
字典嵌套
info = { \'xiyang\':{ \'house\':[\'北京\',\'上海\',\'成都\',\'江苏\'], \'car\':{ \'china\':[\'比亚迪\',\'长安\',\'红旗\'], \'japan\':[\'丰田\',\'马自达\',\'雷克萨斯\'], \'Genmany\':{ \'奔驰\':2, \'宝马\':3, \'大众\':5 } } } }
# 溪洋又买了一辆宝马 stu_info[\'xiyang\'][\'car\'][\'Genmany\'][\'宝马\']+=1 # a+=1等同于a=a+1。包括-= /= *=同理，如a-=2，就是a=a-2 print(stu_info) # 溪洋把比亚迪扔掉了 stu_info[\'xiyang\'][\'car\'][\'china\'].remove(\'比亚迪\')# 按照字典层级去找 print(stu_info)
字典循环
# 第一种效率快一些，第二种慢一些，数据多的话用第一种
accounts = { \'name\':\'xiyang\', \'age\':18, \'job\':\'软件测试\' } accounts1 = { \'sex\':\'女\' } accounts2 = { \'email\':\'136000\',
\'sex\':\'女\'
# 方法一：直接循环字典 for k in accounts: # print(\'%s ==> %s\' %(k,accounts[k]))
# 方法二：使用items()函数 for k,v in accounts.items(): print(\'%s ==> %s\' % (k,v))
# enumerate()函数：同时取位置索引和对应的值 for i, v in enumerate(accounts): print(i, v) # >>>0 name 1 age 2 job # zip() 函数：同时循环两个或多个序列 for a,b,c in zip(accounts,accounts1,accounts2): print(accounts,accounts1,accounts2) # >>>{\'name\': \'xiyang\', \'age\': 18, \'job\': \'软件测试\'} {\'sex\': \'女\'} {\'email\': \'136000\', \'sex\': \'女\'} # reversed()函数：逆向循环 for i in reversed(accounts): print(i,accounts[i]) # sorted()按指定顺序循环序列 basket = [\'apple\', \'orange\', \'apple\', \'pear\', \'orange\', \'banana\'] for i in sorted(basket): print(i) # set()去除序列中重复的元素 basket = [\'apple\', \'orange\', \'apple\', \'pear\', \'orange\', \'banana\'] for f in sorted(set(basket)): print(f)
json & pickle
简介
# 在python中，有专门处理json格式的模块--json 和 pickle模块 # json 模块提供了四个方法： dumps、dump、loads、load # pickle 模块也提供了四个功能：dumps、dump、loads、load # json的数据格式其实就是python里面的字典格式，里面可以包含方括号括起来的数组，也就是python里面的列表。 # json的数据必须使用双引号
# json格式通常用于现代应用程序的数据交换
实例
import json data = { "error_code":0, "stu_info":[ { "id":300, "name":"怡宝", "sex":"男", "age":18, "addr":"北京市海淀区" }, { "id": 301, "name": "农夫山泉", "sex": "女", "age": 18, "addr": "北京市朝阳区" }, { "id": 302, "name": "百岁山", "sex": "男", "age": 18, "addr": "北京市昌平区" } ] }
# json模块把字典转成json字符串的方法--dumps with open(\'abc.txt\',\'w\',encoding=\'utf-8\') as fw: s = json.dumps(data,ensure_ascii=False, indent=4) fw.write(s) print(s) # 参数解释： # data，需要转换为json格式的字符串 # ensure_ascii=False，解决中文问题，若为True则输出的格式为Unicode # indent=4，代表缩进，4个空格
# json模块把字典转成json字符串的方法--dump with open(\'abc.txt\',\'w\',encoding=\'utf-8\') as fw: s = json.dump(data,fw,ensure_ascii=False, indent=4) print(s) # 参数解释： # data，需要转换为json格式的字符串（字典） # fw, 需要打开的文件名 # ensure_ascii=False，解决中文问题，若为True则输出的格式为Unicode # indent=4，代表缩进，4个空格
# dumps方法和dump方法的区别： # dump比dumps方法多传一个文件名，dump就不需要手工的write一次了，这个方法会自动write。
# json模块把字符串转成字典的方法--loads with open(\'abc.txt\', encoding=\'utf-8\') as fr: # json字符串要在文件中存在才可以 result = fr.read() print(\'result,刚从文件里面读出来的\',result,type(result)) dic = json.loads(result) # loads代表字符串转成字典 print(\'dic,转换完之后的\', dic, type(dic))
# json模块把字符串转成字典的方法--loads with open(\'abc.txt\', encoding=\'utf-8\') as fr: # json字符串要在文件中存在才可以 result = json.load(fr) print(\'result\',type(result)) print(result)
# loads方法和load方法的区别： # load比loads方法多传一个文件名，load方法就不需要手工的read一次了，这个方法会自动read，相对来说load方法更简单一些
set（集合）
简介：
集合是一个无序的、不重复的数据组合，它的主要作用有两个，分别是：进行成员关系测试和删除重复元素。
集合是由一个或数个形态各异的大小整体组成的，构成集合的事物或对象称作元素或是成员。
可以使用大括号 { } 或者 set() 函数创建集合，注意：创建一个空集合必须用 set() 而不是 { }，因为 { } 是用来创建一个空字典。
集合天生可以去重，并且是无序的（就是不能通过下标来取值）。但是可以通过循环去取值
实例：
定义&取值
s = set() # 定义一个空集合
s1 = [1,1,2,3,4,3] print(set(s1)) # 输出的结果是{1, 2, 3, 4} #通过循环取值 for i in s1: print(i) # 输出的结果是1 1 2 3 4 3
添加元素 add()和update()
s = set() # 定义一个空集合 # add()方法添加元素：参数可以是整数，小数，字符串，元组 s.add(1) s.add(2.32) s.add(\'d\') s.add((7,)) print(s)
# update()方法添加：参数可以是列表，元组，集合，字典，字符串 s.update([2]) s.update((5,)) s.update({3}) s.update({\'name\':\'xiyang\'}) # 只能将key添加进去\'name\' s.update(\'2\')
print(s)
# 使用add()和update()两种方法重复添加值 s2 = {8,9,10,11,\'a\'} # 如果添加重复的元素，比如s2.add(8)、s2.update(\'a\')，是不会加进去的。因为集合本身就是不能重复的 s2.add(8) s2.update(\'a\') s2.update([\'a\',\'b\']) print(s2) # >>>{\'b\', 8, 9, 10, 11, \'a\'}只添加进去了b，因为a和8原本的集合中已经存在了
删除
s.remove(1) # 删除元素
s.discard(5) # 删除集合中指定的元素 print(s.pop()) # 随机删除一个元素
print(s)
其他
print(len(s2))# 打印集合中元素的长度（去重后的长度）
print(s.copy()) # 拷贝一个集合
交集、并集、差集、对称差集
language1 = [\'c\',\'c++\',\'java\',\'python\'] language2 = [\'python\',\'js\',\'css\',\'html\'] lan1_set = set(language1) lan2_set = set(language2) # 取交集的两种写法。取多个集合里边都有的 print(lan1_set.intersection(lan2_set)) print(lan1_set & lan2_set) # >>> {\'python\'} # 取并集的两种写法。把多个集合合并到一起，在去重 print(lan1_set.union((lan2_set))) print(lan1_set | lan2_set) # >>> {\'c\', \'js\', \'java\', \'html\', \'c++\', \'python\', \'css\'} # 取差集的两种写法。取出在a集合里边有，在b集合里边没有的 print(lan1_set.difference(lan2_set)) print(lan1_set - lan2_set) # >>> {\'java\', \'c\', \'c++\'} # 取对称差集的两种写法。把多个集合中都有的元素删除，在取出（两个集合的并集减去它们的交集） print(lan1_set.symmetric_difference(lan2_set)) print(lan1_set ^ lan2_set) # >>> {\'c\', \'js\', \'java\', \'html\', \'c++\', \'css\'}
判断
language1 = [\'c\',\'c++\',\'java\',\'python\'] language2 = [\'python\',\'js\',\'css\',\'html\'] lan1_set = set(language1) lan2_set = set(language2) print(lan1_set.isdisjoint(lan2_set)) # 判断两个集合是否包含相同的元素，如果有返回 False，如果没有返回 True。 print(lan1_set.issubset(lan2_set)) # 判断指定集合是否为该方法参数集合的子集。如果有返回 True，如果没有返回 False。 print(lan1_set.issuperset(lan2_set)) # 判断该方法的参数集合是否为指定集合的子集。如果有返回 True，如果没有返回 False。