ubuntu下安装MiniConda和 jupyter并进行相应的练习_ubuntu miniconda

---

前言

环境：
1、ubuntu20.0.4
2、VMware16.0

---

一、MiniConda安装

下载地址：miniconda

在文件所在处用终端打开进行安装：

键入下面的命令进行安装：

bash Miniconda3-py38_23.1.0-1-Linux-x86_64.sh 
1

一路点enter，然后输入yes，回车即可完成安装，最后一步会提醒你是否要自动初始化环境，这里我们选择yes。

• 新建一个终端，前面多了一个base,说明安装成功了：
  

• 可以通过下面的命令退出conda环境：

conda deactivate
1

二、jupyter和 numpy安装

• base环境下安装：

pip3 install jupyter -i https://pypi.tuna.tsinghua.edu.cn/simple
1

• 键入下面的语句启动jupyter：

jupyter-notebook
1

点击下面打开单元格：

• 引入 numpy报错，说明没有安装：
  

• 在单元格中输入下面命令安装numpy：

!pip install numpy  -i https://pypi.tuna.tsinghua.edu.cn/simple
1

下载成功：

三、练习

1、numpy的10道基础练习

1、创建一个长度为10的一维全为0的ndarray对象，然后让第5个元素等于1

import numpy as np
s1=np.zeros(shape=10)
s1
1
2
3

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

s1[4]=1
s1
1
2

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

2、创建一个元素为从10到49的ndarray对象

np.random.randint(10,50,size=10)
1

array([29, 34, 36, 38, 42, 46, 20, 10, 34, 28])
1

np.linspace(10,49,10)
1

array([10.        , 14.33333333, 18.66666667, 23.        , 27.33333333,
       31.66666667, 36.        , 40.33333333, 44.66666667, 49.        ])
1
2

a=np.arange(10,50)
a
1
2

array([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, 38, 39, 40, 41, 42, 43,
       44, 45, 46, 47, 48, 49])
1
2
3

3、将第2题的所有元素位置反转

a[::-1]
1

array([49, 48, 47, 46, 45, 44, 43, 42, 41, 40, 39, 38, 37, 36, 35, 34, 33,
       32, 31, 30, 29, 28, 27, 26, 25, 24, 23, 22, 21, 20, 19, 18, 17, 16,
       15, 14, 13, 12, 11, 10])
1
2
3

4、使用np.random.random创建一个10*10的ndarray对象，并打印出最大最小元素

a4=np.random.random(size=(10,10))
a4
1
2

array([[0.57864122, 0.75825205, 0.671457  , 0.01652972, 0.83662473,
        0.07993135, 0.31517659, 0.57477863, 0.94565608, 0.49343344],
       [0.7051955 , 0.08854673, 0.00977959, 0.59359878, 0.83501832,
        0.59548494, 0.99590864, 0.17911834, 0.26063783, 0.06151621],
       [0.68713937, 0.29235894, 0.03071282, 0.0069819 , 0.28939325,
        0.35035552, 0.76373131, 0.70860792, 0.18704257, 0.42649714],
       [0.72537482, 0.19555892, 0.73276841, 0.48774894, 0.38532655,
        0.43165531, 0.60560044, 0.38469067, 0.41840802, 0.71391871],
       [0.74888979, 0.18545503, 0.62210795, 0.16764943, 0.47245473,
        0.73949373, 0.34973878, 0.89478131, 0.2574486 , 0.67459515],
       [0.49782418, 0.78249273, 0.00481123, 0.51504344, 0.02692346,
        0.70258034, 0.78931153, 0.06893658, 0.0275792 , 0.24421366],
       [0.21202118, 0.6368179 , 0.14432268, 0.71477657, 0.67925453,
        0.42254828, 0.20566852, 0.8844454 , 0.57986194, 0.11061856],
       [0.59480983, 0.67130815, 0.71493204, 0.46390142, 0.25450817,
        0.28102949, 0.61794472, 0.63754591, 0.04469933, 0.64122652],
       [0.68132466, 0.60579935, 0.26041903, 0.81581584, 0.41348766,
        0.28581916, 0.82335752, 0.46807092, 0.6238304 , 0.87707721],
       [0.44571048, 0.71596592, 0.5418371 , 0.40256469, 0.00684384,
        0.19073276, 0.49419077, 0.19056293, 0.91979081, 0.03392778]])
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20

zmin,zmax=a4.min(),a4.max()
zmin,zmax
1
2

