Python入门笔记（一）

Python的优点很多，简单的可以总结为以下几点。

简单明了，学习曲线低，比很多编程语言都容易上手。

开放源代码，拥有强大的社区和生态圈，尤其是在数据分析和机器学习领域。

解释型语言，天生具有平台可移植性，代码可以工作于不同的操作系统。

对两种主流的编程范式（面向对象编程和函数式编程）都提供了支持。

代码规范程度高，可读性强，适合有代码洁癖和强迫症的人群。

Python的缺点主要集中在以下几点。

执行效率稍低，对执行效率要求高的部分可以由其他语言（如：C、C++）编写。

代码无法加密，但是现在很多公司都不销售卖软件而是销售服务，这个问题会被弱化。

在开发时可以选择的框架太多（如Web框架就有100多个），有选择的地方就有错误。

目前Python在Web应用后端开发、云基础设施建设、DevOps、网络数据采集（爬虫）、自动化测试、数据分析、机器学习等领域都有着广泛的应用。

启动PyCharm之后会来到一个欢迎页，在欢迎页上我们可以选择“创建新项目”（Create New Project）、“打开已有项目”（Open）和“从版本控制系统中检出项目”（Get from Version Control）。

如果选择了“Create New Project”来创建新项目就会打一个创建项目的向导页。下图所示是PyCharm专业版创建新项目的向导页，可以看出专业版支持的项目类型非常的多，而社区版只能创建纯Python项目（Pure Python），没有这一系列的选项。

接下来，我们要为项目创建专属的虚拟环境，每个Python项目最好都在自己专属的虚拟环境中运行，因为每个项目对Python解释器和三方库的需求并不相同，虚拟环境对不同的项目进行了隔离。在上图所示的界面在，我们可以选择新建虚拟环境（New environment using Virtualenv），这里的“Virtualenv”是PyCharm默认选择的创建虚拟环境的工具，我们就保留这个默认的选项就可以了。

项目创建完成后就可以开始新建各种文件来书写Python代码了，如下图所示。左侧是项目浏览器，可以看到刚才创建的项目文件夹以及虚拟环境文件夹。我们可以在项目上点击鼠标右键，选择“New”，在选择“Python File”来创建Python代码文件，下图中我们创建了两个Python文件，分别是poker_game.py和salary_system.py。当然，如果愿意，也可以使用复制粘贴的方式把其他地方的Python代码文件复制到项目文件夹下。

在工作窗口点击鼠标右键可以在上下文菜单中找到“Run”选项，例如要运行salary_system.py文件，右键菜单会显示“Run 'salary_system'”选项，点击这个选项我们就可以运行Python代码啦，运行结果在屏幕下方的窗口可以看到，如下图所示。

常用操作和快捷键

PyCharm为写Python代码提供了自动补全和高亮语法功能，这也是PyCharm作为集成开发环境（IDE）的基本功能。PyCharm的“File”菜单有一个“Settings”菜单项（macOS上是在“PyCharm”菜单的“Preferences…”菜单项），这个菜单项会打开设置窗口，可以在此处对PyCharm进行设置，如下图所示。

PyCharm的菜单项中有一个非常有用的“Code”菜单，菜单中提供了自动生成代码、自动补全代码、格式化代码、移动代码等选项，这些功能对开发者来说是非常有用的，大家可以尝试使用这些菜单项或者记住它们对应的快捷键，例如在macOS上，格式化代码这个菜单项对应的快捷键是alt+command+L。除此之外，“Refactor”菜单也非常有用，它提供了一些重构代码的选项。所谓重构是在不改变代码执行结果的前提下调整代码的结构，这也是资深程序员的一项重要技能。还有一个值得一提的菜单是“VCS”，VCS是“Version Control System”（版本控制系统）的缩写，这个菜单提供了对代码版本管理的支持。版本控制的知识会在其他的课程中为大家讲解。

下表列出了一些PyCharm中特别常用的快捷键，当然如果愿意，也可以通过设置窗口中“Keymap”菜单项自定义快捷键，PyCharm本身也针对不同的操作系统和使用习惯对快捷键进行了分组。

