python数据处理

API

API
API2

python内置函数

算术运算符

/就是返回一个真正的值，%是返回余数部分，//返回整数部分

a=10/2.1  #这个/就是返回一个真正的数
print(a)

for

import numpy as np
a=np.array([1,5,7,4])
#这里的len就是4，这样就是打印0到3
for i in range(0,len(a)):
    print(i)

把a里面的数都循环一遍

a=[1,5,7]
for i in a:
    print(i)

i就是等于一行

a=np.random.randint(8,size=(3,4))
print(a)
print('*')
for i in a:
    print(i)

for在列表中的使用

values=[[1,7,3],[4,5,6]]#列表
rank=[0,1]
for i in range(len(values)):  # 循环两次
    valuesi = [values[i][A] for A in rank]  # valuesi＝values的第i列第a行（a就是rank中的值）
    print(valuesi)
print('*')
print(valuesi)

这里的for不像C语言，for里面改变了，外面的也随之改变

rank =np.array([1,2,3])
a=[4,5,6,7]
print(rank)
print('*')
for rank in a:
    print(rank)
print('*')
print(rank)

values=[[7,2,5],[4,5,6]]
rank=[0,2,1]
valuesi = [values[0][A] for A in rank]  # 函数值
print(valuesi)

[][]中取第一个

#先按x1中的数从小到达排序，如果相等，就看x0，也是从小到大排序
a=[(1,2),(4,8),(2,6),(8,5),(9,5),(1,5)]
b = sorted(a, key=lambda x: (x[1],x[0]))
print(b)
print('*')
a = [j[0] for j in b]  # [][]中取第一个
print(a)

一串数组中选中对应元素

a=np.array([[1,2,3],[4,5,6],[7,8,9]])
for x,y,z in a:
    print(x,y,z)
    print("*"*10)

map() 函数

将参数依次带入到函数中，返回计算后的值
详解

import numpy as np

def square(x):
    return x**2

a=np.array([1,2,3,5])
# b=map(aquare,[1,2,3]) 另外一种写法
b=map(square,a)#将a中的数 一一带入函数aquare中 然后得出解
b=list(i for i in b)#必须要加上这一步 因为上一步得到是对象格式，需要转换成列表格式
print(b)

zip()函数

详解
把每个数组中的对应值合并到一起

import numpy as np
a=[1,2,3,4,5]
b=(1,2,3,4,5)
c=np.arange(5)
d="zhang"
zz=zip(a,b,c,d)
print(zz)

输出：
[(1, 1, 0, 'z'), (2, 2, 1, 'h'), (3, 3, 2, 'a'), (4, 4, 3, 'n'), (5, 5, 4, 'g')]

len

a=np.array([1,5,7,4])
print(len(a))# 打印多少个
b=np.array([[1,2,3],[4,5,6]])#数组只能这样放 即([ [] [] ]) 不能 ([] [] )
print(len(b))# 二维数组打印行数
c=[[1,2,3],[4,5,6]]#这个是列表
print(len(c))#也是行数

print打印

格式化打印：

name = "Alex"
age = 22
print( f"hello my name is {name}, I am {age} old..")

a=[1,5,7]
b=['小','龙','虾']
for i in range(len(a)):
    print('第%d层,解的序号为%s'%(i,a[i]))
    print('第%d层,解的序号为%s'%(i,b[i]))

文字和变量一起打印出来

a=[1,2,3]
print('a的值为：',a)

np.zeros

创建一个给定形状和类型的用0填充的数组
解析

distance = np.zeros(shape=(3, ))  # 创建三项全为0的数组 默认是浮点型
print(distance)

求最大max/最小min

详解，里面还有很多种用法

a=np.array([1,2,3])
print(max(a))
print(min(a))

sorted()排序函数

详解

按照里面的排序函数的意思，就是按照列表的长度进行排序

list = ['a', 'bc', 'defg', 'handsome', 'qwerrtyyuu']
print(sorted(list,key=lambda x:len(x),reverse=True))

Output：
['qwerrtyyuu', 'handsome', 'defg', 'bc', 'a']

