推荐系统-Python语言及数据科学库基础(二)

机器学习语言必备-Python语言入门(二)

1.函数详解

• 函数分为4中类型

  • 根据参数和返回值进行判断
    • 没有返回值没有参数
    • 有参数没有返回值
    • 没有返回值有参数
    • 有参数有返回值的

• 全局变量和局部变量

  • global

#函数有几种类型：
#1.函数的返回值
#2.函数的参数

#无返回值无参数
def repeatString():
    print("helloWorld\t"*5)
repeatString()
repeatString()
#有返回值没有参数
def repeatString():
    return "Hello"
output=repeatString()
print(output)
#没有返回值有参数
def addThreeNumwer(a,b):
    print(a+b)
addThreeNumwer(1,2)
#有返回值有参数
def addThreeNumber1(a,b):
    return a+b
print(addThreeNumber1(1,2))

#全局变量和局部的变量
X=60
def showValue(X):
    print("Current X values is :",X)
    X=100
    print("Change X values is:",X)
showValue(X)
print("Final X value is:",X)

Y=60
def showValueY():
    global Y # 将Y设置为全局变量
    print("current values result is:",Y)
    Y=100
    print("change  values result is:",Y)
showValueY()
print("Final Y result is:",Y)

2.函数详解-参数

• 参数
  • 默认参数
    • 默认参数需要注意他的顺序
  • 关键字参数
    • 关键字参数可以调换顺序，但是需要明确指明具体参数名字
  • VarArgs参数
    • * 表示的是tuple或列表
    • ** 表示的是dict
  • zip重述

# 默认参数
# 非默认参数必须在最后
def showNumber(x,y=1,z=1):
    print(x+y+z)
showNumber(1,1,1)
# 关键字参数
def addThreeNumber(a,b,c=1):
    print(a+b+c)
addThreeNumber(1,2,3)
addThreeNumber(a=1,b=2,c=3)
addThreeNumber(c=3,a=1,b=2)
addThreeNumber(a=1,b=2)
# VarArgs参数
#* 表示可迭代的对象---元祖或列表
#**表示的是字典--key：value
def printFunction(fparameters,*tuple1,**dict1):
    print(fparameters)
    print(tuple1)
    print(dict1)
printFunction(1,2,3,4,5,"okok",age="12",name="zhangsan")
# 输出结果如下
# 1
# (2,3,4,5,"okok")
# {'age':12,'name':'zhangsan'}
vec=[[1,2,3],[4,5,6],[7,8,9]]
print(list(map(list,zip(*vec))))
print(list(map(list,zip([1,2,3],[4,5,6],[7,8,9]))))


#4.传递参数时的序列解包
def demo3(a,b,c):
    print(a+b+c)
seq=[1,2,3]
demo3(*seq)

tup=(1,2,3)
demo3(*tup)

3. 函数详解-Lambda函数

• lambda函数—匿名函数
• 语法：lambda 变量：表达式
• 平方：lambda x:x*x,可以在其中跟上默认参数，如果直接想输出的话直接使用括号进行输出即可
• lambda函数需要结合map函数使用，直接将lambda函数应用于可迭代对象或序列上
• 了解sort函数和lambda结合的形式

# 语法：lambda 变量：表达式
# x*x
#lambda 匿名函数
g=lambda x:x*x
print(g(9))
#三个数字的之和
g1=lambda x,y,z=0:x+y+z
print(g1(1,1,1))
#直接输出结果
print((lambda x,y,z=0:x+y+z)(1,2,3))
#lambda函数直接用于map、reduce、filter函数
addNumber=list(map(lambda x,y,z:x+y+z,range(5),range(5),range(5)))
print(addNumber)


