第一章 Python环境搭建

1.1. 计算机基础

1.1.1. 什么是编程

​ “编程”这两个字在最近几年的时间里，已经越来越多的出现在我们的生活中，很多人都多多少少的接触过“编程”，系统的学习过“编程”。现在好多的小朋友都已经开始“编程”了，“少儿编程”的课程也数不胜数。甚至于一些电视剧居然也以“程序员”为题材来进行拍摄了。（小声BB：虽然大篇幅的内容依然是情情爱爱的，与编程没有太多关系。。。）那么什么是“编程”呢？

​ “编程”，就是编写程序，让计算机去执行，解决我们的需求。比如我们现在手机上的各种APP，都是为了解决我们的各种需求而诞生的“程序”，例如微信、支付宝、京东、淘宝等等。程序员将需求告诉计算机，让计算机去处理各种问题，这就是“编程”。

​ 在编程的过程中，程序员需要与计算机进行对话，这个过程其实跟我们人与人之间的沟通交流一致。两个人想要正常的沟通交流，必须要满足的条件是:

• 你说的话对方能听懂
• 对方说的话你能听懂

但是人和机器怎么去沟通？机器只认识0和1，无法学会人类的语言；而人类如果使用0和1组成的机器语言来沟通，效率极其低下。于是人类就找到了一个“翻译”，将我们人类的语言翻译成为机器能够识别的语言。但是“翻译”本身也是一个程序，也无法识别我们生活中使用到的语言，此时就需要程序员去学会“翻译”的语言，这就是我们所谓的“编程语言”。

1.1.2. 什么是进制

1.1.2.1. 进制的简介

进制也就是进位计数制，是人为定义的带进位的计数方法（有不带进位的计数方法，比如原始的结绳计数法，唱票时常用的“正”字计数法，以及类似的tally mark计数）。 对于任何一种进制—X进制，就表示每一位置上的数运算时都是逢X进一位。 十进制是逢十进一，十六进制是逢十六进一，二进制就是逢二进一，以此类推，x进制就是逢x进位。

1.1.2.2. 进制的分类

在程序中，常用的进制可以分为以下几种：

二进制： 以数字0-1来表示每一个自然数，逢2进1。

八进制： 以数字0-7来表示每一个自然数，逢8进1。

十进制： 以数字0-9来表示每一个自然数，逢10进1。

十六进制： 以数字0-9，a-f来表示每一个自然数，逢16进1。

二进制: 0, 1, 10, 11, 100, 101, 110, 111, 1000, …

八进制: 0, 1, 2, 3, 4, 5, 6, 7, 10, 11, 12, …

十进制： 0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, …

十六进制: 0, 1, 2, 3, 4, 5, 6, 7, 8, 9, a, b, c, d, e, f, 10, 11, …

1.1.2.3. 进制的表示

同一个自然数，用不同的进制表示的话，结果可能是不一样的。例如，数字10，如果是二进制，表示数字2； 如果是八进制，表示数字8；如果是十进制，表示数字10；如果是十六进制，表示数字16。 因此，不同的进制，需要有不同的标识，来区分不同的进制。

二进制： 以 0b 作为开头，表示一个二进制的数字，例如： 0b10、0b1001…

八进制： 以 0o 作为开头，表示一个八进制的数字，例如：0o10、0o27…

十进制： 没有以任何其他的内容作为开头，表示一个十进制的数字，例如： 123、29…

十六进制： 以 0x 作为开头，表示一个十六进制的数字，例如：0x1001、0x8FC3…

1.1.2.4. 进制的转换

• 十进制转其他进制

辗转相除法： 用数字除进制，再用商除进制，一直到商为零结束，最后将每一步得到的余数倒着连接以来，就是这个数字的指定的进制表示形式。

18 = 0b10010 = 0o22 = 0x12

• 其他进制转十进制

每一位的数字乘进制的位数-1次方，再将所有的结果累加到一起。

0b10010 = 1 x 2⁴ + 1 x 2¹ = 16 + 2 = 18

0o22 = 2 x 8¹ + 2 x 8⁰ = 16 + 2 = 18

0x12 = 1 x 16¹ + 2 x 16⁰ = 16 + 2 = 18

• 二进制与八进制,十六进制的相互转换

每一个八进制位可以等价替换成三个二进制位。
注意:
1.划分从右到左进行,如果二进制数的左边不够三位,直接在高位补零凑齐三位
2.当八进制数转成二进制数时,将上述过程反转,有一点要记住,每一个八进制的数必须对应三位二进制位,如果八进制数在转化时得到的二进制数不够三位,直接在最左边用零补齐.

每一个十六进制位可以等价替换成四个二进制位。
跟二进制与八进制的转化规则类似

1.1.2.5. 原反补(了解)

数据的转换

在计算机中， 所有的数据存储都是以二进制的形式存储的。 文字、图片、视频… ， 在计算机中都是二进制。 那么， 在计算机的存储系统中， 每一个文件都有大小。 那么文件的大小是如何计算的？

每一个二进制位称为一个 比特位(bit)

8个比特位称为一个字节(Byte)

因为:位能表示的数太小了,所以习惯上我们将字节作为计算机存储的最小单位

从字节开始， 每1024个单位向上增1。

8bit = 1Byte

1024Byte = 1KB

1024KB = 1MB

1024MB = 1GB

1024GB = 1TB

1024TB = 1PB

1024PB = 1EB

1024EB = 1ZB

…

负数的表示

在使用二进制表示数字的时候，通常会写满1个字节，如果1个字节表示不了，使用2个字节。如果2个字节表示不了，使用4个字节。以此类推，8个字节、16个字节、32个字节…

在使用二进制表示数字的时候，最高位（最左侧的位）不是用来表示数字的大小的，而是用来表示数字的正负的。0代表正数，1代表负数。因此，最高位又被称为符号位。

0b0000 1000 所表示的数字是 8
0b1000 1000 所表示的数字是 -8

补码的引入

• 符号位参与运算的问题

在数据的运算中， 由于有符号位的存在。 符号位直接参与运算， 会导致计算的结果出问题。

