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

一时失言乱红尘 2022-01-06 16:11 140阅读 0赞

# 元组： #

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

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()　　\#删除不存在的值可以不报错

# 数据类型总结： #

按照存值个数区分：