一、文件操作

  文件操作链接:http://www.cnblogs.com/linhaifeng/articles/5984922.html(更多内容见此链接)

一、对文件操作流程

  1. 打开文件,得到文件句柄并赋值给一个变量
  2. 通过文件句柄对文件进行操作
  3. 关闭文件

二、文件操作

  1、范例

 #打开
f=open('a.txt',mode='r',encoding='utf-8')
# 读/写
data=f.read()
print(data)
#关闭
del f #回收Python的资源
f.close() ##回收操作的资源

  2、文件操作的流程分析

  • 向操作系统发起系统调用
  • 操作系统打开这个文件,返回一个文件句柄给应用程序
  • 在应用程序中把文件句柄赋值给一个变量

  3、注意两点

  1、打开一个文件对应两部分,一个是Python级别的文件句柄,另一个是操作系统打开的文件(默认打开文件的编码是以操作系统的编码为准的,除非open()指定encoding='编码')
  2、当文件操作完毕后,应该回收两部分资源:
  del f #回收应用程序资源(Python解释器自动的垃圾回收机制已经处理完毕)
  f.close #回收操作系统的资源

三、文件处理:with语句

  with open('a.txt',mode='r',encoding='utf-8') as f:
print(f.read())

  1、文本类文件操作,操作模式t(text),可省略

    1、r 是默认的文件操作模式,只读,文件不存在则报错
  with open('a.txt',mode='r',encoding='utf-8') as f:
print(f.readlines()) #读所有行,结果放入列表中(适用于小文件)
print(f.readline(),end='') #读一行,去掉后面的换行符
print(f.read()) #读所有:bytes---->decode('utf-8')---->str
    2、w 只写模式,若文件存在则清空,若文件不存在则新建
  with open('b.txt',mode='w',encoding='utf-8') as f:
f.write('11111\n') #写一行 :unicode---->encode(utf-8)---->bytes
f.writelines(['881899\n','文件\n','qiiqwhuq']) ##写多行
    3、a 追加写模式,若文件存在则把光标已到文件末尾,若文件不存在则新建
  with open('c.txt',mode='a',encoding='utf-8') as f:
f.write('1899\n')
f.writelines(['OK\n','权限\n'])

  2、文本类文件操作,操作模式b类型:以bytes的形式去操作文件内容,不能指定编码(不然会报错):可以操作任何类型的文件以读取图片为例

  with open('weiduoliya.jpg',mode='rb') as f:
print(f.read()) with open('d.txt',mode='wb') as f:
f.write('alex最牛\n'.encode('utf-8')) with open('d.txt',mode='ab') as f:
f.write('engon最棒\n'.encode('utf-8'))

四、打开文件的模式

  下面的模式可以自由组合

  • ‘r' open for reading (default)
  • ‘w' open for writing, truncating the file first
  • ‘a' open for writing, appending to the end of the file if it exists
  • ‘b' binary mode
  • ‘t' text mode (default)
  • ‘+' open a disk file for updating (reading and writing)
  • ‘U' universal newline mode (for backwards compatibility; should not be used in new code)
#. 打开文件的模式有(默认为文本模式):
r ,只读模式【默认模式,文件必须存在,不存在则抛出异常】
w,只写模式【不可读;不存在则创建;存在则清空内容】
a, 之追加写模式【不可读;不存在则创建;存在则只追加内容】 #. 对于非文本文件,我们只能使用b模式,"b"表示以字节的方式操作(而所有文件也都是以字节的形式存储的,使用这种模式无需考虑文本文件的字符编码、图片文件的jgp格式、视频文件的avi格式)
rb
wb
ab
注:以b方式打开时,读取到的内容是字节类型,写入时也需要提供字节类型,不能指定编码 #. 了解部分
"+" 表示可以同时读写某个文件
r+, 读写【可读,可写】
w+,写读【可读,可写】
a+, 写读【可读,可写】 x, 只写模式【不可读;不存在则创建,存在则报错】
x+ ,写读【可读,可写】
xb

五、操作文件的方法

