“&” 的使用方法（最推荐大家使用它了，容错率最好）

1

command 1 & command 2 & command 3......

可以同时执行多条命令，即使这3个命令中有任何一个执行失败，其他任意2个命令都会执行成功。abcd命令是一个不存在的错误命令，就是显示下效果。如图所示：

“&& “的使用方法

1

command 1 && command 2 && command 3......

可以同时执行多条命令，如果这3个中有一处命令执行失败，那么当碰到执行失败的命令之后的其他任何命令都不会被执行。第一个calc命令会被正确执行，第二个abcd是不存在的错误命令，它执行失败后，第三个mspaint(画图程序)命令及之后的其他任何命令都不会被执行。如图：

“|” 的使用方法（这个方法的使用意义最不大，容错率为0）

1

command 1 | command 2 | command 3......

可以同时执行多条命令，这些命令中只要有一个错误的命令，不管是第几条命令，所有的命令都不会被执行。

“||” 的使用方法

1

command 1 || command 2 || command 3......

可以同时执行多条命令，无论有多少个命令并存，只要多条命令中有一个命令被正确执行，其他的任何命令都不会被执行。下图中第一条abcd是不存在的错误命令，但是第二条calc命令被正确执行，那么之后的mspaint命令不会再被执行，即使后面多条命令都是正确的。它只执行一条正确的命令。

2022-03-10更新：

2022-03-08复盘

股票交易

低估值公司：

优质赛道公司：

国产芯片公司

股票基础知识

市盈率 PE(倍数)

定义：

市价盈利比率： 公司市值/净利润 P/E 。(回本年限,市场热度)【DYNAINFO(39)】

分类：

• PE:静态 ，上年度的 年报净利润

• PE-E:动态，上季度的 净利润*4

• PE-TTM:滚动，往前12个月 的净利润总和

应用：

• 同行业对比

• 历史值对比

• 合理估值，分位点 >50%即高估 <50%即低估 分位点：26%表示当前PE比过去74%的时候低

PEG 市盈率/盈利增速

• PEG=1,估值合理 净利润增长率很难长期超过30%

• 估值低

  • PE低

  • 盈利增长率高

  • 适用处于上升阶段 同时参考：PE,PB)

市净率 PB

• 股价/净资产 P/B 【C/FINANCE(34)】

• 反应公司经营状况的好坏 尤其适用靠净资产增值盈利的公司： 银行和金融机构

• PB值越小，安全边际高

• 没有关联盈利和盈利增速 适用盈利不稳定的周期股

• 计算要剔除商誉 股价/(净资产-商誉)

• PB>8时，风险较大

• 尤其适用靠净资产增值盈利的公司：

  • 银行和金融机构，PB值越小，安全边际高, 没有关联盈利和盈利增速
  • 适用盈利不稳定的周期股，计算要剔除商誉

市销率 PS

• P/S S:每股收入或 总市值/销售收入 TOTALCAPITALC100/FINANCE(20)

• 不受折旧、存货、非经常性收支影响 不像利润那一容易被操控

• 收入不会出现负值 及时利润为负

• 销售收入增大而下降 营业收入规模大的公司PS低

• 不体现成本控制能力， 不关联利润

• 体现公司的潜在价值 市销率越低，说明该公司股票目前的投资价值越大

  • 不受折旧、存货、非经常性收支影响
  • 不像利润那一容易被操控，收入不会出现负值。即使利润为负， 销售收入增大而下降
  • 营业收入规模大的公司PS低，不体现成本控制能力，不关联利润

  EPS 每股收益 （ 税后）

• EPS=本期税后净利/ 普通股在外流通股数

• EPS高代表 公司某种能力强 衡量盈利能力最重要的财务指标 反映普通股的获利水平 【FINANCE(30) / (CAPITAL*100)】

• 产品行销能力

• 技术能力

• 管理能力

• 用途

  • 比较不同公司EPS高低没有意义， 要同时考虑股价和市盈率才有意义

  • 关注公同一司过去EPS趋势， 以及未来成长性也要列入评估

  • EPS要稳定，小心EPS忽高忽低的股票

  • 获利不稳的公司，要观察稀释EPS 股数必须把一些认股权证、可转换债券等， 可能会变成「新股」的股份也都算进来，

  • 小心获利和现金流的落差

  • 常增资的公司，要注意流通在外股数的加权计算问题

净资产收益率 ROE

• FINONE(281,0,0):当前值
• FINONE(281,YEAR-1,1231):去年年报值
• 计算公式：ROE=净利润 / 净资产 = 净利润 / 销售收入 X 销售收入 / 总资产 X 总资产 / 净资产

!

• 净利润/销售收入=净利率

  • 高净利率代表有很强的定价权

• 销售收入/总资产=周转率

  • 高周转率：加速资金流动，提高资金利用率

• 总资产/净资产=杠杆率

  • 通过高杠杆，提高利润
  • 高杠杆同时高负债，高风险

• 应用：

  • 10年年均ROE
    • 年均ROE过低，公司就不适合长期投资，说明公司所在的行业一片红海，长期收益也低；
    • 年均ROE过高，也有问题，就是一块肥肉，就会吸引狼群，没有很高的护城河，很快就会有大量公司涌入ROE很难保持在过高的位置，反而容易落入低ROE情况
    • 10-15%：一般
    • 15-20%：杰出
    • 20%：优秀

