python基础：数据类型二

本文目录：

一、元组类型

二、字典类型

三、集合

一、元组类型

 什么是元祖

元组: 元组就是一个不可变的列表

用途: 用于存放多个值,当存放的多个值只有读的需求没有改的需求时用元组最合适

定义方式:在()内用逗号分隔开多个任意类型的值

t=(1,3.1,'aaa',(1,2,3),['a','b']) # t=tuple(...)
# print(type(t))
# res=tuple('hello')
# res=tuple({'x':1,'y':2})
# print(res)

常用操作+内置的方法

1、按索引取值(正向取+反向取)：只能取

# t=('a','b',1)
# t[0]=111

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

# t=('h','e','l','l','o')
# res=t[1:3]
# print(res)
# print(t)

3、长度

# t=('h','e','l','l','o')
# print(len(t))

4、成员运算in和not in

# t=('h','e','l','l','o')
# print('h' in t)

5、循环

# t=('h','e','l','l','o')
# for item in t:
#     print(item)

总结

# ======================================该类型总结====================================
# 存多个值

# 有序

# 不可变（1、可变：值变，id不变。可变==不可hash 2、不可变：值变，id就变。不可变==可hash）
t=(1,'a',['x','y','z'])
# print(id(t[2]))

# print(id(t))
t[2][0]='X'
# print(t)
# print(id(t))

# print(id(t[2]))

# list1=['a','b','c']
# print(id(list1[0]))
# print(id(list1[1]))
# print(id(list1[2]))
#
# print('='*50)
# list1[1]='B'
# print(id(list1[0]))
# print(id(list1[1]))
# print(id(list1[2]))

# 掌握的方法
t=('a','b','a')
# print(t.index('a'))
# t.index('xxx')
print(t.count('a'))

 二、字典类型

什么是字典

类似于java编程语言中的Map

用途: 用来存方多个(不同种类的)值

定义方式: 在{}内用逗号分隔开多个key:value的元素,其中value可以是任意数据类型,而key的功能通常是用来描述value的,所以key通常是字符串类型,但其实key必须是不可变的类型(intfloatstr uple)

d={0:'x',1.3:'y','k1':'z',(1,2,3):'aaa'} # d=dict(....)
# print(d[(1, 2, 3)])
# d1={[1,2,3]:'aaaaa'}

# d=dict([('k1',1),('k2',2),('k3',3)])
# print(d)

# l=[('k1',1),('k2',2),('k3',3)]
# d={}
# for t in l: #t=('k1',1)
#     k,v=t
#     # print(k,v)
#     d[k]=v
# print(d)
# #
# d=dict(l)
# print(d)

# d=dict(x=1,y=2,z=3)
# print(d)

常用操作+内置的方法

1、按key存取值：可存可取

d={'x':1}
print(d['x'])
print(id(d))
d['x']=1111
print(d)
print(id(d))
d['y']=2222
print(d)

2、长度len

d={'x':1,'y':2,'z':3}
print(len(d))

3、成员运算in和not in

d={'x':1,'y':2,'z':3}
print(1 in d)
print('x' in d)
# 一般判断这个元素是否存在于字典的key中

4、删除

d={'x':1,'y':2,'z':3}
# del d['y']
# print(d)

# res=d.pop('y')
# print(d)
# print(res)

# res=d.popitem() #取出字典最后一个key，val并返回个元祖
# print(res)

5、键keys()，值values()，键值对items()

d={'name':'egon','age':18,'sex':'male','hobbies':[1,2,3]}
print(d.keys())
# print(list(d.keys()))

print(d.values())
# print(list(d.values()))

print(d.items())
# print(list(d.items()))

6、循环

# for k in d.keys():
#     print(k)
# for k in d:
#     print(k)

# for v in d.values():
#     print(v)

for k,v in d.items(): #k,v=('name', 'egon')
    print(k,v)

总结

# ======================================该类型总结====================================
# r存多个值

# 无序

# 可变（1、可变：值变，id不变。可变==不可hash 2、不可变：值变，id就变。不可变==可hash


# 需要掌握的操作
# get方法
# d={'name':'egon','age':18,'sex':'male','hobbies':[1,2,3]}
# v=d.get('namexxxxxxx')
# print(v)

# v1=d['namexxxxxxxxxxx']
# print(v1)

#update方法
# d={'name':'egon','age':18,'sex':'male','hobbies':[1,2,3]}
# d.update({'x':1,'name':"EGON"})
# print(d)

# fromkeys:需求是快速新造出一个字典,value的初始值全都为None,而key是来自于一个列表
# keys=['name','age','sex']
# # d={}
# # for k in keys:
# #     d[k]=None
#
# d={}.fromkeys(keys,None)
# print(d)

# setdefault
d={"x":1,"y":2}

# 按照默认的操作形式
# d['x']=1111 # key存在则修改
# d['z']=1111 #key不存在则新增

# 按照setdefault的形式
# d={"x":1,"y":2}
# res=d.setdefault('x',11111) # 在key存在的情况下不修改值,会返回原值
# print(d)
# print(res)

