一、文件的操作

介绍

计算机系统分为：计算机硬件，操作系统，应用程序三部分。

我们用python或其他语言编写的应用程序若想要把数据永久保存下来，必须要保存于硬盘中，这就涉及到应用程序要操作硬件，众所周知，应用程序是无法直接操作硬件的，这就用到了操作系统。操作系统把复杂的硬件操作封装成简单的接口给用户/应用程序使用，其中文件就是操作系统提供给应用程序来操作硬盘虚拟概念，用户或应用程序通过操作文件，可以将自己的数据永久保存下来。

有了文件的概念，我们无需再去考虑操作硬盘的细节，只需要关注操作文件的流程：

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

1、打开一个文件

语法:

open(filename,mode)

解释:

filename:代表你要访问的文件名

mode:这里代表你打开文件的模式,有只读，写入，读写，追加等模式；默认为只读模式。

我们可以看下面的列表:

1、读模式 r 以只读方式打开文件。

　　文件的指针将会放在文件的开头。这是默认模式

例子:

1 f = open("foo.txt", "r",encoding="UTF-8")  #只读的方式打开的文件,encoding是转码的意思，告诉解释器，是以UTF-8的格式
2 i=f.read()   # 读取文件，bing 赋值给i
3 print(i)     #打印i
4 f.close()    #关闭文件夹

输出：

Python 是一个非常好的语言。是的，的确非常好!!

2、读写模式 r+ 打开一个文件用于读写。

文件指针将会放在文件的开头。

例子:

1 f = open("foo.txt", "r+",encoding="UTF-8")  #读写的方式打开的文件,encoding是转码的意思，告诉解释器，是以UTF-8的格式
2 i=f.read()   # 读取文件，bing 赋值给i
3 print(i)     #打印i
4 f.write("我要学Python\n")       #写入
5 # f.flush()
6 f.close()    #关闭文件夹

输出：

我要学Python
我要学Python

3、写模式 w 打开一个文件只用于写入。

如果该文件已存在则将其覆盖。如果该文件不存在，创建新文件

例子:

1 f = open("foo.txt", "w",encoding="UTF-8")  #写的方式打开的文件,encoding是转码的意思，告诉解释器，是以UTF-8的格式
2 f.write("我要学Python\n")       #写入,文件夹存在覆盖，不存在创建
3 f.close()    #关闭文件夹

4、读写模式 w+ 打开一个文件用于读写。

如果该文件已存在则将其覆盖。如果该文件不存在，创建新文件

例子:

1 f = open("foo.txt", "w+",encoding="UTF-8")  #写的方式打开的文件,encoding是转码的意思，告诉解释器，是以UTF-8的格式
2 f.write("我要学Python\n")       #写入,文件夹存在覆盖，不存在创建
3 print("定位之前的光标位置:%s" % (f.tell()))
4 f.flush()                       #刷新文件使内存的内容刷新至文件夹
5 f.seek(0)                       #因为W+读取文件之后会定位在文件尾部，所以需要重新定位一下光标位置，要不无法读取
6 print("定位之后的光标位置:%s" % (f.tell()))
7 i = f.read()
8 print(i)
9 f.close()    #关闭文件夹

输出：

定位之前的光标位置:17
定位之后的光标位置:0
我要学Python

5、追加 a 打开一个文件用于追加。

如果该文件已存在，文件指针将会放在文件的结尾。也就是说，新的内容将会被写入到已有内容之后。如果该文件不存在，创建新文件进行写入

例子：

1 f = open("foo.txt", "a",encoding="UTF-8")  #追加方式打开的文件,encoding是转码的意思，告诉解释器，是以UTF-8的格式
2 f.write("我要学Python\n")       #写入,文件夹存在追加，不存在创建
3 print("定位之前的光标位置:%s" % (f.tell()))
4 f.seek(0)                       #因为a追加文件之后会定位在文件尾部，所以需要重新定位一下光标位置，要不无法读取
5 print("定位之后的光标位置:%s" % (f.tell()))
6 f.close()    #关闭文件夹

6、追加读 a+打开一个文件用于读写。

如果该文件已存在，文件指针将会放在文件的结尾。文件打开时会是追加模式。如果该文件不存在，创建新文件用于读写。

例子:

