20181127（文件指针，函数相关）

一、文件内指针的移动f.seek

强调：只有t模式下的read（n），n代表的是字符个数，除此以外都是以字节为单位。

with open('a.txt',mode='rt',encoding='utf-8') as f:

res=f.read(4) # 读取前四个字符

print(res)

 

with open('a.txt',mode='rb') as f:

res=f.read(3) # 读取前三个字节

print(res.decode('utf-8')) #将字节解码

 

with open('a.txt',mode='at',encoding='utf-8') as f:

f.truncate(3) #截断a.txt中的内容，取前三个字符。此方法用于从文件的首行首字符开始截断，截断文件为 *个字符，无*表示从当前位置截断；截断之后，后面的所有字符被删除，其中 Widnows 系统下的换行代表2个字符大小。

f.seek():指针移动是以字节为单位

三种模式:只有0模式可以在t\b模式下都可以使用，1，2只能在b模式下使用。

0（默认）：参照文件开头

with open('c.txt',mode='rt',encoding='utf-8') as f:
    f.seek(3,0)
    print(f.tell())   #file.tell() 方法返回文件的当前位置，即文件指针当前位置。
    print(f.read())

1：参照指针当前所在位置

with open('c.txt',mode='rb') as f:
    f.read(2)
    f.seek(3,1)
    print(f.tell())
    print(f.read().decode('utf-8')) #读取的是字节，所以显示的时候需要解码

2：参照文件末尾

with open('c.txt',mode='rb') as f:
    f.seek(-3,2)
    print(f.tell())
    print(f.read().decode('utf-8'))

 

tail -f acces.log小程序：打开文件，指针跳到文件末尾，不停监测是否有新内容，如果有则显示出来。

先建立文件,如access.log:
aaa
bbb
           #文件要直接换一行
再建立一个写入程序，如run.py：
with open('access.log',mode='at',encoding='utf-8') as f:  #文件模式为at(追加，字符串模式)
    f.write('666\n')  # \n为自动换行符，写入之后则自动换行
编写检测程序：
import time   #输入time模块（因为不需要让检测程序一直不停的工作，如果一直不停的循环，CPU占用过多）
with open('access.log',mode='rb') as f:  # 只读模式即可
    f.seek(0,2)  #2即把指针放到文件末尾，0代表指针不做移动
    while True:  #建立循环
        line=f.readline()  #readline从文件读取整行，包括 "\n" 字符，一行一行读取
        if len(line) == 0:   # 行的长度等于0，即表示空，没有新增内容
            time.sleep(0.1)   #计算机休息0.1s
        else:
            print(line.decode('utf-8'),end='')  # 打开是以二进制打开的，所以需要解码过程，且写入程序自带换行符，所以此处打印时，不要再有换行符了
​

 

二、函数

1.什么是函数：组织好的，可重复使用的，用来实现单一或相关联功能的代码块。

在程序具备某一功能的工具=》函数

事先准备好工具=》函数的定义

遇到应用场景，拿来就用=》函数的调用

分成两大类：

①内置函数

②自定义函数

2.为什么用函数

Ⅰ代码冗余

Ⅱ程序的组织结构不清晰，可读性差

Ⅲ扩展性差

 

3.如何用函数

函数的使用必须遵循一个原则：

①先定义 #定义阶段，只检测语法，不执行代码

定义语法：

def 函数名（参1，参2。。。）: #可以没有参数

"""

文档注释

"""

代码1

代码2

。。。

return 值 #可以没有返回值 ，没有return语句相当于返回None

②后调用 #调用阶段，开始执行函数体代码

函数名()

在调用/输出函数之前把相关函数及变量都设置好就可以了。

在定义阶段，只会检测python的语法，不会执行代码。也就是说，只要语法对，就能够定义（至于执行代码时会不会报错再说）。

在调用阶段，才会开始执行函数体代码。

def foo():
    print('from foo')
    bar()
def bar():
    print('from bar')
foo()   #代码能够正常运行，只要在调用代码之前把函数定义正确/完整就可以了。
​
#说明:函数调用可以看作程序执行流程中的一个迂回路径，遇到函数调用时，并不会直接继续执行下一条语句，而是跳到函数体的第一行，继续执行完函数代码块中的所有语句，再跳回原来离开的地方，

 

三、定义函数的三种形式

1、无参函数

def func():
    print('from func')
func()

2、有参函数

def max2(x,y):
    if x > y:
        print(x)
    else:
        print(y)
max2(1,2)

3、空函数

def register():
    pass

 

四、调用函数的三种方式

1、语句形式

def func():
    print('from func')
func()

 

2、表达式形式：有返回值的才行

def max2(x,y):
    if x > y:
        return x
    else:
        return y
res=max2(2,3)
print(res)

 

3、函数的调用可以当做另外一个函数的参数传入

def max2(x,y):
    if x > y:
        return x
    else:
        return y
res=max2(max2(1,2),3)
print(res)

 

五、函数的返回值

1.什么是函数的返回值：

返回值是函数体代码的运行成果

2.为何要有返回值

需要拿到函数的处理结果做进一步的处理，则函数必须有返回值

3.如何用：

return返回值的特点：

Ⅰ返回值没有类型限制，也没有个数限制

return或者函数没return：返回值是None

return值：返回的就是该值本身

return值1，值2。。。返回元组（值1，值2）

Ⅱreturn是函数结束运行的标志，函数内可以有多个return，但只要执行一次函数就会立即结束，并且将return后的值当做本次调用的结果返回

