前言
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: