Python的学习心得和知识总结（一）|Python简介和入门

2020年3月31日09:38:36 开始

Python入门

Python 简介

Python的官网 这是官方链接，是学习和了解最新Python技术的权威出处。当然还是那句老话：一定要好好学习English！

Python是一种计算机程序设计语言。是一种解释型和面向对象的语言，最初被设计用于编写自动化脚本(shell)，随着版本的不断更新和语言新功能的添加，越来越多被用于独立的、大型项目的开发。当然学习Python，也是需要安装相应的开发环境（这也就是我当时不喜欢学Java的原因）。对于我们初学者而言，是可以在上面官网的敲上一两行代码感受一下！

我这里使用的还是VS2019，之前我写过博客：Visual Studio 2019 的安装 在这里面，各位也可以试着安装Python的开发环境。当然Python的开发工具也有很多，我就不一一列举了！

Python的特点如下：

1. 可读性友好：良好的可读性可以使我们作为开发人员在更短的时间之内 更快更准确的理解和学习代码，以快速提高工作效率
2. 简洁性强大：我们都知道Python是由C语言研发而成，但是之前C里面指针等复杂的datatype都不再出现。这也就使得Python的容易程度大大提升，同理 程序的开发难度和代码量大幅度降低。具体的程序开发将会更加着重于任务自身，而非繁杂的语言语法
3. 效率相应下降：若是我们大家平时刷些oj，就会知道什么叫做严格的时间限制。对于简单易于书写代码的Python就是个致命打击。作为解释型语言：解释执行 性能很低。因此：个人对各位同学的小小建议：C C++ 数据结构 算法等，还是要掌握的。偷得学习的苦，就会在别的地方还回来。但是一旦你拥有一个强大的基础再来学习Python，就会有一种“柳暗花明又一村”的体验。
4. 面向对象 免费开源 （这些东西在C++面前不值一提）
5. 良好的可移植性和扩平台：Python的代码是首先被编译处理成与OS相关的二进制代码，再进行解释执行（有点类似于Java），当然这种方式的扩平台性非常好
6. 丰富的库：这一点需要额外说明的。Python有大量的标准库，以及丰富的扩展库
7. 可扩展性：Python代码是可以被嵌入到C C++之中的

但是也正是Python的简单易用也深受大家的喜爱（最近人工智能 大数据等比较火，连那些非科班出身的人员都想参与其中），当然我个人是做C（C++）开发的 也是迷上了Python的简洁！虽然其效率十分低下，但是毕竟好在Python解释器的快速发展 Python的效率将会大幅提升。如下：

import turtle
t=turtle.Pen()
for x in range(360):
    t.forward(x)
    t.left(59)

寥寥数语，就可以实现我们C（C++）不可想象的效果！

Python 优劣

下面来说一下Python语言的应用场景：

• Artificial Intelligence（Python无敌）
• 大数据 云计算
• 科学计算
• web server和大型网站后端（Java最多 PHP次之）
• GUI、游戏研发（Python用于快速开发业务逻辑；C/C++用于开发核心功能）
• 移动设备 嵌入式设备
• 系统运维

上面我们也提及到其效率的问题了，一个原则：Python功能强大，效率低下 适合快速搭建开发业务逻辑。遇到影响性能的地方：使用C C++等。

下面来说一下Python语言的版本和兼容问题：
目前市面上有两个版本：Python2 Python3。Python3 不兼容 2，但是其性能大幅度提升。Python2的最新版本为2.7 不过现在Python3上面很多新的特性也被移植到2.7上了。这个兼容的问题：若是程序可在2.7之上运行，我们可以借助于 2to3 （Python自带脚本）进行到Python3的无缝迁移转换。

作为解释型的语言，程序的执行离不开Python解释器了。市面上常见的解释器如下：

• CPython C语言实现的解释器 最常用 效率最高
• Jython Java实现 它可以直接调用Java类库，适于Java平台开发
• IronPython .net平台使用的解释器。可直接调用.net平台的类，适于.net平台开发
• PyPy Python语言实现的解释器

Python环境

Python 安装

去下载 Python下载链接 当然初学者就Python3吧
安装
配置环境变量 很重要，有了环境变量 就可以在cmd上运行Python解释器
至于Python的安装，傻瓜式的操作。各位自行去CSDN上找安装教程吧 恕在下直言，若是连环境变量PATH都不知道，那你需要更加倍的努力了。

