Pandas数据帧(DataFrame)的基本属性和方法

1、DataFrame属性:

  • T:转置行和列。
  • axes:返回行轴标签列表。
  • dtypes:返回对象的数据类型。
  • empty:如果系列为空,则返回True。
  • ndim:返回底层数据的维数,默认定义:1。
  • size:返回基础数据中的元素数。。
  • values:将系列作为ndarray返回。
  • shape:返回表示DataFrame的维度的元组。
import pandas as pd
import numpy as np

data = {"Name": pd.Series(['nanako', 'kanghee', 'ranglee', 'ricky', 'vin', 'Jack', 'Tom']),
        "Age": pd.Series([18, 20, 22, 24, 38, 44, 50]),
        "Company": pd.Series(['Taobao', 'Alipay', 'Sina', 'Sohu', 'Tencent', 'Weibo', 'MeiTuan']),
        }

df = pd.DataFrame(data)

print(df)
'''
      Name  Age  Company
0   nanako   18   Taobao
1  kanghee   20   Alipay
2  ranglee   22     Sina
3    ricky   24     Sohu
4      vin   38  Tencent
5     Jack   44    Weibo
6      Tom   50  MeiTuan
'''

# 返回DataFrame的转置。
print(df.T)
'''
              0        1        2      3        4      5        6
Name     nanako  kanghee  ranglee  ricky      vin   Jack      Tom
Age          18       20       22     24       38     44       50
Company  Taobao   Alipay     Sina   Sohu  Tencent  Weibo  MeiTuan
'''

# 返回行轴标签和列轴标签列表
print(df.axes)  # [RangeIndex(start=0, stop=7, step=1), Index(['Name', 'Age', 'Company'], dtype='object')]

# 返回每列的数据类型
print(df.dtypes)
'''
Name       object
Age         int64
Company    object
dtype: object
'''

# 返回布尔值,表示对象是否为空; 返回True表示对象为空
print(df.empty)   # False

# 返回对象的维数
print(df.ndim)    # 2

# 返回表示DataFrame的维度的元组。 元组(a,b),其中a表示行数,b表示列数
print(df.shape)   # (7, 3)

# 返回DataFrame中的元素数。
print(df.size)    # 21

# 将DataFrame中的实际数据作为NDarray返回
print(df.values)
'''
[['nanako' 18 'Taobao']
 ['kanghee' 20 'Alipay']
 ['ranglee' 22 'Sina']
 ['ricky' 24 'Sohu']
 ['vin' 38 'Tencent']
 ['Jack' 44 'Weibo']
 ['Tom' 50 'MeiTuan']]
'''

2、DataFrame方法:

  • head():返回前N行。
  • tail():返回后N行。
import pandas as pd
import numpy as np

data = {"Name": pd.Series(['nanako', 'kanghee', 'ranglee', 'ricky', 'vin', 'Jack', 'Tom']),
        "Age": pd.Series([18, 20, 22, 24, 38, 44, 50]),
        "Company": pd.Series(['Taobao', 'Alipay', 'Sina', 'Sohu', 'Tencent', 'Weibo', 'MeiTuan']),
        }

df = pd.DataFrame(data)

print(df)
'''
      Name  Age  Company
0   nanako   18   Taobao
1  kanghee   20   Alipay
2  ranglee   22     Sina
3    ricky   24     Sohu
4      vin   38  Tencent
5     Jack   44    Weibo
6      Tom   50  MeiTuan
'''

# head()返回前n行(观察索引值)。显示元素的默认数量为5,但可以传递自定义数字值。
print(df.head(2))
'''
      Name  Age Company
0   nanako   18  Taobao
1  kanghee   20  Alipay
'''

# 返回最后n行(观察索引值)。显示元素的默认数量为5,但可以传递自定义数字值。
print(df.tail(2))
'''
   Name  Age  Company
5  Jack   44    Weibo
6   Tom   50  MeiTuan
'''

 

Pandas系列(Series)的基本属性和方法