data=list(range(20))
print(data)
import random
random.shuffle(data)
print("shuffle data:",data)
print((lambda x:x)(data)) #[19, 16, 9, 17, 14, 12, 10, 3, 4, 8, 0, 2, 7, 13, 11, 1, 15, 6, 18, 5]
data.sort(key=lambda x:x)
print(data)
print("="*100)
print((lambda x:len(str(x)))(data)) #[19, 16, 9, 17, 14, 12, 10, 3, 4, 8, 0, 2, 7, 13, 11, 1, 15, 6, 18, 5]
data.sort(key=lambda x:len(str(x))) #使用lambda表达式指定排序规则
print(data)
data.sort(key=lambda x:len(str(x)),reverse=True)
print(data)
# [10, 11, 12, 13, 14, 15, 16, 17, 18, 19, 0, 1, 2, 3, 4, 5, 6, 7, 8, 9]

4.Python控制语句详解

• if_elif_else条件控制
  • 条件判断

#猜数字游戏
number=100
guessNumber=int(input("Please input your number:"))
if guessNumber == number:
    print("Wow,you guess number is right!")
elif guessNumber > number:
    print("Your guess number is larger than before!")
else:
    print("Your guess number is smaller than before")

• while循环
  • 在不确定次数的时候使用while循环

#猜数字游戏
number=100
while  True:
    guessNumber=int(input("Please input your number:"))
    if guessNumber == number:
        print("Wow,you guess number is right!")
        break
    elif guessNumber > number:
        print("Your guess number is larger than before!")
        continue
    else:
        print("Your guess number is smaller than before")
        continue

• for循环
  • 常用于迭代可迭代的对象，如列表、元祖等

# 在Python2中使用Python3的语法可以这样导包
from __future__ import print_function
for i in range(10):
    print(i,end="") # 没有空格

print()
for i in [1,2,3,4]:
    print(i,end=" ") # 有空格


print()
for i in (1,2,3,4):
    print(i,end="")

print()
for i in {"apple":1,"pear":2}.values():
    print(i,end="")
print()


for i in range(10):
    print(i,end="")
else:
    print("Finish")

5.Python文件读写详解

• Python的文件读写简单
  • open(file,mode="r") 读
    • 如何判断文件读到末尾？
      • 循环读取
      • 如果指定读取行的长度为0，结束(if len(line)==0 break)
      • f.readline()
  • open(file,mode="w")写
    • f.writeline()

def writeFile():
    sen = '''\
This is first line!
This is second line!
This is third line!
This is last line!\
'''
    f = open("sentecnce.txt", mode="w")
    f.writelines(sen)
    f.close()
def readLines():
    f = open("sentecnce.txt", mode="r")
    while True:
        line = f.readline()
        if len(line) == 0:
            break
        print(line, end="")

if __name__ == '__main__':
    # writeFile()
    readLines()

6.Python异常控制详解

• 案例

# 2/0 #ZeroDivisionErro r: division by zero
# print(name*4) #NameError: name 'name' is not defined
try:
    2/0 #ZeroDivisionError: division by zero
    age=int(input("please input your age:"))
    print(age) #ValueError: invalid literal for int() with base 10: '80098090-=='
except: # except后面不加可以捕获所有异常
    print("input again!")
finally:
    print("Finish")

• try-----except----finally

• 改写python的猜数字游戏

#猜数字游戏
number=100
while  True:
    try:
        guessNumber=int(input("Please input your number:"))
        if guessNumber == number:
            print("Wow,you guess number is right!")
            break
        elif guessNumber > number:
            print("Your guess number is larger than before!")
            continue
        else:
            print("Your guess number is smaller than before")
            continue
    except:
        print("input again:")
    finally:
        print("Done")

7.Python面向对象

• Python通过class关键字进行面向对象的设计
• 如何通过py文件导入python的类？
  • 使用from py文件 import 类名
  • 直接进行计算

class ArithMatic():
    def __init__(self,x,y):
        self.X=x
        self.Y=y
    def add(self):
        return self.X+self.Y
    def sub(self):
        return self.X-self.Y
    def mul(self):
        return self.X*self.Y
    def div(self):
        return self.X/self.Y
if __name__ == '__main__':
    x=int(input("please input number:"))
    y=int(input("please input another number:"))
    aritcal=ArithMatic(x,y)
    print(aritcal.add())
    print(aritcal.sub())
    print(aritcal.mul())
    print(aritcal.div())