例如， 在计算 8 + (-8) 的时候， 如果直接使用二进制表示形式进行运算的时候:

0000 1000 + 1000 1000 = 1001 0000

得到结果 -16

原因就是因为符号位参与了运算， 导致计算的结果出了问题。

• 原反补

为了规避在计算过程中， 符号位的参与运算， 导致计算结果出错。 人们引入了补码， 规避了这个问题。 在计算机中， 所有的数据存储和运算， 都是以 补码 的形式进行的。

1. 原码： 一个数字的二进制表示形式， 前面的计算二进制表示形式， 得到的就是原码。

2. 反码: 正数的反码与原码相同； 负数的反码是原码符号位不变， 其他位按位取反。

3. 补码: 正数的补码与原码相同； 负数的补码是反码 + 1 。

8， 因为是正数， 原反补都是 0000 1000

-8[原] = 1000 1000

-8[反] = 1111 0111

-8[补] = 1111 1000

• 补码运算

在计算机中， 所有的数据存储和运算， 都是以 补码 的形式进行的。 因此， 在进行数据运算的时候， 将数据计算出补码， 再进行运算。

8 + (-8) = 0

0000 1000 + 1111 1000 = 1 0000 0000

在上述的计算结果中， 出现了多出一位的情况， 这种情况， 称为 溢出 。 如果出现了溢出的情况， 溢出位直接舍去不要， 即最后的计算结果是 0000 0000， 结果是 0

8 + (-16) = -8

0000 1000 + 1111 0000 = 1111 1000

注意: 补码与补码的计算结果，还是补码。 所以， 我们需要将这个结果再转成原码。

补码求原码的过程： 再对这个补码求补即可。 得出结果: 1000 1000， 结果是 -8

1.2. Python的介绍

Python由荷兰数学和计算机科学研究学会的吉多·范罗苏姆（龟叔）于1990年代初设计，作为一门叫做ABC语言的替代品。Python提供了高效的高级数据结构，还能简单有效地面向对象编程。Python语法和动态类型，以及解释型语言的本质，使它成为多数平台上写脚本和快速开发应用的编程语言，随着版本的不断更新和语言新功能的添加，逐渐被用于独立的、大型项目的开发。

Python的创始人为荷兰人吉多·范罗苏姆（Guido van Rossum）。1989年圣诞节期间，在阿姆斯特丹，Guido为了打发圣诞节的无趣，决心开发一个新的脚本解释程序，作为ABC语言的一种继承。之所以选中单词Python（意为大蟒蛇）作为该编程语言的名字，是因为英国20世纪70年代首播的电视喜剧《蒙提·派森的飞行马戏团》（Monty Python’s Flying Circus）。

Python 已经成为最受欢迎的程序设计语言之一。自从2004年以后，python的使用率呈线性增长。Python 2于2000年10月16日发布，稳定版本是Python 2.7。Python 3于2008年12月3日发布，不完全兼容Python 2。 2011年1月，它被TIOBE编程语言排行榜评为2010年度语言。

现如今的Python已经全面进入到3.0的年代，使用的都是3.x版本在进行开发!

1.3. Python的安装与使用

1.3.1. Python的下载

如果我们想要使用Python语言来开发程序，我们必须先要下载Python的安装包进行安装，并配置Python的运行环境。

Python官网：https://www.python.org

注：

​ Python已经全面步入3的时代，Python2已经停止维护了。因此我们在学习的时候，直接以Python3来学习。目前最新的版本为Python3.11，但是这个版本目前市场的兼容性有点问题，一些三方库还未适配到，会导致后续学习的时候出现问题。因此我们依然使用的Python3.10的版本。

1.3.2. Windows安装Python

安装完成之后，可以验证是否成功。

我们打开一个新的cmd窗口，按住键盘上的win+r键，输入cmd，即可打开这个窗口。

1.3.3. Mac安装Python

Mac的安装包，打开之后，一路确定到底即可完成。没有多余的操作去选择！

验证是否安装完成，可以打开“终端”程序。

1.4. Python解释器

我们在安装完成Python的环境之后，可以在Windows的cmd打开的DOS命令窗口输入“python”，或者在Mac的终端界面输入“python3“，即可打开一个可以输入内容的运行界面。这个界面就是“解释器”的界面，我们可以直接通过解释器界面进行代码的编辑的操作，并且执行相应的代码，得到我们想要的结果。

为什么python的解释器可以运行程序代码呢？

其实很简单，计算机是不会认识Python代码的。但是Python有解释器程序，将代码解释成了二进制形式提交到计算中进行了运行，所以python环境本质上就是在电脑上，安装了Python解释器程序。

对于python的解释器而言是可以便于我们代码的书写，但是如果我们编写的代码量多，成百上千行那么解释器就明显不能满足我们的开发需求了，所以python允许将python的代码写入到文件中，文件的后缀名以【.py】结尾，代表是一个python的文件，然后再“命令行窗口中”通过**【python 文件所在路径】**也可以执行代码。

1.5. PyCharm的安装与使用

1.5.1. PyCharm的下载

Python程序的开发有许多种方式，一般我们常见的有：

• Python解释器环境内，执行单行代码
• 使用Python解释器程序，执行Python代码文件
• 使用第三方IDE（集成开发工具），如PyCharm软件，开发Python程序

PyCharm集成开发工具（IDE），是当下全球Python开发者，使用最频繁的工具软件。绝大多数的Python程序，都是在PyCharm工具内完成的开发。PyCharm官方网址：https://www.jetbrains.com/pycharm/

PyCharm提供了免费使用的Community版本，和收费使用的Professional版本。虽然Professional版本提供了很多的插件和工程可以给到开发者使用，但是在学习阶段，使用Community版本已经可以满足我们的需求了。因此我们使用免费的Community社区版本。

1.5.2. PyCharm的使用

	1. 创建一个新的Python项目
	2. 配置新的项目相关的属性信息，包括项目保存的路径，和使用到的Python环境。
	3. PyCharm主界面的介绍
	4. 创建一个新的Python文件，写我们的代码
	5. 给新创建的Python文件命名
	6. 运行我们的第一个Python程序！