1、Series属性:

  • axes:返回行轴标签列表。
  • dtype:返回对象的数据类型。
  • empty:如果系列为空,则返回True。
  • ndim:返回底层数据的维数,默认定义:1。
  • size:返回基础数据中的元素数。。
  • values:将系列作为ndarray返回。
import pandas as pd
import numpy as np

s = pd.Series(np.random.randn(4))
print(s)

# axes 返回系列的标签列表。
print(s.axes)   # [RangeIndex(start=0, stop=4, step=1)]

# 返回对角的数据类型
print(s.dtype)  # float64

# empty 返回布尔值,表示对象是否为空。返回True则表示对象为空。
print(s.empty)  # False

# ndim 返回对象的维数
print(s.ndim)   # 1

# 返回系列的大小(长度)
print(s.size)   # 4

# 以数组形式返回系列中的实际数据值。
print(s.values)     # [0.13208987 0.68657237 0.99915012 0.92312993]

2、Series方法:

  • head():返回前N行。
  • tail():返回后N行。
import pandas as pd
import numpy as np

s = pd.Series(np.random.randn(4))

print(s)
'''
0   -0.030506
1    0.179275
2   -1.249866
3   -1.179606
dtype: float64
'''

# head()返回前n行(观察索引值)。要显示的元素的默认数量为5,但可以传递自定义这个数字值。
print(s.head(2))
'''
0   -0.030506
1    0.179275
dtype: float64
'''

# tail()返回最后n行(观察索引值)。 要显示的元素的默认数量为5,但可以传递自定义数字值。
print(s.tail(2))
'''
2   -1.249866
3   -1.179606
dtype: float64
'''

 

Pandas数据帧(DataFrame)的常用操作

数据帧(DataFrame)是二维数据结构,即数据以行和列的表格方式排列。

结构体:

假设要创建一个包含学生数据的数据帧。参考以下图示

可以将上图表视为SQL表或电子表格数据表示。

Pandas.DataFrame

pandas中的DataFrame可以使用以下构造函数创建

pandas.DataFrame( data, index, columns, dtype, copy)
编号 参数 描述
1 data 数据采取各种形式,如:ndarray,series,map,lists,dict,constant和另一个DataFrame。
2 index 对于行标签,要用于结果帧的索引是可选缺省值np.arrange(n),如果没有传递索引值。
3 columns 对于列标签,可选的默认语法是 – np.arange(n)。 这只有在没有索引传递的情况下才是这样。
4 dtype 每列的数据类型。
5 copy 如果默认值为False,则此命令(或任何它)用于复制数据。

创建DataFrame

  • 列表
  • 字典
  • 系列
  • Numpy ndarrays
  • 另一个数据帧(DataFrame)

1、创建一个空的DataFrame

创建基本数据帧是空数据帧。

>>> import pandas as pd
>>> df = pd.DataFrame()
>>> df
Empty DataFrame
Columns: []
Index: []

2、从列表创建DataFrame

可以使用单个列表或列表列表创建数据帧(DataFrame)。

>>> import pandas as pd
>>> data = [1,2,3,4,5]
>>> df = pd.DataFrame(data)
>>> df
   0
0  1
1  2
2  3
3  4
4  5

示例2:

>>> import pandas as pd
>>> data = [['nanako',18],['kanghee',20],['ranglee',22]]
>>> df = pd.DataFrame(data, columns=['Name','Age'], dtype=float)
>>> df
      Name   Age
0   nanako  18.0
1  kanghee  20.0
2  ranglee  22.0

3、从ndarrays/Lists的字典来创建DataFrame

所有的ndarrays必须具有相同的长度。如果传递了索引(index),则索引的长度应等于数组的长度。如果没有传递索引,则默认情况下,索引将为range(n),其中n为数组长度。

>>> import pandas as pd
>>> data = {'Name':['nanako','kanghee','ranglee','ricky'],'Age':[18,20,22,24]}
>>> df = pd.DataFrame(data)
>>> df
      Name  Age
0   nanako   18
1  kanghee   20
2  ranglee   22
3    ricky   24

