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()
以上都不好\
4、好的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')
文件的改：【步骤】
1、打开元文件，产生句柄
2、创建新文件，产生句柄
3、读取源文件，进行修改，写入新文件
4、将原文件删除
5、新文件重命名元文件
#需要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：引用局部变量
函数名：
1、可以互相赋值
def func():
print(666)
f1 = func
f1()
2、可以当成函数参数
def func1():
print(666)
def func2(argv):
argv()
print(777)
func2(func1)
3、可以当成容器类数据类型的参数
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']()
5、函数名可以当成函数返回值
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())
原文地址：http://blog.51cto.com/xiaorenwutest/2104378
