python相关用法

梦中生花

于 2023-03-28 20:37:38 发布

阅读量1.5k

点赞数 3

文章标签： python numpy 数据分析

本文链接：https://blog.csdn.net/qwe14325/article/details/129824465

版权

python相关用法

文章目录

python相关用法

常见库及其用法

内置函数

zip()

data_dicts = [
    {"image": image_name, "label": label_name}
    for image_name, label_name in zip(image_paths, label_paths)
]

zip() 函数是 Python 内置函数之一，它的作用是将多个可迭代对象中的元素按照索引位置打包成一个个元组，并返回由这些元组组成的迭代器。

具体来说，zip() 函数接受任意多个可迭代对象作为参数，其中每个可迭代对象的元素个数可以不同。zip() 函数会遍历这些可迭代对象中的元素，按照索引位置将它们打包成元组，然后返回由这些元组组成的迭代器。当任意一个可迭代对象用尽时，迭代器停止迭代。

例如，假设有两个列表 a 和 b：

a = [1, 2, 3]
b = ['a', 'b', 'c']
c = zip(a, b)
for x in c:
    print(x)
    
# 输出结果
(1, 'a')
(2, 'b')
(3, 'c')

从输出结果可以看出，zip() 函数将列表 a 和 b 中的元素按照索引位置进行了打包，然后返回了由这些元组组成的迭代器。

numpy 库

数组的内积和点乘以及乘除

内积

m = np.array([[1, 2, 3], [4, 5, 6]])       # 2X3
n = np.array([[1, 2], [3, 4], [5, 6]])     # 3X2
p = np.dot(m, n)
q = np.matmul(m, n)

点乘

m = np.array([[1, 2, 3], [4, 5, 6]])       # 2X3
n = np.array([[1, 2], [3, 4], [5, 6]])     # 3X2
p = m*n
q = np.multiply(m, n)

事实上做点乘的两个矩阵的形状不一定要相同

数组平方、乘除法、加减法

m = np.array([[1, 2, 3], [4, 5, 6]])
n = m**2 或者 n = m*m
# 数组中所有元素进行缩放
n = m*100 // n = m/100
n = m+100 // n = m-100

linspace()函数

list_1 = np.linspace(0, 9)
list_2 = np.linspace(0, 9, num=10)
list_3 = np.linspace(0, 9, num=10, retstep=True)
list_4 = np.linspace(1, 9, num=10, endpoint=False)

start：起始点
stop：终止点【包含】，左闭右闭
num : 生成start和stop之间num个等差间隔的元素，默认50，
endpoint ：生成等差间隔为 (stop - start)/num 的元素，默认为True
retstep：返回一个（array，num）元组，array是结果数组，num是间隔大小，默认False
dtype：输出数组的类型。

ceil() & floor() & round() & around()函数

np.ceil() 向上取整，
np.floor()向下取整
np.round()和np.around() 四舍六入五成双

round | around(array, decimals=0, out=None)

其中，decimals 指定保留小数点后的位数。默认值为0。如果为负，整数将四舍五入到小数点左侧的位置

round()和around()功能是一样的

a = np.array([1.2, 4.3, 5.6, 7.2, 8.1])
print(np.ceil(a))  # 向上取整，不是四舍五入
print(np.floor(a))  # 向下取整，不是四舍五入
print(np.around(a))	# 四舍五入

# 输出结果
[2. 5. 6. 8. 9.]
[1. 4. 5. 7. 8.]
[1. 4. 6. 7. 8.]

argmax()函数

numpy.argmax(array, axis) 用于返回一个numpy数组中最大值的索引值。当一组中同时出现几个最大值时，返回第一个最大值的索引

import numpy as np
a = np.array([[1, 5, 5, 2],
              [9, 6, 2, 8],
              [3, 7, 9, 1]])
b=np.argmax(a, axis=0)  #按列搜索最大值，每列最大值的下标
c=np.argmax(a, axis=1)	#按行搜索最大值，每行最大值的下标

结果为:
b = [1 2 2 1]
c = [1 0 2]

mean()函数

mean() 函数定义：

import numpy as np

numpy.mean(a, axis, dtype, out，keepdims )

