java基础字节流

最新推荐文章于 2023-11-08 16:57:27 发布
最新推荐文章于 2023-11-08 16:57:27 发布
阅读量149 收藏 1
点赞数
分类专栏： java 基础 文章标签： java 编程语言
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/guenping2020/article/details/110236290
版权

24.2.字节流

2.1.IO流概述和介绍

IO流述

  • IO：输入/输出(Input/Output)
  • 流：是一种抽象概念，是对数据传输的总称。也就是说数据在设备间的传输称为流，流的本质是数据传输
  • IO流就是用来处理设备间数据传输问题的
    • 常见的应用:文件复制;文件上传;文件下载

IO流的分类

  • 按照数据的流向

    • 输入流：读数据
    • 输出流：写数据

  • 按照数据类型来分
    字节流
    字节输入流 ; 字节输出流
    字符流
    字符输入流 ; 字符输出流

一般来说，我们说IO流的分类是按照数据类型来分的那么这两种流都在什么情况下使用呢?

如果数据通过Window自带的记事本软件打开，我们还可以读懂里面的内容，就使用字符流，否则使用字节流。如果你不知道该使用哪种类型的流，就使用字节流

2.2 字节流写数据

字节流抽象基类

  • lnputStream:这个抽象类是表示字节输入流的所有类的超类
  • OutputStream:这个抽象类是表示字节输出流的所有类的超类
  • 子类名特点:子类名称都是以其父类名作为子类名的后缀

FileOutputStream:文件输出流用于将数据写入File

  • FileOutputStream(String name):创建文件输出流以指定的名称写入文件

使用字节输出流写数据的步骤:

  • 创建字节输出流对象(调用系统功能创建了文件，创建字节输出流对象，让字节输出流对象指向文件)
  • 调用字节输出流对象的写数据方法
  • 释放资源(关闭此文件输出流并释放与此流相关联的任何系统资源)
import java.io.FileOutputStream;
import java.io.IOException;

public class FileOutputStreamDemo01 {
    public static void main(String[] args) throws IOException {
        //创建字节输出流对象
//FileOutputStream(Stringname):创建文件输出流以指定的名称写入文件
        FileOutputStream fos = new FileOutputStream(".\\fos.txt");
        /*
        做了三件事情;
            A:调用系统功能创建了文件
            B:创建了字节输出流对象
            c:让字节输出流对象指向创建好的文件
         */
//  void write (int b),将指定的字节写入此文件输出流
        fos.write(97);
//        fos.write(57);
//        fos.write(55);
//        最后都要释放资源
//void close ():关闭此文件输出流并释放与此流相关联的任何系统资源。
        fos.close();

    }
}

2.3.字节流写数据的三种方式

方法名说明
void write(int b)将指定的字节写入此文件输出流一次写一个字节数据
void write(byte[] b)将b.length字节丛指定的字节数组写入此文件输出流一次写一个字节数组数据
void write(byte[] b,int off,int len)将len字节从指定的字节数组开始，从偏移量off开始写入此文件输出流一次写一个字节数组的部分数据

构造方法;

FileOutputStream(String name):创建文件输出流以指定的名称写入文件

FileOutputStream(file file):创建文件输出流以写入由指定的File对象表示的文件

import java.io.FileOutputStream;
import java.io.IOException;

public class FileOutputStreamDemo02 {
    public static void main(String[] args) throws IOException {
//FileOutputStream(String  name):创建文件输出流以指定的名称写入文件, 一般写这个方便
        FileOutputStream fos = new FileOutputStream(".\\fos.txt");
        //new File(name)自动封装了
//      FileOutputStream fos = new FileOutputStream(new File(".\\fos.txt"));

//FileOutputStream(file file):创建文件输出流以写入由指定的File对象表示的文件
//        FileOutputStream fos2 = new FileOutputStream(new File(".\\fos.txt"));

//  void write(int b)将指定的字节写入此文件输出流一次写一个字节数据
/*
        fos.write(97);
        fos.write(98);
        fos.write(99);
        fos.write(100);
        fos.write(101);*/

//void write(byte[] b)将b.length字节丛指定的字节数组写入此文件输出流一次写一个字节数组数据
///        byte[] bys = {97,98,99,100,101,102};
        //byte[] getBytes ():返回字符串对应的字节数组
        byte[] bys = "abcdefg".getBytes();
//        fos.write(bys);
///  void write(byte[] b,int off,int len)将len字节从指定的字节数组开始，从偏移量off开始写入此文件输出流一次写一个字节数组的部分数据
        fos.write(bys, 1, 3);

//        释放资源
        fos.close();
    }
}

