之文件操作,文件的操作

By admin in 4858.com on 2019年3月31日

一 、文件读写格局

壹 、文件的二种形式:

格式: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("q5ert\n")
7 #文件追加模式,通常用于写日志
8 f3=open("test2","a",encoding="utf-8")
9 f3.write("1213\n1234")

“+” 表示能够同时读写文件

  • 之文件操作,文件的操作。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'0000000000\r\n1111111111\r\n2222222222\r\n3333333333\r\n4444444444\r\n5555555555'

叁 、文件的改动,例如将test第22中学的文件内容改动成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)

 

(七)File 文件的操作,file文件操作

  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,world
    4858.com ,\naaaaaaa’

 

“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
'helllo\ntest'

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()  跳转到有些地点

壹 、文件读写格局

一 、文件的二种形式:

格式: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("q5ert\n")
7 #文件追加模式,通常用于写日志
8 f3=open("test2","a",encoding="utf-8")
9 f3.write("1213\n1234")

“+” 表示能够而且读写文件

  • 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'0000000000\r\n1111111111\r\n2222222222\r\n3333333333\r\n4444444444\r\n5555555555'

③ 、文件的修改,例如将test第22中学的文件内容改动成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)

 

文件的操作,file文件操作
一 、文件读写情势 一 、文件的几种形式:
格式:f=open(“文件名”,”情势”,encode=”utf-8”) 1 #
文件的只读模…

  操作文件时,一般要求阅历如下步骤:

二.治本上下文

为了幸免打开文件后忘记关闭,能够透过管理上下文

 

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)打开文件

 2.haproxy布署文件更改操作

需求:

  1.匹配值 ,并将合作到的始末以列表格局重回给用户

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

4858.com 14858.com 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

配备文件

4858.com 34858.com 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)r,只读形式【暗中同意】

   
(2)w,只写形式【不可读;不存在则开创;存在则清空内容】

  (3)x,只写情势【不可读;不存在则创设;存在则报错】

  (4)a,追加方式【可读;不存在则开创;存在则只扩大内容】

  下边是一个简便的例证,判断”w”情势下的文书是还是不是可读,因为在此以前一样没有在意,不领悟”w”形式下文件不可读。实例如下:

    with open(“test.log”,”w”) as f:
    f.write(“123\n”)
    f.write(“I love
python\n”)
    f.write(“I must
to work hard\n”)
    f.write(“I must
to write string in the file\n”)
    #认清文件是或不是可读readable()
    ret = f.readable()
  
  print(ret)

  运维如下:

  False

   
首先,大家用”w”只写情势打开文件,并向文件中添加内容,然后采纳readable()判断文件是或不是可读,结果重临False,表达文件是不行读的。

   
“+”表示能够而且读写某些文件

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

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

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

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

  ”U”表示在读取时,能够将\r
\n \r\n自动转化成(与r或r+方式还要采纳)

   
(1)U

  (2)r+U

  ”b”表示处理二进制文件(如:FTP发送上传ISO镜像文件,linux可忽略,windows处理二进制文件时需标注)

   
(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)

发表评论

电子邮件地址不会被公开。 必填项已用*标注

网站地图xml地图
Copyright @ 2010-2019 美高梅手机版4858 版权所有