Python IDE

上面我也说了，我这次使用的IDE 就是VS2019。这个不重要，大家喜欢哪个都行。
集成开发环境，其本质上就是对上面安装的Python解释器python.exe的封装。IDE的存在使得我们程序开发更加方便 减少（尤其 拼写出错）出错率。
下面是一些常见的IDE：

• IDLE
• Pycharm
• wingIDE
• Eclipse
• IPython

下面先使用一下cmd进行运行，如下：

使用cmd进行交互的时候，ctrl + c（发送键盘中断）是 中断程序执行 。上面这个cmd交互模式的工作原理和Python处理文件的方式一样。

下面着重介绍一下 IDLE：

1. IDLE是官方标准开发环境 ，安装Python完成同时也就安装了IDLE
2. 它具备几乎所有的功能（不同颜色提示不同的类型、语法智能提示等），适合初学者
3. 属于Python标准发行版内置的小巧IDE，它包括：交互式命令行、编译器和调试器等基本组件
4. 是基于Tkinter的Python编译的（其最初的作者就是Python之父）

---

注：下面说一下在Python中一些 注意事项：

1、不要在程序之中的 行开头处增加空格。因为空格在Python中有缩进的含义。逻辑行 前面的空白（空格和制表符）是用来决定该逻辑行的缩进层次，进而确定语句的分组情况 。而且Python语言是通过缩进来组织程序的。一般情况下，一个缩进是4空格，在vs上面验证一个Tab 为4空格。
2、语句从新一行的第一列开始的，所以再次说明 不要在程序之中的 行开头处增加空格。
3、书写符号的时候，注意中英文和大小写的区别。
4、注释一行用 #； 注释多行 上下都加 三连续引号""" 或者 三连续单引号’’’

详解第一个程序

从第一个Python程序来学习一下 GUI程序设计：

import turtle
t=turtle.Pen()
for x in range(360):
    t.forward(x)
    t.left(59)

这个是前面我们所提及到小程序：海龟画图。下面进行扩展，来详细学习一下第一个程序，如下：

注：它这里的坐标轴就是同中学的笛卡尔坐标系是一样的！
这里的走动都是划线了，我们若是不想让它划其路线 如下：

画圆操作：逆时针 在该点的左边半径 r 处做圆。

下面就开始实践一下，海龟画图之 奥运五环： （今年的东京奥运会也停摆了）

详细代码如下：

# 海龟画图之奥运五环
import turtle           #导入 turtle 模块
turtle.width(8)         #选择笔宽
turtle.showturtle()     #显示箭头
turtle.color("blue")
turtle.circle(50)       #画圆     第一个圆

turtle.penup()
turtle.goto(110,0)
turtle.pendown()
turtle.color("black")
turtle.circle(50)       #画圆     第二个圆

turtle.penup()
turtle.goto(220,0)
turtle.pendown()
turtle.color("red")
turtle.circle(50)       #画圆     第三个圆

turtle.penup()
turtle.goto(55,-50)
turtle.pendown()
turtle.color("gold")
turtle.circle(50)       #画圆     第四个圆

turtle.penup()
turtle.goto(165,-50)
turtle.pendown()
turtle.color("green")
turtle.circle(50)       #画圆     第五个圆

---

Python基础

Python程序构成

如上图所示：
1、Python程序是由众多模块所组成的，而一个模块则对应一个.py的Python源文件。
2、一个模块，即一个源文件里面由诸多语句（包括函数、类等）组成的。运行Python程序的时候，是按照模块中的语句顺序依次执行（从上到下）的。
3、一条条语句是Python程序的构成单元，用于创建对象、变量、赋值、调用函数、控制语句等。
4、上面的语句则是由表达式来组成的。

代码组织与缩进

缩进的意义：
相较于我们熟悉的其他编程语言：使用{}、关键字如BEGIN/END等，配合着代码书写的缩进来进行代码块的划分和提高程序可读性。但是在我们的Python语言里面，是直接通过缩进来组织和划分代码块的。 缩进时，我们通常使用“四个空格或1个Tab”来表示一个缩进。 这一点上，VS2019是将一个Tab 设置成4个空格。

注：有些大神在记事本上书写Python的时候，需要注意 避免将Tab键 和 空格的混合使用！！！
注释的意义：
前面也说过了，注释（单行和多行）。根据在下的实际经验：像我这样的程序员最恨的是自己要写注释（没那个必要），同时也最恨别人不写注释！！！ 当然注释的作用并非是给自己添堵，而是以后回顾的时候备用。

