python编程二编码在使用_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 []: None

from test02 return is []: 0

from test03 return is []: (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)