调用自己写的类
自己写的类ArithDemo

class ArithMatic():
    def __init__(self,x,y):
        self.X=x
        self.Y=y
    def add(self):
        return self.X+self.Y
    def sub(self):
        return self.X-self.Y
    def mul(self):
        return self.X*self.Y
    def div(self):
        return self.X/self.Y

测试类testDemo

from ArithMaticDemo import ArithMatic
x=int(input("please input your number:"))
y=int(input("please input your another number:"))
artical=ArithMatic(x,y)
print(artical.add())
print(artical.sub())
print(artical.mul())
print(artical.div())

8.Python-GUI程序设计

• tkinter包
• demo案例

from tkinter import *
import tkinter.simpledialog as dl
import tkinter.messagebox as mb
mb.showinfo(title="welcome",message="Hello world")
dl.askinteger("Ask integer : ","Please input your age : ")

• messagebox和askinteger包实现猜数字游戏
• 学会将猜数字游戏使用GUI实现

import tkinter.messagebox as mb
import tkinter.simpledialog as dl

mb.showinfo(title="Weclome",message="GuessNumberGame!")
number=100
while True:
    guessNumber=dl.askinteger("Ask integer:","Please input your age:")
    if guessNumber ==number:
        mb.showinfo("Wow","Your will win the whole world!")
        break
    elif guessNumber >number:
        mb.showinfo("error","You guess wrong!larger than before one!")
        continue
    else:
        mb.showinfo("error","You guess wrong!smaller than before one!")
        continue

9.阶段小练习-HongBao程序实战

• 练习python的语法
• 设置两个参数—total—num
• 设置存放红包的数据结构—list数据结构
• 设置already就是将已经发放的金额进行保存
• 最后一个用户直接用total-already

import random
def hongbao(total,num):
    #total指的是有多少钱
    #num指的是红包有多少个
    result=[]
    #规则：N个人，首先给前N-1个人发红包，在给最后一个人发
    already=0
    for  i in range(1,num):
        t=random.randint(1,(total-already)-(num-i)) # randomint的范围是 :[a,b]
        result.append(t)
        already+=t
    result.append(total-already)
    return  result

if __name__ == '__main__':
    total=int(input("please input your money:"))
    num=int(input("please input your num:"))
    for i in range(30):
        result=hongbao(total,num)
        print(result)

• 升级版 ---- python2版本

#模拟发红包程序
import random
def hongbao(total,num):
    total=float(total)#红包数
    num=int(num)#红包总额
    min = 0.01  # 最小红包
    if (num < 1):
        return
    if num == 1:
        print("第%d个人拿到红包金额为：%.2f" % (num, total))
        return
    i = 1
    while (i < num):
        #过程解释：
        #num=4,total=10
        #i=1,1<4,10-0.03=9.97,k=1,if假,max=9.97/1=9.97,money=随机数(1,997),假设650，取余得到6.50，total=10-6.5=3.5
        #total=3.5 i=2,2<4,max=3.5-0.01*(4-2)=3.5-0.02=3.48,k=0,k=2,max=3.48/2=1.24 money=(1,124),假设20，取余得到0.2，total=3.5-0.2=3.3
        #total=3.3 i=3,3<4,max=3.3-0.01(4-3)=3.29,k=0,k=1,max=3.3,money=(1,330),假设130，取余得1.3，total=3.3-1.3=2
        #total=2,i=4不小于num=4,退出while循环，将剩余的2元钱拿到自己手里，程序结束

        # 保证即使一个红包是最大的了, 后面剩下的红包, 每个红包也不会小于最小值
        max = total - min * (num - i)
        k = int((num - i) / 2)
        #保证最后两个人拿的红包不超出剩余红包
        if num - i <= 2:
            k = num - i
        #最大的红包限定的平均线上下
        max = max / k
        #保证每个红包大于最小值,又不会大于最大值
        monney = random.randint(int(min * 100), int(max * 100))
        #保留两位小数
        monney = float(monney) / 100
        total = total - monney
        print("第%d个人拿到红包数为：%.2f, 余额为: %.2f" % (i, monney, total))
        i += 1

    print("第%d个人拿到红包数为：%.2f, 余额为: %.2f" % (i, total, 0.0))#最后一个人拿走剩下的红包
    # each=[]
    # already=0
    # for i in range(1,num):
    #     t=random.randint(1,(total-already)-(num-i))
    #     each.append(t)
    #     already=already+t
    # each.append(total-already)
    # return each