2.4.字节流写数据的两个小问题

1.字节流写数据如何实现换行

​ window: \r\n

​ linux: \n

​ mac: \r

2.字节流写数据如何实现追加写入

  • public FileOutputStream (String name , boolean append)

  • 创建文件输出流以指定的名称写入文件。如果第二个参数为true ，则字节将写入文件的末尾而不是开头

import java.io.FileOutputStream;
import java.io.IOException;

public class FileOutputStreamDemo03 {
    public static void main(String[] args) throws IOException {
        //创建字节流输出对象
//        FileOutputStream fos = new FileOutputStream(".\\fos.txt");
        FileOutputStream fos = new FileOutputStream(".\\fos.txt",true);

        //写数据
        for (int i = 0; i < 10; i++){
            fos.write("hello".getBytes());
            fos.write("\r\n".getBytes());
        }
        //释放资源
        fos.close();
    }
}

2.5.字节流写数据加异常处理

==finally:==在异常处理时提供finally块来执行所有清除操作。比如说IO流中的释放资源

特点:被finally控制的语句一定会执行，除非JVM退出

在这里插入图片描述

import java.io.FileNotFoundException;
import java.io.FileOutputStream;
import java.io.IOException;

public class FileOutputStreamDemo04 {
    public static void main(String[] args) throws FileNotFoundException {
        FileOutputStream fos = null;
        try {
            fos = new FileOutputStream(".\\fos.txt");
            fos.write("hello".getBytes());

        } catch (IOException e) {
            e.printStackTrace();
        } finally {
            if (fos != null)
                try {
                    fos.close();
                } catch (IOException e) {
                    e.printStackTrace();
                }
        }

    }
}

2.6.字节流读数据(一次读一个字节数据)

FilelnputStream:从文件系统中的文件获取输入字节

  • FileInputStream(String name):通过打开与实际文件的连接来创建一个FileInputStream，该文件由文件系统中的路径名name 命名。

    read方法包括：

    1. read（），此方法一个字节一个字节的读取，从输入流中读取数据的下一个字节。返回 0 到 255 范围内的 int 字节值。如果因为已经到达流末尾而没有可用的字节，则返回值 -1 。

    2. read (byte[] b)，此方法按b进行读取，如果文件总共读取的byte长度是46，b长度为10，则读取4次，每次读取10个字节，最后一次读取6个字节。以整数形式返回实际读取的字节数。

    3. read (byte[] b,int off,int len) 方法， 将输入流中最多 len 个数据字节读入 byte 数组。尝试读取 len 个字节，但读取的字节也可能小于该值。以整数形式返回实际读取的字节数。

    write方法包括：(参照read方法)

    1. write（）

    2. write (byte[] b) 在这里，和read方法不同的是，如果byte长度是46，则输出5次，每次读取10个字节，最后一次只有6个字节，却多出了4个字节，而采用第三种方法就可以避免你多余输出，占了内存。

    3. write (byte[] b,int off,int len)

/*
需求:把文件fos.txt中的内容读取出来在控制台输出
使用字节输入流读数据的步骤 :

①  创建字节输入流对象

②  调用字节输入流对象的读数据方法

③  释放资源
*/
import java.io.FileInputStream;
import java.io.IOException;

public class FileIntputStreamDemo01 {
    public static void main(String[] args) throws IOException {
        //创建字节输入流对象
        //FileInputStream(String name)
        FileInputStream fis = new FileInputStream("E:\\javastudent\\fos.txt");

//        调用字节输入流对象的读数据方法
//        int read() 从该输入流读取一个字节的数据。

/*
        //第一次读取数据
        int by = fis.read();
        System.out.println(by);
        System.out.println((char) by);
        System.out.println("-----");
        //第二次读取数据
        by = fis.read();
        System.out.println(by);
        System.out.println((char) by);
        System.out.println("-----");
        //再多读取两次
        by = fis.read();
        System.out.println(by);
        by = fis.read();
        System.out.println(by);
*/

/*        int by = fis.read();
        while (by != -1) {
            System.out.print((char) by);
            by = fis.read();
        }*/
//        优化上面的程序
        int by;
        /*
        fis.read( ):读数据
        by=fis.read():把读取到的数据赋值给by
        by != -1:判断读取到的数据是否是-1*/

        while ((by = fis.read()) != -1) {
            System.out.print((char) by);
        }
//        释放资源
        fis.close();
    }
}
/*
hello
world
*/