(0.004811229760691482, 0.995908637507578)
1

5、创建一个10*10的ndarray对象，且矩阵边界全为1，里面全为0

nd=np.zeros(shape=(10,10),dtype=np.int8)
nd[[0,9]]=1
nd[:,[0,9]]=1
nd
1
2
3
4

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

a5=np.ones((10,10))
a5
1
2

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

a5[1:-1,1:-1]=0
a5
1
2

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

6、创建一个每一行都是从0到4的5*5矩阵

l=[0,1,2,3,4]
nd=np.array(l*5)
nd.reshape(5,5)
1
2
3

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

nd6_1=np.arange(0,5,1)
nd6_1
1
2

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

nd6=np.arange(0,25).reshape(5,5)
nd6
1
2

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, 24]])
1
2
3
4
5

nd6[0:5]=nd6_1
nd6
1
2

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

7、创建一个范围在(0,1)之间的长度为12的等差数列

np.linspace(0,1,12)
1

array([0.        , 0.09090909, 0.18181818, 0.27272727, 0.36363636,
       0.45454545, 0.54545455, 0.63636364, 0.72727273, 0.81818182,
       0.90909091, 1.        ])
1
2
3

8、创建一个长度为10的随机数组并排序

a8=np.random.random(10)
a8
1
2

array([0.38322221, 0.94047054, 0.09864148, 0.19621559, 0.17850924,
       0.75333279, 0.26089512, 0.13318057, 0.07681047, 0.10118547])
1
2

np.sort(a8)
1

array([0.07681047, 0.09864148, 0.10118547, 0.13318057, 0.17850924,
       0.19621559, 0.26089512, 0.38322221, 0.75333279, 0.94047054])
1
2

a8.argsort()
1

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

a8[a8.argsort()]
1

array([0.07681047, 0.09864148, 0.10118547, 0.13318057, 0.17850924,
       0.19621559, 0.26089512, 0.38322221, 0.75333279, 0.94047054])
1
2

9、创建一个长度为10的随机数组并将最大值替换为0

nd=np.random.randint(0,10,size=10)
display(nd)
index_max=nd.argmax()
1
2
3

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

nd[index_max]
1

9
1

all_index_max=np.argwhere(nd==nd[index_max]).reshape(-1)
all_index_max
1
2

array([2])
1

nd[all_index_max]=-100
nd
1
2

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

10、如何根据第3列来对一个5*5矩阵排序

n10=np.random.randint(0,100,size=(5,5))
n10
1
2

array([[16, 21, 73, 55, 27],
       [11, 67, 51, 97, 10],
       [62, 16, 76, 14, 42],
       [71, 18, 31, 96,  3],
       [69, 82, 80, 53, 73]])
1
2
3
4
5

n10[:,2]
1

array([73, 51, 76, 31, 80])
1

np.argsort(n10[:,2])
1

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

n10[np.argsort(n10[:,2])]
1

array([[71, 18, 31, 96,  3],
       [11, 67, 51, 97, 10],
       [16, 21, 73, 55, 27],
       [62, 16, 76, 14, 42],
       [69, 82, 80, 53, 73]])
1
2
3
4
5

2、python例题复习

1、定义斐波那契数列推荐事件：

• 代码：

import random
 
def fin_loop(n):
    listNum = []
    a,b = 0,1
    for i in range(n):
        a,b = b,a+b
        listNum.append(a)
    return listNum
 
if __name__ == "__main__":
    listPlan = ['吃零食','学习','学习','学习','看电影','学习','旅游','睡觉','学习']
    listNum = fin_loop(6)
    varIdx = random.randint(0,5)
    varRandom = listNum[varIdx]
    print("今日计划：",listPlan[varRandom])
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16

• 效果：
  

2、数字类型：

数字、字符串、元组均属于不可变数据类型，即如果改变变量的赋值则会重新开辟一块内存空间。此外可变数据类型包括列表、字典、集合。

代码

i=3
print(id(i))
i+=1
print(id(i))
1
2
3
4

• 效果：
  

修改变量值后，地址值不同。

3、字符串的访问(栅栏式)

• 代码：

str='Picture'
print(str[1:3])
print(str[-3:-1])
print(str[3:-1])
print(str[-6:7])
print(str[2:])
print(str*2)
print(str+"TEST")
1
2
3
4
5
6
7
8

• 效果：
  

4、字符串的赋值

