005、Python-数据类型的内置方法(下)

数据类型的内置方法—tuple、dict、set

1、元组 tuple

不可变类型，所以 在 **元组内元素不能’修改’ **–元组内各索引值指向的内存地址不能修改

# 定义方式：在 () 内用逗号分隔开 多个类型的元素
"定义只有一个元素时必须用 逗号 , 否则不一定是元组类型"
x = (10)
print(type(x)) # int

x = (10,)
print(type(x)) #  tuple

t1 = (1,2,3,4, [55,66] )
t1[-1].append('77')
print( t1 ) 
# (1,2,3,4, [55, 66, 77] ) 

数据类型转换

"所有可迭代对象 都可以进行 元组类型转换"
str1 = "hello"
print(tuple(str1)) # ('h','e','l','l','o')

常用操作

tuple = (1,2,3,4,5,6)
#1、按索引取值(正向取+反向取)：只能取   
#2、切片(顾头不顾尾，步长)----->切片的本质是 复制 而不是剪切！并不改变原来的数据
#3、长度
#4、成员运算in和not in
#5、统计某个元素出现的个数 .count() 方法

2、字典类型 dict

# 定义方式：在 {} 内用逗号分隔开 多个元素,每个元素都是 key:value 的格式
"key 必须是不可变类型 并且不能重复 ；value 可以为任意类型"
"字典是无序的！用 循环取值 每次取出的顺序都是不一样的"

数据类型转换

# 由于 每个元素都是 key:value 的格式 所以进行数据类型转换时必须成对出现

str = 'hello'
print(dict(str)) # 报错

list1 = [['key1',"value"],["key2","value"]]
print(dict(list1)) # {'key1': 'value', 'key2': 'value'}

print(dict(x=1,y=2,z=0) # {'x': 1, 'y': 2, 'z': 0}

取值操作

按照 key 取值—该方法如果 key 不存在，则报错

dict1={'x': 1, 'y': 2, 'z': 0}
print(dict1['y']) # 结果：2 

. get( ) 取值—方法如果 key 不存在，则返回 None

'第二个参数不写 则默认返回 None，写了则返回这第二个参数'
dict1={'x': 1, 'y': 2, 'z': 0}

print(dct1.get('y')) # 结果：2

print(dct1.get('a')) # 结果：None 
print(dct1.get('a','这个键不存在')) # 结果：这个键不存在

获取所有的键、所有的值、所有的键值对

dict1={'x': 1, 'y': 2, 'z': 0}
dict1.keys()  # 获取所有的键
dict1.values() # 获取所有的值
dict1.items() # 获取所有的键值对
'上述三个方法 在 Python3 中 返回的是一个对象--可以看成一个列表 '
'在 Python2 中 返回的就是一个列表 '
print(dict1.keys())	# dict_keys(['x', 'y', 'z'])
print(dict1.values())	# dict_values([1, 2, 0])
print(dict1.items())	# dict_items([('x', 1), ('y', 2), ('z', 0)])

for i in dict1.keys():
    print(i) # 结果为：x y z

添加与修改

按 key 修改 ，如果 key 不存在 则直接添加

dict1={'x': 1, 'y': 2, 'z': 0}

dict1['x'] = 5
print(dict1) # {'x': 5, 'y': 2, 'z': 0}

dict1['a'] = 4
print(dict1) # {'x': 5, 'y': 2, 'z': 0, 'a' : 4}

update( {new dict} )–存在的 key 直接修改，不存在的会添加

dict1={'x': 5, 'y': 2, 'a' :4}

dict1.update({'b':5,'x':6})
print(dict1) # {'x': 6, 'y': 2, 'a': 4, 'b': 5}

setdefault(‘key’ , ‘value’)-- 如果字典中没有所要求的 key 则加入 key:value, 如果有 则不需要操作

该方法有返回值，返回的是这个 key 对应的 value 值

(如果原字典有这个 key 那么就是已经存在字典中的 value)

dic = {'name':'Jason', 'age':19}
v = dic.setdefault('gender','male')
w = dic.setdefault('name','franklin')

print(dic) # {'name': 'Jason', 'age': 19, 'gender': 'male'}
print(v) # male
print(w) # Jason

删除与取走

del 方法

dict1 = {'x': 5, 'y': 2, 'a' : 4, 'z':5}

del[dict1['z']]
print(dict1)  # {'x': 5, 'y': 2, 'a' : 4}

取走 . pop( key )–有返回值

dict1 = {'x': 5, 'y': 2, 'a' : 4, 'z':5}
v = dict1.pop('x')
print(v)  # 返回的是 value 值 5
print(dict1) # {'y': 2, 'a': 4}

v2 = dict1.popitem() # 随机取走一对 key:value 元素
print(v2)	# 返回的是一个元组，包含 key,value 两个元素

其他操作

# 成员运算 in , not in
'判断的是 key 值 返回 bool 值'

# 长度 len
'统计的是 key 的个数'

快速新建一个字典 .fromkeys([a list of keys], value )

用途：快速产生一个初始化好的字典，因此 value 一般都是 None

注意：所有的 value 值都是指向同一个内存地址，所以如果是 可变类型 的修改就会把所有的 value 都修改

dic = {}.fromkeys(['name', 'age', 'gender'],None)
print(dic) # {'name': None, 'age': None, 'gender': None}

'所有的 value 值都是指向同一个内存地址，所以如果是 可变类型 的修改就会把所有的 value 都修改'
dic = {}.fromkeys(['name', 'age', 'gender'],[])
dic['name'].append(111) # 会同时修改所有的列表
print(dic)  # {'name': [111], 'age': [111], 'gender': [111]}

3、集合 set

'用途：关系运算 去重'
# 定义方式：在{}内 用逗号 分割开多个元素，但是必须满足
		1、集合内的元素必须是  不可变类型
  	2、集合内的元素没有重复
    '集合本身是可变类型的'
 '集合 与 字典 内的元素都是无序的'

# 只有空的{} 其实是字典类型
set1 = {}
print(type(set1)) # <class 'dict'>

# 空集合定义方法
s = set()
print(type(s)) # <class 'set'>

# 集合定义方法
s1 = set(1,2,3)

数据类型转换

'所有可迭代对象都能进行数据类型转换'
res = set([11,22,33,44,55])
print(res) # {11,22,33,44,55}

s = set("hello")
print(s) # {h,l,e,o}

集合运算

　pythons={'alex','egon','yuanhao','wupeiqi','gangdan','biubiu'}
　linuxs={'wupeiqi','oldboy','gangdan'}

' | 合集'
print(pythons | linuxs)
# {'yuanhao', 'biubiu', 'oldboy', 'gangdan', 'alex', 'wupeiqi', 'egon'}

' & 交集'
print(pythons & linuxs)
# {'gangdan', 'wupeiqi'}

' - 差急'
print(pythons - linuxs)
# {'egon', 'yuanhao', 'biubiu', 'alex'}

print(linuxs - pythons)
# {'oldboy'}

' ^ 对等差集 = 没有同时报名两门课的 = 只属于一个集合的元素'
set1 = pythons - linuxs
set2 = linuxs - pythons
print(set1 | set2)
# {'biubiu', 'yuanhao', 'oldboy', 'alex', 'egon'}

print(pythons ^ linuxs)
# {'biubiu', 'yuanhao', 'oldboy', 'alex', 'egon'}

' 父子集 ： 包含与被包含的关系'
s1 = {1,2,3}
s2 = {1,2}
'完全包含'
print(s1 > s2) # True
's1 是否为 s2 的父集'
print(s1 >= s2) # True