2.7.案例:复制文本文件

需求:把“E:\\窗里窗外.txt”复制到模块目录下的“窗里窗外.txt"
分析:
①复制文本文件，其实就把文本文件的内容从一个文件中读取出来(数据源)，然后写入到另一个文件中(目的地)

数据源:

E:\\窗里窗外.txt —读数据— InputStream —FilelnputStream

目的地:

窗里窗外.txt—写数据— OutputStream -----FileOutputStream

思路:

①根据数据源创建字节输入流对象

②根据目的地创建字节输出流对象

③读写数据，复制文本文件(一次读取一个字节，一次写入一个字节)

④释放资源

import java.io.FileInputStream;
import java.io.FileOutputStream;
import java.io.IOException;

public class CopyTxtDemo {
    public static void main(String[] args) throws IOException {
        //根据数据源创建字节输入流对象
        FileInputStream fis = new FileInputStream("E:\\窗里窗外.txt");
        //根据目的地创建字节输出流对象
        FileOutputStream fos = new FileOutputStream("窗里窗外.txt");
        //读写数据，复制文本文件(一次读取一个字节，一次写入一个字节)
        int by;
        while ((by=fis.read())!=-1){
            fos.write(by);
        }
        //释放资源
        fos.close();
        fis.close();
    }
}

2.8字节流读数据(一次读一个字节数组数据)

需求:把文件fos.txt中的内容读取出来在控制台输出

使用字节输入流读数据的步骤:
①创建字节输入流对象
②调用字节输入流对象的读数据方法
③释放资源

import java.io.FileInputStream;
import java.io.IOException;
import java.lang.String;

public class FileInputStreamDemo02 {
    public static void main(String[] args) throws IOException {
        FileInputStream fis = new FileInputStream("fos.txt");
//调用字节输入流对象的读数据方法
//int read (byte[] b)，从该输入流读取最多b.length个字节的数据到一个字节数组
//    byte[] bys =new byte[5];
//
//        //第一次读取数据
//        int len =fis.read(bys);
//        System.out.println(len);
//        //String (byte[] bytes)
//        System.out.println(new String(bys,0,len));
//
//        //第二次读取数据
//        len =fis.read(bys);
//        System.out.println(len);
//        System.out.println(new String(bys,0,len));
//
//        //第三次读取数据
//        len =fis.read(bys);
//        System.out.println(len);
        //String (byte[] bytes, int offset， int length)
//        System.out.println(new String(bys,0,len));
        byte[] bys = new byte[1024];//1024及其整数倍
        int len;
        while ((len = fis.read(bys)) != -1) {
            System.out.println(new String(bys,0,len));

        }
    //释放资源
        fis.close();
    }
}
/*
hello
world
*/

2.9.案例复制图片

需求:把“E:\litcastlImn.jpg”复制到模块目录下的“mn.jpg"

思路:

①根据数据源创建字节输入流对象

②根据目的地创建字节输出流对象

③读写数据，复制图片(一次读取一个字节数组，一次写入一个字节数组)

④释放资源

import java.io.FileInputStream;
import java.io.FileOutputStream;
import java.io.IOException;

public class CopyJpgDemo {
    public static void main(String[] args) throws IOException {
        //根据数据源创建字节输入流对象
        FileInputStream fis = new FileInputStream("D:\\Backup\\我的文档\\My Pictures\\Saved Pictures\\mn.jpg");
        //根据目的地创建字节输出流对象
        FileOutputStream fos = new FileOutputStream("mn.jpg");

        //读取数据,复制图片(一次读取一个字节数组,一次写入一个字节数组)
        byte[] bys = new byte[1024];
        int len;
        while ((len = fis.read(bys)) != -1) {
            fos.write(bys, 0, len);
        }
        //释放资源
        fos.close();
        fis.close();
    }
}

2.10.字节缓冲流

字节缓冲流:

  • BufferOutputStream: 该类实现缓冲输出流。通过设置这样的输出流，应用程序可以向底层输出流写入字节，而不必为写入的每个字节导致底层系统的调用

  • BufferedInputStream: 创建Bufferedlnputstream将创建一个内部缓冲区数组。当从流中读取或跳过字节时，内部缓冲区将根据需要从所包含的输入流中重新填充，一次很多字节

