之文件操作,文件的操作

黄金年代、文件读写情势

1、文件的两种格局:

格式:f=open("文件名","模式",encode="utf-8")

1 #文件的只读模式
2 f1=open("test1","r",encoding="utf-8") #encoding="utf-8"可以不写
3 print(f1.read())
4 #文件只写模式,文件如果不存在,则创建,存在写入内容会覆盖原来的
5 f2=open("test2","w",encoding="utf-8")
6 f2.write("q5ertn")
7 #文件追加模式,通常用于写日志
8 f3=open("test2","a",encoding="utf-8")
9 f3.write("1213n1234")

" " 表示能够并且读写文件

  • r , 读写【可读,可写】
  • w ,写读【可读,可写】
  • x ,写读【可读,可写】
  • a , 写读【可读,可写】

 "b"表示以字节的方法操作

  • rb  或 r b
  • wb 或 w b
  • xb 或 w b
  • ab 或 a b

 注:以b方式打开时,读取的是byte类型

 1 # #读写模式、先读后写
 2 # f1=open("test1","r ")
 3 # print(f1.read())
 4 # f1.write("qqqqqqqqqq")
 5 # #写读模式,先写后读
 6 # f2=open("test2","w ")
 7 # f2.write("qqqqqqqqqq")
 8 # f2.read()
 9 # print(f2.read())
10 #追加写读
11 f2=open("test2","a ")
12 f2.write("wwwwwwww")
13 
14 # f1=open("test1","rb")  #不需要指定编码
15 # print(f1.read())
16 # #b'0000000000rn1111111111rn2222222222rn3333333333rn4444444444rn5555555555'

3、文件的修正,例如将test2中的文件内容更换成test1的原委

1 import os
2 with open('test1','r',encoding="utf-8") as f1,  
3         open('test2','w',encoding="utf-8") as f2:
4     for i in f1:
5         f2.write(line)
6 
7 os.remove('test1')
8 os.rename('test2','test3')

设若我们对文件之中有个别内容就能够改进呢

打开两个文件,修改其中内容后再写入另一个文件
f1=open("text1","r ",encoding="utf-8")
f2=open("text2","w ",encoding="utf-8")
for line in f:
    if "1111" in line:
        line=line.replace("1111","qqqq")
    f2.write(line)

 

  open函数,该函数用于文书管理

后生可畏.文件基本操作

  1.文件的开荒

打开文件时,需要指定文件路径和以何等方式打开文件,打开后,即可获取该文件句柄,日后通过此文件句柄对该文件操作

   文件句柄 = open('文件路径', '模式')

``

2.文本的读取

>>> f = open("f:/test.txt", "r")
>>> f.read()
'hello,world'
>>> f.close

  3.开辟文件的形式有:  

  • r ,只读方式【暗许】
  • w,只写形式【不可读;官样文章则开创;存在则清空内容;】
  • x, 只写模式【不可读;官样文章则创设,存在则报错】
  • a, 追加形式【可读;   一纸空文则开创;存在则只扩展内容;】

" " 表示能够并且读写某些文件

  • r , 读写【可读,可写】
  • w ,写读【可读,可写】
  • x ,写读【可读,可写】
  • a , 写读【可读,可写】

    f = open("f:/test.txt", 'r ') f.read() 'heheo,world' f.write("naaaaaaa") 8 f.tell() 22 f.read() '' f.tell() 22 f.seek(0) 0 f.read() 'heheo,worldnaaaaaaa'

 

"b"表示以字节的措施操作

  • rb  或 r b
  • wb 或 w b
  • xb 或 w b
  • ab 或 a b

    #以二进制文件写 f = open("file.txt", "wb") str_data = "呵呵" bytes_data = bytes(str_data, encoding='utf-8') f.write(bytes_data) f.close()

    #以二进制文件读 f = open("file.txt",'rb') data = f.read() f.close() print(data) str_data = str(data,encoding="utf-8") print(str_data)

 

    注:以b模式展开时,读取到的从头到尾的经过是字节类型,写入时也急需提供字节类型

  4. r , w , x , a 区别

  r 可读,可写,若文件一纸空文会报错,依照指针地方可写随便地点

  w 可写,可读,若文件不设有会成立,在拓宽写操作会清空文件内容

  x 可写,可读,若文件存在会报错,子虚乌有则开创

  a 可写,可读,只可以扩充在文书尾部