由于字符串是不可变类型，所以向一个字符串索引位置赋值会引起错误，要修改字符串内容，只能重新进行赋值，这会生成一个新的变量。

• 代码：

word='Python'
print(word[0],word[5])
print(word[-1],word[-6])
word[0]='Q'
1
2
3
4

• 效果：
  

5、List(列表)类型的访问

列表使用方括号[ ]进行定义，数据项之间使用逗号进行分隔。列表的数据项可以是数字、字符串、也可以是列表。列表的截取语法与字符串类似，但列表中的单个元素可以修改，并且List还内置了很多方法，例如append()、pop()。

• 代码：

list=['a',56,1.13,'HelloWorld',[7,8,9]]
print(list)
print(list[4])
print(list[-2:5])
print(list[2:])
1
2
3
4
5

• 效果：
  

6、列表元素的修改

• 代码：

a=[1,2,3,4,5,6]
a[0]=9
print(a)
a.append(7)
print(a)
a[2:5]=[]
print(a)
a.pop(2)
print(a)
1
2
3
4
5
6
7
8
9

• 效果：
  

7、Tuple(元组)访问

元组写在小括号中，元素之间使用逗号隔开，元素可以具有不同的数据类型，元组的截取方式与字符串和列表都类似，但元组的元素不能修改。虽然元组的元素不可改变，但如果元组内部的数据项是可变的类型，则该数据项可以修改。

• 代码：

tuple=('Spiderman',2017,33.4,'Homecoming',14)
tinytuple=(16,'Marvel')
print(tuple)
print(tuple[0])
print(tuple[3:4])
print(tuple+tinytuple)
1
2
3
4
5
6

• 效果：
  

8、Tuple(元组)修改

• 代码：

tuple=([16,'Marvel'],'Spiderman',2017,33.4,'Homecoming',14)
print(tuple[0])
tuple[0][0]='Marvel'
tuple[0][1]='16'
print(tuple)
1
2
3
4
5

• 效果：
  

因为元组的第一个元素是列表，属于可变的数据类型，所以可以进行修改。

9、字典的使用

• 代码：

# 字典基本操作
dict = {'Name':'jiangjiang','Class':'人工智能与机器学习','Age':10}
# 字典的访问
print("Name：",dict['Name'])
print(dict)
# 添加 add
dict['Gender'] = 'male'
print(dict)
# 修改 update
dict.update({"No":"001"})
dict['Age'] ={8,9,10}
print(dict)
# 也可以使用 update 方法添加/修改多个数据
dict.update({'Gender':'Man','Id':'001'})
print(dict)
# 删除元素
del dict['Gender']
print(dict)
dict.clear()
print(dict)
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20

• 效果：
  

10、Set(集合)类型

• 代码：

# 集合基本操作
# 创建集合
var = set()
print(var,type(var))
var = {'LiLei','HanMeiMei','ZhangHua','LiLei','LiLei'}
print(var,type(var))     # 从输出中可以看出，集合中没有重复元素，与数学集合一致
# 集合成员检测
result = 'LiLei' in var
print(result)
result = 'jiangjiang' in var
print(result)
# 增删改查
var.add('jiangjiang')
print(var)
var.update('pl')        # 该方法首选拆分元素，然后一次添加
print(var)
var.remove('LiLei')     # 这里会删除所有一致元素
print(var)
# 集合的遍历
for item in var:       # 方法1
    print(item)
for item in enumerate(var): # 方法2
    print(item)
# 交集、并集、差集
var1 = set()
var1 = {'jiangjiang','002','003'}
jiaoji = var&var1      # 交集
print(jiaoji)
bingji = var|var1      # 并集
print(bingji)
chaji = var-var1       # 差集
print(chaji)
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

• 效果：
  

3、pandas、matplotlib库例题

1、pandas

Pandas使用强大的数据结构提供高性能的数据操作和分析工具。模块提供了大量的能便捷处理数据的函数、方法和模型，还包括操作大型数据集的工具，从而高效的分析数据。其中，Pandas主要处理以下三种数据结构：Series、DataFrame、Panel，这些数据结构都构建在NumPy数组之上，运算速度很快。

在单元格输入下面命令下载pandas库：

!pip install pandas  -i https://pypi.tuna.tsinghua.edu.cn/simple
1

1、为一个地理位置数据创建Series对象

Series是一种类似于一维数组的对象，它由一种数据以及一组与之相关的数据标签(即索引)组成，数据可以是任何NumPy数据类型(整数、字符串、浮点数、Python对象等)。

