数据类型（下），文件处理（上）

8-3

**dic**
# ======================================基本使用======================================
# 1、用途：

# 2、**定义**方式：
# 在{}内用逗号分割开多个元素，每个元素都是key:value的形式
# 其中value可以是任意类型，而key必须是不可变类型，通常是字符串类型
# dic = {1:111111,33.33:"aaa",(1,2,3):'bbbb'}  # dic =  dict(...)
# print(dic[(1,2,3)])

**# dict数据类型转换**
# dic = dict([('name','egon'),('age',18)])
# print(dic)

# dic = dict(name='egon',age=18,gender='male')
# print(dic)

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

# print(dic.get('name'))
# print(dic.get('name1'))     #不报错，默认返回None

# dic= {'k1':'jason','k2':'Tony','k3':'JY'}
# res=dic.get('xxx',666)       # key不存在时，可以设置默认返回的值
# print(res)
# 666 
# ps:字典取值建议使用get方法

# dic['gender'] = 'male'    #有则改之无则添加
# print(dic)

【>>> dic = {
...     'name': 'xxx',
...     'age': 18,
...     'hobbies': ['play game', 'basketball']
... }
>>> dic['name']
'xxx'
>>> dic['hobbies'][1]
'basketball'】

# setdefault()    #有则不变，无则添加

【# key不存在则新增键值对，并将新增的value返回
>>> dic={'k1':111,'k2':222}
>>> res=dic.setdefault('k3',333)
>>> dic # 字典中新增了键值对
{'k1': 111, 'k3': 333, 'k2': 222}

# key存在则不做任何修改，并返回已存在key对应的value值
>>> dic={'k1':111,'k2':222}
>>> res=dic.setdefault('k1',666)
>>> dic # 字典不变
{'k1': 111, 'k2': 222}】

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

**# 3、成员运算in和not in**
# dic = {'name': 'egon', 'age': 18}
# print('name' in dic)

**# 4、删除**

# 万能删除del
# 删除指定key，与pop相同，不同的是pop是圆括号，del是中括号，另外del可直接删除变量
# dic = {'name': 'egon', 'age': 18}
# del dic['name']   
# print(dic)

# dic.pop()
# 删除指定键值对,因为列表是无序的，所以要通过指定字典的key来删除字典的键值对
# v = dic.pop('name')    
# print(v)

# dic.popitem()
# 随机删除列表中的一条数据，括号中无参数，并将删除的键值放到元组内返回
# res = dic.popitem()
# print(res)

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

>>> dic = {'name': 'egon', 'age': 18}
>>>
>>>
>>> dic.keys()
['age', 'name']
>>>
>>> dic.values()
[18, 'egon']
>>>
>>> dic.items()
[('age', 18), ('name', 'egon')]

**# 6、循环**

# dic = {'name': 'egon', 'age': 18}
# 只遍历key
# for key in dic.keys():
#	    print(key)

# 默认遍历的是字典的key
# for key in dic:
#     print(key)

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

# for k,v in dic.items():
#     print(k,v)

# **需要掌握的操作**
# dic = {'name': 'egon', 'age': 18}
# 用新字典更新旧字典，有则改之，无则添加
# dic.update({'name': "EGON", 'gender': "male"})
# print(dic)
# **kwargs 的用法 **kwargs 允许你将不定长度的 键值对 , 作为参数传递给一个函数。
# 如果你想要在一个函数里处理 带名字的参数 , 你应该使用 **kwargs
>>> dic= {'k1':'jason','k2':'Tony','k3':'JY'}
>>> dic.update({'k1':'JN','k4':'xxx'})
>>> dic
{'k1': 'JN', 'k3': 'JY', 'k2': 'Tony', 'k4': 'xxx'}

# dic = {'name': 'egon', 'age': 18,'level':100}
# 如果level这个key存在于字典中，则什么都不做
# 否则就往字典中添加一组键值对'level':10
# if 'level' in dic:
#     pass
# else:
#      dic['level'] = 10

# v = dic.setdefault('level',10)
# print(dic)
# print(v)

# l = ['name', 'age', 'gender']
# dic = {}
# for x in l:
#     dic[x] = None

# dic = {}.fromkeys(l,None)
# dic['name'].append(111)
# print(dic)

# 练习：
nums = [11, 22, 33, 44, 55, 66, 77, 88, 99, 90]

dic = {'k1': [], 'k2': []}

for num in nums:
    if num > 66:
        dic['k2'].append(num)
    else:
        dic['k1'].append(num)
print(dic)

