元组.字典.集合及内置方法

---恢复内容开始---

1：元祖tuple：

与列表类似可以存多个值，多种数据类型，但是不同的是元祖本身不能被修改

　　1 用途：记录多个值，当多个值没有改的需求，此时用元组更合适

　　2 定义方式：与列表类型比，只不过[]换成()，在()内用逗号分隔开多个任意类型的值

tile=(1,12,45,'kvein',[23,'hive'],'kill')#等价 tile=tuple((1,12,45,'kvein',[23,'hive'])

tile=(1,12,45,'kvein',[23,'hive'],'kill')
print(type(tile))
>>><class 'tuple'>       在定义容器类型的时候，哪怕内部只有一个元素，你也要用逗号隔开 区分一下

2：常用操作+内置的方法

优先掌握的操作：

1、按索引取值(正向取+反向取)：只能取，不能存，不能修改

tile=(1,12,45,'kvein',[23,'hive'],'kill')
print(tile[::2])     # 索引、切片取值都是顾头不顾尾，按步长，默认从左到右取值
print(tile[::])

>>>(1, 45, [23, 'hive'])
>>>(1, 12, 45, 'kvein', [23, 'hive'], 'kill')

3、长度

tile=(1,12,45,'kvein',[23,'hive'],'kill')
print(len(tile))  # 取元组中元素的个数
>>6

4、成员运算in和not in

tile=(1,12,45,'kvein',[23,'hive'],'kill')
k='kvein'
k in tile
print(k in tile)  # 成员运算 判断是否为真，返回的是 Ture或 False
W='music'
W not in tile
print(W)


>>True 
>>music     #  none时返回的是 值

5、循环

tile=(1,12,45,'kvein',[23,'hive'],'kill')
for 1 in tile:

>>1,12,45,'kvein',[23,'hive'],'kill

print(t.count('a'))
print(t.index('xxx'))

print(t.count('a'))   #统计‘a’在元组中出现的次数

 print(t.index('xxx'))  # 索引，查找

总结：能存多个值
有序
不可变

二：列表类型

　　　　　　　　　　能存多个值
　　　　　　　　　　有序的
　　　　　　　　　　可变

一：基本使用
　　1 用途：存放多个值，可以根据索引存取值

　　2 定义方式：在[]内用逗号分割开多个任意类型的值

l=['egon','lxx','yxx'] # l=list(['egon','lxx','yxx'])
l1=list('hello') #list就相当于调用了一个for循环依次取出'hello'的值放入列表
print(l1)
l2=list({'x':1,'y':2,'z':3})
print(l2)
list(10000) # 报错

3 常用操作+内置的方法

优先掌握的操作：
#1、按索引存取值(正向存取+反向存取)：即可存也可以取
l=['egon','lxx','yxx']
print(l[0])
l[0]='EGON'
print(l)
print(l[-1])
print(l[3])
l[0]='EGON'  # 只能根据已经存在的索引去改值
l[3]='xxxxxxxx'  #如果索引不存在直接报错

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

l=['egon','lxx','yxx',444,555,66666]
print(l[0:5])
print(l[0:5:2])   # 顾头不顾尾，步长取值
print(l[::-1])

3、长度 len

l=['egon','lxx','yxx',444,555,66666,[1,2,3]]
print(len(l))

4、成员运算in和not in

l=['egon','lxx','yxx',444,555,66666,[1,2,3]]
print('lxx' in l)
print(444 in l)

5、追加

l=['egon','lxx','y']
l.append('只管努力')
l.append('剩下的交给天意')
print(l)

>>['egon', 'lxx', 'y', '只管努力', '剩下的交给天意']

6、往指定索引前插入值

l=['egon','lxx','yxx']
l.insert(0，'不要假装很努力')
print(l)
l.insert(2，'结果不会陪你演戏')
print(l)

7、一次性添加多个元素

l = ['jason','nick']
l.extend(['tank','sean'])

8、删除
l=['egon','lxx','yxx']

# 单纯的删除值：
# 方式1：
del l[1] # 通用的
print(l)

# 方式2：
res=l.remove('lxx') # 指定要删除的值，返回是None
print(l,res)

9、从列表中拿走一个值

l=['sdg',34,'天意','造人']
res=l.pop(-1) # 按照索引删除值(默认是从末尾删除)，返回删除的那个值
print(l)
print(res)

>>['sdg', 34, '天意']
>>造人

8、循环

l=['egon','lxx','yxx']
for item in l:
    print(item)
>>egon
>>lxx
>>yxx

需要掌握的操作
l=['egon','egon','lxx','yxx',444,555,66666]
print(l.count('egon'))
print(l.index('egon'))
print(l.index('yxx',0,1))
l.clear()

items=['a','b','c']
items='hello'
for item in items:
l.append(item)
l.extend(items)
print(l)

l=['egon','egon','lxx','yxx',444,555,66666]
l.reverse()
print(l)

