首页 > 编程语言 > 详细

python修炼第三天

时间:2018-04-20 14:03:03      阅读:161      评论:0      收藏:0      [点我收藏+]

今天主要讲了文件操作,函数与装饰器,装饰器比较烧脑,需要多做练习,逐步分解来进行理解!    加油!

一 文件操作

操作系统 提供文件的概念
可以操作磁盘。

文件的只读模式: 注意如果是windows 前面要加个r:open(r"C:\a.txt") . 或者分隔符是 /
f = open("D:/python21期/L002-老男孩教育-Python20期VIP视频-mp4/b.txt","r",encoding="utf-8")
data = f.read()
print(data)
f.close() # 文件关闭,回收操作系统的资源
print(f) 这个f变量还是存在的因为是python的变量。 python变量是在程序结束后自动释放
f.read() 这个文件已经被操作系统关闭了,所以就无法read读取了。

另一种方法: with open
with open("a.txt","r",encoding="utf-8")
pass
这个是可以帮你自动关闭文件

其他读方法
1 f.readline() 只读取一行
print(f.readline(),end="")
print(f.readline(),end="")
print(f.readline(),end="")

2 readlines() 吧文件都读出来,并全部放在一个列表list里面。
注意:如果文件过大,比如1T文件 就无法进行操作,这个只适用于小文件


文件的只写模式: 默认是wt文本写,如果文件不存在就创建文件,如果存在文件就清空原来的文件!!
f = open("b.txt","w",encoding="utf-8")
f.write(1111\n)
f.write(222222\n)
f.close()

其他写方法:
1 f.write("11111\n")

2 f.writelines 可以通过列表的形式 或元祖的形式 吧多行内容写到文件。
f.writelines(["name\n","age\n","hobbie"])
结果是
name
age
hobbie
########## 注意 如果是wt文本格式打开的那么就只能写字符串格式


1 文件处理
补充
print(f.writable()) 看一下是否是可写的 可写返回True 不可写False
新的写模式:
a 追加模式, 整个文件末尾追加写
f = open("b.txt","a",encoding="utf-8") 文件不存在就新建一个,如果存在就打开文件吧光标移动到文件末尾追加写,原文件内容不影响

读取多行的话 可以使用for
whit open("a.txt","r",encoding="utf-8") as f:
for line in f:
print(line)

