【Python】文件操作以及Numpy常用方法

按照数据的组织形式，文件大致可以分为以下两类：文本文件与二进制文件。前者是由若干字符组成的文件，可以用文本编辑器进行阅读或编辑，例如以.txt、.py以及.html为后缀的文件都是文本文件。二进制文件是无法用文本编辑器打开的，需要使用特定的软件打开，例如.mp3、.png等格式的文件。我们下面介绍对于文件的基本操作。

open()、close()、read()以及write().

对文件的所有读写操作都是建立在打开文件的基础上进行的，并且文件的打开方式可以有多种。'r’代表read只读、'w’代表write覆盖写、'a’代表append在文件末尾追加以及’b’代表打开二进制文件，默认情况下认为open()是以只读模式打开，例如f=open("Sample.txt")，所以如果该文件不存在，程序将会报错。当对文件的内容操作完以后，一定要关闭文件，这样才能保证所修改的数据保存到文件中去，同时也释放内存资源以供其他程序使用，关闭文件使用close()函数，f.close().当然，如果你的程序在open()之后，close()之前发生了错误导致程序异常中断，那么文件就没有被正常关闭。所以在管理文件对象时使用with-as语句可以有效避免这类问题，不再需要显式的close()语句，基本的语法格式如下：

with open("Sample.txt") as f:
    str1=f.read()
    print(str1)

关于文本文件的读写操作，我们可以放在一起介绍：

• read([size])方法从文本文件中读取size个字节或字符作为结果返回，如果省略size参数，则会读取所有的内容;
• readlines()方法会读取文件中的所有行，并且将每一行的内容作为一个字符串存入列表，最终返回一个字符串列表。注意如果文件很大，那么readlines()方法就会占用大量内存，这样的情况下不推荐使用；
• readline()方法是readlines()方法的单数形式，每次只读出一行内容返回一个字符串结果。
• 除此之外我们还可以使用for line in f:这样的循环形式来读取文件中的每一行；
• wirte(s)方法向文件中写入内容字符串s，注意我们在打开文件时，'w’模式意味着文件指针在文件首部，'a’模式的文件指针在文件末尾，而write()方法是从该指针的位置开始写入的。一定要记住这一点，以面文件被无意覆盖；
• writelines(s)方法向文件中写入字符串列表s，需要注意的是，这一方法并不会为每个字符串元素单独设置一行，而是不换行地写入；

读写二进制文件.

文本文件使用字符序列来存储数据，而二进制文件使用字节序列存储数据，它只能使用特定的读取器读取。Python中的pickle模块提供了将数据序列化与反序列化的功能。

• dump(obj,file[,protocol=0])用于将对像obj序列化存储到文件file中，protocol是序列化的模式，默认值0代表文本的序列化，1或2表示二进制的序列化；
• load(file)表示从文件file中读取一个字符串，并将其重构为原本的Python对象

文件指针.

在介绍write()方法是我们提到过文件指针，它用于标志当前读写文件的位置，我们正是通过文件指针来对文件进行各种操作的。

• tell()方法可以获取当前文件指针的位置；
• seek(offset[,beg=0])可以从起始位置将文件指针后移offset个单位，注意当offset<0时等同于前移，起始位置默认为0，即文件的开头。另外beg=1代表文件指针的当前位置，beg=2代表文件末尾。

复制、移动、重命名与删除.

shutil模块中提供了我们常见的复制、移动文件操作，os模块中则提供了重命名与删除的文件操作。

• shutil.copy(src,dst)，表示将arc复制一份到dst表示的位置，例如shutil.copy(r"D:\User\Sample.txt",r"D:\User\Data\Sample.txt");
• shutil.move(src,dst)，表示将arc移动到dst表示的位置；
• os.rename(src,dst)，表示将arc重命名为dst中的名字；
• os.remove(src)，删除arc.

★Numpy中的常用操作.