print(np.mean(a))
2.5

print(np.mean(a, axis=0)) # axis=0，计算每一列的均值
[2. 3.]

print(np.mean(a, axis=1)) # axis = 1计算每一行的均值

mean() 函数功能：求取均值，经常操作的参数为axis，以m * n矩阵举例：

axis 不设置值，对 m * n 个数求均值，返回一个实数；
		axis = 0：压缩行，对各列求均值，返回 1 * n 矩阵；
		axis = 1 ：压缩列，对各行求均值，返回 m * 1 矩阵。

std()函数

import numpy as np

np.std(a, axis=None, dtype=None, out=None, ddof=0, keepdims=)

axis=0时，表示求每一列标准差；

axis=1时，表示求每一行标准差；

当axis=None时，表示求全局标准差。

shape()函数

shape 包含在 numpy 库中，是矩阵（ndarray）的属性，可以获取矩阵的形状（例如二维数组的行列），获取的结果是一个元组，例如：

import numpy as np
x = np.array([[1, 2, 3, 4, 5], 
              [6, 7, 8, 9, 10], 
              [10, 9, 8, 7, 6], 
              [5, 4, 3, 2, 1]])
#输出数组的行和列数
print(np.shape(x)) 	#结果： (4, 5)
#输出数组的行数
print(np.shape(x)[0]) #结果： 4
#输出数组的列数
print(np.shape(x)[1]) #结果： 5

zeros() & ones() & empty()函数

np.zeros()：返回来一个给定形状和类型的用0填充的数组

zeros(shape, dtype=float, order='C')
# shape：表示形状
# dtype: 数据类型，可选参数，默认numpy.float64
# order: 可选参数，c代表行优先；F代表列优先

示例：

array=np.zeros(5)	# 创建一维数组
array=np.zeros((5,2))	# 创建多维数组

np.ones()：返回给定形状和数据类型的新数组，其中元素的值设置为1

用法与np.zeros()类似

np.ones(shape, dtype=float, order='C')

np.empty()创建一个随机数值的ndarray数组

np.empty(shape, dtype=float, order='C')

identity() & diag() & eye()函数

np.identity(3)		#单位矩阵
array([[1,0,0],
      [0,1,0],
      [0,0,1]])

np.diag([1,2,3,4])	#对角矩阵
array([[1,0,0,0],
      [0,2,0,0],
      [0,0,3,0],
      [0,0,0,4]])

np.eye(N, M=None, k=0, dtype=float)
# np.eye()是一个NumPy函数，用于创建一个二维数组（矩阵），该数组的对角线元素为1，其余元素为0。
# 参数N表示输出数组的行数；参数M表示输出数组的列数，默认值为None，表示列数等于行数；
# 参数k表示对角线的偏移量，当k=0时，对角线位于数组的主对角线上，当k>0时，对角线位于主对角线的上方，当k<0时，对角线位于主对角线的下方；参数dtype表示输出数组的数据类型，默认为float。
arr = np.eye(4, 4, 1)
array([[0., 1., 0., 0.],
       [0., 0., 1., 0.],
       [0., 0., 0., 1.],
       [0., 0., 0., 0.]])

随机数组(random)

np.random.randint(0,50,5)		#随机数组，5个 0到50之间的整数
np.random.randint(0,50,(3,5))	#3行5列
np.random.rand(10)				#10个介于[0,1)的随机数
np.random.standard_normal(5)	#从标准正态分布中随机采样5个数字
np.random.standard_normal(size=(2,4,3))	#3页4行2列

fliplr()和flipud()函数

numpy.fliplr()：向左/向右翻转数组

numpy.flipud()：向上/向下翻转数组

语法：

numpy.fliplr(array)
numpy.flipud(array)
# 参数array：Input array, must be at least 2-D.

示例：

numpy.fliplr()

>>> A = np.diag([1.,2.,3.])
>>> A
array([[1.,  0.,  0.],
       [0.,  2.,  0.],
       [0.,  0.,  3.]])
       
>>> np.fliplr(A)
array([[0.,  0.,  1.],
       [0.,  2.,  0.],
       [3.,  0.,  0.]])