使用数组创建一个索引的数据帧(DataFrame)。

>>> import pandas as pd
>>> data = {'Name':['nanako','kanghee','ranglee','ricky'],'Age':[18,20,22,24]}
>>> df = pd.DataFrame(data, index=['index1','index2','index3','index4'])
>>> df
           Name  Age
index1   nanako   18
index2  kanghee   20
index3  ranglee   22
index4    ricky   24

4、从列表创建数据帧DataFrame

>>> import pandas as pd
>>> data = [{'a':1,'b':2},{'a':5,'b':10,'c':20}]
>>> df = pd.DataFrame(data)
>>> df
   a   b     c
0  1   2   NaN
1  5  10  20.0

注意:观察到,NaN(不是数字)被附加在缺失的区域。

以下示例显示如何通过传递字典列表和行索引来创建数据帧(DataFrame)。

>>> import pandas as pd
>>> data = [{'a':1,'b':2},{'a':5,'b':10,'c':20}]
>>> df = pd.DataFrame(data, index=['index1','index2'])
>>> df
        a   b     c
index1  1   2   NaN
index2  5  10  20.0

5、从系列的字典来创建DataFrame

字典的系列可以传递以形成一个DataFrame。 所得到的索引是通过的所有系列索引的并集。

>>> import pandas as pd
>>> data = {'one':pd.Series([1,2,3],index=['a','b','c']),'two':pd.Series([1,2,3,4],index=['a','b','c','d'])}
>>> df = pd.DataFrame(data)
>>> df
   one  two
a  1.0    1
b  2.0    2
c  3.0    3
d  NaN    4

列选择、列添加、列删除

示例1:列选择

>>> import pandas as pd
>>> data = {'one':pd.Series([1,2,3],index=['a','b','c']),'two':pd.Series([1,2,3,4],index=['a','b','c','d'])}
>>> df = pd.DataFrame(data)
>>> df['one']
a    1.0
b    2.0
c    3.0
d    NaN
Name: one, dtype: float64

示例2:列添加

>>> import pandas as pd
>>> data = {'one':pd.Series([1,2,3],index=['a','b','c']),'two':pd.Series([1,2,3,4],index=['a','b','c','d'])}
>>> df = pd.DataFrame(data)
>>> df['three'] = pd.Series([10,20,30],index=['a','b','c'])
>>> df
   one  two  three
a  1.0    1   10.0
b  2.0    2   20.0
c  3.0    3   30.0
d  NaN    4    NaN

示例3:列删除

>>> import pandas as pd
>>> data = {'one':pd.Series([1,2,3],index=['a','b','c']),'two':pd.Series([1,2,3,4],index=['a','b','c','d'])}
>>> df = pd.DataFrame(data)
>>> df['three'] = pd.Series([10,20,30],index=['a','b','c'])
>>> del df['one']
>>> df
   two  three
a    1   10.0
b    2   20.0
c    3   30.0
d    4    NaN
>>> df.pop('two')
a    1
b    2
c    3
d    4
Name: two, dtype: int64

行选择、行添加、行删除

标签选择:可以通过将行标签传递给loc()函数来选择行。

>>> import pandas as pd
>>> data = {'one':pd.Series([1,2,3],index=['a','b','c']),'two':pd.Series([1,2,3,4],index=['a','b','c','d'])}
>>> df = pd.DataFrame(data)
>>> df.loc['a']
one    1.0
two    1.0
Name: a, dtype: float64

结果是一系列标签作为DataFrame的列名称。 而且,系列的名称是检索的标签。

按整数位置选择:可以通过将整数位置传递给iloc()函数来选择行。

>>> import pandas as pd
>>> data = {'one':pd.Series([1,2,3],index=['a','b','c']),'two':pd.Series([1,2,3,4],index=['a','b','c','d'])}
>>> df.iloc[2]
one    3.0
two    3.0
Name: c, dtype: float64

行切片

可以使用:运算符选择多行。