# res=d.setdefault('z',11111) # 在key不存在的情况下会新增值,会返回新增的值
# print(d)
# print(res)

# 练习
s='hello alex alex say hello sb sb'

# d={'hello':2,'alex':2,'say':1,'sb':2}

d={}
words=s.split()
# print(words) #words=['hello', 'alex', 'alex', 'say', 'hello', 'sb', 'sb']
for word in words: #word=  'alex'
    # d[word]=words.count(word) #d['alex']=words.count('alex')
    d.setdefault(word,words.count(word))
    #d={'hello':2,'alex':2}

# print(d)

#补充元组符号
# t=(1,)
# print(t,type(t))


name=input('>>: ').strip()
print(('my name is %s' %name).center(50,'*'))

 

三、集合

什么是集合　

pythons=['egon','张铁蛋','李铜蛋','赵银弹','王金蛋','艾里克斯']
linuxs=['欧德博爱','李铜蛋','艾里克斯','lsb','ysb','wsb']
l=[]

for stu in pythons:
    if stu in linuxs:
        l.append(stu)
print(l)

上面是找出即在python学员名单又在linux学员名单中的学员，有没有更好更简单的方法呢？

有的，就是集合

什么是集合？
在{}内用逗号分隔开多个值,集合的特点:
            1. 每个值必须是不可变类型
            2. 集合无序
            3. 集合内元素不能重复

为何要用集合
    1. 用于做关系运算
    2. 去重

　　

3. 如何用集合

# s={1,1.3,'aa',[1,2,]}
# s={1,1.3,'aa'}
# print(s)
# s={1,1,1,1,1,1,1,2} #s=set(....)
# print(type(s))
# print(s)
# d={'x':1,'x':2,'x':3}
# print(d)
# res=set('hello')
# res=set([1,2,['a','b']])
# print(res)

集合的第一大用途: 关系运算

pythons={'egon','张铁蛋','李铜蛋','赵银弹','王金蛋','艾里克斯'}
linuxs={'欧德博爱','李铜蛋','艾里克斯','lsb','ysb','wsb'}
# 1 求同时报名两门课程的学生姓名:交集
# print(pythons & linuxs)
# print(pythons.intersection(linuxs))
# pythons=pythons & linuxs
# print(pythons) #{'李铜蛋', '艾里克斯'}
# pythons.intersection_update(linuxs) #pythons=pythons.intersection(linuxs)
# print(pythons) #{'艾里克斯', '李铜蛋'}
# 2 求报名老男孩学校课程的所有学生姓名:并集
# print(pythons | linuxs)
# print(pythons.union(linuxs))
# 3 求只报名python课程的学生姓名: 差集
# print(pythons - linuxs)
# print(pythons.difference(linuxs))
# print(linuxs - pythons) #求只报名linux课程的学生姓名
# print(linuxs.difference(pythons))
# 4 求没有同时报名两门课程的学生姓名: 对称差集
# print((pythons - linuxs) | (linuxs - pythons))
# print(pythons ^ linuxs)
# print(pythons.symmetric_difference(linuxs))
# 5 父子集:指的是一种包含与被包含的关系
# s1={1,2,3}
# s2={1,2}
# print(s1 >= s2)
# print(s1.issuperset(s2))
# print(s2.issubset(s1))

# 情况一:
# print(s1 > s2) #>号代表s1是包含s2的,称之为s1为s2的父集
# print(s2 < s1)
# 情况二:
# s1={1,2,3}
# s2={1,2,3}
# print(s1 == s2) #s1如果等于s2,也可以称为s1是s2的父集合
# 综上:
# s1 >= s2 就可以称为s1是s2的父集

# s3={1,2,3}
# s4={3,2,1}
# print(s3 == s4)
# s5={1,2,3}
# s6={1,2,3}
# print(s5 >= s6)
# print(s6 >= s5)

集合的第二大用途:去重

 

 

# 集合去重的局限性:
# 1. 会打乱原值的顺序
# 2. 只能针对不可变的值去重

# stus=['egon','lxx','lxx','alex','alex','yxx']
# new_l=list(set(stus))
# print(new_l)
#
# old_l=[1,[1,2],[1,2]]
# set(old_l)

l=[
    {'name':'egon','age':18,'sex':'male'},
    {'name':'alex','age':73,'sex':'male'},
    {'name':'egon','age':20,'sex':'female'},
    {'name':'egon','age':18,'sex':'male'},
    {'name':'egon','age':18,'sex':'male'},
]
# new_l=[]
# for dic in l:
#     if dic not in new_l:
#         new_l.append(dic)
# print(new_l)

# 需要掌握的操作:
s1={1,2,3}
# s1.update({3,4,5})
# print(s1)
# print(s1.pop())
# print(s1)

# s1.remove(2)
# print(s1)

# s1={1,2,3}
# print(id(s1))
# s1.add(4)
# print(s1)
# print(id(s1))

# s1={1,2,3}
# s1.discard(4)
# s1.remove(4)
# print(s1)

# s1={1,2,3}
# s2={4,5}
# print(s1.isdisjoint(s2))

#总结
# 存多个值
# 无序
# set可变