#掌握
f.read() #读取所有内容,光标移动到文件末尾
f.readline() #读取一行内容,光标移动到第二行首部
f.readlines() #读取每一行内容,存放于列表中 f.write('1111\n222\n') #针对文本模式的写,需要自己写换行符
f.write('1111\n222\n'.encode('utf-8')) #针对b模式的写,需要自己写换行符
f.writelines(['333\n','444\n']) #文件模式
f.writelines([bytes('333\n',encoding='utf-8'),'444\n'.encode('utf-8')]) #b模式 #了解
f.readable() #文件是否可读
f.truncate #_ 截取文件
f.writable() #文件是否可读
f.tell()  #告知光标所在的位置
f.truncate #截取文件,以字节为单位
f.seek   #指定光标移动到某个位置
f.closed #文件是否关闭
f.encoding #如果文件打开模式为b,则没有该属性
f.flush() #立刻将文件内容从内存刷到硬盘
f.name

六、文件内光标移动

  一: read(3):

    1. 文件打开方式为文本模式时,代表读取3个字符

    2. 文件打开方式为b模式时,代表读取3个字节

  二: 其余的文件内光标移动都是以字节为单位如seek,tell,truncate

  注意:

    1. seek有三种移动方式0(文件开头),1(当前位置),2(文件末尾),其中1和2必须在b模式下进行,但无论哪种模式,都是以bytes为单位移动的

    2. truncate是截断文件,所以文件的打开方式必须可写,但是不能用w或w+等方式打开,因为那样直接清空文件了,所以truncate要在r+或a或a+等模式下测试效果

七、文件的修改 

  open的参数全部写上,操作多个文件时,可以换行(避免一行内容过多)

  文件的数据是存放于硬盘上的,因而只存在覆盖、不存在修改这么一说,我们平时看到的修改文件,都是模拟出来的效果,具体的说有两种实现方式:

  方式一:将硬盘存放的该文件的内容全部加载到内存,在内存中是可以修改的,修改完毕后,再由内存覆盖到硬盘(word,vim,nodpad++等编辑器)

import os

with open('a.txt') as read_f,open('.a.txt.swap','w') as write_f:
data=read_f.read() #全部读入内存,如果文件很大,会很卡
data=data.replace('alex','SB') #在内存中完成修改 write_f.write(data) #一次性写入新文件 os.remove('a.txt')
os.rename('.a.txt.swap','a.txt')

  方式二:将硬盘存放的该文件的内容一行一行地读入内存,修改完毕就写入新文件,最后用新文件覆盖源文件

import os

with open('a.txt') as read_f,open('.a.txt.swap','w') as write_f:
for line in read_f:
line=line.replace('alex','SB')
write_f.write(line) os.remove('a.txt')
os.rename('.a.txt.swap','a.txt')

八、实战

  1、bool值 :所有数据类型都自带bool值

  • 布尔值为假的情况 0 空 None
  • #真默认返回True ,假默认返回False
  x = 1
# print(bool(x))
if x:
print('ok')

  2、循环文件

  with open('a.txt',encoding='utf-8') as f:
#不推荐使用:消耗资源(磁盘IO)
lines = f.readlines() #一下读取所有内容
for line in lines:
print(line,end='')
#推荐使用:读取一行,打印一行内容
for line in f:
print(line,end='')

二、函数

一、函数简介

 1、为什么要用函数?换句话讲不用函数,会怎么样?

  1. 组织结构混乱,可读性差
  2. 代码冗余(重复的代码比较多)
  3. 无法统一管理,维护难度极大

 2、什么叫做函数?使用原则?

  函数:具有某一功能的工具

  使用原则:先定义,后调用

#定义阶段
def tell_tag():
print('===========') def tell_msg(msg):
print(msg) #调用阶段
tell_tag()
tell_msg('hello world')

 3、函数分类

  1、内置函数:Python解释器自带的函数,Python解释器启动就会定义好这些函数

例如:len(),min(),max()

  2、自定义函数:根据需要用户自己定义的函数(函数名和函数体是必须有的

def 函数名(参数1,参数2,...):
"""注释"""
函数体
return 返回值

二、函数的定义阶段

  在定义阶段,只检测语法,不执行代码

  函数的定义,将相当于在定义一个变量;若没有定义而直接调用,就相当于没有在引用不存在的变量名。

 1、怎么定义函数

 def foo():
xyz
print('')
return 1
print('')
return 2

 2、函数的原则:先定义后调用

 #测试1
def foo():
print('from foo')
bar() ##bar没有定义就调用,错误
foo() # 测试2 正确
def bar():
print('from bar')
def foo():
print('from foo')
bar()
foo() # 测试3 下面的也不会报错,
###定义阶段
def foo():
print('from foo')
bar()
def bar():
print('from bar')
#调用阶段
foo()

 3、定义函数的三种形式

 无参:应用场景——只执行一些操作,例如:打印等等
有参:需要根据外部传进来的参数,才能执行相应的逻辑,例如比较大小,统计数量
空函数:设计代码结构
 def main():
while True:
user=input('>>:').strip()
# if len(user) == 0:continue #若长度为0,下面的代码不执行
if not user:continue
password=input('>>:')
res=auth(user,password)
if res:
print('login sucessful')
else:
print('login error')

无参

 def auth(user,pwd):
if user == 'egon' and pwd == '':
return True
else:
return False main()

有参:函数体的代码,需要外部传入的值

 def select(sql):
#注释:输入'''''',回车自动输出下面的格式
'''
查询功能
:param sql:
:return:
'''
pass

空函数:定义完函数,不输入函数体内容,直接输入pass

三、调用函数

 1、调用函数

函数的调用:函数名加括号
先找到名字找到函数的内存地址,然后根据名字调用代码

 2、函数的返回值

什么时候该有返回值?
    调用函数,经过一系列的操作,最后要拿到一个明确的结果,则必须要有返回值
    通常有参函数需要有返回值,输入参数,经过计算,得到一个最终的结果
什么时候不需要有返回值?
    调用函数,仅仅只是执行一系列的操作,最后不需要得到什么结果,则无需有返回值
    通常无参函数不需要有返回值

  需要注意以下的第一点:

在调用函数的过程中,一旦执行到return,就会立刻终止函数,并且把return后的结果当做本次调用的返回值返回
#函数体内可以有多个return,但是只能执行一次
 def test():
print('test1')
# return 1
print('test2')
return 2
print('test3')
return 3
res=test()
print('函数调用完毕',res)

  需要注意第二点:

返回的值,可以是任意类型
 #msg={'name':'wzs','sex':'male'}
msg=['wzs','egon']
def test():
print('test1')
return msg
res=test()
print('函数调用完毕',res)

  需要注意的第三点:

没有返回值 —— 返回None
不写return
只写return:结束一个函数的继续
return None —— 不常用
返回1个值
可以返回任何数据类型
只要返回就可以接收到
如果在一个程序中有多个return,那么只执行第一个
返回多个值
用多个变量接收:有多少返回值就用多少变量接收
用一个变量接收: 得到的是一个元组(touple)
 def test():
return None
res=test()
print('函数调用完毕',res,type(res))
print('函数调用完毕',res)

 3、调用的三种方式

1 语句形式:foo()
2 表达式形式:3*len('hello')
3 当中另外一个函数的参数:range(len('hello'))

三、函数的参数

 1、形参与实参

形参:在定义阶段,括号内定义的参数。就相当于变量名
实参:在调用阶段,括号内定义的参数。就相当于变量值
在调用阶段,实参的值会绑定给形参,在调用结束后,解除绑定

 2、参数的分类

    1、位置参数
    位置形参:必须被传值的参数,多少都不行
位置实参:从左到右依次赋值给形参
 def foo(x,y):
print(x,y)
foo(1,3)
    2.关键字参数:在函数调用阶段,按照key=value的形式定义实参
    特性:
1、可以不依赖位置而指明参数给形参传参
2、可以与位置实参混用,需要注意:
1)位置参数必须在位置参数前面
2)不能为一个形参重复传值
 def foo(x,y):
print(x,y) # foo(y=2,x=3)
# foo(3,y=2)
# foo(1,2,y=3) 错误
    3、默认参数(形参):在函数定义阶段,已经为形参赋值了,意味着调用阶段可以不传值
    注意的问题:
1、默认参数的值,只在定义阶段,赋值一次
2、位置形参应该默认参数的前面
3、默认参数的值应该是不可变类型(数字,字符串,元组)
 def foo(x,y):
print(x,y)
foo(1,y=3) 应用场景:学员注册
def resister(name,age,sex='male'):
print(name,age,sex) resister('wzs',20)
resister('xiaoyu',27,'female') x='male'
def resister(name,age,sex=x):
print(name,age,sex) x='female' #
resister('wzs',20) #只在定义阶段,赋值一次
resister('xiaoyu',27,'female') def resister(name,sex='male',age): #错误:位置形参必须在默认参数前面
print(name,age,sex) resister('wzs',20)
resister('xiaoyu',27,'female')
    4、可变长参数:实参值的个数是不固定的
    实参定义形式有两种:1、位置实参 2、关键字实参
针对这种形式的实参个数不固定,相应的,形参也要有两种解决方案
位置实参:* 关键字实参:**
针对按照位置定义的溢出的那部门实参,形参:*args  *后面的是变量名,可以随便定义但以args
 def func(a,b,c,*args):
print(a,b,c)
print(args) func(1,2,3)
func(1,2,3,4,5,57)
func(1,2,3,*[4,5,57]) ##见到*将列表内容打散func(1,2,3,4,5,57)
func(*[1,2,3,4,5,57]) ##func(1,2,3,4,5,57)
# func([1,2,3,4,5,57]) #func(1,2,3,4,5,57) ##这个是错误的

 针对按照关键字定义的溢出的那部分实参,形参:**kwargs

 def foo(x,y,**kwargs): #kwargs={'a':1,'z':3,'b':2}
print(x,y)
print(kwargs) foo(y=2,x=1,z=3,a=1,b=2)
# foo(1,2,3,z=3,a=1,b=2) #赋值不全
foo(y=1,x=2,**{'a':1,'b':2,'c':3}) #foo(x=2,y=1,c=3,b=2,a=1)
# foo(**{'x':1,'a':1,'b':2,'c':3}) #foo(x=1,c=3,b=2,a=1) #少一个y def foo(x,y,z):
print(x,y,z) dic={'x':1,'y':3,'z':1}
foo(**dic) #foo(x=1,y=3,a=1) def home(name,age,sex):
print('from home====>',name,age,sex) def wrapper(*args,**kwargs): #args=(1,2,3,4,5,6,7),kwargs={'c':3,'b':2,'a':1}
home(*args,**kwargs)
# home(*(1,2,3,4,5,6,7),**{'c':3,'b':2,'a':1})
#home(1,2,3,4,5,7,a=1,b=2,c=3) # wrapper(1,2,3,4,5,6,7,a=1,b=2,c=3)
wrapper('egon',sex='male',age=19)
    5、命名关键字参数(了解)
    形参中,在*后定义的参数
特性:传值时,必须按照关键字实参的形式传值

 def func(a,b=100,*args,c=1,d):
print(a,b,c,d)
print(args) func(10000,d=10)
func(10,10000,1,45,555,c=1100,d=8999)
这五种参数的排列顺序为:位置参数,默认参数,*args,命名关键字参数,**kwargs

四、函数对象

  函数是第一类对象:函数可以当做数据来使用

# 1、可以对调用
def func():
print('from func') f=func
print(f) ##返回函数的内存地址
f()
# 2、可以当做参数传入一个函数
def wrapper(x):
print(x)
x()
wrapper(func)
# 3、可以当做函数的返回值
def wrapper():
return func
f1=wrapper()
print(f1 is func)
# 4、可以当做容器类型的一个元素
l=[func,1,2] ##当列表的一和元素
print(l) #打印列表
print(l[0]()) ##取出函数这个元素,并执行函数

  通过此特性可以取代if..elif ...else

 def insert(sql):
print('insert功能: ', sql) def update(sql):
print('update功能: ', sql) def delete(sql):
print('delete功能: ', sql) def alter(sql):
print('alter功能:',sql) func_dic={
'select':select,
'update':update,
'insert':insert,
'delete':delete,
'alter':alter
} def main():
while True:
inp=input('>>: ').strip()
if not inp:continue
sql=inp.split()
cmd=sql[0]
# if cmd == 'select':
# select(sql)
# elif cmd == 'update':
# update(sql)
# elif cmd == 'insert':
# insert(sql)
# elif cmd == 'delete':
# delete(sql)
if cmd in func_dic:
func_dic[cmd](sql)
else:
print('command not found') main()