# 利用集合，去掉重复，减少循环次数
# s='hello alex alex say hello sb sb'
# dic={}
# words=s.split()
# words_set=set(words)
# for word in words_set:
#     dic[word]=s.count(word)

# ======================================该类型总结====================================
# 存多个值
# 无序
# 可变

**set**

#优先掌握的操作：
#1、长度len
#2、成员运算in和not in
#3、|合集
#4、&交集
#5、-差集
#6、^对称差集
#7、==
#8、父集：>,>= 
#9、子集：<,<=

# pythons = ['张三', '李四', '王五', '刘6', 'egon', 'lili', '李建国']
# linux = ['铁蛋', '铜蛋', '钢弹', 'egon', '狗蛋', 'lili']
#
# l = []
# for name in pythons:
#     if name in linux:
#         l.append(name)
# print(l)

# ======================================基本使用======================================
# **1、用途**
# (1) 关系运算
# （2）去重（鸡肋）
# names = ['egon','tom','jack','egon','egon','egon']
# s = set(names)
# print(list(s))

# students_info = [
#     {"name": 'egon', 'age': 18},
#     {"name": 'tom', 'age': 18},
#     {"name": 'jack', 'age': 18},
#     {"name": 'egon', 'age': 18},
#     {"name": 'egon', 'age': 18},
#     {"name": 'egon', 'age': 18},
#     {"name": 'egon', 'age': 18},]
# res = []
#
# for info in students_info:
#     if info not in res:
#         res.append(info)
# print(res)

# **2、定义方式**：在{}内用逗号分隔开多个元素，集合元素的特点如下
#             1、集合内元素不能重复
#             2、集合内的元素必须是不可变类型
#             3、集合内的元素无序

# s = {111,33.333,(1,2,3),111,111,111,111}  # s=set(...)
# print(s)

# set数据类型转换
# print(set('hello'))
# print(set([(1,2,3),[1,2,3,4,5],(1,2,3)]))

**# 3、常用操作+内置的方法**
# 优先掌握的操作：
# 1、长度len
# s = {1,2,3}
# print(len(s))

**# 2、成员运算in和not in**
# s = {1,2,3}
# print(1 in s)

pythons = {'张三', '李四', '王五', '刘6', 'egon', 'lili', '李建国'}
linuxs = {'铁蛋', '铜蛋', '钢弹', 'egon', '狗蛋', 'lili'}

**# 3、|合集: 求所有的同学姓名** (|=shift+\)
# print(pythons | linuxs)
# print(pythons.union(linuxs))

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

# pythons = pythons & linuxs
# pythons.intersection_update(linuxs)

**# 5、-差集: 求只报名了python课程的同学（只存在这个文件，另一个文件中不存在。）**
# print(pythons - linuxs)
# print(pythons.difference(linuxs))
# pythons.difference_update(linuxs)

# print(linuxs - pythons)

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

# s = pythons.symmetric_difference(linuxs)
# print(s)

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

**# 8、父集：>=,子集：<=**
# s1 = {1,2,3}
# s2 = {1,2}
# s2 = {1,2,4}
# print(s1 >= s2)
# print(s1.issuperset(s2))
# 用于判断指定集合的所有元素是否都包含在原始的集合中，是则返回 True，否则返回 False
# print(s2 <= s1)
# 用于判断集合的所有元素是否都包含在指定集合中，如果是则返回 True，否则返回 False
# print(s2.issubset(s1))

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

# s1.remove(22222)         #会报错
# print(s1)

# s1.discard(2222222)      #不报错，默认返回None
# print(s1)

# s1.add(4)
# print(s1)

s2 = {3, 4, 5, 6}
# 用于判断两个集合是否包含相同的元素，如果没有返回 True，否则返回 False
print(s1.isdisjoint(s2))

# ======================================该类型总结====================================
# 存多个值
# 无序
# 可变

集合去重复有局限性
# 1. 只能针对不可变类型
# 2. 集合本身是无序的，去重之后无法保留原来的顺序

**二.去重练习题*****

　　 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']))))

**文件处理**

1什么是文件
    文件是操作系统提供给应用程序或者说用户的一种操作硬盘功能
    应用程序----------》
    操作系统---------》文件
    计算机硬件-------》硬盘

2为何要处理文件
    为了操作硬盘

3如何处理文件

f = open(r'a.txt',mode='rt',encoding='utf-8')
# print(f)

data = f.read()
print(data)

# for line in f:
#     print(line)
    # user,pwd = line.strip('\n').split(':')
    # print(user,pwd)

f.close()

print(f)
f.read()