• ROE过去十年均值小于15%的公司，胜率低。 巴菲特曾说过，对于长期投资公司，你的年化收益通常就等于公司的年均ROE。这句话有3层意思： 2、年均ROE≥15%，年化收益也在15%附近，说明公司价格合理，也很适合长期投资； 3、年均ROE≥15%，年化收益也远大于15%，说明公司是好公司，但短期价格高估了；三是年均ROE≥15%，年化收益也远小于15%，说明短期价格低估了，这时就要看看短估的原因，若是因为行业衰退了，则要远离，若仅是市场情绪影响，则是投资的好机会。

股息率

• 函数：FINANCE(45)

利润同比

• 函数： FINANCE(43)

•  净利润        FINANCE(30)
  

• 扣非净利润 FINVALUE(206)

收入同比

• 函数：FINANCE(44)

存货

• 函数： FINANCE(27)

权益比

• 函数：FINANCE(36)

• 股东权益(净资产)/资产总额*100

• 股东权益比率与资产负债率之和等于1。

资产负债率

• 函数：FINANCE(9)

销售利润率

• 毛利率 FINVALUE(202)

• 净利率 FIVALUE(199)

流动比率

• FINANCE(11)/FINANCE(15)*100

• 流动比率=流动资产/流动负债 参考>1.5

速动比率

• 速动比率=速动资产÷流动负债 (FINANCE(11)-FINANCE(27))/FINANCE(15)

• 速动资产=流动资产-存货 FINANCE(11)-FINANCE(27)

字典 dict

dict 字典是一些 ‘键：值’ 对的集合。

• 用键来索引

• 字典是可变对象，值的类型不限，键类型是不可变类型

  键类型不能是列表、元组、集合、字典

创建字典

关键字创建字典

1

dict(a=3, b=33)

1

{'a': 3, 'b': 33}

zip()函数生成关键字参数创建

1

dict(zip(['a', 'b'], [3, 4]))

1

{'a': 3, 'b': 4}

fromkeys()函数创建

1

dict.fromkeys(['a', 'b'], [3, 4])

1

{'a': [3, 4], 'b': [3, 4]}

1

dict.fromkeys(['a', 'b'], 11)

1

{'a': 11, 'b': 11}

1

dict.fromkeys('a', [3, 4])

1

{'a': [3, 4]}

解析式创建字典

1

{k: v for k, v in [('a', 1), ('b', 2), ('c',3)]}

1

{'a': 1, 'b': 2, 'c': 3}

1

{k:v for k,v in zip(['a','b','c'],[1,2,3])}

1

{'a': 1, 'b': 2, 'c': 3}

索引

d[key] 字典索引返回对应的值

• 如果key不存在则抛出KeyError异常

1
2

dt1 = dict(zip(['a', 'b', 'c'], [11, 22, 33]))
dt1

1

{'a': 11, 'b': 22, 'c': 33}

1

dt1['b']

1

22

键测试

• key in d。测试指定键是否存在字典中

1
2

'c' in dt1
's' in dt1

1
2

True
False

字典的迭代：

d.keys()

• 返回一个dict_keys对象，它是一个可迭代对象，迭代时返回键序列

1
2
3
4
5

# 返回迭代器
dt1.keys()

# 将迭代器转成列表
list(dt1.keys())

1
2

dict_keys(['a', 'b', 'c'])
['a', 'b', 'c']

d.values()：

• 返回一个dict_values对象，它是一个可迭代对象，迭代时返回值序列

1
2
3

dt1.values()

list(dt1.values())

1
2

dict_values([11, 22, 33])
[11, 22, 33]

d.items()：

• 返回一个dict_items对象，它是一个可迭代对象， 迭代时返回元组(键，值)的序列

1
2
3
4
5

dt1.items()

list(dt1.items())

[list(x) for x in list(dt1.items())]

1
2
3

dict_items([('a', 11), ('b', 22), ('c', 33)])
[('a', 11), ('b', 22), ('c', 33)]
[['a', 11], ['b', 22], ['c', 33]]

字典的操作

获取字典的内容

1
2
3
4

[x for x in dt1]
[x for x in dt1.keys()]
[x for x in dt1.values()]
[x for x in dt1.items()]

1
2
3
4

['a', 'b', 'c']
['a', 'b', 'c']
[11, 22, 33]
[('a', 11), ('b', 22), ('c', 33)]

字典的增删改

1
2
3
4
5

d1= dict(zip(['a', 'b', 'c'], [11, 22, 33]))
d1

d1['f']=100
d1

1
2

{'a': 11, 'b': 22, 'c': 33}
{'a': 11, 'b': 22, 'c': 33, 'f': 100}

1
2
3

d1= dict(zip(['a', 'b', 'c'], [11, 22, 33]))
d1.pop('a')
d1

1
2

11
{'b': 22, 'c': 33}

1
2
3

d1= dict(zip(['a', 'b', 'c'], [11, 22, 33]))
del d1['a']
d1

1

{'b': 22, 'c': 33}

