>>>a = [1,2,3,4,5]

 >>>b = [4,5,6,7,8]

 >>>a_set = set(a)

 >>>b_set = set(b)

 >>>rint(a_set.intersection(b_set))

 >>>print(a_set.intersection(b_set),type(a_set.intersection(b_set)))

 >>>{4, 5} <class 'set'>#可以看出字典和集合都是{}，先将a和b都转成集合，然后求出交集（它们两都有的）

 >>>a = [1,2,3,4,5]

 >>>b = [4,5,6,7,8]

 >>>a_set = set(a)

 >>>b_set = set(b)

 >>>print(a_set.union(b_set))

 >>>a = [1,2,3,4,5]

 >>>b = [4,5,6,7,8]

 >>>a_set = set(a)

 >>>b_set = set(b)

 >>>print(a_set.difference(b_set))#(前后存在顺序问题，a里面有的b里面没有的（有---没有）)

 >>>print(b_set.difference(a_set))#b里面有的a里面没有

 >>>a = [1,2,3,4,5]

 >>>b = [4,5,6,7,8]

 >>>a_set = set(a)

 >>>b_set = set(b)

 >>>print(a_set.issubset(b_set))

 >>>print(b_set.issubset(a_set))

 >>>False

 >>>False

 >>>a = [1,2,3,4,5]

 >>>b = [4,5,6,7,8]

 >>>a_set = set(a)

 >>>b_set = set(b)

 >>>print(a_set.issuperset(b_set))

 >>>print(b_set.issuperset(a_set))

 >>>False

 >>>False

 >>>a = [1,2,3,4,5]

 >>>b = [4,5,6,7,8]

 >>>a_set = set(a)

 >>>b_set = set(b)

 >>>print(a_set.symmetric_difference(b_set))

 >>>{1, 2, 3, 6, 7, 8}

a = [1,2,3,4,5]

b = [4,5,6,7,8]

a_set = set(a)

b_set = set(b)

print(a_set.isdisjoint(b_set))#前后两者存在交集就返回False，没有交集就打印True

解释：

    isdisjoint是判断a和b是否存在交集，如果存在返回False，不存在交集返回Trun

 >>>a = [1,2,3,4,5]

 >>>a_set = set(a)

 >>>print(a_set)

 >>>a_set.add(55)#一次只能添加一个元素，否则会报错

 >>>print(a_set)

 >>>a = [1,2,3,4,5]

 >>>a_set = set(a)

 >>>print(a_set)

 >>>a_set.update('','lei','lei')

 >>>print(a_set,type(a_set))

 >>>{1, 2, 3, 4, 5}

 >>>{1, 2, 3, 4, 5, '', 'e', 'l', 'i'} <class 'set'>#通过结果不难看出集合天然去重

 >>>a = [1,2,3,4,5]

 >>>a_set = set(a)

 >>>print(a_set)

 >>>a_set.remove(1)#一次只能删除一个，否则会报错

 >>>print(a_set,type(a_set))

>>>a = [1,2,3,4,5]

>>>a_set = set(a)

>>>b_set = a_set.copy()

>>>print(a_set,type(a_set))

>>>print(b_set,type(b_set))

>>>{1, 2, 3, 4, 5} <class 'set'>

>>>{1, 2, 3, 4, 5} <class 'set'>

 >>>a = [1,2,3,4,5]

 >>>a_set = set(a)

 >>>b_set = a_set.pop()#随机删除，并返回删除的元素

 >>>print(a_set,type(a_set))

 >>>print(b_set)

 >>>{2, 3, 4, 5} <class 'set'>

 >>>1

 >>>a = [1,2,3,4,5]

 >>>a_set = set(a)

 >>>b_set = a_set.discard(5)

 >>>print(a_set)

 >>>print(b_set)

 >>>{1, 2, 3, 4}

 >>>None#有的话删除后并返回一个None

 >>>就算没有，不报错，也只会返回一个None

f = open("yesterday",'w',encoding="utf-8")#文件句柄（放到了内存什么位置）

f.write("哈哈哈")#写入内容，如果没有该文件就自动创建

f.close#(关闭文件)

>>>with open("yesterday","w",encoding='utf-8') as data:#读写完后自动关闭,因为windows上默认的编码是gbk，所以需要转换成utf-8

       data.write("哈哈哈")

r，只读模式（默认）。

w，只写模式。（不可读；不存在就自动创建；存在则删除内容）

a，追加模式。（可读；   不存在则创建；存在则只追加内容）

"+" 表示可以同时读写某个文件

r+，可读写文件。【可读；可写；可追加】

w+，写读

a+，同a

"U"表示在读取时，可以将 \r \n \r\n自动转换成 \n （与 r 或 r+ 模式同使用）

rU

r+U

"b"表示处理二进制文件（如：FTP发送上传ISO镜像文件，linux可忽略，windows处理二进制文件时需标注）

