集合类型/数据类型总结/文件处理初步了解

目录

• 集合类型
  • 集合（set）用途
  • 定义方式
  • 数据类型转换
  • 集合set去重
  • 集合set关系运算
    • 1、交集
    • 2、并集
    • 3、差集
    • 4、对称差集 \交叉补集
    • 5、父子集
  • 集合set常用操作
    • 1、set长度
    • 2、成员运算in 和 not in
  • 集合set .方法
    • 1、set.update()
    • 2、set.add()
    • 3、set.remove
    • 4、 set.discard
    • 5、set.pop
    • 6、 set.clear
  • 集合set总结
• 数据类型总结
• 文件处理
  • 引入
  • 文件操作的基本流程
  • 1.1基本流程
  • 1.2资源回收与上下文管理
  • 1.3指定操作文本文件的字符编码

集合类型

集合（set）用途

（1).去重

（2).关系运算

定义方式

在{}内逗号分科开多个元素，集合内元素的特点有三个

（1）每一个元素都是不可变类型

（2）集合内元素不能重复

（3）集合内元素无序、

#s = {11,3.1,"xxx",(1,2,3),}
#如果用集合方式 添加元素  添加可变类型会报错  ，所以说在现有的数据类型当中
可以在集合当中的有 整型、浮点型、字符串、元组   ------>不可变类型
像 列表、字典 都不可以用集合类型-------->可变类型

数据类型转换

# 但凡能被for循环的遍历的数据类型（强调：遍历出的每一个值都必须为不可变类型）都可以传给set()转换成集合类型
>>> s = set([1,2,3,4])
>>> s1 = set((1,2,3,4))
>>> s2 = set({'name':'jason',})
>>> s3 = set('egon')
>>> s,s1,s2,s3
{1, 2, 3, 4} {1, 2, 3, 4} {'name'} {'e', 'o', 'g', 'n'}

集合set去重

集合去重复有局限性

1、只针对不可变类型

2、集合本身是无序的，去重之后无法保存原来的顺序

>>> l=['a','b',1,'a','a']
>>> s=set(l)
>>> s # 将列表转成了集合
{'b', 'a', 1}
>>> l_new=list(s) # 再将集合转回列表
>>> l_new
['b', 'a', 1] # 去除了重复，但是打乱了顺序

#那么我们应该怎么去重复呢？

# 针对不可变类型，并且保证顺序则需要我们自己写代码实现，例如
l=[
    {'name':'lili','age':18,'sex':'male'},
    {'name':'jack','age':73,'sex':'male'},
    {'name':'tom','age':20,'sex':'female'},
    {'name':'lili','age':18,'sex':'male'},
    {'name':'lili','age':18,'sex':'male'},
]

new_l=[]

for dic in l:
    if dic not in new_l:
        new_l.append(dic)

print(new_l)
# 结果：既去除了重复，又保证了顺序，而且是针对可变类型的去重
[
    {'age': 18, 'sex': 'male', 'name': 'lili'}, 
    {'age': 73, 'sex': 'male', 'name': 'jack'}, 
    {'age': 20, 'sex': 'female', 'name': 'tom'}
]

集合set关系运算

交集、并集、差集、对称差集、父子集

pythons ={"william","egon","lili","lxx","xxx"}
linuxs ={"william","egon","lili","lxx","jay","yay","wow"}

1、交集

两个集合之间重复的元素

print(pythons&linuxs)
>>>{'lili', 'egon', 'lxx', 'william'}

#方式二： set.intersection(set)
print(pythons.intersection(linuxs))
>>>{'lxx', 'egon', 'lili', 'william'}

2、并集

两个集合合并到一起

print(pythons|linuxs)
>>>{'jay', 'lxx', 'wow', 'yay', 'xxx', 'william', 'lili', 'egon'}

#方式二  set.union(set)
print(pythons.union(linuxs))
 >>>{'lili', 'jay', 'egon', 'william', 'yay', 'wow', 'lxx', 'xxx'}

3、差集

一个集合见到与另一个集合共同的部分 / 两个集合每个集合内不重复元素 / 该集合不同于另一个集合的所有元素

print(pythons-linuxs)  # “-”左边代表判断该集合的主体  另一边是参考集合
# >>>{'xxx'}    #主体集合与 参考集体差异的元素有哪些
print((linuxs-pythons))
# >>>{'yay', 'jay', 'wow'}

#方式二  set.difference(set)
print(pythons.difference(linuxs))
#>>>{'xxx'}
print(linuxs.difference(pythons))
>>>{'yay', 'jay', 'wow'}

4、对称差集 \交叉补集

两个集合内各自不同于另一个集合 元素合并到一起

res=(pythons -linuxs) | (linuxs-pythons)
print(res)
# >>>{'jay', 'yay', 'xxx', 'wow'}

print(pythons^linuxs)   #简便方法
# >>>{'yay', 'wow', 'jay', 'xxx'}

