強調：只有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')) #因為是b二進位制所以要轉碼，這裡用到decode轉碼

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) #在3個位元組後打印出資訊

print(f.tell()) #tell是統計游標在哪裡開始執行

print(f.read())

1： 參照指標當前所在的位置

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

f.read(2) #這裡是2個位元組，因為用到的b

f.seek(4,1)

print(f.tell()) #tell這裡的指標是在6個位元組後執行，2+4 =6個位元組

print(f.read().decode('utf-8'))

2: 參照檔案末尾

with open('a.txt',mode='rb') as f:
f.seek(-5,2) #-5就是游標在尾巴處，往前退5個位元組
print(f.tell()) #這裡游標顯示為9是因為是-5,後退5個位元組，游標所以在為3個字元後面就是9個位元組
print(f.read().decode('utf-8')) #當碰到b 就需要decode轉義下

tail -f access.log

import time

with open('access.log',mode='rb') as f:
f.seek(0,2) #0就是從頭開是，2就是參照尾部
while True:
line=f.readline()
if len(line) == 0: #統計line的個數，如果為空
time.sleep(0.1) #讓系統睡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() #這裡bar沒定義所以執行錯誤

#

foo()

示範二：

def bar():

print('from bar')

#

def foo():

print('from foo')

bar()

#

foo()

#示範三：

定義

def foo():

print('from foo')

bar()

#

def bar():

print('from bar')

呼叫

foo() #這裡不會報錯，因為定義是全部定義好之後在執行foo()

三：定義函式的三種形式

1. 無參函式

def func():

print('from func')

#

func() #什麼是無參函式，就是直接列印，不需要任何東西，func()，括號內是空的這個就是無參函式

2. 有參函式

def max2(x,y):

x=1

y=2

if x > y:

print(x)

else:

print(y)

#

max2(1,2) #有參還是就是(x,y)這個就是有引數，呼叫函式給你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) #表示式函式就是讓return給你一個返回值，讓你去呼叫這個返回值

#

res=len('hello') #其實len就是在呼叫系統內部函式

print(res)

3 函式的呼叫可以當作另外一個函式的引數傳入

def max2(x,y):

if x > y:

return x

else:

return y

#

res=max2(max2(1,2),3) #這裡是函式的return的返回值在呼叫函式，

print(res)

            #首先x=1,y=2 取得2，然後res=max2(2,3)  在進行呼叫，x=2,y=3 取得3

'''

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] #這裡return的返回值是(1, 1.2, 'aaa', [1, 2, 3])，可以是多個值

pass #pass 這裡的return的返回值是none

res=func()

print(res)

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

res=func() #這裡說明，return至返回第一個return，後面2個return就不會執行了，只執行第一個
print(res)

一 函式的引數分為兩大類：

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): #括號內有內容就是位置形參，這裡是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): #這裡因為有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) #這裡x=1,y=2, args=(3, 4, 5, 6) 因為實參多出來了，只能用元祖形式顯示給形參

#

func(1,2,3,4,5,6)

2. 形參中帶：會溢位的關鍵字實參存成字典的格式然後賦值其後變數名

def func(x,y,**kwargs):

print(x,y,kwargs) #這裡因為用了2個*，所以kwargs為{'z': 3, 'm': 1, 'n': 2} 這裡用字典存著

#

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) #這個是正確的做法，因為x=1,y=2,z=3

func(1,z=3,y=2,x=333) #這裡也是錯誤的，因為x=1已經被賦值過了，再次賦值肯定會報錯

func(x=1,2,z=3) # 報語法錯誤，因為預設實參不能跟在關鍵詞實參後面

#2.3 實參中*與**的用法

1. 實參中帶*：先將實參打散成位置實參，然後再與形參做對應

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

#func(1,[2,3]) #報錯，因為少了一個z的實參

func([1,2,3]) #func(1,2,3) #用了的實參就是吧作為位置實參來看待,不會改變裡面實參的位置

#func(*'hello') #func('h','e','l','l','o') #這裡會報錯，因為你給你位置形參太多的值了，超過3個了

func(*'hel') #func('h','e','l') #這裡給三個值，所以x=h,y=e,z=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)