3）文件讀寫追加、函數、入門裝飾器

                           文件讀寫追加、函數、入門裝飾器

 

 

1、文件操做

 1、文件名稱

 2、字符編碼

 3、動做mode、讀寫等。。。

 

 

 f1,文件句柄，file 或者f_handle,f_obj

 open 打開的指令，windows的指令，windows編碼方式默認gbk；linux；utf-8

 

1）打開文件，產生文件句柄

2）操做文件，操做文件句柄

3）關閉文件

 

 

 r全讀  rb非文字類  r+ r+b

w  wb  w+ w+b

a  ab  a+ a+b

 

 

絕對路徑的

f1 = open(r'E:\sss.txt',encoding='gbk')
cot = f1.read()
print(cot)
f1.close()

 

相對路徑

f = open('opg',encoding='gbk')
cot = f.read()
print(cot)
f.close()

 

 

 

1全讀

read

 

一行行讀

2readline

 

f = open(r'opg',encoding='utf-8')
print(f.readline())
print(f.readline())
print(f.readline())
f.close()

 

 

3Readlins：將每一行做爲列表的一個元素並返回這個列表

f = open(r'opg',encoding='utf-8')
print(f.readlines())
f.close()

 

 

以上都很差\

 

四、好的for循環，內存佔的小

f = open(r'opg',encoding='utf-8')
for i in f:
    print(i)
f.close()

 

 

 

Read(n)安照字符去讀的5個指定讀取幾個字符

f = open(r'opg',encoding='utf-8')
content = f.read(5)
print(content)

 

 

#按照非字符的方式去讀用於網絡
f.close()

f = open(r'opg',mode='rb')
content = f.read(5)
print(content)
f.close()

 

 

rb模式去讀 字節去讀取  都用於網路這一塊，非文字的操做

f = open(r'opg',mode='rb')
cot = f.read()
print(cot)
f.close()

往回轉換用decode

f = open(r'opg',mode='rb')
content = f.read(5)
print(content.decode('utf-8')) #轉換回去
f.close()

 

R+ 可讀寫功能

 

內容：

 

 

若是現寫後讀和光標位置有關，光標按照字節運轉

 

調光標位置seek

跳到最後seek(0,2)

 

 

 

 

 

重點：

Unicde----> bytes   encode（）

返回用decode（）

 

 

 

 

試一個

s1 = '中國'
s2 = s1.encode('gbk')
print(s2)

s3 = b'\xd6\xd0\xb9\xfa'
s4 = s3.decode('gbk')
s5 = s4.encode('utf-8')
print(s5)

 

 

簡單方式：

s3 = b'\xd6\xd0\xb9\xfa'.decode('gbk').encode('utf-8')
print(s3)

 

 

 

 

再試一個聯繫：

s1 = '中國'
s2 = s1.encode('gbk')
# s2 = b'\xd6\xd0\xb9\xfa'
s3 = s2.decode('gbk')
s4 = s3.encode('utf-8')
s5 = s4.decode('utf-8')
print(s5,s1)


s1 = '中國'.encode('gbk').decode('gbk').encode('utf-8').decode('utf-8')
print(s1)

 

 

寫

Write

沒有文件自動建立

有文件將源文件內容清空，寫入新內容

 

Wb:

 

 

 

W+ 現寫後讀

 

沒啥用，可是想要這樣要調光標

 

 

 

a 追加  ab

 

 

 

a+追加讀用的很少

沒用

 

 

 

 

Readable:writeable:判斷可讀寫

Seek：調整光標

Tell：告訴指針位置

 

 

Seek(參數)0，2調製最後按照字節調整光標

 

 

 

 

Wich open() as: 文件句柄

with open('opg',encoding='utf-8') as f1:
    print(f1.read())

 

 

能夠套接

with open('opg',encoding='utf-8') as f1,\
        open('log2',encoding='utf-8',mode='w') as f2:
    print(f1.read())
    f2.write('777')

 

 

 

 

文件的改：【步驟】

一、打開元文件，產生句柄

二、建立新文件，產生句柄

三、讀取源文件，進行修改，寫入新文件

四、將原文件刪除

五、新文件重命名元文件

 

#須要os模塊
import os
with open('log2',encoding='utf-8')as f1,\
    open('log2.bak',encoding='utf-8',mode='w')as f2:
    old = f1.read()
    new = old.replace('xxx','777')
    f2.write(new)
os.remove('log2')
os.rename('log2.bak','log2')

 

 

不太好：

這個好哦：一行一行執行，不佔內存

import os
with open('log2',encoding='utf-8')as f1,\
    open('log2.bak',encoding='utf-8',mode='w')as f2:
    for line in f1:
        new_line = line.replace('777','utf-8')
        f2.write(new_line)
os.remove('log2')
os.rename('log2.bak','log2')

 

 

函數：
li = [1,2,3,4,5,'sdf']
count = 0
for i in li:
    count+=1