说明：Windows系统下如果使用PyCharm的默认设置，可以将上面的command键换成ctrl键即可，唯一的例外是ctrl + space那个快捷键，因为它跟Windows系统切换输入法的快捷键是冲突的，所以在Windows系统下默认没有与之对应的快捷键。

指令和程序

计算机的硬件系统通常由五大部件构成，包括：运算器、控制器、存储器、输入设备和输出设备。其中，运算器和控制器放在一起就是我们通常所说的中央处理器，它的功能是执行各种运算和控制指令以及处理计算机软件中的数据。我们通常所说的程序实际上就是指令的集合，我们程序就是将一系列的指令按照某种方式组织到一起，然后通过这些指令去控制计算机做我们想让它做的事情。

今天的计算机也是冯诺依曼结构：

“冯·诺依曼结构”有两个关键点，一是指出要将存储设备与中央处理器分开，二是提出了将数据以二进制方式编码。

了解1？二进制以及它与我们生活中的十进制之间的转换关系，以及2？二进制与八进制和十六进制的转换关系还是有必要的。

变量是一种存储数据的载体。计算机中的变量是实际存在的数据或者说是存储器中存储数据的一块内存空间，变量的值可以被读取和修改，这是所有计算和控制的基础。计算机能处理的数据有很多种类型，除了数值之外还可以处理文本、图形、音频、视频等各种各样的数据，那么不同的数据就需要定义不同的存储类型。

整型：在Python 3.x中整数只有int这一种了（而且支持二进制（如0b100，换算成十进制是4）、八进制（如0o100，换算成十进制是64）、十进制（100）和十六进制（0x100，换算成十进制是256）的表示法。）

浮点型：浮点数也就是小数，之所以称为浮点数，是因为按照科学记数法表示时，一个浮点数的小数点位置是可变的，浮点数除了数学写法（如123.456）之外还支持科学计数法（如1.23456e2）。

字符串型：字符串是以单引号或双引号括起来的任意文本，比如'hello'和"hello",字符串还有原始字符串表示法、字节字符串表示法、Unicode字符串表示法，而且可以书写成多行的形式（用三个单引号或三个双引号开头，三个单引号或三个双引号结尾）。

布尔型：布尔值只有True、False两种值，要么是True，要么是False，在Python中，可以直接用True、False表示布尔值（请注意大小写），也可以通过布尔运算计算出来（例如3 < 5会产生布尔值True，而2 == 1会产生布尔值False）。

复数型：形如3+5j，跟数学上的复数表示一样，唯一不同的是虚部的i换成了j。实际上，这个类型并不常用，了解一下就可以了。

每个人都需要自己的一个姓名

在Python中，变量命名需要遵循以下这些必须遵守硬性规则和强烈建议遵守的非硬性规则。

硬性规则：

变量名由字母（广义的Unicode字符，不包括特殊字符）、数字和下划线构成，数字不能开头。

大小写敏感（大写的a和小写的A是两个不同的变量）。

不要跟关键字（有特殊含义的单词，后面会讲到）和系统保留字（如函数、模块等的名字）冲突。

PEP 8要求：

用小写字母拼写，多个单词用下划线连接。

受保护的实例属性用单个下划线开头（后面会讲到）。

私有的实例属性用两个下划线开头（后面会讲到）。

Python 包含的保留字可以执行如下命令进行查看：

>>> import keyword>>> keyword.kwlist['False', 'None', 'True', 'and', 'as', 'assert', 'break', 'class', 'continue', 'def', 'del', 'elif', 'else', 'except', 'finally', 'for', 'from', 'global', 'if', 'import', 'in', 'is', 'lambda', 'nonlocal', 'not', 'or', 'pass', 'raise', 'return', 'try', 'while', 'with', 'yield']

需要注意的是，由于 Python 是严格区分大小写的，保留字也不例外。所以，我们可以说 if 是保留字，但 IF 就不是保留字。在实际开发中，如果使用 Python 中的保留字作为标识符，则解释器会提示“invalid syntax” 的错误信息，如图 2 所示。

a = 100b = 12.345c = 1 + 5jd = 'hello, world'e = Trueprint(type(a)) # print(type(b)) # print(type(c)) # print(type(d)) # print(type(e)) #

可以使用Python中内置的函数对变量类型进行转换。

int()：将一个数值或字符串转换成整数，可以指定进制。