先按x1中的数从小到大排序，如果相等，就看x0，也是从小到大排序

#先按x1中的数从小到达排序，如果相等，就看x0，也是从小到大排序
a=[(1,2),(4,8),(2,6),(8,5),(9,5),(1,5)]
b = sorted(a, key=lambda x: (x[1],x[0]))
print(b)
print('*')
a = [j[0] for j in b]  # [][]中取第一个
print(a)

.T

矩阵的转置

extend——扩展列表

用于在列表末尾一次性追加另一个序列中的多个值（用新列表扩展原来的列表）
解析

A = [1, 2, 3]
B = [['a', 'b']]
A.extend([4])
A.extend([5, 6])
B.extend(['c', 'd'])
B.extend([['e', 'f']])
print(A)
print(B)

append

append（）用于在列表末尾添加新的对象，输入参数为对象；
extend（）用于在列表末尾追加另一个序列中的多个值，输入对象为元素队列；
详解

my_list = ['abc', '123']
my_list.extend('456') # 字符串
my_list.extend(['alice', 18])  # 列表
my_list.extend({'alice': 18, 'amy': 22}) # 字典（默认key）
print('extend输出结果：', my_list)
 
my_list = ['abc', '123']
my_list.append('456') # 字符串
my_list.append(['alice', 18]) # 列表
my_list.append({'alice': 18, 'amy': 22}) # 字典（默认key）
print('append输出结果：', my_list)

remove()函数

remove()函数用于移除列表中某个值的第一个匹配项。
详解

aList = [123, 'xyz', 'zara', 'abc', 'xyz']

aList.remove('xyz')
print("List : ", aList)
aList.remove('abc');
print("List : ", aList)

列表与数组之间转换

为什么要转换，因为列表无法-1
列表——数组

lis=[[1,2,3],[4,5,6],[8,7,5]]
lis=np.array(lis)
print(lis)
print(lis-1)#转换之后就可以进行这种操作了
print(1/lis)

数组——列表tolist()函数

solution=np.array([[1,2,3],[4,5,6],[7,8,9]])
print('这是数组\n',solution,'\n')

solution=solution.tolist()
print('这是列表\n',solution)

enumerate函数

有很多高级用法（暂时先不说），这个函数的基本应用就是用来遍历一个集合对象，它在遍历的同时还可以得到当前元素的索引位置。

names = ["Alice","Bob","Carl"]
for index,value in enumerate(names):
    print(f'{index}: {value}')

0: Alice
1: Bob
2: Carl

np.where()

np.where有两种用法：

用法一：
np.where(condition,x,y) 当where内有三个参数时，第一个参数表示条件，当条件成立时where方法返回x，当条件不成立时where返回y

#用法一
#当self.net_input(X)返回的值大于等于0.0时，where返回1，否则返回0
np.where(self.net_input(X) >= 0.0, 1, 0)

方法二：
np.where(condition) 当where内只有一个参数时，那个参数表示条件，当条件成立时，where返回的是每个符合condition条件元素的坐标,返回的是以元组的形式

#用法二
a = np.array([2,4,6,8,10])
#只有一个参数表示条件的时候
np.where(a > 5)

输出：
array([ 6,  8, 10])

冒号

详解
1 、写完整的情况下
单个冒号的情况下，对数组的遍历操作是从前向后操作。如：arr[a:b] ，冒号前的a含义是从a开始遍历，冒号后的b含义是到b截止（不包括b）。

arr = [1, 2, 3, 4, 5, 6, 7]
print(arr[1:3])

输出结果为：[2, 3]

2、 略写冒号前面的情况
如果略写冒号前面的话，默认系统会指定为第一个

arr = [1, 2, 3, 4, 5, 6, 7]
print(arr[:3])

输出结果为：[1, 2, 3]

3、 略写冒号后面的情况
如果略写冒号后面的话，默认系统会指定为操作对象的长度+1，也就是说会遍历到最后一个元素为止。

arr = [1, 2, 3, 4, 5, 6, 7]
print(arr[3:])

输出结果为：[4, 5, 6, 7]

4、 冒号前后指定负数的情况
冒号前后指定位置的变量或者常量还有更灵活的用法，例如可以指定为负数，例如 arr[2:-2] ，其中-2代表的含义是倒数第二个位置。本质上是用 len(arr)+1-2 计算得位置。

5 、总结：
​ 冒号前面后面随便都可以省略，只需要记住冒号前指定开始位置，冒号后指定结束位置+1（就类似于经常出现在python各种参数指定的“左闭右开”的原则）如果省略不指定冒号前面，就代表从0开始，如果省略不指定冒号后面，就代表到对象的最后一个元素。

两个冒号

main

定义了main函数，但是main之前的或者之后的，都会被执行到

print('在main之前')

def main():
    print(1111)

if __name__ == '__main__':
    main()


print('在main之后')

变量

1、变量的修改：就是将编号指向另外的一个地方。如果一个变量一开始给他赋值1，后面给他改成2.那么就只是单纯的这个变量名指向了另外的一个内存地址。原本那个内存地址的值也就是1还是在的。相当于将标签贴到了另外的地方，原本地方的货物不变。但内存却不会爆，因为python解释器有一个自动回收机制（比如1s会扫描一次），只要是无主的货物就会给他收走删除
2、这个就是因为name2指向的是name所指向的那个值（name2和name没有任何关系，他只是借助了name找到了其中的值），因此不会因name的值的改变而改变。这点就和c不一样了，因为这个的name值改变是换个内存指向，而c则是修改这个所指向的内存的值，而不是换个地方指向

name=1
name2=name
name=5
print(name2)

列表

a=[[1,2,3],[4,5,6],[7,8,9]]
print(a)
print(a[2][1])#注意他是从0开始的，所以2就是最后那行 1就是第二个

列表与数组的区别

列表与数组一个特别大的区别是 列表可以装任意类型的数据

a=["zhangsan",5,3.22,'李四']
print(a)

random

程序中有很多地⽅需要⽤到随机字符，⽐如登录⽹站的随机验证码，通过random模块可以很容易⽣成随机字符串

>>> random.randrange(1,10) #返回1-10之间的⼀个随机数，不包括10
>>> random.randint(1,10) #返回1-10之间的⼀个随机数，包括10
>>> random.randrange(0, 100, 2) #随机选取0到100间的偶数
>>> random.random() #返回⼀个随机浮点数
>>> random.choice('abce3#$@1') #返回⼀个给定数据集合中的随机字符
'#'
>>> random.sample('abcdefghij',3) #从多个字符中选取特定数量的字符
['a', 'd', 'b'] #⽣成随机字符串
>>> import string
>>> ''.join(random.sample(string.ascii_lowercase + string.digits, 6))
'4fvda1'
#洗牌
>>> a [0, 1, 2, 3, 4, 5, 6, 7, 8, 9]
>>> random.shuffle(a)
>>> a [3, 0, 7, 2, 1, 6, 5, 8, 9, 4]

import random

print( random.randint(1,10) )        # 产生 1 到 10 的一个整数型随机数  
print( random.random() )             # 产生 0 到 1 之间的随机浮点数
print( random.uniform(1.1,5.4) )     # 产生  1.1 到 5.4 之间的随机浮点数，区间可以不是整数
print( random.choice('tomorrow') )   # 从序列中随机选取一个元素
print( random.randrange(1,100,2) )   # 生成从1到100的间隔为2的随机整数

a=[1,3,5,6,7]                # 将序列a中的元素顺序打乱
random.shuffle(a)
print(a)

import random
import string

# 随机整数：
print random.randint(1,50)

# 随机选取0到100间的偶数：
print random.randrange(0, 101, 2)

# 随机浮点数：
print random.random()
print random.uniform(1, 10)

# 随机字符：
print random.choice('abcdefghijklmnopqrstuvwxyz!@#$%^&*()')

# 多个字符中生成指定数量的随机字符：
print random.sample('zyxwvutsrqponmlkjihgfedcba',5)