>>> import pandas as pd
>>> data = {'one':pd.Series([1,2,3],index=['a','b','c']),'two':pd.Series([1,2,3,4],index=['a','b','c','d'])}
>>> df = pd.DataFrame(data)
>>> df[2:4]
   one  two
c  3.0    3
d  NaN    4

附加行

使用append()函数将新行添加到DataFrame。 此功能将附加行结束。

>>> import pandas as pd
>>> df = pd.DataFrame([[1, 2], [3, 4]], columns = ['a','b'])
>>> df2 = pd.DataFrame([[5, 6], [7, 8]], columns = ['a','b'])
>>> df = df.append(df2)
>>> df
   a  b
0  1  2
1  3  4
0  5  6
1  7  8

删除行

使用索引标签从DataFrame中删除或删除行。 如果标签重复,则会删除多行。

>>> import pandas as pd
>>> df = pd.DataFrame([[1, 2], [3, 4]], columns = ['a','b'])
>>> df2 = pd.DataFrame([[5, 6], [7, 8]], columns = ['a','b'])
>>> df = df.append(df2)
>>> df = df.drop(0)
>>> df
   a  b
1  3  4
1  7  8

 

Pandas.Series创建系列4种方式和系列索引

Pandas系列可以使用以下构造函数创建

pandas.Series( data, index, dtype, copy)构造函数的参数如下
编号 参数 描述
1 data 数据采取各种形式,如:ndarray,list,constants
2 index 索引值必须是唯一的和散列的,与数据的长度相同。 默认np.arange(n)如果没有索引被传递。
3 dtype dtype用于数据类型。如果没有,将推断数据类型
4 copy 复制数据,默认为false。

可以使用各种输入创建一个系列

  • 数组
  • 字典
  • 标量值或常数

1、创建一个空的系列

>>> import pandas as pd
>>> s = pd.Series()
>>> s
Series([], dtype: float64)

2、从ndarray创建一个系列

如果数据是ndarray,则传递的索引必须具有相同的长度。 如果没有传递索引值,那么默认的索引将是范围(n),其中n是数组长度,即[0,1,2,3…. range(len(array))-1] – 1]。

>>> import pandas as pd
>>> import numpy as np
>>> data = np.array(['a','b','c','d'])
>>> s = pd.Series(data)
>>> s
0    a
1    b
2    c
3    d
dtype: object

这里没有传递任何索引,因此默认情况下,它分配了从0到len(data)-1的索引,即:0到3。

>>> import pandas as pd
>>> import numpy as np
>>> data = np.array(['a','b','c','d'])
>>> s = pd.Series(data, index=[100,101,102,103])
>>> s
100    a
101    b
102    c
103    d
dtype: object

在这里传递了索引值。现在可以在输出中看到自定义的索引值。

3、从字典创建一个系列

字典(dict)可以作为输入传递,如果没有指定索引,则按排序顺序取得字典键以构造索引。 如果传递了索引,索引中与标签对应的数据中的值将被拉出。

>>> import pandas as pd
>>> import numpy as np
>>> data = {"name":"nanako","age":18,"company":"TaoBao"}
>>> s = pd.Series(data)
>>> s
name       nanako
age            18
company    TaoBao
dtype: object

注意:字典键用于构建索引。

4、从标量创建一个系列

如果数据是标量值,则必须提供索引。将重复该值以匹配索引的长度。

>>> import pandas as pd
>>> import numpy as np
>>> s = pd.Series(5, index=[0,1,2,3])
>>> s
0    5
1    5
2    5
3    5
dtype: int64

从具有位置的系列中访问数据

系列中的数据可以使用类似于访问ndarray中的数据来访问。

检索第一个元素。比如已经知道数组从零开始计数,第一个元素存储在零位置等等。

>>> import pandas as pd
>>> s = pd.Series([1,2,3,4,5], index=['a','b','c','d','e'])
>>> s[0]
1

检索系列中的前三个元素。 如果a:被插入到其前面,则将从该索引向前的所有项目被提取。 如果使用两个参数(使用它们之间),两个索引之间的项目(不包括停止索引)。