numpy.flipud()

>>> A = np.diag([1.0, 2, 3])
>>> A
array([[1.,  0.,  0.],
       [0.,  2.,  0.],
       [0.,  0.,  3.]])
       
>>> np.flipud(A)
array([[0.,  0.,  3.],
       [0.,  2.,  0.],
       [1.,  0.,  0.]])

tqdm库

tqdm()函数

tqdm 是一个快速，可扩展的Python进度条，可以在 Python 长循环中添加一个进度提示信息，用户只需要封装任意的迭代器 tqdm(iterator)，使用pip就可以安装。

trange(i) 是 tqdm(range(i)) 的简单写法

bar = tqdm(["a", "b", "c", "d"])
for char in bar:
    bar.set_description("Processing %s" % char)
    
效果：    
Processing d: 100%|███████████████████████████████████| 857K/857K [00:04<00:00, 246Kloc/s]

logging库

basicConfig()函数

logging.basicConfig(stream=sys.stdout, level=logging.INFO)

这行代码是用来设置 Python 的 logging 模块的配置，主要包含以下几个部分：

logging.basicConfig：logging 模块提供的一个简单的配置函数，用于在控制台上输出日志信息。
stream=sys.stdout：设置日志输出的位置，这里指定输出到标准输出流（控制台）。
level=logging.INFO：设置日志级别，只有级别高于等于 INFO 的日志信息才会被输出，级别包括 DEBUG、INFO、WARNING、ERROR、CRITICAL。

因此，以上代码表示将 Python 的日志输出到控制台，并且只输出级别高于等于 INFO 的日志信息。如果想要输出更详细的信息，可以将日志级别设置为 DEBUG。

SummaryWriter库

导入库：

from torch.utils.tensorboard import SummaryWriter

writer = SummaryWriter()
writer.add_scalar("train_loss", loss.item(), epoch_len * epoch + step)

该语句是在PyTorch中使用TensorBoard进行可视化时使用的语句。

writer.add_scalar()函数是用于将标量数据添加到TensorBoard的方法。它有三个参数：

tag：字符串类型，用于指定要添加的标量数据的名称。在TensorBoard中，这个名称将用作标量数据的图例。
scalar_value：数值类型，是要添加的标量数据的值。
global_step：数值类型，表示添加的标量数据是在哪个全局步骤（global step）中记录的。

在这个语句中，tag是"train_loss"，表示这是训练损失的值。scalar_value是loss.item()，表示这是当前的训练损失值。global_step是epoch_len * epoch + step，它表示当前的全局步骤数，其中epoch_len是一个epoch中的步骤数，epoch是当前的epoch数，step是当前的步骤数。

这个语句的作用是将训练损失值写入TensorBoard中，以便在训练过程中可视化训练损失的变化。通过指定不同的标签和全局步骤数，可以在TensorBoard中同时可视化多个指标的变化。

glob库

glob()

glob.glob(os.path.join(args.data_path,"image", "*.nii.gz"))

glob.glob() 是 Python 标准库中的一个函数，它用于查找匹配特定模式的文件路径名。

glob.glob(pattern) 接受一个字符串参数 pattern，该参数描述了要搜索的文件名模式。该函数返回一个包含所有匹配模式的文件路径名的列表。

glob.glob() 还支持更复杂的文件名模式，例如使用通配符 * 匹配任意字符，使用 ? 匹配单个字符，使用 [] 匹配指定范围内的字符等。例如：

time

time()函数

epoch_start = time.time()

这行代码使用了 Python 中的 time 模块中的 time() 函数，它返回当前时间的时间戳（以秒为单位）。在这里，time.time() 函数返回的时间戳被存储在 epoch_start 变量中。

通常，这行代码用于记录程序中的开始时间，以便可以计算出程序的运行时间。

argparse库

argparse是Python标准库中用于解析命令行参数和选项的模块。

创建ArgumentParser对象，用于解析命令行参数和选项，通常包括以下几个步骤：

创建ArgumentParser对象。
使用add_argument()方法向ArgumentParser对象添加需要解析的命令行参数和选项。
使用parse_args()方法解析命令行参数和选项。

import argparse

