1.1.1 投资-编程基础-numpy

Kelvin写代码

已于 2024-03-29 17:34:51 修改

阅读量949

点赞数 18

分类专栏：投资文章标签：执行合一：投资篇编程基础-numpy

于 2023-12-25 16:18:50 首次发布

本文链接：https://blog.csdn.net/sdfiiiiii/article/details/135202665

版权

投资专栏收录该内容

12 篇文章 0 订阅

订阅专栏

跳转到根目录：知行合一：投资篇

已完成：
1、投资&技术
1.1.1 投资-编程基础-numpy
1.1.2 投资-编程基础-pandas
1.2 金融数据处理
 1.3 金融数据可视化
2、投资方法论
2.1.1 预期年化收益率
 2.1.2 一个关于y=ax+b的故事
 2.1.3-数据标准化
 2.1.4-相关性分析
 2.2.1.1-一个关于定投的故(姿)事(势)
2.2.1.3-移动平均线

3、投资实证

1. 创建

1.1. 通过列表

通过列表创建numpy数组很简单，不过实际应用中很少这么操作。

# 通过列表创建数组
import numpy as np
a_list = [2014, 2015, 2016, 2017, 2018, 2019, 2020, 2021, 2022, 2023]
arr = np.array(a_list)
arr

array([2014, 2015, 2016, 2017, 2018, 2019, 2020, 2021, 2022, 2023])

1.2. np.arange起止、步长

知道开始、截止、步长，来创建数组。

注意：前闭后开[)。输出的最后一个 <= 截止。

# 通过np.arange创建数组
import numpy as np
arr = np.arange(2014, 2024, 1)  # 前闭后开：从2014到2024，递增1
print('长度：', len(arr))
print(arr)

arr = np.arange(2014, 2024, 2)  # 前闭后开：从2014到2024，递增1
print('长度：', len(arr))
print(arr)


长度： 10
[2014 2015 2016 2017 2018 2019 2020 2021 2022 2023]
长度： 5
[2014 2016 2018 2020 2022]

1.3. np.linspace固定个数

知道开始、截止，创建固定输出个数的数组。

注意：1. 前闭后开；2. 输出结果是小数(可以通过参数dtype=int来指定输出的结果)

场景：比如说知道一只股票的最低和最高价，在此间均分10等份，统计各区间命中个数后形成直方图。

import numpy as np
arr = np.linspace(2014, 2023, 10)
print(arr)

arr = np.linspace(2014, 2024, 10)
print(arr)

arr = np.linspace(2014, 2024, 10, dtype=int)
print(arr)


[2014. 2015. 2016. 2017. 2018. 2019. 2020. 2021. 2022. 2023.]
[2014.         2015.11111111 2016.22222222 2017.33333333 2018.44444444	2019.55555556 2020.66666667 2021.77777778 2022.88888889 2024.        ]
[2014 2015 2016 2017 2018 2019 2020 2021 2022 2024]

2. 访问

2.1. 取出第x个

0和-1，是第一个和最后一个

import numpy as np
arr = np.arange(2014, 2024, 1)  # 前闭后开：从2014到2024，递增1
print(arr[0])
print(arr[-1])

2014
2023

2.2. 间隔着取数

有时候，不一定是间隔1个，也可能是间隔x个。

然后看到两个冒号连一起，第一感觉是懵的…

import numpy as np
arr = np.arange(2014, 2024, 1)  # 前闭后开：从2014到2024，递增1
print(arr)
print(arr[0:5:2])  # 从第0到第5，每隔2个取1个
print(arr[::2])    # 2个冒号，也就这么回事儿

[2014 2015 2016 2017 2018 2019 2020 2021 2022 2023]
[2014 2016 2018]
[2014 2016 2018 2020 2022]

2.3. 迭代nditer flat

迭个代，也是要了命。

import numpy as np
arr = np.arange(2014, 2024, 1)  # 前闭后开：从2014到2024，递增1
print('arr=', arr)

for i in arr:
    print(arr)  # surprise! 其实想想也合理，人家numpy也没说是一维数组啊，况且人家强项应该就是多维数组的处理，嗯，就是这样...吧
    

# 真的是要了命了，就是想简单遍历一下一维的数组，还得查资料，没有简(偷)便(懒)办法
# 迭代大法1：  np.nditer(arr)
for item in np.nditer(arr):
    print(item)

# 迭代大法2： arr.flat 与 arr.flatten() 效果一样
for item in arr.flat:  
    print(item)
    
for item in arr.flatten():
    print(item)

2.4. 花式索引

一般常用的就是1维数组，2维和更高维的。