print(count)


s1 = 'dsfaewadsfdsa'
count1 =0
for i in s1:
    count1 += 1
print(count1)
#代碼重複可執行差

 

 

 

 

簡單方法：

 

sl = 'sdfsadgfgrewfgsav'
def my_len():
    count1 = 0
    for i in sl:
        count1 += 1
    print(count1)
my_len()

'''
def 關鍵字 函數名設定與變量相同：
     函數體
'''

 

 

 

函數的返回值 ：

  return遇到結束函數

def func():
    print(11)
    print(22)
    return
    print(33)
func()

 

給函數的的調用者

s1 = 'sdfqweafadsfads'
def my_len():
    count = 0
    for i in s1:
        count +=  1
    return count
print(my_len())

 

無return 返回none

s1 = 'sdfqweafadsfads'
def my_len():
    count = 0
    for i in s1:
        count +=  1
    # return count
print(my_len())

 

Return不寫或者None

 

 

s1 = 'sdfqweafadsfads'
def my_len():
    count = 0
    for i in s1:
        count +=  1
    return
print(my_len())

 

s1 = 'sdfqweafadsfads'
def my_len():
    count = 0
    for i in s1:
        count +=  1
    return None
print(my_len())

 

若是return返回單個數：

s1 = 'sdfqweafadsfads'
def my_len():
    count = 0
    for i in s1:
        count +=  1
    return 'sss'
print(my_len(),type(my_len()))

 

 

 

Return若是返回多個數值，將放在一個元祖中返回
s1 = 'sdfqweafadsfads'
def my_len():
    count = 0
    for i in s1:
        count +=  1
    return 666,333,'sss','lll'
print(my_len(),type(my_len()))

 

 

 

分別賦值

s1 = 'sdfqweafadsfads'
def my_len():
    count = 0
    for i in s1:
        count +=  1
    return 666,333,count
ret1,ret2,ret3 = my_len()
print(my_len(),type(my_len()))

 

 

函數（）定義的是行參

s1 = 'sdfqweafadsfads'
li = [1,2,3,4,5,'sdfa']

def my_len(a):
    count = 0
    for i in a:
        count+=1
    return count
ret =my_len(s1)
print(ret)

 

函數（）執行的是實參

 

 

從實參角度：

1）、位置參數，一一對應，按照順序

def func1(x,y):
    print(x,y)
func1(1,2)

 

 

def func1(x,y,z):
    print(x,y,z)
func1(1,2,z=8)

 

2）

2）、關鍵字參數，這個不分順序，必須一一對應def func1(x,y,z):
    print(x,y,z)
func1(y=1,z=9,x=7)

 

 

小練習：
def func1(x,y):
    if x >y:
        return x
    else:
        return y
print(func1(100,200))

 

也能夠這樣

 

3）混合參數：--------------關鍵字參數要在位置參數後面

def func1 (argv1,argv2,argv3):
    print(argv1)
    print(argv2)
    print(argv3)
func1(1,2,argv3=5) # 賦值的參數要放在最後

 

 

 

#從形參角度

1）位置參數

2）默認參數：-----------------默認參數必須在位置參數後面

def register(name,sex):
    with open('register',encoding='utf-8',mode='a') as f1:
        f1.write('{}{}\n.'.format(name,sex))
while True:
    name = input('請輸入姓名')
    sex = input('請輸入性別')
    register(name,sex)

def register(name,sex):
    with open('register',encoding='utf-8',mode='a') as f1:
        f1.write('{}{}\n.'.format(name,sex))
while True:
    name = input('請輸入姓名: /q ro Q exit')
    if name.upper() == 'Q':break
    sex = input('請輸入性別')
    register(name,sex)

 

 

def register(name,sex='男'):
    with open('register',encoding='utf-8',mode='a') as f1:
        f1.write('{}{}\n.'.format(name,sex))
while True:
    name = input('請輸入姓名')
    if name.upper() =='Q':break
    if 'a' in name:
        sex = input('請輸入性別')
        register(name,sex)
    else:
        register(name)

 

 

 

 

 

3）動態參數*args  **kwargs

def func2(*args,**kwargs): #萬能參數
    print(args)  #元祖：接受全部位置參數
    print(kwargs) # 字典：關鍵字
func2(1,2,3,4,5,6,'sdf','oosd',a='www',b='sss')

 

  

這個下面在函數執行*交打散，形參加*交聚合

 

若是是**就會把這個位置參數 放到字典當中

 

名稱空間與內存的關係：【全局名稱空間】

 

 

臨時名稱空間：臨時名稱空間，【局部名稱空間】，存入函數裏面的變量與值得關係

隨着函數執行的結束，臨時名稱空間結束

 

【內置名稱空間】

len
ss=len('dsfdsagafsdg')
print(ss)  # 內置名稱空間

 

 