if __name__=='__main__':
    total = input('输入红包总金额:')
    num = input('输入发红包数量:')
    try:
        # 模拟30次
        for i in range(30):
            each = hongbao(total, num)
            print(each)
    except:
        print('Error')

10.Python实战-蒙特卡罗方法求解近似值

• Spark中实际案例演示
• 蒙特卡洛—近似值求解方法
• 以圆周率为求解目标：设定用圆的面积除以正方形面积*4近似计算圆周率，使用扔飞镖方式模拟求解面积，如果落入园内的飞镖数值/落入正方形内的飞镖数值*4近似求解PI的近似值。
• 使用python近似求解

import random
#times是表示落入正方形内的次数
def estimatePiDemo(times):
    #定义变量表示落入圆内次数
    hists=0
    #在落入正方形之上如何落入圆内
    for i in range(times):
        x=random.random()*2-1 #x in the interval [-1, 1)
        y=random.random()*2-1 #x in the interval [-1, 1)
        # 或者修改为[0,1)之间也可以
        if x*x+y*y <1:
            hists+=1
    return 4.0*hists/times

#测试
if __name__ == '__main__':
    PI=estimatePiDemo(10000)
    print(PI)

11.Python实战-卷积的练习操作

• 卷积—实际上对图像进行操作
• 使用卷积核对原图像进行处理
• 通过移动卷积核分别对原图像进行先累乘在累加得到图像处理后的结果
• 说明：在工程方面求解卷积方面需要将卷积核进行反转的，但是在深度学习或图像处理领域通过不对卷积核进行反转，而是直接使用卷积核对原来的图形进行卷积，卷积之后的结果就是对图像处理的结果。

import scipy as sp
result=sp.convolve([1,2,3,4,5,6,7,8,8,9],[4,5,6])
print(result) #[ 4 13 28 43 38 24]
# 简单调用即可

# 详细步骤
# lst1=[4,5,6] ===》lst1=[6,5,4]==》length1=3 i---》range(1,4)=1,2,3
# 1.  3-1=2 lst1=[4(2)]
# 2.  3-2=1 lst1=[5(1),4(2)]
# 3.  3-3=0 lst1=[6(0),5(1),4(2)]
# lst2=[1,2,3,4]==》length2=4
def conv(lst1,lst2):
    length1=len(lst1)
    length2=len(lst2)
    lst1.reverse()
    result=[]
    for i in range(1,length1+1):
        t=lst1[length1-i:]
        r1=sum([t1*t2 for t1,t2 in zip(t,lst2)])
        result.append(r1)
    #使用lst2进行相对移动----加一个翻转
    # lst2=[1,2,3,4]==》length2=4==>range(1,4)==》1,2,3
    # 1.lst2[1:]   lst2=[2,3,4]
    # 2.lst2[2:]   lst2=[3,4]
    # 2.lst2[3:]   lst2=[4]
    for i in range(1,length2):
        t=lst2[i:]
        r2=sum([t1*t2 for t1,t2 in zip(lst1,t)])
        result.append(r2)
    return result

if __name__ == '__main__':
    result=conv([1,2,3,4,5,6,7,8,8,9],[4,5,6])
    print("convolve 1 result:",result)

12.Numpy简介和创建随机数实例

• numpy

1.高性能科学计算和数据分析的基础包
2.ndarray，多维数组（矩阵），具有矢量运算能力，快速、节省空间
3.矩阵运算，无需循环，可完成类似Matlab中的矢量运算
4.线性代数、随机数生成
5.import numpy as np

