day03 set集合，文件操作，字符编码以及函数式编程

嗯哼，第三天了

我们来get 下新技能，集合，个人认为集合就是用来list 比较的，就是把list 转换为set 然后做一些列表的比较啊求差值啊什么的。

先看怎么生成集合：

 list_s = [1,3,4,5,7,9]
 list_t = [1,3,4,5,7,9]
 dic_1 = {
     'name':'shenyang',
     'age':16
     }
 dic_2 = {'name':'wanglu',
          'age':18,
          'sex':'girl'}

 s = set(list_s)
 t = set(list_t)
 d = set(dic_1)
 n = set(dic_2)
 print(s,type(s))
 print(t,type(t))
 print(d,type(d))
 print(n,type(n))

集合 set  也是无序的：

  以后经常用到的数据类型，两个重要的用处：

  1 可以去重

  2 关系测试

 

我们先来看去重功能：

 

关系测试：

 

 

取出交集

找并集：

找出list1 里有的但是在list2 中没有的

      同样可以找list2 里有的list1里没有的

检查是否是子集

#对称差集  把交集去掉，留两边互相都没有的

检查两个set 是否有交集，有返回False 没有返回True

使用运算符 来测试关系：

添加：

删除：

remove  指定删除  如果不存在会报错  discard 不会报错

pop  随机删除

练习：

 #!/usr/bin/env python3
 s = set([1,3,4,5,7,9])
 t = set([2,3,4,6,8,10])
 #交集
 print(s & t)
 #并集
 print(s | t)
 #差集 有顺序，找出前面有的后面没有的
 print(s - t)
 #对称差集
 print(s ^ t)

 #往集合里添加
 s.add(10) #添加一项
 print(s)
 s.update([13,14,15]) #添加多项
 print(s)
 #删除
 s.pop() #随机删除
 print(s)
 s.remove(13) #删除指定项
 print(s)

 #成员测试
 if 14 in s:
 print("is in")
 if 13 not in s:
 print("is not in")

 

 

文件操作：

 

打开，操作，关闭

 

打开：