做用域：
全局做用域：包括全局名稱空間，內置名稱空間

局部做用域：局部名稱空間

 

加載順序：

內置名稱空間------------全局名稱空間-------------局部名稱空間（函數執行時）

取值順序：局部名稱空間-----------全局名稱空間-----------內置名稱空間

 

Globals和locals內置函數

Globals：全局名稱空間的變動量放到字典

Locals：局部名稱空間的變量與值放到字典

 

關鍵字：

Global   nonlocal

 

Global：

聲明一個全局變量

 

 

內部名稱空間的能夠應用外部的，可是不能改變，否則會報錯

 

Global做用： 申明一個全局變量，   更改一個全局變量

name = 'lxf'
def func():
    global name
    name = '777'
    return
func()
print(name)

 

 

 

Nonlocal：引用局部變量

 

 

函數名：

一、能夠互相賦值

def func():
    print(666)
f1 = func
f1()

 

2、能夠當成函數參數

def func1():
    print(666)

def func2(argv):
    argv()
    print(777)
func2(func1)

 

 

三、能夠當成容器類數據類型的參數
def f1():

    print('f1')

 

def f2():

    print('f2')

 

def f3():

    print('f3')

 

l = [f1,f2,f3]

d = {'f1':f1,'f2':f2,'f3':f3}#調用l[0]()

d['f2']()

 

五、函數名能夠當成函數返回值

def func1():
    print(666)

def func2(argv):
    print(777)
    return argv
ret = func2(func1)
ret()

 

 

 

閉包函數：內層函數對外層函數非全局變量的應用交閉包：

 

 

def wrapp():
    name = 'lxf'
    def inner():
        print(name)
    inner()
wrapp()

不是閉包：

name = 'sdf'
def wrapp():

    def inner():
        print(name)
    inner()
wrapp()

 

判斷是否是閉包：

是閉包

def warapper():
    name = 'lxf'
    def inner():
        print(name)
    inner()
    print(inner.__closure__)#cell是閉包
warapper()

 

def warapper(argv):
    def inner():
        print(argv)
    inner()
    print(inner.__closure__)#cell是閉包
name = 'lxf'
warapper(name)

 

 

閉包的好處：防止佔內存過大飽滿

若是python檢測閉包，他又一個機制，你的局部做用域不會隨着函數的結束而結束
from urllib.request import urlopen

def index():

    url = "http://www.xiaohua100.cn/index.html"

    def get():

        return urlopen(url).read()

    return get

 

xiaohua = index()

content = xiaohua()

print(content)

 

 

裝飾器：
在不改變元函數及原函數的的調用狀況下，爲原函數增長額外功能，如打印日誌，執行時間、登錄時間
舉個列子：

import time
def func1():
    print('晚上回去吃燒烤')
    time.sleep(0.3)
def func2():
    print('晚上回去喝啤酒')
    time.sleep(0.3)
def timer(f1):
    start_time = time.time()
    f1()
    end_time = time.time()
    print('執行效率是%s'%(end_time - start_time))
timer(func1)
timer(func2)

這個很差改變了源代碼的執行方式。。。。。。。

進行修改在試試：

import time
def func1():
    print('晚上回去吃燒烤')
    time.sleep(0.3)
def func2():
    print('晚上回去喝啤酒')
    time.sleep(0.3)
def timer(f1):
    start_time = time.time()
    f1()
    end_time = time.time()
    print('執行效率是%s'%(end_time - start_time))
f =func1
func1 = timer
func1(f)

換是不太比如以前強一點點。。。。。

import time
def func1():
    print('晚上回去吃燒烤')
    time.sleep(0.3)

def timer(f1):
    def inner():
        start_time = time.time()
        f1()
        end_time = time.time()
        print('執行效率是%s'%(end_time - start_time))
        return inner
func1 = timer(func1)
func1()

最簡單版裝飾器

 

接下來語法堂：

import time
def timer(f1):
    def inner():
        start_time = time.time()
        f1()
        end_time = time.time()
        print('執行效率是%s'%(end_time - start_time))
        return inner
@timer
def func1():
    print('晚上回去吃燒烤')
    time.sleep(0.3)
func1()
@timer
def func2():
    print('晚上回去喝啤酒')
    time.sleep(0.3)
func2()

 

帶參數的裝飾器：

import time
def timer(f1):
    def inner(*args,**kwargs):
        start_time = time.time()
        f1(*args,**kwargs)
        end_time = time.time()
        print('執行效率是%s'%(end_time - start_time))
        return inner
@timer
def func(a,b):
    print(a,b)
    print('晚上回去吃燒烤')
    time.sleep(0.3)
func(111,222)

最終版本的裝飾器：

 

def wrapper(f1):
    def inner(*args,**kwargs):
        ret = f1(*args,**kwargs)
        return ret
    return f1
@wrapper
def func1():
    print(222)
    return 333
print(func1())