五、嵌套函数

 1、函数的嵌套调用:在调用一个函数的过程中,又调用另外一个函数

#比较四个数字,找出最大值(两两比较大小)
def max2(x,y):
if x > y:
return x
else:
return y def max4(x,y,z,o):
res1=max2(x,y)
res2=max2(res1,z)
res3=max2(res2,o)
return res3
res=max4(100,111,222,9888)
print(res)

 2、函数的嵌套定义:在定义一个函数内部,又定义一个函数(函数只能同级调用)

def f1():
def f2():
def f3():
print('from f3')
f3()
x=1
f2()
print(x)
f1()

三、名称空间和作用域

一、名称空间:存放名字与值绑定关系的地方

    内置名称空间
存放的是:内置的名字和值的绑定关系:内置函数len
生效:Python解释器启动
失效:Python解释器关闭
全局名称空间(文件级别)
存放的是:文件级别定义的名字和值的绑定关系
生效:执行Python文件时,将该文件级别定义的名字和值的绑定关系存在
失效:文件执行完毕
局部名称空间
存放的是:函数内部定义的名字和值的绑定关系
生效:调用函数时,临时生效??
失效:函数调用结束
  加载顺序:
    先内置,再全局,最后局部
  查找名字的顺序:
    先局部,再全局,最后内置

二、作用域

  作用域:http://www.cnblogs.com/z360519549/p/5172020.html

全局作用域:
包含内置名称空间的名字与全局名称空间的名字
特点:全局存活,全局有效 局部作用域:
包含局部名称空间的名字
特点:临时存活,局部有效
 x=
def f1(a):
y='abcdefg'
print(locals())
print(globals()) ##在全局作用域 locals() is globals()
print(globals())
print(locals() is globals())
# f1()
作用域关系
  在函数定义时,已经固定,与调用无关
 x=1000000000
def f1():
def f2():
x=819892011921818
print(x)
# f2() #全局变量,局部临时生效
return f2
f=f1()
# print(f)
# print(x) ##返回变量的值是全局的定义值 def func():
x=123
# f()
x='hello'
func()

  查看作用域 global(),local()

名字查找顺序:locals -> enclosing function -> globals -> __builtins__
python引用变量的顺序: 当前作用域局部变量->外层作用域变量->当前模块中的全局变量->python内置变量 。
locals 是函数内的名字空间,包括局部变量和形参
enclosing 外部嵌套函数的名字空间(闭包中常见)
globals 全局变量,函数定义所在模块的名字空间
builtins 内置模块的名字空间
 global关键字用来在函数或其他局部作用域中使用全局变量。但是如果不修改全局变量也可以不使用global关键字
声明全局变量,如果在局部要对全局变量修改,需要在局部也要先声明该全局变量:(使用global)
在局部如果不声明全局变量,并且不修改全局变量。则可以正常使用全局变量
nonlocal关键字用来在函数或其他作用域中使用外层(非全局)变量 :只能用于局部变量,找离当前函数最近一层的局部变量