#方式二 set.symmetric_difference(set)
print(pythons.symmetric_difference(linuxs))
>>>{'yay', 'xxx', 'jay', 'wow'}

5、父子集

当一个集合完全包含另外一个集合的所有元素，称为该集合为另一个集合的父集

这里面的大于等于是指的包含关系

let1={"william",'shidifen','daerwen'}
let2={"william",'shidifen'}
print(let1>=let2)
# >>>True
print(let2<=let1)
# >>>True

集合set常用操作

1、set长度

let1={"william",'shidifen','daerwen'}
print(len(let1))
>>>3

2、成员运算in 和 not in

let1={"william",'shidifen','daerwen'}
print("william" in let1)
# >>>True
print(1 in let1)
# >>>False

集合set .方法

1、set.update()

s1={1,2,3,}
# s1.update({3,4,5})   # 更新集合  会把新集合添加到 原集合中去
# print(s1)
>>>{1, 2, 3, 4, 5}

2、set.add()

s1={1,2,3,}
s1.add(4)    #  添加单个元素 到集合
print(s1)
>>>{1, 2, 3, 4}

3、set.remove

指定元素删除 如果该集合内没有该元素则会报错

s1={1,2,3,}
s1.remove(1)    # 指定元素删除#如果没有会报错
print(s1)  
>>>{2, 3}

4、 set.discard

指定元素删除 该集合内没有该元素也不会报错

s1={1,2,3,}
s1.discard(4)
print(s1)   #指定元素删除  没有不会报错

5、set.pop

在集合中也能有这种方法删除 但是在集合中没有参数选项，不能指定参数，所以就变成了随机删除

6、 set.clear

清空集合

s1={1,2,3,}
s1.clear()
print(s1)
>>>set()

集合set总结

可以存放多个值 值无序 是可变类型

# 存一个值or存多个值
# 多个值
# 有序or无序
# 无序
# 可变or不可变（1、可变：值变，id不变。可变==不可hash 2、不可变：值变，id就变。不可变==可hash）
# 可变

数据类型总结

存储空间占用从低到高

数字
字符串
集合：无序，即无序存索引相关信息
元组：有序，需要存索引相关信息，不可变
列表：有序，需要存索引相关信息，可变，需要处理数据的增删改
字典：无序，需要存key与value映射的相关信息，可变，需要处理数据的增删改

存一个值还是多个值，存多个称做容器

标量／原子类型	数字，字符串
容器类型	列表，元组，字典

按可变不可变

可变类型	不可变类型
列表	整型
字典	浮点型
	字符串
	元组

按访问顺序区分

直接访问	数字
顺序访问	字符串，列表，元组
key值访问（映射类型）	字典

end

文件处理

引入

**1、什么是文件 **

​ 文件时操作系统提供给用户或者应用程序操作硬盘的一种机制

2、为何用文件

读写文件 -------->存取硬盘

3、如何用文件

​ 打开文件

​ 读/写

​ 关闭文件

文件操作的基本流程

1.1基本流程

# open("路径")
f=open(r"路径",mode="rt",encoding="Utf-8")

# 1. 打开文件，由应用程序向操作系统发起系统调用open(...)，操作系统打开该文件，对应一块硬盘空间，并返回一个文件对象赋值给一个变量f
f=open('a.txt','r',encoding='utf-8') #默认打开模式就为r

# 2. 调用文件对象下的读/写方法，会被操作系统转换为读/写硬盘的操作
data=f.read()

# 3. 向操作系统发起关闭文件的请求，回收系统资源
f.close()

1.2资源回收与上下文管理

打开一个文件包含两部分资源：应用程序的变量f和操作系统打开的文件。在操作完毕一个文件时，必须把与该文件的这两部分资源全部回收，回收方法为：

1、f.close() #回收操作系统打开的文件资源
2、del f #回收应用程序级的变量

其中del f一定要发生在f.close()之后，否则就会导致操作系统打开的文件无法关闭，白白占用资源， 而python自动的垃圾回收机制决定了我们无需考虑del f，这就要求我们，在操作完毕文件后，一定要记住f.close()，虽然我们如此强调，但是大多数读者还是会不由自主地忘记f.close()，考虑到这一点，python提供了with关键字来帮我们管理上下文

# 1、在执行完子代码块后，with 会自动执行f.close()
with open('a.txt','w') as f:
    pass 

# 2、可用用with同时打开多个文件，用逗号分隔开即可
with open('a.txt','r') as read_f,open('b.txt','w') as write_f:  
    data = read_f.read()
    write_f.write(data)

1.3指定操作文本文件的字符编码

f = open(...)是由操作系统打开文件，如果打开的是文本文件，会涉及到字符编码问题，如果没有为open指定编码，那么打开文本文件的默认编码很明显是操作系统说了算了，操作系统会用自己的默认编码去打开文件，在windows下是gbk，在linux下是utf-8。
这就用到了上节课讲的字符编码的知识：若要保证不乱码，文件以什么方式存的，就要以什么方式打开。

f = open('a.txt','r',encoding='utf-8')

.....