python-数据分析与数据可视化（上）

Python语法回顾

1.1 关键字

import keyword

print(keyword.kwlist)

['False', 'None', 'True', 'and', 'as', 'assert', 'async', 'await', 'break', 'class', 'continue', 'def', 'del', 'elif', 'else', 'except', 'finally', 'for', 'from', 'global', 'if', 'import', 'in', 'is', 'lambda', 'nonlocal', 'not', 'or', 'pass', 'raise', 'return', 'try', 'while', 'with', 'yield']

1.2 转义符

python输出函数与输入函数

输出函数：print()

输入函数：input()

python的转义符：

转义符，即\ + 特异功能的首字母

1.\n:换行

2.\t:制表符 4个空格

3.\r:覆盖

4.\b:删除 键盘->backspace

5.\ :两个反斜线表示一个

6.原字符：使转义字符不起作用，卸载前面，用r或R

print("我的\"同学\"名字叫")
print("我的\t同学\n名字叫")
print("我爱\r你")
print("我爱\b你")
print("\\")
print(r"我的\t同学\n名字叫")

我的"同学"名字叫
我的	同学
名字叫
你
我爱你
\
我的\t同学\n名字叫

1.3 布尔值

bool True=1 False=0

布尔值也可以用and,or和not运算

python的空值–None 什么都没有

print(True and True)  
print(True and False)  
print(not True)  

True
False
False

1.4 字符串

(1) 切片

切片[开始:结尾] 取左不取右

name = "小仙女长相甜美并且温柔"
print(name[0:3])
print(name[-3:-1])
print(name[-3:])
print(name[0:6:2])
print(name[::-1])

小仙女
且温
且温柔
小女相
柔温且并美甜相长女仙小

字符串索引 下标->>由0开始 负数

s = '学习Python'
print(s[-2])

o

(2) 字符串拼接 +

a = '我爱你'
b = '中国'
print(a + b)
print(",".join((a, b)))

我爱你中国
我爱你,中国

(3) 格式化:

        format()

s2 = "大家好，我的名字较{}，今年{}岁，性别{}".format("lucky", "18", "女")
s3 = "大家好，我的名字较{}，今年{}岁，性别{}"
print(s2)
print(s3.format("lucky", "18", "女"))
s4 = "大家好，我的名字是{2}，今年{1}岁，性别{0}"
print(s4.format("lucky", "18", "女"))

大家好，我的名字较lucky，今年18岁，性别女
大家好，我的名字较lucky，今年18岁，性别女
大家好，我的名字是女，今年18岁，性别lucky

(4) find,count

第一个参数：目标片段
第二个参数：开始位置
第三个参数：结束位置

s5 = "pythonMuzhoou"
print(s5.find("o", 6, 13))
print(s5.count("o", 6, 13))

10
2

(5) replace,upper,lower

replace:替换指定的字符串片段

第一个参数：要替换片段

第二个参数：替换后片段

第三个参数：替换次数，从前往后，默认全部

upper:转大写

lower:转小写

s6 = "python on muzhou"
res = s6.replace('o', 'TT', 2)
print(res)

print(res.upper())
print(res.lower())

pythTTn TTn muzhou
PYTHTTN TTN MUZHOU
pythttn ttn muzhou

(6) split,strip

split:指定风度对字符串进行峰

参数1：分割点

参数2：分隔的次数（默认遭到所有的分割的进行分隔）

strip:去除字符串首尾的空格

s7 = "111abd112abs113jqh"
# 将字符串，用规定的字符"a"进行分隔，得到一个列表
print(s7.split('a', 1))

s8 = '      python:666   '
print(s8.strip())

s8 = '6py6thon:666'
print(s8.strip('6'))

['111', 'bd112abs113jqh']
python:666
py6thon:

(7) 格式化

传统的格式化输出方法：%

%s:为字符串占位，任意类型都可以

%d:为数值类型占位

%f:为浮点数占位



F表达式（F,f都一样，python3.6以上支持)


len(s)

s9 = '我%s你' % ('爱')
print(s9)
s9 = '我%s你' % (100)
print(s9)
s9 = '我%s你' % ([1, 2])
print(s9)
s10 = '我%d' % (99.99)
print(s10)
s11 = '我%f' % (99.99)
print(s11)

我爱你
我100你
我[1, 2]你
我99
我99.990000

name = 'lucky'
age = 18
s4 = '我的名字叫{},我的年龄是{}'.format(name, age)
s5 = F'我的名字叫{name},我的年龄是{age}'
print(s4)
print(s5)

我的名字叫lucky,我的年龄是18
我的名字叫lucky,我的年龄是18

s = 3.6567
x = 9.6567
print("橘子{1:.2f}".format(s, x))

print('百分比{:.3%}'.format(0.234578))

橘子9.66
百分比23.458%

1.5 列表

list1 = [1, 2, 3, 4, '我爱你', [10, 20, 30]]
print(list1[5][1])
print(len(list1))
list1[2] = 99
print(list1)

20
6
[1, 2, 99, 4, '我爱你', [10, 20, 30]]

(1) 列表的加法和乘法操作

list_1 = [10, 20, 30]
list_2 = [5, 6, 7]
print(list_1 + list_2)
print(list_1 * 3)

[10, 20, 30, 5, 6, 7]
[10, 20, 30, 10, 20, 30, 10, 20, 30]

(2) 列表的切片取值

print('-' * 100)
list_1 = [10, 20, 30, 40, 50, 60, 70]
print(list_1[0:3])  # [10,20,30]
print(list_1[-3:-1])  # [50,60]
print(list_1[1:6:2])  # [20,40,60]
print(list_1[-6:-1:2])
print(list_1[::-1])

----------------------------------------------------------------------------------------------------
[10, 20, 30]
[50, 60]
[20, 40, 60]
[20, 40, 60]
[70, 60, 50, 40, 30, 20, 10]

(3) 列表的操作方法：

    1.del关键字 删除，报错
    2.append方法
        append函数用于向列表末尾添加元素。

aa = [1, 2, 3]
# del aa # 在计算机（内存）当中a变量定义列表 删除
del aa[1]  # 删除掉 列表中的制定值
print(aa)
aa.append(7)
print(aa)

[1, 3]
[1, 3, 7]

(4) 列表的操作方法：

1.insert方法

insert函数用于向列表中插入元素

insert函数的第一个参数是插入的位置，第二个参数是插入的对象

2.clear函数用于将列表清空,不报错

list_2 = [20, 30, 40, 50]
list_2.insert(2, [1, 2, 3])
print(list_2)
list_2.clear()
print(list_2)

[20, 30, [1, 2, 3], 40, 50]
[]

(5) remove,pop

1.remove
用于从列表溢出元素
2.pop
移除最后一个元素

a = ["hello", "world", "python", "hello"]
a.remove("hello")
print(a)

print(a.pop(2))
print(a)

['world', 'python', 'hello']
hello
['world', 'python']

(6) index,reverse

列表
1.index函数
index函数用于返回所匹配的元素的索引
2.reverse函数
reverse函数用于将列表反向排列

a = ["hello", "world", "hello", "python"]
print(a.index('hello'))
print(a.index('hello', 1, 3))

0
2

(7) extend,append

列表：
extend 添加入当前的列表
append
“+” 返回新的列表

a = [10, 20, 30]
a.append([1, 2, 3])
print(a)
a.extend([1, 2, 3])
print(a)
b = [1, 2, 3]
print(a + b)

[10, 20, 30, [1, 2, 3]]
[10, 20, 30, [1, 2, 3], 1, 2, 3]
[10, 20, 30, [1, 2, 3], 1, 2, 3, 1, 2, 3]

(8) copy

列表
copy函数用于创建列表的副本

a = ["hello", "world", "hello", "python"]
b = a.copy()
del a[0]
print('删除a[0]元素之后，输出列表:', b)

删除a[0]元素之后，输出列表: ['hello', 'world', 'hello', 'python']

(9) sort

列表
sort函数
ASCII码的大小规则：0_9Z

print("=" * 100)
a = ["hello", "world", "我", "hw", "python"]
a.sort()
print(a)

print("=" * 100)

====================================================================================================
['hello', 'hw', 'python', 'world', '我']
====================================================================================================

1.6 元祖

1.元组是一种数据容器，使用小括号"()"表示

能使用列表的地方，基本都能使用元素，包括推导式，切片等

元组与列表的区别是元组不可变的
2.元组的元素类型可以不统一

t = ("hello", 66, -10, 3.66, [10, 20, 30])
print(t[1:4])

t1 = ("hello", "world", "python")
t2 = ([1, 2], [3, 4], [5, 6, 7, 8])
t3 = t1 + t2
t3[3][0] = 'lucky'
print(t3)

(66, -10, 3.66)
('hello', 'world', 'python', ['lucky', 2], [3, 4], [5, 6, 7, 8])

元组的注意事项

b = 10, 20, 30
print(b)
d = (20,)
print(d * 10)

print("=" * 100)

(10, 20, 30)
(20, 20, 20, 20, 20, 20, 20, 20, 20, 20)
====================================================================================================

1.7 集合

集合是无序的，集合中的元素是唯一的，集合一般用于元组或者列表中的元素去重，集合默认去重

创建集合

1.变量名=set(元素) 字符串/列表/元组/字典

2.变量名={元素，元素…} 元组/字符串/数字

3.元素是唯一的，用于列表的去重

#  字符串
a = set("1234")
print(a)
#  列表
b = set([10, 20, 30])
print(b)
#  元组
c = set((1, 2, 3, 4))
print(c)
#  字典
d = {
    "年龄": 18,
    "名字": "lucky"
}
f = set(d)
print(f)

{'2', '3', '1', '4'}
{10, 20, 30}
{1, 2, 3, 4}
{'年龄', '名字'}

(1)创建

用大括号创建集合

字典/列表 用大括号是不可行的

aa = {1, 2, 3, (1, 2, 3), "123"}
print(aa)

{1, 2, 3, (1, 2, 3), '123'}

(2) 去重

#  列表的去重
a = set([1, 2, 1, 1, 1, 1, 1])
print(a)
#  元组的去重
bb = set((1, 1, 1, 1))
print(bb)
#  字典去重
cc = {
    "名字": "luch",
    "名字": "lllll"
}
ff = set(cc)
print(ff)
#  字符串去重
zz = set('12111')
print(zz)

abc = {1, 2, 1, 1, (1, 1, 111)}
print(abc)

{1, 2}
{1}
{'名字'}
{'2', '1'}
{1, 2, (1, 1, 111)}

(3) 添加元素

1.add() 往集合添加元素 数字/字符串/元组

2.update 可以将集合合并

集合排序 随机排序

a = {1, 2, 3}
a.add(6)
print(a)
b = {'w', 'b', 'a'}
a.update(b)
print(a)

{1, 2, 3, 6}
{1, 2, 3, 'b', 6, 'w', 'a'}

(4) 删除元素

1.remove

使用remove，如果没有程序报错

2.pop

pop删除是随机删除，如果没有程序报错

3.discard

如果元素不存在不做任何操作

a = {'python', '学', 'lucky', 'lll', 'ehyk'}
a.remove('学')
print(a)

a.pop()
print(a)

a.discard("l")

{'lll', 'python', 'ehyk', 'lucky'}
{'python', 'ehyk', 'lucky'}

(5)并集和交集

1.交集

使用"&“链接多个集合，得到相同的元素

2.并集

使用”|"符号连接多个集合，得到集合中的全部数据

s1 = {1, 2, 3, 5}
s2 = {1, 2, 6, 7}
print(s1 | s2)
print(s1 & s2)

print("=" * 100)

{1, 2, 3, 5, 6, 7}
{1, 2}
====================================================================================================

1.8 字典

字典创建方式：

键可以是任意不可变类型(元组/字符串/数字)

1.1直接使用"{}"

1.2使用dict()

a = {
    "姓名": "lucky",
    1: 18,
    (1,2,3):"123"
}
print(a)
b = dict((["年龄","18"],["名字","lucky"]))
print(b)

c = {}  # 直接写大括号 表达的是字典

# 集合
d = set()  # 表达空集合  用set()
print(d)

{'姓名': 'lucky', 1: 18, (1, 2, 3): '123'}
{'年龄': '18', '名字': 'lucky'}
set()

(1) 增删改查

d = {
    "名字":"lucky",
    "年龄":18
}
d["技能"] = "python"
print(d)
del d["技能"]
print(d["年龄"])
r = d.get("名字")
print(r)
print(d.keys())

{'名字': 'lucky', '年龄': 18, '技能': 'python'}
18
lucky
dict_keys(['名字', '年龄'])

(2) items,values

3.items函数

以列表的形式返回字典中索引键值对

4.values函数

values函数将以列表的形式返回字典中索引值

d = {
    '名字':'lucky',
    '年龄':18
}
r = d.items()
r1 = d.values()
print(r)
print(r1)

dict_items([('名字', 'lucky'), ('年龄', 18)])
dict_values(['lucky', 18])

(3) clear,copy

5.clear

将字典清空

6.copy

用于创建字典的副本

d={
    "名字":"lucky",
    "年龄":18
}
d3 = d.copy()
del d3["名字"]
print(d3)
d.clear()
print(d)
print(len(d))

{'年龄': 18}
{}
0

(4) fromkeys,pop

fromkeys用于创建一个新的字典

第一个参数是一共序列（列表/元祖/集合），用于作为字典的键

第二个参数可以是任何数据类型,作为每个键的值

pop函数用于从字典中一处指定键

d = {}
d1 = d.fromkeys(("名字", "年龄"), 6)
print(d1)

d = {
    "名字": "lucky",
    "年龄": 18
}
p = d.pop('名字')
print(p)
print(d)

