1.Python简介
Python特性：
（1）易读性：Python的语法结构层次分明，语法逻辑简单易懂。
（2）解释性：在Python中去除了编译环节和链接环节，这些修改提升了语言的解释性，提升了程序的开发效率，所以Python进行程序开发能够相对缩短开发周期。
（3）可移植性：因为Python在设计之初就是一门面向开源的编程语言，而开源的一大特性就是兼容性，所以Python能够被众多平台移植和使用。
（4）可扩展性：Python能够使用其他程序语言实现自身的扩展。
（5）交互性：Python提供了很多实时交互的软件，而且本身自带交互功能，我们可以使用Python自带的交互提示，以互动的方式执行我们的程序，这样还能方便程序的调试和维护。
（6）面向对象：Python还是一门面向对象的编程语言，在Python中提供了支持面向对象的程序设计和对象封装的编程技术。
（7）初学者语言：Python对于初学者而言，是一种易于理解和掌握的编程语言，有相对较少的关键字，而且结构简单，有明确定义的语法，更容易学习；Python对代码的定义更清晰，还有完备的开源社区和大量的开源库可供学习和使用 ，对主流的操作系统如UNIX、Wimdows、iOS等也有极强的兼容性。
2.Jupyter Notebook
（1）Anaconda的安装与使用。
安装后出现问题以及解决办法
**问题1 打开Anaconda Navigator闪退解决 **
第一步：使用管理员运行：conda prompt
第二步：执行命令 conda update anaconda-navigator
第三步：执行anaconda-navigator --reset
第四步：执行conda update anaconda-client
第五步：执行conda update -f anaconda-client
问题2 安装Anaconda之后在电脑终端输入conda list 显示conda不是内部或外部命令之解决办法
- cmd进入电脑终端，输入path查看系统环境变量。我这个是已经为conda配置好环境变量的，所以在下图最后两行可以看到其路径：“C:\Users*\Anaconda3”和“C:\Users**\Anaconda3\Scripts”。如果conda报错那么就没有这两条路径。
2.添加环境变量，记得是添加而不是修改，修改的话覆盖原有的环境变量而影响其他软件。在终端输入这两条语句：
“set path=%path%;C:\Users*\Anaconda3” 和 “set path=%path%;C:\Users\。。。\Anaconda3\Scripts” 如下图所示。注意，如果你把Anaconda安装在其他路径下就改一下路径就行了，总之得是英文路径。
原文链接：https://blog.csdn.net/qq_38668281/article/details/84334720
（2）Jupyter Notebook的安装和使用。
安装：在CMD命令行窗口中输入“conda install jupyter”并回车。
开启Jupyter Notebook：jupyter notebook
安装后出现问题以及解决办法
**问题1 启动Jupyter Notebook提示ImportError: DLL load failed: 找不到指定的模块 **
将anaconda安装路径里面的Scripts和Library\bin路径添加到系统环境变量中
Jupyter Notebook的使用
Notebook文件：*.ipynb
在Jupyter Notebook的web应用程序主界面中包含以下操作元素：
1)Files:用于显示当前目录下所有文件的信息，还可以通过不同的筛选方式找到主目录下相应的文件并进行选择和操作。
Folders：用于选取当前目录下的所有子文件；
All Notebooks：用于选取当前目录下的所有Notebook文件；
Running：用于选取当前目录下所有正在运行的Notebook文件；
Files：用于选取当前目录下所有文件夹类型的文件；
在通过筛选方式选出相应的文件后，相应的操作信息也会被显示出来，而且不同类别的文件对应不同的操作方法。
2)Running:用于显示正在运行的Notebook文件。
shutdown：这个选项用于强制关闭正在运行的Notebook文件；
3）New:用于创建新的文件。新建文件主要有两个类别可供选择，分别是Notebook文件和Other文件。
如果我们选择的是Notebook文件中的Python3，那么系统会新建一个支持Python3.5版本的Notebook文件，这个文件具体支持哪个Python版本，是根据我们在启动Jupyter Notebook应用程序时所在的环境下安装的Python版本而定的。
如果我们选择的是Other文件中的Text File或Folder，那么系统会新建一个空的文本文件或文件夹。
新建Notebook文件： New->Python3
默认文件名：Untitled+数字
修改文件名：双击当前文件名，改完之后选Rename
Notebook主界面的第2行显示的是一列菜单工具栏，在这一列菜单工具栏中常用的是File和Kernel这两个菜单选项
单击File后出现的菜单栏中：
1)New Notebook：用于创建新的Notebook文件，在创建完成后会直接进入新的Notebook文件，在创建完成后会直接进入新的Notebook文件的主界面。
2）Open：用于选取我们需要打开的文件，如果文件不在当前默认的目录下，则需要通过目录切换找到文件并载入。
3）Rename：重命名当前打开的Notebook文件。
4）Download as：将当前打开的Notebook文件保存为哦指定的文件格式，可以选择后缀名为ipynb的Notebook文件，也可以选择后缀名为html的HTML文件和后缀名为md的Markdown文件。
单击Kernel后出现的菜单栏中：
1）Restart：重启当前Notebook文件的Kernel。
2）Restart&Clear Output：重启当前Notebook文件的Kernel，并清空因运行代码而出现在Notebook文件中的内容。
3）Restart&Run All：重启当前Notebook文件的Kernel，在重启完成后重新运行Notebook文件的输入单元中的全部代码。
4）Shutdown：强制关闭当前Notebook文件的Kernel，在关闭后如需重新使用，则要动手激活当前文件的Kernel。
Notebook文件主界面的第3行是一系列快捷操作图标：
从左至右代表的快捷操作分别是保存当前 Notebook 文件、增加Notebook文件中新的输入单元、剪切被选中的输入单元、复制被选中的输入单元、粘贴被选中的输入单元、上移被选中的输入单元、下移被选中的输入单元、运行被选中的输入单元、暂停和刷新 Notebook 文件的 Kernel，最后一个选项指定被选中的输入单元的内容编辑模式。而我们最常用的是前面两种内容编辑模式： Code 模式和 Markdown 模式。
1)Code模式：在Code模式下，我们在输入单元中输入的内容必须是代码才能运行，我们在运行输入单元中的内容后会马上得到Notebook文件的反馈信息，比如，使用Python代码的打印函数，所以在输入单元被运行后，“Hello World！”被打印输出在Notebook文件中。
同时，我们可以看到输入单元最前面的内容In[ ]变成了In[1]，这表明这个输入单元目前已经被运行了一次，如果同一个输入单元被运行了多次，那么括号中的数字还会累加。
2）Markdown模式：在Markdown模式下，Notebook文件的输入单元变成了一种文本编辑器，我们可以通过不同的设置让输入单元中的内容被运行后显示不同的字体、大小、格式等。
井号和标题的对应级别：一个井号对应一级标题，两个井号对应二级标题，以此类推。
快捷键
当处于命令模式时 ，我们常用的快捷键 下。
( 1) Enter 进入编辑模式
( 2) Esc ：退出编辑模式，进入命令模式
(3) Shift-Enter：运行当前选中的输入单元中的内容，并选中下 个输入单元。
( 4) Ctrl-Enter：仅运行当前选中的输入单元中的内容。
( 5) Alt-Enter： 运行当前选中的输入单元中的内容，并在选中的输入单元之后插入新的输入单元。
( 6) 1:将输入单元的内容编辑模式设置为 Markdown模式，并在输入单元中的内容的开始处添加一级标题对应的井号个数和一个空格字符。
( 7) 2：将输入单元的内容编辑模式设置为 Markdown 模式，并在输入单元中的内容的开始处添加二级标题对应的井号数和 空格字符。
( 8)3 ：将输入单元的内容编辑模式设置为 Markdown 模式并在输入单元中的内容的开始处添加三级标题对应的井号个数和一个空格字符。
( 9) 4：将输入单元的内容编辑模式设置为 Markdown 模式并在输入单元中的内容的开始处添加四级标题对应的井号个数和一个空格字符。
( 10)5 ：将输入单元的内容编辑模式设置为 Markdown 模式，并在输入单元中的内容的开始处添加五级标题对应的井号数和 个空格字符。
( 11) 6：将输入单元 的内 容编辑模式设置为 Markdown 模式，并在输入单元中的内容的开始处添加六级标题对应的井号数和一个空格字符。
(12) Y：将输入单元的内容编辑模式设置为Code 模式。
(13) M：将输入单元的内容编辑模式设置为 Markdown 模式。
(14) A：在当前的输入单元 的上方插入新的输入单元。
(15) B：在当前的输入单元的下方插入新的输入单元。
(16) D：删除当前选中的输入单元。
(17) X：剪切当前选中的输入单元。
(18) C：复制当前选中的输入单元。
（19) Shift-V：将复制或者剪切的输入单元粘贴到选定的输入单元上方。
(20)V ：将复制或者剪切的输入单元粘贴到选定的输入单元下方。
( 21）Z：恢复删除的最后一个输入单元。
(22) S：保存当前正在编辑的 Notebook 文件。
(23) L：在Notebook 的所有输入单元前显示行号。
当处于编辑模式时，我们常用的快捷键如下。
（1) Enter ：进入编辑模式。
（ 2) Esc ：退出编辑模式，进入命令模式。
(3) Tab：如果输入单元的内容编辑模式为 Code 模式，则可以通过该快捷键对不完整的代码进行补全或缩进。
（ 4) Shift-Tab：如果输入单元的内容编辑模式为Code 模式， 则可以通过该快捷键显示被选取的代码的相关提示信息。
( 5) Shift-Enter：运行当前边中的输入单元中的内容并选中下一个输入单元，在运行后会退出编辑模式并进入命令模式。
(6) Ctrl-Enter：仅运行当前选中的输入单元中的内容，在运行后会退出编辑模式并进入命令模式。
( 7) Alt-Enter：运行当前选中的输入单元中的内容，并在选中的输入单元之后插入新的输入单元，在运行后会退出编辑模式并进入命令模式。
(8) PageUp：将光标上移到输入单元的内容前面。
( 9) PageDown：将光标下移到输入单元的内容后面。
3.Python入门
（1）Python的基本语法
1)打印输出
在Python中使用print语句来完成代码的打印输出，而且默认对打印输出的结果进行自动换行，所以如果我们写了多个print语句，则会发现每个print语句打印输出的内容自成一行。
如果我们想在一行中对多个独立的内容进行打印输出，则需要在代码在使用dou’h5将这些独立的内容分开；
如果我们想对某个内容自定义重复打印输出的次数，则可以在代码中通过乘以一个数字来实现。
2）代码中的注释
在Python中可以通过在开头添加井号（#）来标注我们想要注释的内容。
注意，一个井号只能完成对一行内容进行注释。如果需要对多行内容进行注释，则可以使用三个单引号(’’’)或三个双引号(""")，使用的位置是被注释内容的第一行和最后一行。
3）代码的缩进
在Python中代码的缩进有着特别的意义。Python通过对每行代码使用不同的缩进来控制语法的判断逻辑，让程序知道有相同缩进的代码构成的是同一个逻辑代码块，而大部分编程语言使用大括号（{}）来帮助识别代码的逻辑代码块，从而完成逻辑的判断。
在Python中代码的缩进使用的是空格，所以必须严格控制空格的使用数量，对同一层次的逻辑代码块必须使用相同的缩进，如果缩进使用的空格数量不同，则会导致程序的逻辑出现错误。
在写Python代码时按如下原则来控制缩进字符的使用数量：在第1个逻辑代码块中不使用缩进，而在第2个逻辑代码块中使用一个空格来缩进，在第3个逻辑代码块中使用两个空格来缩进。以此类推，通过逐层增加缩进字符的使用数量来表示不同的逻辑代码块。
缩进相同的一组语句可以构成同一个逻辑代码块，不过对于复合语句而言会有一些小小的差异。复合语句有个很大的特点，就是在第1行语句结束后会使用冒号（：）作为结尾，在冒号之后新起的一行或者多行代码会被默认为归属于复合语句下的一个逻辑代码块，所以在这个逻辑代码块中使用的缩进字符的数量必须保持一致，循环语句、判断语句等常用的复合语句都要遵守这个约定。
4）多行语句的分割
在Python中可以使用斜杠（\）来将原本完整的一行代码分割成多行，虽然代码被分割成了多行，但是这些代码仍然是一个完整的整体，所以在Python中使用的分割方法比较简单且容易操作。
（2）Python变量
在Python中，我们通过定义变量来存储不同类型的数据，所以对变量的命名也是非常关键的，最好使用与需要存储的数据相对应的名字。
int_num=10
float_num=10.00
string=“Hello,World”
以上是变量的点对点的赋值操作过程，在实际应用中还可以有点对多点和多点对多点的变量赋值操作。
点对多点的变量赋值操作其实就是将一个数据在一次赋值操作中同时传递给已经定义好的多个变量。
string1=string2=string3=“Hello,World”
另外，多点对多点其实就是在一条语句中将多个数据赋值给多个变量，不过赋值的数据个数和定义的变量个数要相等，并且位置要一一对应，在改变位置后会得到截然不同的结果。
（3）常用的数据类型
1)数字
常用的数字数据类型有整型（int）和浮点型（folat）。
我们可以自定义浮点数打印输出的精度：
float_num=10.000
print(float_num)
print("%f" % float_num)
print("%.2f" % float_num)
print("%.4f" % float_num)
2）字符串
字符串数据类型是由字母、数字和下划线等特殊符号组成的一连串字符表示，使用单引号（’ '）或者双引号（" "）来标识赋值给变量的数据。
string1=‘Hello,World_01’
string2=“Hello,World_02”
print(string1)
print(string2)
代码中的string1和string2变量均包含了14个字符。对于这类长字符串变量，可以使用索引值对变量中的字符进行操作，通过使用变量的索引值，我们不仅可以随意提取变量中的字符，还可以通过相应的操作生成新的字符串。索引值从左到右的取值范围是0~13，从右到左的范围是-1 ~ -14。
索引值操作方法，如果想选取特定位置的字符，则只需在变量后加上[索引值]；如果想选取特定位置的字符串，则需要在变量后加上[前索引值:后索引值]，其中后索引值对应的字符不会被提取，结束字符是后索引值的前一个字符，若前索引值或后索引值为空，则表示获取前索引以前的全部字符串或后索引以后的全部字符。
3)列表
列表是一种容器型数据类型，容器型数据类型的最大特点就是可以实现多种数据类型的嵌套，所以我们可以在列表中将数字、字符串等类型的数据嵌套到列表中，甚至能够在列表中嵌套列表。列表的索引值的使用规则和字符串一样。
因为列表具备了容器的特性，所以我们可以对列表中的元素进行重新赋值。重新赋值相当于对旧数据进行了一次覆盖操作。
4)元组
元组是另一种容器型数据类型，用圆括号（()）进行标识，它的基本性质、索引值操作和列表是一样的，其最大的区别就是元组内的元素不能重新赋值，如果定义好了一个元组，那么它内部的元素就固定了，所以元组也被称作只读型列表。这个只读的特性也非常有用，可以应用于不需要重新赋值的场景下。
5）字典
字典虽然也是一种容器型数据类型，但是相较于列表和元组，具有更灵活的操作和复杂的性质，相应的，对字典数据类型的操作也更有难度。其中一个区别就是列表和元组是有序的元素集合，字典却是一组无序的元素集合，虽然是无序的，但是为了达到对字典内元素的可操控性，在字典的每个元素中都会加入相应的键值。若我们需要对字典中元素的值进行赋值或者重新赋值等，则只能通过元素对应的键值来进行，而不能使用在列表和元组中操作索引值的方法。
（4）Python运算
1）算术运算符
算术运算符是我们对变量进行算术运算时用到的符号，不同的符号代表了不同的算术运算方式，常用的算术运算符如下：
【1】加法、减法、乘法、除法算术运算符：使用符号“+、-、
- 、/”表示，对符号前后的变量进行相加、相减、相乘、相除运算。
【2】取模运算符：使用符号“%”表示，符号前的变量以符号后的变量为模进行取模运算。
【3】求幂运算符：使用符号“ ** ”表示，符号前的变量以符号后的变量为幂进行求幂运算。
【4】取整运算符：使用符号“//”表示，符号前的变量以符号后的变量为底进行取整运算。
2）比较运算符
比较运算符主要用于对比较运算符前后的变量进行比较，然后返回一个布尔值。布尔值也是一种数据类型，不过布尔型数据的值只有两个，分别是真值（True）和假值（False）。
单层比较：
a=5
b=2
print(a==b)
print(a!=b)
print(a>b)
print(a>=b)
print(a<b)
print(a<=b)
多层比较：
a=5
b=2
c=4
print(abc)
print(a>b>c)
print(a<b<c)
3）布尔运算符
我们最常用的布尔运算符是与、或、非这三个，并且这三个布尔运算符后返回的运算结果值也是布尔型的。
a=True
b=False
print(a and b)
print(a or b)
print(not a)
通过比较运算和布尔运算进行融合来构造一个相对复杂的布尔运算：
a=2
b=1
c=3
print(a>b and a<b) #F
print(a>b or a<b) #T
print(not a<b) #T
print(not a>b) #F
print(a>b and ca) #F
print(a>b or aa) #T
print(a>b or aa) #T
print(a>b and aa) #T
4）成员运算符
若我们已经拥有一个目标列表，则当我们想判断某个元素是否是目标列表中的元素时，就可以使用成员运算符进行操作，使用成员运算符进行运算后返回的值是布尔型的。最典型的成员运算符是“in”。
list_1=[“I”,“am”,“super”,“man”]
a=“super”
b=1
print(a in list_1) #T
print(b in list_1) #F
如上所示，我们首先定义了一个目标列表和两个变量a、b，然后通过成员运算符判断变量a的值和变量b的值是否在目标列表中，如果在，则返回布尔值True，否则返回布尔值False。
5）身份运算符
**以变量为例，身份运算符用于判断我们比较的变量是否是同一个对象，或者定义的这些变量是否指向相同的内存地址。**身份运算符在进行运算后返回的值同样是布尔型的。常用的身份运算符是“is”和“is not”。
a=500
b=500
print(“a的内存地址：”,id(a))
print(“b的内存地址：”,id(b))
print(“a is b”,a is b)
print(“a is not b”,a is not b)
print("ab",ab)
a=10
b=10
print(“a的内存地址：”,id(a))
print(“b的内存地址：”,id(b))
print(“a is b”,a is b)
print(“a is not b”,a is not b)
print("ab",ab)
运行结果：
a的内存地址： 2458839687216
b的内存地址： 2458839687312
a is b False
a is not b True
ab True
a的内存地址： 140737195844272
b的内存地址： 140737195844272
a is b True
a is not b False
ab True
代码中的id函数用于返回我们所定义的变量的内存地址。可以看到，只要变量指向的内存地址相同，那么使用身份运算符运算后返回的结果就是True，否则返回的结果是False。
不过上面有个很奇怪的地方，就是在赋值给变量a和变量b的值为10时，它们的内存地址是一样的，但是在赋值给变量a和b的值为500时，它们的内存地址就不一样了，这其实是Python的解释器引起的问题。
在代码中我们还使用了等于运算符来比较变量a和变量b，可见**“is”和“==”运算有着本质的区别， 后者仅仅比较变量值是否相等，而前者比较变量是否属于同一个对象。**
（5）Python条件判断语句
条件判断语句用于通过对给定的条件进行判断来确定接下来是否执行指定的代码块，最简单的条件判断语句的设计方式就是：如果满足已经给定的条件，就执行指定的代码块，否则进行其他操作，定义的其他操作也可以是另一个代码块或者不做任何处理。
在条件判断语句中有4种常见的条件判断形式，但其使用的关键词只有三个，分别是if、elif和else。
（6）Python循环语句
循环语句要做的是先定义一个循环条件，当满足循环条件的情况发生时，就会执行我们事先定义好的内容代码块，如果一直满足循环条件，就会一直执行下去。循环语句和之前介绍的条件判断语句不同，循环语句只有满足条件就能够反复执行，如果使用得当，就可以减少很多重复的工作。
在Python中最常用的循环语句有两种，分别是while循环和for循环。除了循环语句，还有三种常用的循环控制语句，分别是break、continue和pass：
【1】break：出现在循环代码块中，用于中断当次循环并结束整个循环语句。
【2】continue：出现在循环代码块中，用于中断当次循环并直接开始下次循环。
【3】pass：出现在循环代码块中，不做任何操作，继续执行当次循环中的后续代码。该循环控制语句主要用于保持代码块的完整性。
#通过while循环语句构建一个循环
number=0
while (number < 10):
print(“The number is”,number)
number+=1
#使用for循环语句来构建一个循环
number=10
for i in range(10):
if i<number:
print(“The number is”,i)
通过以上内容，我们知道了while和for循环语句之间的区别和联系，接下来通过实例看看如何使用之前提到的循环控制语句：
number=10
for i in range(10):
if i==5:
break
if i<number:
print(“The number is”,i)
运行结果：
The number is 0
The number is 1
The number is 2
The number is 3
The number is 4
在以上代码中定义了触发break循环控制语句的条件是变量i的值等于5，不过，在break循环控制语句没有被触发前，循环一直在打印输出变量i的值，而在break循环控制语句之后，整个循环语句就直接结束了。
number=10
for i in range(10):
if i==5:
continue
if i<number:
print(“The number is”,i)
运行结果：
The number is 0
The number is 1
The number is 2
The number is 3
The number is 4
The number is 6
The number is 7
The number is 8
The number is 9
在最后的打印输出结果中我们发现少了数字5。在以上代码中我们定义的continue循环控制语句的触发条件和break循环控制语句的是一样的，但是在continue循环控制语句被触发后，受影响的仅仅是当次循环，所以导致当次循环没有进行打印输出，但是之后的循环过程没有受到任何影响。
number=10
for i in range(10):
if i==5:
pass
if i<number:
print(“The number is”,i)
运行结果：
The number is 0
The number is 1
The number is 2
The number is 3
The number is 4
The number is 5
The number is 6
The number is 7
The number is 8
The number is 9
代码中的pass语句不执行任何处理和操作，但是循环并没有卡壳，而是继续执行了下去，整个循环代码的运行没有任何异常。
除了以上内容，还有个非常实用的操作，就是通过使用循环完成列表的迭代，通过对列表的迭代可以遍历列表中的每个元素。
a_list=[1,2,3,4,5,6]
for i in a_list:
print(i)
运行结果：
1
2
3
4
5
6
（7）Python中的函数
编程语言中的函数就是一组按照相应的规则编写的能够实现相关功能的代码块，Python中的函数也是这样的。通过对函数的使用，代码具备了模块化的性质，降低了代码编写的重复性。在Python中已经存在许多优秀的函数库，可供我们设计程序时使用，不过要想满足一些个性化需求，使用自定义的函数会更方便。
1)定义函数
定义函数需要遵守的通用规则：
【1】在定义的函数代码块开头要使用def关键词，而且在关键词后需要紧跟函数名称和括号（（）），在括号内定义在函数被调用时需要传入的参数，在括号后以（：）结尾。
【2】在函数内同一个逻辑代码块需要使用相同的空格缩进。
【3】在函数代码块的最后，我们可以通过return关键词返回一个值给调用该函数的方法，如果在return后没有接任何内容或者在代码段中根本没有使用return关键词，那么函数默认返回一个空值（None）给调用该函数的方法。
不需要进行参数传递的函数的调用实例：
def function():
print(“Hello,World.”)
return
a=function()
print(a)
运行结果：
Hello,World.
None
因为我们定义的函数不需要进行参数传递，所以在调用该函数时括号内的内容必须留空，不然会报错。
在函数被调用的过程中发生参数传递的实例如下：
def function(string=‘Hi’):
print(“What you say is:”,string)
return
function()
function(string=“Hello,World.”)
运行结果：
What you say is: Hi
What you say is: Hello,World.
虽然函数被定义成了可传递参数的函数，但是**在实际使用中我们可以传递参数给这个函数，也可以不传递参数给这个函数。**在不传递参数给这个函数时，函数本身也不会报错，而是使用函数定义默认参数，这和无参数传递的函数是有明显区别的。如果在调用函数时传递了合法的参数，在该函数中就会使用我们传递的参数来进行相应的操作，而不再使用默认的参数。
2）函数的参数
在定义附带参数的函数时会涉及参数的传递方式，但是在函数中参数的传递方式又与定义的参数类别有非常大的联系。下面简要说明在参数传递的过程中经常会用到的几种参数类别:
1）必备参数：如果函数定义的参数是必备参数，那么在调用该函数时必须将相应的参数传递给函数，否则程序会报错。
2）关键字参数：关键字参数和函数的调用关系很紧密，在函数调用时使用关键字参数来确定传入的参数值，在传递时调换关键字的位置不会对最终的参数传递顺序产生影响。
3）默认参数：使用默认参数的函数，在调用函数时如果我们没有对该函数进行参数传递，那么该函数使用的参数就是其已经定义的默认参数。
4）不定长参数：当我们需要传递给函数的参数比函数声明时的参数要多很多时，我们就可以使用不定长参数来完成。
#定义必备参数
def function1(string):
print(“What you say is:”,string)
return
#定义默认参数
def function2(string=“Hi”):
print(“What you say is:”,string)
return
def function3(string2=“World”,string1=“Hello”):
print(“What you say is:”,string1,string2)
return
#定义不定长参数
def function4(arg1,*arg2):
print(arg1)
for i in arg2:
print(i)
return
function1(“Hello,World.”)
function2()
function3()
function4(10,1,2,3,4)
运行结果：
What you say is: Hello,World.
What you say is: Hi
What you say is: Hello World
10
1
2
3
4
（8）Python中的类
类是用来描述具有相同属性和方法的对象的集合，定义了该集合中每个对象所共有的属性和方法，对象则是类的实例。
1）类的创建
在Python中使用class关键词来创建一个类，在class关键词之后紧接着的是类的名称，以冒号（：）结尾。在类的创建过程中需要注意的事项如下：
【1】类变量：在创建的类中会定义一些变量，我们把这些变量叫作类变量，类变量的值在这个类的所有实例之间是共享的，同时内部类或者外部类也能对这个变量的值进行访问。
【2】init()：是类的初始化方法，我们在创建一个类的实例时就会调用一次这个方法。
【3】self：代表类的实例，在定义类的方法时是必须要有的，但是在调用时不必传入参数。
class Student:
student_Count=0
def _init_(self,name,age):
self.name=name
self.age=age
Student.student_Count +=1
def dis_student(self):
print("Student name:",self.name,"Student age:",self.age)
student1=Student("Tang","20") #创建第1个Student对象
student2=Student("Wu","22") #创建第2个Student对象
student1.dis_student()
student2.dis_student()
print("Tatal Student:",Student_Count)
2）类的继承
我们可以将继承理解为：定义一个类，通过继承获得另一个类的所有方法，被继承的类叫作父类，进行继承的类叫作**子类。**这样可以有效的解决代码的重用问题，在提升了代码的效率和利用率的基础上还增加了可扩展性。
不过需要注意的是：当一个类被继承时，这个类的类初始化方法是不会被自动调用的，所以我们需要在子类中重新定义类的初始化方法；另外，我们在使用Python代码去调用某个方法时，默认会先在所在的类中进行查找，如果没有找到，则判断所在的类是否为子类，如果为子类，就继续到父类中查找。
class People:
def _intit_(self,name,age):
self.name=name
self.age=age
def dis_name(self):
print("name is:",self.name)
def set_age(self,age):
self.age=age
def dis_age(self):
print("age is:",self.age)
class Student(People):
def init(self,name,age,school_name):
self.name=name
self.age=age
self.school_name=school_name
def dis_student(self):
print("school name is:",self.school_name)
student=Student("Wu","20","GLD2")
student.dis_student() #调用子类的方法
student.dis_name() #调用父类的方法
student.dis_age() #调用父类的方法
student.dis_age(22) #调用父类的方法
student.dis_age()# 调用父类的方法
3）类的重写
在继承一个类后，父类中的很多方法也许就不能满足我们现有的需求了，这时我们就要对类进行重写。
class Parent: #定义父类
def _init_(self):
pass
def print_info(self):
print("This is Parent.")
class Child(Parent): #定义子类
def _init_(self):
pass
def print_info(self):#对父类的方法进行重写
print("This is Child.")
child=Child()
child.print_info()
4.Python中的Numpy
Numpy是一个高性能的科学计算和数据分析基础包，在现在的数据分析领域有很多应用，这得益于NumPy的多维数组对象、线性代数、傅里叶变换和随机数等强大功能。
（1）NumPy
Numpy的安装：运行”pip install numpy"语句对NumPy进行安装。
安装后显示：
Requirement already satisfied: numpy in c:\users\16550.000\anaconda3\lib\site-packages (1.18.1)
Note: you may need to restart the kernel to use updated packages.
在输入”inport numpy“运行后没有报错，说明NumPy已经正确安装并可以使用了。
（2）多维数组
在NumPy中非常重要的一个应用就是其多维数组对象。
1）创建多维数组
这里介绍如何创建一个多维数组，常用的方法是使用NumPy中的array。
import numpy as np
np.array([1,2,3])
运行结果：
array([1, 2, 3])
在以上代码中创建的是一个一维数组，其方法是直接在array中传入一个带有参数的列表，这个列表会被转换成数组。
接下来看看如何创建一个更高维度的数组。
import numpy as np
np.array([[1,2,3],[4,5,6]])
运行结果：
array([[1, 2, 3],
[4, 5, 6]])
创建更高维数组的方法和一维数组差不多，只不过变成了把一个嵌套的列表作为参数传递给array。
直接将一串数字作为参数传递给array来创建一个数组是不合法的，如果我们传递给array的参数是列表，则列表会被array当作一个不定长参数进行处理，但若传递给array的参数是一串数字，则会被array当作多个参数而不能处理。
在NumPy中有许多方法可以创建维度指定的临时数组。
【1】：使用NumPy中的ones可以创建维度指定且元素全为1的数组。
import numpy as np
np.ones([2,3])#创建全为1的数组
运行结果：array([[1., 1., 1.],
[1., 1., 1.]])
在以上代码中使用ones生成了一个元素全为1且维度为（2,3）的数组，传递给ones的参数是一个列表，如果使用元组，则也能够达到一样的效果。这样，一个可用来进行临时数据存放的数组就创建完成了，之后若要更新这个数组中的元素，则直接进行覆盖就可以了。
import numpy as np
a=np.ones([2,3]) #创建全为1的数组
a[1,2]=2 #对数组中的元素进行覆盖
print(a)
运行结果：
[[1. 1. 1.]
[1. 1. 2.]]
【2】使用NumPy中的zeros可以创建维度指定且元素全为0的数组。
import numpy as np
np.zeros([2,3])#创建全0的数组
运行结果：
array([[0., 0., 0.],
[0., 0., 0.]])
【3】使用NumPy中的empty可以创建维度指定且元素全为随机数的数组。
import numpy as np
np.empty([2,3]) #创建随机初始化的数组
运行结果：
array([[0., 0., 0.],
[0., 0., 0.]])（？？？）
2)多维数组中的常用属性
【1】ndim：返回统计的数组维度，即维度的数量。
import numpy as np
a=np.ones([2,3]) #创建全为1的数组
a.ndim
运行结果：2（2维数组）
【2】shape：返回数组的纬度值，对返回的结果使用一个数据类型为整型的元组来表示，比如一个二维数组返回的结果为（n,m），那么n和m表示数组中对应维度的数据的长度。
如果使用shape输出的是矩阵的维度，那么在输出的（n,m）中，n表示矩阵的行，m表示矩阵的列。
import numpy as np
a=np.ones([2,3])
print(a)
print(a.shape)
运行结果：
[[1. 1. 1.]
[1. 1. 1.]]
(2, 3)
在以上代码中输出的数组维度为（2，3），其中2表示第1个维度的数据长度为2（即有两行），只要我们把以上代码的数组中的[1.1.1.]看作一个整体，那么在数组中就只有两个数据。然后我们把以上代码的数组中的[1.1.1.]看作第2个维度的数据，那么第2个维度的数据长度是3，所以数组的维度是（2，3）。
查看矩阵维度的方法如下：
import numpy as np
a=np.matrix([[2,3],[3,4]])
print(a)
print(a.shape)
运行结果：
[[2 3]
[3 4]]
(2, 2)
在以上代码中使用了np.matrix来搭建矩阵，搭建矩阵需要传递的参数和使用array搭建数组时传递参数的方法一样。
【3】size：返回要统计的数组中的元素的总数量。
import numpy as np
a=np.ones([2,3]) #创建全为1的数组
print(a.size)
运行结果：6
【4】dtype：返回数组中的元素的数据类型。不过其显示的数据类型和我们之前定义的变量的数据类型名有所区别，因为这些数据类型都是使用NumPy进行定义的，而在NumPy中表示数据类型使用的是numpy.int32、numpy.int16和numpy.float64这类格式的名字。
import numpy as np
a=np.ones([2,3]) #创建全为1的数组
a.dtype
运行结果：dtype(‘float64’)
若想要重新改写现有元素的数据类型，则可以通过如下方法进行，不过只能使用在NumPy中定义的数据类型的名字。
import numpy as np
a=np.ones([2,3],dtype=np.int32) #创建全为1的数组
a.dtype
运行结果：dtype(‘int32’)
【5】itemsize：返回数组中每个元素的字节大小。比如元素的dtype是float64，那么其itemsize是8，计算方法是8=64/8；如果元素的dtype是complex32，那么其itemsize是4，计算方法是4=32/8，其他dtype的计算方法以此类推。
import numpy as np
a=np.ones([2,3],dtype=np.int32) #创建全为1的数组
a.itemsize
运行结果：4
3）数组的打印
数组可以通过print进行打印输出，打印出的数组和嵌套的列表很相似。
import numpy as np
a=np.ones([2,5,3]) #创建全为1的数组
print(a)
运行结果：
[[[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.]]]
还有一种情况，在数组中的元素太多时，若全部进行打印输出，则会占用大面积的显示空间，而且不易查看，所以在打印输出元素过多的数组时，输出显示的内容会自动跳过中间的部分，只打印首尾的一小部分，对中间的部分用省略号（…）来代替。
import numpy as np
a=np.arange(2000)
print(a)
运行结果：[ 0 1 2 … 1997 1998 1999]
（3）多维数组的基本操作
1）数组的算术运算
数组能够直接进行加法、减法、乘法和除法算术运算：
import numpy as np
a=np.array([1,2,3])
b=np.array([4,5,6])
print(“a-b=”,a-b)#打印a-b的结果
print(“a+b=”,a+b)#打印a+b的结果
print(“a/b=”,a/b)#打印a/b的结果
print("ab=",ab)#打印ab的结果
运行结果：
a-b= [-3 -3 -3]
a+b= [5 7 9]
a/b= [0.25 0.4 0.5 ]
ab= [ 4 10 18]
虽然数组在构造上类似于矩阵，但是其运算和之前介绍的矩阵运算存在诸多不同：
首先，矩阵是不存在除法运算的，但是数组能够进行除法运算；
其次，数组的乘法运算机制是通过将位置对应的元素相乘来完成的，和矩阵的乘法运算机制不同。
import numpy as np
a=np.array([1,2,3])
b=np.array([4,5,6])
print("ab=",ab)#打印a*b的结果
c=a.dot(b)
print("Matrix1:ab=",c)#打印ab的结果
d=np.dot(a,b)
print("Matrix2:ab=",c)#打印ab的结果
运算结果：
ab= [ 4 10 18]
Matrix1:ab= 32
Matrix2:a*b= 32
在以上代码中使用了两种方法来实现矩阵的惩罚运算，其计算结果是一样的。数组和矩阵的算术运算还有一个较大的不同点，就是数组可以直接和标量进行算术运算，但是在矩阵运算中是不可以的。
import numpy as np
a=np.array([1,2,3])
print("a2=",a2)
print(“a/2=”,a/2)
print(“a-2=”,a-2)
print(“a+2=”,a+2)
运行结果：
a*2= [2 4 6]
a/2= [0.5 1. 1.5]
a-2= [-1 0 1]
a+2= [3 4 5]
2）数组的自身运算
除了数组和数组、数组和标量之间的算术运算，我们还可以通过自定义一些方法来对数组本身进行操作。
【1】min：默认找出数组的所有元素中值最小的元素，可以通过设置axis的值来按行或者列查找元素中的最小值。
【2】max：默认找出数组的所有元素中值最大的元素，可以通过设置axis的值来按行或者列查找元素中的最大值。
【3】sum：默认对数组中的所有元素进行求和运算，并返回运算结果，同样可以通过设置axis的值来按行或者列对元素进行求和运算。
import numpy as np
a=np.array([1,2,3])
print(“min of array:”,a.min())
print(“max of array:”,a.max())
print(“sum of array:”,a.sum())
运行结果：
min of array: 1
max of array: 3
sum of array: 6
以上代码只是针对一维数组的情况编写的，如果是多维数组的情况，操作如下进行：
import numpy as np
a=np.array([[1,2,3],
[3,2,1]])
print(“min of array:”,a.min())
print(“min of array:”,a.min(axis=0))
print(“min of array:”,a.min(axis=1))
print(“max of array:”,a.max())
print(“max of array:”,a.max(axis=0))
print(“max of array:”,a.max(axis=1))
print(“sum of array:”,a.sum())
print(“sum of array:”,a.sum(axis=0))
print(“sum of array:”,a.sum(axis=1))
运行结果：
min of array: 1
min of array: [1 2 1]
min of array: [1 1]
max of array: 3
max of array: [3 2 3]
max of array: [3 3]
sum of array: 12
sum of array: [4 4 4]
sum of array: [6 6]
在复杂的多维数组中，我们通过对axis参数进行不同的设置，来得到不同的运算结果：当axis为0时，计算方向是针对数组的列的；当axis为1时，计算方向是针对数组的行的。
【4】exp：对数组中的所有元素进行指数运算。
【5】sqrt：对数组中所有元素进行平方根运算。
【6】square：对数组中所有元素进行平方运算。
import numpy as np
a=np.array([1,2,3])
print(“Exp of array:”,np.exp(a))
print(“Sqrt of array:”,np.sqrt(a))
print(“Square of array:”,np.square(a))
运算结果：
Exp of array: [ 2.71828183 7.3890561 20.08553692]
Sqrt of array: [1. 1.41421356 1.73205081]
Square of array: [1 4 9]
3）随机数组
生成随机数在我们平时的应用中是很有用的，在NumPy中有许多方法可以生成不同属性的随机数，以满足在计算中使用随机数字的需求。
【1】seed：随机因子，在随机数生成器的随机因子被确定后，无论我们运行多少次随机程序，最后生成的数字都是一样的，随机因子更像把随机的过程变成一种伪随机的机制，不过这有利于结果的复现。
【2】rand：生成一个在[0,1)范围内满足均匀分布的随机样本数。
【3】randn：生成一个满足平均值为0且方差为1的正态分布随机样本数。
【4】randint：在给定范围内生成类型为整数的随机样本数。
【5】binomial：生成一个维度指定且满足二项分布的随机样本数。
【6】beta：生成一个指定维度且满足beta分布的随机样本数。
【7】normal：生成一个指定维度且满足高斯正态分布的随机样本数。
import numpy as np
np.random.seed(42) #随机因子
print(np.random.rand(2,3))
print(np.random.randn(2,3))
print(np.random.randint(1,10))
print(np.random.binomial(6,1))
print(np.random.beta(2,3))
print(np.random.normal(2,3))
运行结果：
[[0.37454012 0.95071431 0.73199394]
[0.59865848 0.15601864 0.15599452]]
[[ 1.57921282 0.76743473 -0.46947439]
[ 0.54256004 -0.46341769 -0.46572975]]
6
6
0.45543839870822056
2.666236704694229
4）索引、切片和迭代
一维数组：
import numpy as np
a=np.arange(10)
print(a) #输出整个数组
print(a[:5]) #输出数组的前五个元素
for i in a: #迭代输出数组的全部元素
print(i)
运行结果：
[0 1 2 3 4 5 6 7 8 9]
[0 1 2 3 4]
0
1
2
3
4
5
6
7
8
9
多维数组的索引、切片和迭代操作。对于多维数组而言，在每个维度上都可以通过索引值进行切片，这些索引值构成的是一个用逗号分隔的元组。
import numpy as np
a=np.array([[1,2,3],
[4,5,6],
[7,8,9]])
print(a)#输出整个数组
print("-"10)
print(a[1])#输出指定维度的数据
print("-"10)
print(a[0:2,1:3])#输出指定维度的数据（？？？）**
运行结果：
[[1 2 3]
[4 5 6]
[7 8 9]
[4 5 6]
[[2 3]
[5 6]]
多维数组可以针对可以针对不同的维度进行迭代：
import numpy as np
a=np.array([[1,2,3],
[4,5,6],
[7,8,9]])
for i in a:
print(i)
print("-"*10)
for i in a:
for j in i:
print(j)
运行结果：
[1 2 3]
[4 5 6]
[7 8 9]
1
2
3
4
5
6
7
8
9
将代码中的第2种迭代方法写成如下形式，也可以达到同样的效果，这相当于将多维数组进行了扁平化处理，将其转变成了一维数组：
for i in a.flat:
print(i)
5.Python中的Matplotlib
Matplotlib是Python的绘图库，不仅具备强大的绘图功能，还能够在很多平台上使用，和Jupyter Notebook有很强的兼容性。
（1）Matplotlib的安装
通过”pip install matplotlib“语句来安装Matplotlib，运行”import matplotlib“检验是否安装成功。
如果是在Jupyter Notebook的Notebook文件中使用的，则要想直接显示Matplotlib绘制的图像，就需要添加”%matplotlib inline“语句。
（2）创建图
Matplotlib本身定位于数据的可视化展现，所以集成了很多数据可视化方法：
【1】线型图
线型图通过线条的形式对数据进行展示，可以通过它很方便地看出数据的趋势和波动性。
import matplotlib.pyplot as plt
import numpy as np
%matplotlib inline
np.random.seed(42)
x=np.random.randn(30)
plt.plot(x,“r–o”)
运行结果：
以上代码的前三行用于导入我们需要的包，并让通过Matplotlib绘制的图像直接在Notebook文件中显示；然后通过np.random.seed(42)设置了随机种子，以方便我们之后的结果复现；接着通过np.random.randn(30)生成30个随即参数并赋值给变量x；最后绘图的核心代码通过plt.plot(x,“r–o”)将这30个随机参数以点的方式绘制出来并用线条进行连接，传递给plot的参数r–o用于在线型图中标记每个参数点使用的形状、连接参数点使用的线条颜色和线型，而且线型图的横轴和纵轴也是有区别的，纵轴生成的是30个随机数的值，横轴生成的是这30个点的索引值，同样是30个。
【2】线条颜色、标记形状和线型
在绘制线型图时，我们通过标记每个参数点使用的形状、连接参数点使用的线条颜色和线型，可以很好的区分不同的数据，这样做可以使我们想要显示的数据更清晰，还能突出重要的数据。
用于设置线型图中线条颜色的常用参数如下。
(I) b：指定绘制的线条颜色为蓝色
(2 )g:指定绘制的线条颜色为绿色
(3 ）r：指定绘制的线条颜色为红色。
(4 ）c：指定绘制的线条颜色为蓝绿色。
(5 ）m：指定绘制的线条颜色为洋红色。
(6 ）y：指定绘制的线条颜色为黄色。
(7 ）k:指定绘制的线条颜色为黑色。
(8 ）w:飞指定绘制的线条颜色为白色。
用于设置线型图中标记参数点形状的常用参数如下
( 1）o：指定标记实际点使用的形状为圆形。
(2 ）*：指定标记 实际点使用“ 符号。
(3 ）＋：指定标记 实际点使用“ ”符号
(4 ）x：指定标记实际点使用“ ”符号。
用于设置线型图中连接参数点线条形状的常用参数如下
( 1）-：指定线 条形状为实线。
( 2) --： 指定线条形状为虚线
(3 ）：-．”： 指定线条形状为点实线
(4 ）”：“： 指定线条形状为点线。
【3】标签和图例
为了让我们绘制的图像更易理解，我们可以增加一些绘制图像的说明，一般是添加图像的轴标签和图例。
import matplotlib.pyplot as plt
import numpy as np
%matplotlib inline
np.random.seed(42)
x=np.random.randn(30)
y=np.random.randn(30)
plt.title(“Example”)
plt.xlabel(“X”)
plt.ylabel(“Y”)
X,=plt.plot(x,“r–o”)
Y,=plt.plot(y,“b-*”)
plt.legend([X,Y],[“X”,“Y”])
运行结果：
从图中我们看到了图标签和图例，这是因为代以上代码中增加了标签的显示代码plt.xlabel(“X”)、plt.ylabel(“Y”)和图例的显示代码plt.legend([X,Y],[“X”,“Y”])，传递给plt.legend的是两个列表参数，第一个列表参数是在图中实际使用的标记和线形，第二个列表参数是对应图例的文字描述。
【4】子图
若我们需要将多个图像在不同的位置显示，则需要用到子图（Subplot）的功能。
import matplotlib.pyplot as plt
import numpy as np
%matplotlib inline
a=np.random.randn(30)
b=np.random.randn(30)
c=np.random.randn(30)
d=np.random.randn(30)
fig=plt.figure()
ax1=fig.add_subplot(2,2,1)
ax2=fig.add_subplot(2,2,2)
ax3=fig.add_subplot(2,2,3)
ax4=fig.add_subplot(2,2,4)
A,=ax1.plot(a,“r–o”)
ax1.legend([A],[“A”])
B,=ax2.plot(b,“b-*”)
ax2.legend([B],[“B”])
C,=ax3.plot(c,“g-.+”)
ax3.legend([C],[“C”])
D,=ax4.plot(d,“m:x”)
ax4.legend([D],[“D”])
运行结果：
在绘制子图时，我们首先需要通过fig=plt.figure()定义一个实例，然后通过fig.add_subplot方向向fig实例中添加我们需要的子图。在代码中传递给fig.add_subplot方法的参数是1组数字，拿第1组数字（2，2，1）来说，前两个数字表示把整块图划分成了两行两列，一共4张子图，最后1个数字表示具体使用哪一张子图进行绘制。除了绘制线型图，利用Matplotlib强大的绘图库还能绘制散点图、直方图、饼图等常用的图形。
【5】散点图
如果我们获取的是一些散点数据，则可以通过绘制散点图(Scatter)更清晰地展示所有数据的分布和布局。
import matplotlib.pyplot as plt
import numpy as np
%matplotlib inline
np.random.seed(42)
x=np.random.randn(30)
y=np.random.randn(30)
plt.scatter(x,y,c=“g”,marker=“o”,label="(X,Y)")
plt.title(“Example”)
plt.xlabel(“X”)
plt.ylabel(“Y”)
plt.legend(loc=1)
plt.show()
运行结果：
绘制散点图的核心代码plt.scatter(x,y,c=“g”,marker=“o”,label="(X,Y)")，其中有三个我们需要特别留意的参数：
1）“c”：指定散点图中绘制的参数点使用哪种颜色，可设置的颜色参数可参与之前绘制线型图时对线条颜色选择的参数范围，这里使用“g”表示设置为绿色。
2）“marker”：指定散点图中绘制的参数点使用哪种形状，和之前线型图中的设置一样，这里使用“o”表示设置为圆形。
3）“label"：指定在散点图中绘制的参数点使用的图例，与线型图中的图例不同。
我们还可以通过plt.legend(loc=1)对图例的位置进行强制设定，对图例位置的参数设置一般有以下几种：
1)“loc=0”：图例使用最好的位置。
2)"loc=1’：强制图例使用图中右上角的位置。
3)“loc=2”：强制图例使用图中左上角的位置。
4)“loc=3”：强制图例使用图中左下角的位置。
5)“loc=4”：强制图例使用图中右下角的位置。
【6】直方图
直方图（Histogram）又称质量分布图，是一种统计报告图，通过使用一系列高度不等的纵向条纹或直方表示数据分布的情况，一般用横轴表示数据类型，用纵轴表示分布情况。
import matplotlib.pyplot as plt
import numpy as np
%matplotlib inline
np.random.seed(42)
x=np.random.randn(1000)
plt.hist(x,bins=20,color=“g”)
plt.title(“Example”)
plt.xlabel(“X”)
plt.ylabel(“Y”)
plt.show()
运行结果：
绘制直方图的核心代码是plt.hist(x,bins=20,color=“g”)，其中color的功能和散点图中的c是一样的，bins用于指定我们绘制的直方图条纹的数量。
【7】饼图
饼图用于显示一个数据系列，我们可以将一个数据系列理解为一类数据，而每个数据系列都应当拥有自己唯一的颜色。在同一个饼图中可以绘制多个系列的数据，并根据每个系列的数据量的不同来分配它们在饼图中的占比。
import matplotlib.pyplot as plt
labels=[‘Dos’,‘Cats’,‘Birds’]
sizes=[15,50,35]
plt.pie(sizes,explode=(0,0,0.1),labels=labels,autopct=’%1.1f%%’,
startangle=90)
plt.axis(‘equal’)
plt.show()
运行结果:
绘制饼图的核心代码为plt.pie(sizes,explode=(0,0,0.1),labels=labels,autopct=’%1.1f%%’,startangle=90)
其中sizes=[15,50,35]的三个数字确定了每部分数据系列在整个圆形中的占比；explode定义每部分数据系列之间的间隔，如果设置两个0和一个0.1，就能突出第3部分；autopct其实就是将sizes中的数据以所定义的浮点精度进行显示；startangle是绘制第1块饼图时该饼图与X轴正方向的夹角度数，这里设置为90，默认为0；pltaxis(‘equal’)是必不可少的，用于使X轴和Y轴的刻度保持一致，只有这样，最后得到饼图才是圆形。
86
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