.readlines(读成一个列表，所有内容)#默认每行之间有空行因为有\n，用strip（）就行
  .readline（默认一次只读一行）
  .seek#位置0是开始
  .tell#打印当前位置
  .encoding#当前编码
  .readable#文件是否可读
  .writeable#是否可写
  .flush#默认是等内存缓存满了才写入，强刷读一条直接写入硬盘

 #!/usr/bin/env python

 #—*—coding:utf-8—*—

 with open("yesterday","r",encoding='utf-8') as data_1 , \

     open("yesterdaybak","w",encoding='utf-8') as data_2:#读写完后自动关闭

     for line in data_1.readlines():

         if "中国石油" in line:

             line = line.replace("中国石油","中国石化")

         data_2.write(line)

yesterday#文件更改前

新浪

百度

中国石油

yesterdaybak#更改后文件内容

新浪

百度

中国石化

打开文件yesterday（windows上），内容如下

新浪

百度

中国石油

>>>with open("yesterday","r") as data:

>>>    for line in data:

>>>        line = line.strip('\n')

>>>        print(line)

报错：

UnicodeDecodeError: 'gbk' codec can't decode byte 0xad in position 18: illegal multibyte sequence

解释：

      我们知道utf-8是unicode的扩展，windows上默认编码是gbk，按照上图所示打开文件的时候我们需要将gbk转码直接解码（encoding）成utf-8。

      如果是python2,.x的话，如果编码格式是gbk，我们首先需要将gbk转码成unicode，然后再将unicode解码（encoding）成utf-8。

 >>>def func():

 >>>    print("你好中国！")

 >>>func()

>>>def func():#1>>#3(首先python程序通过关键字发现这是个函数)（当执行完func（）时候又到了这里）

>>>    print("你好中国！")#4（最后才执行到这里）

>>>func()#2（然后从上往下，这里执行了上面的函数）

 #默认参数

 def func(x,y):#这里的x和y只是形参（形式参数）

     print(x)

     print(y)

 func(1,2)#这里是实参（实际参数，就是真真切切要往函数体里面传的参数）

 #1对应x，2对应y，也就是说实参合形参是平行对应的，否则打印出的效果就相反了。形参和实参不能多也不能少，否则报错。

 #关键参数

 def func(x,y,z):

     print(x)

     print(y)

     print(z)

 func(x= "中国",y="北京",z = "海淀")

 #这样的话就没有了顺序的问题，只是要求形参和实参一定要对应，不能多，也不能少

 #默认参数和关键参数混用

 def func(x,y,z=""):#默认参数和关键参数混合使用的时候，关键参数必须在最后

     print(x)

     print(y)

     print(z)

 func(1,2,z='')#默认参数和关键参数混合使用的时候，关键参数必须在最后。

 #如上，z，如果如果没有给传实际参数，默认使用形式参数赋的值，如果实参给了就用实参的参数。

 #非固定参数（万能参数）

 def func(*args):#*是关键指定不可变，args是名称可以更改

     print(args[0])

     print(args,type(args))

 func(1,2,3,4)#通过结果可看出*传进去的是元祖

 >>>1

 >>>(1, 2, 3, 4) <class 'tuple'>

 #非固定参数（万能参数**kwargs）

 def func(**kwargs):

     print(kwargs,type(kwargs))

 func(Name = '中国',Age = '上下五千年')

 #**因为**输出的是字典，所以传值得时候一定是类似xxx = yyyy形式。

 name = "china"

 def func(*args,**kwargs):

     name = "beijing"#注意，局部变量是存在于函数体内的变量，全局变量是不在任何一个函数体内的变量

     print(name)#如果局部变量和全局变量同时存在的话，优先使用局部变量

     print(args)

     print(kwargs)

 func(1,2,3,age = "上下五千年")

 #更改全局变量

 name = "china"

 def func(*args,**kwargs):

     global name#引用全局变量的name

     print(name)#打印结果肯定是china

     name = "Beijing"#修改，这里有点像如果引用一个变量，首先从函数体内找，如果函数体内没有就找全局变量

     print(name)

     print(args)

     print(kwargs)

 func(1,2,3,age = "上下五千年")

 >>>china

 >>>Beijing

 >>>(1, 2, 3)

 >>>{'age': '上下五千年'}

 要想获取函数的执行结果，就可以用return语句把结果返回

 注意:

 函数在执行过程中只要遇到return语句，就会停止执行并返回结果，so 也可以理解为 return 语句代表着函数的结束

 如果未在函数中指定return,那这个函数的返回值为None 

定义：在函数内部，可以调用其他函数。如果一个函数在内部调用自身本身，这个函数就是递归函数。

#函数的递归

def info(n):

    print(n)

    if int(n/2) > 0:

        return  info(int(n/2))

    print(">>>>",n)

info(10)

结果：

10

5

2

1

>>>> 1

递归特性:

1. 必须有一个明确的结束条件

2. 每次进入更深一层递归时，问题规模相比上次递归都应有所减少

3. 递归效率不高，递归层次过多会导致栈溢出（在计算机中，函数调用是通过栈（stack）这种数据结构实现的，每当进入一个函数调用，栈就会加一层栈帧，每当函数返回，栈就会减一层栈帧。由于栈的大小不是无限的，所以，递归调用的次数过多，会导致栈溢出）

def add(x,y,f):#实参将3和-6传给形参

    return f(x) + f(y)#返回值首先将3和-6取绝对值（那就是3和6），再相加，结果肯定是9

res = add(3,-6,abs)#abs是内置函数，让的定义简单里面就是去绝对值

print(res)