{'名字': 6, '年龄': 6}
lucky
{'年龄': 18}

(5) popitem和setdefault

d = {
    "名字": "lucky",
    "年龄": 18
}
r = d.popitem()
print(r)
print(d)

d.setdefault("技能","python")
# 如果重复，不报错
print(d)

('年龄', 18)
{'名字': 'lucky'}
{'名字': 'lucky', '技能': 'python'}

(6) update

d1 = {
    "名字": "lucky"
}
d2 = {
    "名字": "liu"
}
d1.update(d2)
print(d1)

{'名字': 'liu'}

(7) 成员检测与标示号检测

使用"in"和"not in"运输安抚来判断某个对象是否为序列的成员

print("4" in "1234")
print(1 in (1, 2, 3, 4))
print(1 in [1, 2, 3])
print("名字" in {"名字": "lucky"})

print(3 not in (1, 2, 9))

True
True
True
True
True

(8) 判断两个对象是否相同

用is和not is 运算符

数字/字符串/元祖 表面一样 完全一样

列表/字典/集合 表面一样 其实不一样

#  字符串
c="111"
d="111"
print(c is d)
#  元祖
ee = (1,2,3)
kk = (1,2,3)
print(ee is kk)
# 列表
f=[1]
g=[1]
print(f is g)

True
False
False

1.9 python的条件语句

if...elif...else...

1.10 python的数据类型转换

1.1 检测数据类型方法：type() 

1.2 强制类型转换：

str():所有类型转换为字符串

a = '123'
b = 123
c = [1, 2, 3]
d = (1, 2, 3)
e = {1, 2, 3}
f = {"名字": "小明", "年龄": 18}
g = True
h = 3.14
# 字符串
print(type(a))
# int整型
print(type(b))
# list列表
print(type(c))
# tuple元祖
print(type(d))
#  set集合
print(type(e))
#  dict字典
print(type(f))
#  bool
print(type(g))
#  float浮点数
print(type(h))

int() float()

• 数字类型之间可以相互转换
• 只要字符串可以转换为数字类型
• 并且字符串中的元素必须是纯数字，否则无法转换

b = "-123"
res_b = float(b)
print(res_b, type(res_b))
c = [1,2,3]
res_c = str(c)
print(res_c, type(res_c))

-123.0 
[1, 2, 3] 

bool()

1.容器类型转布尔类型
    容器类型数据：字符串，列表，元祖，字典，集合
    
    非容器类型数据：数字类型，布尔类型
    
    容器为空-->False
    
    容器中有元素-->True
    
    
2.数字类型转布尔类型
    int类型，0为False,其余为真
    
    float类型，0.0为False,其他为真

a = ""  # 空字符串
b = []  # 空列表
c = ()  # 空元祖
d = {}  # 空字典
e = set()  # 空集合
print(bool(a), bool(b), bool(c), bool(d), bool(e))

False False False False False

list()列表[],tuple()元祖(),set()集合{}

1.数字类型是非容器类型，不能转换为列表
2.字符串转列表时，会把每一个字符当作列表的元素
3.元祖转列表时，会把每一个字符当作列表的元素
4.字典转列表时，只保留字典中的键
5.集合转列表时，结果是无序的，因为集合本身就是无序的

a=(1,2,'love','a',1.2)
# 元祖
print("元祖")
print(tuple(a))
# 集合
print("集合")
print(set(a))
# 列表
print("列表")
print(list(a))

元祖
(1, 2, 'love', 'a', 1.2)
集合
{1.2, 1, 2, 'a', 'love'}
列表
[1, 2, 'love', 'a', 1.2]

dict() 其他转字典类型

1.数字类型是非颇能勾起类型，不能转换为字典
2.字符串不能转字典类型，因为字符串不能生成二级容器
3.列表转字典，列表必须为登场二级容器，子容器中的元素个数必须为2
4.元祖类型转字典，列表必须为登场二级容器，子容器中的元素个数必须为2
5.集合不能转字典

cc = [[1, 2], ['a', 'b'], ['名字', 'lucky']]
print(dict(cc))
dd = ((1, 2), ('a', 'b'), ('名字', 'lucky'))
print(dict(dd))
#  ee = {{1, 2}, {'a', 'b'}, {'名字', 'lucky'}}
#  集合是不可以转换成字典的

{1: 2, 'a': 'b', '名字': 'lucky'}
{1: 2, 'a': 'b', '名字': 'lucky'}

1.11 isinstance()

用来判断一共对象是否是一个已知的类型。

返回一个布尔值。

isinstance(对象，对象类型)