def test():
    print('111')
    return 666
    print('222')
    return gogogo
test()
​
print(test())
#输出结果为：
111
​
111
666

 

六、函数参数的使用

Ⅰ函数的参数分为两大类：

1.形参：在定义函数时括号内指定的参数（变量名），称之为形参

2.实参：在调用函数时括号内传入的值（变量值），称之为实参

二者的关系：在调用函数时，实参值（变量值）会传给形参（变量名），这种绑定关系在调用函数时生效，调用结束后解除绑定。

Ⅱ函数参数详解

1.形参：

1.1位置形参：在定义阶段，按照从左到右的顺序依次定义的形参

特点：必须被传值

def func(x,y,z):
    print(x,y,z)
func(1,2,3)  #正常输出
func(1,2,3,4)  #报错
func(1,2)   #报错

 

1.2默认参数：在定义阶段，就已经为某个形参赋值，该形参称之为默认形参

特点：在定义阶段就已经有值，在调用阶段可以不用为其传值。

注意点：位置形参必须放在默认形参前面，也就是说非默认参数要放在默认参数的前面。

def fuc(x,y,z=666):
    print(x,y,z)
fuc(x=1,y=2)
输出结果为：
1 2 666

1.3形参中*与**的用法：

①形参中带*：*会将溢出的位置实参存成元组的形式然后赋值其后变量名

def func(x,y,*args):
    print(x,y,args)
func(1,2,3,4,5,6)
输出结果为：
1 2 (3, 4, 5, 6)

 

②形参中带**：**会将溢出的关键字实参存成字典的格式然后赋值其后的变量名。

def func(x,y,**kwargs):
    print(x,y,kwargs)
func(1,y=2,z=3,m=1,n=2)
输出结果为：
1 2 {'z': 3, 'm': 1, 'n': 2}

def test(a,*args,**kwargs):
    print a
    print args
    print kwargs
test(1,2,3,d='4',e=5)
输出结果：
1
(2, 3)   #简单说，对于不是键值对的，*args储存成元组。而有=的，则用**kwargs储存成字典
{'e': 5, 'd': '4'}

 

2.实参

2.1位置实参：在调用阶段，按照从左到右的顺序依次传入的值（传值的一种格式）

特点：这种传值方式会与形参一一对应

2.2关键字实参：在调用阶段，按照key=value的格式传值

特点：可以完全打乱位置，但仍然能为指定的形参传值

注意：可以混用关键字实参与位置实参，但是

①同一个形参是能被赋值一次

def fuc(x,y,z):
    print(x,y,z)
fuc(x=1,y=2,z=3)
输出结果为：
1 2 3
​
def fuc(x,y,z):
    print(x,y,z)
fuc(x=1,y=2,z=3,x=66)
输出结果会报错

 

②位置实参必须在关键字实参的前面，否则会报语法错误

def fuc(x,y,z):
    print(x,y,z)
fuc(1,z=3,y=2)
输出结果为：
1 2 3

def fuc(x,y,z):
    print(x,y,z)
fuc(x=1,2,z=3)
输出结果会报错
​
def fuc(x,y,z):
    print(x,y,z)
fuc(1,x=2,z=3)
此种情况也会报错，会显示x被赋值两次

2.3实参中*与**的用法：

①实参中带*：先将实参打散成位置实参，然后再与形参做对应。

def func(x,y,z):
    print(x,y,z)
​
func(1,[2,3])  #会报错
func(*[1,2,3]) #输出结果为1 2 3
func(*'hello') #会报错，因为给了五个值
func(*'hel') #输出h e l

 

②实参中带**：先将实参打散成关键字实参，然后再与形参做对应

def func(x,y,z):
    print(x,y,z)
func(**{'x':1,'z':3,'y':2}) #func(z=3,y=2,x=1)，此处字典key必须与形参名一致!
输出结果为：1 2 3 

3.可变长参数

可变长指的是实参值的个数不固定，而实参有按位置和按关键字两种形式定义。
针对这两种形式的可变长，形参对应有两种解决方案来完整地存放它们，分别是*args，**kwargs

===========*args===========
        def foo(x,y,*args):
            print(x,y)
            print(args)
        foo(1,2,3,4,5)
        输出结果：
        1 2
       (3, 4, 5)
​
        def foo(x,y,*args):
            print(x,y)
            print(args)
        foo(1,2,*[3,4,5])
        输出结果为：
        1 2
   (3, 4, 5)
​
​
        def foo(x,y,z):
            print(x,y,z)
        foo(*[1,2,3])
        输出结果为：
        1 2 3
​
       ===========**kwargs===========
        def foo(x,y,**kwargs):
            print(x,y)
            print(kwargs)
        foo(1,y=2,a=1,b=2,c=3)
        输出结果为：
        1 2
  {'a': 1, 'b': 2, 'c': 3} 
​
        def foo(x,y,**kwargs):
            print(x,y)
            print(kwargs)
        foo(1,y=2,**{'a':1,'b':2,'c':3})
        输出结果为：
        1 2
  {'a': 1, 'b': 2, 'c': 3}
​
        def foo(x,y,z):
            print(x,y,z)
        foo(**{'z':1,'x':2,'y':3})
        输出结果为：
        2 3 1
​
       ===========*args+**kwargs===========
​
        def foo(x,y):
            print(x,y)
​
        def wrapper(*args,**kwargs):
            foo(*args,**kwargs)

 

 

 

转载于:https://www.cnblogs.com/realadmin/p/10028280.html