• 代码：

import pandas as pd
print('-------  列表创建Series  --------')
s1=pd.Series([1,1,1,1,1])
print(s1)
print('-------  字典创建Series  --------')
s2=pd.Series({'Longitude':39,'Latitude':116,'Temperature':23})
print('First value in s2:',s2['Longitude'])
print('------- 用序列作Series索引 --------')
s3=pd.Series([3.4,0.8,2.1,0.3,1.5],range(5,10))
print('First value in s3:',s3[5])
1
2
3
4
5
6
7
8
9
10

• 效果：
  

2、DataFrame对象

DataFrame是一个表格型的数据结构，包含一组有序数列。列索引对应表格的字段名，行索引对应表格的行号，值是一个二维数组。每列表示一个独立的属性，各个列的数据类型可以不同。下面简单创建一个DataFrame对象：

• 代码：

import pandas as pd
dict1={'col':[1,2,5,7],'col2':['a','b','c','d']}
df=pd.DataFrame(dict1)
df
1
2
3
4

• 效果：

3、Pandas求方差

• 代码：

import numpy as np
import pandas as pd
a=np.arange(0,60,5)
a=a.reshape(3,4)
df=pd.DataFrame(a)
print(df)
print('-------------------')
print(df.std())
1
2
3
4
5
6
7
8

• 效果：
  

2、matplotlib

Matplotlib是Python的一个基本2D绘图库，它提供了很多参数，可以通过参数控制样式、属性等，生成跨平台的出版质量级别的图像。使用Matplotlib，能让复杂的工作变得容易，可以生成直方图、条形图、散点图、曲线图等。Matplotlib可用于Python scripts、Python、IPython、Jupyter Notebook、Web应用服务器等。

在单元格输入下面命令下载matplotlib库：

!pip install matplotlib  -i https://pypi.tuna.tsinghua.edu.cn/simple
1

1、绘制简单的plot表格

• 代码：

import matplotlib.pyplot as plt
fig=plt.figure()
ax1=fig.add_subplot(2,2,1)
ax2=fig.add_subplot(2,2,2)
1
2
3
4

• 效果：
  

2、绘制多条简单直线

• 代码：

import matplotlib.pyplot as plt
import numpy as np
a=np.arange(10)
plt.xlabel('x')
plt.ylabel('y')
plt.plot(a,a*1.5,a,a*2.5,a,a*3.5,a,a*4.5)
plt.legend(['1.5x','2.5x','3.5x','4.5x'])
plt.title('simple lines')
plt.show()
1
2
3
4
5
6
7
8
9

• 效果：
  

3、绘制sin(x)函数图像

• 代码：

import matplotlib.pyplot as plt
import numpy as np
x=np.linspace(-10,10,100) #列举出100个数据点
y=np.sin(x)  #计算出对应的y
plt.plot(x,y,marker="o")
1
2
3
4
5

• 效果：
  

**补充：**在base环境下的命令行环境下使用pip或者apt-get下载这两个库容易失败并且有可能下载完了以后，在单元格进行引入还会报错，所以建议使用上面的方法。

四、什么是图灵测试

图灵测试是一种对机器进行判断是否具有人工智能的测试。
定义：

图灵测试是指测试者与被测试者（一个人和一台机器）隔开的情况下，通过一些装置（如键盘）向被测试者随意提问。进行多次测试后，如果机器让平均每个参与者做出超过30%的误判，那么这台机器就通过了测试，并被认为具有人类智能。

进展：

还没有一台机器能够通过图灵测试，也就是说，计算机的智力与人类相比还差得远呢。比如自动聊天机器人。同时图灵试验还存在一个问题，如果一个机器具备了“类智能”运算能力，那么通过图灵试验的时间会延长，那么多长时间合适呢，这也是后继科研人员正在研究的问题。

---

五、总结

Conda可以快速安装、运行和更新软件包及其依赖项。所以相比于conda的大体积我选择了miniconda更加的小和易用。第一次接触到 jupyter，对这种单元格式的编程还是一种新鲜的尝试。Conda是在Windows、macOS和Linux上运行的开源软件包管理系统和环境管理系统。通过这次的学习，还稍微学习了一些python，方便了后面的学习。再者就是体会到了使用numpy、pandas、matplotlib进行运算的便捷性。

六、参考资料

什么是图灵测试
20道numpy练习题
Jupyter Notebook介绍、安装及使用教程