不过！好消息是！可能用不到！

import numpy as np
arr = np.arange(2014, 2024, 1)  # 前闭后开：从2014到2024，递增1
print('arr=', arr)

print(arr[[0, -1, 2]]) # 要用2个方括号，因为第一层的方括号，其实是去找对应的维度
# 实际做投资分析，遇到的还真不多，真的需要，就把代码写的细致一点，也更好理解，不做防御性编程。

# 用一个2维数组看看
arr = np.arange(32).reshape(8,4)
print(arr)
# 如果用1个方括号，取出来的是什么呢？
print('1个方括号arr[0]= ', arr[0])  # 如果是多维的，最好就不这么写，自己也难理解。写成"行,列"这种格式，逗号前是对行的限制，逗号后是对列的限制，不要炫技，没意思。
print('2个方括号arr[[0]]= ', arr[[0]])  # 和 arr[[0],] 等价，就好理解了，逗号左边代表怎么取行，右边代表怎么取列。那就是第0行，对列没限制，取所有列
print('2个方括号arr[[0],]= ', arr[[0],])
print('2个方括号arr[:[0]]= ', arr[:,[0]])  # 逗号前的冒号，代表取所有行；逗号之后的[0]，代表只需要这些行里面的第0列


arr= [2014 2015 2016 2017 2018 2019 2020 2021 2022 2023]
[2014 2023 2016]
[[ 0  1  2  3]
 [ 4  5  6  7]
 [ 8  9 10 11]
 [12 13 14 15]
 [16 17 18 19]
 [20 21 22 23]
 [24 25 26 27]
 [28 29 30 31]]
1个方括号arr[0]=  [0 1 2 3]
2个方括号arr[[0]]=  [[0 1 2 3]]
2个方括号arr[[0],]=  [[0 1 2 3]]
2个方括号arr[:[0]]=  [[ 0]
 [ 4]
 [ 8]
 [12]
 [16]
 [20]
 [24]
 [28]]

2.5. 布尔型索引

起到过滤的作用，比如取出特定条件的数据。这种操作在一般的编程语言里少见。

import numpy as np
arr = np.arange(2014, 2024, 1)  # 前闭后开：从2014到2024，递增1
print('arr=', arr)

print('布尔型索引，过滤2018年之后的数据：', arr[arr > 2018])

arr= [2014 2015 2016 2017 2018 2019 2020 2021 2022 2023]
布尔型索引，过滤2018年之后的数据： [2019 2020 2021 2022 2023]

3. 变更

3.1. 切片

如果是一维数组，print(arr[[0,-1]])表示：取第0和-1位置的值。

如果是二维数组，arr[x:y , m:n]表示：取第x到y行，再从中取m到n列。

一维数组案例：

import numpy as np
arr = np.arange(2014, 2024, 1)  # 前闭后开：从2014到2024，递增1
print('arr=', arr)

print(int(len(arr)/2))
print(arr[int(len(arr)/2): -1])  # arr[5:-1]

arr= [2014 2015 2016 2017 2018 2019 2020 2021 2022 2023]
5
[2019 2020 2021 2022]

二维数组案例：

import numpy as np

# 用一个2维数组看看
arr = np.arange(32).reshape(8,4)
print(arr)
# 如果用1个方括号，取出来的是什么呢？
print('1个方括号arr[0]= ', arr[0])  # 如果是多维的，最好就不这么写，自己也难理解。写成"行,列"这种格式，逗号前是对行的限制，逗号后是对列的限制，不要炫技，没意思。
print('2个方括号arr[[0]]= ', arr[[0]])  # 和 arr[[0],] 等价，就好理解了，逗号左边代表怎么取行，右边代表怎么取列。那就是第0行，对列没限制，取所有列
print('2个方括号arr[[0],]= ', arr[[0],])
print('2个方括号arr[:[0]]= ', arr[:,[0]])  # 逗号前的冒号，代表取所有行；逗号之后的[0]，代表只需要这些行里面的第0列

[[ 0  1  2  3]
 [ 4  5  6  7]
 [ 8  9 10 11]
 [12 13 14 15]
 [16 17 18 19]
 [20 21 22 23]
 [24 25 26 27]
 [28 29 30 31]]
1个方括号arr[0]=  [0 1 2 3]
2个方括号arr[[0]]=  [[0 1 2 3]]
2个方括号arr[[0],]=  [[0 1 2 3]]
2个方括号arr[:[0]]=  [[ 0]
 [ 4]
 [ 8]
 [12]
 [16]
 [20]
 [24]
 [28]]