• Numpy矩阵运算库
• ndarray—所有矩阵类的父类
• 底层C语言—速度快，数据科学基础的矩阵运算
• Scipy-基于Numpy基础上的数据科学运算库

1.在NumPy库的基础上增加了众多的数学、科学及工程常用的库函数
2.线性代数、常微分方程求解、信号处理、图像处理
3.一般的数据处理numpy已经够用
4.import scipy as sp

• 如何创建随机数？

  import numpy as np
  np.random.randn(5,5)
  

  使用随机数可以模拟数据

import numpy as np
r1=np.random.randn(6,6) #standard normal标准正态分布
print(type(r1)) #<class 'numpy.ndarray'>
print(r1)
# [[ 0.35768082 -2.24003375  0.97901171  2.04710821 -1.91734127  0.96683924]
#  [-0.65749804 -0.21972666 -1.19110268 -0.04720957  1.09637419 -0.51316831]
#  [-0.429027    0.61554557 -0.89818235  0.15425943 -1.73827879 -0.24784541]
#  [-0.95538335  0.88994479 -0.32886515 -0.10198783  0.42304614  0.1480035 ]
#  [-0.22419574  0.27653052  1.75053804  0.87883921 -0.48265662 -0.11972343]
#  [ 1.46267967 -0.19993685  0.14474872 -0.04683207 -0.45452299 -2.14185888]]
r2=np.random.normal(0,1,size=(5,5)) #a normal (Gaussian) distribution.
# 正态分布/高斯分布
print(r2)
# [[-0.55432089  0.09616651  0.08412417  1.01892604  0.19838077]
#  [-2.13648325 -0.83398919  0.68912474  0.08068824 -0.07962395]
#  [-0.48719013 -0.29557087  0.12035972  0.09068141  0.82581846]
#  [ 1.36233663  0.2267474  -1.18723997 -1.99202401 -0.21559526]
#  [ 0.98151658 -1.62043668  0.49755657 -1.87820321  0.25764869]]
r3=np.random.binomial(10,0.5,size=(3,3))# 二项分布
print(r3)
# [[3 5 7]
#  [6 4 3]
#  [4 6 6]]
shape, scale = 2., 2.  # mean=4, std=2*sqrt(2)
# 伽马分布
s = np.random.gamma(shape, scale, 1000)
print(s)

参考学习资料：
Python、NumPy和SciPy介绍：http://cs231n.github.io/python-numpy-tutorial
NumPy和SciPy快速入门：https://docs.scipy.org/doc/numpy-dev/user/quickstart.html

13.Numpy-array方式创建矩阵及矩阵属性详解

• ndarray父类实现矩阵的创建基本方式
• np.array方法创建多维度的矩阵
• np.array([[1,2,3],[4,5,6]])
• array属性
  • shape属性–几行几列
  • ndim属性—几维度
  • size属性—多少个元素
  • dtype-----类型
• 可以自己改变属性 , 改变什么属性就对什么属性赋值即可

import numpy as np
r1=[[1,2,3],[4,5,6],[7,8,9]]
print(type(r1))#<class 'list'>
#矩阵得array定义
arr1=np.array([[1,2,3],[4,5,6],[7,8,9]],dtype="float32") #<class 'numpy.ndarray'>
print(type(arr1))
print(arr1)
#矩阵的性质
print("shape",arr1.shape) #shape (3, 3) 几行几列
print("ndim",arr1.ndim) # 维度 : 向量-1维度  矩阵-2维度  数组-3维度
print("dtype:",arr1.dtype) # 类型 : dtype: int32
print("size:",arr1.size) # 大小 : size :9
#其他数据类型的转换
print(np.array((1,2,3,4))) # tuple转array
print(np.array({1,2,3,4})) # set转array
print(np.array({1:"apple",2:"banana"})) #字典转array 
# [1 2 3 4]
# {1, 2, 3, 4}
# {1: 'apple', 2: 'banana'}
# ### 利用type查看类型
# list of list嵌套序列转换为ndarray
lis_lis = [range(10), range(10)]
arr = np.array(lis_lis)

