強調：只有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)　　　　截斷,清除之後的字元

f.seek()：指標移動是以位元組為單位的
 

三種模式：只有0模式既可以在t下用也可以在b下用，而1、2兩種模式只能在b模式下使用
0（預設的）：參照檔案開頭
with open('a.txt',mode='rt',encoding='utf-8') as f:
    f.seek(3,0)
    print(f.tell())
    print(f.read())

1：         參照指標當前所在的位置
with open('a.txt',mode='rb') as f:
    f.read(2)
    f.seek(4,1)
    print(f.tell())
    print(f.read().decode('utf-8'))

2:          參照檔案末尾
 

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

tail -f access.log
import time

with open('access.log',mode='rb') as f:
    f.seek(0,2)
    while True:
        line=f.readline()
        if len(line) == 0:
            time.sleep(0.1)
        else:
            print(line.decode('utf-8'),end='')
 




函式的基本使用

1. 什麼是函式
    在程式具備某一功能的工具=》函式
    事先準備好工具=》函式的定義
    遇到應用場景、拿來就用=》函式的呼叫

    分為兩大類：
        1. 內建函式
        2. 自定義函式


2. 為何要用函式
    1. 程式碼冗餘
    2. 程式的組織結構不清晰，可讀性差
    3. 擴充套件性差

3. 如何用函式
    函式的使用必須遵循一個原則：
        1. 先定義
            定義語法：
                def 函式名(參1,參2,參3,...):
                    """
                    文件註釋
                    """
                    程式碼1
                    程式碼2
                    程式碼3
                    ...
                    return 值

        2. 後呼叫
            函式名()



一. 定義階段: 只檢測語法，不執行程式碼
def func():
    print('from func 1')
    print('from func 2')
    print('from func 3')
    print('from func 4')

二. 呼叫階段: 開始執行函式體程式碼
func()
func()
func()

示範一：
def foo():
    print('from foo')
    bar()

foo()


from foo 
示範二：
def bar():
    print('from bar')

def foo():
    print('from foo')
    bar()

foo()

from foo
from bar

示範三：
定義
def foo():
    print('from foo')
    bar()

def bar():
    print('from bar')

呼叫
foo()

from foo 
from bar

三：定義函式的三種形式
1. 無參函式
def func():
    print('from func')

func()

2. 有參函式
def max2(x,y):
    # x=1
    # y=2
    if x > y:
        print(x)
    else:
        print(y)

max2(1,2)
max2(3,4)


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(1000,2000) * 12
print(res)

res=len('hello')
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 返回值的特點：
        1. 返回的值沒有型別限制，也沒有個數限制
            I: return或者函式沒return:返回值None
            II: return 值：返回的就是該值本身
            III: return 值1,值2,值3：返回元組(值1,值2,值3)

        2. return是函式結束執行的標誌，函式內可以有多個return，但只要執行一次函式就立即結束，並且將return後的值當作本次呼叫的結果返回

def func():
    # return 1,1.2,'aaa',[1,2,3]
    pass
res=func()
print(res)


def func():
    print('aaaa')
    return 1
    print('bbb')
    return 2
    print('ccc')
    return 3


func()

一 函式的引數分為兩大類：
1. 形參：在定義函式時括號內指定的引數(變數名)，稱之為形參
2. 實參：在呼叫函式時括號內傳入的值(變數值)，稱之為實參
二者的關係：在呼叫函式時，實參值（變數值）會傳給形參（變數名），這種繫結關係在呼叫函式時生效，呼叫結束後解除繫結
def func(x,y):
    x=1
    y=2
    print(x,y)#

func(1,2)
print(x)
a=1
b=2
func(a,b)

二：函式引數詳解
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 func(x,y=2):
    print(x,y)

func(1)
func(1,3333333)

def register(name,age,sex='male'):
    print(name,age,sex)

register('靚仔',18,)
register('小紅',28,)
register('小黑',38,)
register('花姑娘',16,'female')

def func(y=2,x):
    print(x,y)


1.3 形參中*與**的用法
1. 形參中帶*：*會將溢位的位置實參存成元組的形式然後賦值其後變數名
def func(x,y,*args):
    print(x,y,args)

func(1,2,3,4,5,6)
2. 形參中帶**：**會溢位的關鍵字實參存成字典的格式然後賦值其後變數名
def func(x,y,**kwargs):
    print(x,y,kwargs)

func(1,y=2,z=3,m=1,n=2)

2. 實參
2.1 位置實參: 在呼叫階段，按照從左到右的順序依次傳入的值
特點：這種傳值方式會與形參一一對應
func(2,1,3)

2.2 關鍵字實參: 在呼叫階段，按照key=value的格式傳值
特點：可以完全打亂位置，但仍然能為指定的形參傳值
func(z=3,y=2,x=1)

注意：可以混用關鍵字實參與位置實參，但是
1. 同一個形參只能被賦值一次
2. 位置實參必須跟在關鍵字實參的前面
func(1,z=3,y=2)
func(1,z=3,y=2,x=333)
func(x=1,2,z=3) # 報語法錯誤


2.3 實參中*與**的用法
1. 實參中帶*：先將實參打散成位置實參，然後再與形參做對應
def func(x,y,z):
    print(x,y,z)

func(1,[2,3])
func(*[1,2,3]) #func(1,2,3)
func(*'hello') #func('h','e','l','l','o')
func(*'hel') #func('h','e','l')

2. 實參中帶**：先將實參打散成關鍵字實參，然後再與形參做對應
def func(x,y,z):
    print(x,y,z)

func(**{'x':1,'z':3,'y':2}) #func(z=3,y=2,x=1)


def index(x,y,z):
    print(x,y,z)

def wrapper(*args,**kwargs):  # args=(1,2,3,4,5) kwargs={'c':3,'b':2,'a':1}
    index(*args,**kwargs)   #index(*(1,2,3,4,5),**{'c':3,'b':2,'a':1}) #index(1,2,3,4,5,a=1,b=2,c=3)
                          index(1,z=3,y=2)
wrapper(1,2,3,4,5,a=1,b=2,c=3)

wrapper(1,z=3,y=2)