1 f = open("foo.txt", "a+",encoding="UTF-8")  #追加读方式打开的文件,encoding是转码的意思，告诉解释器，是以UTF-8的格式
2 f.write("我要学Python\n")       #写入,文件夹存在创建，不存在创建
3 print("定位之前的光标位置:%s" % (f.tell()))
4 f.flush()                       #刷新文件使内存的内容刷新至文件夹
5 f.seek(0)                       #因为W+读取文件之后会定位在文件尾部，所以需要重新定位一下光标位置，要不无法读取
6 print("定位之后的光标位置:%s" % (f.tell()))
7 i = f.read()
8 print(i)
9 f.close()    #关闭文件夹

输出：

1 定位之前的光标位置:136
2 定位之后的光标位置:0
3 我要学Python
4 我要学Python
5 我要学Python
6 我要学Python
7 我要学Python

二、文件的操作方法

文件的常用方法有13种，如下图:

文件的file.close、file.flush、file.seek、file.tell在前面文件的读、写、追加已经介绍过了这里就不一一说了，下面我们说一下剩余的几种方法吧！

1、fileno()

方法返回一个整型的文件描述符(file descriptor FD 整型)，可用于底层操作系统的 I/O 操作

语法：

fileObject.fileno()

返回值：文件描述符

例子

1 f = open("foo.txt", "a+",encoding="UTF-8")  #追加读方式打开的文件,encoding是转码的意思，告诉解释器，是以UTF-8的格式
2 fid = f.fileno()
3 print("文件的描述符为:",fid)
4 f.close()    #关闭文件夹

输出：

文件的描述符为: 3

2、next()

返回文件的下一行

语法：

next(iterator[,default])例子：

1 # 打开文件
2 fo = open("foo.txt", "r",encoding="UTF-8")
3 print ("文件名为: ", fo.name)
4 for index in range(5):
5     line = next(fo)
6     print ("第 %d 行 - %s" % (index, line))
7 # 关闭文件
8 fo.close()

输出：

# 文件名为:  foo.txt
# 第 0 行 - 我要学Python0
# 第 1 行 - 我要学Python1
# 第 2 行 - 我要学Python2
# 第 3 行 - 我要学Python3
# 第 4 行 - 我要学Python4

3、read方法：

用于从文件读取指定的字节数，如果为给定或为负则读取所有

语法:

fileObject.read()

例子：

 1 fo = open("foo.txt", "r",encoding="UTF-8")2 print ("文件名为: ", fo.name)3 line = fo.read()       #不指定字符节读取所有4 print(line)5 fo.close()    # 关闭文件6 # 如下:7 # C:\Python35\python.exe D:/linux/python/all_test/总练习.py8 # 文件名为:  foo.txt9 # 我要学Python0
10 # 我要学Python1
11 # 我要学Python2
12 # 我要学Python3
13 # 我要学Python4
14 # 我要学Python5
15
16 ===========================================
17 fo = open("foo.txt", "r",encoding="UTF-8")
18 print ("文件名为: ", fo.name)
19 line = fo.read(16)       #指定读取16字节
20 print(line)
21 fo.close()    # 关闭文件

输出：

# 文件名为:  foo.txt
# 我要学Python0
# 我要学Py

4、readline()

方法用于从文件读取整行，包括 "\n" 字符。如果指定了一个非负数的参数，则返回指定大小的字节数，包括 "\n" 字符。

语法：

fileObject.readline()

例子：

 1 fo = open("foo.txt", "r",encoding="UTF-8")2 print ("文件名为: ", fo.name)3 line = fo.readline(3)       #指定读取16字节4 print("读取指定的字符串为:%s" % (line))5 print("光标现在的位置:%s" %(fo.tell()))6 fo.seek(0,0)          #之所以用这个是因为前面已经读了16个字符了所以要把光标调到0 的位置7 print("调整后光标的位置:%s" %(fo.tell()))8 line = fo.readline()       #读取第一行9 print("读取第一行:%s" % (line))
10 fo.close()    # 关闭文件

输出：

# 文件名为:  foo.txt
# 读取指定的字符串为:我要学
# 光标现在的位置:9
# 调整后光标的位置:0
# 读取第一行:我要学Python0

5、readlines()

方法用于读取所有行(直到结束符 EOF)并返回列表，若给定sizeint>0，返回总和大约为sizeint字节的行, 实际读取值可能比sizhint较大, 因为需要填充缓冲区。如果碰到结束符 EOF 则返回空字符串。

语法:

fileObject.readlines()

例子:

1 fo = open("foo.txt", "r",encoding="UTF-8")
2 print ("文件名为: ", fo.name)
3 line = fo.readlines(3)       #指定读取3字节
4 print("读取指定的字符串为:%s" % (line))
5 for line in fo.readlines():
6     line = line.strip("\n")     #使用strip去掉换行符/n
7     print("读取所有行:%s" % (line))
8 fo.close()    # 关闭文件

输出：

文件名为:  foo.txt
读取指定的字符串为:[‘我要学Python0\n‘]
读取所有行:我要学Python1
读取所有行:我要学Python2
读取所有行:我要学Python3
读取所有行:我要学Python4
读取所有行:我要学Python5
读取所有行:我要学Python6
读取所有行:我要学Python7

6、truncate()

方法用于截断文件，如果指定了可选参数 size，则表示截断文件为 size 个字符。如果没有指定 size，则重置到当前位置。

语法：

fileObject.truncate( [ size ])
例子1：

1 fo = open("foo.txt", "r+",encoding="UTF-8")
2 line = fo.readline()
3 print ("读取行: %s" % (line))
4
5 fo.truncate()
6 line = fo.readlines()
7 print ("读取行: %s" % (line))
8 fo.close()    # 关闭文件

输出：

读取行: 我要学Python1读取行: [‘我要学Python2\n‘, ‘我要学Python3\n‘, ‘我要学Python4‘]

例子2：

1 fo = open("foo.txt", "r+",encoding="UTF-8")
2 fo.truncate(10)            #截取10个字符，其余的清空
3 line = fo.read()
4 print ("读取的数据: %s" % (line))
5 fo.close()    # 关闭文件

输出：

读取的数据: 我要学P

7、writelines()

方法用于向文件中写入一序列的字符串，这一序列字符串可以是由迭代对象产生的，如一个字符串列表，换行需要制定换行符 \n。

语法

writelines() 方法语法如下：

fileObject.writelines( [ str ])
例子：

1 fo = open("foo.txt", "a+",encoding="UTF-8")
2 seq = ["我要学Python 1\n", "我要学Python 2"]
3 fo.writelines( seq )
4 fo.flush()
5 fo.seek(0,0)                                            #跳到行首
6 line = fo.readlines()                                 #读取所有行
7 print ("读取的数据: %s" % (line))
8 fo.close()    # 关闭文件

输出：

读取的数据: [‘我要学Python 1\n‘, ‘我要学Python 2‘]

三元运算

一、三元运算符

三元运算符就是在赋值变量的时候，可以直接加判断，然后赋值

格式：[on_true] if [expression] else [on_false]

res = 值1 if 条件 else 值2

1.举例说明：

a =1

b = 2

c= a if a>1 else b #如果a大于1的话，c=a，否则c=b

如果不用三元运算符，就用if-else条件判断，如下：

a = 1

b = 2

if a >1:

c = a

else:

c = b

2.三元运算符也可以用在列表和字典中

例：1-10的数字，打印出其中的偶数

三元运算：

ss = [i for i in range(1,11) if i%2==0 ] #循环1-11间的值（不包括11），如果值能被2整除（即取偶数），就写到ss这个list中

print(ss) #最终打印结果 [2, 4, 6, 8, 10]

if-else条件判断

s = []

for i in range(1,11):

if i %2==0:

s.append(i)

print(s)

二、集合

集合：set持有一系列元素，和list很像，也是一种数据类型，但是set的元素没有重复，而且是无序的

特点：set不包含重复的元素（天生去重）且无序

2.集合的定义

a.定义一个列表，通过强制转换来定义集合

nums = [1,1,2,3,5,6,77,8]

num_set = set(nums)

b.直接定义

num_set1={1,2,3,3,4}

集合不能通过下标来访问元素

3.循环遍历set

s = set([‘Adam‘, ‘Lisa‘, ‘Bart‘])

for name in s:

print (name)

结果：

Lisa

Bart

Adam

4.添加元素

s = {1,2,3}

s.add(4)

print(s)#结果 {1, 2, 3, 4}

s.update([333,444,333])

s.update({56,78,999})

5.删除元素

s.remove(333) #删除元素，如果元素不存在就会报错

s.pop() #删除一个随机的元素，并返回删除的元素

s.discare(111) #如果删除的元素存在，删除，不存在不做处理

三、函数

1.什么是函数？

定义: 函数是指将一组语句的集合通过一个名字(函数名)封装起来，要想执行这个函数，只需调用其函数名即可。

2.使用函数的好处

a.简化代码

b.提高代码的复用性

c.代码可扩展

3.python中函数定义

def functionname( parameters ): function_suite return [expression]

说明：def为关键字，后面为函数名，函数名不能重复，括号中内容为参数，根据实际情况，定义你需要的参数个数

function_suite 为函数体

return 为返回值如果不写return这一行的话，默认返回为None

4.函数调用

def hello():

print(‘hello!‘)

hello() #函数调用，函数调用的方式为，函数名后跟括号

5.形参和实参

函数在调用的时候，可以传入参数，有形参和实参

形参：形参变量只有在被调用时才分配内存单元，在调用结束时，即刻释放所分配的内存单元。因此，形参只在函数内部有效。

实参：实参可以是常量、变量、表达式、函数等，无论实参是何种类型的量，在进行函数调用时，它们都必须有确定的值，以便把这些值传送给形参。函数调用结束返回主调用函数后则不能再使用该形参变量。

6.函数的参数类型

函数的四种参数类型：位置参数、默认参数、不定长参数、关键字参数

位置参数：

位置参数，就是按照参数的位置来进行传参

例：

def reg(name,age):

print(‘hello %s,age is %s‘ %(name,age))#name,age是必填参数，位置参数

reg(‘hhf‘,27)

说明：有几个位置参数在调用的时候就要传几个，否则就会报错

如果有多个位置参数，但却记不住参数的位置，可以使用位置参数的名字来指定调用

具体调用为reg(name=‘huihui‘,age=25),这种调用方式叫做关键字传参

默认参数：

默认参数就是在定义形参的时候，给函数默认赋一个值

默认参数不是必填的，如果给默认参数传值的话，它就会使用你传入的值。如果使用默认值参数的话，必须放在位置参数后面定义

例：

def reg(name,age，sex=‘男‘):

print(‘hello %s,age is %s‘ %(name,age))#name,age是必填参数，位置参数 #sex是默认值参数，不是必填参数

reg(‘hhf‘,27)#不传sex，sex使用默认值参数，sex=‘男‘

reg(‘huihui‘,28,‘女‘) #给sex传值，sex=‘女‘

非固定参数：

上面的两种位置参数和默认参数都是参数个数是固定的

如果有一个函数，参数不是固定的，也不知道函数会扩展成啥样，可能参数越来越多，这个时候如果使用固定的参数，后面程序就不好扩展，这时候就可以用非固定参数了

非固定参数有两种，一种是可变参数，一种是关键字参数

可变参数：

可变参数用*来接收，后面想传多少个参数就传多少个，如果位置参数、默认值参数、可变参数一起使用的的话，可变参数必须在位置参数和默认值参数后面。可变参数也是非必传的。

例：

def post(*args):

print(args)