1
2
3
4
5

d1= dict(zip(['a', 'b', 'c'], [11, 22, 33]))
d1

d1['a']=[12,34,5]
d1

1
2

{'a': 11, 'b': 22, 'c': 33}
{'a': [12, 34, 5], 'b': 22, 'c': 33}

1

len(d1)

1

3

合并字典

1
2
3
4

d1= dict(zip(['a', 'b', 'c'], [11, 22, 33]))
d2= dict(zip(['d', 'e', 'f'], [1, 2, 3]))
d1.update(d2)
d1

1

{'a': 11, 'b': 22, 'c': 33, 'd': 1, 'e': 2, 'f': 3}

1
2
3
4

d1= dict(zip(['a', 'b', 'c'], [11, 22, 33]))
d2= dict(zip(['c', 'd', 'e'], [1, 2, 3]))
d1.update(d2)
d1

1

{'a': 11, 'b': 22, 'c': 1, 'd': 2, 'e': 3}

认识 list

• list 是一个序列
• 存在于中括号内
• list 中元素的类型可以多样，同一个 list 中的元素的类型可以是字符串（str）、整型（int）、布尔型（Boolean）、以及嵌套的 list 等

1
2
3
4
5
6

list1 = ['东北', '华北', '华南', '华东', '西南', '西北']  # 字符串用引号包含起来
list2 = []  # 空列表

type(list1)
list1
list2

1
2
3

list
['东北', '华北', '华南', '华东', '西南', '西北']
[]

1
2
3
4

list3 = list('ABCDEF')  # 字符串列表
list4 = list(range(10))  # 整型列表
list3
list4

1
2

['A', 'B', 'C', 'D', 'E', 'F']
[0, 1, 2, 3, 4, 5, 6, 7, 8, 9]

list 的索引

下标索引

• 注意索引是从 0 开始，最后一个的索引编号为 n-1，即所有元素的编号依次为(0,1, 2, …, n-1)。

1
2
3
4

list3[0]
list3[2]
list3[-1]
list3[-2]

1
2
3
4

'A'
'C'
'F'
'E'

切片

• list[start: end : step]
• 包含 “start”，但不包含 “end”
• “step” 表示步长，默认情况下，“step”为 1

1
2
3
4
5

list3[1:4]
list3[:4]
list3[4:]
list3[::-1]
list3[::2]

1
2
3
4
5

['B', 'C', 'D']
['A', 'B', 'C', 'D']
['E', 'F']
['F', 'E', 'D', 'C', 'B', 'A']
['A', 'C', 'E']

用for 循环遍历列表

1
2

for i in list1:
    print(i)

1
2
3
4
5
6

东北
华北
华南
华东
西南
西北

列表的增、改、删

• list 是一个可变的序列，可以通过添加、修改、删除等操作来操作 list 中的元素。

append() 方法

• 是在 list 的末尾添加元素

1
2
3
4

a = ['北京', '上海', '天津', '重庆']

a.append('深圳')  # 在列表的末尾增加新值
a

    ['北京', '上海', '天津', '重庆', '深圳']

insert()

• 是在指定位置添加元素。

1
2

a.insert(1, '广州')  # 表示在索引1的位置插入新值
a

    ['北京', '广州', '上海', '天津', '重庆', '深圳']

用 pop()

• 方法删除 list 末尾的元素

1
2

a.pop()
a

1
2

'深圳'
['北京', '广州', '上海', '天津', '重庆']

用 pop(i) 方法

• 删除指定位置的元素

1
2

a.pop(0)
a

1
2

'北京'
['广州', '上海', '天津', '重庆']

修改 list 中的元素

• 直接通过 list 的索引进行赋值来实现

1
2

a[0] = "北京"
a

1

['北京', '上海', '天津', '重庆']		

列表操作符

‘ + ’ 拼接列表

1
2
3
4

es = ['黑龙江', '吉林', '辽宁']
ws = ['新疆', '青海', '甘肃', '宁夏', '陕西']

es+ws

1

['黑龙江', '吉林', '辽宁', '新疆', '青海', '甘肃', '宁夏', '陕西']

‘ * ‘ 重复列表

1

es*2

1

['黑龙江', '吉林', '辽宁', '黑龙江', '吉林', '辽宁']

判断元素是否存在

1
2

'黑龙江' in es
'黑龙江' in ws

1
2

True
False

列表函数

len( )

1
2
3

a = list(range(11, 29, 4))

len(a)

1

5

- max(list)

• 返回列表元素最大值

1

max(a)

1

27

min(list)

• 返回列表元素最小值

1

min(a)

1

11

list（）

• 将其他序列转成列表

1
2

b = (1, 3, 5, 7)
list(b)

1

[1, 3, 5, 7]

list的其他方法

list.count(obj)

• 统计某个元素在列表中出现的次数

1
2
3

a = list('guangzhou')
a.count('g')

1

2

list.extend(seq)

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

1
2
3

a = list('guangzhou')
a.extend(['sh',12345])
a

1

['g', 'u', 'a', 'n', 'g', 'z', 'h', 'o', 'u', 'sh', 12345]

list.index(obj)

• 从列表中找出某个值第一个匹配项的索引位置