open("file_name“)

读：

open("file_name“,encoding="utf-8").read

a = open("file_name“,encoding="utf-8").read

print("a")

打开文件要指定打开文件的模式：

r 读模式 ，默认为读

报错

使用w模式写 会覆盖掉原来的文件

追加模式：  a

加在文件最后  不能读

 实验：
 1 写：
 file1 = open("music.lrc","r",encoding="utf-8")
 r_file1 = file1.read()
 print(r_file1)
 file1.close()
 2 读：
 file1 = open("music.lrc","r",encoding="utf-8")
 r_file1 = file1.read()
 print(r_file1)
 file1.close()
 3 追加：  并不能读
 file1 = open("music.lrc","a",encoding="utf-8")
 file1.write("This is the last write")
 file1 = open("music.lrc","r",encoding="utf-8")
 r_file1 = file1.read()
 print(r_file1)
 file1.close()

一行一行读：

一行一行读，但是也是全部一次性读取 ，并判断：

readlines 会把一行转换为列表的每个元素.

 

比较low 的办法

高级的办法：

真正的一行一行读，内存里只保存1行数据，我们应该忘记上面的方法，这种是最高效的

判断行号，只能自己加一个计数器  高逼格的办法

句柄指针：  是按字符计算的

打印文件的字符编码：

返回操作系统的发开文件的编号

f.fileno()

 

打印文件名字

print(f.name)

 

判断位置是否可移动的

告诉操作系统强制刷入硬盘：

f.flush()

 

打印进度条

不使用flush  会等待缓冲区满了才打印呢，使用flush  每次打印

截断：

截断多少字符，即从0开始保留多少的字符

f.truncate(10)

读写 ：

r+  先读 再写 也是追加

 

写读：  基本没什么卵用

w+   创建新文件再写

 

 

文件读写原理，

只要是写就会覆盖写所在的位置的原来的字符

 

以二进制的格式读取文件：

rb 

 

以二进制格式写

wb

 

修改文件：

 

 实践：
 #!/usr/bin/env python3
 # Auth: Shen Yang
 f1 = open("lrc.db","r",encoding="utf-8")
 f2 = open("lrc2.db","w",encoding="utf-8")
 for line in f1:
     if "王山炮" in line:
         line = line.replace("王山炮","Alex")
     f2.write(line)
 f1.close()
 f2.close()

同时打开多个文件建议换行  \

 

 

 

 

字符编码：

 

unicode 占两个字节 16位

 

utf-8 是 unicode 的一个扩展，

   英文依然以阿斯克码那样存，中文占用三个字节 

+++++++++++++++++++++++++++++++++++++++++++++

 

先decode  并告诉我原来的是什么   然后转换成什么

 

文件头就是制定我的文件是什么编码

 

 

 

 

pyhton 3  默认所有的数据类型就是Unicode   你哈 还是 utf-8  除非你转到gbk 上面的只是说这个文件的编码

python 3 中 encode 不但转换了编码还变成了bytes 格式的

函数式编程：

 

 

编程方法：

1 面向对象

2 面向过程

3 函数式编程

过程就是没有返回值的函数  但是在python 中  隐式的给过程一个结果

 练习：
 import time
 def logger():
     time_format = '%T-%m-%d %X'
     time_current = time.strftime(time_format)
     with open("fun.log","a+",encoding="utf-8") as f:
         f.write("{_format} aadd the log\n".format(_format=time_current))
     time.sleep(0.5)
 def test1():
     print("This is test1")
     logger()
 def test2():
     print("This is test2")
     logger()
 def test3():
     print("This is test3")
     logger()
 test1()
 test2()
 test3()

优点：

1 减少重复代码

2 便于扩展和修改

return  下面的就不再执行

 

return 可以return 任意类型

返回值 是返回一个元组，吧多个值返回到一个元组中

 

 

x y 形参：

不调用，永远不会占用空间

实参：

1 2

实参和形参是一一对应的，按顺序，从左往右一一对应

 

关键字参数，不需要遵循位置：

默认参数：

 

在定义形参的时候先给一个值

默认参数特点：

#用途：

 1 例如软件安装的时候，默认安装就是使用的默认参数

传递非固定实参的时候形参使用以* 开头的任意字符即可但不要这样写，就写args ：

接收字典：

 

**kwargs  ：把n个关键字参数转换成字典方式：

可以以关键字参数一直写下去：

以字典的方式保存参数

默认参数一定要放在** 的前面

*args  接收的是位置参数，接收不到关键字参数

 

**kwargs 接收的是关键字形式参数，接收不到位置参数

局部变量:

只在函数里生效：

里面的改不了

 

 

如果改全局的就需要声明一下

测试：

 name = "yang"
 Job = "Pyther"
 def change_name(name="Lu"):
 #global Job
 Job = "Shell"

 print("name:",name,Job)

 change_name(name="Wang")
 print(name,Job)

 

可以改，但是不要这么用：

=+只

递归函数：

一个没有终点的递归最终会循环999次后报错：  程序的保护机制会自动给停了

def calc(n):
    prin(n)
    return calc(n)

永远循环下去就没了

 

类似镜子里看镜子

 

 

所以递归的特性为：

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

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

 最简单的递归：
 #!/usr/bin/env python3
 # Auth: Shen Yang
 def calc(n):
     print(n)
     if int(n/2) >0:
         return calc(int(n/2))
     print("This is >>",n)
 calc(10)

函数式编程，

所谓函数式编程并不是我们所写的一个函数里面有好多代码，函数式编程里的函数的意思是数学中的函数。

函数式编程语言有 erlang hashshell 等 

 

只要了解以上即可

 

 

高阶函数:

所谓高阶函数就是把一个另一个函数传入函数中做运算

 def add(a,b,f):
     return f(a) + f(b)
 res = add(3,-6,abs)
 print(res)

abs 是一个内置函数用来求绝对值

 

结果是9

 

还没用过。。。

 

 

 

eval(b)  把字符串转为字典