行连接符 \：
这个行连接符在脚本语言、Makefile等之中也是很常见的：它的作用在于 处理一个非常长的代码行，保证良好的阅读体验。通常 它是放在1行结束的地方，来将一行进行拆分。、

>>> key="你好\
China"
>>> key
'你好China'
>>> 

Python 对象

和Linux中 一切皆文件 类似，在Python中，一切皆对象。对象有：可爱的、不可爱的；性格乖的、性格暴躁的；温柔的、野蛮的 等等······ 开个玩笑，活跃下气氛！

对象由：identity（标识）、type（类型）和value（值） 组成的。而且所谓对象：其本质上就是一个内存块，拥有特定的值，支持特定类型的相关操作。

• 标识：主要用于唯一标识该对象，通常对应于对象在计算机内存中的地址。可以使用内置函数id(obj)来返回对象obj的标识。
• 类型：用于表示对象存储的“数据”的类型。类型可以限制对象的取值范围，以及可以进行的操作。可以使用type(obj)来获得对象的所属类型。
• 值：用于表示对象所存储的数据的信息。使用print(obj)可以直接打印其值。

Python 3.8.2 (tags/v3.8.2:7b3ab59, Feb 25 2020, 23:03:10) [MSC v.1916 64 bit (AMD64)] on win32
Type "help", "copyright", "credits" or "license()" for more information.
>>> a=3   #把3 赋给 a变量
>>> a
3
>>> id(3)
140723631871712  对象的地址
>>> type(3)
<class 'int'>    对象的类型
>>> print(3)
3                对象的值
>>> 
>>> id(a)
140723631871712
>>> type(a)
<class 'int'>
>>> print(a)
3
>>> 

如上：3是一个对象，a是变量。这时的3，我们看到的只是一个表象，它是上面元素的集合体（有机体）。此时的a 成了对象的一个代表的标签。

Python 引用

在Python中，上面的变量是：对象的引用。此时变量存储的是 对象的地址，也即：变量通过地址引用了“对象”。

很容易理解：对象位于堆区内存，变量位于栈区。 这一点 我们可以理解着同C++一起学习！但是同C不相同的是：Python里面的变量 是不需要显示声明它是什么类型（直接写就行）。根据变量它引用的对象（对象里面有类型），Python解释器自动就可以推演确定其数据类型。 这点称之为：Python是动态类型语言。

此外，每个对象都有数据类型，且只支持该类型的相关操作。（也即：根据对象的类型来看它具有什么样的操作） Python也是强类型语言。

Python 标识符

标识符：主要是给 变量、函数、类和模块等起名字用的。通常情况下，标识符有如下的特殊规定：
1、严格区分大小写
2、第一个字符必须 是字母或者下划线。其后的字符是：字母、数字、下划线
3、关键字不可使用。if else等
4、系统中 以双下划线_ _ 开头的和 _ _结尾的名字 通常都有特殊的含义，尽量避免这种写法。
5、对于模块和包名：全小写字母，尽量简单，见名知意。若是多个单词，以下划线连接
6、对于函数名：全小写字母。若是多个单词，以下划线连接
7、对于类名：首字母大写，使用驼峰原则。多个单词时，每个单词第一个字母大写，其余部分小写。
8、对于常量名：全大写字母。若是多个单词，以下划线连接

退出help帮助，使用quit即可。在交互框 按键F1，就可以进入到Python的帮助文档 当然肯定全英文了。 以后我会对这个文档的重要模块做一个简单的中文翻译！

Python变量和简单赋值语句

Python 变量

变量的定义：
上面也说了变量和对象的关系：变量位于栈区，是存储对象的地址。变量的声明和赋值用于将一个变量绑定到一个对象上，其格式如下：

变量名 = 表达式  #不需要指定类型

当然最简单的表达式就是字面量。比如：a=3 它做的事情是：解释器先运行右边的表达式，即先把3这个对象创建出来（生成一个可以代表表达式运算结果的对象）；然后把对象的地址赋值给左边的变量a，这样变量a才可以使用。因此变量若是在使用前不做赋值操作，那么这个变量会报错：变量 is not defined。

变量的删除和垃圾回收机制：
删除一个变量是通过del 语句完成的，但是这个变量的删除只是去除了变量在栈区的内容空间。他所引用的对象还是在的（堆区），不过这些没有变量引用的对象会被 垃圾回收器回收，来清空内存空间。

