一、字符编码补充知识点
1.文本编辑器存取文件的原理（nodepad++，pycharm，word）
打开编辑器就打开了启动了一个进程，是在内存中的，所以在编辑器编写的内容也都是存放与内存中的，断电后数据丢失
因而需要保存到硬盘上，点击保存按钮，就从内存中把数据刷到了硬盘上。
在这一点上，我们编写一个py文件（没有执行），跟编写其他文件没有任何区别，都只是在编写一堆字符而已。
2.python解释器执行py文件的原理 ，例如python test.py
第一阶段：python解释器启动，此时就相当于启动了一个文本编辑器
第二阶段：python解释器相当于文本编辑器，去打开test.py文件，从硬盘上将test.py的文件内容读入到内存中
第三阶段：python解释器解释执行刚刚加载到内存中test.py的代码
总结：
（1）python解释器是解释执行文件内容的，因而python解释器具备读py文件的功能，这一点与文本编辑器一样
（2）与文本编辑器不一样的地方在于，python解释器不仅可以读文件内容，还可以执行文件内容
3.python2和python3的区别
（1）在python2中有两种字符串类型str和unicode
（2）在python三种也有两种字符串类型str和bytes
4.encode和decode
字符串在Python内部的表示是unicode编码，因此，在做编码转换时，通常需要以unicode作为中间编码，即先将其他编码的字符串解码（decode）成unicode，再从unicode编码（encode）成另一种编码。
decode的作用是将其他编码的字符串转换成unicode编码，如str1.decode('gb2312')，表示将gb2312编码的字符串str1转换成unicode编码。
encode的作用是将unicode编码转换成其他编码的字符串，如str2.encode('gb2312')，表示将unicode编码的字符串str2转换成gb2312编码。
二、文件处理
1.文件处理流程
（1）打开文件，得到文件句柄并赋值给一个变量
（2）通过句柄对文件进行操作
（3）关闭文件
示例：
f = open('chenli.txt') #打开文件
first_line = f.readline()
print('first line:',first_line) #读一行
print('我是分隔线'.center(50,'-'))
data = f.read()# 读取剩下的所有内容,文件大时不要用
print(data) #打印读取内容
f.close() #关闭文件
正确的打开方式
不指定打开编码，默认使用操作系统的编码，windows为gbk，linux为utf－8，与解释器编码无关
f=open('chenli.txt',encoding='gbk') #在windows中默认使用的也是gbk编码，此时不指定编码也行
f.read()
2.文件打开方式
语法：
文件句柄 = open('文件路径', mode='模式')
打开文件的模式有：
- r ，只读模式【默认模式，文件必须存在，不存在则抛出异常】
- w，只写模式【不可读；不存在则创建；存在则清空内容】
- a， 追加模式【可读； 不存在则创建；存在则只追加内容】
"+" 表示可以同时读写某个文件
- r+， 读写【可读，可写】
- w+，写读【可读，可写】
- a+， 写读【可读，可写】
"b"表示以字节的方式操作
- rb 或 r+b
- wb 或 w+b
- ab 或 a+b
注：以b方式打开时，读取到的内容是字节类型，写入时也需要提供字节类型，不能指定编码
3.文件处理示例
（1）上下文管理
with open('a.txt','r',encoding='utf-8') as f,open('b.txt') as b_f:
print(f.read())
print('====>')
（2）以字节码方式打开文件时的操作
with open('a.txt','rb') as f:
print(f.read().decode('utf-8'))
with open('c.txt','wb') as f:
f.write('哈哈哈'.encode('utf-8'))
（3）文本的方式读不了二进制文件
f=open('sb.jpg','r',encoding='utf-8')
print(f.read())
（4）读取多个文件时的书写格式
with open('sb.jpg','rb') as read_f,\
open('sb_alex.jpg','wb') as write_f:
data=read_f.read()
write_f.write(data)
（5）文件操作技巧
seek(offset,where): where=0从起始位置移动，1从当前位置移动，2从结束位置移动。当有换行时，会被换行截断。seek（）无返回值，故值为None。
tell(): 文件的当前位置,即tell是获得文件指针位置，受seek、readline、read、readlines影响，不受truncate影响
truncate(n): 从文件的首行首字符开始截断，截断文件为n个字符；无n表示从当前位置起截断；截断之后n后面的所有字符被删除。其中win下的换行代表2个字符大小。
readline(n):读入若干行，n表示读入的最长字节数。其中读取的开始位置为tell()+1。当n为空时，默认只读当前行的内容
readlines读入所有行内容
read读入所有行内容
- 数字指的是读的是字符
with open('a.txt','r',encoding='utf-8') as f:
print(f.read(4))
with open('a.txt','rb') as f:
print(f.read(1))
- seek内指定的数字代表字节
- tell指定当前光标所在的位置
with open('a.txt','r',encoding='utf-8') as f:
f.seek(3)
print(f.tell())
print(f.read())
with open('aa.txt','r+',encoding='utf-8') as f:
# f.seek(3)
# print(f.read())
f.truncate(1) #从文件的首行首字符开始截断，截断文件为n个字符
- seek的使用方式
with open('b.txt','rb') as f:
f.read()
f.seek(3) #默认情况，是以文件起始位置作为开始，往后移动3个bytes
f.read(1)
print(f.tell())
f.seek(2,1) # 1 代表以当前光标所在的位置为开始，往后移动2个bytes
print(f.tell())
f.seek(-1,2) # 2 代表以结束光标所在的位置为开始，往后移动2个bytes
print(f.tell())
f.seek(0,2)
with open('c.txt','r',encoding='utf-8') as f:
f.seek(0,2)
print('====>',f.read())
补充知识：
（1）tail命令的输出方式
tail -f access.log
import time
with open('access.log','r',encoding='utf-8') as f:
f.seek(0,2)
while True:
line=f.readline().strip()
if line:
print('新增一行日志',line)
time.sleep(0.5)
（2）for循环结合else的用法
当for循环不被break打断，就会执行else的代码
for i in range(3):
print(i)
# continue
if i == 1:
break
else:
print('=============>')
with open('a.txt','r',encoding='utf-8') as read_f,\
open('aa.txt','w',encoding='utf-8') as write_f:
for line in read_f:
write_f.write(line)
else:
print('write successfull')
i=0
while i< 5:
print(i)
i+=1
if i == 3:
break
else:
print('------>')
三、函数
1.没有函数会有什么问题？
（1）无组织无结构，代码冗余
（2）可读性差
（3）无法统一管理且维护成本高
2.函数和过程
过程定义：过程就是简单特殊没有返回值的函数
当一个函数/过程没有使用return显示的定义返回值时，python解释器会隐式的返回None，所以在python中即便是过程也可以算作函数。
def test01():
pass
def test02():
return 0
def test03():
return 0, 10, 'hello', ['alex', 'lb'], {'WuDaLang': 'lb'}
t1 = test01()
t2 = test02()
t3 = test03()
print('from test01 return is [%s]: ' % type(t1), t1)
print('from test02 return is [%s]: ' % type(t2), t2)
print('from test03 return is [%s]: ' % type(t3), t3)
运行结果：
from test01 return is [<class 'NoneType'>]: None
from test02 return is [<class 'int'>]: 0
from test03 return is [<class 'tuple'>]: (0, 10, 'hello', ['alex', 'lb'], {'WuDaLang': 'lb'})
3.函数分类
（1）内置函数
sum
max
min
a=len('hello')
print(a)
b=max([1,2,3])
print(b)
（2）自定义函数
def print_star():
print('#'*6)
def print_msg():
print('hello world')
print_star()
print_msg()
print_star()
运行结果：
######
hello world
######
4.定义函数
（1）为什么要定义函数？
先定义后使用，如果没有定义而直接使用，就相当于引用了一个不存在的变量名。
foo()
def foo():
print('from foo')
print(foo)
函数定义阶段到底干了什么事情：只检测函数体的语法，并不会执行
（2）函数的使用
函数的使用包含两个阶段：定义阶段和使用阶段
def 函数名(参数1，参数2，...):
"""文档注释"""
函数体
return 值
x=len('hello')
print(x)
（3）定义函数的三种形式
- 无参数函数
如果函数的功能仅仅只是执行一些操作而已，就定义成无参函数，无参函数通常都有返回值
def print_star():
print('#'*6)
- 有参函数
函数的功能的执行依赖于外部传入的参数，有参函数通常都有返回值
def my_max(x,y):
res=x if x >y else y
return res
- 空函数
def auth():
"""认证功能"""
pass
auth()
5.函数参数
（1）函数的参数分类
形参(变量名)，实参（值）
- 形参变量只有在被调用时才分配内存单元，在调用结束时，即刻释放所分配的内存单元。因此，形参只在函数内部有效。函数调用结束返回主调用函数后则不能再使用该形参变量
- 实参可以是常量、变量、表达式、函数等，无论实参是何种类型的量，在进行函数调用时，它们都必须有确定的值，以便把这些值传送给形参。因此应预先用赋值，输入等办法使参数获得确定值
（2）详细的区分函数的参数（五类）
1）位置参数
def foo(x,y,z): #位置形参:必须被传值的参数
print(x,y,z)
foo(1,2,3) #位置实参数：与形参一一对应
2）关键字参数：key=value
def foo(x,y,z):
print(x,y,z)
foo(z=3,x=1,y=2)
关键字参数需要注意的问题：
1：关键字实参必须在位置实参后面
foo(1,x=1,y=2,z=3)
2: 不能重复对一个形参数传值
foo(1,z=3,y=2) #正确
foo(x=1,2,z=3) #错误
3）默认参数
def register(name,age,sex='male'): #形参：默认参数
print(name,age,sex)
register('asb',age=40)
register('a1sb',39)
register('a2sb',30)
register('a3sb',29)
register('钢蛋',20,'female')
register('钢蛋',sex='female',age=19)
默认参数需要注意的问题：
- 默认参数必须跟在非默认参数后
def register(sex='male',name,age): #在定义阶段就会报错
print(name,age,sex)
- 默认参数在定义阶段就已经赋值了，而且只在定义阶段赋值一次
a=100000000
def foo(x,y=a):
print(x,y)
a=0
foo(1)
- 默认参数的值通常定义成不可变类型
4）可变长参数
第一种：*args
*会把溢出的按位置定义的实参都接收，以元组的形式赋值给args
def foo(x,y,*args):
print(x,y)
print(args)
foo(1,2,3,4,5)
运行结果:
1 2
(3, 4, 5)
def add(*args):
res=0
for i in args:
res+=i
return res
print(add(1,2,3,4))
print(add(1,2))
运行结果:
10
3
第二种：**kwargs
**会把溢出的按关键字定义的实参都接收，以字典的形式赋值给kwargs
def foo(x, y, **kwargs):
print(x, y)
print(kwargs)
foo(1,2,a=1,name='egon',age=18)
运行结果：
1 2
{'a': 1, 'name': 'egon', 'age': 18}
def foo(name,age,**kwargs):
print(name,age)
if 'sex' in kwargs:
print(kwargs['sex'])
if 'height' in kwargs:
print(kwargs['height'])
foo('egon',18,sex='male',height='185')
foo('egon',18,sex='male')
运行结果：
egon 18
male
185
egon 18
male
5）命名关键字参数
*后定义的参数为命名关键字参数，这类参数，必须被传值，而且必须以关键字实参的形式去传值
def foo(name,age,*,sex='male',height):
print(name,age)
print(sex)
print(height)
foo('egon',17,height='185')
运行结果：
egon 17
male
185
6.综合使用
def foo(name,age=10,*args,sex='male',height,**kwargs):
print(name)
print(age)
print(args)
print(sex)
print(height)
print(kwargs)
foo('alex',1,2,3,4,5,sex='female',height='150',a=1,b=2,c=3)
运行结果：
alex
1
(2, 3, 4, 5)
female
150
{'a': 1, 'c': 3, 'b': 2}
def foo(*args):
print(args)
foo(1,2,3,4)
*['A','B','C','D'],=====>'A','B','C','D'
foo(*['A','B','C','D']) #foo('A','B','C','D')
foo(['A','B','C','D'])
def foo(x,y,z):
print(x,y,z)
# foo(*[1,2,3]) #foo(1,2,3)
foo(*[1,2]) #foo(1,2)
def foo(**kwargs):
print(kwargs)
#x=1,y=2 <====>**{'y': 2, 'x': 1}
# foo(x=1,y=2)
foo(**{'y': 2, 'x': 1,'a':1}) #foo(a=1,y=2,x=1)
def foo(x,y,z):
print(x,y,z)
# foo(**{'z':3,'x':1,'y':2}) #foo(x=1,z=3,y=2)
foo(**{'z':3,'x':1}) #foo(x=1,z=3)
def foo(x,y,z):
print('from foo',x,y,z)
def wrapper(*args,**kwargs):
print(args)
print(kwargs)
wrapper(1,2,3,a=1,b=2)
def foo(x,y,z):
print('from foo',x,y,z)
def wrapper(*args,**kwargs):
print(args) #args=(1,2,3)
print(kwargs) #kwargs={'a':1,'b':2}
foo(*args,**kwargs) #foo(*(1,2,3),**{'a':1,'b':2}) #foo(1,2,3,b=2,a=1)
# wrapper(1,2,3,a=1,b=2)
wrapper(1,z=2,y=3)
def foo(x,y,z):
print('from foo',x,y,z)
def wrapper(*args,**kwargs):
# print(args) #args=(1,)
# print(kwargs) #kwargs={'y':3,'z':2}
foo(*args,**kwargs) #foo(*(1,),**{'y':3,'z':2}) #foo(1,z=2,y=3)
# wrapper(1,2,3,a=1,b=2)
wrapper(1,z=2,y=3)
7.函数的返回值
def foo():
print('from foo')
return None
res=foo()
print(res)
运行结果：
from foo
None
以下三种情况返回值都为None：
（1）没有return
（2）return 什么都不写
（3）return None
return为一个值时，函数调用返回的结果就是这个值
def foo():
print('from foo')
x=1
return x
res=foo()
print(res)
运行结果：
from foo
1
return 值1,值2，值3,... 返回结果:(值1,值2，值3,...)
def foo():
print('from foo')
x=1
return 1,[2,3],(4,5),{}
res=foo()
print(res)
a,b,c,d=foo()
print(d)
运行结果：
from foo
(1, [2, 3], (4, 5), {})
from foo
{}
参数取值
t=(1,2,3)
a,_,_=t
print(a)
t=(1,2,3,4,5,6,7,8,9)
a,*_,c=t
print(a)
print(c)
运行结果：
1
1
9
8.函数调用
- 按照有参和无参可以将函数调用分两种
foo() #定义时无参，调用时也无需传入参数
bar('egon') #定义时有参，调用时也必须有参数
def foo():
print('from foo')
def bar(name):
print('bar===>',name)
- 按照函数的调用形式和出现的位置，分三种
#调用函数的语句形式
foo()
#调用函数的表达式形式
def my_max(x,y):
res=x if x >y else y
return res
res=my_max(1,2)*10000000
print(res)
#把函数调用当中另外一个函数的参数
res=my_max(my_max(10,20),30)
print(res)