Day2_元组_字典_集合_字符编码_文件处理

元组：

作用：存多个值，元组不可变，主要用来读

age=(11,22,33,44,55)

print(age[2])　　#取出元组内的值

print(age[1:4])　　#取出元组内的某些值

print(age.index(33))　　#取出33的索引

print(age.count(33))　　#取出值得数量

字典类型：

作用：存多个值，key-value存取，取值速度快。

定义:key必须是不可变类型，value可以是任意类型。

#取出字典的值
info={'name':'yangshuai','age':22,'sex':'male'}
print(info('age'))

重要操作：

*.pop()　　#删除字典内的某个值，括号内输入的是key的值

*.pop('sasadsad',None)　　#当取出某个不存在的值得时候会报错，这样定义可以在取不存在的值得时候输出自定义的值。

*.get()　　#取出字典内的值，括号内输入的是可以的值

*.get('sdasdasd',None)　　#跟get同理

掌握的：

*.popitem()　　#随机弹出一个key-value值

*.keys()　　　　#输出字典的所有的key

*.values()　　#取出字典所有的values

打印字典中的所有值：

定义一个字典dic，　　for key.values in dic.items():　　print(key,values)

*.clear()　　#清空字典

*.formkeys()　　#利用输入的内容快速创建一个字典：　　

　　dic=info.formkeys(['name','age','sex'],1111)　　#注意这样传入的值，所有value都是一样的，只有key是不同的。

*.update()　　#括号内放的是以字典，是将括号内字典的内容更新到旧的字典中，不存在的加入，存在的替换。

另外一种方式创建字典：

　　print(dict([('name','yangshuai'),('age',18),('sex','male')]))

*.setdefault()小练习：

　　#定义一个空字典，加一条用户的详细信息，各种参数加入

d={}
print(d)
d['name']='yangshuai'
d['age']=18
d['sex']='male'
 
#d['hobby']=[]    #多个可以不断变化，最好利用列表来表示
#d['hobby'].append('play basketball')
#d['hobby'].append('paly football')
#当加入字典的一个key对应多个值的时候,需要先定义一个新空列表，一个个往里边加值，这样我们可以利用*.setdefault()这个参数，简写程序。
d.setdefault('hobby',[]).append('paly basketball')
d.setdefault('hobby',[]).append('paly football')
print(d)

字典练习：

　　有如下值集合 [11,22,33,44,55,66,77,88,99,90...]，将所有大于 66 的值保存至字典的第一个key中，将小于 66 的值保存至第二个key的值中。

　　

a={'k1':[],'k2':[]}
c=[11,22,33,44,55,66,77,88,99,90]
for i in c:
    if i>66:
        a['k1'].append(i)
    else:
        a['k2'].append(i)
print(a)

　　统计s='hello alex alex say hello sb sb'中每个单词的个数，结果如：{'hello': 2, 'alex': 2, 'say': 1, 'sb': 2}

s='hello alex alex say hello sb sb'
 
l=s.split()
dic={}
for item in l:
    if item in dic:
        dic[item]+=1
    else:
        dic[item]=1
print(dic)

集合：

作用：去重，关系运算

集合内的可以有多个元素，但是每个元素都是不可变类型，即可hash类型。

集合内的元素唯一

定义：s={1，‘ss’，2，34,2,424}

优先掌握的用法：

判断某个值在不在集合中：　　value in   字典

关系运算：　　

s1={1,10,11,22}
s2={1,11,33}
#求两个交集
print(s1 & s2)
#求两个并集
print(s1 | s2)
#求差集
#只在s1内的，不在s2的
print(s1-s2)
#求不同时在s1和s2的，对称差集
print(s1 ^ s2)
#谁是谁的父集,s1 >= s2
#谁是谁的子集,s1 <= s2
s1={1,2,3,4}
s2={1,2}
print(s1 <= s2)
print(s1 >= s2)

 去重小练习：

　　 1. 有列表l=['a','b',1,'a','a']，列表元素均为可hash类型，去重，得到新列表,且新列表无需保持列表原来的顺序

　　 2.在上题的基础上，保存列表原来的顺序

　　 3.去除文件中重复的行，肯定要保持文件内容的顺序不变
　　 4.有如下列表，列表元素为不可hash类型，去重，得到新列表，且新列表一定要保持列表原来的顺序

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'},
]

#去重,无需保持原来的顺序
l=['a','b',1,'a','a']
print(set(l))
 
#去重,并保持原来的顺序
#方法一:不用集合
l=[1,'a','b',1,'a']
 
l1=[]
for i in l:
    if i not in l1:
        l1.append(i)
print(l1)
#方法二:借助集合
l1=[]
s=set()
for i in l:
    if i not in s:
        s.add(i)
        l1.append(i)
 
print(l1)
 
#同上方法二,去除文件中重复的行
import os
with open('db.txt','r',encoding='utf-8') as read_f,\
        open('.db.txt.swap','w',encoding='utf-8') as write_f:
    s=set()
    for line in read_f:
        if line not in s:
            s.add(line)
            write_f.write(line)
os.remove('db.txt')
os.rename('.db.txt.swap','db.txt')
 
#列表中元素为可变类型时,去重,并且保持原来顺序
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'},
]
# print(set(l)) #报错:unhashable type: 'dict'
s=set()
l1=[]
for item in l:
    val=(item['name'],item['age'],item['sex'])
    if val not in s:
        s.add(val)
        l1.append(item)
 
print(l1)
 
#定义函数,既可以针对可以hash类型又可以针对不可hash类型
def func(items,key=None):
    s=set()
    for item in items:
        val=item if key is None else key(item)
        if val not in s:
            s.add(val)
            yield item
 
print(list(func(l,key=lambda dic:(dic['name'],dic['age'],dic['sex']))))
--摘自老男孩egon笔记

 集合内置方法：

定义集合A，集合B

　　求交集：print(A.intersection(B))

　　求并集：print(A.union(B))

　　求差集：print(A.difference(B))

　　求对称差集（去掉共同部分）：print(A.symmetric_difference(B))

　　A.add()　　#向集合添加值

　　A.pop()　　#随机删除值

　　A.remove()　　#指定删除值

　　A.discard()　　#删除不存在的值可以不报错

　　

数据类型总结：

按照存值个数区分：

　　标量/原子类型：数字，字符串

　　容器类型：列表，元组，字典

按照不可变区分：

　　可变：字典，列表

　　不可变：数字，字符串，元组

按访问顺序区分：

　　访问方式：数字

　　按照索引访问：　字符串，列表，元组

　　按照映射访问：字典