parser = argparse.ArgumentParser()
parser.add_argument('--verbose', help='increase output verbosity', action='store_true')
parser.add_argument('filename', help='name of file to read')
parser.add_argument("--num_classes", default=1, type=int, help="分类")
args = parser.parse_args()

文件操作

CSV文件

CSV文件介绍

CSV（逗号分隔值）（Comma-Separated Values，CSV，有时也称为字符分隔值，因为分隔字符也可以不是逗号），其文件以纯文本形式存储表格数据（数字和文本）；
纯文本意味着该文件是一个字符序列，不含必须像二进制数字那样被解读的数据；
CSV文件由任意数目的记录组成，记录间以某种换行符分隔，每条记录由字段组成，字段间的分隔符是其它字符或字符串，最常见的是逗号或制表符。

read_csv()函数

read_csv() 函数的返回值是 ndarray(N维数组)

import pandas as pd

ndarray = pd.read_csv(path)		# 注意：ndarray中的元素类型为object
ndarray = pd.read_csv(path).astype('float')		#数组元素转换为对应数据类型
ndarray = pd.read_csv(path).astype('int')

属性	说明
ndarray.shape	数组的维数，返回一个元组。对于一个n行m列的矩阵，值为 (n,m) 。如果是三维数组，则返回的元组包含3个元素
ndarray.reshape(n,m)	reshape 函数用于调整数组的大小，其参数n、m分别表示数组的行和列
ndarray.size	数组元素的个数，相当于 ndarray.shape 中 n*m 的值
ndarray.dtype	array 对象的元素类型

注意：[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-npWJpGhT-1680006843196)(C:\Users\JOHN\AppData\Roaming\Typora\typora-user-images\image-20221104114317350.png)]

(1) 使用 read_csv() 读取 UCI 数据集出来的数组最后一列由 ‘nan’ 组成;

(2) r ‘D:\机器学习基础\课程实验\实验二\abc.csv’ 而不是 ‘D:\机器学习基础\课程实验\实验二\abc.csv’，避免\xx是一个转义字符而导致的错误

TXT文件

文件读写模式

r : 读文件，若文件不存在则会报错
w: 写文件，若文件不存在则会先创建再写入，会覆盖原文件
a : 写文件，若文件不存在则会先创建再写入，但不会覆盖原文件，而是追加在文件末尾
rb，wb：分别与r，w类似，但是用于读写二进制文件
r+ : 可读、可写，文件不存在也会报错，写操作时会覆盖
w+ : 可读，可写，文件不存在先创建，会覆盖
a+ : 可读、可写，文件不存在先创建，不会覆盖，追加在末尾

读写函数

f = open(文件路径，读写模式， 编码)
或者
with open(文件路径，读写模式， 编码) as f:　

f.read()	#读取整个文件
line = f.readline()	#读取第一行
lines = f.readlines()	#读取所有行，并且以数列的格式返回结果，通常配合 for line in lines 使用

f.write(str)	#写入str

f.close()

清除内容函数

使用情况：在对文件写入内容时，在某个条件下要清除文件内容再进行写入操作时，就可以使用truncate(size)，不用删除文件再从新创建。

我们可以使用 truncate(size)函数来删除 txt 文件内容，size是表示从第几个字节开始清除，如果是0时代表是删除全部内容。

例子：清除上面已经写入内容的 test.txt 文件

with open(r'test.txt','r+',encoding='utf-8') as f:
	f.truncate(0)

删除文件函数

with open(r'test.txt','r+',encoding='utf-8') as f:
	f.remove(r'test.txt')

npy文件

npy即numpy对应的文件格式，关于其保存使用的是np.save()方法，其读取使用的是np.load()方法。

矩阵和numpy数组都支持以npy文件类型保存

import numpy as np
a = np.mat('1, 2, 3;4, 5, 6')
b = np.array([[1, 2, 3], [4, 5, 6]])

np.save('a.npy', a)			#保存为npy文件
np.save('b.npy', b)

data1 = np.load('a.npy')	#读取npy文件，且都是numpy数组数据类型
data2 = np.load('b.npy')

mat文件

