零基础学python：超详细的入门教程！

第一章：Python的概述

1.1：什么是Python?

Python它是一种直译式，面向对象，解释式的脚本语言。它和Java,C/C++,Go语言一样都是高级语言，但由于它是解释式语言，所以运行速度会比Java，C/C++等语言慢（虽说隔壁Go也是解释式语言，但比它快很多）。不过任何事物有利也有弊，Python因为自身携带了许多库（如：OS、TCP、Urllib、Trutle)，语法简单，第三库也有很多（如飞机大战所需的pygame)，所以被称为胶水语言，同时也深受开发者青眯。

1.2：Python之父与简介

Python之父：Guido van Rossum，荷兰人。他也是一个比较传奇的人物，1982年 在阿姆斯特丹大学获得计算机和数学科学硕士学位 ，1989年制作Python，1995年Guido van Rossum从荷兰移民到美国，2005年在Google工作，并用Python发明了面向网页的代码浏览工具Mondrian，之后又开发了Rietveld。现在在Dropbox工作。

1.3：Python应用范围

基本全能，例如:系统运维、图形处理、数学处理、文本处理、数据库编程、网络编程、web编程、多媒体应用、pymo引擎、黑客编程、爬虫编写、机器学习、人工智能等。

1.4：Python优缺点

优点：免费开源、无社区限制、可开发应用面广、可跨平台、功能强大、自身携带模块多、第三方模块多、语法简单，代码量少可实现多功能等。例如以下代码实例
按照程序界传统，入门新人写的第一个程序就是输出Hello,world。要是我们用C实现

#include<stdio.h>
int main()
{
printf("Hello world!\n");
return 0;
}

然而我们用Python

def print()：
	return print
print('Hello world')

或者更简单

print('Hello world')

我们可以看出制作同一个程序，运用代码量Python远比C要少，所以这就是它受广大程序员青睐的原因之一。
缺点：运行速度远比C/C++等语言要慢等。

第二章：安装与配置Python IDE

在古代战场上，一把趁手的武器与士兵精湛的武术、将军正确的指挥，相辅相成，相得益彰，这样胜率往往会提高很多。在做某爱时，即使女方精通某爱技艺，身材妩媚妖娆的妹子，但如果你的烧火棍很小，那么你将不能满足她，然后就可能会造成伴侣之间某冷淡。但如果你的烧火棍犹如定海神针般，那么你将可以给予她*方面的满足，同时也增进了伴侣间的感情（开始正儿八经的胡说八道）…这些道理放到配置Python解释器方面也同样适用。因此，我们应该如何正确配置Python解释器了？下面的方法将会对你正确指导。

Windows（Python 3.8.9)

IDLE:官网：https://www.python.org/downloads/
点击网址进入官网，搜索Python 3.8.9

然后找到它

看系统是多少位的就根据多少位选择

下载后点击Next,根据自己爱好来安装（借3.4.4来当教材，安装原理一样）

确认后只需等待一会就可安装完成。
如果不确定是否安装完成，可以在Command(Cmd)中输入Python。如果安装成功输出如下

如果失败可以尝试一下点击Repair（别说九年教育了连这个词都不懂），修复完后重试通常都能成功。