b 模式 可以理解为而二进制
rb 二进制读
with open("a.txt","rb‘) as f:
print(f.read().decode("utf-8")) ## 如果是文本内容也存为b二进制模式,可以使用decode解码查看文本

wb 二进制写
with open("a.txt","wb") as f:
res = "添加".encode("utf-8") 二进制写需要进行一下编码编码为二进制写
f.write(res)

ab 追加写
跟上面一样 就是需要encode("utf-8")

练习 ; 实现cp命令 可以拷贝任何类型的文件
import sys
_,src_file,dst_file = sys.argv # sys.argv是获取运行的参数,第一个是cp.py程序文件 第二个是源文件,第三个是目标文件,
# 所以第一个不用获取,_,就可以空出第一个参数,src_file是第二个参数源文件
# dst_file 是第三个参数目标文件。
with open("src_file","rb") as read_f, open("dst_file","wb") as write_f:
for line in read_f:
write_f.write(line)
# 注意内存的数据往硬盘中存建议设置个缓存区,积攒一定的大小猴在往磁盘中写入,减少IO压力
# wirte_f.flush() 这个是告诉操作系统赶快写到磁盘中

文件的修改:
import os
with open("1.txt","r",encoding="utf-8") as read_f,open(".1.txt.swap","w",encoding="utf-8") as write_f:
data = read_f.read()
write_f.write(read_f.replace("alex","SB"))
os.remove("1.txt")
os.rename(".1,txt.swap","1.txt")
这样是吧整个文件都写入到内存中修改,如果文件过大,会导致卡顿,所以可以一行一行的改:
for i in read_f:
if "alex" in i:
i = i.replace("alex","SB")
write_f.write(i)

文件内光标移动
只有一种情况光标指的是以字符为单位移动
with open("c.txt","rt","")as f:
f.read(3)
只有read方式才能以字符方式移动
print(f.tell) 告诉光标在第几个字节。 注意 如果有中文的话 一个中文是3个字节。比如
hello你好
f.read(6)
print(f.tell())
这个结果就是8 因为一个英文是一个字节,中文是三个字节 所以读到第六个字符后,这个光标就在5+3=8的字节上

光标的移动
f.seek
with open("a.txt","rt",encoding="utf-8") as f:
f.read(6)
print(f.tell())
这个时候是光标已经移动到了第6个字符(第8个字节)
f.seek(8,0) # 第一个参数是移动几个字节, 第二个参数有三个模式:0,1,2. 0代表相对的位置参照物,参照文件的最开头开始移动
# seek(8,0) 就是从开头0开始移动 往后移动8个字节。
# 0模式在字符t模式与二进制b模式下都可以使用。另外的 1 2 模式需要在bytes模式才能使用。他们的移动单位都是字节
print(f.read())
结果是打印第8个字节后面的内容。

1模式:
从当前光标开始往后移动。
f.read(6) # 已经移动了6个
f.seek(2,1) # 从当前第6个光标继续往后移动2个
print(f.read())
结果是6+2个字节,也是打印第8个字节后面的内容。

2模式:
从文件最末尾为参考开始移动。倒着移动
f.seek(-3,2)
print(f.read())
从文件最后往前移动3个字节,如果文件最后是一个中文,那就只打印这个中文

实现 tail -f access.log
with open("access.log","rb") as f:
f.seek()
while True:
line = f.readline()
if line:
print(line)
else:
time.sleep(0.5)
注意 二进制b模式不翻译\n换行符。 字符t模式翻译\n 如果文本内容有\n换行符,二进制b模式print(line.decode(),end="")
end="" 就是把print自带的空格取消。 如果文本内容中没有\n换行符,哪就直接使用print(line) 就可以了


截断文件
截断模式只能是 a 模式下使用:
with open("a.txt","a",encoding="utf-8") as f:
f.truncate(3) # 只有从文件开头为参照物。3代表截取3个字节
#就是只截断前三个字符



2 函数

  1函数基础
为何要用函数?没有函数带来的困扰
1 组织结构不清晰,可读性差
2 代码冗余
3 可扩展性差

什么是函数?
具备某一个功能的工具-->函数
函数就是事先准备的工具
工具准备好了 ,拿来就可以用。重复使用
先定义,后调用。

函数的分类?
内置函数:
help(函数名) 这个就是查看函数下面的注释信息 参考语法1
len
max
mix
count
自定义函数:def 自定义函数
定义函数
语法:
def 函数名(参数1,参数2):
""" 注释信息""" # 可选
函数体,功能体
return 返回值
(其实函数就是一个变量,只不过可以调用)
所以执行函数分为两步,第一步是通过函数名找到这个函数变量,找到函数就可以用()来调用。
定义阶段:
定义函数只检测语法是否问题,不定义代码。

调用函数:
先定义后调用。
调用函数,如果函数中定义的变量等功能没有或其他问题就会报错。
列子:

def foo():
print(‘from foo")
bar()
foo()
第一次调用会出现问题,因为bar函数没有定义,所以需要再定义一个bar函数
def bar():
print("from bar")
foo()
这次就可以了。 注意先定义后调用原则。

定义函数的三种形式:
1:无参函数
def foo()
print("我是无参数函数")
2:有参函数
def auth(u,p):
if u =="root" and p == "123":
print("login successfull")
else:
print("user or password err")
def interactive()
name = input("请输入账号:").strip()
password = input("请输入密码:").strip()
auth(name,password)
3:空函数
def auth():
pass
在写应用的时候,针对每个功能定义一个函数。空函数就是先一个框架。站个位置。

函数的返回值:
# 函数内可以有多个return 但是只能执行一个return。
def foo(x,y)
print("first")
return 1
print("second")
return 2
print("third")
return 3
res=foo()
print(res) 结果是first 1 因为执行遇到return后就退出了。先运行程序,然后在输出返回值

# 执行return函数就立刻结束,并且return后的值当做本次调用的结果返回。
def foo(x,y):
retrue x+y
res = foo(1,2)

可以返回函数:
def bar();
print("from bar")
def foo():
return bar()
print(foo())

没有return 没有return 返回的是 None print(foo)是打印函数内存地址, print(foo())是返回执行结果
返回一个值return 就返回值本身。
return多个值 返回的是一个元祖格式。

函数调用的三种形式:
def my_mix(x,y):
if x >=y:
return x
else:
reture y
第一种: 单独使用
res1 = my_max
第二种: 把函数返回值的结果进行运算
res2 = my_max(1,2)*10
第三种: 函数调用可以当作另外一个函数的参数
res3 = foo(my_max(1,2),aa)

函数参数的使用
1.参数种类:两种
1 形参 def foo(x,y) 在定义阶段在括号内是形参, 形参在定义阶段是不占内存空间的
2 实参 foo(1,2) 在调用阶段括号内传入的值叫实参, 相当于值
在调用阶段,实参的值会绑定给形参,在调用结束后解除绑定 。
2.位置参数
按照从左到右的顺序依次定义的参数。
1 位置形参:必须被传值,多一个少一个都不行。
2 位置实参:与形参一一对应传值。
def foo(x,y)
print(x,y)
foo(y=1,x=1)
3.关键字参数
在函数调用时,按照key=value的形式定义的实参
特点:指名道姓地给形参传值,不再依赖于位置
注意:
def foo(name,age,sex):
print(name,age,sex)
注意: 1关键字实参必须在位置实参的后面。
2不能为同一个参数赋多次值。

4.默认参数
1 指的是在函数定义阶段,就已经为形参复制。
def foo(x,y=1):
print(x,y)
默认参数的好处就是可以不用传值,当然也可以传值来修改默认参数的值
2 默认参数的值只在定义时被复制一次
res = 1
def foo(x,y=res):
print(x,y)
res = 10
foo("aaaa")
结果是 "aaaa" 1
3 默认参数的值通常应该是不可变类型。 要么是数字,要吗是元祖

5.可变长参数*args, **kwargs
在调用函数时,实参值得个数不固定
实参的形式有:位置实参和关键字实参。
就是实参两个形式的长度个数是不固定。
形参的解决方案: * 和 **
* 是位置实参解决方案
** 是关键字key value解决方案
1 *args
位置的实参会保存为元祖的形式保存
def foo(x,y,*z):
print(x,y)
print(z)
foo(1,2,3,4,5,6)
结果是吧1给x 2给y *接收后面的然后以元祖形式赋值给z3,4,5,6给z
1,2
( 3,4,5,6 )
另一种
def foo(x,y):
print(x,y)
foo(*(1,2))
结果是1,2
2 **kwargs
def foo(x,y,**kwargs):
print(x,y)
foo(x=1,y=2,i=3,l=4)
这种情况*会接收i=3,l=4 并赋值给kwargs 保存为字典 格式。
另一种
def foo(x,y,**kwargs)
foo(y=2,**{"c":5,"b":6,"x":2})
3 应用场景
def bar(x,y,z):
print(x,y,z)
def wrapper(*args.**kwargs):
bar(*args,**kwargs)
wrapper(1,2,3,a=1,b=2,c=2)
这样就会报错,因为wrapper接收参数后,传给bar,然后bar 通过* 与**原封不动的解析回
一开始传给wrapper的参数,所以bar就会报错。无法赋值。

6.命名关键字参数
指的是定义在*后的参数,该参数必须被传值(除非他有默认值),而且必须按照key=value的形式传值。

三 函数进阶

(1)名称空间:
1 名称空间
2 局部名称空间
3 内置名称空间

1 名称空间,或命名空间
运行时开辟出来,里面存的是变量与值内存地址的关系

2 临时名称空间
比如定义了一个函数
def func():
name = "wustr"
age = 23
函数名存放到内存空间中
但是函数体中的变量没有管。
当遇到函数执行的时候,他会通过函数名找到函数体里面的变量然后
临时开辟出一个内存空间,就是临时命名空间,也叫局部名称空间,然后
吧函数里面的变量与值得关系存入到临时命名空间里面
然后随着函数的执行结束,临时名称空间的内存就消失。释放。

3 内置名称空间
只要创建了py文件 解释器就会吧内置名称空间加载到内存中了。内置函数就可以使用了
比如:len()

(2)作用域:
1 全局作用域:全局名称空间,内置名称空间
2 局部作用域:局部名称空间

(3)加载顺序,取值顺序
加载顺序:内置名称空间先加载到内存。然后是全局名称空间加载到内存,最后是局部名称空间(只有函数执行时才加载)
取值顺序:
函数先从局部作用域取值,如果没有在找全局作用域,如果还没有就找内置名称空间。也就是从内向外找。
而且只是单向的,找到最后没有就没了

globals locals 内置函数
globals 将全局命名空间打印出来
locals 将局部命名空间打印出来

global nonlocal 关键字
global
函数里面可以使用全局命名空间的变量。但是不能改变。如果要改变需要使用global关键字声明全局变量

nonlocal 声明全局变量,如果存在就更改全局变量。
引用并改变上一层的局部变量。上一层同层的变量都会改变。


(4)函数名:
1 可以相互赋值
def fun1():
print(666)
f1 = func1
f1()

2 可以当成函数的参数
def func2():
print(111)
def func3(argv):
argv()
print(222)
func3(func2)

3 可以当成容器类数据类型的参数
def func11():
print(222)
def func22():
print(333)
def func33():
print(444)
ll = ["func11","func22","func33"]
for i in ll:
i()

4 可以当作函数的参数和返回值
def func():
print(666)
def func1(argv)
print(777)
return argv
res = func1(func)
res()

(5)闭包:
内层函数对外层函数非全局变量的引用
def wrapper():
name = "alex"
def inner():
print((name)
inner()
wrapper()

判断是不是闭包 inner.__closure__
如果是返回cell 不是返回 None
好处是:如果python检测是闭包。有一个机制,你的局部作用域不会随着函数的结束而结束。
比如爬虫,爬下来的数据,使用闭包可以吧爬下来的数据保存到内存中,下次再爬直接从内存中取
import urlopen,url
def index():
url = "http://www.xiaohua100.com/index.html"
def get():
return urlopen(url).read()
return get
index()()

四 装饰器

    函数对象
函数是第一类对象:指的是函数可以当作数据传递
1 可以被引用 x=1,x=y
def func(x,y):
print(x,y)
f=func
f(1,2)

2 可以当作函数的参数传入
def foo():
print("form foo")
def bar(x):
x():
bar(foo)
3 可以当作函数的返回值
4 可以当作容器类型的元素

后续内容待补。。。

 

python修炼第三天

原文:https://www.cnblogs.com/liyunjie/p/8890375.html

(0)
(0)
   
举报
评论 一句话评论(0
关于我们 - 联系我们 - 留言反馈 - 联系我们:wmxa8@hotmail.com
© 2014 bubuko.com 版权所有
打开技术之扣,分享程序人生!