一、数字类型：int与float类型
# 1、操作：
# 比较运算:int与float之间是可以比较大小
# 数学运算：+-*/,int与float之间也可以进行数学运算
print(10 > 3.1) #True
print(10 * 3.1) #31
#str、list比较运算返回bool值
print('x' > 'y') #False 字符串间比较大小是比较第一个字符的ASCII码
print([1,2,3] > [4,5]) #False
print([1,2,3] > 10) #error:'>' not supported between instances of 'list' and 'int'
进制转换：
print(bin(55)) #转成二进制 0b110111
print(oct(11)) #转成八进制 0o13
print(hex(55)) #转成十六进制 0x37
print(int("0b110111",2)) #转换成十进制，必须加引号，后加进制数
print(int("0o13",8)) #转换成十进制，必须加引号，后加进制数
print(int("0x37",16)) #转换成十进制，必须加引号，后加进制数
二、字符串类型
1、字符串的直接操作：
# 1、按索引取值(正向取+反向取) ：只能取
name='egon'
print(name[0])
print(name[-1])
#name[0]='E' # 错误，字符串只能按照索引取值
# 列表可以修改指定位置的值
l=['aaa','bbb','ccc']
l[0]='AAA'
print(l)
# 2、切片(顾头不顾尾，步长):从一个大的字符串中copy出来了一个子字符串，原字符串不变
msg='hello egon'
print(msg[1:4])
print(msg)
#print(msg[0:5:-1]) #错误！ 运行结果为空，从0起始到5，反向步长，所以为空
print(msg[0:50]) #实际上还是打印整个字符串，底层机制应该是从0—49依次判断，直至字符串终止
msg = 'hello egon'
# 把原字符串完成拷贝一遍
print(msg[0:10])
print(msg[0:len(msg)])
print(msg[0:])
print(msg[:])
# 隔一个取
msg='hello egon'
print(msg[0:10:2]) # 0 2 4 6 8
#h l o e o
print(msg[::2]) # 0 2 4 6 8
# 3、长度len
msg='hello egon'
print(len(msg))
name=input('情输入你的用户名：') # name=''
if not name:# 当用户输入的内容为空的时候，条件成立
print('用户输入的内容为空')
else:
print('用户输入的内容不为空')
if len(name) == 0:
print('用户输入的内容为空')
else:
print('用户输入的内容不为空')
# 4、成员运算in和not in:判断一个子字符串是否存在于一个大字符串
res='egon' in 'egon is dsb'
print(res)
2、字符串类型的常用函数操作：
#1、strip,lstrip,rstrip 形式：str.strip(str)
#2、lower,upper 形式：str.lower（） str.upper()
#3、startswith,endswith 形式：str.startswith(str)
#4、format 形式：print("xxxx{}{}{}".fomat(n1,n2,n2)) n为变量
#5、cout函数 形式：str.cout(str, start=0, end=len(str))
#6、split,rsplit函数 形式：str.split(str)
#7、join函数 形式：str="-" seq=(str1, str2, str3) str.join(str)
#8、replace 形式：str.replace(oldstr, newstr, max times)
#9、isdigit 形式：str.isdigit
#1、strip,lstrip,rstrip
x = " 0011 "
print(x.strip())
print(x.lstrip())
print(x.rstrip())
print(x.strip(' 0')) #不用逗号隔开，只用一个字符串包含所有需要删除的字符
#2、lower,upper
#lower,upper
name='EGON'
print(name.lower()) #将字符串改为小写
print(name.upper()) #将字符串改为大写
#3、startswith,endswith
name='alex_SB'
print(name.endswith('SB')) #判断是否以SB结尾
print(name.startswith('alex')) #判断是否以alex开头
#4、format的三种玩法
#format():把传统的%替换为{}来实现格式化输出
#其实就是format()后面的内容，填入大括号中（可以按位置，或者按变量）
res='个人资料：{} {} {}'.format('egon',18,'male') #按顺序填入
print(res)
#这里注意有两层大括号，输出的结果只有一层大括号
print('数字{{{1}{2}}}和{0}'.format("123",456,'789'))
res='个人资料：{1} {0} {2}'.format('egon',18,'male') #按括号中元素编号索引，0代表第一个数据元素，1代表第二个
print(res)
res='个人资料：{name} {age} {sex}'.format(sex='male',name='egon',age=18) #按变量填入
print(res)
#5、cout函数
'''
count()方法语法：
str.count(sub, start= 0,end=len(string))
Python count() 方法用于统计字符串里某个字符出现的次数。可选参数为在字符串搜索的开始与结束位置。
sub -- 搜索的子字符串
start -- 字符串开始搜索的位置。默认为第一个字符,第一个字符索引值为0。
end -- 字符串中结束搜索的位置。字符中第一个字符的索引为 0。默认为字符串的最后一个位置。
'''
name= "key: :jj:dic"
print(name.count(":",0,6)) #1个冒号，从第一个字符到第六个字符（5号字符）
#6、split,rsplit函数
'''
str.split(str="", num=string.count(str)).
str -- 分隔符，默认为所有的空字符，包括空格、换行(
)、制表符( )等。
num -- 分割次数。默认为 -1, 即分隔所有。
'''
name= "key: :jj:dic"
print(name.split(":")) #结果为['key', '', 'jj', 'dic']，以冒号为分隔符，分隔全部，建立列表
print(name.split()) #默认分隔符为空格
name='C:/a/b/c/d.txt' #只想拿到顶级目录
print(name.split('/',1)) #运行结果['C:', 'a/b/c/d.txt']
print(name.split('/',2)) #运行结果['C:', 'a', 'b/c/d.txt']
print(name.split('/',-1)) #-1代表分隔所有
#7、join函数
# Python join() 方法用于将序列中的元素以指定的字符连接生成一个新的字符串。
# 参数：sequence -- 要连接的元素序列
tag=' '
print(tag.join(['egon','say','hello','world'])) #可迭代对象必须都是字符串
#运行结果egon say hello world，以' '分隔
str = "-"
seq = ("a", "b", "c") # 字符串序列
print(str.join(seq))
#运行结果a-b-c，以"-"分隔
#print(tag.join('egon','say','hello','world')) #错误，.join()中的变量应该是列表类型
print(tag) #tag没变，.join还是创建了一个新的变量副本
#8、replace
'''
描述
Python replace() 方法把字符串中的 old（旧字符串） 替换成 new(新字符串)
如果指定第三个参数max，则替换不超过 max 次。
语法
replace()方法语法：
str.replace(old, new, max)
参数
old -- 将被替换的子字符串。
new -- 新字符串，用于替换old子字符串。
max -- 可选字符串, 替换不超过 max 次
'''
name='alex say :i have one tesla,my name is alex'
print(name.replace('alex','SB',1)) #"alex"被替换的子字符串，"SB"新字符串，用于替换old字符串，1最大替换次数
#9、isdigit
#isdigit：可以判断bytes和unicode类型,是最常用的用于于判断字符是否为"数字"的方法
age=input('>>: ')
print(age.isdigit())
逻辑运算符补充（短路运算）：https://www.cnblogs.com/zhubincheng/p/12341470.html
3、字符串类型需了解的操作：
#1、find,rfind,index,rindex,count
name='egon say hello'
print(name.find('n',1,4)) #顾头不顾尾,找不到则返回-1不会报错,找到了则显示索引
# 即返回其位置，如上则返回3
# print(name.index('e',2,4)) #同上,但是找不到会报错
print(name.count('e',1,3)) #顾头不顾尾,如果不指定范围则查找所有
#2、center,ljust,rjust,zfill
name='egon'
print(name.center(30,'-')) # center()返回一个原字符串居中,并使用空格填充至长度 width 的新字符串。默认填充字符为空格。
# str.center(width, fillchar) 参数：width -- 字符串的总宽度。 fillchar -- 填充字符。
print(name.ljust(30,'*')) # ljust() 方法返回一个原字符串左对齐,并使用空格填充至指定长度的新字符串。如果指定的长度小于原字符串的长度则返回原字符串。
#str.ljust(width, fillchar) 参数：width -- 指定字符串长度。 fillchar -- 填充字符，默认为空格。
print(name.rjust(30,'*'))
print(name.zfill(50)) # zfill() 方法返回指定长度的字符串，原字符串右对齐，前面填充0。
#str.zfill(width) 参数：width -- 指定字符串的长度。原字符串右对齐，前面填充0。
#3、expandtabs
name='egon hello'
print(name)
print(name.expandtabs(1)) #Python expandtabs() 方法把字符串中的 tab 符号(' ')转为空格，tab 符号(' ')默认的空格数是 8。
#4、captalize,swapcase,title
print(name.capitalize()) #首字母大写
print(name.swapcase()) #大小写翻转
msg='egon say hi'
print(msg.title()) #每个单词的首字母大写
#5、is数字系列
#在python3中
num1=b'4' #bytes
num2=u'4' #unicode,python3中无需加u就是unicode
num3='四' #中文数字
num4='Ⅳ' #罗马数字
#isdigt:bytes,unicode
print(num1.isdigit()) #True
print(num2.isdigit()) #True
print(num3.isdigit()) #False
print(num4.isdigit()) #False
#isdecimal:uncicode
#bytes类型无isdecimal方法
print(num2.isdecimal()) #True
print(num3.isdecimal()) #False
print(num4.isdecimal()) #False
#isnumberic:unicode,中文数字,罗马数字
#bytes类型无isnumberic方法
#print(num1.isnumeric()) # AttributeError: 'bytes' object has no attribute 'isnumeric'
print(num2.isnumeric()) #True
print(num3.isnumeric()) #True
print(num4.isnumeric()) #True
#三者不能判断浮点数
num5='4.3'
print(num5.isdigit())
print(num5.isdecimal())
print(num5.isnumeric())
'''
总结:
最常用的是isdigit,可以判断bytes和unicode类型,这也是最常见的数字应用场景
如果要判断中文数字或罗马数字,则需要用到isnumeric
'''
#is其他
print('===>')
name='egon123'
print(name.isalnum()) #字符串由字母或数字组成
print(name.isalpha()) #字符串只由字母组成
print(name.isidentifier()) #如果字符串是有效标识符，则 isidentifier() 方法返回 True，否则返回 False。
#如果字符串仅包含字母数字字母（a-z）和（0-9）或下划线（_），则该字符串被视为有效标识符。有效的标识符不能以数字开头或包含任何空格。
print(name.islower()) #Python islower() 方法检测字符串是否由小写字母组成。
print(name.isupper()) #Python islower() 方法检测字符串是否由大写字母组成。
print(name.isspace()) #Python isspace() 方法检测字符串是否只由空格组成。
print(name.istitle()) #Python istitle() 方法检测字符串中所有的单词拼写首字母是否为大写，且其他字母为小写。
三、列表类型
# 1、作用：按位置存放多个值
# 2、定义
l=[1,1.2,'a'] # 相当于l=list([1,1.2,'a'])
print(l) # 运行结果为：[1, 1.2, 'a']
print(type(l)) # 运行结果为：<class 'list'>
# 3、类型转换: 但凡能够被for循环遍历的类型都可以当做参数传给list()转成列表
res=list('hello')
print(res) # 运行结果为：['h', 'e', 'l', 'l', 'o']
res=list({'k1':111,'k2':222,'k3':3333})
print(res) # 运行结果为：['k1', 'k2', 'k3']
优先掌握的操作：
# 优先掌握的操作：
# 1、按索引存取值(正向存取+反向存取)：即可存也可以取
l = ['aaa', 'bbb', 'ccc']
l[-1]='CCC'
print(l)
# 2、切片(顾头不顾尾，步长)：从一个大列表中复制出一个子列表
l=['aaa','bbb','ccc','ddd','eee']
res=l[1:4]
print(res)
print(l)
# 3、长度
l=['aaa','bbb','ccc','ddd','eee']
print(len(l))
# not l #判断是否为空
# len(l) == 0
# 4、成员运算in和not in
l=['aaa','bbb','ccc','ddd','eee']
res='aaa' in l
print(res)
列表---增
# 5.1 追加 list.append(object) # 在列表最后追加对象 l=[111,'egon','hello'] l.append(3333) l.append(4444) print(l) # 运行结果：[111, 'egon', 'hello', 3333, 4444] # 5.2、插入值 list.insert(index,object) # 在索引位置前添加列表元素 l=[111,'egon','hello'] l.insert(0,'alex') # 在0号索引前添加元素"alex" print(l) # 运行结果：['alex', 111, 'egon', 'hello'] # 5.3、extend添加值 （在列表后添加可迭代对象的所有元素） new_l=[1,2,3] l=[111,'egon','hello'] l.append(new_l) # 运行结果：[111, 'egon', 'hello', [1, 2, 3]] print(l) # 代码实现（不使用extend） for item in new_l: l.append(item) print(l) # extend实现上述代码 l.extend(new_l) l.extend('abc') print(l) # 运行结果：[111, 'egon', 'hello', [1, 2, 3], 1, 2, 3, 'a', 'b', 'c']
列表---删
# 6、删除
# 方式一：通用的删除方法，只是单纯的删除、没有返回值
l = [111, 'egon', 'hello']
del l[1]
# x =del l[1] # 抛出异常，不支持赋值语法
print(l) # 运行结果：[111, 'hello']
# 方式二：l.pop()根据索引删除，会返回删除的值
l = [111, 'egon', 'hello']
l.pop() # 不指定索引默认删除最后一个
print(l) # 运行结果为：[111, 'egon']
res=l.pop(1) # list.pop()的返回值为egon，即删除的元素
print(l) # 运行结果为：[111]
print(res) # 运行结果为：egon
# 方式三：l.remove()根据元素删除，返回None
#注意：remove的删除，是从前往后寻找该元素，一旦找到便删除，即每次删除最靠前的元素。
l = [111, 'egon', [1,2,3],'hello']
l.remove([1,2,3])
print(l) # 运行结果为：[111, 'egon', 'hello']
res=l.remove('egon')
print(res) # 运行结果为：None
# 7、循环
l = ['aaa', 'bbb', 'ccc',[1,2,3]]
for item in l:
print(item)
#ps:反向步长
l=[1,2,3,4,5,6]
print(l[-2:0:-2]) # 结果为[5,3] 顾头不顾尾，如果写到0的话，index=0被舍弃
print(l[-2::-2]) # 结果为[5,3,1] 不填写参数，默认取到头
#正向步长
print(l[0:3:1]) #[1, 2, 3]
#反向步长
print(l[2::-1]) #[3, 2, 1]
#列表翻转
print(l[::-1]) #[6, 5, 4, 3, 2, 1]
#pps:for循环使用嵌套切片
#就是利用range()函数生成1-99的整数，然后从start_index=2（即3）开始以step=3取值，直到终点，再在新序列中取最后五个数。
for i in range(1,100)[2::3][-5::]:
print(i,end=" ") # 输出结果 87 90 93 96 99
列表--内置方法
需要掌握：
l = [1, 'aaa', 'bbb','aaa','aaa'] # 1、l.count() # 在列表中找元素的个数 print(l.count('aaa')) # 运行结果：3 # 2、l.index() # 在列表中找到该元素，并返回其索引位置（从左往右找到第一个） print(l.index('aaa')) # 运行结果：1 # print(l.index('aaaaaaaaa')) # 与字符串相同，找不到报错 # 3、l.clear() # 清空列表 l.clear() print(l) # 运行结果：[] # 4、l.reverse():不是排序，就是将列表倒过来 # list.reverse() 无返回值 l = [1, 'egon','alex','lxx'] print(l.reverse()) # 运行结果为： None print(l) # 运行结果为：['lxx', 'alex', 'egon', 1] # 5、l.sort(): 列表内元素必须是同种类型才可以排序 # 默认升序，若需降序则置reverse = True l=[11,-3,9,2,3.1] l.sort() # 默认从小到大排，称之为升序 l.sort(reverse=True) # 从大到小排，设置为降序 print(l) # 运行结果为：[11, 9, 3.1, 2, -3] # l=[11,'a',12] # l.sort() # 不同数据类型无法排序 l=['c','e','a'] l.sort() # 字符串按照ASCII码排序 print(l) # 运行结果为：['a', 'c', 'e'] # 了解：字符串可以比大小，按照对应的位置的字符依次pk # 字符串的大小是按照ASCI码表的先后顺序加以区别，表中排在后面的字符大于前面的 print('a'>'b') print('abz'>'abcdefg') # 运行结果为：True # 了解：列表也可以比大小,原理同字符串一样,但是对应位置的元素必须是同种类型 l1=[1,'abc','zaa'] l2=[1,'abc','zb'] print(l1 < l2) # 运行结果为：True
列表---队列与堆栈
# 1、队列：FIFO,先进先出
# l=[]
# # 入队操作
l.append('first')
l.append('second')
l.append('third')
#
# print(l)
# # 出队操作
print(l.pop(0))
print(l.pop(0))
print(l.pop(0))
# 2、堆栈：LIFO,后进先出
l=[]
# 入栈操作
l.append('first')
l.append('second')
l.append('third')
print(l)
# 出队操作
print(l.pop())
print(l.pop())
print(l.pop())
四、元组
元组就是"一个不可变的列表"
#1、作用：
按照索引/位置存放多个值，只用于读不用于改
#2、定义:
（）内用逗号分隔开多个任意类型的元素
# 2.1 定义方法：
t=(1,1.3,'aa') # 相当于t=tuple((1,1.3,'aa'))
print(t,type(t)) # 运行结果为：(1, 1.3, 'aa') <class 'tuple'>
x=(10) # 单独一个括号代表包含的意思
print(x,type(x)) # 运行结果为：10 <class 'int'>
t=(10,) # 如果元组中只有一个元素，必须加逗号
print(t,type(t)) # 运行结果为：(10,) <class 'tuple'>
# 2.2 元组中保存的地址不可改：
t=(1,1.3,'aa') # t=(0->值1的内存地址,1->值1.3的内存地址,2->值'aaa'的内存地址，)
#t[0]=11111 #这行代码错误，元组类型中保存的地址都不可更改
#当元组类型中嵌套可变数据类型时
t=(1,[11,22]) # t=(0->值1的内存地址,1->值[1,2]的内存地址，)
print(id(t[0]),id(t[1])) # 18行
# # t[0]=111111111 # 不能改
# # t[1]=222222222 # 不能改
t[1][0]=11111111111111111 # 可变数据类型中的值可作修改，因为此时元组中保存的地址未发生变化
print(t) # 运行结果为：(1, [11111111111111111, 22])
print(id(t[0]),id(t[1])) # 与18行代码的地址打印相同
#2.3 节省内存：
import sys # 导入sys模块，使用sys.getsizeof() 查看在内存中所占字节数
a = (11,[15,17])
b = [11,[15,17]]
# 元组相较于列表的存储更精简空间
print(a,sys.getsizeof(a)) # 运行结果为：(11, [15, 17]) 56
print(b,sys.getsizeof(b)) # 运行结果为：[11, [15, 17]] 72
#3、类型转换
#与list一样，可迭代对象都能转换成元组tuple
print(tuple('hello')) # 运行结果为：('h', 'e', 'l', 'l', 'o')
print(tuple([1,2,3])) # 运行结果为：(1, 2, 3)
print(tuple({'a1':111,'a2':333})) # 运行结果为：('a1', 'a2')
元组---内置方法
#优先掌握的操作：
#1、按索引取值(正向取+反向取)：只能取
t=('aa','bbb','cc')
print(t[0])
print(t[-1])
#2、切片(顾头不顾尾，步长)
t=('aa','bbb','cc','dd','eee')
print(t[0:3])
print(t[::-1])
#3、长度
t=('aa','bbb','cc','dd','eee')
print(len(t))
#4、成员运算in和not in
print('aa' in t)
#5、循环
for x in t:
print(x)
#6、index、count
t=(2,3,111,111,111,111)
print(t.index(111)) # 运行结果为：2 即在2号索引位置找到111
# print(t.index(1111111111)) # 不存在的元素将报错
五、字典
造字典五法
#1、作用
#2、定义：{}内用逗号分隔开多个key：value，其中value可以使任意类型，但是
# key必须是不可变类型,且不能重复
# 造字典的方式一：
d={'k1':111,(1,2,3):222} # d=dict(...)
print(d['k1'])
print(d[(1,2,3)])
print(type(d)) # <class 'dict'>
d={} # 默认定义出来的是空字典
print(d,type(d)) # {} <class 'dict'>
# 造字典的方式二：
d=dict(x=1,y=2,z=3)
print(d,type(d)) # {'x': 1, 'y': 2, 'z': 3} <class 'dict'>
#3、数据类型转换（造字典的方法三）
info=[
['name','egon'],
('age',18),
['gender','male']
]
'''
d={}
for k,v in info: # 实质上就是一个解压操作：k,v=['name','egon']
d[k]=v
print(d)
'''
# 造字典的方式三：
# dict(iterable)
# 实质上是对可迭代对象中元素依次进行解压操作，所以可迭代对象中的元素必须都包含两个子元素，不然将无法解压。
# 相当于 key,value = [x1,x2]/"x1x2"/...依次迭代
res=dict(info) # 一行代码搞定上述for循环的工作
print(res) #{'name': 'egon', 'age': 18, 'gender': 'male'}
# 造字典的方式四:快速初始化一个字典
keys=['name','age','gender']
'''
d={}
for k in keys:
d[k]=None
print(d)
'''
# dict.fromkeys(iterable,value) 即需传参，可迭代对象与值
d={}.fromkeys(keys,None) # 一行代码搞定上述for循环的工作
# 此处初始化列表，一般用None或不可变类型，
# 若使用可变类型，则所有的key中的value都指向该可变类型，一变都变。
print(d) #{'name': None, 'age': None, 'gender': None}
# 造字典的方式五：for语句
{v: k for k, v in obj_dict.items()}
obj.__dict__={'_%s__%s' %(StanfordTeacher.__name__,k):v for k,v in obj.__dict__.items()} # 可以如此操作将对象的字典属性改为隐藏属性
字典---优先掌握操作
#1、按key存取值：可存可取
d={'k1':111}
# 针对赋值操作：key存在，则修改
d['k1']=222
# 针对赋值操作：key不存在，则创建新值
d['k2']=3333
print(d) # {'k1': 222, 'k2': 3333}
#2、长度len
d={'k1':111,'k2':2222,'k1':3333,'k1':4444}
print(d) # 重复key，默认只取最后一个
print(len(d)) # 长度依然为2
#3、成员运算in和not in:根据key
d={'k1':111,'k2':2222} # 只判断key是否在dict中
print('k1' in d) # True
print(111 in d) # False
#4、删除
d={'k1':111,'k2':2222}
# 4.1 通用删除 del
del d['k1'] # 不可赋值给别的变量
print(d) # {'k2': 2222}
d={'k1':111,'k2':2222}
# 4.2 pop删除：根据key删除元素，返回删除key对应的那个value值
res=d.pop('k2') # 返回2222
print(d) # {'k1': 111}
print(res) # 2222
d={'k1':111,'k2':2222}
# 4.3 popitem删除：随机删除，返回元组(删除的key,删除的value)
# dict.popitem() 不可传参，只能随机删除
res=d.popitem() # 返回元组（删除的key,删除的value）
print(d) # {'k1': 111}
print(res) # ('k2', 2222)
#5、键keys()，值values()，键值对items() =>在python3中得到的是老母鸡
d={'k1':111,'k2':2222}
'''
在python2中
>>> d={'k1':111,'k2':2222}
>>>
>>> d.keys()
['k2', 'k1']
>>> d.values()
[2222, 111]
>>> d.items()
[('k2', 2222), ('k1', 111)]
>>> dict(d.items())
{'k2': 2222, 'k1': 111}
>>>
'''
# 在python3中更节省空间
#6、for循环
for k in d.keys():
print(k) # 输出 key
for k in d:
print(k) # 输出 key
for v in d.values():
print(v) # 输出 value
for k in d.items(): # 输出元组（key,value），可改写k,v in d.items()进行解压
print(k) # 输出 (key,value)
'''
在python3中如python2输出：
print(list(d.keys()))
print(list(d.values()))
print(list(d.items()))
'''
字典---内置方法
#需要掌握的内置方法
d={'k1':111}
#1、d.clear()
# 清空字典
#2、d.update()
# 传入另一个字典来更新原有字典。
# 原字典若有重复的key，以传入的列表中key对应的value更新。
# 原字典若无传入列表的key，则以传入列表为准补充
d.update({'k2':222,'k3':333,'k1':111111111111111})
print(d) # {'k1': 111111111111111, 'k2': 222, 'k3': 333}
#3、d.get() ：根据key取值，容错性好
d={'k1':111}
#print(d['k2']) # key不存在则报错
print(d.get('k1')) # 111
print(d.get('k2')) # key不存在不报错，返回None
print(d.get(“k2”,"不存在该值")) # 不存在该值 如果在get(key,“”)中，key后追加值，就可返回该值而不再是None
#4、d.setdefault()
info={}
if 'name' in info:
... # 等同于pass
pass # 占位语句，不做任何事
else:
info['name']='egon'
print(info) # {'name': 'egon'}
# 4.1 如果key有则不添加,返回字典中key对应的值
info={'name':'egon'}
res=info.setdefault('name','jil')
print(info) # {'name': 'egon'}
print(res) # egon 此处还是返回字典中key对应的值
print(res)
# 4.2 如果key没有则添加，返回字典中key对应的值
info={} # 没有"name"，添加
res=info.setdefault('name','egon')
print(info) # {'name': 'egon'}
print(res) # egon
六、集合
1、作用、定义与类型转换
1.1 关系运算
friends1 = ["zero","kevin","jason","egon"]
friends2 = ["Jy","ricky","jason","egon"]
l=[]
for x in friends1:
if x in friends2:
l.append(x)
print(l)
1.2 去重(可以对列表进行去重，但无序)
l = [1,1,1,"a","b",2,2,3,4]
s = set(l)
print(s) # {1, 2, 3, 4, 'a', 'b'}
1.3 定义:
在{}内用逗号分隔开多个元素，多个元素满足以下三个条件
# 1. 集合内元素必须为不可变类型
# 2. 集合内元素无序
# 3. 集合内元素没有重复
s={1,2} # s=set({1,2})
#s={1,[1,2]} # 报错，集合内元素必须为不可变类型
s={1,'a','z','b',4,7} # 集合内元素无序
print(s) # {1, 4, 7, 'b', 'z', 'a'}
s={1,1,1,1,1,1,'a','b'} # 集合内元素没有重复
print(s) # {'b', 1, 'a'}
# 了解
s={} # 默认是空字典
print(type(s)) # <class 'dict'>
# 定义空集合
s=set()
print(s,type(s)) # set() <class 'set'>
1.4 类型转换
res=set('hellolllll')
print(res) # {'o', 'l', 'h', 'e'}
# print(set([1,1,1,1,1,1]))
# print(set([1,1,1,1,1,1,[11,222]]) # 报错
print(set({'k1':1,'k2':2})) # {'k1', 'k2'}
2、内置方法
关系运算符
friends1 = {"zero","kevin","jason","egon"}
friends2 = {"Jy","ricky","jason","egon"}
# 2.1 取交集：两者共同的好友
res=friends1 & friends2 # {'egon', 'jason'}
print(res)
print(friends1.intersection(friends2))
# 2.2 取并集/合集：两者所有的好友
print(friends1 | friends2) # {'ricky', 'kevin', 'Jy', 'jason', 'egon', 'zero'}
print(friends1.union(friends2))
# 2.3 取差集：取friends1独有的好友
print(friends1 - friends2) # {'zero', 'kevin'}
print(friends1.difference(friends2))
# 取friends2独有的好友
print(friends2 - friends1) # {'Jy', 'ricky'}
print(friends2.difference(friends1))
# 2.4 对称差集: 求两个用户独有的好友们（即去掉共有的好友）
print(friends1 ^ friends2) # {'Jy', 'zero', 'kevin', 'ricky'}
print(friends1.symmetric_difference(friends2))
# 2.5 父子集：包含的关系
s1={1,2,3}
s2={1,2,4}
# 不存在包含关系，下面比较均为False：
print(s1 > s2)
print(s1 < s2)
s1={1,2,3}
s2={1,2}
print(s1 > s2) # 当s1大于或等于s2时，才能说是s1是s2他爹
print(s1.issuperset(s2))
print(s2.issubset(s1)) # s2 < s2 =>True
s1={1,2,3}
s2={1,2,3}
print(s1 == s2) # s1与s2互为父子
print(s1.issuperset(s2))
print(s2.issuperset(s1))
去重
# 1、只能针对不可变类型去重
print(set([1,1,1,1,2]))
# 2、无法保证原来的顺序
l=[1,'a','b','z',1,1,1,2]
l=list(set(l))
print(l)
l=[
{'name':'lili','age':18,'sex':'male'},
{'name':'jack','age':73,'sex':'male'},
{'name':'tom','age':20,'sex':'female'},
{'name':'lili','age':18,'sex':'male'},
{'name':'lili','age':18,'sex':'male'},
]
new_l=[]
for dic in l:
if dic not in new_l:
new_l.append(dic)
print(new_l)
3、其他操作
'''
# 1.长度
>>> s={'a','b','c'}
>>> len(s)
3
# 2.成员运算
>>> 'c' in s
True
# 3.循环
>>> for item in s:
... print(item)
...
c
a
b
'''
# 其他内置方法
s={1,2,3}
# 需要掌握的内置方法1：discard
s.discard(4) # 删除元素不存在do nothing
print(s)
#s.remove(4) # 删除元素不存在则报错
# 需要掌握的内置方法2：update
s.update({1,3,5})
print(s) # {1, 2, 3, 5}
# 需要掌握的内置方法3：pop
res=s.pop()
print(res) # 随机弹出
# 需要掌握的内置方法4：add
s.add(4)
print(s) # 加入元素
# 其余方法全为了解
res=s.isdisjoint({3,4,5,6}) # 两个集合完全独立、没有共同部分，返回True
print(res)
# 了解
s.difference_update({3,4,5}) # s=s.difference({3,4,5})
print(s)