# 从a-zA-Z0-9生成指定数量的随机字符：
ran_str = ''.join(random.sample(string.ascii_letters + string.digits, 8))
print ran_str

# 多个字符中选取指定数量的字符组成新字符串：
print ''.join(random.sample(['z','y','x','w','v','u','t','s','r','q','p','o','n','m','l','k','j','i','h','g','f','e','d','c','b','a'], 5))

# 随机选取字符串：
print random.choice(['剪刀', '石头', '布'])

# 打乱排序
items = [1, 2, 3, 4, 5, 6, 7, 8, 9, 0]
print random.shuffle(items)

np.random.randint

np.random.randint（）的用法
返回随机整形数

a=np.random.randint(8,size=(2,6))# 在0到8之间（不包括8）生成一个2行6列的数组
print(f'打印a\n{a}')
print(f'打印a[:,1::2]\n{a[:,1::2]}')#打印a中所有行的从第一列间隔2的取
print(f'打印a[:,0::2]：\n{a[:,0::2]}')#省略的地方就是到底，最后的2就是间隔为2的取

np.random.uniform()

从指定范围生成指定的浮点数
详细介绍

import numpy as np

a=np.random.uniform(1,5,10)#生成10个数 一维数组
print(a.shape)
print(a)
b=np.random.uniform(1,5,size=(2,3))# 随机从1-5中生成两行三列个数
print(b.shape)
print(b)

np.random.seed()函数

每次在创建随机数前调用一下，那么这次创建的随机数就是固定的一组
详解

accuracy_min=np.array([1,1,2,2,2])#5个
accuracy_max=np.array([3,4,5,6,3])#5个

solution=[0 for i in range(12)]
for i in range(5):
    np.random.seed(1)
    solution[i]=np.random.uniform(accuracy_min[i],accuracy_max[i],10)
print(solution)

np.random.choice和random.choice的用法

np.random.choice和random.choice的用法

numpy

API
视频
numpy（numerical python）是python语言中做科学计算的基础。重在于数值计算，也是大部分python科学计算库的基础，多用于在大型、多维数组上执行数值运算
这个是数组，python里面那个y=[1,23,5]这个是列表

数组创建

import numpy as np

#创建数组 下面abc内容相同  出现range都是顾头不顾尾
a=np.array([1,2,3,4,5])#12345
print(a)
b=np.array(range(1,6))#12345
print(b)
c=np.arange(1,7,2)#从1到6每隔2取一个 也就是这个最方便
print(c)
d=np.arange(6)#012345
print(d)
print(type(d))

多维数组创建（中括号里套中括号）与引用（[]引用一行，[][]应用具体某一个）修改

a=np.array([[1,2,3],[4,5,6]])#中括号里套中括号
print(a)
print('*')
print(a[1])#打印某一行
print('*')
print(a[1][1])#打印某一个
print('*')
a[1]=[7,8,9]#修改某一行
print(a)
print('*')
a[1,1]=55#修改某一个
print(a)

numpy类型

#numpy中的数据类型
a=np.arange(6)#012345
print(a)
print(a.dtype)#如果没有指定的话，就按电脑位数来，这个就是int64

b=np.arange(1,4,dtype="float32")
print(b)
print(b.dtype)
print('*'*32)

#调整数据类型
c=b.astype("int8")
print(c.dtype)

小数

#numpy中的小数
a=np.array([random.random() for i in range(10)])#随机10个数
print(a)
print(a.dtype)

b=np.round(a,2)#取两位小数
print(b)

数组形状

1、查看数组形状

# 查看数组的形状
a=np.arange(12)
print(a.shape)#这个是一维数组，所以表示12个(12,)
b=np.array([[1,2,3],[5,7,2]])
print(b)
print(b.shape)# (2,3)表示两行三列

2、修改数组形状

# 修改数组的形状
a=np.arange(24)
print(a)
print(a.reshape((3,8))) #变成三行四列
print('*'*100)
print(a.reshape(2,3,4))#表示2块，每块三行四列
print(a)#本身是不会改变的，有返回值，可以接收 a=a.reshape（（3,8））
#变会一维a.reshape((24,)) 不能写成（1,24）因为一个值表示一维 两个值就表示二维