nums=[3,-1,9,8,11]
nums.sort(reverse=True)
print(nums)items=[1,'a','b',2items.sort()

10、队列：先进先出

l=[]
# # 入队
l.append('first')
l.append('second')
l.append('third')
print(l)
 # # 出队
print(l.pop(0))
print(l.pop(0))
print(l.pop(0))

# 堆栈：先进后出
l=[]
# 入栈
l.append('first')
l.append('second')
l.append('third')
print(l)
# 出栈
print(l.pop())
print(l.pop())
print(l.pop())

三、字典dict

作用：能存存储多组 key:value键值对 key是对value的描述 key通常情况下都是字符串
其实这个key只能是不可变类型,value可以是任意数据类型

定义：
# d = {'name':'jason','password':123}  # d = dict( {'name':'jason','password':123})

d2 = {'name':'jason','name':'tank','name':'nick','password':123}
print(type(d2))  #打印d2的数字类型
print(len(d2))  # 打印d2的长度
print(d2['name'])  
    #按key键值对取值，一 一对应，key不能重复赋值key如果在一个字典里重复出现则只取最    后一个值

赋值语句当key不存在的情况下，会自动新增一个键值对

 4、删除
d3= {'name':'jason','password':'123'}
 del d3['name']
 print(d3)
 res = d3.pop('name')  # 弹出仅仅是value
 res = d3.pop('age')  # 当键不存在的时候直接报错
 print(res)
 print(d3)

5、get()根据key获取value

d1 = {'name':'jason','pwd':123}
# print(d1['name'])
# print(d1['age'])
# print(d1.get('name','你给我的name在字典的key中'))
# res = d1.get('age')  # 当字典的key不存在的情况 不报错 返回None
# res1 = d1.get('xxx','你给我的age在字典的key中')  # 当字典的key不存在的情况 不报错 返回None

 dict.fromkeys()  快速的创建一个字典
l1 = ['name','password','age','hobby']
 print(dict.fromkeys(l1,123))


 dict.popitem()
 print(d1.popitem())  # 尾部以元组的形式弹出键值对

 dict.setdefault()
 d1 = {'name':'jason','pwd':123}
 res1 = d1.setdefault('name','xxoo')  # 当键存在的情况下 不修改值 并且将原先key对应值返回给你
 print(d1,res1)
 res2 = d1.setdefault('age',18)  # 当键不存在的情况下 新增一个键值对 并且将新增的键值对的值返回给你
 print(d1,res2)

 dict.update()
 d1 = {'name':'jason','pwd':123}
 d2 = {"age":18}
  d1.update(d2)
 d1['age'] = 18
 d1.update(age=666)
 print(d1)


6、循环
 d1 = {'name':'jason','password':123}
 for i in d1:
     print(i)



"""
存多个值
无序
可变

四、集合set　

pythons=['李二丫','张金蛋','李银弹','赵铜蛋','张锡蛋','alex','oldboy']
linuxs=['lxx','egon','张金蛋','张锡蛋','alex','陈独秀']

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

一：基本使用:set
1 用途: 关系运算,去重
2 定义方式: 在{}内用逗号分开个的多个值
集合的三大特性:
2.1 每一个值都必须是不可变类型
2.2 元素不能重复
2.3 集合内元素无序

s={1,3.1,'aa',(1,23),} # s=set({1,3.1,'aa',(1,23),})
print(s,type(s))

s={1,1,1,1,1,1,1,1,1,2,3}
print(s)

s={'a','b','c'}
s[0]

s=set('hello')
print(s)
print(set(['a','b','c',[1,2]])

# 3 常用操作+内置的方法
pythons={'李二丫','张金蛋','李银弹','赵铜蛋','张锡蛋','alex','oldboy'}
linuxs={'lxx','egon','张金蛋','张锡蛋','alex','陈独秀'}
# 取及报名python课程又报名linux课程的学员:交集
print(pythons & linuxs)
print(pythons.intersection(linuxs))

# 取所有报名老男孩课程的学员:并集
print(pythons | linuxs)
print(pythons.union(linuxs))

# 取只报名python课程的学员: 差集
print(pythons - linuxs)
print(pythons.difference(linuxs))

# 取只报名linux课程的学员: 差集
print(linuxs - pythons)
print(linuxs.difference(pythons))

# 取没有同时报名两门课程的学员:对称差集
print(pythons ^ linuxs)
print(pythons.symmetric_difference(linuxs))

# 是否相等
s1={1,2,3}
s2={3,1,2}
print(s1 == s2)

# 父集:一个集合是包含另外一个集合
s1={1,2,3}
s2={1,2}
print(s1 >= s2)
print(s1.issuperset(s2))

s1={1,2,3}
s2={1,2,4}
print(s1 >= s2)

# 子集
s1={1,2,3}
s2={1,2}
print(s2 <= s1)
print(s2.issubset(s1))






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

s1={1,2,3}
res=s1.pop()
print(res)

s1={1,2,3}
res=s1.remove(3) #单纯的删除,返回值为None
print(s1)

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

s1={1,2,3}
s2={1,2}
s1.difference_update(s2) #s1=s1.difference(s2)
print(s1)

s1={1,2,3}
res=s1.discard(3) ##单纯的删除,返回值为None
print(s1)
print(res)
s1.remove(444444) #删除的元素不存在则报错
s1.discard(444444) #删除的元素不存在不会报错


s1={1,2,3}
s2={1,2,4}
print(s1.isdisjoint(s2)) #如果两个集合没有交集则返回True

s1={1,2,3}
s2={4,5,6}
print(s1.isdisjoint(s2)) #如果两个集合没有交集则返回True

#二：该类型总结
# 1 存多个值
#
# 2 无序
#
# 3 set可变
s={1,2,3}
print(id(s))
s.add(4)
print(id(s))

# 集合去重
# 局限性
#1、无法保证原数据类型的顺序
#2、当某一个数据中包含的多个值全部为不可变的类型时才能用集合去重
names=['alex','egon','alex','alex','egon','lxx']
s=set(names)
print(s)
l=list(s)
print(l)

stus_info=[
    {'name':'egon','age':18},
    {'name':'alex','age':73},
    {'name':'oldboy','age':84},
    {'name': 'egon', 'age': 18},
    {'name': 'egon', 'age': 18},
    {'name': 'egon', 'age': 18},
    {'name': 'oldboy', 'age': 84},

]
# set(stus_info) # 报错
l=[]
for info in stus_info:
    if info not in l:
        l.append(info)

# print(l)
stus_info=l
print(stus_info)