Python基础学习——文件操作、函数的更多相关文章

  1. Day3 Python基础学习——文件操作、函数

    一.文件操作 1.对文件操作流程 打开文件,得到文件句柄并赋值给一个变量 通过文件句柄对文件进行操作 关闭文件 #打开文件,读写文件,关闭文件 http://www.cnblogs.com/linha ...

  2. python基础篇(文件操作)

    Python基础篇(文件操作) 一.初始文件操作 使用python来读写文件是非常简单的操作. 我们使用open()函数来打开一个文件, 获取到文件句柄. 然后通过文件句柄就可以进行各种各样的操作了. ...

  3. python基础之文件操作,函数

    文件操作 +模式: r+t  w+t  a+t  r+b   w+b  a+b 可读可写,其他功能与人,r,w,a相同 f.seek(offset,whence) 文件指针移动    offest的单 ...

  4. 跟着ALEX 学python day3集合 文件操作 函数和函数式编程 内置函数

    声明 : 文档内容学习于 http://www.cnblogs.com/xiaozhiqi/  一. 集合 集合是一个无序的,不重复的数据组合,主要作用如下 1.去重 把一个列表变成集合 ,就自动去重 ...

  5. python基础之文件操作

    对于文件操作中最简单的操作就是使用print函数将文件输出到屏幕中,但是这种操作并不能是文件保存到磁盘中去,如果下调用该数据还的重新输入等. 而在python中提供了必要的函数和方法进行默认情况下的文 ...

  6. python基础14_文件操作

    文件操作,通常是打开,读,写,追加等.主要涉及 编码 的问题. #!/usr/bin/env python # coding:utf-8 ## open实际上是从OS请求,得到文件句柄 f = ope ...

  7. python基础学习1-内置函数

    #!/usr/bin/env python # -*- coding:utf-8 -*- 系统内置函数 n =abs(-1) #绝对值 print(n) #bytes()函数 s="离开&q ...

  8. Python基础--基本文件操作

    全部的编程语言都一样,学完了一些自带的数据机构后,就要操作文件了. 文件操作才是实战中的王道. 所以,今天就来分享一下Python中关于文件的一些基本操作. open方法 文件模式 这个模式对于写入文 ...

  9. python基础(10):文件操作

    1. 初识文件操作 使⽤python来读写⽂件是非常简单的操作.我们使⽤open()函数来打开⼀个⽂件,获取到⽂ 件句柄,然后通过⽂件句柄就可以进⾏各种各样的操作了,根据打开⽅式的不同能够执⾏的操 作 ...

随机推荐

  1. NOI数论姿势瞎总结(Pi也没有)

    Miller-Rabin素数检测 费马小定理:没人不会吧. 二次探测:如果\(n\)是质数,\(x^2 \equiv 1\ (\mod n)\)的解只有\(x \equiv 1\)或\(x \equi ...

  2. 导数与微分简单总结(updated)

    只讲一些导数在OI中的简单应用,特别基础的东西,不会很详细也不会很全面. 导数的定义 设函数\(y=f(x)\)在点\(x_0\)的某个邻域内有定义,当自变量\(x\)在\(x_0\)处有增量\(Δx ...

  3. 广工2017校赛-F-- tmk找三角

    http://gdutcode.sinaapp.com/problem.php?cid=1056&pid=5 Description 有一棵树,树上有只tmk.他在这棵树上生活了很久,对他的构 ...

  4. 利用 IntelliJ IDEA 进行代码对比的方法

    Sometimes,我们会有这样的需求,即:想对比出两个不同版本代码的区别.如何实现? 第 1 种:如果我们是从 SVN 检出的项目,并且想比较本地代码与从 SVN 检出时的代码相比都有那些区别,可以 ...

  5. PHP CI 框架简单使用(二)

    我们简单认识一下CI框架的MVC.示例代码如下 //CI控制器文件Home.php <?php defined('BASEPATH') OR exit('No direct script acc ...

  6. ImportError: bad magic number in: b'\x03\xf3\r\n'

    解决办法:删除项目中所有的 .pyc 文件.

  7. redis-投票

    package redis.inaction; import redis.clients.jedis.Jedis; import redis.clients.jedis.ZParams; import ...

  8. jenkins入门-----(1)安装、配置

    Jenkins概念 Jenkins是一个开源的.可扩展的持续集成.交付.部署(软件/代码的编译.打包.部署)的基于web界面的平台.允许持续集成和持续交付项目,无论用的是什么平台,可以处理任何类型的构 ...

  9. OpenCV学习笔记(7)——图像阈值

    简单阈值,自适应阈值,Otsu's二值化等 1.简单阈值 当像素值高于阈值时,我们给这个像素赋予一个新值,否则给他赋予另一个值.这个函数就是cv2.threshhold().这个函数的第一个参数就是原 ...

  10. leecode 238除自身以外数组的乘积

    class Solution { public: vector<int> productExceptSelf(vector<int>& nums) { //用除法必须要 ...