14.Numpy-ndarray特殊矩阵创建

• 0矩阵
  • np.zeros()
• 1矩阵
  • np.ones()
• 对角阵
  • np.eye() # 单位对角阵
  • np.diag() # 对角矩阵

import numpy as np
r1=np.zeros(shape=(3,3))
# 指定大小的全0数组。注意：第一个参数是元组，用来指定大小，如(3, 4)。
print(r1)
r2=np.ones(shape=(3,3))
# 指定大小的全1数组。注意：第一个参数是元组，用来指定大小，如(3, 4)。
print(r2)
r3=np.diag([1,2,3,4])
print(r3)
np.eye(2, dtype=int) # 单位矩阵
A = np.diag([1.0, 2, 3])
print(A)
# array([[1., 0., 0.],
#        [0., 2., 0.],
#        [0., 0., 3.]])
print(np.flipud(A)) # 垂直反转
# array([[0., 0., 3.],
#        [0., 2., 0.],
#        [1., 0., 0.]])

A = np.diag([1., 2., 3.])
print(A)
# array([[1., 0., 0.],
#        [0., 2., 0.],
#        [0., 0., 3.]])
print(np.fliplr(A)) # 水平反转
# array([[0., 0., 1.],
#        [0., 2., 0.],
#        [3., 0., 0.]])
np.empty()
# 初始化数组，不是总是返回全0，有时返回的是未初始的随机值（内存里的随机值）。

15.Numpy-arange方式创建矩阵及dtype数据类型简介

• arange创建方式类似于range对象
• arange(start:stop:step)
• arange如何形成矩阵
  • shape赋值维度
  • reshape调整维度
• astype : 转换数组的数据类型 , astype转换数据类型，将已有的数组的数据类型转换为int32
  • zeros_float_arr.astype(np.int32)
• dtype : 指定数组的数据类型，类型名+位数，如float64, int32

# range(start:stop:step)
print(list(range(1,10,1))) # list类型
import numpy as np
r1=np.arange(10)
# arange(start:stop:step)
print(r1)
print(type(r1)) #<class 'numpy.ndarray'>
print(np.array(np.random.randn(3,3)))
#shape : 
r1.shape=2,5
print(r1)
# [[0 1 2 3 4]
#  [5 6 7 8 9]]
#reshape : 重新调整
r2=np.arange(10).reshape(5,2)
print(r2)
# [[0 1]
#  [2 3]
#  [4 5]
#  [6 7]
#  [8 9]]

zeros_int_arr = r2.astype(np.int32)
print(zeros_int_arr)
print(zeros_int_arr.dtype)  # int32

16.Numpy的mat和matrix矩阵创建

• matrix必须是2维度矩阵
• mat是maitrix的别名，直接使用分号和引号将其分开

import numpy as np
r1=np.matrix([1,2,3,4])
print(r1)
print(r1.ndim) #2
print(r1.shape) #(1, 4)
print(r1.size) #4
r2=np.matrix([[1,2,3],[4,5,6],[7,8,9]])
print(r2)
print(r2.ndim) #2
print(r2.shape) #(3, 3)
print(r2.size) #9
# r2=np.matrix([[[1,2,3],[4,5,6],[7,8,9]]]) #ValueError: matrix must be 2-dimensional
r3=np.array([[[1,2,3],[4,5,6],[7,8,9]]]) 
print(r3.shape) #(1, 3, 3)
print(r3.ndim) #3

#mat和matrix区别？
#mat是matrix的别名-----------
r3=np.mat([1,2,3,4])
print(r3)
r4=np.mat("1,2;4,5")
print(r4)
# [[1 2]
#  [4 5]]

17.Numpy的等差和等比数列的创建

• numpy中等差
  • linspace
  • 格式: linspace(start,stop,num=个数)
• numpy中等比
  • logspace
  • 格式 : logspace(start,stop,num=个数)
  • logspace换底
  • 格式np.logspace(start,stop,num=个数,base=2)

