py之基本数据类型
Py之基础数据类型
数据类型
一 Number(数字)
1.1 数字类型的创建
a=10 b=a b=666 print(a)#10 print(b)#666
1.bin()函数将十进制转换成而进制
2.oct()函数将十进制转换成八进制
3.hex()函数将十进制转换成十六进制
分类：整型，布尔，浮点，复数
abs(x) 返回数字的绝对值，如abs(-10) 返回 10 ceil(x) 返回数字的上入整数，如math.ceil(4.1) 返回 5 cmp(x, y) 如果 x < y 返回 -1, 如果 x == y 返回 0, 如果 x > y 返回 1 exp(x) 返回e的x次幂(ex),如math.exp(1) 返回2.718281828459045 fabs(x) 返回数字的绝对值，如math.fabs(-10) 返回10.0 floor(x) 返回数字的下舍整数，如math.floor(4.9)返回 4 log(x) 如math.log(math.e)返回1.0,math.log(100,10)返回2.0 log10(x) 返回以10为基数的x的对数，如math.log10(100)返回 2.0 max(x1, x2,...) 返回给定参数的最大值，参数可以为序列。 min(x1, x2,...) 返回给定参数的最小值，参数可以为序列。 modf(x) 返回x的整数部分与小数部分，两部分的数值符号与x相同，整数部分以浮点型表示。 # pow(x, y) x**y 运算后的值。 # round(x [,n]) 返回浮点数x的四舍五入值，如给出n值，则代表舍入到小数点后的位数。 # sqrt(x) 返回数字x的平方根，数字可以为负数，返回类型为实数，如math.sqrt(4)返回 2+0j
Python 数字类型转换 int(x) 将x转换为一个整数。 float(x) 将x转换到一个浮点数。 complex(x) 将x转换到一个复数，实数部分为 x，虚数部分为 0。 complex(x, y) 将 x 和 y 转换到一个复数，实数部分为 x，虚数部分为 y。x 和 y 是数字表达式。
二 字符串类型（string）
1 什么是字符串数据类型
引号包含的都是字符串类型 S1='hello world' s="hello world" s2="""hello world""" s3='''hello world''' 单引双引没有区别
2 字符串的常用操作
strip()移除空白，也可以去除其他的字符 slipt()分割,默认以空格分割。也可以以其他的字符分割 center()居中显示例如：x='hello' print(x.center(30,'#')) ljust()左对齐 find()查找字符的索引位置，如果是负数，代表查找失败 index()索引 len()长度 切片：如print(x[1:3])也是顾头不顾尾 print(x[0:5:2])#0 2 4 swapcase()大小写字母翻转 join()连接 repalce()替换 endswith()以什么结尾 satrtswith()以什么开头 isdigit()判断是否是数字 islower()判断是否是全部小写 isupper()判断是否是全部大写 lower()全部转换为小写 upper()全部转换为大写 isspace()判断是否是全都是空格 istitle()判断是否是标题（首字母大写）
# string.capitalize() 把字符串的第一个字符大写 # string.center(width) 返回一个原字符串居中,并使用空格填充至长度 width 的新字符串 # string.count(str, beg=0, end=len(string)) 返回 str 在 string 里面出现的次数，如果 beg 或者 end 指定则返回指定范围内 str 出现的次数 # string.decode(encoding='UTF-8', errors='strict') 以 encoding 指定的编码格式解码 string，如果出错默认报一个 ValueError 的 异 常 ， 除 非 errors 指 定 的 是 'ignore' 或 者'replace' # string.encode(encoding='UTF-8', errors='strict') 以 encoding 指定的编码格式编码 string，如果出错默认报一个ValueError 的异常，除非 errors 指定的是'ignore'或者'replace' # string.endswith(obj, beg=0, end=len(string)) 检查字符串是否以 obj 结束，如果beg 或者 end 指定则检查指定的范围内是否以 obj 结束，如果是，返回 True,否则返回 False. # string.expandtabs(tabsize=8) 把字符串 string 中的 tab 符号转为空格，tab 符号默认的空格数是 8。 # string.find(str, beg=0, end=len(string)) 检测 str 是否包含在 string 中，如果 beg 和 end 指定范围，则检查是否包含在指定范围内，如果是返回开始的索引值，否则返回-1 # string.index(str, beg=0, end=len(string)) 跟find()方法一样，只不过如果str不在 string中会报一个异常. # string.isalnum() 如果 string 至少有一个字符并且所有字符都是字母或数字则返回 True,否则返回 False # string.isalpha() 如果 string 至少有一个字符并且所有字符都是字母则返回 True,否则返回 False # string.isdecimal() 如果 string 只包含十进制数字则返回 True 否则返回 False. # string.isdigit() 如果 string 只包含数字则返回 True 否则返回 False. # string.islower() 如果 string 中包含至少一个区分大小写的字符，并且所有这些(区分大小写的)字符都是小写，则返回 True，否则返回 False # string.isnumeric() 如果 string 中只包含数字字符，则返回 True，否则返回 False # string.isspace() 如果 string 中只包含空格，则返回 True，否则返回 False. # string.istitle() 如果 string 是标题化的(见 title())则返回 True，否则返回 False # string.isupper() 如果 string 中包含至少一个区分大小写的字符，并且所有这些(区分大小写的)字符都是大写，则返回 True，否则返回 False # string.join(seq) 以 string 作为分隔符，将 seq 中所有的元素(的字符串表示)合并为一个新的字符串 # string.ljust(width) 返回一个原字符串左对齐,并使用空格填充至长度 width 的新字符串 # string.lower() 转换 string 中所有大写字符为小写. # string.lstrip() 截掉 string 左边的空格 # string.maketrans(intab, outtab]) maketrans() 方法用于创建字符映射的转换表，对于接受两个参数的最简单的调用方式，第一个参数是字符串，表示需要转换的字符，第二个参数也是字符串表示转换的目标。 # max(str) 返回字符串 str 中最大的字母。 # min(str) 返回字符串 str 中最小的字母。 # string.partition(str) 有点像 find()和 split()的结合体,从 str 出现的第一个位置起,把 字 符 串 string 分 成 一 个 3 元 素 的 元 组 (string_pre_str,str,string_post_str),如果 string 中不包含str 则 string_pre_str == string. # string.replace(str1, str2, num=string.count(str1)) 把 string 中的 str1 替换成 str2,如果 num 指定，则替换不超过 num 次. # string.rfind(str, beg=0,end=len(string) ) 类似于 find()函数，不过是从右边开始查找. # string.rindex( str, beg=0,end=len(string)) 类似于 index()，不过是从右边开始. # string.rjust(width) 返回一个原字符串右对齐,并使用空格填充至长度 width 的新字符串 # string.rpartition(str) 类似于 partition()函数,不过是从右边开始查找. # string.rstrip() 删除 string 字符串末尾的空格. # string.split(str="", num=string.count(str)) 以 str 为分隔符切片 string，如果 num有指定值，则仅分隔 num 个子字符串 # string.splitlines(num=string.count('\n')) 按照行分隔，返回一个包含各行作为元素的列表，如果 num 指定则仅切片 num 个行. # string.startswith(obj, beg=0,end=len(string)) 检查字符串是否是以 obj 开头，是则返回 True，否则返回 False。如果beg 和 end 指定值，则在指定范围内检查. # string.strip([obj]) 在 string 上执行 lstrip()和 rstrip() # string.swapcase() 翻转 string 中的大小写 # string.title() 返回"标题化"的 string,就是说所有单词都是以大写开始，其余字母均为小写(见 istitle()) # string.translate(str, del="") 根据 str 给出的表(包含 256 个字符)转换 string 的字符,要过滤掉的字符放到 del 参数中 # string.upper() 转换 string 中的小写字母为大写
# 1 * 重复输出字符串 print('hello'*2) #2[] ,[:] 通过索引获取字符串中字符,这里和列表的切片操作是相同的,具体内容见列表 print('helloworld'[2:]) # 3 in 成员运算符 - 如果字符串中包含给定的字符返回 True print('el' in 'hello') # 4 % 格式字符串 print('alex is a good teacher') print('%s is a good teacher'%'alex')
//msg='name:{},age:{},sex:{}'
//print(msg.format('haiyan',18,"女"))
//msg='name:{0},age:{1},sex:{0}'
//print(msg.format('aaaaaa','bbbbbb'))
//msg='name:{x},age:{y},sex:{z}'
//msg.format(x='haiyan',y='18',z='女')
# 5 + 字符串拼接 a='123' b='abc' c='789' d1=a+b+c print(d1) # +效率低,该用join d2=''.join([a,b,c]) print(d2)
3 字符串格式化
1.%s,%d 举例1：name='egon' age=20 print("my name is %s my age is %s" %(name,age))#%s既能接受字符串，也能接受数字 print(‘my name is %s my age is %d’ %(name,age))#%d只能接受数字
while True: name=input("name:") age=input("age:") sex=input("sex:") height=input("height:") msg=''' ------------%s info----------- name:%s age:%s sex:%s height:%s ------------------------------t '''%(name,name,age,sex,height) print(msg)
4 字符串常用操拾遗
while True: name=input('user: ').strip() password=input('password: ').strip() if name == 'egon' and password == '123': print('login successfull')
while True: cmd=input('>>: ').strip() if len(cmd) == 0:continue cmd_l=cmd.split() print('命令是:%s 命令的参数是:%s' %(cmd_l[0],cmd_l[1]))
oldboy_age=84 while True: age=input('>>: ').strip() if len(age) == 0: continue if age.isdigit(): age=int(age) else: print('must be int')
name='alex_SB' print(name.endswith('SB')) print(name.startswith('alex'))
name='alex say :i have one tesla,my name is alex' print(name.replace('alex','SB')) print('my name is %s my age is %s my sex is %s' %('egon',18,'male')) print('my name is {} my age is {} my sex is {}'.format('egon',18,'male')) print('my name is {0} my age is {1} my sex is {0}:{2}'.format('egon',18,'male')) print('my name is {name} my age is {age} my sex is {sex}'.format( sex='male', age=18, name='egon'))
name='goee say hello' print(name.find('o')) #顾头不顾尾,找不到则返回-1不会报错,找到了则显示索引 print(name.index("s")) #同上,但是找不到会报错 print(name.count('o')) #查找字符串出现的次数
info='root:x:0:0::/root:/bin/bash' print(info.split(':')) l=['root', 'x', '0', '0', '', '/root', '/bin/bash'] print(':'.join(l))
expandtabs name='egon\thetllo' print(name) print(name.expandtabs(1)) name='egon' print(name.center(30,'-')) print(name.ljust(30,'*')) print(name.rjust(30,'*')) print(name.zfill(50)) #用0填充 #captalize,swapcase,title # name='eGon' # print(name.capitalize()) #首字母大写,其余部分小写 # print(name.swapcase()) #大小写翻转 # msg='egon say hi' # print(msg.title()) #每个单词的首字母大写
#在python3中 num0='4' num1=b'4' #bytes num2=u'4' #unicode,python3中无需加u就是unicode num3='四' #中文数字 num4='Ⅳ' #罗马数字
三 List(列表)
n1=[11,22,33,44,55] n2=n1 n3=n1[:] n1[0]=666 n3[1]=999 print n1 n2 n3 //[666,22,33,44,55] [666,22,33,44,55],[11,999,33,44,55] //n1 n2 指向一块内存地址 //n3因为是切片自己 开辟了一块内存地址
1.增（append，insert）
insert 方法用于将对象插入到列表中，而append方法则用于在列表末尾追加新的对象
names_class2=['张三','李四','王五','赵六']
names_class2.append('alex') names_class2.insert(2,'alvin')
2 .删（remove，del，pop）
names_class2=['张三','李四','王五','赵六'] names_class2.remove('张三') del names_class2[0] print(names_class2.pop())//注意,pop是有一个返回值的
3 改（重新赋值）
names_class2 = ['张三', '李四', '王五', '赵六'] names_class2[3] = '赵七' names_class2[0:2] = ['wusir', 'alvin'] print(names_class2)
4 查（切片查找）
l = ['a', 'b', 'c', 'd', 'e', 'f'] print(l[1:5]) print(l[1:5:2]) print(l[2:5]) print(l[3:0:-1])//d c b 正数为空 print(l[-1:-4]) //空 print(l[-4:]) l=['a','b','c','d','e','f'] print(l[-2:])
5 基本用法
hobbies=['play','eat','sleep','study','eat','eat'] hobbies.clear() print(hobbies) l=hobbies.copy() print(l) l=[1,2,3,4,5] l.reverse() print(l) l=[100,9,-2,11,32] l.sort(reverse=False) print(l)
5.1 count
count 方法统计某个元素在列表中出现的次数：
>>> ['to', 'be', 'or', 'not', 'to', 'be'].count('to') 2 >>> x = [[1,2], 1, 1, [2, 1, [1, 2]]] >>> x.count(1) 2 >>> x.count([1,2]) 1
5.2 extend
extend 方法可以在列表的末尾一次性追加另一个序列中的多个值。
extend 方法修改了被扩展的列表，而原始的连接操作（+）则不然，它会返回一个全新的列表。
>>> a = [1, 2, 3] >>> b = [4, 5, 6] >>> a.extend(b) >>> a [1, 2, 3, 4, 5, 6] >>> >>> a + b [1, 2, 3, 4, 5, 6, 4, 5, 6] >>> a [1, 2, 3, 4, 5, 6]
5.3 index
index 方法用于从列表中找出某个值第一个匹配项的索引位置：
names_class2.index('李四')
5.4 reverse
reverse 方法将列表中的元素反向存放。
names_class2.reverse()
print(names_class2)
5.5 sort
sort 方法用于在原位置对列表进行排序。
x = [4, 6, 2, 1, 7, 9] x.sort()#x.sort(reverse=True)
5.6 深浅拷贝
四 tuple（元组）
元组被称为只读列表，即数据可以被查询，但不能被修改，所以，列表的切片操作同样适用于元组。
元组写在小括号(())里，元素之间用逗号隔开。
虽然tuple的元素不可改变，但它可以包含可变的对象，比如list列表。
构造包含 0 个或 1 个元素的元组比较特殊，所以有一些额外的语法规则：
tup1 = () // 空元组 tup2 = (20,) //一个元素，需要在元素后添加逗号
作用：
1 对于一些数据我们不想被修改，可以使用元组；
2 另外，元组的意义还在于，元组可以在映射（和集合的成员）中当作键使用——而列表则不行；元组作为很多内建函数和方法的返回值存在。
元组可以作为字典的key d={(1,2,3):'egon'} //print(d,type(d),d[(1,2,3)]) 切片 goods=('iphone','lenovo','sanxing','suoyi') print(goods[1:3]) 掌握 goods=('iphone','lenovo','sanxing','suoyi') print(goods.index('iphone')) print(goods.count('iphone')) 补充：元组本身是不可变的，但是内部的元素可以是可变类型 t=(1,['a','b'],'sss',(1,2)) t[1][0]='2' print(t)
五. Dictionary（字典）
字典是python中唯一的映射类型，采用键值对（key-value）的形式存储数据。python对key进行哈希函数运算，根据计算的结果决定value的存储地址，所以字典是无序存储的，且key必须是可哈希的。可哈希表示key必须是不可变类型，如：数字、字符串、元组。
字典(dictionary)是除列表意外python之中最灵活的内置数据结构类型。列表是有序的对象结合，字典是无序的对象集合。两者之间的区别在于：字典当中的元素是通过键来存取的，而不是通过偏移存取。
创建字典
dic1={'name':'alex','age':36,'sex':'male'}
dic2=dict((('name','alex'),))
1 增
dic3 = {} dic3['name'] = 'alex' dic3['age'] = 18 print(dic3) # {'name': 'alex', 'age': 18} a = dic3.setdefault('name', 'yuan') b = dic3.setdefault('ages', 22) print(a, b) print(dic3)
2 查
dic3 = {'name': 'alex', 'age': 18}
print(dic3['name'])
print(dic3.get('age',False))//18
print(dic3.items())//dict_items([('name', 'alex'), ('age', 18)])
print(dic3.keys())
print(dic3.values())
print('name' in dic3) # py2: dic3.has_key('name')
print(list(dic3.items()))//[('name', 'alex'), ('age', 18)]
print(list(dic3.keys()))//['name', 'age']
print(list(dic3.values()))//['alex', 18]
3 改
dic3 = {'name': 'alex', 'age': 18}
dic3['name'] = 'alvin'
dic4 = {'sex': 'male', 'hobby': 'girl', 'age': 36} //age值会覆盖之前的
dic3.update(dic4)
print(dic3)//{'name': 'alvin', 'age': 36, 'sex': 'male', 'hobby': 'girl'}
4 删
dic4 = {'name': 'alex', 'age': 18, 'class': 1}
dic4.clear()//清空字典
print(dic4)//{}
del dic4['name'] //删除name
print(dic4)
a = dic4.popitem()//方法随机返回并删除字典中的一对键和值
print(a, dic4)//('class', 1) {'name': 'alex', 'age': 18}
print(dic4.pop('age'))//删除字典给定键 key 及对应的值，返回值为被删除的值。key值必须给出。
print(dic4)//{'name': 'alex', 'class': 1}
5 其他操作以及涉及到的方法
5.1 dict.fromkeys
d1 = dict.fromkeys(['host1', 'host2', 'host3'], 'Mac') print(d1) //{'host1': 'Mac', 'host2': 'Mac', 'host3': 'Mac'} d1['host1'] = 'xiaomi' print(d1) //{'host1': 'xiaomi', 'host2': 'Mac', 'host3': 'Mac'} d2 = dict.fromkeys(['host1', 'host2', 'host3'], ['Mac', 'huawei']) print(d2)//{'host1': ['Mac', 'huawei'], 'host2': ['Mac', 'huawei'], 'host3': ['Mac', 'huawei']} d2['host1'][1] = 'xiaomi' print(d2)//{'host1': ['Mac', 'xiaomi'], 'host2': ['Mac', 'xiaomi'], 'host3': ['Mac', 'xiaomi']}
5.2 d.copy() 对字典 d 进行浅复制，返回一个和d有相同键值对的新字典
5.3 字典嵌套
av_catalog = { "欧美":{ "www.youporn.com": ["很多免费的,世界最大的","质量一般"], "www.pornhub.com": ["很多免费的,也很大","质量比yourporn高点"], "letmedothistoyou.com": ["多是自拍,高质量图片很多","资源不多,更新慢"], "x-art.com":["质量很高,真的很高","全部收费,屌比请绕过"] }, "日韩":{ "tokyo-hot":["质量怎样不清楚,个人已经不喜欢日韩范了","听说是收费的"] }, "大陆":{ "1024":["全部免费,真好,好人一生平安","服务器在国外,慢"] } } av_catalog["大陆"]["1024"][1] += ",可以用爬虫爬下来" print(av_catalog["大陆"]["1024"]) #ouput ['全部免费,真好,好人一生平安', '服务器在国外,慢,可以用爬虫爬下来']
5.4 sorted(dict) : 返回一个有序的包含字典所有key的列表
dic={5:'555',2:'222',4:'444'}
print(sorted(dic))//[2, 4, 5]
5.5 遍历字典
dic5 = {'name': 'alex', 'age': 18}
for i in dic5:
print(i, dic5[i])
for items in dic5.items():
print(items)//('name', 'alex') ('age', 18)
for keys, values in dic5.items():
print(keys, values)//name alex age 18
字典存取学生信息
dic={'zhangsan':{'age':23,'sex':'male'},
'李四':{'age':33,'sex':'male'},
'wangwu':{'age':27,'sex':'women'}
}
5.6 get
info_dic={'name':'egon','age':18,'sex':'male'}
print(info_dic['name11111111'])#找不到则报错了
print(info_dic.get('name',None))
print(info_dic.get('name222222',None))#get方法找不到不报错，可以自己设定默认值
5.7 长度
info_dic={'name':'egon','age':18,'sex':'male'}
print(len(info_dic))
5.8 in
info_dic={'name':'egon','age':18,'sex':'male'}
print('name' in info_dic)
print('name' in info_dic.keys())
print('egon' in info_dic.values())
print(('name','egon') in info_dic.items())
5.9 增 拾遗
info_dic={'name':'egon','age':18,'sex':'male'}
info_dic.update({'a':1,'name':'Egon'})
print(info_dic)
info_dic['hobbies']=[]
info_dic['hobbies'].append('study')
info_dic['hobbies'].append('read')
print(info_dic)
//{'name': 'Egon', 'age': 18, 'sex': 'male', 'a': 1}
//{'name': 'Egon', 'age': 18, 'sex': 'male', 'a': 1, 'hobbies': ['study', 'read']}
setdefault:key不存在则设置默认值，并且放回值默认值 key存在则不设置默认，并且返回已经有的值 info_dic={'name':'egon','age':18,'sex':'male'} info_dic.setdefault('hobbies',[1,2]) print(info_dic) info_dic.setdefault('hobbies',[1,2,3,4,5]) print(info_dic)
info_dic={'name':'egon','age':18,'sex':'male','hobbies':['study','read']}
info_dic.setdefault('hobbies',[]).append('read')
print(info_dic)
info_dic={'name':'egon','age':18,'sex':'male','hobbies':['study','read','sleep']}
info_dic.setdefault('hobbies',[]).append('sleep')
print(info_dic)
l=info_dic.setdefault('hobbies',[])
print(l,id(l))
print(id(info_dic['hobbies']))
info=dict(name='haiyan',age=18,sex='male') print(info)//{'name': 'haiyan', 'age': 18, 'sex': 'male'} info=dict([('name','haiyan'),('age',18)]) print(info)//{'name': 'haiyan', 'age': 18}
六集合(set)
集合是一个无序的，不重复的数据组合，它的主要作用如下：
- 去重，把一个列表变成集合，就自动去重了
- 关系测试，测试两组数据之前的交集、差集、并集等关系
集合(set)：把不同的元素组成一起形成集合，是python基本的数据类型。
集合元素(set elements):组成集合的成员(不可重复)
li2=[1,2,1,'a','a'] s=set(li2) print(s) #{1, 2, 'a'}
集合对象是一组无序排列的可哈希的值：集合成员可以做字典的键
1、创建集合
由于集合没有自己的语法格式，只能通过集合的工厂方法set()和frozenset()创建
s1 = set('alvin') s2= frozenset('yuan') print(s1,type(s1)) #{'l', 'v', 'i', 'a', 'n'} <class 'set'>//只可以添加不可变数据类型 print(s2,type(s2)) #frozenset({'n', 'y', 'a', 'u'}) <class 'frozenset'>//不可变
2、访问集合
由于集合本身是无序的，所以不能为集合创建索引或切片操作，只能循环遍历或使用in、not in来访问或判断集合元素。
s1 = set('alvin') print('a' in s1)Ture print('b' in s1)F
for i in s1：
print(i)
3、更新集合
可使用以下内建方法来更新：
s.add()
s.update()
s.remove()
注意只有可变集合才能更新：
s1 = frozenset('alvin') s1.add(0) #报错 s2 =set('alvin') s2.add('mm') print(s2) # {'mm', 'l', 'n', 'a', 'i', 'v'} s2.update('HO' ) # 添加多个元素 print(s2) # {'mm', 'l', 'n', 'a', 'i', 'H', 'O', 'v'} s2.remove('l') print(s2) # {'mm', 'n', 'a', 'i', 'H', 'O', 'v'}
del：删除集合本身
四、集合类型操作符
1 in ,not in
2 集合等价与不等价(==, !=)
3 子集、超集
s=set('alvinyuan') s1=set('alvin') print('v' in s) T print(s1<s) T
4 联合(|)
联合(union)操作与集合的or操作其实等价的，联合符号有个等价的方法，union()。
s1=set('alvin') s2=set('yuan') s3=s1|s2 print(s3) #{'a', 'l', 'i', 'n', 'y', 'v', 'u'} print(s1.union(s2)) #{'a', 'l', 'i', 'n', 'y', 'v', 'u'} //联合 相同覆盖
5、交集(&)
与集合and等价，交集符号的等价方法是intersection() //属于s1又属于s2的
s1 = set('alvin') s2 = set('yuan') s3 = s1 & s2 print(s3) # {'n', 'a'} print(s1.intersection(s2)) # {'n', 'a'}
6、查集(-)
等价方法是difference() 属于s1 不属于 s2
s1 = set('alvin') s2 = set('yuan') s3 = s1 - s2 print(s3) # {'v', 'i', 'l'} print(s1.difference(s2)) # {'v', 'i', 'l'}
7、对称差集(^)
对称差分是集合的XOR(‘异或’)，取得的元素属于s1,s2但不同时属于s1和s2.其等价方法symmetric_difference()
s1=set('alvin') s2=set('yuan') s3=s1^s2 print(s3) #{'l', 'v', 'y', 'u', 'i'} print(s1.symmetric_difference(s2)) #{'l', 'v', 'y', 'u', 'i'}
应用
'''最简单的去重方式''' lis = [1,2,3,4,1,2,3,4] print list(set(lis)) #[1, 2, 3, 4]
linuxs={'six','wu','dabao'}
linuxs.add('xiaoxiao')#说明set类型的集合是可变类型
linuxs.add([1,2,3])#报错，只能添加不可变类型
linuxs={'six','wu','dabao'}
res=linuxs.pop() //不用指定参数,随机删除,并且会有返回值
res=linuxs.remove('dabao')//指定元素删除，元素不存在则报错，单纯的删除，没有返回值，
res=linuxs.discard('wu') //指定元素删除，元素不存在不报错，单纯的删除，没有返回值
浙公网安备 33010602011771号