保存为mat文件依赖于scipy库中的scipy.io.savemat()方法，读取则需要用到scipy.io.loadmat()方法。
保存时，不仅仅需要传入变量，还需要将该变量的类型一并以字典的形式传入，一样支持numpy数组和矩阵。

import numpy as np
from scipy import io
a = np.mat('1, 2, 3;4, 5, 6')
b = np.array([[1, 2, 3], [4, 5, 6]])

io.savemat('a.mat', {'matrix': a})	#保存为mat文件
io.savemat('b.mat', {'array': b})

data1 = io.loadmat('a.mat')['matrix']	#取出的数据都是numpy数组，不再有矩阵类型
data2 = io.loadmat('b.mat')['array']

DIC文件

.dic是一种词典文件格式，Dic文件由若干单词单元组成，每一个单元包含了单词与解释信息，每个单词单元以单词开始，解释结束。

如下图所示：

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-E5PSnbYY-1680006843197)(C:\Users\JOHN\AppData\Roaming\Typora\typora-user-images\image-20221110211922863.png)]

SCEL文件

scel文件介绍

搜狗的 scel 词库就是保存的文本的 unicode 编码，每两个字节一个字符（中文汉字或者英文字母），找出其每部分的偏移位置即可

将 scel 文件转换为 txt 文件

import struct
import os
# 拼音表偏移，
startPy = 0x1540
 
# 汉语词组表偏移
startChinese = 0x2628
 
# 全局拼音表
GPy_Table = {}
 
# 解析结果
# 元组(词频,拼音,中文词组)的列表
GTable = []
 
# 原始字节码转为字符串
def byte2str(data):
    pos = 0
    str = ''
    while pos < len(data):
        c = chr(struct.unpack('H', bytes([data[pos], data[pos + 1]]))[0])
        if c != chr(0):
            str += c
        pos += 2
    return str
 
# 获取拼音表
def getPyTable(data):
    data = data[4:]
    pos = 0
    while pos < len(data):
        index = struct.unpack('H', bytes([data[pos],data[pos + 1]]))[0]
        pos += 2
        lenPy = struct.unpack('H', bytes([data[pos], data[pos + 1]]))[0]
        pos += 2
        py = byte2str(data[pos:pos + lenPy])
 
        GPy_Table[index] = py
        pos += lenPy
 
# 获取一个词组的拼音
def getWordPy(data):
    pos = 0
    ret = ''
    while pos < len(data):
        index = struct.unpack('H', bytes([data[pos], data[pos + 1]]))[0]
        ret += GPy_Table[index]
        pos += 2
    return ret
 
# 读取中文表
def getChinese(data):
    pos = 0
    while pos < len(data):
        # 同音词数量
        same = struct.unpack('H', bytes([data[pos], data[pos + 1]]))[0]
 
        # 拼音索引表长度
        pos += 2
        py_table_len = struct.unpack('H', bytes([data[pos], data[pos + 1]]))[0]
 
        # 拼音索引表
        pos += 2
        py = getWordPy(data[pos: pos + py_table_len])
 
        # 中文词组
        pos += py_table_len
        for i in range(same):
            # 中文词组长度
            c_len = struct.unpack('H', bytes([data[pos], data[pos + 1]]))[0]
            # 中文词组
            pos += 2
            word = byte2str(data[pos: pos + c_len])
            # 扩展数据长度
            pos += c_len
            ext_len = struct.unpack('H', bytes([data[pos], data[pos + 1]]))[0]
            # 词频
            pos += 2
            count = struct.unpack('H', bytes([data[pos], data[pos + 1]]))[0]
 
            # 保存
            GTable.append((count, py, word))
 
            # 到下个词的偏移位置
            pos += ext_len
 
 
def scel2txt(in_path,file_name):
    print('-' * 60)
    with open(in_path+file_name, 'rb') as f:
        data = f.read()
 
    print("词库名：", byte2str(data[0x130:0x338])) # .encode('GB18030')
    print("词库类型：", byte2str(data[0x338:0x540]))
    print("描述信息：", byte2str(data[0x540:0xd40]))
    print("词库示例：", byte2str(data[0xd40:startPy]))
 
    getPyTable(data[startPy:startChinese])
    getChinese(data[startChinese:])
 