import numpy as np
# 等差数列
# linspace(start,stop,num=个数)
r1=np.linspace(1,10,num=10)
print(r1) #[ 1.  2.  3.  4.  5.  6.  7.  8.  9. 10.]
r2=np.linspace(1,10,num=50)
print(r2)
# 等比数列
# logspace(start,stop,num=个数)
r3=np.logspace(1,10,10)
print(r3)#[1.e+01 1.e+02 1.e+03 1.e+04 1.e+05 1.e+06 1.e+07 1.e+08 1.e+09 1.e+10]
r4=np.logspace(1,10,100)
print(r4)
a = np.logspace(0,9,10,base=2)
print(a)
# array([   1.,    2.,    4.,    8.,   16.,   32.,   64.,  128.,  256.,  512.])

18.Numpy基础函数计算详解

• Numpy基础函数
  • ceil、floor、rint等
• Numpy统计函数
  • std、mean、var等
• Numpy的unique函数
  • sorted、unique

1.元素计算函数
	np.ceil(): 向上最接近的整数，参数是 number 或 array
	np.floor(): 向下最接近的整数，参数是 number 或 array
	np.rint(): 四舍五入，参数是 number 或 array
	np.isnan(): 判断元素是否为 NaN(Not a Number)，参数是 number 或 array
	np.multiply(): 元素相乘，参数是 number 或 array
	np.divide(): 元素相除，参数是 number 或 array
	np.abs()：元素的绝对值，参数是 number 或 array
	np.where(condition, x, y): 三元运算符，x if 		condition else y
2.元素统计函数
	np.mean(), np.sum()：所有元素的平均值，所有元素的和，参数是 number 或 array
	np.max(), np.min()：所有元素的最大值，所有元素的最小值，参数是 number 或 array
	np.std(), np.var()：所有元素的标准差，所有元素的方差，参数是 number 或 array
	np.argmax(), np.argmin()：最大值的下标索引值，最小值的下标索引值，参数是 number 或 array
	np.cumsum(), np.cumprod()：返回一个一维数组，每个元素都是之前所有元素的 累加和 和 累乘积，参数是 number 或 array
	多维数组默认统计全部维度，axis参数可以按指定轴心统计，值为0则按列统计，值为1则按行统计。
3.元素判断函数
	np.any(): 至少有一个元素满足指定条件，返回True
	np.all(): 所有的元素满足指定条件，返回True
4.元素去重排序函数
	np.unique():找到唯一值并返回排序结果，类似于Python的set集合

import  numpy as np

randn = np.random.randn(3, 3)
print(randn)
# 1.元素计算函数
# np.ceil(): 向上最接近的整数，参数是 number 或 array
print(np.ceil(randn))
# np.floor(): 向下最接近的整数，参数是 number 或 array
print(np.floor(randn))
# np.rint(): 四舍五入，参数是 number 或 array
print(np.rint(randn))
# np.isnan(): 判断元素是否为 NaN(Not a Number)，参数是 number 或 array
print(np.isnan(randn))
# np.multiply(): 元素相乘，参数是 number 或 array
arr1=np.array([[1,2],[3,4]])
arr2=np.array([[1,2],[3,4]])
print(np.multiply(arr1,arr2))
# np.divide(): 元素相除，参数是 number 或 array
print(np.divide(arr1,arr2))
# np.abs()：元素的绝对值，参数是 number 或 array
print(np.abs(randn))
# np.where(condition, x, y): 三元运算符，x if condition else y
print(np.where(arr1>0,1,-1))
# =====================================
# np.mean(), np.sum()：所有元素的平均值，所有元素的和，参数是 number 或 array
# 	np.max(), np.min()：所有元素的最大值，所有元素的最小值，参数是 number 或 array
# 	np.std(), np.var()：所有元素的标准差，所有元素的方差，参数是 number 或 array
# 	np.argmax(), np.argmin()：最大值的下标索引值，最小值的下标索引值，参数是 number 或 array
# 	np.cumsum(), np.cumprod()：返回一个一维数组，每个元素都是之前所有元素的 累加和 和 累乘积，参数是 number 或 array
# 	多维数组默认统计全部维度，axis参数可以按指定轴心统计，值为0则按列统计，值为1则按行统计。
import numpy as np
arr1=np.array([[1,2,3],[4,5,6],[7,8,9]])
print(arr1)
print(np.sum(arr1,axis=0)) #列
print(np.sum(arr1,axis=1)) #行
print(np.mean(arr1))
print(np.max(arr1,axis=0))
print(np.max(arr1,axis=1))
print(np.std(arr1,axis=0)) # 标准差
print(np.var(arr1,axis=0)) # 方差
print(np.argmax(arr1,axis=0)) # 最大值对应的下标
print(np.argmax(arr1,axis=1))
print(np.cumsum(arr1,axis=0)) # 累加和
print(np.cumprod(arr1,axis=0)) # 累乘积 , 若没有行列限制是一直乘