第二章 Python语法基础

2.1. 注释

注释：在程序代码中对程序代码进行解释说明的文字。
作用：注释不是程序，不能被执行，只是对程序代码进行解释说明，让别人可以看懂程序代码的作用，能够大大增强程序的可读性。

2.1.1. 单行注释

单行注释：以 #开头，#右边 的所有文字当作说明，而不是真正要执行的程序，起辅助说明作用

注意：#号和注释内容一般建议以一个空格隔开,注释的快捷键ctrl + /

# 我是单行注释
print("人生苦短，我用python")

2.1.2. 多行注释

多行注释： 以 一对三个双引号 引起来 【“”“注释内容“”】来解释说明一段代码的作用使用方法

注意：这个引号可以是双引号也可以是单引号，建议使双引号，多行注释一般对：Python文件、类或方法进行解释

"""
我是多行注释
"""
'''
我是多行注释
'''
print("欢迎来到Python的世界，人生苦短，我用Python!")

2.2. 字面量

字面量：在代码中，被写下来的固定的值被称之为字面量

为什么有字面量？

字面量可以在代码中，展示某个具体数据提供给代码使用（打印、计算、赋值等等）

比较常见的字面量有【整数、小数、字符串、布尔】

print(999)  # 整数常量
print(3.14) # 小数字字常量
print(True) # 布尔字面量
print("欢迎来到Python的世界，人生苦短，我用Python!")  # 字符串字面量

注意：其实这里的字面量我们也称之为字面常量，常量的含义就是不可改变的量，字面量是具体数值其实不可改变的

2.3. 变量

变量从名字角度解读的话可以理解成就是变化的数据，根据不同的场景数据会发生变化，比如温度，随着时间在发生变化，变化的数据不好持有的，所以一般会给温度设置数据标记，用这个标记来存储温度的值，想看当前的温度，就看数据标记现在的值是多少，就代表着温度是多少。这个数据标记就是变量，给这个标记起的名字为变量名

其实变量这个名词来源数学，比如初等数学中的应用方程式【数学中解应用题的时候会对未知的数据设x/y/z等等这些名字来代替未知项参与需求运算】

简单的说，变量就是在程序运行时，记录数据用的便于后续的代码进行操作

Python程序中如何定义一个变量，方式有：

1. 定义一个变量 变量名 = 数据值

age = 19

2. 定义多个变量，多个变量值相同 变量名 = 变量名1 = 变量名2 = 数据值

money = pi = price = 3.14

3. 定义多个变量，多个变量值不同 变量名, 变量名1, 变量名2 = 数据值, 数据值1, 数据值2

zhangsan,lisi,wangwu = "张三","李四","王五"

从程序角度解读定义格式：

先在内存中开辟一块空间，将数据存储在空间中， =是赋值运算符，CPU将数据存储的空间的地址赋值给了变量名， 当我们使用变量名的时候，CPU会拿到空间地址定位到内存位置，获取到该空间的数据

为什么有字面量还要使用变量呢？

变量，从名字中可以看出，表示“量”是可变的。所以，变量的特征就是，变量存储的数据，是可以发生改变的，而字面量的值是不可以改变的，变量更利于在开发中进行数据存储的使用。

变量使用的时候的注意事项：在使用之前 变量必须被定义出来并且赋予初始值

2.4. 数据类型

数据类型: 根据数据的特征对数据进行归类，描述数据的类，python中的基本数据类型

数据类型	描述
int	将所有整数归类到一起就是“整型”
float	将所有的小数归类在一起，统称为浮点型
bool	对逻辑状态的结果进行归类，由于逻辑结构只有两种，所以布尔类型的数据只有两个，分别是True和False
str	对文本数据的归类描述，文本特点是不需要计算机计算其中公式内容，怎么写的怎么存储，怎么把数据标记成字符串类型的，就是在数据外层加对引号【单双引号都可以】
NoneType	这个类型的数据就只有一个，就是None [空] — 什么都没有，定义一个数据不知道赋予什么值时，就可以赋值为None

# 描述学生的信息：姓名、年龄、性别、成绩、手机号
name = "张三丰"
age = 21
gender = '不详'
score = 88.5
phoneNumber = None

编程时我们可以通过对变量的赋值所提供的数据来人为的判断数据类型，但是如果需要程序来判断数据类型该如何操作呢？

我们可以通过python中提供type()语句来进行判断type(数据/变量)

string_type = type(name) # 可以用type返回的结果进行赋值
print(string_type)
print(type(11)) # 可以在print语句中 直接输入类型信息

Python中定义变量时,并不会像其他语言一样提供数据类型，而是【变量名 = 数据值】，这是因为Python是一门动态类型的语言【特点：变量的具体的类型是根据值来决定的】，那么我们通过type(变量)可以输出类型，这是查看变量的类型还是数据的类型？
查看的是：变量存储的数据的类型。因为，变量无类型，但是它存储的数据有。

2.5. 数据类型转换

数据类型之间，在特定的场景下，是可以相互转换的，如字符串转数字、数字转字符串等
那么，我们为什么要转换它们呢？

数据类型转换，将会是我们以后经常使用的功能。

• 从文件中读取的数字，默认是字符串，我们需要转换成数字类型
• 后续学习的input()语句，默认结果是字符串，若需要数字也需要转换
• 将数字转换成字符串用以写出到外部系统
• 等等

python中提供数据类型转换有如下操作

2.5.1. 把数据转换为整数类型

具体的操作是把数据转化为十进制格式的整数类型

操作：int(数据)

场景：

1. 对浮点数取整数部分

2. 将字符串格式的整数数据转化为整数类型

   要求：字符串中数据的格式是要满足十进制数据整数要求 【不满足就会报错】

   如果字符串的内容格式是其他进制的 要转换为十进制 该如何操作？？？？

   不满足十进制格式会报错的原因是因为功能内部是按照十进制数据集在解析数据，相关转换其他进制的数据的，需要设置一下解析数据时的进制方式即可， 修改操作 int('数据', base=进制数)

a = int(3.14)
b = int("1")
print(type(a))
print(type(b))