int(整数) float(浮点数）bool(布尔值）str（字符串）list(列表）turple（元祖）set（集合）dict（字典）

a = 123
print(isinstance(a, int))
a = 123.77
print(isinstance(a, int))
a = 123.77
print(isinstance(a, (int, float, str)))

True
False
True

1.12 for

for循环用来遍历序列，

通过不是有下标的方式来实现对序列中每一个元素的访问

列表/元祖/字符串/字典/集合

遍历数字 range()



python的for循环
1.遍历字典的 键 和 值  d.items()
2.range函数的步长

for i in [1,2,3]:
    print(i,end='')
print()

d = {
    "名字":"lucky",
    "年龄":18
}
print(d.items())

for i in d.items():
    print(i)

for i in range(0,6,2):
    print(i)

123
dict_items([('名字', 'lucky'), ('年龄', 18)])
('名字', 'lucky')
('年龄', 18)
0
2
4

a=[1,2,4,[10,20,30],[50,60,70]]
for i in a:
    if isinstance(i,list):
        for x in i:
            print(x)

10
20
30
50
60
70

1.13 break和continue

break 语句可以跳出for和while的循环体

continue 语句被用来跳过当前循环体块中的剩余语句，然后继续进行下一轮循环

1.14 pass

pass是空语句，是为了保持程序结果的完整性
它用于那些语法上必须要有什么语句，但程序什么也不做的场合

for i in range(0,10):
    pass

1.15 Python函数

1.1 创建函数的关键字：def

1.2 函数的参数

之前使用的是Python的内建函数。这些函数的功能都是预先设计好的，但在实际生产中，使用最多的还是自定义函数。

传入的参数可以是任何的数据类型
注意：函数，先定义函数，再调用

def abc(a,b):
    print(a+b)

abc(100,200)

300

默认参数

def abc(a=300,b=400):
    print(a+b)
# 为第一个默认参数传入值，另一共默认参数继续使用默认
abc(100)

def abc(a,b=[]):
    b.append(a)
    print(b)

abc(100)
abc(200)

500
[100]
[100, 200]

关键字参数

函数调用是，指定函数名称，称为关键字参数（别和默认参数混淆，这里是函数调用

注意：函数调用时，关键字参数必须在普通参数的后面

函数定义时，默认参数后面必须也是默认参数

def abc(x,a=100, b=200):
    print(a+b)
abc(100,a=200,b=600)

800

限定关键字形参

为了限制后面几个参数只能按关键字传递

def abc(a,*,c,d):
    print(a)
    print(c)
    print(d)
#     c,d必须使用关键字
abc(100,c=200,d=600)

100
200
600

可变参数

*参数：最常见的变量名是args，看见该变量名，一眼就知道变量args指向一个tuple(元祖)对象

def abc(a,*b):
    print(a)
    print(b)
    print("*" * 10)
abc(100)
abc(100,100)
abc(100,100,200,300)

def abc(a,*args):
    print(a)
    print(*args)
    print(type(args))
abc(100,100,200,300)

100
()
**********
100
(100,)
**********
100
(100, 200, 300)
**********
100
100 200 300

**参数：最常见的变量名是kwargs,看到该变量名，一眼就知道变量kwargs指向一个dict（字典）对象。

def abc(a,**b):
    print(a)
    print(b) # b 指向的是 空字典 {} 键值对
abc(100)
abc(100,x=100,y=300)

def abc(a,**kwargs):
    print(a)
    print(kwargs)
    print(type(kwargs))
abc(100,x=100)

100
{}
100
{'x': 100, 'y': 300}
100
{'x': 100}

1.16 参数的解包

参数数据类型是：字符串/列表/元祖/集合/字典的时候可以解包
传递实参时，可以在序列的参数前添加星号，这样他会字典将序列中的元素依次作为参数传递

s="123"
l=[1,2,3]
t=(1,2,3)
s1={1,2,3}
d={
    1:"lucky",
    "年龄":18,
    "技能":"python"
}
def abc(a,b,c):
    print(a)
    print(b)
    print(c)

abc(*s)
abc(*l)
abc(*t)
abc(*s1)
abc(*d)

1
2
3
1
2
3
1
2
3
1
2
3
1
年龄
技能

d={
    "名字":"lucky",
    "b":18,
    "c":"python"
}
def abc(名字,b,c):
    print(名字)
    print(b)
    print(c)

abc(**d)

lucky
18
python

参数解包和可变参数配合使用

注意：**参数值搜集未匹配的关键字参数

def abc(a,*args):
    print(a)
    print(args)
abc(100,*[1,2,3])
abc(100,*(1,2,3))


d={
    "名字":"lucky",
    "年龄":18
}
def abc(a,**kwargs):
    print(a)
    print(kwargs)
abc(100,**d)

100
(1, 2, 3)
100
(1, 2, 3)
100
{'名字': 'lucky', '年龄': 18}

注意事项：

1.可变参数，必须定义在普通参数以及默认值参数的后面

2.函数定义时，二者同时存在，移动需要将*args放在**kwargs之前

def abc(a,name='lucky',*args,**kwargs):
    print(a)
    print(name)
    print(args)
    for i in args:
        print(i)
    print(kwargs)
    for key ,value in kwargs.items():
        print(key)
        print(value)

abc(100,'lily',1,2,3,4,x=100,y=200,z=300)

100
lily
(1, 2, 3, 4)
1
2
3
4
{'x': 100, 'y': 200, 'z': 300}
x
100
y
200
z
300

1.17 函数的返回值

python中函数可以使用return 返回数据，也可以不要return返回，默认返回"None"

python的函数返回函数

函数里面嵌套函数；函数返回函数

def abc(a,b,c):
    return a+100,b+100,c+100
r=abc(100,200,300)
x,y,z=r# 元祖的解包
print(x)
print(y)
print(z)

200
300
400

def abc():
    def xyz():
        return [1,2,3]
    return xyz

r=abc()# r结束是一共函数，xyz这个函数
print(r)
r2=r()
print(r2)

.xyz at 0x0000019076BAF620>
[1, 2, 3]

数据分析基本语法

numpy简介

numpy

NumPy是Python语言的一共扩展程序库，支持大量的维度数组与矩阵运算，
此外也正对数组运算提供大量的数学函数库。

作用

NumPy是一共运行速度非常快的数学库，主要用于数组计算。

包含

• 一个强大的N维对象 ndarray
• 广播功能函数
• 整合C/C++/Fortran代码的工具
• 线性代数，傅立叶变换，随机数生成等功能
  优势
• 对于同样的数值计算任务，使用numpy要比直接编写Python代码便捷的多
• numpy中的数值的存储效率和输入输出性能均远远由于Python中等价的基本数据结构，且其能提升性能是与数组中的元素成比例的。
  应用
  Numpy通常与SciPy和Matplotlib一起使用，这种组合广泛用于替代MatLab

SciPy

是一个开源的Python算术库和数学工具包

包含的模块有最优化，线性代数，积分，插值，特殊函数，快速傅里叶变幻，信号处理和图像处理，常微分方程求解和其他科学与工程中常用的计算

Matplotlib

是Python编程语言及其数值数字扩展包NumPy的可视化操作界面。它为利用通用的图像用户界面工作包，如Tkinter,wxPython,Qt或GTK+向应用程序嵌入式绘图提供了应用程序接口（API）

2.Ndarry对象简介

• NumPy最重要的一个特点是其N为数组对象ndarray,它是一系列同类型数据的集合，以0下标为开始进行集合中元素的索引
• ndarray对象是用于存放同类型元素的多维数组
• ndarray中的每个元素在内存中都有相同存储大小的区域

组成

• 一个指向数据（内存或内存映射文件中的一块数据）的指针
• 数据类型或dtype,描述在数组中固定大小值的格子
• 一个表示数组形状(shape)的元祖，表示多维度大小的元祖
• 一个跨度元祖(stride)，其中的整数指的是为了前进到当前维度下一个元素需要“跨过”的字节数

numpy

一，数组的基本使用

1.numpy数据类型

numpy支持的数据类型比Python内置的类型要多很多，基本上可以和C语言的数据类型对应上，其中部分类型对应为Python内置的类型。

numpy的数值类型实际上是是dtype对象的实例，并对应唯一的字符，包括np.bool_,np.int32,np.float32等

（1）dtype

数据类型对象(dtype)

数据类型是用来描述与数组对应的内置的内存区域如何使用，这依赖如下几个方面：

• 数组的类型（整数，浮雕书或者Python对象）
• 数据的大小（例如，整数使用多少个字节存储）
• 数据的字节顺序（小端法或大端法）「通过对数据类型预先设定“<”或">"来决定的。」
• 在结构化类型的情况下，字段的名称，每个字段的数据类型和每个字段所取的内存块的部分。
• 如果数据类型是子数组，它的形状和数据类型
  创建数据类型对象

原型：numpy.dtype(object, align, copy)

参数	说明
object	要转换为的数据类型对象
align	如果为true,填充字段使其类似C的结构体
copy	复制dtype对象，如果为false,则是对内置数据类型对象的引用

import numpy as np
dt=np.dtype(np.int32)
print(dt)
print(type(dt))

int32

import numpy as np
dt=np.dtype('i4')
print(dt)
print(type(dt))

int32

import numpy as np
dt=np.dtype(')
print(dt)
print(type(dt))

int32

import numpy as np
student=np.dtype([("name","a20"),("age","i4"),("marks","f4")])
print(student)
print(type(student))

[('name', 'S20'), ('age', '

（2）array

# 一维数组
import numpy as np

arr = np.array([1,2,3,4,5])
print(arr)
print(type(arr))

[1 2 3 4 5]

# 元素类型要相同
import numpy as np
arr=np.array([1,2,3,4.5,5,6,7,8])
arr

array([1. , 2. , 3. , 4.5, 5. , 6. , 7. , 8. ])

# 多维数组
arr = np.array([[1,2,3],[4,5,6]])
arr

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

arr = np.array([1,2,3,4,5,6,7,8,9,0],ndmin=2)
arr

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

# dtype参数
arr = np.array([1,2,3,4,5],dtype=np.float)
arr

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

# dtype参数
arr = np.array([1,2,3,4,5],dtype='f')
arr

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

# 结构化数据类型
student=np.dtype([('name','a20'),('age','i4'),('marks','f4')])
arr=np.array([('sunck',18,99.999),('kaige',19,98.99)],dtype=student)
arr

array([(b'sunck', 18, 99.999), (b'kaige', 19, 98.99 )],
      dtype=[('name', 'S20'), ('age', '

（3）asarray

arr=np.asarray([1,2,3,4,5])
arr

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

arr=np.asarray((1,2,3,4,5))
arr

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

arr=np.asarray([[1,2,3],[4,5]])
arr

array([list([1, 2, 3]), list([4, 5])], dtype=object)

arr=np.asarray([(1,2,3),(4,5)])
arr

array([(1, 2, 3), (4, 5)], dtype=object)

arr=np.asarray([1,2,3,4,5],dtype='f')
arr

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

（4）empty

arr=np.empty([3,2],dtype=int)
print(arr)

[[740   0]
 [740   0]
 [  0   0]]

（5）zeros

arr=np.zeros(5,dtype=int)
arr

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

arr=np.zeros([3,2],dtype=int)
arr

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

arr=np.zeros([2,2],dtype=[('x','i4'),('y','f')])
arr

array([[(0, 0.), (0, 0.)],
       [(0, 0.), (0, 0.)]], dtype=[('x', '

（6）ones

arr=np.ones([3,2],dtype='i4')
arr

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

（7）full

arr = np.full([3,2],fill_value=1024,dtype='i4')
arr

array([[1024, 1024],
       [1024, 1024],
       [1024, 1024]])

（8）eye

arr=np.eye(10,dtype='i4')
arr

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

（9）arange

arr=np.arange(1,11,1)
arr

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

（10）frombuffer

# 加b是因为python3默认str是Unicode类型，转成bytestring
s=b'sunk is a good man'
arr=np.frombuffer(s,dtype='S1')
arr

array([b's', b'u', b'n', b'k', b' ', b'i', b's', b' ', b'a', b' ', b'g',
       b'o', b'o', b'd', b' ', b'm', b'a', b'n'], dtype='|S1')

s=b'sunk is a good man'
arr=np.frombuffer(s,dtype='S1',count=5,offset=2)
arr

array([b'n', b'k', b' ', b'i', b's'], dtype='|S1')

（11）fromiter

x=[1,2,3,4,5]
z=iter(x)
print(z)
print(type(z))
arr=np.fromiter(z,dtype='f')
arr

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

（12）linespace

# 等差数列
arr=np.linspace(1,10,10,dtype='i4')
arr

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

（13）logspace

# 等比数列
arr=np.logspace(1,10,10,dtype='f',base=2)
arr

array([   2.,    4.,    8.,   16.,   32.,   64.,  128.,  256.,  512.,
       1024.], dtype=float32)

（14）random.rand()

arr=np.random.rand()
print(arr,type(arr))

0.5240079097273224 

arr=np.random.rand(3)
arr

array([0.74424632, 0.0461115 , 0.97206901])

arr=np.random.rand(3,2)
arr

array([[0.47903539, 0.86998436],
       [0.4848891 , 0.93572588],
       [0.80295038, 0.43218968]])

arr=np.random.rand(3,2,2)
arr

array([[[0.9998886 , 0.52552298],
        [0.72106014, 0.96203488]],

       [[0.75085369, 0.85251696],
        [0.79907398, 0.56997836]],

       [[0.18186443, 0.9797123 ],
        [0.92801473, 0.4115582 ]]])

（15）random.random()

arr=np.random.random()
arr

0.8665808836177759

arr=np.random.random(3)
# 只能传一个参数
arr

array([0.26886665, 0.62606371, 0.46375206])

（16）random.randint()

arr=np.random.randint(0,2,5)
# 不包含上限
arr

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

（17）random.randn()

# 标准正太分布
arr=np.random.randn(5)
arr

array([ 0.04725359,  0.08053696,  0.40550154, -0.03437786,  1.59262774])

arr=np.random.randn(2,4)
arr

array([[-1.66432309,  0.61895489,  1.07879291, -0.18574263],
       [ 1.50803635,  1.27650794,  0.31630973, -0.28127994]])

arr=np.random.randn(4,3,2)
arr

array([[[ 0.09520901,  1.05710472],
        [-0.67894414, -0.92668902],
        [-0.99919225, -2.26500541]],

       [[ 0.78823024, -0.19165543],
        [ 0.56963642,  1.13648296],
        [-0.39464062, -1.01984739]],

       [[ 0.58437937,  0.27091969],
        [-0.98023475, -0.53879467],
        [-0.23887656,  0.76977131]],

       [[ 0.09462572,  1.17498424],
        [ 1.14252958,  1.56363165],
        [ 0.67231065,  0.2925184 ]]])

（18）random.normal

# 生成高斯分布的概率密度随机数
# 均值 标准差 输出的shape,默认1
arr=np.random.normal(loc=1,scale=2,size=5)
arr

array([ 1.35304045, -0.97383003,  4.44448123,  0.33490791, -0.25775527])

2.numpy数组与Python中列表的对比

import random

li=[]
for i in range(10000000):
    li.append(random.random())

import time
t1=time.time()
ret=sum(li)
t2=time.time()
print("耗时：%f"%(t2-t1))
print(ret)

耗时：0.144993
4998742.3535691025

import numpy as np
n=np.array(li)

t1=time.time()
ret=np.sum(n)
t2=time.time()
print("耗时：%f"%(t2-t1))
print(ret)

耗时：0.049558
4998742.353568689

3.Ndarray数组属性

（1）ndim

import numpy as np

arr=np.arange(24)
print(arr)
print(arr.ndim)

print('-'*50)

# arr.reshape 调整数组维度
arr2=arr.reshape(2,3,4)
print(arr2)
print(arr2.ndim)

[ 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
--------------------------------------------------
[[[ 0  1  2  3]
  [ 4  5  6  7]
  [ 8  9 10 11]]

 [[12 13 14 15]
  [16 17 18 19]
  [20 21 22 23]]]
3

（2）shape

# 表示数组的维度，返回一个元祖，这个元祖的长度就是维度的数目
arr=np.array([[1,2,3],[4,5,6]])
print(arr)
print(arr.shape)

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

arr=np.array([[1,2,3],[4,5,6]])
# 更改维度
arr.shape=(3,2)
print(arr)
print(arr.shape)

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

arr=np.array([[1,2,3],[4,5,6]])
arr=arr.reshape(3,2)
# 更改维度
print(arr)
print(arr.shape)

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

（3）size

arr=np.array([[1,2,3],[4,5,6]])
print(arr)
print(arr.size)
print(arr.dtype)

[[1 2 3]
 [4 5 6]]
6
int32

（4）itemsize

arr1=np.array([1,2,3,4,5],dtype='i1')
print(arr1)
# 每个元素所站字节
print(arr1.itemsize)

arr2=np.array([1,2,3,4,5],dtype='f')
print(arr2)
print(arr2.itemsize)

[1 2 3 4 5]
1
[1. 2. 3. 4. 5.]
4

（5）flags

# 返回内存信息
arr=np.array([1,2,3,4,5])
print(arr.flags)

  C_CONTIGUOUS : True
  F_CONTIGUOUS : True
  OWNDATA : True
  WRITEABLE : True
  ALIGNED : True
  WRITEBACKIFCOPY : False
  UPDATEIFCOPY : False

二，元素操作

1.切片

ndarray对象的内容可以通过所以或切片来访问和修改，与Python中list的切片操作一样

import numpy as np

arr=np.arange(10)
print(arr)

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

arr[1]

1

s=slice(2,7,2)
arr[s]

array([2, 4, 6])

arr2=arr[2:7:2]
arr2

array([2, 4, 6])

arr=np.arange(15)
arr.shape=(5,3)
print(arr)
arr2=arr[2][1]
print(arr2,type(arr2))

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

arr=np.arange(15)
arr.shape=(5,3)
print(arr)
print("\n")
arr2=arr[2:]
print(arr2,type(arr2))
print(arr2.shape)

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


[[ 6  7  8]
 [ 9 10 11]
 [12 13 14]] 
(3, 3)

arr=np.arange(15)
arr.shape=(5,3)
print(arr)
print("\n")
# 所有行，第一列
print(arr[...,1])
print("\n")
print(arr[1:3,...])

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


[ 1  4  7 10 13]


[[3 4 5]
 [6 7 8]]

2.高级索引

import numpy as np

arr = np.array([[1,2,3],[4,5,6],[7,8,9]])
# 0,0 1,1 2,3
print(arr)
print("\n")
print(arr[[0,1,2],[0,1,1]])

[[1 2 3]
 [4 5 6]
 [7 8 9]]


[1 5 8]

arr = np.array([[1,2,3],[4,5,6],[7,8,9],[10,11,12]])
print(arr)
rows=np.array([[0,0],[3,3]])
cols=np.array([[0,2],[0,2]])
print("\n")
print(arr[rows,cols])

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


[[ 1  3]
 [10 12]]

arr=np.array([[1,2,3],[4,5,6],[7,8,9],[10,11,12]])
print(arr)
print('\n')
print(arr[1:3,1:3])
print('\n')
print(arr[1:3,[1,0]])
print('\n')
print(arr[...,1:])

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


[[5 6]
 [8 9]]


[[5 4]
 [8 7]]


[[ 2  3]
 [ 5  6]
 [ 8  9]
 [11 12]]

arr=np.array([[1,2,3],[4,5,6],[7,8,9],[10,11,12]])
print(arr[arr>5])

[ 6  7  8  9 10 11 12]

arr=np.array([np.nan,1,2,np.nan,4,5,6])
print(arr)
print(arr[~np.isnan(arr)])

[nan  1.  2. nan  4.  5.  6.]
[1. 2. 4. 5. 6.]

3.广播

import numpy as np
a=np.array([
    [0,0,0],
    [10,10,10],
    [20,20,20],
    [30,30,30]
])
b=np.array([1,2,3])
bb=np.tile(b,(4,1))
print(bb)
print('-----')
print(a+b)

print('\n')
print(a+bb)

[[1 2 3]
 [1 2 3]
 [1 2 3]
 [1 2 3]]
-----
[[ 1  2  3]
 [11 12 13]
 [21 22 23]
 [31 32 33]]


[[ 1  2  3]
 [11 12 13]
 [21 22 23]
 [31 32 33]]

4.迭代

order

import numpy as np

a= np.arange(12)
a=a.reshape(3,4)
print(a)
print('\n')
for x in np.nditer(a):
    print(x,end=',')
print('\n')

print(a.T)
print('\n')
for x in np.nditer(a.T):
    print(x,end=',')
print('\n')

b=a.T.copy(order='C')
print(b)
print('\n')
for x in np.nditer(b):
    print(x,end=',')
print('\n')

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


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

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


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

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


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

import numpy as np

a= np.arange(12)
a=a.reshape(3,4)
print(a)
print('\n')
for x in np.nditer(a):
    print(x,end=',')
print('\n')

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


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

b=a.T.copy(order='C')
print(b)
for x in np.nditer(b):
    print(x,end=',')

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

b=a.T.copy(order='F')
print(b)
for x in np.nditer(b):
    print(x,end=',')

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

op_flags

import numpy as np

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

# np_flags 默认只读
for x in np.nditer(a,order='F'):
    print(x,end=',')
print('\n')

for x in np.nditer(a,order='F',op_flags=['readwrite']):
    x[...]=x*2
print(a)
print('\n')

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


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

[[ 0  2  4  6]
 [ 8 10 12 14]
 [16 18 20 22]]

flags

import numpy as np

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

# external_loop 一维数组
for x in np.nditer(a,flags=['external_loop'],order='F'):
    print(x,end=',')
print('\n')

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


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

广播迭代

a=np.arange(12).reshape(3,4)
b=np.arange(1,5)
for x,y in np.nditer([a,b]):
    print("%d:%d"%(x,y),end=',')
print("")

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

三，数组操作

1.修改数组形状

reshape()

import numpy as np

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

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

flatten

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

b=a.flatten()
print(b)
print('\n')

c=a.flatten(order='F')
print(c)
print('\n')

b[0]=100
print(b)

print(a)

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


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


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


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

ravel() 会修改原数组

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

b=a.ravel()
print(b)
print('\n')

# 注意：F风格下不改
c=a.ravel(order='F')
c[1]=100
print(c)
print('\n')

b[0]=100
print(b)

print(a)

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


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


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


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

2.翻转数组

transpose()

import numpy as np

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

b=np.transpose(a)
print(b)

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


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

ndarray.T

import numpy as np

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

b=a.T
print(b)

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


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

rollaxis()

import numpy as np

a = np.arange(12).reshape(3,4)
print(a)
print(a.shape)
print('\n')

b=np.rollaxis(a,1)
print(b)
print(b.shape)

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


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

import numpy as np

a = np.arange(24).reshape(2,3,4)
print(a)
print(a.shape)
print('\n')

b=np.rollaxis(a,2)
print(b)
print(b.shape)

b=np.rollaxis(a,2,start=1)
print(b)
print(b.shape)

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

 [[12 13 14 15]
  [16 17 18 19]
  [20 21 22 23]]]
(2, 3, 4)


[[[ 0  4  8]
  [12 16 20]]

 [[ 1  5  9]
  [13 17 21]]

 [[ 2  6 10]
  [14 18 22]]

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

 [[12 16 20]
  [13 17 21]
  [14 18 22]
  [15 19 23]]]
(2, 4, 3)

swapaxes()

import numpy as np

a = np.arange(24).reshape(2,3,4)
print(a)
print(a.shape)
print('\n')

b =np.swapaxes(a,2,0)
print(b)
print(b.shape)

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

 [[12 13 14 15]
  [16 17 18 19]
  [20 21 22 23]]]
(2, 3, 4)


[[[ 0 12]
  [ 4 16]
  [ 8 20]]

 [[ 1 13]
  [ 5 17]
  [ 9 21]]

 [[ 2 14]
  [ 6 18]
  [10 22]]

 [[ 3 15]
  [ 7 19]
  [11 23]]]
(4, 3, 2)

3.修改数组维度

broadcast()

返回一个对象

import numpy as np

x=np.array([[1],[2],[4]])
y=np.array([4,5,6])
print(x)
print(y)

[[1]
 [2]
 [4]]
[4 5 6]

b=np.broadcast(x,y)
print(b)

r,c=b.iters
print(r)
print(c)

print(next(r),next(c))

1 4

print(next(r),next(c))

1 5

print(next(r),next(c))

1 6

print(next(r),next(c))

2 4

print(next(r),next(c))

2 5

print(next(r),next(c))

2 6

print(next(r),next(c))

4 4

print(next(r),next(c))

4 5

print(next(r),next(c))

4 6

b = np.broadcast(x,y)
print(b.shape)

(3, 3)

c = np.empty(b.shape)
print(c)

[[0.00000000e+000 0.00000000e+000 0.00000000e+000]
 [0.00000000e+000 0.00000000e+000 6.12641401e-321]
 [1.24610926e-306 1.23875425e-259 4.61915757e+281]]

print(x+y)

[[ 5  6  7]
 [ 6  7  8]
 [ 8  9 10]]

broadcast_to()

a=np.arange(1,5).reshape((1,4))
b=np.broadcast_to(a,(4,4))
b

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

expand_dims()

x=np.arange(1,5).reshape((2,2))
print(x)
print(x.shape,x.ndim)

[[1 2]
 [3 4]]
(2, 2) 2

y=np.expand_dims(x,axis=0)
print(y)
print(y.shape,y.ndim)

[[[1 2]
  [3 4]]]
(1, 2, 2) 3

squeeze()

会删除size=1的轴

x=np.arange(1,10).reshape((1,3,3))
print(x)
print(x.shape,x.ndim)

[[[1 2 3]
  [4 5 6]
  [7 8 9]]]
(1, 3, 3) 3

y=np.squeeze(x)
print(y)
print(y.shape,y.ndim)

[[1 2 3]
 [4 5 6]
 [7 8 9]]
(3, 3) 2

4.连接数组

concatennate()

import numpy as np

x=np.arange(4).reshape((2,2))
print(x)
print('\n')

y=np.arange(4,8).reshape((2,2))
print(y)
print('\n')

a=np.concatenate((x,y))
print(a)
print(a.shape,a.ndim)
print('\n')
b=np.concatenate((x,y),1)
print(b)
print(b.shape,b.ndim)

[[0 1]
 [2 3]]


[[4 5]
 [6 7]]


[[0 1]
 [2 3]
 [4 5]
 [6 7]]
(4, 2) 2


[[0 1 4 5]
 [2 3 6 7]]
(2, 4) 2

stack

import numpy as np

x=np.arange(4).reshape((2,2))
print(x)
print('\n')

y=np.arange(4,8).reshape((2,2))
print(y)
print('\n')

a=np.stack((x,y))
print(a)
print(a.shape,a.ndim)
print('\n')
b=np.stack((x,y),1)
print(b)
print(b.shape,b.ndim)

[[0 1]
 [2 3]]


[[4 5]
 [6 7]]


[[[0 1]
  [2 3]]

 [[4 5]
  [6 7]]]
(2, 2, 2) 3


[[[0 1]
  [4 5]]

 [[2 3]
  [6 7]]]
(2, 2, 2) 3

hstack

import numpy as np

x=np.arange(4).reshape((2,2))
print(x)
print('\n')

y=np.arange(4,8).reshape((2,2))
print(y)
print('\n')

a=np.hstack((x,y))
print(a)
print(a.shape,a.ndim)
print('\n')

[[0 1]
 [2 3]]


[[4 5]
 [6 7]]


[[0 1 4 5]
 [2 3 6 7]]
(2, 4) 2

vstack

import numpy as np

x=np.arange(4).reshape((2,2))
print(x)
print('\n')

y=np.arange(4,8).reshape((2,2))
print(y)
print('\n')

a=np.vstack((x,y))
print(a)
print(a.shape,a.ndim)
print('\n')

[[0 1]
 [2 3]]


[[4 5]
 [6 7]]


[[0 1]
 [2 3]
 [4 5]
 [6 7]]
(4, 2) 2

5.分割数组

split

import numpy as np

x=np.arange(12)
print(x)

a=np.split(x,3) #分成3份，不能平均就报错
print(a)

b=np.split(x,[2,7]) #2，7下标左侧切一刀
print(b)

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

x=np.arange(12).reshape(3,4)
print(x)
print('\n')
a=np.split(x,3)
print(a)

a=np.split(x,2,axis=1)#按列来切
print(a)

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


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

hsplit() 水平分割数组

x=np.arange(12).reshape(2,6)
print(x)
print('\n')
a=np.hsplit(x,3)
print(a)

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


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

vsplit() 垂直分割数组

x=np.arange(12).reshape(2,6)
print(x)
print('\n')
a=np.vsplit(x,2)
print(a)

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


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

6.数组元素的添加与删除

resize

返回指定大小的新数组

import numpy as np
x=np.arange(6).reshape(2,3)
print(x)
print('\n')

y=np.resize(x,(3,2))
print(y)
print('\n')

z=np.resize(x,(3,3))
print(z)
print(z.shape)

[[0 1 2]
 [3 4 5]]


[[0 1]
 [2 3]
 [4 5]]


[[0 1 2]
 [3 4 5]
 [0 1 2]]
(3, 3)

append()

在数组的末尾添加值最佳操作会分配整个数组，并把原来的数组赋值到新1数组中
输入数组的维度必须匹配否则将生成ValueError

x=np.arange(6).reshape(2,3)
print(x)
print('\n')

y=np.append(x,[7,8,9])
print(y)#一维数组
print(y.shape)
print('\n')

y=np.append(x,[[7,8,9]],axis=0)#行同
print(y)
print(y.shape)
print('\n')

y=np.append(x,[[7,8],[8,9]],axis=1)#列同
print(y)
print(y.shape)
print('\n')

[[0 1 2]
 [3 4 5]]


[0 1 2 3 4 5 7 8 9]
(9,)


[[0 1 2]
 [3 4 5]
 [7 8 9]]
(3, 3)


[[0 1 2 7 8]
 [3 4 5 8 9]]
(2, 5)

insert

x=np.arange(6).reshape(3,2)
print(x)
print('\n')

a=np.insert(x,3,[11,12])
print(a)
print('\n')

a=np.insert(x,3,[11],axis=0)
print(a)
print('\n')

a=np.insert(x,1,[[11],[12]],axis=1)
print(a)
print('\n')

[[0 1]
 [2 3]
 [4 5]]


[ 0  1  2 11 12  3  4  5]


[[ 0  1]
 [ 2  3]
 [ 4  5]
 [11 11]]


[[ 0 11 12  1]
 [ 2 11 12  3]
 [ 4 11 12  5]]

delete()

x=np.arange(2,14).reshape(3,4)
print(x)
print('\n')

a=np.delete(x,4)
print(a)
print('\n')

a=np.delete(x,1,axis=0)
print(a)
print('\n')

a=np.delete(x,1,axis=1)
print(a)
print('\n')

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


[ 2  3  4  5  7  8  9 10 11 12 13]


[[ 2  3  4  5]
 [10 11 12 13]]


[[ 2  4  5]
 [ 6  8  9]
 [10 12 13]]

unique()

去重

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

a=np.unique(x)
print(a)
print(a.size)
print('\n')

a=np.unique(x,return_index=True)# 同时返回原下标
print(a)
print('\n')

a=np.unique(x,return_inverse=True)# 旧列表元素在新列表中的位置
print(a)
print('\n')

a=np.unique(x,return_counts=True)
print(a)
print('\n')

a=np.unique(x,return_counts=True,return_inverse=True)
print(a)
print('\n')

x数组：
[1 2 3 4 9 5 9 6 7 8 8 9 9 9]
14


[1 2 3 4 5 6 7 8 9]
9


(array([1, 2, 3, 4, 5, 6, 7, 8, 9]), array([0, 1, 2, 3, 5, 7, 8, 9, 4], dtype=int64))


(array([1, 2, 3, 4, 5, 6, 7, 8, 9]), array([0, 1, 2, 3, 8, 4, 8, 5, 6, 7, 7, 8, 8, 8], dtype=int64))


(array([1, 2, 3, 4, 5, 6, 7, 8, 9]), array([1, 1, 1, 1, 1, 1, 1, 2, 5], dtype=int64))


(array([1, 2, 3, 4, 5, 6, 7, 8, 9]), array([0, 1, 2, 3, 8, 4, 8, 5, 6, 7, 7, 8, 8, 8], dtype=int64), array([1, 1, 1, 1, 1, 1, 1, 2, 5], dtype=int64))

五，函数

1.字符串函数

add()

对两个数组的元素进行字符串连接

import numpy as np

print(np.char.add(['sunk'],['good']))
print(np.char.add(['sunk','kaige'],['good','nice']))

['sunkgood']
['sunkgood' 'kaigenice']

multiply()

返回按元素多重连接后的字符串

print(np.char.multiply('good',3))

goodgoodgood

center()

将字符串居中，并使用指定字符在左侧和右侧进行填充

print(np.char.center(['nice','handsome'],20,fillchar='*'))

['********nice********' '******handsome******']

capitalize()

将字符串第一个字母转换为大写

print(np.char.capitalize(['nice TT meet you','handsome']))

['Nice tt meet you' 'Handsome']

title()

将字符串的每个单词第一个字母转换为大写

print(np.char.title(['nice TT meet you','handsome']))

['Nice Tt Meet You' 'Handsome']

lower()

数组元素转换为小写

print(np.char.lower(['nice TT meet you','handsome']))

['nice tt meet you' 'handsome']

upper()

数组元素转换为大写

print(np.char.upper(['nice TT meet you','handsome']))

['NICE TT MEET YOU' 'HANDSOME']

split()

指定分隔符对字符串进行分割，并返回数组列表

print(np.char.split(['nice TT meet you','handsome']))

[list(['nice', 'TT', 'meet', 'you']) list(['handsome'])]

splitlines()

返回元素中的行列表，以换行符分隔

print(np.char.splitlines(['nice T\nT meet you','handsome']))

[list(['nice T', 'T meet you']) list(['handsome'])]

strip()

移除元素开头或者结尾处的特定字符

print(np.char.strip(['****nice TT meet you***','*h*andsome'],'*'))

['nice TT meet you' 'h*andsome']

replace()

实验新字符替换字符串中的所有子字符串

print(np.char.replace(['nice TT meet you','nicek handsome'],'nice','hang'))

['hang TT meet you' 'hangk handsome']

join()

使用新字符串替换字符串中所有子字符串

print(np.char.join('-',['nice TT meet you','handsome']))
print(np.char.join(('-','i'),['nice TT meet you','handsome']))

['n-i-c-e- -T-T- -m-e-e-t- -y-o-u' 'h-a-n-d-s-o-m-e']
['n-i-c-e- -T-T- -m-e-e-t- -y-o-u' 'hiainidisioimie']

encode()

编码，数组元素依次调用str.encode

print(np.char.encode(['sunk','nice'],'utf-8'))

[b'sunk' b'nice']

decode()

解码，数组元素依次调用str.decode

a=np.char.encode(['sunk','nice'],'utf-8')
print(np.char.decode(a,'utf-8'))# 什么编码就用什么解码

['sunk' 'nice']

2.数学函数

标准三角函数sin(),cos(),tan()

反三角函数arcsin,arccos(),arctan()

around()

指定数字的四舍五入值

x=np.array([1.0,3.456,1234,0,12345,12187.7656])
print(np.around(x))
print(np.around(x,decimals=1))
print(np.around(x,decimals=-1))

[1.0000e+00 3.0000e+00 1.2340e+03 0.0000e+00 1.2345e+04 1.2188e+04]
[1.00000e+00 3.50000e+00 1.23400e+03 0.00000e+00 1.23450e+04 1.21878e+04]
[    0.     0.  1230.     0. 12340. 12190.]

floor()

向下取整

x=np.array([-1.7,1.5,-0.2,0.6,10])
print(np.floor(x))

[-2.  1. -1.  0. 10.]

ceil()

向上取整

x=np.ceil([-1.7,1.5,-0.2,0.6,10])
print(np.floor(x))

[-1.  2. -0.  1. 10.]

3.算术函数

add(),subtract(),multiply(),divide()

作用：加减乘除

import numpy as np

x = np.arange(9, dtype='f').reshape(3, 3)
print('x数组：')
print(x)
print('\n')

y = np.array([10,10,10])
print('y数组：')
print(y)
print('\n')

print(np.subtract(x,y))
print('-'*50)
print(x-y)

x数组：
[[0. 1. 2.]
 [3. 4. 5.]
 [6. 7. 8.]]


y数组：
[10 10 10]


[[-10.  -9.  -8.]
 [ -7.  -6.  -5.]
 [ -4.  -3.  -2.]]
--------------------------------------------------
[[-10.  -9.  -8.]
 [ -7.  -6.  -5.]
 [ -4.  -3.  -2.]]

reciprocal()

作用：返回参数做个元素的倒数

x = np.array([0.25,0.5,1,100])
print(np.reciprocal(x))

[4.   2.   1.   0.01]

power()

作用：将第一个输入数组中的元素作为底数，技术安它与第二个输入数组中相应元素的幂

x = np.array([2,3,4])
y = np.array([1,2,3])
print(np.power(x,y))

[ 2  9 64]

mod(),remainder()

作用：计算输入数组中相应元素的相除后的余数

x = np.array([10,10,10])
y = np.array([2,3,4])
print(np.mod(x,y))
print(np.remainder(x,y))

[0 1 2]
[0 1 2]

4.统计函数

amax(),amin()

作用：计算数组中的元素沿指定轴的最大值，最小值

x=np.random.randint(1,11,9).reshape([3,3])
print(x)
print('\n')

print(np.amin(x,0))
print(np.amin(x,1))
print('\n')

print(np.amax(x,0))
print(np.amax(x,1))

[[ 1  2  7]
 [10  7  1]
 [ 1 10  7]]


[1 2 1]
[1 1 1]


[10 10  7]
[ 7 10 10]

ptp()

作用：计算数组中元素最大值与最小值的差（最大值-最小值）

print(np.ptp(x))
print(np.ptp(x,0))
print(np.ptp(x,1))

9
[9 8 6]
[6 9 9]

percentile()

作用：百分位数是统计中实验的度量，展示小于这个值观察值的百分比

x = np.array([[10,7,4],[3,2,1]])
print(x)
print('\n')

print(np.percentile(x,50))
print(np.percentile(x,50,axis=0))
print(np.percentile(x,50,axis=1))

[[10  7  4]
 [ 3  2  1]]


3.5
[6.5 4.5 2.5]
[7. 2.]

median()

作用：算数组中元素的中位数（中值）

x = np.array([[30,65,70],[80,95,10],[50,90,60]])
print(x)
print('\n')

print(np.median(x))
print(np.median(x,axis=0))
print(np.median(x,axis=1))

[[30 65 70]
 [80 95 10]
 [50 90 60]]


65.0
[50. 90. 60.]
[65. 80. 60.]

mean()

作用：返回数组中元素的算术平均值

x=np.arange(1,10).reshape((3,3))
print(x)
print('\n')

print(np.mean(x))
print(np.mean(x,axis=0))
print(np.mean(x,axis=1))

[[1 2 3]
 [4 5 6]
 [7 8 9]]


5.0
[4. 5. 6.]
[2. 5. 8.]

average()

作用：根据在另一个数组中给出的各自的权重计算数组中元素的加权平均值。

import numpy as np;
x = np.array([1,2,3,4])
print(x)
print('\n')

print(np.average(x))
print('\n')

vata = np.array([4,3,2,1])
print(np.average(x,weights=vata))
print('\n')

# 如果returned参数设为true,则返回权重的和
print(np.average(x,weights=vata,returned=True))

[1 2 3 4]


2.5


2.0


(2.0, 10.0)

x = np.array([0,1,2,3,4,5]).reshape((3,2))
print(x)

wts = np.array([3,5])
print(np.average(x,axis=1,weights=wts))

标准差

标准差是一组数据平均值分散程度的一种度量

标准差是方差的算术平方根

print(np.std([1,2,3,4]))

1.118033988749895

方差

统计中的方差（样本方差）是每个样本值与全体样本值的平均数之差的平均数，即mean（(x-x.mean())**2）.

换句话说，标准差是方差的平方根

print(np.var([1,2,3,4]))

1.25

5.排序函数

quicksort(快速排序),mergesort(归并排序),heapsort（堆排序）

sort()

import numpy as np

x=np.random.randint(1,11,12).reshape(3,4)
print('x数组：')
print(x)
print('\n')

a=np.sort(x)
print(a)
print('\n')

b=np.sort(x,axis=0)
print(b)

dt=np.dtype([('name','S10'),('age',int)])
y=np.array([('liuliu',34),('lolo',23),('qiqi',40),('xiaoxiao',30)],dtype=dt)
print(y)
c=np.sort(y,order='age')
print(c)

x数组：
[[7 2 1 7]
 [6 6 8 8]
 [7 8 6 3]]


[[1 2 7 7]
 [6 6 8 8]
 [3 6 7 8]]


[[6 2 1 3]
 [7 6 6 7]
 [7 8 8 8]]
[(b'liuliu', 34) (b'lolo', 23) (b'qiqi', 40) (b'xiaoxiao', 30)]
[(b'lolo', 23) (b'xiaoxiao', 30) (b'liuliu', 34) (b'qiqi', 40)]

agsort()

作用：对输入数组沿给定轴执行间接排序，并使用指定排序类型返回数据的索引数组。
这个索引数组用于构造排序后的数组。

x=np.array([3,1,2])
print('x数组：')
print(x)
print('\n')

a=np.argsort(x)

b=x[a]
print(b)
print('\n')

for index in a:
    print(x[index])

x数组：
[3 1 2]


[1 2 3]


1
2
3

lexsort()

作用：使用键序列执行间接排序。键可以看作是电子表格中的一列。该函数返回一个索引数组，使用它可以获得排序数据。

注意：最后一个键恰好是sort的主键

nm=('raju','anli','ravi','amar')
dv=('f.y','s.y','s.y','f.y')

a=np.lexsort((dv,nm))
print(a)
print('\n')

print([nm[i]+','+dv[i] for i in a])

[3 1 0 2]


['amar,f.y', 'anli,s.y', 'raju,f.y', 'ravi,s.y']

msort(a)

作用：数组按第一个轴排序，返回排序后的数组副本

说明：np.msort(a)相等与np.sort(a,axis=0)

sort_complex(a)

作用：对复数按照先实部后虚部的顺序进行排序

y = np.array([1+2j,2-1j,3-2j,3-3j,3+5j])
print('y数组：')
print(y)
print('\n')

y数组：
[1.+2.j 2.-1.j 3.-2.j 3.-3.j 3.+5.j]

partition(a,kth[,axis,kind,order])

作用：指定一个数，对数组进行分区

x=np.array([3,4,2,1])
print('x数组：')
print(x)
print('\n')

print(np.partition(x,3))
print('\n')

print(np.partition(x,[1,3]))

x数组：
[3 4 2 1]


[2 1 3 4]


[1 2 3 4]

argpartition(a,kth[,axis,kind,order])

作用：可以通过关键字kind指定算法沿着指定轴对数组进行分区

x=np.array([3,4,2,1])
print('x数组：')
print(x)
print('\n')
#比第三小
print(np.argpartition(x,2))
print('\n')
#比第四小
print(np.argpartition(x,3))
print('\n')
#比第二大
print(np.argpartition(x,-2))
print('\n')


print(x[np.argpartition(x,2)])
print(x[np.argpartition(x,2)[2]])
print('\n')

print(x[np.argpartition(x,-2)])
print(x[np.argpartition(x,-2)[-2]])
print('\n')

x数组：
[3 4 2 1]


[3 2 0 1]


[2 3 0 1]


[3 2 0 1]


[1 2 3 4]
3


[1 2 3 4]
3

6.搜索函数

max(),min()

作用：沿给定轴返回最大和最小值

import numpy as np

x=np.array([[30,40,70],[80,20,10],[50,90,60]])
print('x数组：')
print(x)
print('\n')

print(x.flatten())
print('\n')

print(np.max(x))
print(np.max(x,axis=0))
print(np.max(x,axis=1))

x数组：
[[30 40 70]
 [80 20 10]
 [50 90 60]]


[30 40 70 80 20 10 50 90 60]


90
[80 90 70]
[70 80 90]

argmax(),argmin()

作用：沿给定轴返回最大和最小元素的索引

x=np.array([[30,40,70],[80,20,10],[50,90,60]])
print('x数组：')
print(x)
print('\n')

print(x.flatten())
print('\n')

print(np.argmax(x))
print(np.argmax(x,axis=0))
print(np.argmax(x,axis=1))

x数组：
[[30 40 70]
 [80 20 10]
 [50 90 60]]


[30 40 70 80 20 10 50 90 60]


7
[1 2 0]
[2 0 1]

nonzero()

作用：返回输入数组中非0元素的索引

x=np.array([[0,40,70],[80,20,10],[50,90,60]])
print('x数组：')
print(x)
print('\n')

print(np.nonzero(x))#下标

x数组：
[[ 0 40 70]
 [80 20 10]
 [50 90 60]]


(array([0, 0, 1, 1, 1, 2, 2, 2], dtype=int64), array([1, 2, 0, 1, 2, 0, 1, 2], dtype=int64))

where()

作用：返回数组中满足给定条件的元素的索引

y=np.where(x>30)
print(y)

(array([0, 0, 1, 2, 2, 2], dtype=int64), array([1, 2, 0, 0, 1, 2], dtype=int64))

extract()

作用：根据某个条件从数组中抽取元素，返回满条件的元素

x=np.array([[30,40,70],[80,20,10],[50,90,60]])
print('x数组：')
print(x)
print('\n')

con=np.mod(x,2)==0
print(con)
print('\n')

print(np.extract(con,x))

x数组：
[[30 40 70]
 [80 20 10]
 [50 90 60]]


[[ True  True  True]
 [ True  True  True]
 [ True  True  True]]


[30 40 70 80 20 10 50 90 60]

六，拷贝

1.赋值

x=np.array([1,2,3,4,5,6])
print('x数组：')
print(x)
print('\n')

print(id(x))
y=x
print(y)
print(id(y))
print('\n')

y.shape=(3,2)
print(y)
print(x)

x数组：
[1 2 3 4 5 6]


1612271023808
[1 2 3 4 5 6]
1612271023808


[[1 2]
 [3 4]
 [5 6]]
[[1 2]
 [3 4]
 [5 6]]

2.视图

又称浅拷贝，是数据的一个别称或引用，通过该别称或引用亦可访问，操作原有数据，但原有数据不会发生拷贝。对视图进行修改，它会影响到原始数据，物理内存存在同一位置。

numpy的切片操作返回原数据的视图，修改数据会影响到原始数组

x=np.arange(12)
print('x数组：')
print(x)
print('\n')

y=x[3:]
print(y)
print('\n')

y[1]=400
print(y)
print(x)
print('\n')

print(id(x),id(y),id(x[3:]))

x数组：
[ 0  1  2  3  4  5  6  7  8  9 10 11]


[ 3  4  5  6  7  8  9 10 11]


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


1612271024528 1612271025168 1612271024608

调用ndarray的view()函数产生一个视图

创建一个新的数组对象，该方法创建的新数组的维数更改不会更改原始数据的维数

x=np.arange(6).reshape((3,2))
print('x数组：')
print(x)
print('\n')

y=x.view()
print(y)
print('\n')

y[1][0]=200
print(y)
print(x)
print('\n')

y.shape=(2,3)
print(y)
print(x)

x数组：
[[0 1]
 [2 3]
 [4 5]]


[[0 1]
 [2 3]
 [4 5]]


[[  0   1]
 [200   3]
 [  4   5]]
[[  0   1]
 [200   3]
 [  4   5]]


[[  0   1 200]
 [  3   4   5]]
[[  0   1]
 [200   3]
 [  4   5]]

3.副本

又可称为深拷贝 是一个数据的完整的拷贝，如果我们对副本进行修改，它不会影响到原始数据，物理内存不在同一位置

调用ndarray的copy()函数产生一个副本

x=np.array([[10,10],[2,3],[4,5]])
print('x数组：')
print(x)
print('\n')

y=x.copy()
print(y)
print('\n')

y[0][0]=100
print(y)
print(x)

x数组：
[[10 10]
 [ 2  3]
 [ 4  5]]


[[10 10]
 [ 2  3]
 [ 4  5]]


[[100  10]
 [  2   3]
 [  4   5]]
[[10 10]
 [ 2  3]
 [ 4  5]]

Python序列的切片操作，调用deepCopy()函数

七，IO操作

1.IO函数

numpy可以读写磁盘上的文本数据或二进制数据

numpy为ndaray对象引入了一个简单的文本格式：npy

npy文件用于存储重建ndarray所需的数据，图形，dtype和其他信息

numpy.save()

import numpy as np

x=np.array([[10,10],[2,3],[4,5]])
print(x)
np.save('./outfile.npy',x)
print('\n')

y=np.load('./outfile.npy')
print(y)

[[10 10]
 [ 2  3]
 [ 4  5]]


[[10 10]
 [ 2  3]
 [ 4  5]]

numpy.savez()

import numpy as np

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

np.savez('outfile.npz',x,y,sin_arr=z)

ret=np.load('./outfile.npz')
print(ret)

print(ret['arr_0'])
print(ret['arr_1'])
print(ret['sin_arr'])

[1 2 3]
[4 5 6]
[7 8 9]

numpy.savetext()

x=np.array([1,2,3])
np.savetxt('./out.txt',x)
y=np.loadtxt('out.txt')
print(y)
print('\n')

x=np.array([1,2.1,3])
# delimiter 指定各种分隔符，针对特定列的转换器函数，需要跳过的行数等
np.savetxt('out2.txt',x,fmt='%d',delimiter='，')
y=np.loadtxt('out2.txt',delimiter='，')
print(y)

[1. 2. 3.]


[1. 2. 3.]

matplotlib

一，初识matplotlib

1.matplotlib简介

Matplotlib是用于数据可视化的最流行的Python包之一

它是一个跨平台库，用于根据数组中的数据制作2D图

Matplotlib是用Python编写的，并使用了Python的数值属性扩展Numpy
它提供列一个面向对象的API，有助于使用Python GUI工具包（如PyQt,WxPythonnotTkinter)在应用程序中嵌入绘图

它也可以用于Python和IPpthon shell ,jupyter笔记本和Web应用程序服务器

Matplotlotlib和NumPy可以被认为是MATLAB的开源等价物

Pillow可以使用的唯一数据类型是unit8

2.pylot简介

matplotlib.pyplot是命令样式函数的集合，使Matplotlib香MATLAB一样工作。每个功能都会对图形进行一些更改，例如，函数创建一个图形，一个图形中的绘图区域，绘制图区域中的一些线条，用标签装饰图形等

绘制（图表）类型

图像函数

轴函数

图形函数

3.pylab模块

Matplotlib是整个包，matplotlib.pyplot是Matplotlib中的一个模块，它和PyLab是一个与Matplotlib一起安装的模块。PyLab是Matplotlib面向对象绘制库的过程接口，是一个非常方便的模块，可以在单个名称空间中批量导入matplotlib.pyplot(用于绘图)和NumPy(用于数学和使用数组)。虽然有很多示例使用PyLab,但不再推荐使用它。

import numpy as np
import pylab as plb

x=np.linspace(-3,3,30)
y=x**2

plb.plot(x,y)
plb.show()

线的颜色与样式

颜色：b,g,r,c,m,y,k,w

符号：^,v,<,>,s,+,x,D,d,1,2,3,4,h,H,p,|,_,-,–,-.,.,，,o

import numpy as np
import pylab as plb

x=np.linspace(-3,3,30)
y=x**2

plb.plot(x,y,'r1')
plb.show()

import numpy as np
import pylab as plb

x=np.linspace(-3,3,30)
y=x**2

plb.plot(x,np.sin(x))
plb.plot(x,np.cos(x),'r--')
plb.plot(x,-np.sin(x),'g--')

plb.show()

显示一个简单的角度线图，以弧度为单位，与正弦值相对应

import numpy as np
import math
import matplotlib.pyplot as plt

%matplotlib inline

x=np.arange(0,math.pi*2,0.05)
y=np.sin(x)

print(x)
print('\n')
print(y)
print('\n')

plt.plot(x,y)
# plt.show()

plt.rcParams['font.size']=20
plt.title('sine wave')
plt.xlabel('angle',color='r',fontsize=20)
plt.ylabel('sine',color='b',rotation=60)

[0.   0.05 0.1  0.15 0.2  0.25 0.3  0.35 0.4  0.45 0.5  0.55 0.6  0.65
 0.7  0.75 0.8  0.85 0.9  0.95 1.   1.05 1.1  1.15 1.2  1.25 1.3  1.35
 1.4  1.45 1.5  1.55 1.6  1.65 1.7  1.75 1.8  1.85 1.9  1.95 2.   2.05
 2.1  2.15 2.2  2.25 2.3  2.35 2.4  2.45 2.5  2.55 2.6  2.65 2.7  2.75
 2.8  2.85 2.9  2.95 3.   3.05 3.1  3.15 3.2  3.25 3.3  3.35 3.4  3.45
 3.5  3.55 3.6  3.65 3.7  3.75 3.8  3.85 3.9  3.95 4.   4.05 4.1  4.15
 4.2  4.25 4.3  4.35 4.4  4.45 4.5  4.55 4.6  4.65 4.7  4.75 4.8  4.85
 4.9  4.95 5.   5.05 5.1  5.15 5.2  5.25 5.3  5.35 5.4  5.45 5.5  5.55
 5.6  5.65 5.7  5.75 5.8  5.85 5.9  5.95 6.   6.05 6.1  6.15 6.2  6.25]


[ 0.          0.04997917  0.09983342  0.14943813  0.19866933  0.24740396
  0.29552021  0.34289781  0.38941834  0.43496553  0.47942554  0.52268723
  0.56464247  0.60518641  0.64421769  0.68163876  0.71735609  0.75128041
  0.78332691  0.8134155   0.84147098  0.86742323  0.89120736  0.91276394
  0.93203909  0.94898462  0.96355819  0.97572336  0.98544973  0.99271299
  0.99749499  0.99978376  0.9995736   0.99686503  0.99166481  0.98398595
  0.97384763  0.9612752   0.94630009  0.92895972  0.90929743  0.88736237
  0.86320937  0.83689879  0.8084964   0.7780732   0.74570521  0.71147335
  0.67546318  0.6377647   0.59847214  0.55768372  0.51550137  0.47203054
  0.42737988  0.38166099  0.33498815  0.28747801  0.23924933  0.19042265
  0.14112001  0.09146464  0.04158066 -0.00840725 -0.05837414 -0.10819513
 -0.15774569 -0.20690197 -0.2555411  -0.30354151 -0.35078323 -0.39714817
 -0.44252044 -0.48678665 -0.52983614 -0.57156132 -0.61185789 -0.65062514
 -0.68776616 -0.72318812 -0.7568025  -0.78852525 -0.81827711 -0.8459837
 -0.87157577 -0.89498936 -0.91616594 -0.93505258 -0.95160207 -0.96577306
 -0.97753012 -0.98684386 -0.993691   -0.99805444 -0.99992326 -0.99929279
 -0.99616461 -0.99054654 -0.98245261 -0.97190307 -0.95892427 -0.94354867
 -0.92581468 -0.90576664 -0.88345466 -0.85893449 -0.83226744 -0.80352016
 -0.77276449 -0.74007731 -0.70554033 -0.66923986 -0.63126664 -0.59171558
 -0.55068554 -0.50827908 -0.46460218 -0.41976402 -0.37387666 -0.32705481
 -0.2794155  -0.23107779 -0.1821625  -0.13279191 -0.0830894  -0.03317922]

import numpy as np
import math
import matplotlib.pyplot as plt

%matplotlib inline

x=np.arange(0,math.pi*2,0.05)
y=np.sin(x)


plt.rcParams['font.sans-serif']='SimHei'# 中文
plt.rcParams['axes.unicode_minus']=False # 负号正常显示

plt.plot(x,y)
# plt.show()
plt.title('正弦波')
plt.xlabel('角度',color='r',fontsize=20)
plt.ylabel('正弦',color='b',rotation=60)

二，进阶使用

1.使用面向对象的思想画图

Figure类

容器

import matplotlib.pyplot as plt
%matplotlib inline

fig = plt.figure()
print(fig)

Figure(432x288)

Axes类

是具有数据空间的图像区域

figure对象通过调用add_axes()方法将Axes对象添加到图中，它返回轴对象并在位置rect[left,bottom,width,height]添加一个轴

import matplotlib.pyplot as plt
%matplotlib inline

fig = plt.figure()
ax=fig.add_axes([0,0,1,1])
print(fig)

import math

x=np.arange(0,math.pi*2,0.05)
y=np.sin(x)

fig=plt.figure()
ax=fig.add_axes([0,0,1,1])

ax.plot(x,y)
ax.set_title('sine wave')
ax.set_xlabel('angle')
ax.set_ylabel('sine')

plt.show()

ax.legend()

作用：为绘图图形添加一个图例

ax.plot()

作用：这是轴类的基本方法。它将一个数组的值与另一个数组的值绘制为线或标记原型

y=[1,4,9,16,25,36,49,64]
x1=[1,16,30,42,55,68,77,88]
x2=[1,6,12,18,28,40,52,65]

fig=plt.figure(figsize=(10,5))
ax=fig.add_axes([0,0,1,1])

ax.plot(x1,y,'bo-')
ax.plot(x2,y,'rs--')

ax.legend(labels=('television','phone'),loc='lower right')

ax.set_title('sine wave')
ax.set_xlabel('angle')
ax.set_ylabel('sine')

plt.show()

x=np.arange(0,math.pi*2,0.05)
y=np.sin(x)

fig=plt.figure(figsize=(10,5))
ax=fig.add_axes([0,0,1,1])

ax.plot(x,y,color='red',alpha=0.2,linestyle='--',lw=5)

plt.show()

y=[1,4,9,16,25,36,49,64]
x=[1,16,30,42,55,68,77,88]

fig=plt.figure(figsize=(10,5))
ax=fig.add_axes([0,0,1,1])

ax.plot(x,y,'r--',marker='s',markersize=20,markeredgewidth=5,markeredgecolor='green',markerfacecolor='yellow')

plt.show()

2.axes与figure对象的关系

一张白纸上可以画在几个区域内画图，而所谓区域，必须存在白纸上才有一样，figure上可以有多个axes,axes必须在figure上，要画图必须有axes.

3.画布上创建多个子图

subplot()

作用：返回给定王国位置的axes对象

说明：

1,在当前图中，该函数创建并返回一个Axes对象，在ncolsaxes的nrows王国的位置索引处。索引从1到nrows*ncols.以行主顺序递增。如果nrows,ncols和index都小于10.索引也可以作为当，连接，三个数字给出。

2.例如，subplot(2,3,3)和subplot(233)都在当前图形的又是那个叫创建一个轴，占据图形高度的一般和图形宽度的三分之一.

3.创建子图将删除任何与其重叠的预先存在的子图，而不是共享边界。

import matplotlib.pyplot as plt
%matplotlib inline

fig = plt.figure(figsize=(12,6))

ax1 = plt.subplot(2,1,1)
ax1.plot(range(12))

ax2 = plt.subplot(212,facecolor='y')
ax2.plot(range(12))

plt.show()

subplots()

import numpy as np

fig,axList=plt.subplots(2,2)

x=np.arange(1,5)

axList[0][0].plot(x,x*x)
axList[1][0].plot(x,np.exp(x))
axList[0][1].plot(x,np.sqrt(x))
axList[1][1].plot(x,np.log10(x))

plt.show()

subplot2grid()

ax1=plt.subplot2grid((3,3),(0,0),colspan=2,rowspan=1)
ax2=plt.subplot2grid((3,3),(0,2),colspan=1,rowspan=3)
ax3=plt.subplot2grid((3,3),(1,0),colspan=2,rowspan=2)

x=np.arange(1,10)

ax1.plot(x,np.exp(x))
ax1.set_title('square root')

ax3.plot(x,np.log(x))
ax3.set_title('log')

ax2.plot(x,x*x)
ax2.set_title('square')

plt.show()

通过在同一图形画布中添加另一个轴对象来在同一图中添加插入图

import math
fig=plt.figure()

x=np.arange(0,math.pi*2,0.05)

ax1=fig.add_axes([0,0,1,1])
ax1.plot(x,np.sin(x))
ax1.set_title('sin')

ax2=fig.add_axes([0.55,0.55,0.3,0.3])
ax2.plot(x,np.cos(x),'r')
ax2.set_title('cos')

plt.show()

figure类的add_subplot()函数

import math
fig=plt.figure()

x=np.arange(0,math.pi*2,0.05)

ax1=fig.add_subplot(111)
ax1.plot(x,np.sin(x))
ax1.set_title('sin')

ax2=fig.add_subplot(222,facecolor='r')
ax2.plot(x,np.cos(x),'y')
ax2.set_title('cos')

plt.show()

4.网格

axes对象的grid()函数将图中的可见性设置为on或off.还可以显示网格的主要/次要（或两者）刻度，还可以在grid()函数中设置color,linestyle和linewidth属性。

import numpy as np
import matplotlib.pyplot as plt
%matplotlib inline

fig,axes = plt.subplots(1,3,figsize=(12,4))

x=np.arange(1,11)

axes[0].plot(x,x*x)
axes[0].grid(True)
axes[1].plot(x,x*x)
axes[1].grid(color='r',ls='--',lw=0.3)
axes[2].plot(x,x*x)

plt.show()

5.设置轴线

基本样式设置

• 轴尖端是连接刻度线的线，划分绘图区域的边界
• 轴对象的尖端位于定不，底部，左侧和右侧
• 每个尖端可以通过指定颜色和宽度进行格式化
• 如果任何边缘的颜色设置为无，则可以使其不可见

import numpy as np
import matplotlib.pyplot as plt
%matplotlib inline

fig,axes = plt.subplots(1,2,figsize=(10,4))

x=np.arange(1,6)
# 原图
axes[0].plot(x,x*x)
axes[0].plot(x,np.exp(x))
# 设置之后
axes[1].plot(x,x*x)
axes[1].plot(x,np.exp(x))

#
axes[1].spines['bottom'].set_color('red')
axes[1].spines['left'].set_color('yellow')
axes[1].spines['left'].set_linewidth(4)
axes[1].spines['right'].set_color(None)
axes[1].spines['top'].set_color(None)

plt.show()

格式化轴

有时候一个或几个点比大量数据大很多，在这种情况下，轴的比例需要设置为对数(log)而不是正常比例

fig,axes=plt.subplots(1,2,figsize=(10,4))
x=np.arange(1,6)

axes[0].plot(x,x*x)
axes[0].plot(x,np.exp(x))
axes[0].set_xlabel('x axis')

axes[1].plot(x,x*x)
axes[1].plot(x,np.exp(x))
axes[1].set_xlabel('x axis')

axes[1].set_yscale('log')
axes[1].xaxis.labelpad=30

plt.show()

设置限制

将x轴上的限制格式化为（0到10）和y轴（0到10000）

fig,axes=plt.subplots(1,2,figsize=(10,4))
x=np.arange(1,11)
y=np.exp(x)

axes[0].plot(x,y)

axes[1].plot(x,y)

axes[1].set_xlim(0,10)
axes[1].set_ylim(0,10000)

plt.show()

设置刻度和刻度标签

• xticks()和yticks()
  
  作用：将列表对象作为参数，列表中的元素表示将显示刻度的相应操作的位置
• set_xlabels()和set_ylabels()
  
  设置刻度线的标签

fig,axes=plt.subplots(1,2,figsize=(10,4))
x=np.arange(0,math.pi*2,0.05)
y=np.sin(x)

axes[0].plot(x,y)

axes[1].plot(x,y)
axes[1].set_xticks([0,2,4,6])
axes[1].set_xticklabels(['zero','tow','four','six'])
axes[1].set_yticks([-1,0,1])

plt.show()

设置轴线的类型

原型：axis(‘xxx’)

常用类型：tight off equal

fig,axes=plt.subplots(1,2,figsize=(12,4))
x=np.linspace(-1,1,100)
f=lambda x : (1-x**2)**0.5

axes[0].plot(x,f(x))
axes[0].plot(x,-f(x))

axes[1].plot(x,f(x))
axes[1].plot(x,-f(x))
axes[1].axis('equal')
axes[1].axis('off')

plt.show()

6.保存图片

savefig

x=np.arange(0,math.pi*2,0.05)
y=np.sin(x)

fig=plt.figure()

ax=fig.add_axes([0,0,1,1])
ax.plot(x,y)
ax.set_title('sine')
ax.set_xticks([0,2,4,6])
ax.set_yticks([-1,0,1])

plt.show()

fig.savefig('sin.jpg',dpi=200)# dpi 图像分辨率

三，绘图

1.条形图

垂直基本条形图

import numpy as np
import matplotlib.pyplot as plt
%matplotlib inline

fig=plt.figure()
ax=fig.add_axes([0,0,1,1])
langs=['C','C++','Python','Java','PHP']
students=[22,45,65,33,42]

# 宽，高
ax.bar(langs,students,0.5,10,align='center',color='red')

plt.show()

垂直组合条形图

当比较多个数量和更改一个变量时，可能需要一个条形图，其中有一个颜色的条形图用于一个数量值

fig=plt.figure()
ax=fig.add_axes([0,0,1,1])

x=np.arange(4)
data=[[30,25,50,20],
     [40,23,51,17],
     [35,22,45,19]]

ax.bar(x,data[0],color='r',width=0.25)
ax.bar(x+0.25,data[1],color='g',width=0.25)
ax.bar(x+0.5,data[2],color='b',width=0.25)

plt.show()

垂直堆叠条形图

fig=plt.figure()
ax=fig.add_axes([0,0,1,1])

N=5
ind=np.arange(1,N+1)
menNum=(20,35,30,35,27)
womenNum=(25,32,34,20,25)

ax.bar(ind,menNum,color='r')
ax.bar(ind,womenNum,color='b',bottom=menNum)

ax.set_ylabel('people_num')
ax.set_xticks(ind)
ax.set_xticklabels(['G1','G2','G3','G4','G5'])
ax.legend(labels=['men','women'])

plt.show()

水平条形图

import numpy as np
import matplotlib.pyplot as plt
%matplotlib inline

fig=plt.figure()
ax=fig.add_axes([0,0,1,1])
langs=['C','C++','Python','Java','PHP']
students=[22,45,65,33,42]

# 高,宽
ax.barh(langs,students,0.5,align='center',color='red')

plt.show()

水平组合条形图

fig=plt.figure()
ax=fig.add_axes([0,0,1,1])

x=np.arange(4)
data=[[30,25,50,20],
     [40,23,51,17],
     [35,22,45,19]]

ax.barh(x,data[0],color='r',height=0.25)
ax.barh(x+0.25,data[1],color='g',height=0.25)
ax.barh(x+0.5,data[2],color='b',height=0.25)

plt.show()

水平堆叠条形图

fig=plt.figure()
ax=fig.add_axes([0,0,1,1])

N=5
ind=np.arange(1,N+1)
menNum=(20,35,30,35,27)
womenNum=(25,32,34,20,25)

ax.barh(ind,menNum,color='r')
ax.barh(ind,womenNum,color='b',left=menNum)

ax.set_xlabel('people_num')
ax.set_yticks(ind)
ax.set_yticklabels(['G1','G2','G3','G4','G5'])
ax.legend(labels=['men','women'])

plt.show()

2.直方图

import numpy as np
import matplotlib.pyplot as plt
%matplotlib inline

fig=plt.figure()
ax=fig.add_axes([0,0,1,1])

a=np.array([22,87,5,43,56,73,55,54,11,20,51,5,79,31,27])

ax.hist(a,bins=[0,25,50,75,100],density=True,cumulative=True)
# density 概率密度计数
# cumulative 累加
ax.set_title('Result histogram')
ax.set_xticks([0,25,50,75,100])
ax.set_xlabel('score')
ax.set_ylabel('the number of students')

plt.show()

3.饼图

• 饼图只能显示一系列数据
• 饼图在一个数据系列中显示项目的大小，与项目的总和成比例
• 饼图中的数据点显示为整个饼图的百分比

import numpy as np
import matplotlib.pyplot as plt
%matplotlib inline

fig=plt.figure(figsize=(10,5))
ax=fig.add_axes([0,0,1,1])
ax.axis('equal')

langs=['C','C++','Python','Java','PHP']
students=[23,17,35,29,12]


ax.pie(students,labels=langs,autopct="%1.2f%%",colors=['red','yellow','green','pink'],explode=[0.1,0.2,0,0,0],shadow=True)

plt.show()

4.散点图

• 散点图用于绘制水平轴和垂直轴上的数据点，以视图显示一个变量受另一个变量影响程度
• 数据表中的没一行都由一个标记表示，该位置取决于其在X和Y轴上设置的列中的值
• 可以将迪桑变量设置为对应于标记的1颜色或大小，从而为该图添加另一个维度

import numpy as np
import matplotlib.pyplot as plt
%matplotlib inline

fig=plt.figure(figsize=(10,5))
ax=fig.add_axes([0,0,1,1])

girls_grades=[89,90,70,89,100,80,90,100,80,34]
boys_grades=[30,29,49,48,100,48,38,45,20,30]
grades_range=[10,20,30,40,50,60,70,80,90,100]

ax.scatter(grades_range,girls_grades,color='r',alpha=1)
ax.scatter(grades_range,boys_grades,color='b',alpha=1)

ax.set_title('examples of scatter plots')
ax.set_xlabel('scores range')
ax.set_ylabel('grades')

ax.legend(labels=('girls','boys'),loc='upper right')

plt.show()

5.箱形图

箱形图也称为须状图，显示包含最小值，第一四分位数，中位数，第三四分位数和最大值的一组数据的摘要。

在方块图中，绘制从第一个四分位数到第三个四分位数的方框。垂直线穿过中间的框。须状从每个四分位数的最小值到最大值。

import numpy as np
import matplotlib.pyplot as plt
%matplotlib inline

fig=plt.figure(figsize=(10,5))
ax=fig.add_axes([0,0,1,1])

np.random.seed(10)
collectn_1=np.random.normal(100,10,200)# 高斯分布 均值，标准差，个数
collectn_2=np.random.normal(80,30,200)
collectn_3=np.random.normal(90,20,200)
collectn_4=np.random.normal(70,25,200)

ax.boxplot([collectn_1,collectn_2,collectn_3,collectn_4])

plt.show()

6.轮廓图

import numpy as np
import matplotlib.pyplot as plt
%matplotlib inline

fig=plt.figure(figsize=(10,5))
ax=fig.add_axes([0,0,1,1])

x=np.linspace(-3,3,100)
y=np.linspace(-3,3,100)

X,Y=np.meshgrid(x,y)
Z=np.sqrt(X**2+Y**2)

ct=ax.contourf(X,Y,Z)
fig.colorbar(ct)

plt.show()

7.图像内的文字，注释，箭头

text(),xlabel(),ylabel(),title(),legend()

import numpy as np
import matplotlib.pyplot as plt
%matplotlib inline

fig=plt.figure()
ax=fig.add_axes([0,0,1,1])

t=np.arange(0.0,2.0,0.01)
s=np.sin(2*np.pi*t)

ax.plot(t,s)

#ax.set_title('sunk',fontsize=20)
ax.set_title(r'$\alpha_i>\beta_i$',fontsize=20)

ax.text(0.6,0.3,r'sunck is a good man',fontsize=20)
ax.text(0.6,0.5,r'sunck is a nice man',fontsize=20,style='italic',bbox={'facecolor':'red'})
ax.text(0.6,0,r'$\sqrt{2}$',fontsize=20)
ax.text(0.6,-0.2,r'$\mathcal{A}\mathrm{sin}{2 \omega t}$',fontsize=20)#asin(2wt)

ax.set_xlabel('time(s)')
ax.set_ylabel('volts(mV)')

ax.legend(labels=('k'),loc='upper right')

plt.show()

suptitle()

import math 

fig=plt.figure(figsize=(12,6))

x=np.arange(0,math.pi*2,0.05)
y1=np.sin(x)
y2=np.cos(x)

ax1=plt.subplot(121)
ax1.plot(x,y1)
ax1.set_title('sin')

ax2=plt.subplot(122)
ax2.plot(x,y2)
ax2.set_title('cos')

plt.suptitle('sin&cos')

plt.show()

figtext()

fig=plt.figure()
ax=fig.add_axes([0,0,1,1])

x=np.arange(0,math.pi*2,0.05)
y=np.sin(x)

ax.plot(x,y)

plt.figtext(0.2,0.5,s='sin(0)=0')

plt.show()

annotate()

fig=plt.figure()
ax=fig.add_axes([0,0,1,1])

x=np.arange(0,math.pi*2,0.05)
y=np.sin(x)

ax.plot(x,y)

plt.figtext(0.2,0.5,s='sin(0)=0')

ax.annotate('sunck',xy=(1.5,0.8),xytext=(1,0.4),arrowprops=dict(facecolor='red',shrink=(0.001)))
# shrink 设置箭头顶点，尾部与指示点，注释文字的距离（比例值）

plt.show()

fig=plt.figure(figsize=(12,9))
ax=fig.add_axes([0,0,1,1])

arrstyles=['-','->','-[','<-','<->','fancy','simple','wedge']
for i,style in enumerate(arrstyles):
    ax.annotate(style,xy=(0.2,0.9-0.1*i),xytext=(0.05,0.85-0.1*i),arrowprops=dict(arrowstyle=style));

connstyles=['arc','arc,angleA=10,rad=30','arc3,rad=.2','arc3,rad=-.2','angle','angle3']
for i,style in enumerate(connstyles):
    ax.annotate(style,xy=(0.7,0.9-0.1*i),xytext=(0.6,0.85-0.1*i),arrowprops=dict(arrowstyle='->',connectionstyle=style));
    
plt.show()

四，图像处理

1.Pillow模块处理图片

from PIL import Image

tup=Image.open('./tup.jpeg')
print(type(tup))
print(tup)
tup

from PIL import Image

tup=Image.open('./tup.jpeg')
tup_data=np.array(tup)

print(type(tup))
print(tup_data)

[[[255 255 255]
  [255 255 255]
  [255 255 255]
  ...
  [255 255 255]
  [255 255 255]
  [255 255 255]]

 [[255 255 255]
  [255 255 255]
  [255 255 255]
  ...
  [255 255 255]
  [255 255 255]
  [255 255 255]]

 [[255 255 255]
  [255 255 255]
  [255 255 255]
  ...
  [255 255 255]
  [255 255 255]
  [255 255 255]]

 ...

 [[255 255 255]
  [255 255 255]
  [255 255 255]
  ...
  [255 255 255]
  [255 255 255]
  [255 255 255]]

 [[255 255 255]
  [255 255 255]
  [255 255 255]
  ...
  [255 255 255]
  [255 255 255]
  [255 255 255]]

 [[255 255 255]
  [255 255 255]
  [255 255 255]
  ...
  [255 255 255]
  [255 255 255]
  [255 255 255]]]

红绿蓝–》蓝绿红

from PIL import Image

tup=Image.open('./tup.jpeg')
tup_data=np.array(tup)

tup_data=tup_data[:,:,::-1]

print(tup_data)

tup2=Image.fromarray(tup_data)
tup2

[[[255 255 255]
  [255 255 255]
  [255 255 255]
  ...
  [255 255 255]
  [255 255 255]
  [255 255 255]]

 [[255 255 255]
  [255 255 255]
  [255 255 255]
  ...
  [255 255 255]
  [255 255 255]
  [255 255 255]]

 [[255 255 255]
  [255 255 255]
  [255 255 255]
  ...
  [255 255 255]
  [255 255 255]
  [255 255 255]]

 ...

 [[255 255 255]
  [255 255 255]
  [255 255 255]
  ...
  [255 255 255]
  [255 255 255]
  [255 255 255]]

 [[255 255 255]
  [255 255 255]
  [255 255 255]
  ...
  [255 255 255]
  [255 255 255]
  [255 255 255]]

 [[255 255 255]
  [255 255 255]
  [255 255 255]
  ...
  [255 255 255]
  [255 255 255]
  [255 255 255]]]

红绿蓝-》绿红蓝

tup=Image.open('./tup.jpeg')
tup_data=np.array(tup)

tup_data=tup_data[:,:,[1,0,2]]

print(tup_data)

tup3=Image.fromarray(tup_data)
tup3

[[[255 255 255]
  [255 255 255]
  [255 255 255]
  ...
  [255 255 255]
  [255 255 255]
  [255 255 255]]

 [[255 255 255]
  [255 255 255]
  [255 255 255]
  ...
  [255 255 255]
  [255 255 255]
  [255 255 255]]

 [[255 255 255]
  [255 255 255]
  [255 255 255]
  ...
  [255 255 255]
  [255 255 255]
  [255 255 255]]

 ...

 [[255 255 255]
  [255 255 255]
  [255 255 255]
  ...
  [255 255 255]
  [255 255 255]
  [255 255 255]]

 [[255 255 255]
  [255 255 255]
  [255 255 255]
  ...
  [255 255 255]
  [255 255 255]
  [255 255 255]]

 [[255 255 255]
  [255 255 255]
  [255 255 255]
  ...
  [255 255 255]
  [255 255 255]
  [255 255 255]]]

2.Matplotlib包中的图像模块

Matplotlib提供加载，重新缩放和显示图像所需功能，仅支持png

imread

作用：用于读取float32 dtype 的ndarray对象中的图像数据

import numpy as np
import matplotlib.image as mping

data=mping.imread('./tup.png')
# data=mping.imread('./tup.jpeg') 整数，pillow读
print(type(data))
print(data)

[[[0. 0. 0. 0.]
  [0. 0. 0. 0.]
  [0. 0. 0. 0.]
  ...
  [0. 0. 0. 0.]
  [0. 0. 0. 0.]
  [0. 0. 0. 0.]]

 [[0. 0. 0. 0.]
  [0. 0. 0. 0.]
  [0. 0. 0. 0.]
  ...
  [0. 0. 0. 0.]
  [0. 0. 0. 0.]
  [0. 0. 0. 0.]]

 [[0. 0. 0. 0.]
  [0. 0. 0. 0.]
  [0. 0. 0. 0.]
  ...
  [0. 0. 0. 0.]
  [0. 0. 0. 0.]
  [0. 0. 0. 0.]]

 ...

 [[0. 0. 0. 0.]
  [0. 0. 0. 0.]
  [0. 0. 0. 0.]
  ...
  [0. 0. 0. 0.]
  [0. 0. 0. 0.]
  [0. 0. 0. 0.]]

 [[0. 0. 0. 0.]
  [0. 0. 0. 0.]
  [0. 0. 0. 0.]
  ...
  [0. 0. 0. 0.]
  [0. 0. 0. 0.]
  [0. 0. 0. 0.]]

 [[0. 0. 0. 0.]
  [0. 0. 0. 0.]
  [0. 0. 0. 0.]
  ...
  [0. 0. 0. 0.]
  [0. 0. 0. 0.]
  [0. 0. 0. 0.]]]

imshow

import matplotlib.pyplot as plt

data=mping.imread('./tup.png')

plt.axis('off')

plt.imshow(data)

data=mping.imread('./tup.png')

# plt.axis('off')

plt.imshow(data)
data=data[:,:,0]
plt.imshow(data,cmap='hot')

plt.set_cmap('nipy_spectral')
plt.colorbar(ticks=[0.1,0.2,0.3,0.4,0.5,0.6,0.7,0.8,0.9],orientation='horizontal')

data=mpimg.imread('./tup.png')
plt.imsave('./tup2.png',data,cmap='gray',origin='lower')

3.ndarray图像操作练习

import numpy as np
import matplotlib.pyplot as plt
import matplotlib.image as mpimg

tup_data = mpimg.imread('./tup.jpeg')
print(tup_data)
plt.imshow(tup_data)

[[[255 255 255]
  [255 255 255]
  [255 255 255]
  ...
  [255 255 255]
  [255 255 255]
  [255 255 255]]

 [[255 255 255]
  [255 255 255]
  [255 255 255]
  ...
  [255 255 255]
  [255 255 255]
  [255 255 255]]

 [[255 255 255]
  [255 255 255]
  [255 255 255]
  ...
  [255 255 255]
  [255 255 255]
  [255 255 255]]

 ...

 [[255 255 255]
  [255 255 255]
  [255 255 255]
  ...
  [255 255 255]
  [255 255 255]
  [255 255 255]]

 [[255 255 255]
  [255 255 255]
  [255 255 255]
  ...
  [255 255 255]
  [255 255 255]
  [255 255 255]]

 [[255 255 255]
  [255 255 255]
  [255 255 255]
  ...
  [255 255 255]
  [255 255 255]
  [255 255 255]]]

tup_data=tup_data[::,::-1,::]
print(tup_data)
plt.imshow(tup_data)

[[[255 255 255]
  [255 255 255]
  [255 255 255]
  ...
  [255 255 255]
  [255 255 255]
  [255 255 255]]

 [[255 255 255]
  [255 255 255]
  [255 255 255]
  ...
  [255 255 255]
  [255 255 255]
  [255 255 255]]

 [[255 255 255]
  [255 255 255]
  [255 255 255]
  ...
  [255 255 255]
  [255 255 255]
  [255 255 255]]

 ...

 [[255 255 255]
  [255 255 255]
  [255 255 255]
  ...
  [255 255 255]
  [255 255 255]
  [255 255 255]]

 [[255 255 255]
  [255 255 255]
  [255 255 255]
  ...
  [255 255 255]
  [255 255 255]
  [255 255 255]]

 [[255 255 255]
  [255 255 255]
  [255 255 255]
  ...
  [255 255 255]
  [255 255 255]
  [255 255 255]]]

tup_data=tup_data[::,::-1,::]
print(tup_data)
plt.imshow(tup_data)

[[[255 255 255]
  [255 255 255]
  [255 255 255]
  ...
  [255 255 255]
  [255 255 255]
  [255 255 255]]

 [[255 255 255]
  [255 255 255]
  [255 255 255]
  ...
  [255 255 255]
  [255 255 255]
  [255 255 255]]

 [[255 255 255]
  [255 255 255]
  [255 255 255]
  ...
  [255 255 255]
  [255 255 255]
  [255 255 255]]

 ...

 [[255 255 255]
  [255 255 255]
  [255 255 255]
  ...
  [255 255 255]
  [255 255 255]
  [255 255 255]]

 [[255 255 255]
  [255 255 255]
  [255 255 255]
  ...
  [255 255 255]
  [255 255 255]
  [255 255 255]]

 [[255 255 255]
  [255 255 255]
  [255 255 255]
  ...
  [255 255 255]
  [255 255 255]
  [255 255 255]]]

import numpy as np
import matplotlib.pyplot as plt
import matplotlib.image as mpimg

tup_data = mpimg.imread('./tup.jpeg')
plt.imshow(tup_data)
print(tup_data.shape)
tup_data2=tup_data[::20,::20]
print(tup_data2.shape)
print(tup_data2)
plt.imshow(tup_data2)

(969, 686, 3)
(49, 35, 3)
[[[255 255 255]
  [175 194  87]
  [168 186  78]
  ...
  [ 78  87  30]
  [ 92 103  43]
  [255 255 255]]

 [[255 255 255]
  [150 168  58]
  [168 186  76]
  ...
  [ 75  85  32]
  [ 82  93  35]
  [255 255 255]]

 [[255 255 255]
  [145 210  66]
  [150 210  62]
  ...
  [153 225  63]
  [155 220  64]
  [255 255 255]]

 ...

 [[255 255 255]
  [116 166  41]
  [125 169  46]
  ...
  [195 234  83]
  [201 236  80]
  [255 255 255]]

 [[255 255 255]
  [125 171  49]
  [139 179  57]
  ...
  [197 237  76]
  [197 233  81]
  [255 255 255]]

 [[255 255 255]
  [175 214  63]
  [169 209  60]
  ...
  [121 185  29]
  [112 181  28]
  [255 255 255]]]

tup_data = mpimg.imread('./tup.png')
# plt.imshow(tup_data)

tup_data=tup_data[60:360,120:600]#行，列
plt.imshow(tup_data)

tup_data = mpimg.imread('./tup.png')
# plt.imshow(tup_data)

tup_temp=tup_data[60:360,120:600,::-1]#行，列
plt.imshow(tup_temp)

tup_ret=tup_data.copy()
tup_ret[60:360,120:600]=tup_temp
plt.imshow(tup_ret)

tup_data = mpimg.imread('./tup.png')
# plt.imshow(tup_data)

tup_temp=tup_data[60:360,120:600]#行，列
print(tup_temp.shape)
tup_temp=tup_temp[::20,::20]
print(tup_temp.shape)

tup_ret=tup_data.copy()
for i in range(15):
    for j in range(24):
        tup_ret[60+i*20:60+20+i*20,120+j*20:120+20+j*20]=tup_temp[i,j]
plt.imshow(tup_ret)

(300, 480, 4)
(15, 24, 4)

tup_data = mpimg.imread('./tup.png')
tup_data2 = np.concatenate([tup_data,tup_data])

plt.imshow(tup_data2)

tup_data = mpimg.imread('./tup.png')
tup_data2 = np.concatenate([tup_data,tup_data],axis=1)

plt.imshow(tup_data2)

cat_data = mpimg.imread('./tup.png')
print(cat_data.shape)
cat1,cat2,cat3=np.split(cat_data,indices_or_sections=[300,500],axis=1)
print(cat1.shape,cat2.shape,cat3.shape)

plt.imshow(cat1)

(1024, 1024, 4)
(1024, 300, 4) (1024, 200, 4) (1024, 524, 4)

plt.imshow(cat2)

plt.imshow(cat3)

4.图像灰度化

灰度化：在RGB模型中，如果R=G=B时，则彩色表示一种灰度颜色，其中R=G=B的值叫灰度值

最小值法或者是最大值法（极值法）

import numpy as np
import matplotlib.pyplot as plt
import matplotlib.image as mpimg

cat_data=mpimg.imread('./tup.png')
print(cat_data.shape)
print(cat_data)

cat_data_gray=cat_data.min(axis=-1)
print(cat_data_gray.shape)
print(cat_data_gray)
plt.imshow(cat_data_gray,cmap='gray')

(1024, 1024, 4)
[[[0. 0. 0. 0.]
  [0. 0. 0. 0.]
  [0. 0. 0. 0.]
  ...
  [0. 0. 0. 0.]
  [0. 0. 0. 0.]
  [0. 0. 0. 0.]]

 [[0. 0. 0. 0.]
  [0. 0. 0. 0.]
  [0. 0. 0. 0.]
  ...
  [0. 0. 0. 0.]
  [0. 0. 0. 0.]
  [0. 0. 0. 0.]]

 [[0. 0. 0. 0.]
  [0. 0. 0. 0.]
  [0. 0. 0. 0.]
  ...
  [0. 0. 0. 0.]
  [0. 0. 0. 0.]
  [0. 0. 0. 0.]]

 ...

 [[0. 0. 0. 0.]
  [0. 0. 0. 0.]
  [0. 0. 0. 0.]
  ...
  [0. 0. 0. 0.]
  [0. 0. 0. 0.]
  [0. 0. 0. 0.]]

 [[0. 0. 0. 0.]
  [0. 0. 0. 0.]
  [0. 0. 0. 0.]
  ...
  [0. 0. 0. 0.]
  [0. 0. 0. 0.]
  [0. 0. 0. 0.]]

 [[0. 0. 0. 0.]
  [0. 0. 0. 0.]
  [0. 0. 0. 0.]
  ...
  [0. 0. 0. 0.]
  [0. 0. 0. 0.]
  [0. 0. 0. 0.]]]
(1024, 1024)
[[0. 0. 0. ... 0. 0. 0.]
 [0. 0. 0. ... 0. 0. 0.]
 [0. 0. 0. ... 0. 0. 0.]
 ...
 [0. 0. 0. ... 0. 0. 0.]
 [0. 0. 0. ... 0. 0. 0.]
 [0. 0. 0. ... 0. 0. 0.]]

cat_data=mpimg.imread('./tup.png')
cat_data_gray=cat_data.max(axis=-1)
print(cat_data_gray)
plt.imshow(cat_data_gray,cmap='gray')

[[0. 0. 0. ... 0. 0. 0.]
 [0. 0. 0. ... 0. 0. 0.]
 [0. 0. 0. ... 0. 0. 0.]
 ...
 [0. 0. 0. ... 0. 0. 0.]
 [0. 0. 0. ... 0. 0. 0.]
 [0. 0. 0. ... 0. 0. 0.]]

平均值法

cat_data=mpimg.imread('./tup.png')
cat_data_gray=cat_data.mean(axis=-1)
print(cat_data_gray)
plt.imshow(cat_data_gray,cmap='gray')

[[0. 0. 0. ... 0. 0. 0.]
 [0. 0. 0. ... 0. 0. 0.]
 [0. 0. 0. ... 0. 0. 0.]
 ...
 [0. 0. 0. ... 0. 0. 0.]
 [0. 0. 0. ... 0. 0. 0.]
 [0. 0. 0. ... 0. 0. 0.]]

加权平均值法（三原色法）

cat_data=mpimg.imread('./tup.png')

print(cat_data.shape)

rgb_weight=[0.299,0.587,0.111,0.003]# 加起来等于1

cat_data_gray=np.dot(cat_data,rgb_weight)
print(cat_data_gray)
plt.imshow(cat_data_gray,cmap='gray')

(1024, 1024, 4)
[[0. 0. 0. ... 0. 0. 0.]
 [0. 0. 0. ... 0. 0. 0.]
 [0. 0. 0. ... 0. 0. 0.]
 ...
 [0. 0. 0. ... 0. 0. 0.]
 [0. 0. 0. ... 0. 0. 0.]
 [0. 0. 0. ... 0. 0. 0.]]