arr2=np.array([1,2,1,2,1,2,-1,-2,-4])
print(np.unique(arr2,return_inverse=True))
# return_inverse返回唯一值的下标
a = np.array([[1, 0, 0], [1, 0, 0], [2, 3, 4]])
print(a)
print(np.unique(a, axis=0)) # 行去重且排序
print(np.unique(a, axis=1)) # 列去重且排序
# array([[1, 0, 0], [2, 3, 4]])

19.Numpy线性代数运算详解

• Numpy线性代数运算
  • 矩阵的乘法
  • 矩阵的转置
  • 矩阵的求逆
  • 矩阵的分解
    • 矩阵的QR分解
    • 矩阵的特征值分解
    • 矩阵的奇异值分解

import numpy as np
arr1=np.array([[1,2,3],[4,5,6],[7,8,9]])
#矩阵乘法
#way1
print(np.dot(arr1,arr1))
#way2
print(arr1.dot(arr1))
#矩阵的转置
print(arr1.T)
print(arr1.T.dot(arr1))
#矩阵的行列式
from numpy.linalg import det
print("行列式",det(arr1))
arr2=np.array([[1,2],[2,4]])
print(det(arr2)) #0.0
#矩阵求逆---伴随矩阵/行列式----行列式为0的话，整个求逆的结果不存在
from numpy.linalg import inv
print(inv(arr1))
# print(inv(arr2))#numpy.linalg.linalg.LinAlgError: Singular matrix
#矩阵的分解-QR分解--分解为Q矩阵和R矩阵
from numpy.linalg import  qr
Q,R=qr(arr1)
print(Q)
print(R)
#验证乘积的结果
print(Q.dot(R))
#矩阵的分解-特征值分解
from numpy.linalg import eig
value,vector=eig(arr1)
print(value)# 特征值
#[ 1.61168440e+01 -1.11684397e+00 -9.75918483e-16]
print(vector)# 特征向量
# [[-0.23197069 -0.78583024  0.40824829]
#  [-0.52532209 -0.08675134 -0.81649658]
#  [-0.8186735   0.61232756  0.40824829]]
#如何将特征值和特征向量转化为原来的矩阵
#A=Vector*value*inv(Vector)
print(vector.dot(np.dot(np.diag(value),inv(vector))))
# [[1. 2. 3.]
#  [4. 5. 6.]
#  [7. 8. 9.]]
#矩阵的分解-奇异值分解
from numpy.linalg import svd
U,Sigma,VT=svd(arr1)
print(U)
print(Sigma)#[1.68481034e+01 1.06836951e+00 3.33475287e-16]
print(VT)
#是否正交 ---- 单位阵
print(U.dot(inv(U)))
print(VT.dot(inv(VT)))
# print(9999999999999999999999*99999999999999999999999999999)
#转换回去
print(np.dot(U,np.dot(np.diag(Sigma),VT)))
# [[1. 2. 3.]
#  [4. 5. 6.]
#  [7. 8. 9.]]
print(np.allclose(np.dot(U,np.dot(np.diag(Sigma),VT)),arr1))

20.总结