post(‘001‘,‘denglu‘,‘http://www.baidu.com‘,post,a=1)

post()

说明：可变参数，也叫参数组，也不是必填的，它接收到的是一个元组

它把调用函数时传进去的每一个参数到一个元组里

关键字参数：

关键字参数使用**来接收，后面的参数也是不固定的，想写多少个写多少个，当然也可以和上面的几种一起来使用，如果要一起使用的话，关键字参数必须在最后面。

使用关键字参数的话，调用的时候必须使用关键字传参，关键字参数也是非必传的

例：

def kw(**kwargs):

print(kwargs)

kw()

kw(age=18,name=‘aaa‘)

d={‘age‘:18,‘name‘:‘aaa‘}

kw(**d)

说明：关键字参数，接收的是一个字典，调用得用xx=11，也不是必填的

传入字典调用的时候就得写**{‘age‘:18,‘name‘:‘aaa‘}

其它例子：

def other2(name,country=‘china‘,*args,**kwargs):

print(name)

print(country)

print(args)

print(kwargs)

other2(‘hhf‘)

other2(‘niuhui‘,‘beijing‘,‘python‘,‘changping‘,user=‘niu‘)

说明：如果必填参数，默认值参数，可变参数和关键字参数要一起使用的话，

必须参照必填参数、默认值参数、可变参数和关键字参数的顺序接收，否则会报错

def write(filename,model,ending,user,os,money,other):

print(filename)

print(model)

print(ending)

print(user)

print(os)

print(money)

print(other)

write(os=‘Windows‘,user=‘wubing‘,model=‘w‘,filename=‘a.tx‘,ending=‘utf8‘,money=9999,other=‘xxx‘)

-#write(os=‘windows‘,‘a.txt‘) #位置参数调用参数必须在关键字调用前，否则报错

write(‘a.txt‘,‘w‘,‘gbk2312‘,‘hhf‘,os=‘windwos‘,money=9999,other=‘xxx‘)

7.函数返回值

def plus(a,b):

c=a+b

return c

说明：

a函数碰到return，立即结束这个函数

b调用完函数之后，返回计算结果

c函数可以没有返回值，如果没有返回值的话，默认返回None,如果这个函数的处理

结果我们需要在别的地方用到，就得给函数一个返回值

如果函数return多个值的话，那么它就会把多个值放到一个元组里面去

score1 = 50

score2 = 90

def echo():

return score1,score2

8.局部变量和全局变量

局部变量：在局部内生效，出了这个变量的作用域，这个变量就失效了

全局变量：在整个程序里面都生效的，在程序最前面定义的都是全局变量

-# score3 = [1,2,3,4,5]

-# score3 = {"id":1}

score3 = 100

def my_open():

fw = open(‘a.txt‘,‘a+‘)

fw.seek(0)

print(‘score3‘,score3)

d={‘id‘:2}

d[‘price‘]=99

说明：

a.在函数里面定义变量叫局部变量，它只能在函数里面用，出了该函数外，就不能使用了

b.在函数外面定义的变量，是全局变量，在函数内也可以使用

c 如果想在函数里面修改全局变量的值，那么要先用global关键字声明

要修改全局变量是int、string的话，必须得写global

如果是字典和list的话,要修改的话，不能加global

 转载;https://www.cnblogs.com/hhfzj/p/6978092.html

Python学习——02-Python基础——【4-文件处理与三元运算】相关推荐

Python 学习 02 —— Python如何爬取数据
文章目录系列文章二.Python 爬虫 1.任务介绍 2.简介 3.基本流程 3.1.准备工作 3.1.1.分析页面 3.1.2.编码规范 3.1.3.导入模块 3.1.4.程序流程 3.2.获 ...
Python学习笔记_1_基础_2：数据运算、bytes数据类型、.pyc文件（什么鬼）
Python学习笔记_1_基础_2:数据运算.bytes数据类型..pyc文件(什么鬼) 一.数据运算 Python数据运算感觉和C++,Java没有太大的差异,百度一大堆,这里就不想写了.比较有意思 ...
Python学习系列（五）(文件操作及其字典)
Python学习系列(五)(文件操作及其字典) Python学习系列(四)(列表及其函数) 一.文件操作 1,读文件在以'r'读模式打开文件以后可以调用read函数一次性将文件内容全部读出 ...
Python学习day16-模块基础
<!doctype html>day16 - 博客 Python学习day16-模块基础模块的四种形式import和from-import循环导入模块的搜索路径Python文件的两种用途 ...
Python学习日记-day1基础篇字符输出注释
Python学习日记-day1基础篇字符输出注释 by北栀一刺 # -*- coding: utf-8 -*- """ Spyder EditorThis is a ...
Python学习教程（Python学习路线_Python基础学习教程_Python视频教程）：初学者新手怎样快速入门Python
Python学习教程(Python学习路线_Python基础学习教程_Python视频教程):初学者新手怎样快速入门Python? 人生苦短,我用Python!!!短短几个字,现在在各大学习类平台随处 ...
[python教程入门学习]python学习笔记（CMD执行文件并传入参数）
本文章向大家介绍python学习笔记(CMD执行文件并传入参数),主要包括python学习笔记(CMD执行文件并传入参数)使用实例.应用技巧.基本知识点总结和需要注意事项,具有一定的参考价值,需要的朋 ...
python学习[第十四篇] 文件的输入与输出
python学习[第十四篇] 文件的输入与输出标准文件类型一般来说只要程序一执行,就会访问3个文件: 标准输入(键盘) stdin 标准输出(显示器缓冲区) stdout 默认输出到屏幕标准错误 ...
python学习记录part10：读写文件
python学习part10:第十章文件和异常教材:<python:从入门到实践> 今天有别的学习任务,相应的自由学习时间也就少了,所以今天学习内容不多,估计以后也不能保持很快的进度 ...
python学习课程 0基础学Python视频教程
python学习课程,零基础Python初学者应该怎么去学习Python语言编程?python学习路线这里了解一下吧.想python学习课程?学习路线网免费下载海量python教程,上班族也能在家自学 ...

Python学习——02-Python基础——【4-文件处理与三元运算】