5.文书之中协理操作:

readline()   逐行读取数据

 

#逐行去读,较省内存
f = open('log','r')
result = list()
for line in open('log'):
    line = f.readline()
    print(line)
    result.append(line)
print(result)
f.close() 

trancate(),从文件的首行首字符起头截断,截断文件为n个字符;无n表示从当前任务起截断;截断之后n前边的有着字符被剔除

 

>>> with open("f:/test.txt" , 'r ') as f:
...     f.seek(2)
...     f.truncate(3)
...
2
3
>>> with open("f:/test.txt" , 'r ') as f:
...     f.read()
...
'hel'

read(),读取文件内容

>>> with open("f:/test.txt" , 'r ') as f:
...     f.read()
...
'hel'

write(),写入内容

>>> with open("f:/test.txt" , 'r ') as f:
...     f.read()
...     f.write('llo'   'n'   'test')
...     f.seek(0)
...     f.read()
...
'hel'
8
0
'helllontest'

readlines(), 将文件内容以列表的款型寄放,---->[“第一行”, "第二行"] 

>>> with open("f:/test.txt" , 'r ') as f:
...     temp = f.readlines()
...     print(temp)
...
['heheo,world~~n', 'aaaaaaa']

open(),张开文件

>>> f = open('f:/test.txt', 'r')

close(),关闭文件

 f.close()

flush(),强行刷入硬盘  

tell()  获取指针地方
seek()  跳转到有些地方

  操作文件时,经常需求经验如下步骤:

二.拘系上下文

为了防止展开文件后忘记关闭,能够经过拘禁上下文

 

with open("log", 'r ') as f:
    data = f.read()
    print(data)

三.练习  

编纂脚本实现,客商登陆,注册,改密,删除功效

#!/usr/bin/env python
# -*- coding:utf-8 -*-
#删除用户,修改密码
def login(username, password):
    """
    用户登录验证
    :param username: 用户名
    :param password: 密码
    :return: True成功,False失败
    """
    f = open('log', 'r', encoding='utf-8')
    for line in f:
        line = line.strip()
        userlist = line.split('$')
        if username == userlist[0] and password == userlist[1]:
            return True
    return False

def user_ex(username):
    """
    用于检测用户是否存在
    :param username: 用户名
    :return: True 表示存在,False用户不存在
    """
    with open('log','r',encoding='utf-8') as f:
        for line in f:
            line = line.strip()
            userlist = line.split('$')
            if username in userlist:
                return True
    return False

def res(username, password):
    """
    用于用户注册
    :param username: 用户名
    :param password: 密码
    :return: True注册成功
    """
    with open('log','a',encoding='utf-8') as f:
        temp = "n"   username   "$"   password
        f.write(temp)
    return True

def change_pwd(username, password):
    """
    用户修改密码
    :param username: 用户名
    :param password: 修改后的密码
    :return: True修改成功,False修改失败
    """
    file_object = open('log')
    try:
        lines=open('log','r').readlines()
        for i in range(len(lines)):
            if username in lines[i]:
                test=lines[i].split('$')[1]
                lines[i]=lines[i].replace(test,password)
                open('log','w').writelines(lines)
                return True
        return False
    finally:
        file_object.close( )

def del_user(username):
    """
    删除用户
    :param username: 要删除用户名
    :return: true 删除成功,False用户名不在列表中
    """
    file_object = open('log')
    try:
        lines = open('log', 'r').readlines()
        for i in range(len(lines)):
            if username in lines[i]:
                del lines[i]
                print(lines)
                open('log','w').writelines(lines)
                return True
            else:
                return False
    finally:
        file_object.close()

# def del_user(username):
#     with open('log', 'r') as f:
#         for line in f:
#             if re.match("lisi", line):
#                 pass
#             else:
#                 data = line
#     with open('log', 'w ') as f:
#         f.write(data)
#         return True
#     return False