构造方法:

  • 字节缓冲输出流: BufferedOutputStream(OutputStream out)
  • 字节缓冲输入流: BufferedInputStream(InputStream in)

为什么构造方法需要的是字节流，而不是具体的文件或者路径呢?

  • 字节缓冲流仅仅提供缓冲区，而真正的读写数据还得依靠基本的字节流对象进行操作
import java.io.BufferedInputStream;
import java.io.FileInputStream;
import java.io.IOException;

public class BufferStreamDemo {
    public static void main(String[] args) throws IOException {
//        字节缓冲输出流: BufferedOutputStream(OutputStream out)
/*        FileOutputStream fos = new FileOutputStream("bos.txt");
          BufferedOutputStream bos = new BufferedOutputStream(fos);*/
/*
        BufferedOutputStream bos = new BufferedOutputStream(new FileOutputStream("bos.txt"));
        //写数据
        bos.write("hello\r\n".getBytes());
        bos.write("world\r\n".getBytes());
        bos.close();*/
        BufferedInputStream bis = new BufferedInputStream(new FileInputStream("bos.txt"));
        //读数据
        //一次读取一个字节数据
/*        int by;
        while ((by=bis.read())!=-1){
            System.out.print((char) by);
        }
        System.out.println("-----");
        bis.close();*/
//      一次读取一个字节数据的数据
        byte[] bys = new byte[1024];
        int len;
        while ((len=bis.read(bys))!=-1){
            System.out.println(new String(bys,0,len));

        }
        bis.close();
    }
}

2.11.复制视频(改成了gif图)

需求:把“E:字节流复制图片.avi”复制到模块目录下的“字节流复制图片.aviT

思路:

①根据数据源创建字节输入流对象

②根据目的地创建字节输出流对象

③读写数据，复制视频

④释放资源

1.基本字节流一依读写一个字节

/*
    四种方式实现复制视频,并记录每种方式复制视频的时间
        1.基本字节流一依读写一个字节 共耗时: 4986毫秒
        2.基本字节流一次读写一个字节数组 共耗时: 5253毫秒
        3.字节缓冲流一次读写一个字节	共耗时: 54毫秒
        4.字节缓冲流一次读写—个字节数组 共耗时: 5毫秒
*/

import java.io.*;

public class CopyVideo {
    public static void main(String[] args) throws IOException {
        //记录开始时间
        long startTime = System.currentTimeMillis();

        //复制视频
//        method1();
//        method2();
//        method3();
          method4();


        //记录结束时间
        long endTime = System.currentTimeMillis();
        System.out.println("共耗时: " + (endTime - startTime) + "毫秒");
    }
    //        4.字节缓冲流一次读写—个字节数组
    public static void method4() throws IOException {
        BufferedInputStream bis = new BufferedInputStream(new FileInputStream("D:\\Backup\\我的文档\\My Pictures\\Saved Pictures\\上个图很难吗.gif"));
        BufferedOutputStream bos = new BufferedOutputStream(new FileOutputStream("上个图很难吗.gif"));

        byte[] bys = new byte[1024];
        int len;
        while ((len=bis.read(bys))!=-1){
            bos.write(bys,0,len);

        }
        bos.close();
        bis.close();
    }
    //        3.字节缓冲流一次读写一个字节
    public static void method3() throws IOException {
        BufferedInputStream bis = new BufferedInputStream(new FileInputStream("D:\\Backup\\我的文档\\My Pictures\\Saved Pictures\\上个图很难吗.gif"));
        BufferedOutputStream bos = new BufferedOutputStream(new FileOutputStream("上个图很难吗.gif"));
        int by;
        while ((by = bis.read()) != -1) {
            bos.write(by);
        }
        bos.close();
        bis.close();
    }

    public static void method2() throws IOException {
        FileInputStream fis = new FileInputStream("D:\\Backup\\我的文档\\My Pictures\\Saved Pictures\\上个图很难吗.gif");
        FileOutputStream fos = new FileOutputStream("上个图很难吗.gif");

        byte[] bys = new byte[1024];
        int len;
        while ((len = fis.read()) != -1) {
            fos.write(bys, 0, len);
        }
        fos.close();
        fis.close();
    }