>>> import pandas as pd
>>> s = pd.Series([1,2,3,4,5], index=['a','b','c','d','e'])
>>> s[:3]
a    1
b    2
c    3
dtype: int64

检索最后三个元素

>>> import pandas as pd
>>> s = pd.Series([1,2,3,4,5], index=['a','b','c','d','e'])
>>> s[-3:]
c    3
d    4
e    5
dtype: int64

使用标签检索数据(索引)

使用索引标签值检索单个元素。

>>> import pandas as pd
>>> s = pd.Series([1,2,3,4,5], index=['a','b','c','d','e'])
>>> s['a']
1

使用索引标签值列表检索多个元素。

>>> import pandas as pd
>>> s = pd.Series([1,2,3,4,5], index=['a','b','c','d','e'])
>>> s[['a','b','c']]
a    1
b    2
c    3
dtype: int64

如果不包含标签,则会出现异常。

>>> import pandas as pd
>>> s = pd.Series([1,2,3,4,5], index=['a','b','c','d','e'])
>>> s['f']
...
KeyError: 'f'

NumPy中random模块用法总结

1、numpy中产生随机数的方法

  • rand()   产生[0,1]的浮点随机数,括号里面的参数可以指定产生数组的形状
  • randn()  产生标准正太分布随机数,参数含义与random相同
  • randint()  产生指定范围的随机数,最后一个参数是元祖,他确定数组的形状
  • random_integers(low[, high, size])  返回随机的整数,位于闭区间 [low, high]。
  • random_sample([size])  返回随机的浮点数,在半开区间 [0.0, 1.0)。
  • random([size])  返回随机的浮点数,在半开区间 [0.0, 1.0)。
>>> import numpy as np
>>> np.random.rand(3,2)
array([[0.89568903, 0.67137793],
       [0.67693093, 0.57607126],
       [0.74009118, 0.68072618]])
>>> np.random.randn(3,2)
array([[-0.65032648, -0.79415556],
       [-0.24292345, -0.90326513],
       [ 0.92086505,  1.77013844]])
>>> np.random.randint(0,10,size=(2,5))
array([[6, 6, 4, 7, 7],
       [4, 7, 1, 1, 9]])
>>> np.random.random_sample(5)
array([0.97, 0.05, 0.25, 0.2 , 0.39])

2、常用分布

  • normal()  正太分布
  • uniform()  均匀分布
  • poisson()  泊松分布
>>> np.random.randint(0,10,size=(2,5))
array([[6, 6, 4, 7, 7],
       [4, 7, 1, 1, 9]])
>>> import numpy as np
>>> np.set_printoptions(precision=2)
>>> r1 = np.random.normal(100,10,size=(3,4))
>>> r1
array([[105.27, 104.85, 101.77, 102.73],
       [103.  ,  70.28,  96.11,  81.3 ],
       [107.95, 102.12, 101.67, 101.84]])
>>> r2 = np.random.uniform(0,10,size=(3,4))
>>> r2
array([[3.31, 7.91, 2.42, 0.79],
       [4.47, 6.54, 9.02, 0.6 ],
       [0.03, 5.38, 5.76, 0.36]])
>>> r3 = np.random.poisson(2.0,size=(3,4))
>>> r3
array([[2, 2, 0, 4],
       [3, 1, 2, 3],
       [3, 3, 3, 1]])

 

NumPy中ndarray对象的常见属性

1、ndim:数组的维数(即数组轴的个数),等于秩。最常见的为二维数组(矩阵)。

>>> import numpy as np
>>> x = np.ones((3,3))
>>> x.ndim
2

2、shape:数组的维度。为一个表示数组在每个维度上大小的整数元组。ndarray.shape返回一个元组,这个元组的长度就是维度的数目,即ndim属性。

>>> import numpy as np
>>> x = np.ones((3,3))
>>> x.shape
(3, 3)

3、size:数组元素的总个数,等于shape属性中元组元素的乘积。

>>> import numpy as np
>>> x = np.ones((3,3))
>>> x.size
9