PyCharm(官网：https://www.jetbrains.com/pycharm/）

进入官网后找到Download PyCharm now,然后找到社区(community)版本下载（专业版需要付费，社区版是免费的）。

然后（可以根据自己实际情况选磁盘）

根据自己的系统位数选择勾选安装，然后安装（install）


下载完后，创建一个新Project，并选择合适的解释器

成功

Linux与Mac OS

Linux

IDEA：
Linux 系统是为编程而生的，因此绝大多数的 Linux 发行版（Ubuntu、CentOS 等）都默认自带了 Python。有的 Linux 发行版甚至还会自带两个版本的 Python，例如最新版的 Ubuntu 会自带 Python 2.x 和 Python 3.x。

打开 Linux 发行版内置的终端（Terminal），输入python命令就可以检测是否安装了 Python，以及安装了哪个版本，如下所示：

[c.biancheng.net@localhost ~]$ python
Python 2.7.5 (default, Jun 17 2014, 18:11:42)
[GCC 4.8.2 20140120 (Red Hat 4.8.2-16)] on linux2
Type "help", "copyright", "credits" or "license" for more information.
>>>

可以看到，python命令能够正常运行，并输出了 Python 的版本信息，这表明当前的 Linux 发行版已经自带了 Python 2.7.5。

大部分的 Linux 发行版会自带 Python 2.x，但是不一定自带 Python 3.x，要想检测当前 Linux 发行版是否安装了 Python 3.x，可以在终端`

（Terminal）输入python3命令，如下所示：
[c.biancheng.net@localhost ~]$ Python3
Python 3.6.4 (default , Nov 18 2018 , 13:02:36)
[GCC 4.8.2 20140120 (Red Hat 4.8.2-16)] on linux2
Type "help","copyright","credits" or "license" for more information.
>>>

如果python3命令运行成功，并出现 Python 提示符>>>，则表明当前 Linux 发行版已经安装了 Python 3 开发环境，只需执行python3命令就可以启动 Python 3 开发环境。

如果当前 Linux 发行版没有安装 Python 3，或者你觉得现有的 Python 3 版本不够新，那么就需要更新 Python 版本。本节我们以 Ubuntu 为例来进行演示。
更新 Python 版本
在 Ubuntu 终端执行以下两条命令即可更新 Python 版本：

$sudo apt-get update
$sudo apt-get install python3.8

对命令的说明：
第一条命令用来指定更新 /etc/apt/sources.list 和 /etc/apt/sources.list.d 所列出的源地址，这样能够保证获得最新的安装包。
第二条命令用来指定安装 Python 3.8，这是目前最新的 Python 版本。

等待以上两条命令执行完成，再次在终端输入python3命令，就可以看到 Python 交互式编程环境已经更新到 Python 3.8。
重新安装 Python
以上更新方法仅在 Ubuntu 已经安装 Python 的情况下才有效，如果你的 Ubuntu 中没有 Python 环境，或者你想重新安装，那么就得到官网下载源代码，然后自己编译。

1. 下载源代码
   Python 官方下载地址：https://www.python.org/downloads/

打开链接，可以看到各个版本的 Python：

Python 下载页面截图
图 1 Python 下载页面截图

点击上图中的版本号或者“Download”按钮进入对应版本的下载页面，滚动到最后即可看到各个平台的 Python 安装包。

找到源码包地址
图 2 找到源码包地址

在“Gzipped source tarball”处单击鼠标右键，从弹出菜单中选择“复制链接地址”，即可得到.tgz格式的源码压缩包地址。

然后执行以下命令：

$ wget https://www.python.org/ftp/python/3.8.1/Python-3.8.1.tgz

解压源码包：

$ tar -zxvf Python-3.8.1.tgz

2. 编译
   使用 make 工具进行编译：

$ ./configure  --prefix=/usr/local
$ make&&sudo make install

这里的–prefix=/usr/local用于指定安装目录（建议指定）。如果不指定，就会使用默认的安装目录。

经过以上几个命令，我们就安装好了 Python，这时就可以进入终端，输入 Python 指令，验证是否已安装成功。
小技巧
python命令默认调用的是 Python 2.x 开发环境，如果你习惯使用 Python 3.x，感觉每次输入python3命令有点麻烦，那么你可以修改配置，让python命令转而调用 Python 3.x 开发环境。具体命令如下：

$sudo unlink /usr/bin/python
$sudo ln -s /usr/bin/python3.8 /usr/bin/python

注意，第二条命令中 Python 3.x 的路径和版本一定要正确。

上述命令执行完成以后，再次在终端输入python命令，进入的就是 Python 3.8 的交互式开发环境了。

Mac OS

和 Linux 发行版类似，最新版的 Mac OS X 也会默认自带 Python 2.x。

我们可以在终端（Terminal）窗口中输入python命令来检测是否安装了 Python 开发环境，以及安装了哪个版本，如下所示：
c.biancheng.net:~ mozhiyan$ python
Python 2.7.10 (default, Jul 30 2016, 18:31:42)
[GCC 4.2.1 Compatible Apple LLVM 8.0.0 (clang-800.0.34)] on darwin
Type “help”, “copyright”, “credits” or “license” for more information.
可以看到，python命令能够正常运行，并输出了 Python 的版本信息，这表明当前的 Mac OS X 系统已经自带了 Python 2.7.10。

python命令默认指向 Python 2.x 开发环境，如果想检测当前 Mac OS X 是否安装了 Python 3.x，可以在终端（Terminal）窗口中输入python3命令：
如果系统提示command not found，则说明没有安装 Python 3.x；
如果python3命令运行成功，并显示出版本信息，则说明已经安装了 Python 3.x。

对于没有安装 Python 3.x 的 Mac OS X，想要安装也非常简单，用户只需要下载安装包，然后一直“下一步”即可，这和 Windows 安装 Python 的过程是非常类似的。
Mac OS X 安装 Python 3.x
Python 官方下载地址：https://www.python.org/downloads/

打开链接，可以看到各个版本的 Python：

图 1 Python 下载页面截图

点击上图中的版本号或者“Download”按钮进入对应版本的下载页面，滚动到最后即可看到各个平台的 Python 安装包。

图 2 各个平台的 Python 安装包

macOS 64-bit installer即为 Mac OS X 系统的 Python 安装包。点击该链接，下载完成后得到一个 python-3.8.1-macosx10.9.pkg 安装包。

双击 python-3.8.1-macosx10.9.pkg 就进入了 Python 安装向导，然后按照向导一步一步向下安装，一切保持默认即可。

图 1 Python安装向导

安装完成以后，你的 Mac OS X 上将同时存在 Python 3.x 和 Python 2.x 的运行环境，在终端（Terminal）输入python命令将进入 Python 2.x 开发环境，在终端（Terminal）输入python3命令将进入 Python 3.x 开发环境。
c.biancheng.net:~ mozhiyan$ python3
Python 3.8.1 (v3.8.1:1b293b6006, Dec 18 2019, 14:08:53)
[Clang 6.0 (clang-600.0.57)] on darwin
Type “help”, “copyright”, “credits” or “license” for more information.
与 Windows 系统类似，Mac OS 下的 Python 3.x 也会自带 IDLE 简易开发工具，你可以在程序列表中找到它。

图 2 安装完成以后的程序列表

第三章：Python基础

3.1： Python的输出（略讲，第五章将会与输入一同详细讲）

在Python中，如果想要输出一些特定数据，我们就必须用到print()函数
利用Print()函数输出的方法有很多中，比如我喜欢了一个叫LWL的小女孩，我要去简单表白。如果我想要节省字节免得占磁盘的话，我可以

print('LWL我喜欢你，可不可以做我女朋友呀？')

如果觉得无所谓，也可以

Loveyou='LWL我喜欢你，可不可以做我女朋友呀？'
print(Loveyou)

你也可以把字串符结合再输出

Love='LWL我喜欢你，'
you='可不可以做我女朋友呀？'
print(Love + you)

或者来点更高b格的

def Loveyou1314():
	print('LWL我喜欢你，不知你可不可以做我女朋友')
Loveyou1314()

这个输出是运用到自定义函数输出，关于Python的函数与内置函数以后会讲。

3.2:Python数据类型(数字)

在Python中，数字数据类型有int、float、bool（布尔型）、complex（复数）。在这里要提醒一下学过C语言的人，在Python中浮点类型只有单精度float，不要以为保留两位小数的数就是双精度类型(double),在Python中无论你是多少位小数它的数据类型都是float。
当然，如果你想判断该数字的数据类型，你可以尝试用type()函数来判定，如以下代码实例：

a6,a5,a3,a2,a1=4 + 7j,47.88 ,47 ,47.8 ,47.88888
a4=False
print(type(a1),type(a2),type(a3),type(a4),type(a5),type(a6))

输出如下

当然，也可以用isinstance()函数来判定，结果返回True代表你认为的数据类型是正确的，False就代表错误。

a6,a5,a3,a2,a1=4 + 7j,47.88 ,47 ,47.8 ,47.88888
a4=False
print("Type a1:",type(a1),isinstance(a1, type(a1)),)
      
print("Type a2:",type(a2),isinstance(a2, type(a2)),)
print("Type a1\3:",type(a3),isinstance(a3, type(a3)),)
print("Type a4:",type(a4),isinstance(a4, type(a4)),)
print("Type a5:",type(a5),isinstance(a5, type(a5)),)
print("Type a6:",type(a6),isinstance(a6, type(a6)),)

输出

好了，既然学完了数字数据类型，那么也学下算术运算符吧。

3.2.1:算术运算符

在Python中，运算符有：+、-、*、/、%、**、//(加、减、乘、除、取模、次方、整除）
+:加法，两个变量相加求和
-:减法，两个变量相减求差
*：乘法，变量相乘求积
/：除法，变量相除求商
%：取模，得到除法结果第一位余数
**：次方，求变量（a）的n次幂->(a)ⁿ，可以用pow()函数代替
//：整除，取除法后的整数部分
学完算术运算符后，我们可以与之前学过的数字数据类型来结合使用。

a = 1314
b = 521
print(a+b,a-b,a*b,a/b,a%b,a**b,pow(a,b),a//b,)

输出如下

3.3：Python数据类型（字串符：string）

在Python中，数据类型不仅仅有数字数据类型，当然也有其他的，string（字串符）数据类型也是其中一种。
如果你想换行转义输出，你可以在要转义的字串符之间加个\n（PS：反斜杠\是特殊转义字符），但在字串符前加个r将会是原字串符输出。

a = 'Hello','LWL'
b = 'Hello''LWL'	
#注意字串符a与b的区别，如果有逗号，
#那么输出时将会是两个字串符一起输出，如
#果没有输出将会两个字串符相互结合输出

c,d= 'Hello','LWL'
print(a)
print(b)
print(c,d)
print(c+d)
print(b[0:-2])
print(c[0:-3])
print(d[0:-1])
print(c*2,d*2)#各输出两次
print((c+d)*2)#结合输出两次
print('Hello,\nLWL')
print(r'Hello,LWL')#加了r后转义字符失效
e='Love LWL 1314'
print(e[0],e[5])#输出指定索引位置的字母
print(e[0],e[-2],e[3])#Python与C语言字串符不同的地方在于Python字串符是不可以被改变的，
                      #如果向一个指定索引赋值，那么将会错误

输出结果如下

3.3:Python数据类型（列表:List）

在Python中，复合数据类型分别有三种：Tuple（元组）、Set（集合）与List（列表）。然后今天教的复合数据类型就是这三类之中最easist的一类：List（列表）
在Python中，创建一个列表数据类型方法如下

变量名称 = ['数值',数值]

在列表的数值内容中，数值可以类型不同，但要记住的一点是：**除数字以外其他任何数值都必须要用单引号括起（无论是中文还是其他国家语言，都必须要），而数字数值可以不用单引号括起）。**代码实例如下
PS：具体内容已在注释

a = ['a','b','c',3] #创建两个列表
b = [4,7,'love','to','lwl',',','never','change']
print(a,b)
print(a[0:1:3]) #输出指定列表被切割后的指定数据
print(b[1:7])
print(a[3]) #输出指定索引搜索的数据
print(b[7])
a[0:3]='A','B','C'  #修改列表中指定数据，即可以直接修改
print(a)
b.append(347)   #append()函数用于在制定列表末尾添加新数值
print(b)
a[1]=[] #移除a列表中指定索引数据
print(a)
print('a列表数据个数:',len(a),'b列表数据个数:',len(b))  #len()函数用于统计列表数据个数
c=[0,1]   #生成一个嵌入式列表
d=[2,3]
e=[c,d]
print(e)

3.4:Python数据类型（Tuple:元组）

在Python中，元组的语法与列表差不多，不同之处就是元组使用小括号（），且括号中元素不能被改变，创建元组可以不需要括号;而列表是使用中括号[]。
因此想要把列表转换为元组或元组转换为列表，只需要改一下括号即可

变量名称 = ('元素',元素)
变量名称 = "元素","元素"

创建元组实例

a = ('C/c++','Python',2)	#创建两个元组
b = "Python菜中菜的菜鸟","Love to lxx for Li wenli","never change"
print(a,b)

创建一个空的元组

a = ()

因为元组与列表语法相似，所以元组可以与其他元组结合为一个新元组并输出

a = ('C/C++','Python',2)	#创建两个元组
b = "Python菜中菜的菜鸟","Love to lxx for Li wenli","never change"
c = a+b #相互结合
print(c)

输出

如果想删除元组，那么可以用del语句来实现

a = ('C/C++','Python',2)	#创建两个元组
b = "Python菜中菜的菜鸟","Love to lxx for Li wenli","never change"
c = a+b #相互结合
print(c)
del c
print(c)

因后元组被删除所以会输出异常

当然，元组也和字串符一样支持+和*运算符（具体已在注释表面）

a = ('C/C++','Python',2)	#创建两个元组
b = "Python菜中菜的菜鸟","Love to lxx for Li wenli","never change"
c = a+b #相互结合
print(len(c))#输出c元组内数据个数
print(c*2)#复制输出
print(b in ("Python菜中菜的菜鸟","Love to lxx for Li wenli","never change"))
#判断元素是否存在
for c in ("Python菜中菜的菜鸟","Love to lxx for Li wenli","never change",'C/C++','Python',2):
      print(c,) #迭代输出

输出

元组的内置函数（具体在注释）

a = ['C/C++','Python',2,4]	#创建列表
b = ["Python菜中菜的菜鸟","Love to lwl for Li wenli","never change"]
c = a+b #相互结合
c = tuple(c)#强制转换为元组
print(len(c))#输出列表内数据个数
d = ('3','4','7')
print(max(d))#输出d元组内最大数值
print(min(d))#输出d元组内最小数值，max()是判断最大值函数，min()反之

输出

3.5:Python数据类型（Set:集合）

Set（集合）数据类型它和Tuple、List一样都属于复合数据类型，而且集合数据类型是一种无序不重复元素的序列
在Python中，我们可以使用大括号｛｝或内置函数Set()来创建一个集合(创建一个空集合必须用Set()函数，不可用｛｝，因为｛｝实质是创建一个空的字典
格式实例

a = {'a','b','c','d','a'}#创建集合a
print(a)#因为集合是无序不重复元素序列，所以不会输出多出的a
b = set('sdgsdggfdgdasrfdsf')#运用Set()函数创建集合b
print(b)

输出

判断元素是否在集合内

a = {'a','b','c','d','a'}#创建集合a
print('a' in a，'e' in a)

在这个代码中代码片段’a’ in a与’e’ in a主要判断a与e元素是否在此集合内，如果在就输出True，反之位False。
输出结果

与List与Tuple一样，Set也支持数学运算符运算，不同运算符使用范围也不同

a = set('sdfygsyfysdgfsdtfsyhf')
b = set('hgdhsdfsghdvhgsfs')
print(a - b)
print(a | b)
print(a & b)
print(a ^ b)

在这里面，减号(-)的作用就是输出a集合中b集合内没有的元素，竖线符号(|)主要输出集合a或b中包含的元素，逻辑符号(&:and,和，拉丁美语为et)就是要输出集合a和b中共同包含的元素，乘方(^)主要输出不同时包含于a和b的元素。
输出结果

在集合中，我们可以使用关键字add或update来添加新的元素

b = set('hgdhsdfsghdvhgsfs')
print(b)
b.add('fuck')
b.update('good')
print(b)

输出结果，大家对照会发现，每次输出都会有不同的新元素输出

============== RESTART: C:\Users\Administrator\Desktop\新建文件夹\4.py ==============
{'h', 'g', 'f', 's', 'v', 'd'}
{'h', 'fuck', 'g', 'f', 's', 'v', 'o', 'd'}

当然，如果想要删除某些元素，可以使用关键字remove，discard或pop(pop会随机删除某些元素)

b = set('abcdefghijk,fuck,abats')
print(b)
b.remove('f')
print(b)
b.discard('h')
print(b)
b.pop()
print(b)

在这里remove与discard分别删除f与h元素，而pop扶着随机删除集合内任意一个元素

============== RESTART: C:\Users\Administrator\Desktop\新建文件夹\4.py ==============
{'j', 't', 'h', 'k', 'b', 'd', 's', 'f', 'g', 'i', ',', 'a', 'c', 'e', 'u'}
{'j', 't', 'h', 'k', 'b', 'd', 's', 'g', 'i', ',', 'a', 'c', 'e', 'u'}
{'j', 't', 'k', 'b', 'd', 's', 'g', 'i', ',', 'a', 'c', 'e', 'u'}
{'t', 'k', 'b', 'd', 's', 'g', 'i', ',', 'a', 'c', 'e', 'u'}
>>> 
============== RESTART: C:\Users\Administrator\Desktop\新建文件夹\4.py ==============
{'e', 'd', 's', 'g', 'h', 'b', 'c', 'i', 'f', 'k', 'u', 'j', 'a', ',', 't'}
{'e', 'd', 's', 'g', 'h', 'b', 'c', 'i', 'k', 'u', 'j', 'a', ',', 't'}
{'e', 'd', 's', 'g', 'b', 'c', 'i', 'k', 'u', 'j', 'a', ',', 't'}
{'d', 's', 'g', 'b', 'c', 'i', 'k', 'u', 'j', 'a', ',', 't'}
>>> 

大家仔细观察一下，两次输出虽然因为无序输出导致输出不同，但最后删除的元素都分别不同，第一次删除元素为字母j，第二次为字母e。
当然，如果觉得删除一个不过瘾，大家可以使用函数clear()来进行全部删除 😃

b = set('abcdefghijk,fuck,abats')
print(b)
b.clear()
print(b)

在这个代码中第一次输出因为没有使用clear()函数清除因此正常输出，而第二次输出使用了clear()函数删库跑路了，所以只能输出一个空的集合。因此，输出结果如下

============== RESTART: C:\Users\Administrator\Desktop\新建文件夹\4.py ==============
{'t', 'a', 'k', 'c', 'i', 'j', 'b', 'f', 's', ',', 'd', 'u', 'g', 'e', 'h'}
set()
>>> 

3.6:Python数据类型(字典:dictionary)

在Python中，字典是另外一种数据储存的可变容器，而且可以存储任何数据类型的数据值对象。
在上一节提及到，创建一个空字典需要用大括号｛｝，在字典中每一个值对用冒号，且每个值需要逗号（,）分隔。

a = {key1:value1,key2:value2,key3:value3}

dictionary{key->1value1
				key2->value2
				key3->value3

下面将演示创建一个字典并输出

```python
a = {'a':'Python','b':'347','c':'hjgjhfgy'}#创建一个字典
b = {'a':'HTML/Javascript','b':'Rust'}
print(b)
print(a['a'],a['c'])

在这个代码中a['a']与a['c']是分别访问并输出字典内对应数据值，与索引方式差不多，而print(b)则负责输出整个字典b内数据。
输出结果

```python
============== RESTART: C:\Users\Administrator\Desktop\新建文件夹\4.py ==============
{'a': 'HTML/Javascript', 'b': 'Rust'}
Python hjgjhfgy

如果要输出的值字典内没有，那么输出将会显示异常。

a = {'a':'Python','b':'347','c':'hjgjhfgy'}#创建一个字典
b = {'a':'HTML/Javascript','b':'Rust'}
print(b)
print(a['a'],a['d'])

输出

Traceback (most recent call last):
  File "C:\Users\Administrator\Desktop\新建文件夹\4.py", line 4, in <module>
    print(a['a'],a['d'])
KeyError: 'd'

想要修改字典内的数据很简单，与前面的复合数据类型修改方式一样，不过要注意字典修改数据时修改对象填的不是数字，而是对应的名称。

a = {'a':'Python','b':'347','c':'hjgjhfgy'}#创建一个字典
b = {'a':'HTML/Javascript','b':'Rust'}
print(b)
print(a['a'],a['c'])
a['c']='Perl'
print(a['a'],a['c'])

输出

============== RESTART: C:\Users\Administrator\Desktop\新建文件夹\4.py ==============
{'a': 'HTML/Javascript', 'b': 'Rust'}
Python hjgjhfgy
Python Perl

清除字典数据也很简单，与集合一样，使用clear()函数，然而删除的话就需要用到del语句

a = {'a':'Python','b':'347','c':'hjgjhfgy'}#创建一个字典
print(a)
a.clear()#清除字典所有数据
print(a)
del a#删除字典
print(a)

因为del语句把字典删除了，所以输出异常
输出如下

{'a': 'Python', 'b': '347', 'c': 'hjgjhfgy'}
{}
Traceback (most recent call last):
  File "C:\Users\Administrator\Desktop\新建文件夹\4.py", line 6, in <module>
    print(a)
NameError: name 'a' is not defined

第四章：代码格式整洁与三种流行编程规则

4.1：格式整洁

在平时写代码时，我想有一部分人他们平时可能不会注意代码的整洁性，所以写出来的代码都是一坨坨的，导致自己或他人维护会显得很不方便。例如以下C语言迷宫代码

#include<stdio.h>#include<stdlib.h>#include<coin.h>
int map[10][10]={0,0,0,0,0,0,0,0,0,0,
				 0,1,2,1,0,0,0,0,0,0,
				 0,1,1,1,0,0,0,0,0,0,
     			 0,0,1,1,0,0,0,0,0,0,
				 0,0,0,1,0,0,0,0,0,0,
				 0,0,0,1,0,0,0,0,0,0,
				 0,0,0,1,1,0,0,0,0,0,
				 0,0,0,0,1,0,0,0,0,0,
  				 0,0,0,0,1,1,1,1,1,1,
				 0,0,0,0,0,0,0,0,0,0,};void DrawMap();void playGame();int main(){while(1){DrawMap();playGame();system("cls");}}
void DrawMap(){int i,j;
for(i=0; i<10; i++){for(j=0; j<10; j++){if(map[i][j]==0){printf("□");}else if(map[i][j]==1){printf(" ");}else{printf("*");}}printf("\n");}}
void playGame(){char key=getch();int i,j;for(i=0;i<10;i++){for(j=0;j<10;j++){if(map[i][j]==2){break; }}if(map[i][j]==2){break;}}

因为字数限制导致无法显示完全，但从这一部分代码可以看出此代码非常不美观且难以维护。但如果我们加入缩进与换行

#include<stdio.h>#include<stdlib.h>#include<coin.h>
int map[10][10]={0,0,0,0,0,0,0,0,0,0,
				 0,1,2,1,0,0,0,0,0,0,
				 0,1,1,1,0,0,0,0,0,0,
     			 0,0,1,1,0,0,0,0,0,0,
				 0,0,0,1,0,0,0,0,0,0,
				 0,0,0,1,0,0,0,0,0,0,
				 0,0,0,1,1,0,0,0,0,0,
				 0,0,0,0,1,0,0,0,0,0,
  				 0,0,0,0,1,1,1,1,1,1,
				 0,0,0,0,0,0,0,0,0,0,};void DrawMap();void playGame();int main(){while(1){DrawMap();playGame();system("cls");}}
void DrawMap(){int i,j;
for(i=0; i<10; i++)
	{
for(j=0; j<10; j++)
	{
if(map[i][j]==0)
	{
                printf("□");
            }
            else if(map[i][j]==1)
            {
                printf(" ");
            }
            else
            {
                printf("*");
            }        
        }
        printf("\n");
    }}
void playGame(){	 char key=getch();
	int i,j;
	for(i=0;i<10;i++)
	{
		for(j=0;j<10;j++)
		{
			if(map[i][j]==2)
			{
				break; 
			}
			 }
        if(map[i][j]==2)
        {
            break;
        }
		}
	switch(key){
	 case'w':
	 	if(map[i-1][j]==1)
	 	{
	 		map[i][j]=map[i][j]-1;
	 		map[i-1][j]=map[i-1][j]+1;
	 		break;
		 }
	case's':
		if(map[i+1][j]==1)
		{
			map[i][j]=map[i][j]-1;
			map[i+1][j]=map[i+1][j]+1;
			break;
		}
	case'a':
		if(map[i][j-1]==1)
		{
			map[i][j]=map[i][j]-1;
			map[i][j-1]=map[i][j-1]+1;
			break;
		}
	case'd':
		if(map[i][j+1]==1)
		{
			map[i][j]=map[i][j]-1;
			map[i][j+1]=map[i][j+1]+1;
			break;
		}
		   }
		   system("PAUSE");
}  

看起来是否觉得舒服很多？想维护的欲望是否增加许多？
当然，在其他语言比如C/C++可能还有可以不遵守代码整洁这首歌唱，但在Python这里这首歌可就Say goodbye了。因为如果你不遵守代码格式整洁，报错将会可能把你给逼疯。
如以下Python代码

	a = '要是时光可以倒流那该多好，要是可以那么就可以多陪汶励一段时间了。'
print(a)

在此代码中，因为变量a前面有一个缩进，所以代码在运行时将会报错，无法运行

如果我们将缩进去掉，那么将可以正常运行代码
输出如下

要是时光可以倒流那该多好，要是可以那么就可以多陪汶励一段时间了。

好了，废话不多说，开始进入写法教程

4.2：编程规则

匈牙利命名法

匈牙利命名法是由Microsoft 程序员查尔斯- 西蒙尼(Charles Simonyi)提出，匈牙利命名法通过在变量名前面加上相应的小写字母的符号标识作为前缀，标识出变量的作用域，类型等这些符号可以多个同时使用，顺序是先m_（成员变量）， 再指针，再简单数据类型，再其它 。如c_MessageBox

属性+类型+描述
属性一般是小写字母+_:
g_:全局变量
m_:类成员变量
s_:静态变量
c_:常量
类型就多了：
b:bool
sz:以零结束的字符串
p:指针
n:整整
dw:双字
l:长整型
无符号:u
函数:fn

驼峰命名法

驼峰命名法包含了小驼峰命名法与大驼峰命名法，顾名思义利用了驼峰命名法来命名变量该变量也会有些高低起伏。好了，废话不多说，继续进入正题
**小驼峰命名法：**变量名称开头小写，然后后面英文隔一部分后开始大写一个英文字母，如conTent…
代码实例如下

conTent = '我的目标就是在这个月突破100粉！'
print(conTent)

输出如下

我的目标就是在这个月突破100粉！

**大驼峰命名法：**变量开头大写，后面每隔一部分英文后就大写一个英文字母，如ConTent,FirstName,MessageBox…
代码示例如下

MessageBox = "我对汶励的爱永世不变"
print(MessageBox)

输出如下

我对汶励的爱永世不变

帕斯卡命名法

与大驼峰命名法一样，都是开头大写，后面每隔一部分英文后就大写一个英文字母

MessageBox = "我对汶励的爱永世不变"
print(MessageBox)

输出如下

我对汶励的爱永世不变

好了，了解完基本数据类型和代码整洁与流行规范后，现在就开始正式入门吧！
废话不多说，正式开讲！

第五章：正式入门Python

在前文，我们配置好了Python的开发环境，了解了Python的基本数据类型和代码格式与流行规则后，相信大家对Python的基础知识有了一些了解。好了，废话不多说，让我们现在就开始正式入门Python吧！

5.1：print()函数讲解

在所有编程语言中，想要输出一组数据值，就必须定义常量与变量。常量嘛，大家就理解为是一个定义名称，且是定死的就行；变量这个东西，它可以是一组数据，一组数字，一组字串符，或者其他的等等。如以下代码示例

a = 347
b = 'abcd'

在这个代码中，347与字串符abcd就是变量，它们分别通过等于号(=)赋值给a与b。不过别以为写到这里运行时就会有结果输出，想要有结果输出，我们还需要用到一个函数：print()。

a = 347
b = 'abcd'
print(a,b)

在这个代码中，我们调用了print()函数。在数据值赋值给a与b后，然后将a和b传输到print()函数中，之后就可以输出结果了。
输出如下

347 abcd

当然，你也可以偷懒，把数据值直接赋值到print()函数中并输出。按照程序界悠久的历史传统，我们编写的第一个程序就是输出Hello world!。因此，我们想要输出Hello world!，我们也可以直接赋值到print()函数中

print('Hello world')

在刚刚的代码中，我们将Hello world！直接赋值入print函数中，并让它输出
输出结果如下

Hello world!

5.2:利用单引号(‘’)或双引号(“”)包装并输出

在Python中，如果你想赋值一个字串符变量时（数字也可以，不过有些多此一举），你必须要用单引号(‘’)或双引号(“”)包装你要输出的字串符数据值，否则直接赋值的话该写法是不符合语法的（除数字数据类型以外其他数据类型都一样）。因此，这一章我将会教大家单引号(‘’)或双引号(“”)再用print()函数输出

a = '我的目标是上高中后努力学习，考一所好的大学，拿到一个大厂的office，给汶励一个好的生活。'
print(a)

a = "我的目标是上高中后努力学习，考一所好的大学，拿到一个大厂的office，给汶励一个好的生活。"
print(a)

输出结果如下图

我的目标是上高中后努力学习，考一所好的大学，拿到一个大厂的office，给汶励一个好的生活。

在这里的例子，我们用到了’'或""对字串符进行包装，然后赋值给a，最后通过print()函数进行输出结果。虽然这种方法是比上一章讲到的直接输出复杂了些 ，但这种方法可比直接传递输出高级多了。
PS：不积跬步，无以至千里；不积小流，无以成江海。做人，不可做井底之蛙，不可做孤陋寡闻之人，因此我们不能因为新方法的复杂而不去学。只有去学习，去汲取新知识，这样才会慢慢进步 ，成为一个才高八斗、出类拔萃的人。

5.3:输出结合

在Python中，如果我们想要输出一段很长的文本，我们可以选择直接赋值在一个常量中并且输出，当然也可以选择赋值在多个常量中在最后结合输出。然而我们想要实现这种效果，在这里我们就必须要用到一个算术运算符：+。如下面代码例子

a = "我的目标是上高中后努力学习，"
b = "考一所好的大学，"
c = "拿到一个大厂的office，给汶励一个好的生活。"
print(a+b+c)

输出结果如下

我的目标是上高中后努力学习，考一所好的大学，拿到一个大厂的office，给汶励一个好的生活。

5.4:输入与输出

前文我已教大家如何赋值并且输出，现在我将教大家如何输入赋值至常量并输出。
在平时许多软件或其他东西中，想要得到一个想要的结果，就必须输入一些数据值使满足运行条件，如生活中的计算器、或者我们的浏览器等。然而我们在Python中如何实现这种效果了？这时我们就要用到一个函数–input()。具体例子如下：

a = input()
print(a)

如果我这时输入一组字串符：算了，还是做回我的前端开发这个老本行吧。输出结果如下：

算了，还是做回我的前端开发这个老本行吧。

在这个代码中，实现原理就是通过input()函数获取我输入的数据值，然后把这组数据赋值给常量a,然后常量a把数据传递给print()函数，最终输出。
当然，我们也可以结合前面我们所学过的算术运算符与float数据类型做一个超简易计算器（由于是最基础的，所以使用较麻烦）

a = input()
b = input("请输入运算符号")
c = input()
if (b == '+'):
    print(float(a)+float(c))
elif (b == '-'):
    print(float(a)-float(c))
elif (b == '*'):
    print(float(a)*float(c))
elif (b == '/'):
    print(float(a)/float(c))
elif (b == '%'):
    print(float(a)%float(c))
elif (b == '**'):
    print(float(a)**float(c))
elif (b == '//'):
    print(float(a)//float(c))

当我输入22/7时，输出如下

3.142857142857143

当然，input()函数作为一个万能的输入函数，他也可以和其他数据类型相结合，如集合，列表，元组等藕合数据类型，也可以与字典，字串符等数据类型结合使用。如下面例子

a = (str(input()))
b = (list(input()))     #创建一个空列表
c = (tuple(input()))    #创建一个空元组
d = (set(input()))      #创建一个空集合
e = {}  #创建一个空字典
e_ElementName = input("请输入名称:")
e_ValueContent = input("请输入内容:")
e[e_ElementName] = e_ValueContent
print("您输入的字串符:",a)
print("列表结果:",b)
print("元组结果:",c)
print("集合结果:",d)
print("字典结果:",e)

代码原理：通过运用input()函数对创建的各个数据类型与其对应的常量赋值，并传递给相对应的print()函数，最后输出结果。

第六章：判断语句

在所有编程语言中与我们平时写的很多程序中，我们几乎都要运用到判断语句，通过判断语句来帮助我们写的这个程序判断是否达到某个代码块运行的条件。因此我们想实现判断条件是否符合某个代码块运行的条件，那么我们就需要运用到判断语句。在Python中，判断语句有if、if…else、if…elif…else。关键词有or与and。
那么现在我们先从最基础的if语句先开始吧。

6.1：if的用法

具体例子代码如下:

me =int(input())
wl = int(input())
if me < wl :
   print("Lwl赢了")
if me > wl :
   print("我赢了")

代码原理：假如我和WL各输入一个数字，如果WL输入的数字大于我条件为真，输出wl赢了;如果我输入的数字大于WL，条件为虽然也为真，但输出的是与之相对应的结果语句。

6.2： if…else的用法

具体代码例子如下:

me = int(input())
wl = int(input())
if me < wl :
   print("WL赢了")
else :
   print("我赢了")

代码原理:假如我和XX各输入一个数字，如果XX输入的数字比我大，条件为真，输出XX赢了。反之，条件为假，输出我赢了。

6.3:if…elif…else用法

me = int(input())
wl = int(input())
if me < wl : 
   print("WL赢了")
elif me == WL :
  print("打平手了")
else :
   print("我赢了")

代码原理:假如我和XX各输入一个数字，如果XX的比我大，条件为真，输出XX赢了。如果相同，条件为方案2，输出打平手了。反之，输出我赢了。
好了，学完if…elif…else语句，我们可以尝试做一个猜数小游戏了，具体例子如下

import random
a = True
while a:
    b = int(random.random())
    c = int(input("猜数小游戏：请输入一个数字，看一下你猜不猜的中"))
    if c == b :
        print("恭喜你猜中了")
    elif c > b :
        print("输入的数字太大了，再来一次")    
    elif c < b :
        print("输入的太小了，再输入大一点的数字，再来一次")

代码原理：通过运用random模块（以后会在模块章节详讲）来调用random函数，从而生成随机数字并赋值给判断语句来判断。如果玩家输入的数字刚好时随机数，条件为真，输出恭喜你猜中了。反之，如果大于随机数。输出输入的数字太大了，再来一次；小于，输出输入的太小了，再输入大一点的数字，再来一次。

6.4：and的用法

原理：我们输入两个变量条件，如果两个条件均符合，条件为真，输出方案1或方案2;如果不符合，条件为假，输出方案3.具体例子如下：

me = int(input())
wl = int(input())
if me == 520 and wl == 520 :
   print("就知道你爱我。")
else :
   print("这不是你的真心话。")

me = int(input())
wl = int(input())
if me  == 520 and wl == 520 :
   print("就知道你爱我。")
elif me == 1314 and wl == 1314 :
   print("我会一生一世爱你，不仅与你白头到老，而且never change。")
else :
   print("这不是你的真心话。")

:6.5：or的用法

原理：我和LXX各输入一个变量条件，如果有一个条件符合已定的条件，为真，输出方案1或2;为假，输出方案3.具体例子如下：

me = int(input())
wl = int(input())
if me == 520 or wl == 520 :
   print("就知道你爱我。")
else :
   print("这不是你的真心话。")

me = int(input())
wl = int(input())
if me  == 520 or wl == 520 :
   print("就知道你爱我。")
elif me == 99 or wl == 99 :
   print("不错")
else :
   print("这不是你的真心话。")

6.6：操作运算符（补充点）

< ：小于，用于判断变量是否小于常量
> ： 大于，用于判断变量是否大于常量
>= ：大于或等于，用于判断变量是否大于或等于常量
<= ：小于或等于，用于判断变量是否小于或等于常量
== ：等于，用于判断两个常量是否相等
!= :不等于，用于判断两个常量是否不等于

代码原理：我和LXX各输入一个变量条件，如果变量条件为我为520，XX不为520，则输出方案一；如果变量条件为6（5< me and xx <7）时，输出方案二；
如果变量条件为64<=me and XX <=103时，输出方案三；如果均为1314，则输出方案四。代码示例如下

while True:
    me = int(input())
    wl = int(input())
    if me ==520 and wl != 520:
        print('这不是你的真心话')
    elif me > 5 and wl < 7:
        print('我跟你的相遇就像是酸遇上了碱，我们彼此中和，释放出了热与激情。')
        print('我对你的感情就像是钡离子与硫酸根的完美结合，生成了美好的感情沉淀。')
        print('我知道你的未来就像是Li  Na K Ru Cr Ba Ca Sr 的焰色反应一样五彩缤纷，最后希望你能像王水一样所向无敌，溶解掉所有的困难，走向成功。')
    elif me >= 64 and wl <= 103:
        print('我爱你，我会爱你爱到CuSO4 + Ba(OH)2=BaSO4↓+Cu(OH)2 ↓这两个产物无法分离提纯。')
    elif me and wl == 1314:
        print('我夺走了你的电子，请不要生气，我是为了更稳定的跟你结合在一起.')

效果图如下:

第七章：循环语句

在所有编程语言中与我们平时写的很多程序中，我们很多时候需要运用到循环语句，通过循环语句可以帮助我们在程序执行时循环某一个条件以保证程序正常运行，或者循环输出某一个常量，达到程序多输出效果。因此我们想实现上述条件时，我们就需要运用到循环语句。在Python中，循环语句有for和while。PS:Python中没有do …while循环语句！

7.1：for循环语句

在Python中， for 循环可以遍历任何可迭代对象，如一个列表或者一个字符串。（就是按顺序输出常量元素啦！）for循环语句具体格式如下

for 变量 in 顺序:
	声明
例：
for i in range(list(8)):
	print(i)

具体代码例子如下：
字串符

a = '546dsf6d6sf74ds'
for i in range(len(a)):
    print(i,':',a[i])

效果图

代码原理：先通过len()函数获取字串符长度，然后通过for循环与range()函数对其进行遍历与循环处理，最后输出每个长度位置对应的字串符结果。
列表

list = ['a',5,65,654,6545,4,464,4,':',4,48789,]
for i in range(len(list)):
    print(i,':',list[i])

效果图如下

代码原理：与字串符一样。

如果是初学python爬虫，觉得自学比较难的，那么我接下来分享的这全套 Python 学习资料一定不要错过，希望能给那些想学习 Python 的小伙伴们带来帮助！文章来源地址https://www.toymoban.com/news/detail-756848.html

到了这里，关于零基础学python：超详细的入门教程！的文章就介绍完了。如果您还想了解更多内容，请在右上角搜索TOY模板网以前的文章或继续浏览下面的相关文章，希望大家以后多多支持TOY模板网！