Python标准库中提供了array类型用于保存数组类型的数据，但这个array不支持多维数据，处理函数也不够丰富，不适合数值运算，而Numpy库已经成为了科学计算事实上的标准库。Numpy库中最基本的数据类型是由同种元素构成的多维数组ndarry，简称数组。下面我们介绍Numpy中常用的函数，和实际使用中import numpy as np一样，我们在下面的介绍中也用np代替numpy.

• np.array([x,y,z])，用于从Python的list以及tuple类型中创建数组，并且可以是多维数组。示例代码如下所示：

import numpy as np
Array1=np.array([1,2,3,4])
Array2=np.array([[1,2],[2,3]])
Array3=np.array((1,2,3,4))
Array4=np.array(((1,2,3),(3,4,5)))
print(Array1)
print(Array2)
print(Array3)
print(Array4)

• np.arange(x,y,i)，创建一个从x到y，步长为i的数组；
• np.linspace(x,y,n)，创建一个从x到y，等分为n个元素的数组；
• np.random.rand(m,n)，创建一个m行n列的随机矩阵；
• np.ones((m,n),dtype)，创建一个m行n列的全1矩阵，dtype为数据类型；
• np.zeros((m,n),dtype)，创建一个m行n列的全0矩阵，dtype为数据类型；
• np.eye(n)，创建n阶单位矩阵。
  我们给出一段示例代码，具体看看是什么样子：

import numpy as np
list=[]
list.append(np.arange(1,10,2))
list.append(np.linspace(0,100,5))
list.append(np.random.rand(3,4))
list.append(np.ones((3,4),int))
list.append(np.zeros((3,4),int))
list.append(np.eye(3))
index=0
for i in list:
    print(index,i)
    index=index+1

★ndarray常用属性.

• ndim，返回数据的维数；
• shape，数组在每个维度上大小的元组；
• size，元素总个数；
• dtype，每个元素的类型；
• itemsize，每个元素的大小。

import numpy as np
arr=np.eye(5)
print(arr)
print(arr.ndim)
print(arr.shape)
print(arr.size)
print(arr.dtype)
print(arr.itemsize)

★ndarray常用形态变换.

• reshape(m,n)，不改变原数组，返回一个m行n列的二维数组；
• resize(m,n)，和reshape类似，但是改变原数组；
• swapaxes(ax1,ax2)，将数组的两个维度进行调换；
• flatten()，进行降维打击，返回折叠后的一维数组。

import numpy as np
arr=np.eye(6)
print(arr)
print(arr.reshape(4,9))
arr.resize(4,9)
print(arr.swapaxes(0,1))
print(arr.flatten())
arr.resize(4,3,3)
print(arr)

代码的运行结果如下，为了明显显示出形态变化，这个数组设置得有些大，可以对照着每一步的代码，检查每一步的输出：

1:
[[1. 0. 0. 0. 0. 0.]
 [0. 1. 0. 0. 0. 0.]
 [0. 0. 1. 0. 0. 0.]
 [0. 0. 0. 1. 0. 0.]
 [0. 0. 0. 0. 1. 0.]
 [0. 0. 0. 0. 0. 1.]]
2:
[[1. 0. 0. 0. 0. 0. 0. 1. 0.]
 [0. 0. 0. 0. 0. 1. 0. 0. 0.]
 [0. 0. 0. 1. 0. 0. 0. 0. 0.]
 [0. 1. 0. 0. 0. 0. 0. 0. 1.]]
3:
[[1. 0. 0. 0.]
 [0. 0. 0. 1.]
 [0. 0. 0. 0.]
 [0. 0. 1. 0.]
 [0. 0. 0. 0.]
 [0. 1. 0. 0.]
 [0. 0. 0. 0.]
 [1. 0. 0. 0.]
 [0. 0. 0. 1.]]
4:
[1. 0. 0. 0. 0. 0. 0. 1. 0. 0. 0. 0. 0. 0. 1. 0. 0. 0. 0. 0. 0. 1. 0. 0.
 - 0. 0. 0. 1. 0. 0. 0. 0. 0. 0. 1.]
