python基础学习笔记

系统的学习python基础知识
主要包括人工智能几个模块和python的数据结构：
- 列表、元祖、字典
- numpy基本函数的使用
- matloplib绘图库的基本使用

1. 列表、元祖、字典

列表

列表的数据项不需要具有相同的类型
创建一个列表，只要把逗号分隔的不同的数据项使用方括号括起来即可
list(seq) 将元组转换为列表
list.append(obj) 在列表末尾添加新的对象
list.extend(seq) 在列表末尾一次性追加另一个序列中的多个值（用新列表扩展原来的列表）
list.index(obj) 从列表中找出某个值第一个匹配项的索引位置
list.insert(index, obj)将对象插入列表
list.pop(i) 移除列表中的第i元素（默认最后一个元素），并且返回该元素的值
list.remove(obj) 移除列表中某个值的第一个匹配项
list.reverse() 反向列表中元素
list.sort(cmp=None, key=None, reverse=False) 对原列表进行排序 reverse=True(降序,默认False升序), 如果列表中是一个元组key=takeSecond 指定按照元组第二个元素排序(指定可迭代对象中的一个元素来进行排序)

元组

元组与列表类似，不同之处在于元组的元素不能修改
元组使用小括号，列表使用方括号
元组创建很简单，只需要在括号中添加元素，并使用逗号隔开即可
元组中只包含一个元素时，需要在元素后面添加逗号
L[2]读取第三个元素,L[-2]反向读取，读取倒数第二个元素
元组中的元素值是不允许删除的，但我们可以使用del语句来删除整个元组
tuple(seq) 将列表转换为元组

字典

字典是另一种可变容器模型，且可存储任意类型对象
字典的每个键值 key=>value 对用冒号 : 分割，每个键值对之间用逗号 , 分割，整个字典包括在花括号 {} 中
键一般是唯一的，如果重复最后的一个键值对会替换前面的，值不需要唯一
值可以取任何数据类型，但键必须是不可变的，如字符串，数字或元组(一个字典的键的数据类型唯一)
dict['Age'] = 8 有则更新,没有则添加
del dict['Name'] 删除键是'Name'的条目
dict.clear() 清空字典所有条目
del dict 删除字典
键必须不可变，所以可以用数字，字符串或元组充当，所以用列表就不行
len(dict)计算字典元素个数，即键的总数
str(dict) 输出字典可打印的字符串表示
dict.has_key(key) 如果键在字典dict里返回true，否则返回false
dict.items() 以列表返回可遍历的(键, 值) 元组数组
dict.keys() 以列表返回一个字典所有的键
dict.values() 以列表返回字典中的所有值
dict.popitem() 返回并删除字典中的最后一对键和值。

2. numpy基本函数的使用

生成数组

a = np.array([1, 2, 3])
b = np.array((4, 5, 6))
# 指定类型
a = np.array([1, 2, 3], dtype=int)
a = np.array([1, 2, 3], dtype=float)

多维数组

# 0轴：2  1轴：3  从外到里  。还可以有3轴
c = np.array([[1, 2, 3], [4, 5, 6]]) # 二位数组

arange

# [0,101)区间,间隔20的一维数组
a = np.arange(0, 101, 20)

linspace

# [0,19]区间平均分成20份
b = np.linspace(0, 19, 20)
# 可以指定不包含最后一个20[0,20)
c = np.linspace(0, 20, 20, endpoint=False)

一维变多维(创建多维数组)

# 生成一个4*3*2的三维数组（条件4*3*2=24）
h = np.arange(24).reshape(4, 3, 2)

指数数组

# 以2为底，分别为 2**0,2**1，......
g = np.logspace(0, 9, 10, base=2)

矩阵

# 生成矩阵（很接近于0）
x = np.empty((3, 2))
# 元素全部为0的3*2矩阵
y = np.zeros((3, 2), np.int) # 默认为浮点型,指定生成整型
# 生成一个3*2矩阵,元素用1填充
z = np.full((3, 2), 1)
# 自定义函数生成ndarray
def func(i,j):
    return i%5+j
x = np.fromfunction(func,(5,2))
# shape打印规格
print(c.shape)
# 改变规格
d = c.reshape(4,3) # 将原来的阵列,变成一维的,在进行重新转载成我们需要的

切片

注：切片值取出来的对象,二者指向同一个内存地址(修改其中一个,另一个也会改变)

a = np.arange(10)
b = a[1:3] # 1,2
# 改变b的值，a中的元素也会改变
b[0] = 666
print(a[0]) # 666
# 可使用copy函数
c = b.copy() # 重新开辟内存空间

# 改变为10*1的矩阵
a = np.arange(0,60,10)
a = a.reshape(-1,1)
b = np.arange(0,6)
c = a+b
print(c)
print(c.shape) # c为6*6的矩阵

