Set 集合
Set是一个无序而且不重复的元素集合。下面看看他有哪些基本功能
创建集合
|
1
2
3
4
5
6
|
>>> s1
=
{
11
,
22
}
s2
=
set
()
s3
=
set
([
11
,
22
,
33
,
4
])
print
(s1,s2,s3)
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
{
11
,
22
}
set
() {
33
,
11
,
4
,
22
}
|
把列表转换成集合，注意列表中重复的元素只保留一次
|
1
2
3
4
5
|
>>> li
=
[
11
,
22
,
11
,
22
]
s1
=
set
(li)
print
(s1)
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
{
11
,
22
}
|
add给集合添加元素，clear清除集合的内容
|
1
2
3
4
5
6
7
8
9
10
11
12
|
>>> s
=
set
()
print
(s)
s.add(
123
)
s.add(
123
)
s.add(
123
)
print
(s)
s.clear()
print
(s)
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
set
()
{
123
}
set
()
|
两个集合A和B可以通过difference进行比较， 他会输出A中存在，而B中不存在的元素
|
1
2
3
4
5
6
7
8
9
10
|
>>> s1
=
{
11
,
22
,
33
}
s2
=
{
22
,
33
,
44
}
s3
=
s1.difference(s2)
print
(s3)
# A中存在，B中不存在
s3
=
s2.difference(s1)
print
(s3)
-
-
-
-
-
-
-
-
-
-
-
-
-
-
{
11
}
{
44
}
|
symmetric_difference 可以输出两个集合中都不相同的元素
|
1
2
3
4
5
6
7
8
|
>>> s3
=
s1.symmetric_difference(s2)
print
(s1)
print
(s2)
print
(s3)
-
-
-
-
-
-
-
-
-
-
-
-
-
-
{
33
,
11
,
22
}
{
33
,
44
,
22
}
{
11
,
44
}
|
如果后面跟了update，那么他的作用是直接替换到A的结果中，比如A中存在，B中不存在的结果是11，difference_update直接替换了A的内容；类似的如果我再执行symmetric_difference_update,他把A和B都不相同的内容保存在A中。
|
1
2
3
4
5
6
7
|
>>> s1.difference_update(s2)
print
(s1)
s1.symmetric_difference_update(s2)
print
(s1)
-
-
-
-
-
-
-
-
-
-
-
-
{
11
}
{
33
,
11
,
44
,
22
}
|
删除某一个元素可以用discard 或者 remove，但是如果该元素不存在，使用discard不会报错；而remove会抛出异常
|
1
2
3
4
5
|
>>> s1
=
{
11
,
22
,
33
,
1111
}
s1.discard(
1111
)
print
(s1)
-
-
-
-
-
-
-
-
-
-
{
33
,
11
,
22
}
|
不报错
|
1
2
|
>>> s1
=
{
11
,
22
,
33
,}
s1.discard(
1111
)
|
抛出异常
|
1
2
3
4
5
6
7
|
>>> s1
=
{
11
,
22
,
33
,}
# s1.discard(1111)
s1.remove(
11111
)
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
Traceback (most recent call last):
File
"<input>"
, line
3
,
in
<module>
KeyError:
11111
|
如果随机的删除一个元素，可以使用pop
|
1
2
3
4
5
6
|
>>> ret
=
s1.pop()
##随机删
print
(s1)
print
(ret)
-
-
-
-
-
-
-
-
-
-
-
-
-
{
11
,
22
}
33
|
求交集（Intersection）和并集（Union）
|
1
2
3
4
5
6
7
8
9
10
|
>>> s1
=
{
11
,
22
,
33
}
s2
=
{
22
,
33
,
44
}
s3
=
s1.union(s2)
print
(s3)
s3
=
s1.intersection(s2)
s1.intersection_update(s2)
print
(s3)
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
{
33
,
22
,
11
,
44
}
{
33
,
22
}
|
update可以把其他的列表，元祖或者字符串的元素都并集进来，当然重复的不会添加
|
1
2
3
4
5
6
7
8
9
10
11
12
13
|
>>> s1
=
{
11
,
22
,
33
}
s1.add(
11
)
s1.add(
12
)
s1.add(
13
)
li
=
[
11
,
22
,
3
,
11
,
2
]
tup
=
(
11
,
22
,
3
,
11
,
2
)
st
=
"alexalex"
s1.update(li)
s1.update(tup)
s1.update(st)
print
(s1)
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
{
33
,
2
,
3
,
'l'
,
'a'
,
11
,
12
,
13
,
22
,
'x'
,
'e'
}
|
小练习：两个字典，请判断出哪些key进行了变化，添加，删除和没变？
思路：把key单独转换成集合，然后通过判断集合元素是否存在判断添加和删除；通过交集判断哪些仍然存在为改变
|
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
|
>>> old_dict
=
{
"#1"
:
8
,
"#2"
:
4
,
"#4"
:
2
,
}
new_dict
=
{
"#1"
:
4
,
"#2"
:
4
,
"#3"
:
2
,
}
new_set
=
set
(new_dict.keys())
old_set
=
set
(old_dict.keys())
remove_set
=
old_set.difference(new_set)
add_set
=
new_set.difference(old_set)
update_set
=
old_set.intersection(new_set)
print
(remove_set,add_set,update_set)
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
{
'#4'
} {
'#3'
} {
'#2'
,
'#1'
}
|
文件的操作
打开文件的模式
-
r ，只读模式【默认】
-
w，只写模式【不可读；不存在则创建；存在则清空内容；】
-
x， 只写模式【不可读；不存在则创建，存在则报错】
-
a， 追加模式【可读； 不存在则创建；存在则只追加内容；】
"+" 表示可以同时读写某个文件
-
r+， 读写【可读，可写】最常用
-
w+，写读【可读，可写】清空之后再写，然后可以读之后写入的内容
-
x+ ，写读【可读，可写】
-
a+， 写读【可读，可写】只能在末尾更改，无法灵活指定位置
"b"表示以字节的方式操作
-
rb 或 r+b
-
wb 或 w+b
-
xb 或 w+b
-
ab 或 a+b
文件相关的函数
-
fread() 无参数，读取全部；有参数，有b，按照字节读；有参数，无b，按照字符读
-
tell()， 获取当前位置（字节）
-
seek(), 调到指定的位置（字节）
-
write(), 写入数据, 有b，按照字节；无b，按照字符写入
-
close(), 关闭文件
-
fileno()，文件描述符，判断文件是否有变化
-
flush()， 强制刷新到内容
-
readable()，判断是否可读
-
readline(),按行读
-
truncate(),截断，清空指针后面的内容
-
for 循环
-
with自动关闭文件
下面看看具体的例子
以只读方式打开一个文件db，注意编码我指定为utf-8，在utf-8里面 一个汉字等于3个字节；而在gbk里面，一个汉字占据2个字节。
|
1
2
3
4
5
6
7
8
|
>>> f
=
open
(
'db'
,
'r'
,encoding
=
"utf-8"
)
data
=
f.read()
print
(data,
type
(data))
f.close()
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
sdf
aa
dddd <
class
'str'
>
|
我用只读字节的方式打开文件
|
1
2
3
4
|
>>> f
=
open
(
'db'
,
'rb'
)
data
=
f.read()
print
(data,
type
(data))
b
'sdf\r\naa\r\ndddd'
<
class
'bytes'
>
|
下面的操作会抛出异常，因为我用字节的方式打开文件，当我尝试用字符串写入的时候，格式不兼容
|
1
2
3
4
5
6
7
|
>>> f
=
open
(
"db"
,
'ab'
)
f.write(
"hello"
)
f.close()
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
Traceback (most recent call last):
File
"<input>"
, line
2
,
in
<module>
TypeError: a bytes
-
like
object
is
required,
not
'str'
|
字节的方式添加信息
|
1
2
3
|
>>> f
=
open
(
"db"
,
'ab'
)
f.write(bytes(
"哈"
,encoding
=
"utf-8"
))
f.close()
|
结果如下
|
1
2
3
|
sdf
aa
dddd哈
|
以读写方式打开文件，指定只读取前2个字符，注意这里没有指定b，因此是按字符读取；否则按照字节读取；tell（）可以获取当前指针的位置（字节）
|
1
2
3
4
5
6
|
>>> f
=
open
(
"db"
,
'r+'
,encoding
=
"utf-8"
)
data
=
f.read(
2
)
print
(data)
print
(f.tell())
#获取当前指针位置（字节）
sd
2
|
首先读取一个包含汉字的文件，如下所示，我指定了编码是utf-8，也指定了b，因此他是按照字符读取；这里他读取前2个字符“幸福”，然后因为utf-8一个汉字字符是3个字节，因此他的位置是6个字节处
|
1
2
3
4
5
6
7
|
>>> f
=
open
(
"db"
,
'r+'
,encoding
=
"utf-8"
)
data
=
f.read(
2
)
print
(data)
print
(f.tell())
-
-
-
-
-
-
-
-
-
-
-
-
-
-
幸福
6
|
如果这个时候我对这个文件做个修改，seek指定位置为第一个字节处，然后向后覆盖7777，这个时候他会把汉字（3个字节）硬拆开，导致的结果就是乱码
|
1
2
3
4
|
>>> f.seek(
1
)
#当前指针位置开始向后面覆盖
f.write(
"7777"
)
f.close()
|
结果如下所示
|
1
2
3
|
7777sdf
aa
dddd哈
|
flush函数强行把内存的数据写入硬盘保存，尽管还没有close
|
1
2
3
4
|
>>> f
=
open
(
'db'
,
'a'
)
f.write(
'123'
)
f.flush()
#没有close 但是内容写入了硬盘
input
(
"hhhh"
)
|
readable顾名思义，判断一个文件是否可读，这里我一个只写方式打开的文件返回False
|
1
2
3
4
|
>>> f
=
open
(
'db'
,
'w'
)
print
(f.readable())
-
-
-
-
-
-
-
-
-
False
|
read()是读取全部，read(x)是读取前x个字节或者字符，而 readline()是读取一行，注意指针位置变化
|
1
2
3
|
f
=
open
(
'db'
,
'r'
)
f.readline()
#注意指针的变化
f.readline()
|
truncate截断，指针后面的内容清空
|
1
2
3
|
>>> f
=
open
(
'db'
,
'r+'
,encoding
=
'utf-8'
)
f.seek(
3
)
f.truncate()
|
结果如下
|
1
|
sds
|
一个很常见的方式是通过for循环来读取每一行的内容，如下所示
|
1
2
3
4
5
6
7
8
|
>>> f
=
open
(
'db'
,
'r+'
,encoding
=
'utf-8'
)
for
line
in
f:
print
(line)
-
-
-
-
-
-
-
-
-
-
-
-
-
sds
2
234
232sd
|
with自动关闭文件，这样不需要手动的使用 f.close()了
|
1
2
|
with
open
(
'db'
) as f:
pass
|
Python2.7以后，可以同时操作两个文件，比如说，只读方式打开文件1，拷贝前10行文件到文件2里面
|
1
2
3
4
5
6
7
8
|
with
open
(
'db1'
,
'r'
,encoding
=
"utf-8"
) as f1,
open
(
'db2'
,
'w'
,encoding
=
'utf-8'
) as f2:
times
=
0
for
line
in
f1:
times
+
=
1
if
times <
=
10
:
f2.write(line)
else
:
break
|
