day07 列表类型 练习题 元祖类型 元祖vs列表 字典类型 集合类型

#列表类型
# ======================================基本使用======================================
# 1、用途：记录多个值（同种属性）

# 2、定义方式：在[]内用逗号分隔开多个任意类型的值
# l=['a','b','c'] #l=list(['a','b','c'])

# 类型转换
# l=list('hello')
# l=list({'x':1,'y':2})
# print(l)

# 3、常用操作+内置的方法
#优先掌握的操作：
l=['a','b','c','d','e']
#1、按索引存取值(正向存取+反向存取)：即可存也可以取
# print(l[0])
# print(l[-1])
# print(id(l))
# l[0]='A'
# print(id(l))

# l[4]='EEEEEE'
# print(l)

# l[5]='dddddd'


#2、切片(顾头不顾尾，步长)
# l=['a','b','c','d','e']
# print(l[1:4])
# print(l)


#3、长度
# l=['a','b','c','d','e']
# print(len(l))

#4、成员运算in和not in
# print('a' in l)
# print('ssssss' not in l)

#5、追加&插入
# l=['a','b','c','d','e']
# l.append(3333333)
# l.append(44444)
# print(l)

# l.insert(0,11111111111)   #第一个是索引第二个是元素
# print(l)

#6、删除
# l=['a','b','c','d','e']
# del l[0]
# res=l.remove('b')
# print(l)
# print(res)

# res=l.pop(0)
# print(l)
# print(res)

#

#7、循环
# l=['a','b','c','d','e']
# for item in l:
#     print(item)

#需要掌握的操作
# l=['a','b','a','c','d','e']
# print(l.count('a'))

# l=['a','b','a','c','d','e']
# items=[1,2,3,4,5]
# # for item in items:
# #     l.append(item)
#
# l.extend(items)
# print(l)


# l=['a','b','a','c','d','e']
# print(l.index('a',2,5))
# l.index(123123123123123123123123)

# if 123123123123123123123123 in l:
#     print(l.index(123123123123123123123123))


# l=['a','b','a','c','d','e']
# l.reverse()
# print(l)
#
# l=[10,-1,3,11,9]
# # l.sort(reverse=True)
# # print(l)
#
# # print(l.extend(['a','b','c']))
# print(l.pop(0))
# print(l)


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

# 有序

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


# 练习题
#1. 队列：先进先出
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. 堆栈：后进先出
l=[]
# 入栈
l.append('first')
l.append('second')
l.append('third')
print(l)
# 出栈
print(l.pop())
print(l.pop())
print(l.pop())

练习题

# 元组tuple：
# ======================================基本使用======================================
# 1、用途：元组就是一个不可变的列表

# 2、定义方式：在()内用逗号分隔开多个任意类型的元素
# t=(1,2.2,'aa',('b','c'),['a','b','c']) # t=tuple(...)
# print(type(t))
# 强调：
# l=['a']
# print(type(l),l[0])

# t=('a',)
# print(type(t))
# print(t)

# msg=('hello world')

# 类型转换
# t1=tuple('hello')
# t2=tuple([1,2,3])
# print(t1)
# print(t2)

# 3、常用操作+内置的方法
#优先掌握的操作：
# t=(1,2.2,'aa',('b','c'),['a','b','c'])
#1、按索引取值(正向取+反向取)：只能取
# print(t[0])
# print(t[-1])

# t[0]=1111111111

#2、切片(顾头不顾尾，步长)
# t=('a','b','c','e','f')
# print(t[1:4])

#3、长度
# print(len(t))
#4、成员运算in和not in
# print('a' in t)

#5、循环
# for item in t:
#     print(item)

# 需要掌握的操作
# t=('a','b','c','e','a','f')
# print(t.index('a',1,5))
# print(t.count('a'))

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

# 有序

# 不可变（1、可变：值变，id不变。可变==不可hash 2、不可变：值变，id就变。不可变==可hash）
# t=('a','b','c')
# print(id(t))
# t=('A','B','C')
# print(id(t))

t=('a',111,['b','c'])
print(id(t[0]),id(t[1]),id(t[2]))
t[2][0]='B'
# print(t)
print(id(t[0]),id(t[1]),id(t[2]))

# t[0]='A'
# t[2]=[1,2,3]

# l=['a','b','c']
# l[0]='A'

字典类型

#字典类型dict
# ======================================基本使用======================================
# 1、用途:记录多个值,列表是索引对应值,而字典是key对应值,其中key对value有描述性的功能

# 2、定义方式:在{}用逗号分隔开多个元素,每个元素都是key:value的形式,其中key可以不可变类型,通常是字符串类型
# 而value可以是任意类型
# d={1:'aaa',2.2:'bbb','xxx':'ccc',(1,2,3):'dddd'} #d=dict(...)
# print(d[(1,2,3)])

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

# items=[('name','egon'),('age',18),('gender','male')]
# d={}
# for item in items:
#     d[item[0]]=item[1]

# d=dict(items)
# print(d)