def main():
    inp = input("1:登录;2:注册;3:删除用户;4:修改密码")
    user = input("请输入用户名:")
    pwd = input("请输入密码:")
    if inp == "1":
        ret = login(user, pwd)
        if ret:
            print("登录成功")
        else:
            print("登录失败")
    elif inp == "2":
        is_ex = user_ex(user)
        if is_ex:
            print("用户已存在,无法注册")
        else:
            resgister = res(user, pwd)
            if resgister:
                print("用户已成功注册")
            else:
                print("注册失败")
    elif inp == "3":
        del_us = del_user(user)
        if del_us:
            print("已删除")
        else:
            print("无此用户")
    elif inp == "4":
        is_chage = change_pwd(user, pwd)
        if is_chage:
            print("修改成功")
        else:
            print("无此用户")

main()

    (1卡塔 尔(英语:State of Qatar)打开文件

 2.haproxy配置文件改进操作

需求:

  1.相配值 ,并将相配到的内容以列表情势重返给客商

  2.插入内容,客户input数据后,将数据更新至配置文件中

图片 1图片 2

global
        log 127.0.0.1 local2
        daemon
        maxconn 256
        log 127.0.0.1 local2 info
defaults
        log global
        mode http
        timeout connect 5000ms
        timeout client 50000ms
        timeout server 50000ms
        option  dontlognull

listen stats :8888
        stats enable
        stats uri       /admin
        stats auth      admin:1234

frontend oldboy.org
        bind 0.0.0.0:80
        option httplog
        option httpclose
        option  forwardfor
        log global
        acl www hdr_reg(host) -i www.oldboy.org
        use_backend www.oldboy.org if www

backend www.oldboy.org
        server 100.1.7.9 100.1.7.9 weight 20 maxconn 3000

backend buy.oldboy.org
        server 100.1.7.90 100.1.7.90 weight 20 maxconn 3000

布局文件

图片 3图片 4

#!/usr/bin/env python
# -*- coding:utf-8 -*-


def fetch(backend):
    result = []
    with open('ha.conf', 'r') as f:
        flag = False
        for line in f:
            if line.strip().startswith('backend') and line.strip() == "backend "   backend:
                flag = True
                continue
            if flag and line.strip().startswith('backend'):
                break
            if flag and line.strip():
                result.append(line.strip())

    return result


def add(backend, record):
    result = fetch(backend)
    if not result:
        # 无backend,无record
        pass
    else:
        # 有backend
        if record in result:
            # 记录record
            pass
        else:
            result.append(record)
            with open('ha.conf', 'r') as old, open('new.conf', 'w') as new:
                continue_flag = False
                for line in old:

                    if line.strip().startswith('backend') and line.strip() == "backend "   backend:
                        continue_flag = True
                        new.write(line)
                        for temp in result:
                            new.write(" "*8   temp   "n")
                        continue

                    if continue_flag and line.strip().startswith('backend'):
                        continue_flag = False

                    if continue_flag:
                        pass
                    else:
                        new.write(line)


def add2(backend, record):
    with open('ha.conf', 'r') as old, open('new.conf', 'w') as new:
        in_backend = False
        has_backend = False
        has_record = False
        for line in old:
            if line.strip().startswith('backend') and line.strip() == "backend "   backend:
                has_backend = True
                in_backend = True
                new.write(line)
                continue

            if in_backend and line.strip().startswith('backend'):
                if not has_record:
                    new.write(" "*8   record   'n')
                new.write(line)
                in_backend = False
                continue

            if in_backend and line.strip() == record:
                has_record = True
                new.write(line)
                continue

            if line.strip():
                new.write(line)

        if not has_backend:
            # 写backend,写record
            new.write('backend '  backend   'n')
            new.write(' '*8   record   'n')


# ret = fetch("www.oldboy.org")
# print(ret)

# add('www.oldboy.org', "server 100.1.7.10 100.1.7.10 weight 20 maxconn 3000")
# add2('www.oldboy.org', "server 100.1.7.11 100.1.7.11 weight 20 maxconn 3000")

View Code

 3. 号码段截取

需求:

  将文件中的第二列前三字节和后四字节以逗号分开,文件格式如下:

1,"1300000","山东","济南","中国联通","0531","250000"
2,"1300001","江苏","常州","中国联通","0519","213000"
3,"1300002","安徽","巢湖","中国联通","0565","238000"
4,"1300003","四川","宜宾","中国联通","0831","644000"
5,"1300004","四川","自贡","中国联通","0813","643000"

  须要对象:

1,"130","0000","山东","济南","中国联通","0531","250000"

代码实现:

def phone():
    with open("mobile", "w ") as nf, open("Mobile.txt", "r") as f:
        for row in f:
            row = row.strip().split(',')
            row = (row[:1]   [row[1][:4] '"', '"'   row[1][4:]]   row[2:])
            nf.write(str(row).strip('[]').replace('" ', "") 'n')

  

  (2卡塔 尔(阿拉伯语:قطر‎操作文件

  风姿罗曼蒂克、展开文件

    文件句柄 = open("文件路线","格局")

    展开文件是,须求钦命文件路线和以何等办法展开文件,展开后,就能够获取该公文句柄,日后因此此文件句柄对该文件操作。

    张开文件的情势有:

    (1卡塔 尔(英语:State of Qatar)r,只读形式【私下认可】

    (2卡塔尔w,只写格局【不可读;官样文章则创建;存在则清空内容】

  (3卡塔 尔(英语:State of Qatar)x,只写形式【不可读;子虚乌有则开创;存在则报错】

  (4卡塔 尔(英语:State of Qatar)a,追加情势【可读;子虚乌有则开创;存在则只扩张内容】

  下边是三个简易的例证,推断"w"形式下的文本是不是可读,因为早前同样未有留意,不明白"w"格局下文件不可读。实比方下:

    with open("test.log","w") as f:
    f.write("123n")
    f.write("I love pythonn")
    f.write("I must to work hardn")
    f.write("I must to write string in the filen")
    #看清文件是或不是可读readable()
    ret = f.readable()
  
  print(ret)

  运行如下:

  False

    首先,大家用"w"只写情势张开文件,并向文件中增添内容,然后使用readable()判别文件是还是不是可读,结果回到False,表明文件是不足读的。

    " "表示能够同临时间读写有个别文件

  (1)r ,读写【可读,可写】

  (2)w ,写读【可读,可写】

  (3) x ,写读【可读,可写】

  (4)a ,写读【可读,可写】

  "U"表示在读取时,能够将r n rn自动转产生(与r或r 情势还要利用卡塔 尔(阿拉伯语:قطر‎

    (1)U

  (2)r U

  "b"表示管理二进制文件(如:FTP发送上传ISO镜像文件,linux可忽视,windows管理二进制文件时需声明卡塔 尔(英语:State of Qatar)

    (1)rb或r b

  (2)wb或w b

  (3)xb或x b

  (4)ab或a b

  二、操作文件

   (1)def close(self):

    # real signature unknown; restored from __doc__

  关闭文件

   """

  (2)def fileno(self):

    # real signature unknown; restored from __doc__

        文件描述符  
         """ 
  (3)def flush(self):
     # real signature unknown; restored from __doc__  
    刷新文件内部缓冲区
     """
     flush() -> None. Flush the internal I/O buffer. """ pass
  (4)def isatty(self): 
    # real signature unknown; restored from __doc__  
    判断文件是否是同意tty设备 
    """ 
    isatty() -> true or false. True if the file is connected to a tty device.
     """ 
    return False
  (5)def next(self)
    # real signature unknown; restored from __doc__  
    取下一行数据,不存在,则报错
     """ x.next() -> the next value, or raise StopIteration """
     pass
  (6)def read(self, size=None):
     # real signature unknown; restored from __doc__  
    读取指定字节数据 
    """
  read()是读取文件,可以指定读取文件中字符串多少个字节,read(self,size=None)默认是全部读取,在Python3中是按照字符来读取的。读取文件。
    with open("test.log","r") as f:
      ret = f.read(3)

  print(ret)
  运行如下:
  我是你
  上述代码我们以只读模式打开文件,并且读取文件中3个字符长度。
  (7)def readline(self, size=None):
     # real signature unknown; restored from __doc__  
    仅读取一行数据 
    """
   readlin(self,size=None)仅读取一行,经常和readlines()混淆,原来readline()是仅读取一行,readlines()按照换行符读取到一个列表中。示例如
下:

with open("test.log","r") as f:
    ret = f.readline()
    res = f.readline(2)

  print(ret)
  print(res)
  运行结果如下:
  在Python中只能写入字符串
  我喜
  上面代码可以看出,readline()读取了文件的第一行,并且readline(self,size)可以指定读取第一行的字符个数;并且如果第一行读取完成之后,是
不能同时进行读取的,就会读取第二行的内容。
    (8)readable(self,*args,**kwargs)
   readable(self,*args,**kwargs)是判断文件是否可读,如果可以读取就返回布尔值True;否则返回波尔值False.
  (9)def seek(self, offset, whence=None)
    # real signature unknown; restored from __doc__
        指定文件中指针位置
        """  
  seek(self,offset,whence=None)指定文件指针的位置,指定从哪里进行读取,实例如下:
  with open("test.log","r") as f:
      #print(f.tell())
      #插入指针的位置
      f.seek(3)
      #read()是按照字符来读取的
      ret = f.read(2)
      #tell是按照字节来读取的,汉字有3个字节,两个汉字有6个字节
      print(f.tell())
      #tell用来查看当前指针位置
      #seek指定当前指针位置
  print(ret)
  seek(self,offset,whence=None)是指定文件从那里开始读取,以字节的方式。
  tell(self)用来查看当前文件的指针,就是读取之后下一次从哪里开始读取。
    10.def tell(self):
     # real signature unknown; restored from __doc__
        获取当前指针位置
        """ tell() -> current file position, an integer (may be a long integer). """
        pass
  tell(self)是获取当前文件的指针位置。
  11.def truncate(self, size=None): 
  # real signature unknown; restored from __doc__
        截断数据,仅保留指定之前数据
        """
        truncate([size]) -> None.  Truncate the file to at most size bytes.

        Size defaults to the current file position, as returned by tell().
        """
        pass
    truncate(self,size=None)获取截断数据之前的数据。使用seek()截断数据,read()只读取截断文件之后的数据,之前的数据不管;而truncate()是读取
截断之前的数据。示例如下:
  
  with open("test.log","r ") as f:
      #print(f.tell())
      #插入指针的位置
      f.seek(6)
      #读取截断之后的文件内容
      #ret = f.read()
      #读取截断文件之前的文件内容
      res = f.truncate()
  #print(ret)
  print(res)
  truncate(self,size=None)是截取文件指针之前的内容,并把指针后面的文件删除,只保留指针之前的文件信息。
    12.def seekable(self, *args, **kwargs):
     # real signature unknown
        指针是否可操作
        pass
    13. def writable(self, *args, **kwargs): 
    # real signature unknown
        是否可写
        pass  

   14.def write(self, *args, **kwargs):

     # real signature unknown

        写内容
        pass

   15.def writelines(self, sequence_of_strings):

      # real signature unknown; restored from __doc__

         将一个字符串列表写入文件,示例如下:
  with open("test.log","w") as f:
      li = ["I love you.n", "I need to work hard to do someing.n", "In the Python,you can't to write int in the file"]
      f.writelines(li)
  上述代码中,我们把一个字符串列表写入了文件中。readlines(self,sequence_of_strings)以字符串列表的形式向文件中写入内容。
    16. def readlines(self, size=None): 
    # real signature unknown; restored from __doc__
        读取所有数据,并根据换行保存值列表
        """
  readlines(self,size=None)读取文件所有数据,并且以换行符的形式存储在一个列表中,与writelines()类似,实例如下:

  with open("test.log","r") as f:
      ret = f.readlines()

  print(ret)    
  运行结果如下:
    ['I love you.n', 'I need to work hard to do someing.n', "In the Python,you can't to write int in the file"]

with open("test.log","r") as f:
    ret = f.readline()
    res = f.readline(2)

print(ret)
print(res)

本文由星彩网app下载发布于计算机编程,转载请注明出处:之文件操作,文件的操作

TAG标签: 星彩网app下载
Ctrl+D 将本页面保存为书签,全面了解最新资讯,方便快捷。