    public static void method1() throws IOException {
        FileInputStream fis = new FileInputStream("D:\\Backup\\我的文档\\My Pictures\\Saved Pictures\\上个图很难吗.gif");
        FileOutputStream fos = new FileOutputStream("上个图很难吗.gif");

        int by;
        while ((by = fis.read()) != -1) {
            fos.write(by);
        }
        fos.close();
        fis.close();
    }
}
奇犽0.0
关注
专栏目录
Java socket字节流传输示例解析
09-01
Java Socket字节流传输是Java网络编程中...这个例子对于理解Java Socket编程和字节流传输的基础概念非常有帮助。在实际应用中，可能需要对数据进行更复杂的处理，例如解析结构化的数据包或者编码解码特定格式的数据。
IO流java基础
奇犽的博客
11-25 233
二十四.IO流 24.1.File 1.1.File 类概述和构造方法 File:它是文件和目录路径名的抽象表示 文件和目录是可以通过File封装成对象的 对于File而言，其封装的并不是一个真正存在的文件，仅仅是一个路径名而已。它可以是存在的，也可以是不存在的。将来是要通过具体的操作把这个路径的内容转换为具体存在的 方法名 说明 File(String pathname) 通过将给定的路径名字符串转换为抽象路径名来创建新的 File实例。 File(String paren
python subprocess获取stdout和stderr
热门推荐
码农的荒岛求生
02-27 1万+
本文转载自http://www.firefoxbug.com/index.php/archives/2419/，如有版权问题请联系博主删除 用subprocess的时候，怎么获取stdout和stderr？下面是一种方式 import subprocess p = subprocess.Popen(['tail','-10','/tmp/hosts.txt'],stdin=subprocess.P...
python 管道 异步读取 stdout select_关于io：python中subprocess.PIPE上的非阻塞读取
weixin_39986060的博客
12-20 1189
我正在使用子进程模块启动子进程并连接到它的输出流(stdout)。 我希望能够在其标准输出上执行非阻塞读取。 有没有办法让.readline非阻塞或在我调用.readline之前检查流上是否有数据？ 我希望这是可移植的，或至少在Windows和Linux下工作。这是我现在的工作方式(如果没有数据可用，它会在.readline上阻塞)：p = subprocess.Popen('myprogram....
python stdout操作
npjs9806的专栏
06-24 2968
python脚本重定向方法： sys.stdout = open('pyslave.stdout', 'w', 0)         sys.stderr = open('pyslave.stderr', 'w', 0)
python调用其他程序并控制输入输出_python调用外部子进程，通过管道实现异步标准输入和输出的交互...
weixin_39706861的博客
11-21 417
我们通常会遇到这样的需求：通过C++或其他较底层的语言实现了一个复杂的功能模块，需要搭建一个基于Web的Demo，方法查询数据。由于Python语言的强大和简洁，其用来搭建Demo非常合适，Flask框架和jinja2模块功能为python提供了方便的web开发能力。同时，python能够很方便的同其他语言的代码交互。因此我们选择python作为开发Demo的工具。假设我们需要调用的模块（提供底层...
ByteIO_java_字节流_
10-04
在Java编程语言中，字节流（Byte Stream）是I/O操作的基础，它处理的是单个字节的数据。本文将详细解析"ByteIO_java_字节流_"这个主题，主要基于提供的`ByteIO.java`源代码文件，探讨字节流的基本概念、分类、常用类...
详解Java中字符流与字节流的区别
09-02
字节流是最基础的流类型，它以单个字节为最小处理单位，适用于处理任何形式的数据，包括二进制数据。Java中，InputStream和OutputStream是所有字节输入流和输出流的基类。InputStream的read()方法用于从流中读取一个...
java基础 IO流
09-05
java基础中的IO流是Java提供的一套用于文件读写操作的流式API，它包括字节流和字符流两种基本类型。字节流主要用在处理二进制数据，而字符流则是处理文本数据。 首先，文档中提到了`File`类，它是IO流操作中用于...
详解JAVA 字节流和字符流
08-19
Java字节流和字符流是Java I/O流处理中非常基础且重要的概念，它们是用于文件读写操作的两大类型。Java字节流主要包括InputStream和OutputStream两个基类及其子类，字符流则包括Reader和Writer两个基类及其子类。 ...
python stdout用法_使用Python子进程从stdout上的C程序捕获输出...
weixin_39621794的博客
12-06 1210
你不能像那样使用p.stdout;如果您要求“整个标准输出”,则只有在过程终止(或管道缓冲器填充,这可能需要很长时间)时才可用.您需要逐行读取进程的stdout.while True:ln = p.stdout.readline()if '' == ln:breakm = re.search("Thread (?P\d+)", ln);if m:# use m.group() to extract...
python 管道 异步读取 stdout select_python:从线程化子进程的stdout读取非阻塞
weixin_29563497的博客
12-30 353
我有一个脚本(worker.py),它以表单的形式打印未缓冲的输出…123...n其中n是这个脚本中的循环将要进行的一些常量迭代次数。在另一个脚本(service_controller.py)中,我启动了多个线程,每个线程使用subprocess.popen(stdout=subprocess.pipe,…)启动子进程;现在,在我的主线程(service_controller.py)中,我想读取每...
【Linux系统编程】Linux进程间通信方式---管道
chengwei1128的博客
09-29 239
IPC—管道 1.基本概念 管道依据是否有名字分为匿名管道和命名管道(有名管道)，这两种管道有一定的区别。 （平时只说管道的话，一般指的是匿名管道） 管道有以下几个特点： 其本质是一个伪文件(实为内核缓冲区)； 由两个文件描述符引用，一个表示读端，一个表示写端； 规定数据从管道的写端流入管道，从读端流出。 管道有几个重要的限制： 管道是半双工的，数据只能在一个方向上流动，A进程传给B进程，不能反向传递； 管道中的数据不能被反复读取。一旦数据被读走，则管道中就不在保留此数据； 进程不能向管道内自己写入数
python中的stdin和stdout
qq_30653631的博客
07-16 1855
如果需要更好的控制输出，而print不能满足需求，sys.stdout，sys.stdin，sys.stderr就是你需要的。python中的print()函数实际上是sys.stdout.write(obj+’\n’) 以下两行代码等价： sys.stdout.write('hello' + '\n') print('hello') sys.stdin与input sys.stdin.r...
python 管道 异步读取 stdout select_Python异步子进程连续写入stdin和读取stdout/stderr...
weixin_30674431的博客
01-28 407
我目前正在执行一项任务，其中包含python3asyncio中的子进程。我的代码只需同时写入stdin和读取stdout/stderr：import asyncioasync def read_stdout(stdout):print('read_stdout')while True:buf = await stdout.read(10)if not buf:breakprint(f'stdout...
python popen执行系统命令并获取返回值。
yihuliunian的博客
04-08 4420
转载自品略图书馆http://www.pinlue.com/article/2020/03/1106/1510011426025.html 说明： 1. 用communicate方法进行交互，直接读取p.stdout有可能数据还没刷新，会读取不到 2. windows shell参数表明是否使用windows bat作为执行的环境，因此只有在执行windows系统命令如dir,copy...
java字符流 其他特殊流笔记11.8
最新发布
m0_73618358的博客
11-08 65
{122299=林青霞, 122294=王祖贤, 122292=张曼玉}对象序列化：就是将对象保存到磁盘中，或者在网络中传输 对象。toString方法注释掉 ，依然能够准确输出。案例：复制java文件（打印流改进版）tramsient 修饰的不参与序列化。3.10 复制文件的异常处理。4.1 标准输入输出流。案例：复制多级文件夹。4.3 对象序列化流。122299,林青霞。122294,王祖贤。122292,张曼玉。
python stdout.read()阻塞_python - stdout readline（）阻塞 - 堆栈内存溢出
weixin_39768917的博客
12-10 1283
我正在尝试通过Python 2.7运行Minecraft服务器，并且工作正常。 但是，当我尝试将其传递给stop命令时，它直到服务器输出某些内容后才执行任何操作。这是我的代码：import os, sys, subprocess, threading, timeclass Server:def start(self):t = threading.Thread(target=self.run)t....
【python】subprocess readline日志未完全输出的问题
sysu_lluozh
04-20 4315
前面有关于如何监听执行时间并实时输出日志的总结【python】subprocess获取子进程输出且设置执行超时，在使用时发现一个，子进程执行的最后几行数据未输出 一、现象 p.stdout.readline输出 直接执行日志打印 经过比对发现，后面7行数据未打印 二、问题定位 2.1 输出方式 由于使用的是subprocess.PIPE管道方式，怀疑是否与此有关 将subprocess.Popen中的参数设置修改为： stdin=None stdout=None stderr=None 即没有任何重定
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值