# 了解
# keys=['name','age','gender','height','weight']
# d={}
# for key in keys:
#     d[key]=None

# d={}.fromkeys(keys,None)
# print(d,type(d))

# 3、常用操作+内置的方法
#优先掌握的操作：
#1、按key存取值：可存可取
dic={'name':'egon','age':18}
# dic['xxxx']
# print(dic.get('name'))
# print(dic.get('xxx'))

# print(dic['name'])
# dic['name']='EGON'
# dic['gender']='male'
# print(dic)

# l=['a','b','c']
# l[0]='A'
# l[4]='AAA'

#2、长度len
# dic={'name':'egon','age':18}
# print(dic)
# print(len(dic))

#3、成员运算in和not in :是以字典的key为准的
# dic={'name':'egon','age':18}
# print('name' in dic)
# print('egon' in dic)


#4、删除
dic={'name':'egon','age':18}
# del dic['name']
# print(dic)

# res=dic.pop('name')
# print(dic)
# print(res)

# res=dic.popitem()
# print(res)

#5、键keys()，值values()，键值对items()
# 在python2
# >>> dic={'name':'egon','age':18}
# >>>
# >>>
# >>> dic.keys()
# ['age', 'name']
# >>>
# >>>
# >>> dic.values()
# [18, 'egon']
# >>>
# >>>
# >>> dic.items()
# [('age', 18), ('name', 'egon')]

# 在python3
# >>> dic={'name':'egon','age':18}
# >>>
# >>> dic.keys()
# dict_keys(['name', 'age'])
# >>> dic.values()
# dict_values(['egon', 18])
# >>> dic.items()
# dict_items([('name', 'egon'), ('age', 18)])
#6、循环
# dic={'name':'egon','age':18}
# for k in dic:
#     print(k)

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

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

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

# 需要掌握的操作
# dic={'name':'egon','age':18}
# dic={'name':'egon','age':18}
# dic.update({'age':19,'gender':'male'})
# print(dic)


# dic={'name':'egon','age':18}
# 当key存在时,不改原值,返回原值
# res=dic.setdefault('name','EGON')
# print(dic)
# print(res)

# 当key不存在时,增加新值
# res=dic.setdefault('gender','male')
# print(dic)
# print(res)

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

# 无序

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

集合类型

# pythons=['张铁蛋','李铜淡','王金蛋','赵银胆','alex','kevin']
# linuxs=['oldboy','张铁蛋','赵银胆','alex','wxx']
#
# res=[]
# for stu in pythons:
#     if stu in linuxs:
#         res.append(stu)
#
# print(res)


# 集合类型set
# ======================================基本使用======================================
# 1、用途:I: 关系运算  II:去重

# 2、定义方式:在{}内用逗号分隔开多个元素,但是元素的特点是
# I: 集合内的元素必须是不可变类型
# II: 集合内元素无序
# III: 集合内元素不能重复

# s={1,'aaa',2,} #s=set(...)
# print(s,type(s))

# s=set()
# print(s,type(s))

# s={1,1,1,1,1,1,1,1,1,1,1,1,'a','a','a'}
# print(s)

# 数据类型转换
# res=set('hello')
# print(res)

# res=set([1,'a','b'])
# print(res)

# 3、常用操作+内置的方法
#优先掌握的操作：
#1、长度len
#2、成员运算in和not in


pythons={'张铁蛋','李铜淡','王金蛋','赵银胆','alex','kevin'}
linuxs={'oldboy','张铁蛋','赵银胆','alex','wxx'}
#3、|合集:求所有报名的学生
# print(pythons | linuxs)
# print(pythons.union(linuxs))

#4、&交集:求同时报名两门课程的学生
# print(pythons & linuxs)

#5、-差集: 求只报名python课程的学员
# print(pythons - linuxs)
# print(linuxs - pythons) #求只报名linux课程的学员

#6、^对称差集:求没有同时报名两门课程的学生
# res=(pythons - linuxs) | (linuxs - pythons)
# res=pythons ^ linuxs
# print(res)

#7、==
# s1={1,2,3}
# s2={3,2,1}
# print(s1 == s2)

# 注意:父子集描述的是一种包含与被包含的关系
#8、父集：>=
#9、子集：<=
# s1={1,2,3}
# s2={1,2,3,4}
# print(s2 >= s1)
# print(s1 <= s2)

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

s1={1,'aa','bb',3}
# print(s1.pop())

# res=s1.remove('bbbbbb')
# print(s1)
# print(res)

# s1.discard('bbb')
# s1.add(4)
# print(s1)
# ======================================该类型总结====================================
# 存多个值

# 无序

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


# 集合的去重
# 局限性
#1. 只能针对不可变类型
#2. 不能保证原来的顺序
# names=['egon','egon','egon','alex','alex','kevin']

# new_names=list(set(names))
# print(new_names)


l=[
    {'name':'egon','age':18,'sex':'male'},
    {'name':'alex','age':73,'sex':'male'},
    {'name':'kevin','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)