a=np.arange(24)
print(a)
a=a.reshape((3,8))#把a变成三行8列
print(a)
print(a.reshape((a.shape[0]*a.shape[1],)))#在不知道a是几行几列的情况下 把他变成一维 a.shape[0]表示行数，另外一个表示列数
print(a.flatten())#这是第二个变为一维数组的方法

数据的计算

a=np.arange(24).reshape((4,6))
print(a)
print(a+2)#所有的元素都+2 加减乘除都是这样的
print('*'*100)
b = np.arange(100,124).reshape((4,6))#也是对应位置计算  加减乘除都是 也不一定要全部一样，在某一维度相同也是可以的
print(a+b)

数组与数组相乘

一维数组与一维数组直接相乘，就是对应项相乘

a=np.array([1,2,3])
b=np.array([3,4,5])
c=a*b
print(c)

一维数组与多维数组相乘：一维数组分别与每一行 相同位置对应相乘

a=np.array([1,2,3])
b=np.array([[1,2,3],[4,5,6],[2,1,4]])
c=a*b
print(c)

np.dot()使用方法

np.dot()函数主要有两个功能，向量点积和矩阵乘法
使用介绍

矩阵相乘实例

a=np.array([1,2,3])
b=np.array([[1,2,3],[4,5,6],[2,1,4]])
c=np.dot(a,b)
print(c)

将二进制数1010，转换成对应的十进制数

a=np.array([1,0,1,0])
print(np.arange(4)[::-1])#3210的数组 后面[]是切片操作从最初到最后 反方向取
print(a.dot(2**np.arange(4)[::-1]))#a这个数组里的数分别对应与2的3次2次1次0次相成 也就是求一段二进制对应的十进制数

mean()函数

mean()函数功能：求取均值
详解

-1就代表最后一个

a=np.array([1,2,3])
print(a[-1])

数组或者列表读取某一列

详解

solution=np.array([[1,2,3],[4,5,6],[7,8,9]])
print('这是数组\n',solution)
print('数组第二列',solution[:,1])

solution=solution.tolist()
print('这是列表\n',solution)
a=[0,1,2]
b=[x[1] for x in solution]
print('这是列表第二列\n',b)

第一行

a=np.array([[1,2,3],[4,5,6]])
print(a[0,:])

第一列

a=np.array([[1,2,3],[4,5,6]])
print(a[:,0])

数组的增删查改，添加列/行

详解

将solution数组按照312的顺序取列，然后插入到a中
在使用拼接函数的时候，注意用到的是中括号[]

indexx=[2,0,1] #按照312的格式追加

a=np.array([[] for i in range(3)])#这里需要这样三个[] 不然会报错
print(a)
solution=np.array([[1,2,3],[4,5,6],[7,8,9]])
print('这是数组\n',solution)

for i in indexx:
    a=np.c_[a,solution[:,i]]
print('新组成的数组为\n',a)

matplotlin

视频
API
API2

最流行的python底层绘图库，主要做数据可视化图表，名字取材于matlab，模仿matlab构建

	Pyplot 是 Matplotlib 的子库，
	提供了和 MATLAB 类似的绘图 API

折线图——plt.plot

import  random
import numpy as np
# Pyplot 是 Matplotlib 的子库，提供了和 MATLAB 类似的绘图 API。
# Pyplot 是常用的绘图模块，能很方便让用户绘制 2D 图表。
# Pyplot 包含一系列绘图函数的相关函数，每个函数会对当前的图像进行一些修改，例如：给图像加上标记，生新的图像，在图像中产生新的绘图区域等等。
from matplotlib import pyplot as plt

plt.rcParams['font.sans-serif']=['SimHei'] #设置字体 因为matplotlib默认的英文字体是不显示中文的
#设置大小 清晰度
#宽和高 DPI（Dots Per Inch，每英寸点数，这个点就是像素）
fig=plt.figure(figsize=(20,15),dpi=100)