if __name__ == '__main__':
 
    # scel所在文件夹路径
    in_path = u"D:/自然语言处理/课程作业/第二次作业/"
 
 
    # 输出词典所在文件夹路径
    out_path = r"D:\自然语言处理\课程作业\第二次作业\test.txt"
 
    fin = [fname for fname in os.listdir(in_path) if fname[-5:] == ".scel"]
 
 
    # print(fin)
    for f in fin:
        scel2txt(in_path,f)
 
    # 保存结果
    with open(out_path, 'w', encoding='utf8') as f:
        f.writelines([word+'\n' for count, py, word in GTable])

数据类型

查看数据类型

type(5)		#输出：<class 'int'> 
type('str')	#输出：<class 'string'> 

判断数据类型
type(str) == type('abc')
type(a) == type(1)

用法	解释
type()	返回参数的数据类型
dtype	返回数组中元素的数据类型
astype()	对数据类型进行转换，int/float/str

list(列表)

append()函数

list.append(str)	#向列表末尾添加元素

pop()函数

elem = list.pop()	#弹出列表末尾的元素

index()函数

index() 函数用于从序列s中找出某个值第一个出现时的索引位置

s.index(x，beg=0, end=len(string))
# s —— 序列类型数据（字符串、元组、列表）
# x —— 查找的对象

该方法返回查找对象的索引位置，如果没有找到对象则抛出异常

sum()函数

sum(iterable, start)
# iterable，一个可迭代对象，可以是列表、字典、元祖等，重要的是可迭代对象中的元素是可相加的。比如数字、列表是可加的，字符串就不是可加的
# start，可选参数，他会被加到可迭代对象的和中，默认是0

sort()函数

sort方法是Python的列表方法，用于对原列表进行排序，sort方法没有任何返回值。

list.sort(key=function, reverse=boolean)

名称	说明	备注
list	列表名称
key=function	列表元素权值参数	可省略的参数。省略时列表排序不考虑元素的权值
reverse=boolean	排序规则参数	可省略的参数。省略时reverse默认值False

list 去重

1.先建立一个新的空列表，通过遍历原来的列表，再利用逻辑关系not in 来去重

list=[1,2,3,4,5,1,2,3]
 new_list=[]
 for i in list:
     if i not in new_list:
         new_list.append(i)
 print(new_list)

2.利用set的自动去重功能

list=[1,2,3,4,5,1,2,3]
list=list(set(list))
print(list)

remove()函数

list = ['str','1','abc']
list.remove('str')	#按名字删除
如果列表中不存在此元素，则报错
ValueError: list.remove(x): x not in list

max()函数

max(iterable, key = function)

print(max(1,2,3,4))  	# 输出4

s = '12345'
print(max(s))			# 输出5

testlist = [9.2, 10, -20.3, -7.0, 9.999, 20.111]
print(max(testlist, key=abs))		# 输出-20.3，返回绝对值最大

s = {'a': 5, 'b':8，'c':1}
print(max(s))		#输出'c',返回最大的键
print(max(s,key = s.get))	#输出'b',返回值最大的键

dict(字典)

get()函数

dict.get(key, default=None)		#返回指定键的值

#key -- 要查找的键
#default -- 如果指定键的值不存在，返回该默认值

contain()函数

字典(Dictionary) contains() 函数用于判断键是否存在于字典中

如果键在字典 dict 里返回true，否则返回 false

dict = {'Name':'coco', 'Sex':'Female'}  # 定义字典
print(dict.__contains__('Name'))   	# 返回True

dict1.update(dict2) 函数

使用一个字典dict2所包含的键值对来更新己有的字典dict1。

如果被更新的字典中己包含对应的键值对，那么原 value 会被覆盖；

如果被更新的字典中不包含对应的键值对，则该键值对被添加进去。

a = {'one': 1, 'two': 2, 'three':3}
b = {'one': 100, 'four': 4}
a.update(b)
print(a)

结果：
{'one': 100, 'two': 2, 'three': 3, 'four': 4}

获取 key、value、item 列表