4、dtype:表示数组中元素类型的对象,可使用标准的Python类型创建或指定dtype。所有类型可通过set(np.typeDict.values())查看

>>> import numpy as np
>>> x = np.ones((3,3))
>>> x.dtype
dtype('float64')

5、itemsize:数组中每个元素的字节大小。例如,一个元素类型为float64的数组itemsiz属性值为8(float64占用64个bits,每个字节长度为8,占用8个字节),又如一个元素类型为complex32的数组item属性为4。

>>> import numpy as np
>>> x = np.ones((3,3))
>>> x.itemsize
8

6、data:包含实际数组元素的缓冲区地址,由于一般通过数组的索引获取元素,所以通常不需要使用这个属性。

>>> import numpy as np
>>> x = np.ones((3,3))
>>> x.data
<memory at 0x110251a68>

7、nbytes: 这个array的总字节数(=itemsize*size)

>>> import numpy as np
>>> x = np.ones((3,3))
>>> x.nbytes
72

8、real: 代表一个array中所有元素的实数部分

>>> import numpy as np
>>> x = np.ones((3,3))
>>> x.real
array([[1., 1., 1.],
       [1., 1., 1.],
       [1., 1., 1.]])

9、flat: 将这个array整理成一维的,可以索引的一系列的元素组合。它实际上是通过iterator实现的,我们可以通过for x in array.flat来取得到所有的元素

>>> import numpy as np
>>> x = np.ones((3,3))
>>> x.flat
<numpy.flatiter object at 0x7f829e141800>
>>> list(x.flat)
[1.0, 1.0, 1.0, 1.0, 1.0, 1.0, 1.0, 1.0, 1.0]

10、T: 转置矩阵,同transpose()方法返回值

>>> import numpy as np
>>> x = np.arange(10).reshape((2,5))
>>> x
array([[0, 1, 2, 3, 4],
       [5, 6, 7, 8, 9]])
>>> x.T
array([[0, 5],
       [1, 6],
       [2, 7],
       [3, 8],
       [4, 9]])

NumPy中full、eye、empty、random、zeros、ones创建ndarray对象

1、np.full创建一个由常数填充的数组,第一个参数是数组的形状,第二个参数是数组中填充的常数。

>>> import numpy as np
>>> np.full((3,3),8)
array([[8, 8, 8],
       [8, 8, 8],
       [8, 8, 8]])

2、np.eye创建单位矩阵,函数中的参数n,则创建n * n的单位矩阵

>>> import numpy as np
>>> np.eye(5)
array([[1., 0., 0., 0., 0.],
       [0., 1., 0., 0., 0.],
       [0., 0., 1., 0., 0.],
       [0., 0., 0., 1., 0.],
       [0., 0., 0., 0., 1.]])

3、np.empty、np.random.random两者都是按照参数中给出的形状来创建数组,前者生成随机矩阵,后者创建随机数数组。

>>> import numpy as np
>>> np.empty((2,3))
array([[2.31584178e+077, 2.31584178e+077, 2.24814471e-314],
       [2.24817786e-314, 0.00000000e+000, 4.17203470e-309]])
>>> import numpy as np
>>> np.random.random((2,3))
array([[0.93313789, 0.03068198, 0.17294689],
       [0.34856997, 0.82201409, 0.89231669]])

4、np.zeros(shape, dtype=float64, order=’C’) : 产生0数组.shapre可以是数字(一维数字),也可以(3,4)这样多维数组

>>> import numpy as np
>>> np.zeros((2,3))
array([[0., 0., 0.],
       [0., 0., 0.]])

5、np.ones(shape, dtype=float64, order=’C’) : 产生全是1的数组

>>> import numpy as np
>>> np.ones((2,3))
array([[1., 1., 1.],
       [1., 1., 1.]])

Python的re模块中match、search、findall的区别

re是Python中用于正则表达式相关处理的类,这四个方法都是用于匹配字符串的,具体区别如下:

match:匹配string 开头,成功返回Match object, 失败返回None,只匹配一个。