3.2. 拼接concatenate

这个可能用在比如拉取数据，将2个区间数据合并的场景。

import numpy as np
arr = np.arange(2014, 2024, 1)  # 前闭后开：从2014到2024，递增1
print('arr = ', arr)

future = [2024, 2025, 2026]
arr2 = np.concatenate((arr, future))
print('arr2 = ', arr2)

arr= [2014 2015 2016 2017 2018 2019 2020 2021 2022 2023]
arr2 =  [2014 2015 2016 2017 2018 2019 2020 2021 2022 2023 2024 2025 2026]

3.3. 平均分split

注意：如果不能平均分，会报错 array split does not result in an equal division

import numpy as np
arr = np.arange(2014, 2024, 1)  # 前闭后开：从2014到2024，递增1
print('arr = ', arr)

# arr2 = np.split(arr, 3) 
# arr2  # array split does not result in an equal division

arr3 = np.split(arr[0:len(arr)-1], 3) 
print('arr3 = ', arr3)

arr =  [2014 2015 2016 2017 2018 2019 2020 2021 2022 2023]
arr3 =  [array([2014, 2015, 2016]), array([2017, 2018, 2019]), array([2020, 2021, 2022])]

3.4. 去重np.unique

import numpy as np
arr = np.array([2014, 2015, 2016, 2017, 2015, 2016, 2017, 2018, 2019, 2020, 2021, 2022, 2023])
print('arr = ', arr)

u_data, u_index = np.unique(arr, return_index=True) # 这个返回的是去重后的数组，以及这个数组中元素在原来数组的下标
print('去重后的数据：', u_data)
print('取这些index：', u_index)  # 当第i个元素在之前出现过，那么就认为它应该去掉，继续向后逐个排查

arr =  [2014 2015 2016 2017 2015 2016 2017 2018 2019 2020 2021 2022 2023]
去重后的数据： [2014 2015 2016 2017 2018 2019 2020 2021 2022 2023]
取这些index： [ 0  1  2  3  7  8  9 10 11 12]

3.5. 排序

排序主要注意看本身排序，还是说排序返回新ordered数组。

import numpy as np
arr = np.array([2014, 2017, 2016, 2015, 2016, 2021, 2018, 2019, 2020, 2017, 2022, 2023, 2015])
print('arr = ', arr)

arr2 = arr.sort()
print('是直接在arr上排序的', arr)
print('arr2是None:', arr2)

arr =  [2014 2017 2016 2015 2016 2021 2018 2019 2020 2017 2022 2023 2015]
是直接在arr上排序的 [2014 2015 2015 2016 2016 2017 2017 2018 2019 2020 2021 2022 2023]
arr2是None None

如果使用的是np.sort(arr)，那就不是在arr上直接排序，arr并不会被改变

import numpy as np
arr = np.array([2014, 2017, 2016, 2015, 2016, 2021, 2018, 2019, 2020, 2017, 2022, 2023, 2015])
print('arr = ', arr)

arr3 = np.sort(arr)
print('arr3=', arr3)
print('arr=', arr)

arr =  [2014 2017 2016 2015 2016 2021 2018 2019 2020 2017 2022 2023 2015]
arr3= [2014 2015 2015 2016 2016 2017 2017 2018 2019 2020 2021 2022 2023]
arr= [2014 2017 2016 2015 2016 2021 2018 2019 2020 2017 2022 2023 2015]

4. 常用函数

4.1. 字符串函数

目前看用的不多，参考：https://www.runoob.com/numpy/numpy-string-functions.html

4.2. 算数函数

NumPy 算术函数包含简单的加减乘除: add()，subtract()，multiply() 和 divide()。用的不多。

4.3. 统计函数

4.3.1. percentile

import numpy as np
arr = np.arange(1,100, 1) # [1-99]
d_75 = np.percentile(arr, 75)  # 这个很有意思，结果74.5，并不是原来arr数组里的数字
d_75

74.5

4.3.2. 最大、最小、中值、平均数

np.max、np.min、np.median中位数(中值)

import numpy as np
arr = np.array([2014, 2017, 2016, 2015, 2016, 2021, 2018, 2019, 2020, 2017, 2022, 2023, 2015])
print('最小：', np.min(arr))
print('中值：', np.median(arr))
print('平均数：', np.average(arr))  # average, 不指定权重时相当于 mean 函数。用法np.average([1,2,3,4],weights =  [4,3,2,1], returned =  True)
print('算术平均值mean：', np.mean(arr))

最小： 2014
中值： 2017.0
平均数： 2017.923076923077
算术平均值mean： 2017.923076923077