float()：将一个字符串转换成浮点数。

str()：将指定的对象转换成字符串形式，可以指定编码。

chr()：将整数转换成该编码对应的字符串（一个字符）。

ord()：将字符串（一个字符）转换成对应的编码（整数）。

print函数中输出的字符串使用了占位符语法，其中%d是整数的占位符，%f是小数的占位符，%%表示百分号（因为百分号代表了占位符，所以带占位符的字符串中要表示百分号必须写成%%），字符串之后的%后面跟的变量值会替换掉占位符然后输出到终端中

运算符的优先级指的是多个运算符同时出现时，先做什么运算然后再做什么运算。除了我们之前已经用过的赋值运算符和算术运算符，我们稍后会陆续讲到其他运算符的使用。

y = x + 2else:

y = 5 * x + 3print('f(%.2f) = %.2f' % (x, y))

当然根据实际开发的需要，分支结构是可以嵌套的，例如判断是否通关以后还要根据你获得的宝物或者道具的数量对你的表现给出等级（比如点亮两颗或三颗星星），那么我们就需要在的内部构造出一个新的分支结构，同理和中也可以再构造新的分支，我们称之为嵌套的分支结构，也就是说上面的代码也可以写成下面的样子。

x = float(input('x = '))if x > 1:

y = 3 * x - 5else:

if x >= -1:

y = x + 2

else:

y = 5 * x + 3print('f(%.2f) = %.2f' % (x, y))

应用场景

我们在写程序的时候，一定会遇到需要重复执行某条或某些指令的场景。例如用程序控制机器人踢足球，如果机器人持球而且还没有进入射门范围，那么我们就要一直发出让机器人向球门方向移动的指令。在这个场景中，让机器人向球门方向移动就是一个需要重复的动作，当然这里还会用到上一课讲的分支结构来判断机器人是否持球以及是否进入射门范围。再举一个简单的例子，如果要实现每隔1秒中在屏幕上打印一次“hello， world”并持续打印一个小时，我们肯定不能够直接把这句代码写3600遍，这里同样需要循环结构。print('hello, world')

循环结构就是程序中控制某条或某些指令重复执行的结构。在Python中构造循环结构有两种做法，一种是循环，一种是循环。for-inwhile

如果明确的知道循环执行的次数或者要对一个容器进行迭代（后面会讲到），那么我们推荐使用循环，例如下面代码中计算1~100求和的结果

"""用for循环实现1~100求和Version: 0.1Author: 骆昊"""

sum = 0for x in range(101):

sum += xprint(sum)

知道了这一点，我们可以用下面的代码来实现1~100之间的偶数求和。

"""用for循环实现1~100之间的偶数求和Version: 0.1Author: 骆昊"""

sum = 0for x in range(2, 101, 2):

sum += xprint(sum)

当然，也可以通过在循环中使用分支结构的方式来实现相同的功能，代码如下所示。

"""用for循环实现1~100之间的偶数求和Version: 0.1Author: 骆昊"""

sum = 0for x in range(1, 101):

if x % 2 == 0:

sum += xprint(sum)

说明：相较于上面直接跳过奇数的做法，下面这种做法很明显并不是很好的选择。

(代码的运行时间也很重要！！！，不要冗杂！！！)

Zen of Python（Python之禅）（拓展）

如果要构造不知道具体循环次数的循环结构，我们推荐使用循环。循环通过一个能够产生或转换出值的表达式来控制循环，表达式的值为则继续循环；表达式的值为则结束循环。

While while bool True False

下面我们通过一个"猜数字"的小游戏来看看如何使用循环。猜数字游戏的规则是：计算机出一个1到100之间的随机数，玩家输入自己猜的数字，计算机给出对应的提示信息（大一点、小一点或猜对了），如果玩家猜中了数字，计算机提示用户一共猜了多少次，游戏结束，否则游戏继续。while

"""猜数字游戏Version: 0.1Author: 骆昊"""import random

answer = random.randint(1, 100)counter = 0while True:

counter += 1

number = int(input('请输入: '))

if number < answer:

print('大一点')

elif number > answer:

print('小一点')

else:

print('恭喜你猜对了!')

breakprint('你总共猜了%d次' % counter)if counter > 7:

print('你的智商余额明显不足')

