集合的操作

集合是一个无序的，不重复的数据组合，它的主要作用如下：

去重，把一个列表变成集合，就自动去重了

关系测试，测试两组数据之间的交集，差集，并集等关系

集合的写法

list_1 = set([1, 3, 4, 6, 7, 12, 5])

集合的关系

list_1 = set([1, 3, 5, 7, 4, 9, 10])

list_2 = set([1, 8, 10, 15, 12])

集合的交集

print(list_1.intersection(list_2)) 等价于 print(list_1 & list_2)

--->{1, 10}

集合的并集

print(list_1.union(list_2)) 等价于 print(list_1 | list_2)

-->{1, 3, 5, 7, 8, 4, 9, 10, 15, 12}

集合的差集

print(list_1.difference(list_2)) 等价于 print(list_1 - list_2)

-->{3, 5, 7, 4, 9}

集合的子集

print(list_1.issubset(list_2))

list_1是否是list_2的子集

集合的父集

print(list_1.issuprset(list_2))

list_1是否是list_2的父集

集合的对称差集

print(list_1.symmetric_difference(list_2)) 等价于 list_1 ^ list_2

-->{3, 5, 7, 4, 9, 8, 15, 12}

集合的其他函数用法

list_2.isdisjoint(list_3) #两个无交集返回true

list_1.add(4) #集合的添加

list_1.remove(4) #集合的删除，注意当集合中没有该元素会报错所以我们更多用下这个删除

list_1,discard(4) #删除，没有该元素则什么都不操作

文件的操作

文件的操作流程

1.打开文件，得到文件句柄并赋给变量一个值

2.通过句柄对文件进行操作

3.关闭文件

f = open("guangzhou"， "r", encoding = "utf-8") #文件句柄

data = f.read() #f.readline()读取一行

f.close()

这样就把整个文件给读出来了，假如read()两遍，那么第二个read()会读出空的内容，因为当第一个read()执行完成后，这个时候光标位置就处在文件的结束位置，再进行读取的时候也就读不到内容了。

文件的操作模式

r:读模式，默认是读模式

open("guangzhou"， "r", encoding = "utf-8")

w:写模式，打开文件时时创建一个文件，也就是原来的文件没有了

open("guangzhou"， "w", encoding = "utf-8")

a:追加模式

open("guangzhou"， "a", encoding = "utf-8")  只是不覆盖文件，在文件的后面追加内容，这个模式还不支持读read

r+:读写模式，以读和追加的方式来读写，不管光标位置在哪，都在最后面写

w+：写读模式，只能在最后面写，不能写到中间，这是硬盘机制

a+:追加读

rb:二进制读，用途网路传输，读取音频视频文件

wb:二进制写

文件从一个文件读取并改变内容保存到另外一个文件

f = open("guangzhou", "r", encoding = "utf-8")
f_new = open("guanghzou3", "w", encoding = "utf-8")

#循环读取文件，且这种效率最高，比readlines()高好多
for line in f:
　　if "人在广东已经漂泊十年" in line:
　　line = line.replace("人在广东已经漂泊十年", "Jason在广东已经漂泊两年")
　　f_new.write(line)
f.close()
f_new.close()

文件的其他方法

f = open("guangzhou"， "r", encoding = "utf-8")

f.tell() #返回光标的位置,该返回的位置是字符的位置

f.seek(0) #回到某个光标位置

flush方法

当我们在以写文件的方式打开一个文件的时候，我们执行完一条语句write并不一定写到了硬盘上，它是先存到了内存中，当内存达到一定大小的时候才开始往硬盘上面写，这是因为内存的写速度要比硬盘快的多，但是当某些特定条件下需要实时刷新的话，我们就要用flush进行强制刷新，比如进度条，下面的例子：

import sys, time

for i in range(20):
　　sys.stdout.write("*")
　　sys.stdout.flush()
　　time.sleep(0.1)

自己可以执行下看一下

with语句

为了避免文件打开后忘记关闭，可以通过管理上下文，即：

with open("guangzhou", "r") as f:

2.7版本之后也支持同时对多个文件管理，即：

with open("guangzhou", "r") as f, open("guangzhou2", "r") as f2:

字符编码与转码

字符集发展史

中国字符集发展：gb2312--->gb18030-->gbk

国际字符集发展：ascii(英文占用一个字节，不能存中文)-->unicode(英中占用两个字节)-->utf-8(中文占用3个字节，英文一个字节)

函数与函数式编程

函数的定义方法

def text(x):

　　"The function definitions"

　　x += 1

　　return x

函数可以返回多个值，用元组来返回，比如return 1， 3， “hello”， ["a", "b", "c"], {”name”:"Jason"}  返回其实是（1， 3， “hello”， ["a", "b", "c"], {”name”:"Jason"}）

函数增加参数

def text(x,y):

　　print(x,y)

调用方式：

1.text(1, 2)　　　　　　   -->1,2　　位置参数调用

2.text(x = 2,y = 1)　　　　-->2,1　　关键字参数调用

3.text(2, y = 1)　　　　　 -->2 , 1

4. x = 1,

y = 2

text(x, y)　　　　　　　　-->1, 2

5.text(1, x = 2) 报错，x得到了多个值

6.text(x = 2, 1)报错

综上所述，当既有位置参数又有关键字参数的时候，关键参数的后面不能有位置参数，且不能给多个参数赋值

函数的默认参数

1.参数固定

def text(x, y = 2):

　　print(x,y)

2.参数不固定，接受N个位置参数输出用元组

def text(*args):

　　print(args)

text(1, 2, 3, 4, 6)或者text(*[1, 2, 3, 4, 6])

-->(1, 2, 3, 4, 6) 元组

3.接受N个关键字参数输出字典方式

def text(**kwargs):

　　print(kwargs)

text(name = "Jason", age = 24)　　-->{‘name’:'Jason', 'age':24}

这些参数可以混合使用，比如：

def text(name, *args, **kwargs):

　　print(name)

　　print(args)

　　print(kwargs)

text(“Jason”, 1, 2, 5, name = "Jason", age = 24)

-->Jason

(1, 2, 5)

{'name':"Jason", 'age':24}

函数局部变量与全局变量

在子程序中定义的变量为局部变量，在程序的一开始定的变量为全局变量，全局变量作用域整个程序，局部变量作用域定义该变量的子程序，当全局变量与局部变量同名时，在定义局部变量的子程序中，局部变量起作用，在其他地方全局变量起作用。

在子程序中，变量字符串对全局变量的改变对外面没影响，但是，当全局变量为列表字典集合的时候，这个时候改变会影响整个程序的

高阶函数

变量可以指向函数，函数的参数能接受变量，那么一个函数就可以就收另一个函数作为参数，这种函数称之为高阶函数。