1
2

a = list('guangzhou')
a.index('z')

1

5

list.remove(obj)

• 移除列表中某个值的第一个匹配项

1
2
3

a = list('guangzhou')
a.remove('g')
a

    ['u', 'a', 'n', 'g', 'z', 'h', 'o', 'u']

list.sort()

• 对原列表进行排序

1
2
3
4

a = list('guangzhou')
a.sort()

a

1

['a', 'g', 'g', 'h', 'n', 'o', 'u', 'u', 'z']

list.reverse()

• 对原列表进行反向排序

1
2
3

a = list('guangzhou')
a.reverse()
a

1

['u', 'o', 'h', 'z', 'g', 'n', 'a', 'u', 'g']

列表推导式 (解析式)

一般语法结构：

• new_list = [x for x in iterable]
• 其中的 iterable 表示可迭代的对象，包括字符串（str）、列表（list），元组（tuple）、字典（dict）、集合（set）以及生成器（generator）等。

1

[x for x in range(1, 10, 2)]

1

[1, 3, 5, 7, 9]

1
2

# str.lower()转换成小写，str.upper()转换成大写
[x.upper() for x in "Lemon"]  

1

['L', 'E', 'M', 'O', 'N']

1

[str(x) for x in range(5)]

1

['0', '1', '2', '3', '4']

两层 for 循环的列表推导式

• 列表推导式中，可以同时包含多个 for 循环，比如同时两个 for 循环

1

[x**2+y for x in range(1, 4) for y in [10, 20]]

1

[11, 21, 14, 24, 19, 29]

使用两个变量来生成 list

• 列表推导式也可以使用两个或多个变量来生成 list，结合字典的使用

1
2
3

# 结合字典的使用
g = {'x': '1', 'y': '2', 'z': '4'}
[k+'='+v for k, v in g.items()]

1

['x=1', 'y=2', 'z=4']

含 if 语句的列表推导式

• 列表推导式中还可以引入 if 条件语句，
• 包含 if-else 语句的列表推导式

1
2

# 列表推导式中还可以引入 if 条件语句
[x**2 for x in range(5) if x % 2 == 1]

1

[1, 9]

1
2
3

# 包含 if-else 语句的列表推导式
[x**2 if x % 2 == 0 else x+2 for x in range(5)]

1

[0, 3, 4, 5, 16]

1
2

# 包含两个 if 语句的列表推导式
[x**2 for x in range(1, 9) if x % 2 == 0 if x % 3 == 0]

1

[36]

列表的去重

1. 直接用set方法可以去重，但是原列表中元素的顺序被打乱
2. 利用原来各元素在列表中的索引位可以保持原来的顺序

1
2

a = [1, 5, 3, 7, 5, 3, 1, 9]
list(set(a))

1

[1, 3, 5, 7, 9]

列表推导

1
2
3
4
5
6

# 方法1 
b = []
for x in a:
    if x not in b:
        b.append(x)
b

1

[1, 5, 3, 7, 9]

sorted