print(c[:3, :3]) # 左上角
print(c[3:, :3]) # 左下角
# 对角线 一一对应的 0-0 1-1
print(c[(0,1,2,3,4,5),(0,1,2,3,4,5)])

# mask 只取为1的位置的元素
mask = np.array([1,0,0,1,0,0],dtype=bool)
# 抽取第1列
print(c[mask,1])
# 抽取第1行
print(c[1,mask])

维度

a = np.array([1,2,3])
print(a.ndim) # 1
h = np.arange(24).reshape(4, 3, 2)
print(h.ndim) # 3

矩阵运算

a = np.array([1,2,3])
b = np.array([4,5,6])
# +
print(np.add(a,b))
print(a+b) #[5 7 9]
# -
print(np.subtract(a,b))
print(a-b) # [-3 -3 -3]
# *
print(np.multiply(a,b))
print(a*b) # [4 10 18]
# /
print(np.divide(a,b))
print(a/b) #[0.25 0.4 0.5]
# 乘方
print(np.power(a,b)) # a**b  [1 32 729]
# 元素对应值是否相等
print(np.equal(a,b)) # [False False False]
print(np.not_equal(a,b)) # [ True  True  True]
# # 比较大小
print(np.less(a,b)) # [ True  True  True]
print(np.less_equal(a,b)) # <=
print(np.greater(a,b)) # >

广播

两个数组每一维度上的最大值靠齐维度不同伸展

a = np.arange(4)
print(a[None,:].shape) # 1*4
print(a[:,None].shape) # 4*1
print((a[None,:]+a[:,None]).shape) # 4*4

随机数

# 返回一个或一组服从均匀分布的3*3的随机样本值，取值范围[0,1)
print(random.rand(3,3))
# 返回一个或一组服从标准正态分布的3*3的随机样本值
print(random.randn(3,3))
# 0-10的5*2数组
random.seed(10)
print(random.randint(0,10,size=(5,2))) #范围[low, high)
print(np.sum(a,axis=0)) # 列向求和，返回1*2
print(np.sum(a,axis=1,keepdims=True)) # 横向求和，返回2*1

# 从一个均匀分布[low,high)中随机采样
a = np.random.uniform(0,12,12) # 1*12
a = np.random.uniform(0,12,(3,4)) # 3*4

# 默认按行排序
a = np.random.randint(0,10,size=(3,3))
print(np.sort(a)) # 行方向，从小到大排序

统计

b = random.randint(0,5,10)
# x为有哪些元素(由小到大)，index为元素第一次出现的位置
x,index = np.unique(b,return_index=True) #[1 0 0 2 1 0 0 2 2 2]
print(x) #[0 1 2]
print(index) #[1 0 3]
# 统计每个元素出现多少次
print(np.bincount(b))

n = random.rand(20) #[0.44591587 0.59832584 0.84908945 0.60374917]
# 分为5个区间,值得范围是0-1之间  x为区间的元素个数，y为区间
x,y = np.histogram(n, bins=5, range=(0, 1))
print(y) #[0 0.2 0.4 0.6 0.8 1] 分为5个区间
print(x) #[0 0 2 1 1]

3. matloplib绘图库的基本使用

散点图

a = [1,2,3,4]
b = [5,6,7,8]
plt.figure(figsize=(5, 5)) # 设置图片宽高比
# plt.plot(a,b,'ro',markersize=10)# 点图（可设置点的样式和大小）
# plt.plot(a,b) #点相连为线段
plt.scatter(a,b) # 点图
plt.xlabel(r'$a$',fontsize=20) # x轴下标标题
plt.ylabel(r'$b$',fontsize=20) # y轴下标标题
plt.title('scatter figure', loc='center') # 设置标题和位置,默认在中间
plt.grid() # 设置网格线
plt.show()

曲线图

a = np.linspace(0,2*np.pi,100)
b = np.sin(a)
c = np.cos(a**2)
plt.xlabel('x')
plt.ylabel('y')
plt.title('sin demo')
# 设置颜色，线段样式，线段宽度
plt.plot(a,b,label=r'$sin(x)$',color='green',linestyle='dashed', marker='o',linewidth=1)
plt.plot(a,c,label=r'$cos(x)$',color='red',linestyle='dashed', marker='o',linewidth=1)
# # plt.plot(a,b,'go*')
# 设置y轴的范围
plt.ylim(-1,1)
plt.xlim(-1,7)
# 显示图注
plt.legend()
# 要在show之前保存，制定分变率
plt.savefig('sincos.png',dpi=250)
plt.show()

柱状图

