前言
Python目前是一个应用场景非常广泛的编程语言。
优点：
语法言简意赅，容易上手。
功能强大，用途广泛。
生态丰富，具有海量的成熟第三方库。
方便调用C/C++编写的代码进行高性能/系统级操作。
缺点：
执行效率比较弱。
对于多核心并发程序支持偏弱。
动态类型系统对于大型项目不太友好。
本文主要记录Python基础入门学习的笔记。记录于2024年1月30日。
一、Python环境搭建
要想能够进行 Python 开发，就需要搭建好 Python 的环境。
需要安装的环境主要是两个部分：
运行环境：Python
开发环境：PyCharm
1.安装Python
1.根据不同的平台，在官网下载Python：下载地址，以Windows平台为例：
找到下载页面：
关于 Python 版本的补充：
现在主流使用的 Python 版本是 Python 3 系列. 但是有一些比较老的项
目, 可能还在使用 Python 2.3 系列 和 2 系列 之间的语法还是存在不小差别的. 本文的内容主要是依据 Python 3 系列。
2.打开安装包：
1.勾选下 “Use admin privileges when installing py.exe”和"Add Python 3.10 to PATH" 这两个选项。
2.要记录 Python 的安装目录(后面可能会用到)。
3.点击Install Now安装，程序会自动安装直至完成。
2.安装PyCharm
1.官网下载PyCharm：下载地址。
专业版（Professional）是收费软件，选择社区版（Community）免费使用：
2.打开安装包：
1.建议先修改下路径，选择D盘：
2.建议勾选所有选项，然后无脑下一步安装：
3.使用PyCharm创建个项目，输出“Hello World!”
二、Python基础语法
1.常量表达式
可以把 Python 当成一个计算器，来进行一些算术运算。
print(1 + 2 - 3)
print(1 + 2 * 3)
print(1 + 2 / 3)
形如 1 + 2 - 3 这样是算式，在编程语言中称为表达式，算式的运算结果，称为 表达式的返回值。
其中 1 , 2 , 3 这种称为字面值常量，+ - * / 这种称为运算符或者操作符。
注意：
print 是一个 Python 内置的函数。
可以使用 + - * / ( ) 等运算符进行算术运算，先算乘除，后算加减。
2.变量和类型
2.1 变量是什么
变量可以视为是一块能够容纳数据的空间，这个空间往往对应到 “内存” 这样的硬件设备上。
有的时候，我们需要进行的计算可能更复杂一些，需要把一些计算的中间结果保存起来，这个时候就需要用到变量。
示例：
给定四个分数, 67.5, 89.0, 12.9, 32.2 ，编写代码，求这四个分数的方差。
PS：方差的计算过程：取每一项，减去平均值,计算平方，再求和，最后除以 (项数 - 1)。
在这个代码中，就需要先计算这四个数字的平均值，然后再计算方差。这就需要把计算的平均值使用变量保存起来。
avg = (67.5 + 89.0 + 12.9 + 32.2) / 4
total = (67.5 - avg) ** 2 + (89.0 - avg) ** 2 + (12.9 - avg) ** 2 + (32.2 - avg)
** 2
result = total / 3
print(result)
#avg, total, result 均为变量。
#“**”在 Python 中表示乘方运算。 “**2” 即为求平方。
2.2 变量的语法
（1）定义变量
创建变量语法：
a 为变量名，当我们创建很多个变量的时候，就可以用名字来进行区分。
= 为赋值运算符，表示把 = 右侧的数据放到 = 左侧的空间中。
a = 10
变量命名规则：
硬性规则（必须遵守）：
变量名由数字字母下划线构成。
数字不能开头。
变量名不能和 “关键字” 重复。
变量名大小写敏感。 num 和 Num 是两个不同的变量名。
软性规则（建议遵守）：
变量名使用有描述性的单词来表示，尽量表达出变量的作用。
一个变量名可以由多个单词构成，长一点没关系，但是含义要清晰。
当变量名包含多个单词的时候，建议使用 “驼峰命名法”。形如 totalCount，personInfo 这种，除了首个单词外，剩余单词首字母大写。
（2）使用变量
#读取变量的值
a = 10
print(a)
#修改变量的值
a = 10
print(a)
#注意: 在 Python 中, 修改变量也是使用 = 运算, 看起来和定义变量没有明显区别.
#也可以用一个变量的值赋给另外一个变量
a = 10
b = 20
a = b
print(a)
print(b)
2.3 变量的类型
变量里面存储的不仅仅是数字，还可以存储其它种类的数据。为了区分不同种类的数据，我们引入了 “类型” 这样的概念。
注意: 和 C++ / Java 等语言不同， Python 变量的类型不需要显式指定，而是在赋值的时候确定的。如果非要指定类型，可以在变量名后面加个冒号，例如：a:int = 10
（1）整数
a = 10
print(type(a))
注意：
type 和 print 类似，也是 python 内置的函数。可以使用 type 来查看一个变量的类型。
和 C++ / Java 等语言不同，Python 的 int 类型变量，表示的数据范围是没有上限的。只要内存足够大，理论上就可以表示无限大小的数据。
(2) 浮点数(小数)
a = 10.5
print(type(a))
注意：和 C++ / Java 等语言不同，Python 的小数只有 float 一种类型，没有 double 类型。但是实际上
Python 的 float 就相当于 C++ / Java 的 double， 表示双精度浮点数。
(3) 字符串
a = "hello"
print(type(a))
#使用 ' ' 或者 " " 引起来的, 称为字符串.可以用来表示文本.
注意：在 Python 中，单引号构成的字符串和双引号构成的字符串，没有区别。 ‘hello’ 和 “hello” 是完全等价的。
可以使用 len 函数来获取字符串的长度：
a = 'hello'
print(len(a))
可以使用 + 针对两个字符串进行拼接：
a = 'hello'
b = 'world'
print(a + b)
#此处是两个字符串相加. 不能拿字符串和整数/浮点数相加.
(4) 布尔
布尔类型是一个特殊的类型，取值只有两种，True (真/1/非0 ) 和 False (假/0)。
a = True
print(type(a))
b = False
print(type(b))
(5) 其他
除了上述类型之外，Python 中还有 list, tuple, dict, 自定义类型等等。
2.4 为什么要有这么多类型?
(1) 类型决定了数据在内存中占据多大空间。
例如 float 类型在内存中占据 8 个字节。
PS：计算机里面使用二进制来表示数据， 也就是每个位只能表示 0 或者 1。
1 个二进制位，就称为是一个 “比特”， 8 个二进制位，就称为一个 “字节” (Byte)。
一个 float 变量在内存中占据 8 个字节空间，也就是 64 个二进制位。
我的电脑有 16GB 的内存空间，也就是一共有 1024 * 1024 * 1024 * 8 这么多的二进制位。
(2) 类型其实约定了能对这个变量做什么样的操作。
例如 int / float 类型的变量，可以进行 + - * / 等操作。
而 str 类型的变量，只能进行 + (并且行为是字符串拼接)，不能进行 - * / ，但是还能使用 len 等其他操作。
总结：类型系统其实是在对变量进行 “归类”。 相同类型的变量(数据) 往往具有类似的特性和使用规则。
2.5 动态类型的特性
在 Python 中，一个变量是什么类型， 是可以在 “程序运行” 过程中发生变化的，这个特性称为 “动态类型” 。
a = 10
print(type(a))
a = 'hello'
print(type(a))
在程序执行过程中，a 的类型刚开始是 int，后面变成了 str。
注意：C++/Java 这样的语言则不允许这样的操作。一个变量定义后类型就是固定的了。这种特性则称为 “静态类型”。
动态类型特性是一把双刃剑：
对于中小型程序，可以大大的解约代码量(比如写一段代码就可以同时支持多种类型)。
对于大型程序， 则提高了模块之间的交互成本。(程序猿 A 提供的代码难以被 B 理解)。
3.注释
注释是一种特殊的代码，它不会影响到程序的执行，但是能够起到解释说明的作用，能够帮助程序猿理解程序代码的执行逻辑。
PS：写代码是一件比较烧脑的事情，读代码同样也非常烧脑。相比于一板一眼的代码， 一些口语化的描述能更好的帮助程序猿理解程序。
3.1 注释的语法
(1) 注释行
使用 # 开头的行都是注释：
# 这是一行注释
(2) 文档字符串
使用三引号引起来的称为 “文档字符串”，也可以视为是一种注释：
可以包含多行内容。
一般放在 文件/函数/类 的开头。
“”" 或者 ‘’’ 均可 (等价)。
"""
这是文档字符串
这是文档字符串
"""
'''
这也是文档字符串
这也是文档字符串
'''
3.2 注释的规范
内容准确：注释内容要和代码一致。匹配。并在代码修改时及时更新。
篇幅合理：注释既不应该太精简，也不应该长篇大论。
使用中文：一般中国公司都要求使用中文写注释，外企另当别论.。
积极向上：注释中不要包含负能量(例如 领导 SB 等)。
4.输入（input）输出（print）
程序需要和用户进行交互：
用户把信息传递给程序的过程，称为 “输入”。
程序把结果展示给用户的过程，称为 “输出”。
4.1 通过控制台输出
Python 使用 print 函数输出到控制台：
#输出字符串
print('hello')
#输出整数
a = 10
print(a)
#输出布尔
b = True
print(b)
#可以任意输出其他类型的变量
输出的内容混合字符串和变量：
num = 10
print(f"num = {10}")
#控制台输出：num = 10
注意：
使用 f 作为前缀的字符串，称为 f-string，叫做格式化字符串，f就是foramt：格式化的意思。
里面可以使用 { } 来内嵌一个其他的变量/表达式。
4.2 通过控制台输入
Python 使用 input 函数，从控制台读取用户的输入：
num = 0
num = input('请输入一个整数: ')
print(f'你输入的整数是 {num}')
注意：
input 的参数相当于一个 “提示信息”，也可以没有。
input 的返回值就是用户输入的内容，是字符串类型。
a = input('请输入第一个整数: ')
b = input('请输入第二个整数: ')
print(f'a + b = {a + b}')
#控制台输出：a + b = 1020
以上代码的结果是字符串拼接，不是算术运算，如果要想进行算术运算，需要先转换类型。
通过 int( ) 把变量转成了 int 类型（类似的，使用 float( ), bool( ), str( ) 等可以完成对应的类型转换）：
a = input('请输入第一个整数: ')
b = input('请输入第二个整数: ')
a = int(a)
b = int(b)
print(f'a + b = {a + b}')
5.运算符
5.1 算术运算符
像 + - * / % ** // 这种进行算术运算的运算符， 称为 算术运算符。
注意1： / 中不能用 0 作为除数. 否则会抛出异常。
异常是编程语言中的一种常见机制，表示程序运行过程中，出现了一些 “意外情况”，导致程序不能继续往下执行了。
注意2： 整数 / 整数 结果可能是小数，而不会截断。
注意3： % 不是 “百分数”， 而是求余数。
print(7 % 2) #输出：1
注意4： ** 是求乘方， 不光能算整数次方，还能算小数次方。
print(4 ** 2) #输出：16
print(4 ** 0.5) #输出：2.0
注意5： // 是取整除法(也叫地板除)，整数除以整数，结果还是整数(舍弃小数部分，并向下取整，不是四舍五入)
print(7 // 2) #输出：3
print(-7 // 2) #输出：-4
5.2 关系运算符
像 < <= > >= == != 这一系列的运算符称为关系运算符，它们是在比较操作数之间的关系。
(1) 对整数进行比较，如果关系符合，则表达式返回 True，如果关系不符合，则表达式返回 False。
(2) 关系运算符不光针对整数/浮点数进行比较，还能针对字符串进行比较。
a = 'hello'
b = 'world'
print(a < b) #True
print(a <= b) #True
print(a > b) #False
print(a >= b) #False
print(a == b) #False
print(a != b) #True
注意：
直接使用 == 或者 != 即可对字符串内容判定相等(这一点和 C / Java 不同)。
字符串比较大小，规则是 “字典序”。
针对中文的字符串进行比较大小，是没有意义的。
关于字典序：
想象一个英文词典，上面的单词都是按照字母顺序排列，如果首个字母相同，就比较第二个字母(就比如著名单词 abandon)。
我们认为一个单词在词典上越靠前，就越小，越靠后，就越大。
(3) 对于浮点数来说, 不要使用 == 判定相等。
print(0.1 + 0.2 == 0.3) #False
注意：
浮点数在计算机中的表示并不是精确的，在计算过程中，就容易出现非常小的误差。
print(0.1) #输出：0.1
print(0.2) #输出：0.2
print(0.3) #输出：0.3
print(0.1 + 0.2) #输出：0.30000000000000004
可以看到，0.1 + 0.2 的结果并非是 0.3，而是带了个小尾巴，虽然这个尾巴非常小了，但是 == 是锱铢必较的，仍然会导致 == 的结果为 False。
注意：
不止是 Python 如此，主流编程语言都是如此，这个是 IEEE754 标准规定的浮点数格式所引入的问题。
正确的比较方式：
不再严格比较相等了，而是判定差值小于允许的误差范围。
实际工程实践中，误差在所难免，只要保证误差在合理范围内即可。
a = 0.1 + 0.2
b = 0.3
print(-0.000001 < (a - b) < 0.000001)
5.3 逻辑运算符
像 and or not 这一系列的运算符称为 逻辑运算符。
and 并且，两侧操作数均为 True，最终结果为 True。否则为 False(一假则假)。
or 或者，两侧操作数均为 False，最终结果为 False，否则为 True(一真则真)。
not 逻辑取反，操作数本身为 True，则返回 False，本身为 False，则返回 True。
a = 10
b = 20
c = 30
print(a < b and b < c) #True
print(a < b and b > c) #False
print(a > b or b > c) #False
print(a < b or b > c) #True
print(not a < b) #False
print(not a > b) #True
一种特殊写法：
a < b and b < c 这个操作等价于 a < b < c， 这个设定和大部分编程语言都不相同。
关于短路求值：
和其他编程语言类似，Python 也存在短路求值的规则。
对于 and，如果左侧表达式为 False，则整体一定为 False，右侧表达式不再执行。
对于 or，如果左侧表达式为 True，则整体一定为 True，右侧表达式不再执行。
print(10 > 20 and 10 / 0 == 1) #False
print(10 < 20 or 10 / 0 == 1) #True
上述代码没有抛出异常，说明右侧的除以 0 操作没有真正执行。
5.4 赋值运算符
（1）= 表示赋值，注意和 == 区分。
= 除了基本的用法之外，还可以同时针对多个变量进行赋值。
链式赋值：
a = b = 10
多元赋值：
a, b = 10, 20
代码实例：交换两个变量
基础写法：
a = 10
b = 20
tmp = a
a = b
b = tmp
print(a, b)
多元赋值写法：
a = 10
b = 20
a, b = b, a
print(a, b)
（2） 复合赋值运算符
Python 还有一些 复合赋值运算符，例如： += -= *= /= %=
其中 a += 1 等价于 a = a + 1，其他复合赋值运算符也是同理。
注意：
像 C++ / Java 中，存在 ++ – 这样的自增/自减运算符，Python 中则不支持这种运算，如果需要使用，则直接使用 += 1 或者 -= 1。
++ – 最大的问题就是容易分不清前置和后置的区别，这一点 Python 语法在设计的时候就进行了规避，避免出现这种不直观，并且容易混淆的语法。
5.5 其他运算符
除了上述之外，Python 中还有一些运算符，比如 身份运算符 (is, is not)，成员运算符 (in, not in)，位运算符( & | ~ ^ << >>) 等。
6.顺序语句
默认情况下， Python 的代码执行顺序是按照从上到下的顺序，依次执行的。
下面代码，执行结果一定为 “123”，而不会出现 “321” 或者 “132” 等，这种按照顺序执行的代码，我们称为 顺序语句。
print("1")
print("2")
print("3")
注意：
这个顺序是很关键的，编程是一件明确无歧义的事情，安排好任务的顺序，计算机才能够正确的进行执行。
在Python中，一个语句写完以后，可以加上分号也可以不加，通常是不加的；在特定的场景，比如，多个语句写到一行，语句之间必须加上分号，但是一般建议这样写。
7.条件语句
条件语句能够表达 “如果 … 否则 …” 这样的语义，这构成了计算机中基础的 逻辑判定。
条件语句 也叫做 分支语句，表示了接下来的逻辑可能有几种走向。
7.1 语法格式
（1）if语法：
如果 expression 值为 True, 则执行 do_something1, do_something2, next_something
如果 expression 值为 False, 则只执行 next_something, 不执行 do_something1, do_something2
if expression:
do_something1
do_something2
next_something
（2）if else语法：
如果 expression 值为 True, 则执行 do_something1
如果 expression 值为 False, 则执行 do_something2
if expression:
do_something1
else:
do_something2
（3）if elif else语法：
如果 expression1 值为 True, 则执行 do_something1
如果 expression1 值为 False, 并且 expression2 为 True 则执行 do_something2
如果 expression1 值为 False, 并且 expression2 为 False 则执行 do_something3
if expression1:
do_something1
elif expression2:
do_something2
else:
do_something3
示例：输入 1 表示愿意认真学习，输入 2 表示躺平摆烂。
choice = input("输入 1 表示认真学习, 输入 2 表示躺平摆烂: ")
if choice == "1":
print("你会找到好工作!")
elif choice == "2":
print("你可能毕业就失业了!")
else:
print("你的输入有误!")
注意：
Python中的条件语句写法，和很多编程语言不太一样。
if 后面的条件表达式，没有 ( )，使用 : 作为结尾。
if / else 命中条件后要执行的 “语句块”，使用 缩进 (通常是 4 个空格或者 1 个 tab)来表示，而不是 { }。
对于多条件分支，不是写作 else if，而是 elif (合体了)。
（4）缩进和代码块：
代码块指的是一组放在一起执行的代码。
在 Python 中使用缩进表示代码块，不同级别的缩进，程序的执行效果是不同的。
# 代码1
a = input("请输入一个整数: ")
if a == "1":
print("hello")
print("world")
# 代码2
a = input("请输入一个整数: ")
if a == "1":
print("hello")
print("world")
注意上述代码的区别：
在代码1 中，print(“world”) 有一级缩进，这个语句属于 if 内的代码块，意味着条件成立，才执行，条件不成立， 则不执行。
在代码2 中，print(“world”) 没有缩进，这个语句是 if 外部的代码，不属于 if 内部的代码块，意味着条件无论是否成立，都会执行。
另外, 代码块内部还可以嵌套代码块：
a = input("请输入第一个整数: ")
b = input("请输入第二个整数: ")
if a == "1":
if b == "2":
print("hello")
print("world")
print("python")
在这个代码中：
print(“hello”) 具有两级缩进，属于 if b == “2” 条件成立的代码块。
print(“world”) 具有一级缩进，属于 if a == “1” 条件成立的代码块。
print(“python”) 没有缩进，无论上述两个条件是否成立，该语句都会执行。
基于缩进的方式表示代码块，带来的好处就是强制要求程序猿要写明确的缩进，来明确代码之间的相对关系，如果缩进书写的不对，则直接报错。
同时，带来的坏处就是：如果缩进层次比较多，就容易分不清楚某个语句属于哪个层级。
if a == 1:
if b == 2:
if c == 3:
if d == 4:
if e == 5:
if f == 6:
if g == 7:
print("hello")
print("1")
print("2")
因此，就有了 “写 Python 需要自备游标卡尺” 这个梗。
练习：判定年份是否是闰年
闰年定义：
如果年份能被4整除，但不能被100整除，那么这一年就是闰年。
如果年份能被100整除，但同时也能被400整除，那么这一年也是闰年。
代码1：
year = int(input("请输入年份: "))
if year % 100 == 0:
# 判定世纪闰年
if year % 400 == 0:
print("闰年")
else:
print("平年")
else:
# 判定普通闰年
if year % 4 == 0:
print("闰年")
else:
print("平年")
代码2：
year = int(input("请输入年份: "))
if (year % 100 != 0 and year % 4 == 0) or year % 400:
print("闰年")
else:
print("平年")
（5）空语句 pass：
1万+
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