• sorted(list(set(list1),key=list1.index）

1
2

# 方法2
sorted(list(set(a)), key=a.index)

1

[1, 5, 3, 7, 9]

{}.fromkeys(seq)

1
2

# 方法3 
list({}.fromkeys(a))

1

[1, 5, 3, 7, 9]

获取列表离散的元素

• 获得第 1、2、4 个元素，能不能通过离散的索引值来获取呢？
  前面已经实践过，直接通过离散的索引值来获取列表中的元素是不行的。
  通过列表推导式的学习，我们可以换一种思路，来实现列表中离散的元素的获取，

1
2

ws=['新疆', '青海', '甘肃', '宁夏', '陕西']
[ws[x] for x in [0, 2, 4]]

1

['新疆', '甘肃', '陕西']

1
2

lst=list("ABCDEFG")
lst[1:4],lst[:4],lst[2:]

1

(['B', 'C', 'D'], ['A', 'B', 'C', 'D'], ['C', 'D', 'E', 'F', 'G'])

1
2

lst=list("ABCDE")
[lst[i] for i in [0,3,4] ]

1

['A', 'D', 'E']

1
2
3
4

lst=list("ABCDEFG")
lst.extend(["gg","dd"])
lst[len(lst):]=['dddd','ppp']
lst

    ['A', 'B', 'C', 'D', 'E', 'F', 'G', 'gg', 'dd', 'dddd', 'ppp']

Numpy

• 功能强大的N维数组对象。
• 精密广播功能函数。
• 集成 C/C+和Fortran 代码的工具。
• 强大的线性代数、傅立叶变换和随机数功能。

• NumPy提供了一个N维数组类型，即ndarray， 它描述了相同类型的“项目”集合。可以使用例如N个整数来索引项目。
• 所有ndarray都是同质的：每个项目占用相同大小的内存块， 并且所有块都以完全相同的方式解释。
• 如何解释数组中的每个项目由单独的数据类型对象指定， 其中一个对象与每个数组相关联。除了基本类型（整数，浮点数 等 ）之外， 数据类型对象还可以表示数据结构。

导入Numpy模块

1
2
3

import numpy as np
# 或
from numpy import *

初识数组(Arrays)

• numpy数组是一个值网格，所有类型都相同，并由非负整数元组索引。
• 维数是数组的排名; 数组的形状是一个整数元组，给出了每个维度的数组大小。

1
2
3
4
5
6

# 用一个一维列表传入
ar1 = np.array([1, 3, 5, 7])
ar1

# 数组转成列表 
ar1.tolist()

1
2

array([1, 3, 5, 7])
[1, 3, 5, 7]

1
2
3

# 查看类型

type(ar1)

1

numpy.ndarray

1
2
3

# 查看维度  返回的格式(n,m),其中n为行数，m为列数

ar1.shape

1

(4,)

1
2
3

# 查看数组的维度数

ar1.ndim

1

1

1

ar1.size

1

4

1
2
3

# 索引

ar1[0],ar1[2]

1

(1, 5)

1
2
3
4

# 修改值

ar1[2]=9
ar1

1

array([1, 3, 9, 7])

创建数组

创建一维数组

1. 用np.array(list) 传入列表
2. 用np.arange() 传入数值范围

1
2
3
4
5

# 直接用列表传入
np.array([x for x in range(1,20,4)])

lst1=['a',"b","c"]
np.array(lst1)

1
2

array([ 1,  5,  9, 13, 17])
array(['a', 'b', 'c'], dtype='<U1')

1
2
3

# 用 arange() 传入一个范围，arange的用法和range一样

np.arange(1, 10, 3)

1

array([1, 4, 7])

创建二维数组

1. 用np.array([list1,list2]) 传入一个二维列表,且长度一致
2. 用np.arange() .reshape(()) 传入数值范围,用reshpe函数重构，reshape函数内是一个元组格式，元素相乘的结果要等于范围内的个数
3. reshape()函数重构时，必须保证各维度数值相乘的结果等于数组中元素的个数

1
2
3
4

# 直接传入一个二维列表

c = np.array([[1, 2, 3], [4, 5, 6]])
type(c), c.shape, c

1
2
3
4

(numpy.ndarray,
 (2, 3),
 array([[1, 2, 3],
        [4, 5, 6]]))

1
2
3
4

# 用arange传入数据范围后用reshape（）重构，指定成？行？列

d = np.arange(1, 7).reshape((2, 3))
d

1
2

array([[1, 2, 3],
       [4, 5, 6]])

创建多维数组

1. 一般用reshape函数比较简单，因为中括号的嵌套比较复杂。
2. shape属性可以查看数组的维度。如：e.shape
3. 多维数组如何看待？
   1. 维度显示是一个元组形式
   2. 末尾的两位可以简单看成是行数和列数
   3. 再往前则可以理解成小区块，大区快
   4. 如果shape的结果是(2,3,4) 表示有2个区块，每个区块中有3行4列的数据
   5. 如果结果是（2，2，2，3） 表示有2个大区块，每个大区块中有2个小区块，每个小区块中有2行3列数据

1
2
3
4
5
6
7
8

# 创建一个3维数组
# 数组维度是用元组的方式表示的。元组内最后两个数分别表示行和列。再往前就是表示块
# 下面的表示就是：2块，3行4列的数组

e = np.arange(24).reshape(2, 3, 4)

e.shape
e

1
2
3
4
5
6
7
8
9

(2, 3, 4)
  
array([[[ 0,  1,  2,  3],
        [ 4,  5,  6,  7],
        [ 8,  9, 10, 11]],
  
       [[12, 13, 14, 15],
        [16, 17, 18, 19],
        [20, 21, 22, 23]]])

1
2
3
4
5
6

# 多维数组
# 从维度元组中可以得知：最小单位是2行3列的数组，有2个大块，每个大块中包含2个小块，每个小块中有1个2行3列的数组。

f = np.arange(24).reshape(2, 2, 2, 3)

f.shape, f

1
2
3
4
5
6
7
8
9
10
11
12

((2, 2, 2, 3),
 array([[[[ 0,  1,  2],
          [ 3,  4,  5]],
   
         [[ 6,  7,  8],
          [ 9, 10, 11]]],
   
        [[[12, 13, 14],
          [15, 16, 17]],
   
         [[18, 19, 20],
          [21, 22, 23]]]]))

数组的转换

• reshape()函数和flatten()函数

1. 有重构函数reshpe()可以改变数组的维度，只要保证元组元素乘积等于数组数据的个数
2. 多维数组就可以转换成1维数组
   1. reshape((num1,)) num1=数据个数
   2. flatten()展开数组变成一维数组

1
2

a = np.arange(12).reshape(3, 4)
a

1
2
3

array([[ 0,  1,  2,  3],
       [ 4,  5,  6,  7],
       [ 8,  9, 10, 11]])

1
2
3
4
5
6
7

# 转换成一维数组

a.reshape(12,)  # 参数内只写一个数，且数字为数组的大小

a.flatten()  # flatten是numpy.ndarray.flatten的一个函数，即返回一个一维数组，默认按行降维.参数"A"省略

a.flatten("F") #  加入参数“F"变为按列降维

1
2
3

array([ 0,  1,  2,  3,  4,  5,  6,  7,  8,  9, 10, 11])
array([ 0,  1,  2,  3,  4,  5,  6,  7,  8,  9, 10, 11])
array([ 0,  4,  8,  1,  5,  9,  2,  6, 10,  3,  7, 11])

1
2
3
4
5

# 变成其他维度（形状）,用reshape()并指定行列数

a.reshape(2,6)

a.reshape(4,-1) # 参数中的”-1“ 代表自动计算。(据已知条件自动计算)

1
2
3
4
5
6
7

array([[ 0,  1,  2,  3,  4,  5],
       [ 6,  7,  8,  9, 10, 11]])

array([[ 0,  1,  2],
       [ 3,  4,  5],
       [ 6,  7,  8],
       [ 9, 10, 11]])

创建等值的矩阵

1. np.zeros代表全是0
2. np.ones代表全是1

1

np.zeros(5, dtype=np.int32)  

1

array([0, 0, 0, 0, 0])

1

np.zeros((2, 5), dtype=np.int32)  

1
2

array([[0, 0, 0, 0, 0],
       [0, 0, 0, 0, 0]])

1

np.ones(5, dtype=np.float16)

1

array([1., 1., 1., 1., 1.], dtype=float16)

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
32
33
34
35
36
37

import pandas as pd
import numpy as np

# 创建一维数组
a = np.array([1, 2, 3, 4])  # 数组a: [1 2 3 4]
b = np.arange(1, 5)         # 数组b: [1 2 3 4]
type(a)                      # a类型是：<class 'numpy.ndarray'>

# 创建二维数组
c = np.array([[1, 2, 3], [4, 5, 6]])
d = np.arange(1, 7).reshape((2, 3))

# 创建三维数组或更高维度的数组
e = np.arange(24).reshape(2, 3, 4)
f = np.arange(24).reshape(2, 2, 2, 3)
f.shape                                 # 返回值为： (2,2,2,3)
print('''
数组e:{}

数组f:{}'''.format(e,  f))

# 数组的维度转换
g = a.reshape(2, 2)   # 转成2行12列的二维数组
h = g.reshape(-1, 2)  # reshape函数中元组中出现“-1”，则表示根据已知条件自动计算出
i = g.reshape(4,)     # 传递给reshape函数的元组中只有1个数表示转化成1维数组，注意有逗号，逗号后为空
j = g.flatten()       # 与上面的结果相同. array([1, 2, 3, 4])

# 创建特殊数组
np.zeros(5, dtype=np.int32)  # array([0, 0, 0, 0, 0])
np.ones(5, dtype=np.float16)  # array([1., 1., 1., 1., 1.], dtype=float16)
np.zeros((2, 5), dtype=np.int32)  # 生成2行5列的二维数组,值都为0,数据类型为int32

# 查看数组属性
f.ndim  # 返回值:4 表示4维数组
f.shape  # 返回值: (2, 2, 2, 3)
f.size  # 返回值: 24
x = c.reshape(c.size,)  # 数组x: array([1, 2, 3, 4, 5, 6])

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
32

numpy.ndarray
(2, 2, 2, 3)
数组e:[[[ 0  1  2  3]
  [ 4  5  6  7]
  [ 8  9 10 11]]
  
 [[12 13 14 15]
  [16 17 18 19]
  [20 21 22 23]]]
  
数组f:[[[[ 0  1  2]
   [ 3  4  5]]
  
  [[ 6  7  8]
   [ 9 10 11]]]
  
 [[[12 13 14]
   [15 16 17]]
  
  [[18 19 20]
   [21 22 23]]]]
array([0, 0, 0, 0, 0])

array([1., 1., 1., 1., 1.], dtype=float16)

array([[0, 0, 0, 0, 0],
       [0, 0, 0, 0, 0]])

4

(2, 2, 2, 3)
24

创建等分数组

1
2
3

# 将1-5分段，有两个端点

np.linspace(1, 5, 2, dtype=np.float32)

1

array([1., 5.], dtype=float32)

1
2

# 将1-5分段，有3个端点
np.linspace(1, 5, 3)

1

array([1., 3., 5.])

1
2

# 将1-5分段，有36个端点
np.linspace(1, 5, 6)

1

array([1. , 1.8, 2.6, 3.4, 4.2, 5. ])

高斯分布（正态分布）

1
2

np.random.randn(2,5)  # 生成对应形状（shape）的高斯分布
np.random.normal(3, 1, 12)  # 生成均值为loc，标准差为scale，形状（shape）为size的高斯分布

1
2
3
4
5
6

array([[-0.62751446,  2.29446202, -0.53109692, -0.07013024,  0.28581247],
       [-1.02490725, -0.18025872, -1.00725205, -0.0991576 , -0.68541257]])
     
array([3.04006092, 2.57668325, 4.54845812, 4.48776295, 3.01108357,
       5.68784587, 2.80187253, 3.85604824, 4.36074347, 3.00090056,
       1.55342793, 4.60112417])

均匀分布

1
2

np.random.rand(2, 3)  # 生成对应形状（shape）的均匀分布
np.random.uniform(11, 19, 6)  # 生成一个从[low, high)中随机采样的，样本数量为size的均匀分布

1
2
3
4
5

array([[0.24771356, 0.63015361, 0.46175306],
       [0.39705638, 0.13455475, 0.01309569]])

array([18.47429041, 17.74433573, 15.09945145, 18.10811743, 13.92652713,
       18.28708122])

数组索引

• Numpy提供了几种索引数组的方法。

切片(Slicing)

• 与Python列表类似，可以对numpy数组进行切片。由于数组可能是多维的，因此必须为数组的每个维指定一个切片：

1
2
3
4
5
6
7
8
9

# 切片
a = np.arange(12).reshape(3, 4)

a[:, 1:3]  # 所有行的0列
a[:, 0: 2]  # 所有行的0，2列
a[1:2, :]  # 1行的所有列

b = a[:2, 1:3]
b

1
2
3
4
5
6
7
8
9
10
11
12

array([[ 1,  2],
       [ 5,  6],
       [ 9, 10]])
     
array([[0, 1],
       [4, 5],
       [8, 9]])
     
array([[4, 5, 6, 7]])

array([[1, 2],
       [5, 6]])

整数与切片混合索引

• 这样做会产生比原始数组更低级别的数组。

1
2
3
4

a = np.arange(12).reshape(2, 2, 3)
a

a[:,0,:]# 全部块的0行全部列

1
2
3
4
5
6
7
8

array([[[ 0,  1,  2],
        [ 3,  4,  5]],
  
       [[ 6,  7,  8],
        [ 9, 10, 11]]])

array([[0, 1, 2],
       [6, 7, 8]])

1
2
3
4
5
6
7
8

# 整数索引与切片索引混合使用

a = np.arange(12).reshape(4, 3)

a
a[1,0:2]
a[1,[0,2]]
a[[1,2],[0,2]]

1
2
3
4
5
6
7
8
9
10

array([[ 0,  1,  2],
       [ 3,  4,  5],
       [ 6,  7,  8],
       [ 9, 10, 11]])

array([3, 4])
  
array([3, 5])

array([3, 8])

整数数组索引

• 使用切片索引到numpy数组时，生成的数组视图将始终是原始数组的子数组。
• 相反，整数数组索引允许你使用另一个数组中的数据构造任意数组

1
2
3
4
5
6
7
8
9
10
11
12
13

# 整数组索引

a = np.arange(12).reshape(4, 3)
a[[0, 1, 2], [0, 1, 0]]

# 整数组索引的技巧
b = np.array([0, 2, 0, 1])
a[np.arange(4), b]

# 将索引的每个位置的数值加上10

a[np.arange(4), b] += 10
a

1
2
3
4
5
6
7
8

array([0, 4, 6])
  
array([ 0,  5,  6, 10])

array([[10,  1,  2],
       [ 3,  4, 15],
       [16,  7,  8],
       [ 9, 20, 11]])

布尔组索引

1
2
3
4
5
6
7

a = np.arange(12).reshape(4, 3)
print(a)

b = a > 5
a[b]

a[a < 4]

1
2
3
4
5
6
7
8

[[ 0  1  2]
 [ 3  4  5]
 [ 6  7  8]
 [ 9 10 11]]

array([ 6,  7,  8,  9, 10, 11])

array([0, 1, 2, 3])

Numpy的数据类型

1. 用dtype属性查看数组的数据类型 如：a.dtype
2. 用astype()函数指定或改变数组的数据类型
3. 数据类型

   字符	对应类型
   b	布尔型
   i	(有符号) 整型
   u	无符号整型 integer
   f	浮点型
   c	复数浮点型
   m	timedelta（时间间隔）
   M	datetime（日期时间）
   O	(Python) 对象
   S, a	(byte-)字符串
   U	Unicode
   V	原始数据 (void)

4. 数值类型

   Numpy 的类型	C 的类型	描述
   np.int8	int8_t	字节（-128到127）
   np.int16	int16_t	整数（-32768至32767）
   np.int32	int32_t	整数（-2147483648至2147483647）
   np.int64	int64_t	整数（-9223372036854775808至9223372036854775807）
   np.uint8	uint8_t	无符号整数（0到255）
   np.uint16	uint16_t	无符号整数（0到65535）
   np.uint32	uint32_t	无符号整数（0到4294967295）
   np.uint64	uint64_t	无符号整数（0到18446744073709551615）
   np.intp	intptr_t	用于索引的整数，通常与索引相同 ssize_t
   np.uintp	uintptr_t	整数大到足以容纳指针
   np.float32	float
   np.float64 / np.float_	double	请注意，这与内置python float的精度相匹配。
   np.complex64	float complex	复数，由两个32位浮点数（实数和虚数组件）表示
   np.complex128 / np.complex_	double complex	请注意，这与内置python 复合体的精度相匹配。

数组运算

1. 数组的广播机制,对数组内的每个数据分别进行运算

2. 维度方向运算

   1. axis=0,对各列
   2. axis=1,对各行

3. 两个维度不同的数组不能算数运算

4. 两个行列数都不同的数组不能运算

5. 两个维度相同,行数或列数有其一相同,不同的为1的数组可以运算

   1. 如a:(3,4) b:(3,4)可以运算
   2. 如a:(3,4) b:(4,3)不可以运算
   3. 如a:(3,4) b:(1,4) 行数为1,列数相同,可以运算
   4. 如a:(3,4) b:(3,1) 行数相同,列数为1,可以运算

运算函数

1
2
3
4

# 对整个进行某种运算,如求和,求最大,最小,平均等等
a = np.arange(1, 13).reshape(3, 4)

a.sum(), a.max(), a.min(), a.mean()

1

(78, 12, 1, 6.5)

1
2
3
4
5
6
7

# 累加

np.cumsum(a)

# 累差

np.diff(a)

1
2
3
4
5

array([ 1,  3,  6, 10, 15, 21, 28, 36, 45, 55, 66, 78])

array([[1, 1, 1],
       [1, 1, 1],
       [1, 1, 1]])

1
2
3

# 中间值

np.median(a)  

1

6.5

1
2
3
4
5

# 对每个数据求sin值
np.sin(a)  

# 对每个数平方
a**2        

1
2
3
4
5
6
7

array([[ 0.84147098,  0.90929743,  0.14112001, -0.7568025 ],
       [-0.95892427, -0.2794155 ,  0.6569866 ,  0.98935825],
       [ 0.41211849, -0.54402111, -0.99999021, -0.53657292]])

array([[  1,   4,   9,  16],
       [ 25,  36,  49,  64],
       [ 81, 100, 121, 144]])

按维度方向计算

• a.sum(axis=1) 计算各列
• a.max(axis=0) 计算各行

1
2
3
4
5

a = np.arange(1, 13).reshape(3, 4)
print(a)

a.sum(axis=1)
a.max(axis=0)

1
2
3
4
5
6
7

[[ 1  2  3  4]
 [ 5  6  7  8]
 [ 9 10 11 12]]
   
array([10, 26, 42])

array([ 9, 10, 11, 12])

数组与数组进行运算

1
2
3
4

# 同维度的数组各自对应位置进行运算
a = np.arange(1, 13).reshape(3, 4)
b = np.arange(100, 112).reshape((3, 4))
a+b

1
2
3

array([[101, 103, 105, 107],
       [109, 111, 113, 115],
       [117, 119, 121, 123]])

1
2
3
4
5

# 与1行同列数的数组运算

a = np.arange(1, 13).reshape(3, 4)
c = np.arange(100, 104).reshape(1, 4)
a+c

1
2
3

array([[101, 103, 105, 107],
       [105, 107, 109, 111],
       [109, 111, 113, 115]])

1
2
3
4
5

# 数组与数组进行运算. 与1列同行数的数组运算
a = np.arange(1, 13).reshape(3, 4)
d = np.arange(100, 103).reshape(3, 1)

a+d

1
2
3

array([[101, 102, 103, 104],
       [106, 107, 108, 109],
       [111, 112, 113, 114]])

数组排序和转置

• 排序
  1. axis=0 按列排序
  2. axis=1 按行排序
• 数组行列转置
• 简便遍历多维数组 arr.flat表示数组的单元

默认按行排序

• axis=1

1
2
3

ar1 = np.array([[8, 12, 6], [13, 9, 27], [1, 5, 3]])

np.sort(ar1)

1
2
3

array([[ 6,  8, 12],
       [ 9, 13, 27],
       [ 1,  3,  5]])

按列排序

1
2
3

ar1 = np.array([[8, 12, 6], [13, 9, 27], [1, 5, 3]])

np.sort(ar1, axis=0)

1
2
3

array([[ 1,  5,  3],
       [ 8,  9,  6],
       [13, 12, 27]])

全部排序

• 行和列都排序

1

np.sort(np.sort(ar1, axis=0), axis=1)

1
2
3

array([[ 1,  3,  5],
       [ 6,  8,  9],
       [12, 13, 27]])

数组的转置

1
2
3
4
5

# 创建一个3行4列的数组
arr5 = np.arange(12).reshape(3, 4)

# 行列转置,变成4行3列
arr5.T

1
2
3
4

array([[ 0,  4,  8],
       [ 1,  5,  9],
       [ 2,  6, 10],
       [ 3,  7, 11]])

数组的遍历

列表解析法

1
2
3
4
5
6
7

# 因为是多维数组，有、1个for循环解析得到的依然是个二维列表
a = np.arange(12).reshape(3, 4)

[i for i in a]

# 2个for循环即可遍历2维数组的全部元素
[j for i in a for j in i]  

1
2
3

[array([0, 1, 2, 3]), array([4, 5, 6, 7]), array([ 8,  9, 10, 11])]

[0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11]

For循环法

1
2
3
4
5
6

list1 = []
for i in a:
    for j in i:
        list1.append(j)

list1

1

[0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11]

1
2
3
4
5
6

# .flat:表示在数组单元中遍历,这样对多维数组简化了for循环
list2 = []
for i in a.flat:
    list2.append(i)

list2

1

[0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11]

1
2
3
4
5
6
7
8

# np.nditer(a) 表示在数组单元中遍历,这样对多维数组简化了for循环
# 这里的i实际是：arrary(0)等，将数组转成列表 i.tolist()
list3 = []

for i in np.nditer(a):
    list3.append(i.tolist())
  
list3

1

[0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11]