>>> a = 3
>>> a
3
>>> del a
>>> a
Traceback (most recent call last):
  File "", line 1, in <module>
    a
NameError: name 'a' is not defined
>>> id(3)
140722939418336
>>> type(3)
<class 'int'>
>>> print(3)
3
>>> id(a)
Traceback (most recent call last):
  File "", line 1, in <module>
    id(a)
NameError: name 'a' is not defined
>>> 

链式赋值和系列解包赋值

链式赋值：使用同一个对象给多个变量赋值（这多个变量也就同时指向了同个对象）

>>> x=y=3
>>> x
3
>>> y
3
>>>
>--------------------------
>>> m=4;n=4
>>> m
4
>>> n
4
>>> 

系列解包赋值：系列数据赋值给对应相同个数的变量（个数需要保持一致）

>>> a,b,c=1,2,3 #这相当于分开赋值。
>>> a
1
>>> b
2
>>> c
3
>>>

>>> m,n=1,2 #这是利用系列解包赋值 完成的变量交换
>>> m,n=n,m
>>> print(m,n)
2 1
>>>

常量：Python上面的常量是不支持的，即：没有语法规则限制 改变一个常量的值。我们只能够约定常量的命名规则，以及在程序的逻辑上不对这个常量的值做出改变。

>>> I_AM_A_CONSTANT=1024
>>> print(I_AM_A_CONSTANT)
1024
>>> I_AM_A_CONSTANT=2048
>>> print(I_AM_A_CONSTANT)
2048
>>> 

如上：实际上真正意义上的常量在Python里面是不存在的，上面的这个“常量”就被改动了。我们这里为了保证Python里面有常量：我们约定 逻辑上不能改，仅此而已。

内置数据类型

最基本的内置数据类型

我们上面也说了：每个对象都有自己的类型。在Python里面 最基本的内置数据类型有下面几个：

1. 整型：整数
2. 浮点型：小数、科学计数法2e-3
3. 布尔型：真假 仅有True和False
4. 字符串型：由字符组成的序列。“我爱你” “China”

当然我们也可以自定义一些类型

数字及运算

Python支持整数 和 浮点数，可以对数字有如下的运算：

>>> 3+2
5
>>> 2-1
1
>>> 3*3
9
>>> 1.0+2.0
3.0
>>> 2.0-1.0
1.0
>>> 2.0*1.0
2.0
>>>
>>> 8/4  #浮点数除法
2.0
>>> 5/2
2.5
>>> 8//4 #整数除法
2
>>> 5//2
2
>>> 5%2  #取余
1
>>> 2**10 #次方
1024

这里说明一个函数 divmod（），它可以同时算出商和余数。（它返回的是一个元组）如下：

>>> divmod(5,2)
(2, 1)
>>> divmod(6,3)
(2, 0)
>>>

整数

在Python里面，整数进制有：二（0b、0B） 八（0o、0O） 十 十六（0x、0X）进制。进制转换 将会非常方便的应用于“位运算”操作中。

>>> 15
15
>>> 0b1111
15
>>> 0o17
15
>>> 0Xf
15
>>>

这里 我们也顺便介绍一个int（）函数来实现类型转化：

1. 浮点数会被直接舍去小数部分
2. 布尔值会被处理为 1 0
3. 字符串：符合整数格式（浮点数不行）的处理为整数；否则报错

>>> int(1.9)
1
>>> int(1.4)
1
>>> int("1.5")
Traceback (most recent call last):
  File "", line 1, in <module>
    int("1.5")
ValueError: invalid literal for int() with base 10: '1.5'
>>> int("15")
15
>>> int("15abc")
Traceback (most recent call last):
  File "", line 1, in <module>
    int("15abc")
ValueError: invalid literal for int() with base 10: '15abc'
>>> int(True)
1
>>> int(False)
0
>>> 

注：和C里面一样，当整数和浮点数进行混合运算时。表达式的结果会自动转型成浮点数，如下：

>>> 660+6.0
666.0
>>> 

在Python3之后，我们取消了Python2里面 int是32位，Long是64位。现在没有Long类型了，而int 则可以表示任意大的整数。 毕竟Python语言适合做 科学计算的，这时就不会造成“整数溢出”。

浮点数

