day---05 基本数据类型（下）

元组

======================================基本使用======================================
1、用途：能够存储多个元素，每个元素之间用逗号隔开，元素可以是任意数据类型
2、定义方式：是在()内写，　　　　虽然用途和列表一样，但是列表是[]

　　　　　　注意一下：如果只有一个元素的元组，那么这么写

　　　　　　　　t = (11,)      最后加个逗号 否则就不是元组了

　　name = ('xxx','ooo','qqq')

　　本质 name = tuple(('xxx','ooo','qqq))
3、常用操作+内置的方法
======================================该类型总结====================================
存一个值or存多个值

　　存多个值

有序or无序　　

　　有序

可变or不可变 

　　不可变类型

 

常用操作和内河内置方法

1 按索引取值(正向取 和 反向取都行)    但是只能取

l = (1,2,3,4,'a','v',['q','w','e'])
print(l[6])  # ['q', 'w', 'e']
# 如果元素中有可变类型那么元素也是可以改变的
l[6][2] = '就这么改'
print(l)  # (1, 2, 3, 4, 'a', 'v', ['q', 'w', '就这么改'])

2 切片(顾头不顾尾，步长) 

l = (1,2,6,3,6,8,3)
print(l[1:5:2])  # (2, 3)
print(l[-1:-5:-2])  # (3, 6)

3 长度 len

l = ('a','s','g','f','y')
print(len(l))  # 5

4 成员运算 in       not in

l = [1,2,4,5,7,'a','asdas',[]]
print([] in l)  # True
print(9 not in l)  # True

5 循环

l = [1,1,1,1,1,2,4,5,7,'a','asdas',[]]
for i in l:
    print(i)

补充:
print(l.count(1))  # 5    元素出现次数
print(l.index('a'))  #  元素的索引    可以规定位置

字典

======================================基本使用======================================
1、用途：记录有描述性的数据 在{}内    可以存多组key:value键值对  key是对calue的描述  key通常情况下是字符串(这是之前字符串的说法)  这个key只能是不可变类型，value是任意类型的
2、定义方式：

dic = {'name':'james','age':'12'}      原理   dic = dict({'name':'james','age':'12'})

从来没试过的字典

d = {1:'2',2:'3',3:'4','name':'james',(5,):'试试能不能'}
print(d)  # {1: '2', 2: '3', 3: '4', 'name': 'james', (5,): '试试能不能'}    看来是可以的
print(type(d))  # <class 'dict'>

key重复的情况
d = {'age':12,'age':178,'age':19,'name':'james'}
print(d)  # {'age': 19, 'name': 'james'}   字典的key是不能重复的   key重复的话值输出最后一对key，value键值对
print(len(d))  # 2 在字典中如果key重复了    元素个数算一个

 

3、常用操作+内置的方法
======================================该类型总结====================================
存一个值or存多个值

　　存多个值

有序or无序　　

　　无序

可变or不可变 

　　可变类型

常用操作+内置方法

1 按照key存取值：能存能取       也可以改

dic = {'name':'james','age':22,'hobby':'python'}
print(id(dic))  # 5955656
print(id(dic))
print(dic['name'])  # james     根据key取值
res = dic['age'] = 18
print(res,dic)  # 18 {'name': 'james', 'age': 18, 'hobby': 'python'}     age改变了
res = (dic['qq']) = 850446614
print(res,dic)  # 850446614 {'name': 'james', 'age': 22, 'hobby': 'python', 'qq': 850446614}
                #当字典里面出现一个没有的key值时，会自动将这个键值对加在末尾
print(id(dic))  # 5955656    而且发现id没改变    说明是可变类型

2 长度 len

dic = {"name":"james","age":"22","phone":"11111"}
print(len(dic))  # 3 统计的是键值对的数量

3 成员运算 in     not in       对于字典来说只能判断key值

dic = {"name":"james","age":"22","phone":"11111"}
print('james' in dic)  # False     False是因为在字典中只会将key暴露给我们   value 是不会暴露出来的
print('name' in dic)  # True      所以这个key就可以搜到

4 删除

dic = {"name":"james","age":"22","phone":"11111"}
del dic['phone']
print(dic)  # {'name': 'james', 'age': '22'}  直接删除
res = dic.pop('name')
print(res)  # james pop 弹出的是value值
#
这个会报错
print(dic['phone'])   # 报错   因为原字典中没有phone这个键，所以当键不存在直接报错
#
#
dic.clear()
print(dic)  # {} 返回了一空字典  用clean时候 clean提示不接受任何参数
            # 所以clean一般是直接删除字典内所有键值对

5 定义字典的三种方式

(******)
#
dic = {'name':'james','age':22}
print(dic)
#
传参数式方法
d = dict(name='james',age=22)
print(d,type(d))
#
(*)
l = [
    ['name','james'],
    ['age',18],
    ['qq',854125442]
]
dic = {}
for i in l:
    dic[i[0]] = i[1]
    print(dic)
#
l = [
    ['name','james'],
    ['age',18],
    ['qq',854125442]
]
dic = {}
for k,v in l:
    dic[k] = v
print(dic)

6 键keys(),值values(),键值对items()

dic = {'name':'james','age':22}
print(dic.keys())  # dict_keys(['name', 'age'])   还是前面说的老母猪   要就下崽  不要就告诉你 我这里有啥
for k in dic.keys():
    print(k)  #  输出了dic 字典中的两个key     这就是猪下崽的办法
#
dic = {'name':'james','age':22}
print(dic.values())  # dict_values(['james', 22])  同上  只不过这里是输出value
for v in dic.values():
    print(v)  # 让猪下崽
#
dic = {'name':'james','age':22}
print(dic.items())  # dict_items([('name', 'james'), ('age', 22)]) 同上  这里是键值对
for k,v in dic.items():
    dic[k] = v
print(k,v)  # age 22  让猪下崽
#
#
get()根据key获取value    (******************************)   这相当重要
dic = {'name':'james','age':22}
print(dic["name"])  # james
print(dic["age"])  # 22
print(dic.get('name','你给我的name在字典的key中'))  # 在的话返回value值
res = dic.get('phone')
print(res)              # None  很明显字典中没有phone这个键 这就是get 的好处  不报错 返回None
                        但是也告诉你的查询的key不在字典的key中
#
#
dic = {'name':'james','age':22}
res = dic.get('phone','又没有小姐姐，发出来干吗！！！')
print(res)  # 又没有小姐姐，发出来干吗！！！
            # get 还可以传值，如果查询的key在原字典中没有的话 那么他会返回你写好的参数 不写的话返回None
            # 写了就返回你写的内容  没写就返回None
#
dict.fromkeys()    快速创建字典
dic = ['name','age','pwd','phone']
print(dict.fromkeys(dic,123))  # {'name': 123, 'age': 123, 'pwd': 123, 'phone': 123}
                               # 快速创建字典   但是每个key的value 都是同样的
#
dict.popitem()
dic = {'name':'james','age':22,'pwd':'123qwe','phone':12306}
print(dic.popitem())  # ('phone', 12306)     默认将最后一组键值对弹出  先进后出
#
dict.setdefault()
dic = {'name':'james','age':22,'pwd':'123qwe','phone':12306}
print(dic.setdefault('name','kobe'))  # james 当key存在的时候 不修改原值 ，返回原值给你
print(dic.setdefault('vx','asd00000'))  # 查询的不再字典中时候，会增加一个新的键值对，返回新增的键值对
print(dic)  # {'name': 'james', 'age': 22, 'pwd': '123qwe', 'phone': 12306, 'vx': 'asd00000'}
#
dict.update()
dic = {'name':'james','age':22}
dic1 = {'QQ':'1598741','vx':'asd00000'}
dic.update(dic1)
print(dic)  # {'name': 'james', 'age': 22, 'QQ': '1598741', 'vx': 'asd00000'}  两个字典的合并
dic["QQ"] = 6545646546  # 修改key相对应的value值
print(dic)
dic.update(QQ=6554654654654)
print(dic)  # 也是修改key对应的value值

7 循环

dic = {'name':'james','age':22,'pwd':'123qwe','phone':12306}
for i in dic:
    print(i)

集合

集合
作用  去重，关系运算
s = {1,2,3,4,5,6}     # <class 'set'>   原理    s = set
print(type(s))
# 
s = set()
print(type(s))  # <class 'set'>   定义空集合只能用好、关键字set
# 
x = {}
print(type(x))  # <class 'dict'>  仅仅写了一个大括号的哈  python默认他是一个字典
# 
t = ()
print(type(t))  # <class 'tuple'>    元组类型
# 
定义集合
集合 可以包含多个元素，用逗号分隔
集合的元素遵循的三个元素
可变类型：不可hash
不可变类型：可以hash
# 
没有重复的元素
s = {1,2,2,2,2,3,3,3,4,4,4,4,4,5}
print(s)  # {1, 2, 3, 4, 5}  集合自动去重
# 
集合是无序的
s = {1,2,3,4,5,6}
print(s)  # {1, 2, 3, 4, 5, 6}   虽然看着升序  但是记住集合时无序的
# 
# 
注意：集合的目的是将不同的值存放到一起，不同的集合间用来做关系运算的，不用纠结集合中单个的值
# 
优先掌握的操作
1 长度 len
s = {1,2,3,}
print(len(s))  # 3
# 
2 成员运算 in    not in
s = {1,2,3,4,5,6.234}
print('a' in s)  # Falss
print(4 in s)  # True
# 
|合集    &交集    -差集    ^对称差集    >>=父级    <<=子集
s1 = {1,2,3,4,5,6,7,8,9}
s2 = {2,4,6,8}
print(s1 | s2)  # {1, 2, 3, 4, 5, 6, 7, 8, 9}  合集所有的加在一起
print(s1 & s2)  # {8, 2, 4, 6}  交集两边共有的
print(s1 - s2)  # {1, 3, 5, 7, 9}  1有2没有的
print(s1 ^ s2)  # {1, 3, 5, 7, 9}  对称差集    两边没有共同的
print(s1 >= s2)  # True   父集   1有的是不是2都有  是返回Ture
print(s1 <= s2)  # False  子集   1有的是不是2都有  不是返回False
# 
s = {1,2,3,4,5}
print(s.add(666))
print(s.add((1,2,3,4)))
# 
s = {1,2,3,4,5}
print(s.add(5))  # None
print(s)  # 添加元素   原来有就不加  没有的话加在末尾
a = {1,2,3,4,5}
print(a.add((1,2,3,4)))  #None  # 将容器类型当成一个元素传入
print(a)
b = {1,2,3,4,5}
print(b.remove(888888))  # 删除元素为1 的那个元素   没有的话会报错
print(b)
v = {1,2,3,4,5}
print(v.discard(88888))  # 删除一个不存在的元素 不会报错  会返回原集合
print(v)