04-各数据类型的常用操作

一、数字类型：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)