浮点数是用a*b^10形式的科学计数法表示的。例如3.14是314E-2、314e-2。当然float在内存中也是按照科学计数法存储的。

类似于int(),float()也是可以将其他类型转化成浮点数的。如下：

>>> float(3)
3.0
>>> float("3")
3.0
>>> float("3.14")
3.14
>>> float(a)
Traceback (most recent call last):
  File "", line 1, in <module>
    float(a)
NameError: name 'a' is not defined
>>> float("3.14b")
Traceback (most recent call last):
  File "", line 1, in <module>
    float("3.14b")
ValueError: could not convert string to float: '3.14b'
>>> 

需要说明的是 float(3)，是新生成了一个 具有自己id；类型为float；值为3.0的新对象。原来的对象3还是没有变化的。下面再介绍一下 round()函数 具体做的就是 四舍五入。

>>> round(3.14)
3
>>> round(4.51)
5
>>> round("1.25")
Traceback (most recent call last):
  File "", line 1, in <module>
    round("1.25")
TypeError: type str doesn't define __round__ method
>>> 

增强型赋值运算符

这些符号在学C语言的时候，已经大致过了一下 我们在这里就不细说了

>>> a=2
>>> a+=1
>>> a
3
>>> a-=1
>>> a
2
>>> a*=2
>>> a
4
>>> a/=2
>>> a
2.0
>>> a//=2
>>> a
1.0
>>> a=int(a)
>>> a
1
>>> a*=2
>>> a
2
>>> a**=10
>>> a
1024
>>> a//=256
>>> a
4
>>> a%=3
>>> a
1
>>> 

这些都是先运算 右边的表达式，生成新的对象；然后把新对象的地址给了a。（旧对象会被垃圾回收机制处理掉）

时间的表示

我们熟悉Linux的同学都知道：Unix时间（1970年1月1日 00:00:00）。这个时间也是计算机里面计算和表示时间的基准值，单位是 ms。前后时间的计算是通过 加上 相较于基准时间的偏差（正负）。 我们下面看一下Python里面 如何获得当前时刻的时间值：

>>> import time
>>> time.time()
1585726590.7719407
>>> print('当前时间的时间戳：%f' % time.time())
当前时间的时间戳：1585726696.828934
>>> print('time.localtime(): ', time.localtime())
time.localtime():  time.struct_time(tm_year=2020, tm_mon=4, tm_mday=1, tm_hour=15, tm_min=38, tm_sec=36, tm_wday=2, tm_yday=92, tm_isdst=0)
>>> # 最后三个输出的值的含义为 一周的第几日 0 ~ 6（0 是周一），一年中的第几日，夏令时(-1, 0, 1, -1)
>>> t = time.localtime()
>>> print('time.asctime(t): %s' % time.asctime(t))
time.asctime(t): Wed Apr  1 15:40:48 2020
>>> 

上面的这个时间戳1585726696.828934 该值的单位是 s，后面是带us精度的 float值。
这里 我们只简单的说一下time模块了，别的模块以后再说。

下面我们做一个简单的小练习：画地图

#绘制地图 计算唐印距离
import turtle
import math
import datetime

Tang,Luoyang=100,100
Japan,Tokyo=300,0
Philippines,Manila=180,-80
Indonesia,Jakarta=120,-200
India,Delhi=-200,50

# 绘制地图
turtle.width(6)
turtle.pensize(2)

turtle.penup()
turtle.goto(Tang,Luoyang)
turtle.pendown()
turtle.write("大唐",font=('微软雅黑',18,''))

turtle.color("gold")
turtle.goto(Japan,Tokyo)
turtle.write("日本",font=('微软雅黑',18,''))

turtle.color("black")
turtle.goto(Philippines,Manila)
turtle.write("菲律宾",font=('微软雅黑',18,''))

turtle.color("red")
turtle.goto(Indonesia,Jakarta)
turtle.write("印度尼西亚",font=('微软雅黑',18,''))

turtle.color("green")
turtle.goto(India,Delhi)
turtle.write("印度",font=('微软雅黑',18,''))

# 计算唐印距离
distance=math.sqrt((Tang-India)**2+(Luoyang-Delhi)**2)
distance=int(distance)
turtle.penup()
turtle.goto((Tang+India)//2,(Luoyang+Delhi)//2)
turtle.pendown()
turtle.hideturtle()
turtle.color("yellow")
turtle.write(distance,move=True,font=('楷体',24,'italic'))