上面的代码中使用了关键字来提前终止循环，需要注意的是只能终止它所在的那个循环，这一点在使用嵌套的循环结构（下面会讲到）需要引起注意。除了之外，还有另一个关键字是，它可以用来放弃本次循环后续的代码直接让循环进入下一轮。Break break break continue

和分支结构一样，循环结构也是可以嵌套的，也就是说在循环中还可以构造循环结构。下面的例子演示了如何通过嵌套的循环来输出一个九九乘法表。

"""输出乘法口诀表(九九表)Version: 0.1Author: 骆昊"""

for i in range(1, 10):

for j in range(1, i + 1):

print('%d*%d=%d' % (i, j, i * j), end='\t')

print()

但是这些内容已经足够我们来构建程序中的逻辑。对于编程语言的初学者来说，在学习了Python的核心语言元素（变量、类型、运算符、表达式、分支结构、循环结构等）之后，必须做的一件事情就是尝试用所学知识去解决现实中的问题，换句话说就是锻炼自己把用人类自然语言描述的算法（解决问题的方法和步骤）翻译成Python代码的能力，而这件事情必须通过大量的练习才能达成。

我们在本章为大家整理了一些经典的案例和习题，希望通过这些例子，一方面帮助大家巩固之前所学的Python知识，另一方面帮助大家了解如何建立程序中的逻辑以及如何运用一些简单的算法解决现实中的问题。

寻找水仙花数

说明：水仙花数也被称为超完全数字不变数、自恋数、自幂数、阿姆斯特朗数，它是一个3位数，该数字每个位上数字的立方之和正好等于它本身，例如：$1^3 + 5^3+ 3^3=153$。

"""找出所有水仙花数Version: 0.1Author: 骆昊"""

for num in range(100, 1000):

low = num % 10

mid = num // 10 % 10

high = num // 100

if num == low ** 3 + mid ** 3 + high ** 3:

print(num)

在上面的代码中，我们通过整除和求模运算分别找出了一个三位数的个位、十位和百位，这种小技巧在实际开发中还是常用的。用类似的方法，我们还可以实现将一个正整数反转，例如：将12345变成54321，代码如下所示。

正整数的反转