#设置x和y的范围
x=range(2,26,2)  #数据在x轴上的位置2 4 6 到24不包含26
#y=np.array([15,11,14,22,24,6,7,8,9,14,11,12]) #数据在y轴上的位置 与上面的x一一对应
y=[random.randint(20,35) for i in range(12)] #在20到35之间随机生成一个数（包括35），共12次

#设置刻度
#设置x轴刻度
# plt.xticks(range(2,26))这样就每隔1画一个刻度，就会变的更密集
# plt.xticks(x)按照x去显示
#x轴出现字符串打印
_x=list(x)[::2]#将x强制转换为list因为只有list才能取步长 ：：是省略了0，意思是从第一个到最后一个 步长为3进行取值
_xtick_labels=['10点{}分'.format(i) for i in _x]#按照十点多少分的格式 共_x的个数次
plt.xticks(_x,_xtick_labels,rotation=270)#取步长，数字和字符串一一对应，数据的长度一样意思就是第一个是这样显示 字符串旋转270°显示，这样就变成竖着显示了
plt.yticks(range(min(y),max(y)))

#绘图
plt.plot(x,y)#传入x和y，通过plot绘制出折线图

#保存
plt.savefig('./sig_size.png')#也可以保存为svg这种矢量图格式，放大不会有锯齿
#显示
plt.show()#在执行程序的时候显示图形

散点图——plt.scatter

详解

import matplotlib.pyplot as plt
import numpy as np

x = np.array([1, 2, 3, 4, 5, 6, 7, 8])
y = np.array([1, 4, 9, 16, 7, 11, 23, 18])

plt.scatter(x, y)#就是x和y的坐标点
plt.show()

注释——plt.annotate()

为函数图中的点（不是坐标轴）添加注释，或者一些高级功能比如在图中画箭头什么的
简单用法
高级用法

import numpy as np
import matplotlib.pyplot as plt
import matplotlib as mpl
import matplotlib; matplotlib.use('TkAgg')
mpl.rcParams['font.sans-serif'] = ['SimHei']  # 指定默认字体
mpl.rcParams['axes.unicode_minus'] = False  # 解决保存图像是负号'-'显示为方块的问题

#==========定义两个目标函数=============
# 定义函数1
def function1(x):
    value = -(x+2) ** 2+2*x
    return value
# 定义函数2
def function2(x):
    value = -(x - 2) ** 2
    return value

#=========定义群体，并绘制初始解的分布图=====
pop_size = 10
max_gen = 100
# 迭代次数
#Initialization
min_x=-10
max_x=10
np.random.seed(10)#固定随机数种子，使每次生成的初始解集一样
solution=np.random.uniform(min_x,max_x,pop_size) #生成的初始解集  范围为min到max 共生成pop_size个


#函数1 对应的初始目标函数值
values1=map(function1,solution) #python中的map用法，可以对遍历一个列表如solution，然后将列表元素传入到函数function1。得到解。得到的格式为对象
values1=[i for i in values1] #因为上一步得到是对象格式，需要转换成列表格式

#函数2 对应的初始目标函数值
values2=map(function2,solution) #python中的map用法，可以对遍历一个列表如solution，然后将列表元素传入到函数function2。得到解。得到的格式为对象
values2=[i for i in values2] #因为上一步得到是对象格式，需要转换成列表格式


plt.scatter(values1,values2, s=20, marker='o')#绘制散点图 s表示点的大小 marker点的样式
for i in range(pop_size):
    #i为注释的文本内容，这里就是123这样；xy被注释的点的坐标；xytext注释文字的位置
    plt.annotate(i, xy=(values1[i], values2[i]), xytext=(values1[i] - 0.05, values2[i] - 0.05),fontsize=18)
plt.xlabel('function1')
plt.ylabel('function2')
plt.title('解的分布示意图')
plt.show()

pandas

Pandas 可以从各种文件格式比如 CSV、JSON、SQL、Microsoft Excel 导入数据。
Pandas 可以对各种数据进行运算操作，比如归并、再成形、选择，还有数据清洗和数据加工特征。

pandas.DataFrame

使用教程

pd.read_excel