search:在string中进行搜索,成功返回Match object, 失败返回None, 只匹配一个。

findall:在string中查找所有 匹配成功的组, 即用括号括起来的部分。返回list对象,每个list item是由每个匹配的所有组组成的list。

import re

s = 'f80adsa30da7aae'

r1 = re.match('\d', s) # 从头匹配
r2 = re.search('\d', s)
r3 = re.findall('\d', s)
print(r1)
print(r2)
print(r2.group())
print(r3)

s1 = 'life is short, i use python'
r4 = re.search('life(.*)python', s1)
print(r4.group(0))
print(r4.group(1))

python中如何将元组(tuple)、列表(list)展开

可迭代元素(列表, 元组, 生成器等)展开, 可以使用*

1、列表展开:

l = ['kanghee', 'nanako','ranglee']

print(*l) # 输出 kanghee nanako ranglee

1、元展开:

t = ('kanghee', 'nanako','ranglee')

print(*t) # 输出 kanghee nanako ranglee

 

Python中StringIO与BytesIO与区别

1、StringIO

StringIO 是io 模块中的类,在内存中开辟的一个文本模式的buffer,可以像文件对象一样操作它。当close 方法被调用的时候,这个buffer 会被释放。

好处:一般来说,磁盘的操作比内存的操作要慢的多,内存足够的时候,一般的优化思路是少落地,减少磁盘IO的过程,可以大大提高程序的运行速度。业务中单机情况可以使用StringIo或者BytesIO,多机就考虑使用 redis。
缺点:内存断电,buffer 中的数据会丢失,所以不建议存储很重要的数据,但可以存储日志之类的丢失也没有大影响的数据。

1.1、导入

from io import StringIO

1.2、方法

  • close():刷新和关闭流。
  • readline()、readlines()、read:读取。
  • writelines(lines):将多行数据列表写入到流中。不会自动添加行分隔符,因此提供的每一条行数据的最后通常都有行分隔符(即给的行数据本身在每一行后面有行分隔符)。
  • getvalue():获取全部内容
  • readable():返回True如果流是可读的,返回False,如果流不可读,并且引发OSError错误。
  • writable():返回True,如果流是可写的。如果返回False,write()和truncate()操作会引发OSError操作。
  • seekable():返回True,如果流支持随机访问。如果返回错误,那么seek(),tell()和truncate()函数被调用时会引发OSError。
  • seek():设定该文件的当前位置。
  • tell():返回流中游标的当前位置。
  • flush():刷新写缓冲区,这个操作对于只读流和非阻塞流不起作用。
from io import StringIO

f = StringIO()

# 返回 True True True
print(f.readable(), f.writable(), f.seekable())

f.write("hello\nPython")
f.seek(0)

# 返回 hello 读取1行。如果是readlines,返回一个列表 ['hello\n', 'Python']
print(f.readline())

# 读取一行后,文件指针移到了下行行首
f.tell()

# 不受文件指针影响,输出全部内容
print(f.getvalue())

f.close()

2、BytesIO

BytesIO 也是io模块中的类,内存中开辟的一个二进制模式的buffer,也可以像文件对象一样操作它,当close方法调用的时候,这个buffer也会被释放。

简单使用方法与StringIO 一样:

from io import BytesIO

f = BytesIO()

# 返回 True True True
print(f.readable(), f.writable(), f.seekable())

f.write("hello\nPython".encode('utf-8'))
f.seek(0)

# 返回 hello 读取1行。如果是readlines,返回一个列表 ['hello\n', 'Python']
print(f.readline())

# 读取一行后,文件指针移到了下行行首
f.tell()

# 不受文件指针影响,输出全部内容
print(f.getvalue())

f.close()

请注意,写入的不是str,而是经过UTF-8编码的bytes。

3、StringIO、BytesIO的区别

StringIO操作的只能是str数据,BytesIO操作的只能是二进制数据。

4、小结:

  StringIO和BytesIO是在内存中操作str和bytes的方法,使得和读写文件具有一致的接口

近期文章

近期评论

    标签

    随机文章