2.5.2. 把数据转换为浮点类型

操作：float(数据)

场景：就是将字符串格式的数据转换为小数 【要求：字符串的内容必须得满足数学中正常数的要求】

a = float(3)
b = float("3.14")
print(type(a))
print(type(b))

2.5.3. 把数据转换为字符串类型

操作：str(数据)

可以把任意类型的数据转化为字符串类型，结果就是在原数据的外层加一个引号的衣服

str1 = str("1")
str2 = str("3.14")
str3 = str("字符串")
str4 = str("[1,2,3,4]")
print(type(str1))
print(type(str2))
print(type(str3))
print(type(str4))

2.5.4. 把数据转换为布尔类型

操作：bool(数据)

可以任意类型的数据转化为布尔类型，但是不同的数据有不同的转换规则：

1. 对于整型和浮点型数据来说，规则是 非0即为True

2. 对于容器型数据来说，规则是 非空容器即为True

   空容器：数据对象是存在的，但是里面没有元素， 比如 '', [], (), {}, set()

3. 空对象None就是False

   空对象和空容器不是一个意思， None 【连个对象都没有】， 空容器是有对象 但是是个空壳子

#PS: 需要注意Python和其他编程语言不一样，在其他语言中使用“+”进行字符串拼接时会自动转换为字符串类型，而Python仅允许字符串类型与字符串类型使用“+”拼接，非字符串类型无法使用“+”与字符串类型拼接
res1 = bool(1)
print(str(type(res1))+" "+str(res1))
res2 = bool(0)
print(str(type(res2))+" "+str(res2))
res3 = bool([1,2,3,4])
print(str(type(res3))+" "+str(res3))
res4 = bool([])
print(str(type(res4))+" "+str(res4))
res5 = bool(None)
print(str(type(res5))+" "+str(res5))

2.5.5. 其他数据格式之间转换

方法	说明
bin(其他进制的数据)	其他进制的数据转化为二进制
oct(其他进制的数据)	其他进制的数据转化为八进制
hex(其他进制的数据)	其他进制的数据转化为十六进制
ord(字符)	按照编码标准获取字符对应的十进制数据
chr(数据)	按照编码标准获取十进制数据对应的字符

2.6. 标识符与表达式

在编写程序的时候，经常会遇到自己定义名字的场景，自己定义的名字就是标识符，定义名字是有规则的

1. 组成：是由数字、字母、下划线组成的

   因为Python的编码是UTF-8，国际标准，收录的世界语言，各国文字统称为字母

   只不过按照大众的编码习惯，建议字母使用英文字母

变量名命名的硬性规则：

1. 不能以数字开头

2. 区分大小写

3. 不能使用关键字【Python已经占用的并且赋予特殊含义的单词 比如 True/False/None】

   False	True	None	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

4. 不能与系统提供的重名 【初始定义的时候 pycharm有提示 就不要用了 会把原本的功能给覆盖掉】

变量名的非硬性规则：见名知意

表达式：用运算符把字面量或者变量连接起来符合python语法的式子就可以称为表达式。

​ 不同运算符连接的表达式体现的是不同类型的表达式。

​ 表达式其实就是数学中的计算等式 例如 1+1

​ 在编程中我们存在字面量和变量，所以表达式的组成就包含了这两个部分

2.7. 运算符

2.7.1. 算术运算符

运算符	描述	说明
+	加	两个数据进行相加
-	减	两个数据进行相减
*	乘	两个数据进行相乘
/	除	两个数据相除 结果是浮点类型的
//	取整	两个数相除，结果对商进行向下取整【整数类型的】 [shift+回车 单元格中换行] 向下取整：小于或者等于商且最接近于商的整数
%	取余	两个数相除之后的余数
**	指数	两数求幂数 x**y y是N的话，就是求的x的N次方，如果y是(1/N)，表示对x开N次方，注意的是开方的结果是浮点型的

()提高表达式的优先级

算术运算符中 **优先级别是最高的，比正负逗号

布尔类型的数据与整数或者小数参与算术运算时，True被当做1，False被当做0

字符串类型的数据也可以使用算术运算符中的一些符号，比如+， *， %

+: 在字符串中完成的是字符串的拼接，形成一个新的字符串 【注意事项：只能字符串与字符串类型数据进行拼接】

*：将字符串对象乘以的一个正整数N，将字符串的内容重复N次，形成一个新的字符串

%：格式化字符串，已知一段文本的内容格式，但是内容中有不确定的数据需要填充，我们可以在字符串中使用%s，%d，%f在未知的位置进行占位， 然后对字符串进行%运算，在%后面填充数据，前面有几个占位符，就填充几个数据。【%s可以填充任意类型的数据，%d填充整型数据 ，%f填充的是一个浮点型数据】

%.nf 表示填充的数据要保留n位小数

%0nd 按照n位数来格式化数据，不足n位数 前面补0