5:
[[[1. 0. 0.]
  [0. 0. 0.]
  [0. 1. 0.]]

 [[0. 0. 0.]
  [0. 0. 1.]
  [0. 0. 0.]]

 [[0. 0. 0.]
  [1. 0. 0.]
  [0. 0. 0.]]

 [[0. 1. 0.]
  [0. 0. 0.]
  [0. 0. 1.]]]

★ndarray索引与切片.

ndarray是支持像Python原生的list、string那样的索引和切片操作的：

import numpy as np
arr=np.eye(6)
print(arr[2][3])
arr=np.array([1,2,3,4,5,6])
print(arr[1:5])
print(arr[1:6:2])
print(arr)

★ndarray算术运算函数.

这些函数中的x $_1$、x $_2$参数是运算的两个操作数，y参数可选，若y参数指定了则将运算结果保存到y中，否则创建一个新的数组保存计算结果。

• add、subtract、multiple、divide、floor_divide、negative、power以及remainder，这些函数都没有什么可以讲解的东西，就是我们普通的算术运算，作用于ndarray就是对应元素的算术运算。

import numpy as np
arr1=np.array([1,2,3,4])
arr2=np.array([2,4,6,8])
print(arr1+arr2)
print(arr2-arr1)
print(arr1*3)
print(arr1/2)
print(arr1//2)
print(arr1**2)
print(arr2%3)
print(arr1+9)
print(arr1*arr2)
print(arr2/arr1)
print(arr1**arr2)
print(arr1%arr2)

不难发现，其中的运算规律是这样的：

• ndarray与常数运算时，每一个元素依次与常数运算；
• 两个ndarray运算时，是其中的对应元素之间进行运算。

当然，我们上面给出代码中的算数运算符都可以写成np.add(arr1,arr2)这样的形式，不过既然有简洁明了的写法，何必呢。

★ndarray逻辑运算函数.

ndarray也支持逻辑运算符，也就是我们常见的<、>等逻辑运算：

• equal、not_equal、less、less_equal、greater、greater_equal以及比较特殊的where函数。

import numpy as np
arr1=np.array([1,2,3,4])
arr2=np.array([2,4,6,8])
print(arr1<arr2)
print(arr2<=arr1)
print(arr1>arr2)
print(arr1>=arr2)
print(arr1==arr2)
print(arr1!=arr2)
print(arr1*2==arr2)

Python的封装做得相当好，对应Numpy中的ndarray类型，几乎让我们像使用int变量一样使用ndarray，这也是我们选择使用运算符，而不是函数调用形式的原因。

★ndarray特殊运算函数.

• abs()，绝对值；
• sqrt()，算术平方根；
• square()，平方；
• sign()，符号函数，正数返回1，0返回0，负数返回-1；
• ceil()，向上取整；
• floor()，向下取整；
• rint()，四舍五入
• exp()，计算自然指数值；
• log(x)、log10(x)以及log2(x)，第一个计算自然对数值，其余两个就是字面意思。

import numpy as np
arr1=np.array([-1,2,-3,4])
arr2=np.array([1.2,2.6,3.5,4.9])
print(np.sign(arr1)) 	#[-1  1 -1  1]
arr1=np.abs(arr1)
print(arr1)				#[1 2 3 4]
print(np.sqrt(arr1))	#[1.         1.41421356 1.73205081 2.        ]
print(np.square(arr1))	#[ 1  4  9 16]
print(np.ceil(arr2))	#[2. 3. 4. 5.]
print(np.floor(arr2))	#[1. 2. 3. 4.]
print(np.rint(arr2)) 	#[1. 3. 4. 5.]
arr1=np.exp(arr1)		
print(arr1)				#[ 2.71828183  7.3890561  20.08553692 54.59815003]
print(np.log(arr1))		#[1. 2. 3. 4.]
arr3=np.array([10,100,1000,10000])
print(np.log10(arr3))	#[1. 2. 3. 4.]
arr3=np.array([1024,2048,4096,65536])
print(np.log2(arr3))	#[10. 11. 12. 16.]

程序输出的结果，都在每一个print语句之后的注释中了。