Version: 0.1Author: 骆昊"""

num = int(input('num = '))reversed_num = 0while num > 0:

reversed_num = reversed_num * 10 + num % 10

num //= 10print(reversed_num)

百钱百鸡问题。

说明：百钱百鸡是我国古代数学家张丘建在《算经》一书中提出的数学问题：鸡翁一值钱五，鸡母一值钱三，鸡雏三值钱一。百钱买百鸡，问鸡翁、鸡母、鸡雏各几何？翻译成现代文是：公鸡5元一只，母鸡3元一只，小鸡1元三只，用100块钱买一百只鸡，问公鸡、母鸡、小鸡各有多少只？

"""《百钱百鸡》问题Version: 0.1Author: 骆昊"""

for x in range(0, 20):

for y in range(0, 33):

z = 100 - x - y

if 5 * x + 3 * y + z / 3 == 100:

print('公鸡: %d只, 母鸡: %d只, 小鸡: %d只' % (x, y, z))

上面使用的方法叫做穷举法，也称为暴力搜索法，这种方法通过一项一项的列举备选解决方案中所有可能的候选项并检查每个候选项是否符合问题的描述，最终得到问题的解。这种方法看起来比较笨拙，但对于运算能力非常强大的计算机来说，通常都是一个可行的甚至是不错的选择，而且问题的解如果存在，这种方法一定能够找到它。

CRAPS赌博游戏。

说明：CRAPS又称花旗骰，是美国拉斯维加斯非常受欢迎的一种的桌上赌博游戏。该游戏使用两粒骰子，玩家通过摇两粒骰子获得点数进行游戏。简单的规则是：玩家第一次摇骰子如果摇出了7点或11点，玩家胜；玩家第一次如果摇出2点、3点或12点，庄家胜；其他点数玩家继续摇骰子，如果玩家摇出了7点，庄家胜；如果玩家摇出了第一次摇的点数，玩家胜；其他点数，玩家继续要骰子，直到分出胜负。

"""Craps赌博游戏我们设定玩家开始游戏时有1000元的赌注游戏结束的条件是玩家输光所有的赌注Version: 0.1Author: 骆昊"""from random import randint

money = 1000while money > 0:

print('你的总资产为:', money)

needs_go_on = False

while True:

debt = int(input('请下注: '))

if 0 < debt y else (x, y)

for factor in range(x, 0, -1):

if x % factor == 0 and y % factor == 0:

return factor

def lcm(x, y):

"""求最小公倍数"""

return x * y // gcd(x, y)

练习2：实现判断一个数是不是回文数的函数。

参考答案：

def is_palindrome(num):

"""判断一个数是不是回文数"""

temp = num

total = 0

while temp > 0:

total = total * 10 + temp % 10

temp //= 10

return total == num

练习3：实现判断一个数是不是素数的函数。

参考答案：

def is_prime(num):

"""判断一个数是不是素数"""

for factor in range(2, int(num ** 0.5) + 1):

if num % factor == 0:

return False

return True if num != 1 else False

练习4：写一个程序判断输入的正整数是不是回文素数。

参考答案：

if __name__ == '__main__':

num = int(input('请输入正整数: '))

if is_palindrome(num) and is_prime(num):

print('%d是回文素数' % num)

注意：通过上面的程序可以看出，当我们将代码中重复出现的和相对独立的功能抽取成函数后，我们可以组合使用这些函数来解决更为复杂的问题，这也是我们为什么要定义和使用函数的一个非常重要的原因。

变量的作用域

最后，我们来讨论一下

Python中有关变量作用域的问题

def foo():

b = 'hello'

# Python中可以在函数内部再定义函数

def bar():

c = True

print(a)

print(b)

print(c)

bar()

# print(c) # NameError: name 'c' is not defined

if __name__ == '__main__':

a = 100

# print(b) # NameError: name 'b' is not defined

foo()

上面的代码能够顺利的执行并且打印出100、hello和True，但我们注意到了，在bar函数的内部并没有定义a和b两个变量，那么a和b是从哪里来的。我们在上面代码的if分支中定义了一个变量a，这是一个全局变量（global variable），属于全局作用域，因为它没有定义在任何一个函数中。在上面的foo函数中我们定义了变量b，这是一个定义在函数中的局部变量（local variable），属于局部作用域，在foo函数的外部并不能访问到它；但对于foo函数内部的bar函数来说，变量b属于嵌套作用域，在bar函数中我们是可以访问到它的。bar函数中的变量c属于局部作用域，在bar函数之外是无法访问的。事实上，Python查找一个变量时会按照“局部作用域”、“嵌套作用域”、“全局作用域”和“内置作用域”的顺序进行搜索，前三者我们在上面的代码中已经看到了，所谓的“内置作用域”就是Python内置的那些标识符，我们之前用过的input、print、int等都属于内置作用域。

再看看下面这段代码，我们希望通过函数调用修改全局变量a的值，但实际上下面的代码是做不到的。

def foo():

a = 200

print(a) # 200

if __name__ == '__main__':

a = 100

foo()

print(a) # 100

在调用foo函数后，我们发现a的值仍然是100，这是因为当我们在函数foo中写a = 200的时候，是重新定义了一个名字为a的局部变量，它跟全局作用域的a并不是同一个变量，因为局部作用域中有了自己的变量a，因此foo函数不再搜索全局作用域中的a。如果我们希望在foo函数中修改全局作用域中的a，代码如下所示。

def foo():

global a

a = 200

print(a) # 200

if __name__ == '__main__':

a = 100

foo()

print(a) # 200

我们可以使用global关键字来指示foo函数中的变量a来自于全局作用域，如果全局作用域中没有a，那么下面一行的代码就会定义变量a并将其置于全局作用域。同理，如果我们希望函数内部的函数能够修改嵌套作用域中的变量，可以使用nonlocal关键字来指示变量来自于嵌套作用域，请大家自行试验。

在实际开发中，我们应该尽量减少对全局变量的使用，因为全局变量的作用域和影响过于广泛，可能会发生意料之外的修改和使用，除此之外全局变量比局部变量拥有更长的生命周期，可能导致对象占用的内存长时间无法被垃圾回收。

( 垃圾回收这一步对于jvm十分重要，内存管理虽然不用手动管理，但是对于查错确实，排错确是十分重要哦！

大致流程：允许GC之后（注意，发动GC也是需要一定的要求步骤，不详细展开，会另写博客进行说明）-> 开始查找那些允许被回收的（两个算法）-> 开始回收（四个算法）

)http://t.csdn.cn/rufI7

事实上，减少对全局变量的使用，也是降低代码之间耦合度的一个重要举措，同时也是对迪米特法则(http://t.csdn.cn/sm8NA)的践行。减少全局变量的使用就意味着我们应该尽量让变量的作用域在函数的内部，但是如果我们希望将一个局部变量的生命周期延长，使其在定义它的函数调用结束后依然可以使用它的值，这时候就需要使用闭包(闭包函数：声明在一个函数中的函数，叫做闭包函数。

闭包：内部函数总是可以访问其所在的外部函数中声明的参数和变量，即使在其外部函数被返回（寿命终结）了之后。)，这个我们在后续的内容中进行讲解。

说明： 很多人经常会将“闭包”和“匿名函数”混为一谈，但实际上它们并不是一回事，如果想了解这个概念，可以看看维基百科的解释或者知乎上对这个概念的讨论。

说了那么多，其实结论很简单，从现在开始我们可以将Python代码按照下面的格式进行书写，这一点点的改进其实就是在我们理解了函数和作用域的基础上跨出的巨大的一步。

def main():

# Todo: Add your code here

pass

if __name__ == '__main__':

main()

在python的编译界面中输入import this

Beautiful is better than ugly. （优美比丑陋好）

Explicit is better than implicit.（清晰比晦涩好）

Simple is better than complex.（简单比复杂好）

Complex is better than complicated.（复杂比错综复杂好）

Flat is better than nested.（扁平比嵌套好）

Sparse is better than dense.（稀疏比密集好）

Readability counts.（可读性很重要）

Special cases aren't special enough to break the rules.（特殊情况也不应该违反这些规则）

Although practicality beats purity.（但现实往往并不那么完美）

Errors should never pass silently.（异常不应该被静默处理）

Unless explicitly silenced.（除非你希望如此）

In the face of ambiguity, refuse the temptation to guess.（遇到模棱两可的地方，不要胡乱猜测）

There should be one-- and preferably only one --obvious way to do it.（肯定有一种通常也是唯一一种最佳的解决方案）

Although that way may not be obvious at first unless you're Dutch.（虽然这种方案并不是显而易见的，因为你不是那个荷兰人[这里指的是Python之父Guido]）

Now is better than never.（现在开始做比不做好）

Although never is often better than *right* now.（不做比盲目去做好[极限编程中的YAGNI原则]）

If the implementation is hard to explain, it's a bad idea.（如果一个实现方案难于理解，它就不是一个好的方案）

If the implementation is easy to explain, it may be a good idea.（如果一个实现方案易于理解，它很有可能是一个好的方案）

Namespaces are one honking great idea -- let's do more of those!（命名空间非常有用，我们应当多加利用）

————————————————

版权声明：本文为CSDN博主「程序猿编码」的原创文章，遵循CC 4.0 BY-SA版权协议，转载请附上原文出处链接及本声明。

原文链接：https://blog.csdn.net/chen1415886044/article/details/100941004

是 C++ 编程的一个特性，它允许我们有多个具有相同名称但不同参数列表的函数，当我说参数列表时，它表示参数的数据类型和顺序，例如函数myfuncn(int a, float b)的参数列表是(int, float)，它与函数myfuncn(float a, int b)参数列表(float, int)不同。函数重载是编译时多态。

记住这条规则的最简单方法是参数应符合以下任何一个或多个条件，它们应具有不同的类型，数量或顺序的参数。

例如：

这两个函数有不同的参数类型：

print(int num1, int num2)

print(double num1, double num2)

这两个的参数数量不同：

print(int num1, int num2)

print(int num1, int num2, int num3)

这两个有不同的参数顺序：

print(int num1, double num2)

print(double num1, int num2)

以上三种情况都是有效的重载情况。我们可以有任意数量的函数，只需记住参数列表应该是不同的。例如：

int print(int, int)

double print(int, int)

由于参数列表相同，因此不允许这样做。尽管它们具有不同的返回类型，但它无效。