# 在正常计算时 加减乘除和求余是比较正常的计算操作
# 1. 正常的四则运算 可以使用数值变量或数值字面量参与运算
print(1+1)
print(2-1)
print(10*10)
print(9/3) # 除数不能为0
print(10%2)
# 2. 在python中 除法的计算结果时小数，如果仅需要整数的话需要使用 // 取整计算  小数计算时需要取整也是一样使用
print(9//3)
# 3. 快捷计算某个数的次方 **
print(2**3)
# 4. 在计算时如果要提高某个表达式的计算等级 可以添加小括号
print((2+3)*5)
# 5.布尔类型数据在参与计算时 True被当做1 False被当做0
print(True + 1)
print(False + 1)
# 6. 字符串的操作我们在讲输入输出时来完善

2.7.2. 赋值运算符

运算符	描述	说明
=	赋值运算符	变量名 = 数据值 将等号右边的数据赋值给等号左边的变量名

运算符	描述	说明
+=	加法赋值运算符	c += a 等效于 c = c + a
-=	减法赋值运算符	c -= a 等效于 c = c - a
*=	乘法赋值运算符	c *= a 等效于 c = c * a
/=	除法赋值运算符	c /= a 等效于 c = c / a
%=	取模赋值运算符	c %= a 等效于 c = c % a
**=	幂赋值运算符	c **= a 等效于 c = c ** a
//=	取整除赋值运算符	c //= a 等效于 c = c // a
:=	海象运算符	作用是定义一个变量的同时，让变量再参与其他运算

# 赋值运算符
# 1. 定义变量时，将数据存储到变量中
a = 10
print(a) # a这个变量中存储10这个数据
# 2. 提供表达式计算时
sum = a + 10 # 因为 赋值运算符是一个右结合运算符，所以会先计算等号右边的数据然后再赋值等号左边
print(sum) # sum 等于20

# 复合运算符 因为复合运算符逻辑都是都是一样的所以仅举例一个，剩余运算符参考举例即可
"""
复合运算符的场景就是当遇到某个数据需要计算之后在赋值给原有变量时所提供的一种简便计算写法
例如: 定义一个a变量赋值为1 ，然后a变量+1之后在赋值给a变量
"""
# 普通做法
a = 1  # a 赋值为1
a = a+1 # a变量+1计算之后在赋值给a
print(a)
# 复合运算符的简便写法
a = 1
a += 1  # 这里 += 就是复合运算符 a +=1 等价于 a = a+1
print(a)
# 需要注意的是 如果复合运算符的右边有表达式存在 要先计算表达式然后再进行其他运算
a = 3
a *= 3+2  # a *= 3+2  等价于 a = a*(3+2) 即 a = 3*(3+2)
print(a) # 最终a的计算结果时 15 而不是11

# 海象运算符 是python3.8中开始提供的运算符 它作用是在定义变量的同时参数计算
start = input("Do you want to start(y/n)?")
print(start == "y")
# 但是使用海象运算符，我们可以使其更紧凑。
print((start := input("Do you want to start(y/n)?")) == "y")

2.7.3. 比较运算符

运算符	描述	说明
==	判断内容是否相等，满足为True，不满足为False	如a=3,b=3，则(a == b) 为 True
!=	判断内容是否不相等，满足为True，不满足为False	如a=1,b=3，则(a != b) 为 True
>	判断运算符左侧内容是否大于右侧 满足为True，不满足为False	如a=7,b=3，则(a > b) 为 True
<	判断运算符左侧内容是否小于右侧满足为True，不满足为False	如a=3,b=7，则(a < b) 为 True
>=	判断运算符左侧内容是否大于等于右侧满足为True，不满足为False	如a=3,b=3，则(a >= b) 为 True
<=	判断运算符左侧内容是否小于等于右侧满足为True，不满足为False	如a=3,b=3，则(a <= b) 为 True

# 比较表运算符  --》 比较运算符最终计算出的结果是bool类型

#数字比较
a1 = 10
b1 = 10
print(a1 == b1)

a2 = 3.14
b2 = 3.15
print(a2 >= b2)

"""需要注意:在python中没字符的概念存在，所以无论使用单或双引号括起来的都是字符串，使用比较运算符计算时比较的是文本内容，即对应ASCII和Unicode值"""
a3 = 'a'
b3 = 'a'
print(a3.__eq__(b3))

a3_1 = 'A'
b3_1 = 'a'
print(a3_1 > b3_1)

a3_2 = '我'
b3_2 = '我'
print(a3_2 >= b3_2)

# python允许在进行范围比较的时候，使用连续比较的方式
score = 90
print(60 <= score <= 100)

2.7.4. 逻辑运算符

运算符	描述	说明
and	逻辑与，连接的表达式之间是并且的关系，也就是需要两个表达式同时成立，结果才是成立的，有一句总结是 一假则全假 根据总结，逻辑与有短路原则：左边表达式为假，右边表达式不参与运算 这个短路只针对与and有效，后面有其他的逻辑表达式还是会执行的	False and False = False False and True = False True and False = False True and True = True
or	逻辑或，连接的表达式之间是或者的关系，也就是其中一个表达式成立，结果就是成立的，有一句总结是 一真则全真 根据总结，逻辑或有短路原则：左边表达式为真，右边表达式不参与运算 这个短路是真短路，后面所有的表达式都不会执行了	False or False = False False or True = True True or False = True True or True = True
not	逻辑非，对逻辑结果取反的，真变假，假变真 优先级别比and和or高	not False = True not True = False

# 逻辑运算符 --> 使用逻辑运算符列出逻辑表达式

# 1:参加少年运动会的运动员的年龄在13～17之间）
age >= 13 and  age <= 17

# 2:（动物园年龄小于12，大于65的老人免票）
age < 12 or age > 65

# 3:（年龄不小于16岁的人才可以观影）
not age < 16 或者 age >= 16

# 4:构造一个表达式来表示下列条件：
# a:number等于或大于90，但小于100
number >= 90 and number < 100
# b:ch不是字符q也不是字符k
 ch != 'q' and ch != k
# c:number界于1到9之间（包括1不包括9），但是不等于5
(number >= 1 and number < 9) and number != 5
# d:number不在1到9之间
number < 1 or number > 9 或者 not (number>=1 and number<=9)

# 5:判断这个字符是空格，是数字，是字母
ch == ' '
ch >= '0' and ch <= '9'
(ch >= 'A' and ch <= 'Z') or (ch >= 'a' and ch <= 'z')

# 6:有3个整数a,b,c，判断谁最大，列出所有可能
a > b and a > c
b > a and b > c
c > a and c > b
# 7:判断year表示的某一年是否为闰年，用逻辑表达式表示。闰年的条件是符合下面二者之一：a:能被4整除但不能被100整除 b:能被400整除
(year%4==0 and year%100!=0) or (year%400==0)

需要注意：算数运算符优先级>比较运算符优先级>逻辑运算符优先级>赋值运算符优先级

2.8. 输入和输出

2.8.1. 获取键盘输入

如何在Python中做到读取键盘输入的内容呢？ --》 可以使用input语句

# 输入语句input
# 使用了input语句就可以在控制台中输入需要存储到程序中数据，输入成功以【回车】作为结束输入
print("请输入用户名：")
name = input()
print(name)
print("请输入密码：")
ps = input()
print(ps)
# 需要注意：input语句输入的任何数据都是以【字符串】类型处理的，如果需要得到其他类型数据就需要转换操作

2.8.2. 输出数据

# 输出语句print 可以完成将内容（变量、字面等）输出到屏幕上
# 定义一个变量a赋值为10并输出a变量的值
a = 10
print(a)

# 可以使用print语句配合input语句进行输入提示操作
print("欢迎来到千锋学习大数据，请输入您的学号：")
stuNo = input()
print("你的学号是："+stuNo)

# 在输出某些数据的时候为了可以更好表明输入的数据的内容，我们在添加一些描述性的字符串例如上面例子中就添加了
# 在使用字符串与数据连接时可以使用 “+” 运算符来完成，但是需要注意
print("a变量中的值："+a)
"""
当需要使用字符串进行描述并拼接a变量出现了以下的问题
Traceback (most recent call last):
  File "C:\PycharmProjects\pythonProject\FirstPython.py", line 14, in <module>
    print("a变量中的值："+a)
TypeError: can only concatenate str (not "int") to str
这个问题就是Python中 【只允许字符串与字符串之间使用 “+” 来进行拼接操作，如果有非字符串与字符串拼接就会出现上述问题】
"""

# 为了方便在代码中进行字符串操作python提供了 --》 字符串格式化操作
# 格式化方式一： 占位符
# 常用的占位符有 %s %d %f 分别代表了 字符串、整数、小数，上面的案例就可以修改
print("a变量中存储数据是%d"%a)
# 多变量语句拼接
print("欢迎来到%s来学习全链路数据仓库课程，你的学号是QF%d"%("千锋教育",10010))
# 数据精准控制操作
print("欢迎来到%s来学习全链路数据仓库课程，你的学号是QF%d，本次你的考试成绩是%f"%("千锋教育",10010,98.43))
# 可以发现在输入小数数据98.43时输出的结果时98.430000
"""
我们可以使用辅助符号"m.n"来控制数据的宽度和精度
m，控制宽度，要求是数字（很少使用）,设置的宽度小于数字自身，不生效
.n，控制小数点精度，要求是数字，会进行小数的四舍五入
示例：
%3d：表示将整数的宽度控制在3位，如数字11，被设置为3d，就会变成：[空格]11，用1个空格补足宽度。
%8.2f：表示将宽度控制为8，将小数点精度设置为2
      小数点和小数部分也算入宽度计算。如，对3.1415设置了%8.2f 后，结果是：[空格][空格]3.1415。2个空格补足宽度，小数部分限制2位精度后，四舍五入为 .14
%.2f：表示不限制宽度，只设置小数点精度为2，如3.1415设置%.2f后，结果是3.14
"""
print("欢迎来到%s来学习全链路数据仓库课程，你的学号是QF%d，本次你的考试成绩是%.2f"%("千锋教育",10010,98.43))
#如果m比数字本身宽度小，m是不会生效的 .n会对小数部分进行四舍五入操作

# 格式化方式二： f字符串(快速格式化)
eduName = "千锋教育"
stuNo = 10010
stuScore = 98.43
print(f"欢迎来到{eduName}来学习全链路数据仓库课程，你的学号是QF{stuNo}，本次你的考试成绩是{stuScore}")

# 格式化方式三：表达格式化
# 对于那些不使用变量进行存储的表达式，只是提供计算并输出结果可以使用这样的方式完成
print("1+1等于%d"%(1+1))
print(f"1+1等于{1+1}")
#上述格式化字符串的方式可以应用在定义字符串变量时使用

第三章 Python流程控制

3.1. 流程控制介绍

在程序中，代码在执行的时候是可以遵循一定的结构来执行的。而程序执行的结构分为三种：

执行结构	描述	结构图
顺序结构	代码从上往下，逐行执行。也是程序执行的默认结构。
分支结构	程序在某一个节点遇到了多种向下执行的可能性， 根据条件，选择一个分支继续执行。
循环结构	某一段代码需要被重复执行多次。

流程控制就是通过指定的语句，修改程序的执行结构，将原本顺序执行的代码，修改成为分支结构或者循环结构。按照修改的不同的执行结构，流程控制语句可以分为两类: 分支流程控制语句 和 循环流程控制语句。

注意事项：

在Python中，代码块是由缩进形成的，平级的代码缩进是一样的，必须得是纵向齐平

缩进的语法要求是及其严格的

缩进按照编码规范是4个空格， 可以设置编辑器的tab键缩进，让其代表4个空格

3.2. if-else

3.2.1. if的基础语法

# if的最基础的使用
# if 判断条件:
#     条件成立之后的操作
#
# 案例: 从控制台输入一个数字，作为一个成绩，输出这个成绩是否及格了
score = int(input("请输入一个成绩:"))
# 判断成绩是否及格
if score >= 60:
    print("及格了！")

3.2.2. if-else的使用

# else就是“否则”的意思，表示如果if的条件不成立，就执行else中的逻辑
# if 判断条件:
#     条件成立之后执行的操作
# else:
#     条件不成立的时候执行的操作
#
# 案例: 从控制台输入一个数字，作为一个年份，判断这个年份是不是闰年
year = int(input("请输入一个年份: "))
# 判断是否是闰年
if year % 4 == 0 and year % 100 != 0 or year % 400 == 0:
    print(f"{year}是闰年")
else:
    print(f"{year}不是闰年")

3.2.3. elif的使用

# if-else可以实现两个分支的情况，可是现实情况是很多时候我们要处理的分支不止两个。
# 如果遇到了多个分支的情况，就可以使用elif来实现。
# if 判断条件1:
#     条件1成立后执行的操作
# elif 判断条件2:
#     条件1不成立后，再判断条件2是否成立，成立后执行这里的操作
# elif 判断条件3:
#     条件1、2都不成立后，再判断条件3是否成立，成立后执行这里的操作
# ...
#
# 案例: 从控制台输入一个成绩，根据成绩在的范围，输出对应的等级
score = int(input("请输入一个成绩: "))
# 判断不同的范围
if score > 100 or score < 0:
    print("错误的成绩！")
elif score < 60:
    print("不及格")
elif score < 80:
    print("中")
elif score < 90:
    print("良")
else:
    print("优")

3.3. match-case

match-case是在python3.10版本中添加的新特性，因此需要保证自己的python的版本在3.10以上才可以使用！

match-case是一种非常常见的分支流程控制语句，与if不同的是，if是根据一个bool的条件作为分支的依据，而match-case是监控某一个变量的值，根据变量具体的值来决定要执行什么分支的逻辑。

3.3.1. 基础使用

# 基础语法
# match 变量:
#     case 字面量1:
#         如果变量的值等于字面量1，执行这里的业务逻辑
#     case 字面量2:
#         如果变量的值等于字面量2，执行这里的业务逻辑
#     ...
#     case _:
#         如果变量的值，与上面的每一个case的字面量都不一样，执行这里的业务逻辑
#
# 案例: 
# 从控制台输入一个数字，根据数字输出对应的季节
# 1 => spring, 2 => summer, 3 => autumn, 4 => winter，如果是其他数字，输出other
season = int(input("please input a season number: "))
match season:
    case 1:
        print("spring")
    case 2:
        print("summer")
    case 3:
        print("autumn")
    case 4:
        print("winter")
    case _:
        print("other")

3.3.2. 变量捕捉

# 变量的捕捉
# match 变量:
#     case 字面量1:
#         如果变量的值等于字面量1，执行这里的业务逻辑
#     case 变量2:
#         如果变量的值与字面量1没有匹配上，就会将变量的值赋值给变量2！
#

season = int(input("please input a season number: "))
match season:
    case 1:
        print("spring")
    case 2:
        print("summer")
    case 3:
        print("autumn")
    case 4:
        print("winter")
    case other:
        print(f"wrong season: {other}")

# 注意事项：如果在输入的时候，输入的是1-4的数字，可以被case捕获到，就不会创建other变量，这里就会出问题
print(other)

关于match-case的使用，还有很多很多，例如在集合中的使用、在对象中的使用等，后续内容继续讲

3.4. while

3.4.1. while的基础语法

while和if的用法基本类似，区别在于:

• if条件成立，则执行一次
• while条件成立，则重复执行，直到条件不成立为止

# 基础语法:
# while 循环条件:
#     循环体

注意事项：

1. 条件需要提供布尔类型结果，True表示继续循环，False表示结束循环
2. 空格缩进不能忘！（保持和if分支语句一样的格式）
3. 请规划好循环终止条件，否则将无法结束循环，陷入无限循环中

3.4.2. while循环练习

# 案例1: 在控制台输出10行hello world
times = 0
while times < 10:
    print("hello world")
    times += 1
    
# 案例2: 计算1+2+3+...+100的和
sum = number = 0
while number <= 100:
    sum += number
    number += 1
print(sum)

# 案例3: 计算100以内的奇数的和
sum = 0
number = 1
while number <= 100:
    if number % 2 == 1:
        sum += number
    number += 1
print(sum)

# 案例4: 计算100以内的偶数的和
sum = 0
number = 0
while number <= 100:
    sum += number
    number += 2
print(sum)

3.5. for-in

3.5.1. for-in的基础使用

除了while循环语句外，Python同样提供了for循环语句。两者能完成的功能基本差不多，但仍有一些区别：

• while循环的循环条件是自定义的，自行控制循环条件

• for循环是一种”轮询”机制，是对一批内容进行”逐个处理”

# 基础语法
for 变量名 in 容器类型数据:
    循环操作体
# PS：python中的容器类型有字符串（str）、列表（list）、元组（tuple）、字典（dict）、集合（set）

# for-in循环
for s in 'goodprogrammer':
    print(s)
"""
`in 容器型数据` 表示进入到容器结构中，先检查有没有下一个元素，如果有的话，取出元素，把元素的值赋值给`变量名`, 然后执行循环操作体，
 再次 `in 容器型数据` 进入到容器结构中, 先检查有没有下一个元素, 如果没有的话，循环操作就结束了
通俗的说明： 容器类型可以理解为一包瓜子，变量就行获取一包瓜子中的每一个瓜子，直到没有一颗瓜子为止
"""

3.5.2. range等差数列

for-in语句中的【容器类型（也可以称之为可迭代对象）】只能被动取出数据处理，除了刚刚上述说明的类型之外，还可以使用range语句,来获得一个简单的数字序列（可以迭代对象的一种）

# 语法1：
# range(num)
# 获取一个从0开始，到num结束的数字序列（不含num本身）
# 如，range(5)取得的数据是：[0, 1, 2, 3, 4]
for s in range(5):
	print(s)
    
# 语法2：
# range(num1,num2)
# 获得一个从num1开始，到num2结束的数字序列（不含num2本身）
# 如，range(5, 10)取得的数据是：[5, 6, 7, 8, 9]
for s in range(5,10):
	print(s)
    
# 语法3：
# range(num1,num2,step)
# 获得一个从num1开始，到num2结束的数字序列（不含num2本身）
# 数字之间的步长，以step为准（step默认为1）
# num1 < num2 为正数就表示是递增的等差数列             
# 如，range(5, 10, 2)取得的数据是：[5, 7, 9]
for s in range(5,10,2):
	print(s)
# num1 > num2  为负数就表示是递减的等差数列             
# 如，range(10, 5, -2)取得的数据是：[10, 8, 6]  
for s in range(10,5,-2):
	print(s)
# 如果不满足上述要求 生成的数列就是一个空数列 里面没有数据                                 
# 如，range(10, 0, 2)取得的数据是：空数列 
for s in range(10,0,2):
	print(s)

3.6. break和continue

3.6.1. break关键字

无论是while循环或是for循环，都是重复性的执行特定操作，在这个重复的过程中，会出现一些其它情况让我们不得不提前退出循环，不再继续，就可以使用break关键字

"""
break: 终止循环体内容的执行
需求: 模拟20岁工作到80岁, 60岁退休
"""

for age in range(20,81):
	if age == 60:
		break
	print(f"{age}岁正在上班")

3.6.2. continue关键字

无论是while循环或是for循环，都是重复性的执行特定操作，在这个重复的过程中，会出现一些其它情况让我们不得不暂时跳过某次循环，直接进行下一次就可以使用continue关键字

"""
continue: 跳过某次循环体内容的执行
需求: 模拟电梯上行的过程1 - 24层, 4层不停.
"""
for i in range (1,25):
	if i == 4:
		continue
	print(f"{i}层到了")

3.6.3. else关键字

无论是while循环或是for循环，都是需要一个循环的条件的。在循环中，如果是正常停止的（由于循环条件不满足导致的循环终止，或者是因为容器中没有可以迭代的元素而终止），结束后会执行else代码段中的内容！

# 在下面的代码中，循环可以直到循环迭代序列中没有元素而终止，属于“寿终正寝”，因此else中的代码可以执行
for i in range(1, 10):
    print("hello world %d" % i)
else:
    print("循环结束了！")

# 在下面的代码中，循环迭代range范围中的元素，到10的时候，用break关键字强制停掉了循环，因此else中的逻辑不会执行
for i in range(1, 100):
    print("hello world %d" % i)
    if (i == 10):
        break
else:
    print("循环结束了！")

3.7. 嵌套循环与死循环

3.7.1. 嵌套循环

嵌套循环和嵌套分支是一样的，当编程时需要在循环的内部在进行循环时，就需要使用到嵌套循环了，python中提供的循环都可以进行嵌套循环操作

需要注意：

• 循环语句的嵌套，要注意空格缩进（基于空格缩进来决定层次关系）
• 注意条件的设置，避免出现无限循环（除非真的需要无限循环）

# while的嵌套循环
"""
打印如下图形
* * * * *
* * * * *
* * * * *
* * * * *
* * * * *
"""
i = 1
while i <= 5:
    j = 1
    while j <= 5:
        print("*", end=" ") # print打印语句是自带换行操作的，如果不需要换行可以添加第二参数end=""，也可通过end="添加符号进行一行内数据的分隔"
        j += 1
    print()
    i += 1
print("-----------------------------------------------------------")


# for-in的嵌套循环
# 打印直角三角形状的99乘法表
for i in range(1,10):
	for j in  range(1,i+1):
		print(f"{j}*{i}={i*j}",end="\t")
	print()

3.7.2. 死循环

死循话其实指的就是循环条件永远成立，循环无限执行的循环。

# 死（无限）循环
# 推荐使用while循环来完成操作，简单好用只要保证循环条件为True即可
# while True:
# 	print("死循环")
# for-in循环实现起来有一些复杂
# 方法1.1：借助循环遍历列表的cycle方法
# from itertools import cycle
# for _ in cycle([1]):
#     print("死循环")

# 方法1.2：借助无穷迭代器repeat
# from itertools import repeat
# for _ in repeat(None):  # repeat(elem,[n])，对elem迭代n次，n不传则默认无限次
#     print("死循环")

# 方法1.3：借助计数器，但是事实上只会循环到计数值大到将内存撑爆时
# from itertools import count
# for _ in count():
#     print("死循环")

# 方法1.4：借助iter，int函数每次迭代返回的都是0，始终不会等于哨兵值1，所以会无限迭代
for _ in iter(int, 1):
    print("死循环")
# int函数和1只是个例子，可以传入其它可调用对象和哨兵值，只要迭代值始终不等于哨兵值就可以。

3.8. 流程控制综合案例

3.8.1. 需求: 剪刀石头布

需求：
************************************************************
欢迎XXX进入猜拳游戏
1.石头     2.剪刀     3.布     0.退出
************************************************************
请输入数字:
1
恭喜 你赢了


************************************************************
欢迎XXX进入猜拳游戏
1.石头     2.剪刀     3.布     0.退出
************************************************************
请输入数字:
2

************************************************************
欢迎XXX进入猜拳游戏
1.石头     2.剪刀     3.布     0.退出
************************************************************
请输入数字:
0

# 退出游戏后:
			        排行榜


******************************************************************
姓名		总局数		赢场		胜率
XXX		  0		    0		 0

当前的总局数,胜场,胜率

3.8.2. 代码实现

# 定义一些常用局部变量
import random

STotal =  0  # 总局数
SVictory = 0  #胜场
player_choose = 0 # 玩家输入
computer_choose = 0  # 电脑输入
while True:
	print("*" * 60)
	print("欢迎大宝进入猜拳游戏")
	print("1.石头     2.剪刀     3.布     0.退出")
	print("*" * 60)
	print("请输入数字:")
	player_choose = int(input())#获取玩家输入
	#玩家输入0游戏结束
	if 0 == player_choose:
		print("\t\t\t\t\t\t排行榜")
		print("*" * 60)
		print("姓名\t\t总局数\t\t赢场\t\t胜率")
		if STotal == 0 or SVictory ==0:
			print(f"大宝\t\t{STotal}\t\t\t{SVictory}\t\t{0}%")
		else:
			print("大宝\t\t%d\t\t\t%d\t\t%.2f"%(STotal,SVictory,(float(SVictory) / float(STotal) * 100))+"%")
		break
	# 游戏开始
	STotal += 1 # 总局数+1
	# 模拟电脑出拳 使用随机数 random
	computer_choose = random.randint(1,3)
	if computer_choose==1:
		print("电脑出拳是:石头")
	elif computer_choose==2:
		print("电脑出拳是:剪刀")
	else:
		print("电脑出拳是:布")
	"""
    如何判断胜利,平局和输 1.石头     2.剪刀     3.布
    石头 > 剪刀   剪刀 > 布     布> 石头
    """
	win = player_choose - computer_choose
	if win == -1 or win == 2:
		print("恭喜,你赢了!!(#^.^#)")
		print() #换行就是为了打印好看
		SVictory += 1
	elif win == 0:
		print("平局,再来!!o(*￣︶￣*)o")
		print()#换行就是为了打印好看
	else:
		print("你输入了,再来.....!!O(∩_∩)O哈哈~")
		print()#换行就是为了打印好看