Python编程-编码、文件处理、函数

一、字符编码补充知识点

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)