map = {'name':'haohao', 'age': 18}
print(list(map.items()))
print(list(map.keys()))
print(list(map.values()))

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-RQqss27W-1680006843197)(C:\Users\JOHN\AppData\Roaming\Typora\typora-user-images\image-20221115174244997.png)]

字符串

split()函数

拆分字符串，通过指定分隔符对字符串进行切片，并返回分割后的字符串列表（list）

str.split(char, num)
#char:分隔符
#num:分割次数

strip()函数

strip() 方法用于移除字符串头尾指定的字符（默认为空格或换行符）或字符序列。

**注意：**该方法只能删除开头或是结尾的字符，不能删除中间部分的字符。

str.strip([chars])

参数：chars -- 移除字符串头尾指定的字符序列
返回值：移除字符串头尾指定的字符生成的新字符串

示例：

str = "00000003210Runoob01230000000"; 
print str.strip('0') 	#去除首尾字符 0 
 
str2 = " Runoob ";
print(str2.strip())		#去除首尾空格 
 
 
结果：
3210Runoob0123
Runoob

find()函数

查找字符串中是否包含子字符串 str

如果指定 beg（开始）和 end（结束）范围（左开右闭），则检查是否包含在指定范围内。

如果包含子字符串，返回第一个出现 str 的索引值，否则返回-1。s

find（）函数的语法

str.find(str, beg=0, end=len(string))

str – 指定检索的字符串
beg – 开始索引，默认为0
end – 结束索引，默认为字符串的长度

lower()与upper()函数

lower()将字符串中的所有大写字母转换为小写字母，并返回一个新字符串。

upper()将字符串中的所有小写字母转换为大写字母，并返回一个新字符串。

str = 'ABc'
str = str.lower()	#lower()没有参数，str = 'abc'
str = str.upper()	#str = 'ABC'

数组

切片

import numpy as np

arr = np.array([[1,2,3],
                [1,2,3],
                [1,2,3]])
# 切片的范围为左闭右开[ )
a1 = arr[:, 0]		#取数组第一列
a2 = arr[:, -1]		#取数组最后一列
a3 = arr[:, 0:2]	#取数组1-2列
a4 = arr[:, :-1]	#取除最后一列的所有列
# 注意：逗号前面的:不能省略

a4 = arr[0]	#取数组第一行
a5 = arr[-1]	#取数组最后一行
a6 = arr[0:2]	#取数组1-2行
# 注意：可以省略后面的:

a7 = arr[0:2, 0:2]	#取数组1-2行，1-2列

";
print str.strip(‘0’) #去除首尾字符 0

str2 = " Runoob ";
print(str2.strip()) #去除首尾空格

结果：
3210Runoob0123
Runoob




#### 	find()函数

查找**字符串**中是否包含**子字符串** str

如果指定 beg（开始） 和 end（结束） 范围（左开右闭），则检查是否包含在指定范围内。

如果包含子字符串，返回第一个出现 str 的索引值，否则返回-1。s

 find（）函数的语法

```python
str.find(str, beg=0, end=len(string))

str – 指定检索的字符串
beg – 开始索引，默认为0
end – 结束索引，默认为字符串的长度

lower()与upper()函数

lower()将字符串中的所有大写字母转换为小写字母，并返回一个新字符串。

upper()将字符串中的所有小写字母转换为大写字母，并返回一个新字符串。

str = 'ABc'
str = str.lower()	#lower()没有参数，str = 'abc'
str = str.upper()	#str = 'ABC'

数组

切片

import numpy as np

arr = np.array([[1,2,3],
                [1,2,3],
                [1,2,3]])
# 切片的范围为左闭右开[ )
a1 = arr[:, 0]		#取数组第一列
a2 = arr[:, -1]		#取数组最后一列
a3 = arr[:, 0:2]	#取数组1-2列
a4 = arr[:, :-1]	#取除最后一列的所有列
# 注意：逗号前面的:不能省略

a4 = arr[0]	#取数组第一行
a5 = arr[-1]	#取数组最后一行
a6 = arr[0:2]	#取数组1-2行
# 注意：可以省略后面的:

a7 = arr[0:2, 0:2]	#取数组1-2行，1-2列