x = [5, 8, 10]
y = [12, 16, 6]
x1 = [6, 9, 11]
y1 = [6, 5, 17]
plt.bar(x, y, width=0.2, align='center')
plt.bar(x1, y1, width=0.2, color='g', align='center')
plt.xticks()
plt.title('bar graph')
plt.ylabel('Y')
plt.xlabel('X')
plt.show()

子图

# 创建一张图
plt.figure(1)
# 把图代表分为2*2份，放在第二份上
plt.subplot(222)
a = np.linspace(0,2*np.pi,100)
b = np.sin(a)
plt.plot(a,b)

# 第二个小图，放在第一个位置
ax1 = plt.subplot (2,2,1)
c = np.cos(a)
plt.plot(a,c) # 画一个曲线
d = 3*a+1
plt.plot(a,d) # 再画一个曲线

plt.sca(ax1) # 选中子图2
# 设置横坐标样式
plt.xticks(fontsize=16,color='red',rotation=45)
plt.show()

饼图

plt.rcParams['font.sans-serif'] = ['SimHei']  # 用来正常显示中文标签

labels = ['娱乐', '育儿', '饮食', '房贷', '交通', '其它']
sizes = [2, 5, 12, 70, 2, 9]
# explode : 每一块饼图 离开中心距离，默认值为（0,0），就是不离开中心
# 房贷离开中心
explode = (0, 0, 0, 0.1, 0, 0)
plt.pie(sizes, explode=explode, labels=labels, autopct='%1.1f%%', shadow=False, startangle=150)
plt.title("饼图示例-8月份家庭支出")
# 该行代码使饼图长宽相等
plt.axis('equal')
plt.show()

操作图片

plt.figure(1)
img = plt.imread('dog.jpg')
# dtype 返回的是图像的数据类型
print(img.dtype)
# shape可以获取图像的形状，返回一个包含行数，列数，通道数的元组
print(img.shape)

plt.subplot(221)
plt.imshow(img) # 正常显示图片

plt.subplot(222)
plt.imshow(img[::-1])# 上下颠倒显示

plt.subplot(223)
plt.imshow(img[:,::-1]) # 图片左右

plt.subplot(224)
plt.imshow(img[:,:,::-1]) # 通道颠倒(rgb->bgr)

plt.show()

# 提取单通道
plt.figure(2)

plt.subplot(221)
# astype强制转换，img*[1,0,0]就只剩下R通道
plt.imshow((img*[1,0,0]).astype(np.uint8))
# plt.imshow(img[:,:,0])# 无法提取单通道R
# plt.imshow(img[:,:,1])# 无法提取单通道G
# plt.imshow(img[:,:,0])# 无法提取单通道B

plt.subplot(222)
plt.imshow((img*[0,1,0]).astype(np.uint8)) # G

plt.subplot(223)
plt.imshow((img*[0,0,1]).astype(np.uint8)) # B
plt.colorbar() # 显示颜色条

plt.show()

热力图

# 产生两个数组 200j表示用两百个区间来平分-2到2
x,y = np.ogrid[-2:2:200j, -1:2:200j]
print(x)
print(y)
# x*(e**((-x**2-y**2)))
z = x*np.exp(-x**2-y**2)
extent = [np.min(x),np.max(x),np.min(y),np.max(y)]
plt.imshow(z,extent=extent, origin='lower')
plt.colorbar()
plt.show()

等高线

x,y = np.ogrid[-1.5:1.5:200j, -1.5:1.5:200j]
f = (x**2+y**2)**4-(x**2-y**2)**2
extent = [np.min(x),np.max(x),np.min(y),np.max(y)]
# 画轮廓线
v = plt.contour(f,10,extent=extent)
# clabel用于标记等高线
plt.clabel(v,inline=1,fontsize=10)
plt.show()

三维图

# 生成一个二维矩阵[a,b],返回一个20*20的矩阵
x, y = np.mgrid[-2:2:20j, -2:2:20j]
z = x * np.exp(-x ** 2 - y ** 2)
# 3d图
ax = plt.subplot(111, projection='3d')
# 从y方向看 rstride:行之间的跨度  cstride:列之间的跨度
ax.plot_surface(x, y, z, rstride=2, cstride=1, cmap=plt.cm.Blues_r)
ax.set_xlabel('X')
ax.set_ylabel('Y')
ax.set_zlabel('Z')
plt.show()

x = np.arange(-4, 4, 0.25)
y = np.arange(-4, 4, 0.25)
# 生成坐标矩阵X，Y
X, Y = np.meshgrid(x, y)
R = np.sqrt(X ** 2 + Y ** 2)
Z = np.sin(R)
ax = plt.subplot(111, projection='3d')
ax.plot_surface(X, Y, Z, rstride=1, cstride=1, cmap=plt.cm.Greens_r)
ax.set_xlabel('X')
ax.set_ylabel('Y')
ax.set_zlabel('Z')
plt.show()