Python教程 - 2基础语法

更好的阅读体验：点这里 （ www.doubibiji.com ）

2 基础语法

2.1 字面量

什么是字面量

字面量就是在代码中，写下来的固定的值。

举个栗子：

10
3.14
"学Python"

上面定义了3个字面量，它们的类型分别是 整数、浮点数（也就是小数）、字符串。

除了上面3种类型，Python还有哪些数据类型呢？

Python中常用的数据类型有6种：

类型	描述	说明
数字（Number）	整数（int） 浮点数（float） 复数（complex） 布尔（bool）	整数，例如：10、0、-10 浮点数，例如：13.14、-5.12 复数，例如：4+3j，以j结尾表示复数 布尔，只有两个可选值True和False，即真和假，布尔值本质上是数字，True为1，False是0
字符串（String）	记录文本的一种数据类型	字符串是由任意数量的字符组成
列表（List）	有序的可变序列	Python中使用最频繁的数据类型，可有序记录一堆数据
元组（Tuple）	有序的不可变序列	可有序记录一堆不可变的Python数据集合
集合（Set）	无序不重复集合	可无序记录一堆不重复的Python数据集合
字典（Dictionary）	无序key-value集合	可无序记录一堆Key-Value型的Python数据集合

看完上面的表，你可能都蒙圈了，什么乱七八糟的，刚开始学就懵逼，入门就放弃？

不急，慢慢介绍一下。

下面先介绍一下 数字 和 字符串，其他的后面再说。

1 整数(int)

和数学中的一致。

例如：2，123，-12

2 浮点数(float)

也就是数学中的小数。

例如：12.13，-10.24，3.1415926

3 布尔(bool)

值只有2个，即 True 和 False，注意大小写不能错。

4 字符串

字符串（string），又称文本，是由任意数量的字符如中文、英文、各类符号、数字等组成。

Python中，字符串需要用双引号 " 包围起来，被引号包围起来的，都是字符串。

例如：

"123"      # 这个是字符串，不是数字
"abc"
"abc123"
"!@#$%^&"
"你好，China"

这么说完，不懵逼了吧，其他的数据类型，后面再做介绍。

2.2 注释

我们在学习任何语言，都会有注释，注释的作用就是向别人解释我们编写的代码的含义和逻辑，使代码有更好的可读性，注释不是程序，是不会被执行的。

注释一般分类两类，单行注释和多行注释。

1 单行注释

单行注释以 # 开头，井号右边为注释内容。

例如：

# 我是单行注释，打印Hello World
print("Hello World!")

注意：# 号和注释内容一般建议以一个空格隔开，这是代码规范，建议大家遵守。

单行注释一般用于对一行或一小部分代码进行解释。

2 多行注释

多行注释是以一对三个双引号括起来，中间的内容为注释内容，注释内容可以换行。

"""
我是多行注释，
我来哔哔两句
"""
print("哔~~")

多行注释一般对：Python文件、类、方法进行解释，类和方法后面我们再学习。

2.3 变量

变量是在程序运行的时候存储数据用的，可以想象变量为一个盒子。

整数、浮点数（小数）、字符串都可以放在变量中。

1 变量的定义

定义变量的格式：变量名称 = 变量值

例如：

# 定义一个变量，用来表示钱包的余额
money = 50
# 打印出余额
print("余额: ", money, "元")    # 余额: 50元

# 定义一个变量name，用来保存姓名
name = "张三"
print("姓名: ", name)    # 姓名: 张三

使用print函数，我们可以使用如下格式进行多个内容的输出:

print(内容1, 内容2, ......, 内容N)

和 C 和 Java 语言不同，Python不是强类型变量，不需要指定变量的类型。

2 变量的特征

变量变量，从名字中可以看出，表示“量”是可变的。所以，变量的特征就是，变量存储的数据，是可以发生改变的。

例如：

# 定义一个变量，用来表示钱包的余额
money = 50
# 打印出余额
print("余额:", money, "元")     # 余额: 50元

# 买了一个雪糕花了45，减去45元
money = money - 45;
print("买完雪糕后，余额为: ", money, "元")    # 买完雪糕后，余额为: 5元

可以看到变量可以参与运算。

为什么要使用变量？

变量就是在程序运行时，记录数据用的，使用变量是为了重复的使用这些数据。

3 变量的存储

如果对 java 不熟悉，可以忽略 java 的介绍。

Java变量的内存机制

熟悉Java的小伙伴可能知道，Java中的数据类型分基本数据类型与引用数据类型，对于基本数据类型，在栈内存中存储的是基本数据类型的值，而对于引用数据类型，栈内存存储的是引用数据类型数据的内存地址，引用数据的值存储在堆内存空间，这个内存地址的就是该引用数据的堆内存地址。（可以忽略）

Python变量的内存机制

Python万物皆对象，在栈内存永远存储的是数据的堆内存地址，堆内存存储的数据值。

变量内存示意

上面说的是什么意思呢？

举个栗子：

a = 10
b = 20

在内存中的存储，示意图如下：

首先在栈区开辟了为a开辟一块内存，但是10并不是存储在a中，而是在堆区开辟了另一块内存存储10，然后将10的内存地址存在a中，

b同理。

继续

a = 10
b = a

在内存中的存储，示意图如下：

将a赋值给b，是将a中存储的地址赋值给b。

此时a和b指向堆中的同一块内存区域，里面存储了10，那么此时修改a的值，b的值会变吗？

a = 10
b = a

a = 20
print(b);

执行结果：

10

b的值不会变，为什么？

此时内存中的存储，示意图如下：

此时将20赋值给a，是在堆区中重新开辟了一块内存存储20，然后将20的地址赋值给a，a存储了20的地址，b没有变。

is 关键字

如何判断两个变量是否指向同一块内存区域呢？

可以使用 is 关键字，举个栗子：

a = 10
b = 20
print(a is b)				# False，a和b指向的是不同的地址

a = 10
b = a
print(a is b)				# True，a和b指向的是相同的地址

同样还可以使用 is not 来进行相反的判断：

print(a is not b)

小整数对象池

我们之前可以在命令行中编写Python代码进行执行，这种方式称为交互式编程，现在我们重新编写一段代码：

完全懵逼了！！！

为什么a = 10 和 b = 10 指向的是相同的对象？ a = 1000 和 b = 1000 指向的是不同的对象。

这是因为编译器Cpython中存在小整数池[-5, 256]，在解释器启动的时候就自动开辟了，在全局范围内重复使用，不会被垃圾回收。

所以a = 10 和 b = 10 指向的是相同的对象。

把同样的代码放在文件中执行或在PyCharm中执行：

a = 10
b = 10
print(a is b)

a = 1000
b = 1000
print(a is b)

执行结果：

True

True

又懵逼了！！！

为什么和交互式执行的结果又不一样？

这是因为出于对性能的考虑，编译器会扩大小整数池的范围，如果创建变量的值如果相同的话，创建的时间间隔又比较短，那么他们的内存空间的值是相同的。

其他的字符串等不可变类型也都包含在内一便采用相同的方式处理了，我们只需要记住这是一种优化机制，至于范围到底多大，无需细究。

id 函数

上面 is 关键字的逻辑是比较两个变量指向的是否是相同的内存地址，我们可以使用 id 函数获取变量的内存地址：

a = 10
b = 10
print(a is b)
print(id(a))
print(id(b))

执行结果：

True
4400850656
4400850656

可以看到变量 a 和 b 的地址是相同的，所以 a is b 为 True。

4 del 关键字

del的作用是删除变量，解除变量和堆中对象的关联。

举个栗子：

a = 10
del a
print(a)		# 代码执行到这里会报错，因为del a已经将变量a删除了，这里a是没有声明的，所以会报错。

此时的内存示意如下：

此时的变量a内删除，没有变量指向10，10的内存空间随时可能被当做垃圾回收。

2.4 数据类型

刚才在字面量的时候，已经介绍了一下数据类型。

在定义变量的时候，我们也将不同的类型的数据放到了变量中：

例如：

money = 50
name = "张三"

那么如何验证一个数据的数据类型呢？

1 type()

使用type()函数，可以得到数据的类型。

举个栗子：

print(type(10))
print(type(3.14))
print(type("100"))

执行结果如下，可以看到三个数据的类型，分别是整形、浮点型、字符串：

<class 'int'>
<class 'float'>
<class 'str'>

我们还可以将type()的结果保存到变量中：

data_type = type("人生苦短，我选Python")
print(data_type)    # 执行结果: <class 'str'>

也可以查看变量中存储的数据的类型：

name = "张三"
data_type = type(name)
print(data_type)    # 执行结果: <class 'str'>

再来看一个问题，代码如下：

# 在value变量中放入字符串
value = "张三"
data_type = type(value)
print(data_type)

# 在value变量中，重新放入整形
value = 10
data_type = type(value)
print(data_type)

我们先后在同一个变量中，放入字符串和整形数据，执行的结果是：

<class 'str'>
<class 'int'>

可以得出，变量是没有类型的，有类型的只是其中的数据。

2 None

Python中有一个特殊的值，就是None，None表示空，什么都没有。在其他语言中可能叫 null、nil等。

如果我们想创建一个变量，但是变量中存储什么类型的数据还不确定，可以在初始化的时候，赋值为None。

a = None
print(type(a))

打印结果：

<class ‘NoneType’>

None 是 NoneType 数据类型的唯一值，可以将 None 赋值给任何变量。

3 类型转换

数据类型转换就是不同的数据类型之间是可以进行转换的，例如在某些时候，我们需要将数字转换为字符串，或者字符串转换为数字。

为什么需要进行类型转换呢？

例如我们从文件读取的数字，默认是字符串类型的，我们读取以后需要转换为数字类型，例如将字符串"100"转换为数字100。

常用的转换函数有如下3个：

函数	说明
int(x)	将x转换为一个整数
float(x)	将x转换为一个浮点数
str(x)	将x转换为字符串

上面的函数会将转换完成的结果返回。

演示一下，将字符串转换为整数：

v_str = "10"          # 定义一个字符串类型的数据
print(type(v_str))    # 打印: <class 'str'>

v_int = int(v_str)    # 将字符串转换为整数
print(v_int)          # 打印: 10

print(type(v_str))    # 打印: <class 'str'>
print(type(v_int))    # 打印: <class 'int'>

有几点需要注意：

1. 任何类型都可以通过str()转换为字符串，但是如果将字符串转换为数字，字符串必须得是数字格式。

v_str = "123a"
v_int = int(v_str)    # 报错，不是整数，转化失败

v_str = "12.13"
v_int = int(v_str)    # 报错，不是整数，转化失败

2. 浮点数转换为整数会丢失精度

v_float = 12.13
v_int = int(v_float)  # 将浮点数转换为整数
print(v_int)          # 打印: 12, 小数部分丢失

2.5 标识符

什么是标识符？

标识符就是名字，例如变量的名字、方法的名字、类的名字。

起名字肯定会有限制，肯定不能 张Three 这样起名字，所以标识符也有限制。

1 标识符命名规则

标识符需要遵守一下规则：

1. 只能是英文、数字、下划线_、中文（可以是中文，但是强烈建议不要使用），其他任何内容都不允许；
2. 不能使用数字开头，可以英文或下划线开头；

a					# 可以
a_b				# 可以
_a				# 可以
a1				# 可以
a_b_a			# 可以

1					# 错误
1_				# 错误
1_a				# 错误

3. 大小写敏感，大小写不同是不同的标识符；

name = "zhangsan"   
Name = "lisi"				# 和 name 是不同的标识符

4. 不能使用关键字，关键字就是Python中保留的一些单词，有特殊的用途，不能被用作标识符；

Python 有如下关键字：

这么多怎么记？不用记！不用记！不用记！

后面每个关键字都会学到，自然知道每个关键字是做什么用的，不用记！

2 变量命名规范

使用上面说的规则，我们可以定义变量名了。

但是为了优雅、统一、规范，我们在定义变量名时，还应该遵守以下规范，虽然你不遵守，没人开枪打死你，但是建议你遵守。

1. 见名知意

看见一个变量名，就知道这个变量名是干嘛的。

a = "zhangsan"								# 看到a，鬼知道a是干嘛的
name = "zhangsan"							# 看到name，就知道这是个名字，简单明了
a_person_name = "zhangsan"		# 在确保明了的前提下，尽量减少长度，这个有点不够简洁

2. 多个单词使用下划线分隔

first_name = "Jim"
student_nickname = "胖墩"

3. 变量中的英文应全部小写

Name = "zhangsan"			# 不推荐
name = "zhangsan"			# 推荐

2.6 运算符

下面介绍Python中常见的运算符：算数运算符、赋值运算符。

1 算数运算符

算数运算符是干嘛的？

就是进行数学运算的，就是小学学的加、减、乘、除等。

Python中常见的算数运算符如下：

运算符	描述	举例
+	加	返回两个数相加的结果，例如： 10 + 20 = 30
-	减	返回两个数相减的结果，例如 ：10 - 20 = -10
*	乘	返回两个数相乘的结果，例如： 10 * 20 = 200
/	除	返回两个数相除的结果，例如： 10 / 20 = 0.5
//	整除	返回两个数相除，商的整数部分，例如：9 // 2 = 4
%	取余	返回除法运算的余数，例如：9 % 7 = 2
**	指数	返回指数运算结果，例如：2 ** 3 = 8

举例子：

print("10 + 20 =", (10 + 20))				# 10 + 20 = 30
print("10 - 20 =", (10 - 20))				# 10 - 20 = -10
print("10 * 20 =", (10 * 20))				# 10 * 20 = 200
print("10 / 20 =", (10 / 20))				# 10 / 20 = 0.5
print("9 // 2 =", (9 // 2))					# 9 // 2 = 4
print("9 % 7 =", (9 % 7))						# 9 % 7 = 2
print("2的3次方 =", (2 ** 3))				# 2的3次方 = 8

2 赋值运算符

赋值运算符就是用来给变量赋值的。

赋值运算符

运算符	描述	举例
=	赋值运算符	就是把 = 右边的值赋值给左边的变量，之前用过了。

例如：

num = 1 + 2
num = a + b

除了赋值运算符，下面还有复合赋值运算符。

复合赋值运算符

复合赋值运算符就是经过计算后，将值赋给前面的变量。

运算符	描述	举例
+=	加法赋值运算符	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. 更加简练；
2. 效率更高。

2.7 字符串扩展

1 字符串定义方式

在上面我们使用双引号 " 来定义字符串，但其实字符串有3种不同的定义方式：

方式一：双引号定义法

text1 = "我是一个字符串"

方式二：单引号定义法

text2 = '我是一个字符串'

方式三：三引号定义法

三引号除了可以用来表示多行注释，如果将三个引号的内容赋值给一个变量，还可以用来定义字符串，还可以换行：

text3 = """我是一个字符串，
我还可以换行"""

2 转义字符

如果我们的字符串中包含引号，该怎么处理呢？

如果字符串中包含单引号，可以使用双引号定义法：

str = "Hello 'Python'"

如果字符串中包含双引号，可以使用单引号定义法：

str = 'Hello "Python"'

还有一个通用的方法，就是使用转义符 \ ，在引号前面加上 \ 表示后面的字符是普通字符串：

str = "Hello \"Python\""
str = "Hello \'Python\'"

同样，如果你想在字符串中输出 \t ，你可能会这样写：

str = "Hello \t \"Python\""
print(str)

但运行完成结果却没有 \t ，因为 \t 是制表符，同样 \n 是换行符，如果想在字符串中输出 \t 或 \n 等特殊字符，也是需要对 斜杠 \ 进行转义：

str = "Hello \\t \"Python\""
print(str)

3 字符串拼接

使用加号拼接

两个字符串拼接，直接使用 加号+ 拼接即可，例如：

print("Hello " + "World")			# 输出：Hello World

但是上面的拼接纯属脱裤子放屁，直接写成 print(“Hello World”) 就完了，所以一般字符串拼接都是在字面量和变量、变量和变量之间拼接：

name = "张三"
print("Hello, 我是" + name + ", 法外狂徒就是我")		# 输出：Hello, 我是张三, 法外狂徒就是我

拼接其他类型

使用 加号+ 能否拼接 **数字 **或 bool 类型呢？

age = 2023
print("Hello, 我是法外狂徒，我生于:" + age)

运行报错：

那该如何拼接非字符串类型呢？

需要将其他非字符串类型的数据转换为字符串，如下：

age = 2023
is_adult = True
print("Hello, 我是法外狂徒，我生于:" + str(age) + ", 是否成年:" + str(is_adult))

4 字符串格式化

占位符

在上面进行字符串拼接的时候，会发现如果要拼接的变量太多，会很麻烦，而且非字符串变量还需要手动转换为字符串，有没有更好的方式呢？

那就是字符串格式化。

举个栗子：

name = "张三"
print("Hello, 我是%s, 法外狂徒就是我" % name)		# 输出：Hello, 我是张三, 法外狂徒就是我

上面的 %s 表示占位符，**% **表示我要占位，s 表示将变量转换为字符串放到这里。

多个变量呢？

使用 括号() ，将多个变量括起来：

name = "张三"
age = 18
print("Hello, 我是%s, 年龄%s" % (name, age))

数据类型占位

上面的 %s 表示将数据转换为字符串拼接，数字也被转换为字符串后进行拼接。

我数字凭什么要转换为字符串后拼接，就不能直接拼接吗，这显得很不体面，既然不体面，我们就帮它体面。

除了 %s 占位符，还有两个常用的占位符：

格式符号	说明
%s	将内容转换成字符串，放入占位位置
%d	将内容转换成整数，放入占位位置
%f	将内容转换成浮点型，放入占位位置

举个栗子：

name = "张三"
age = 18
money = 3.14
print("Hello, 我是%s, 年龄%d, 我有%f块钱" % (name, age, money))

输出如下：

Hello, 我是张三, 年龄18, 我有3.140000块钱

这个小数点后面是什么鬼，如何控制数字精度呢？

精度控制

我们可以在 占位符 % 后面 使用辅助符号"m.n"来控制数据的宽度和精度：

m：控制宽度（很少使用），要求是数字，设置的宽度小于数字自身，不生效；

.n，控制小数点精度，要求是数字，会进行小数的四舍五入。

有点抽象，举个栗子：

name = "张三"
age = 18
money = 3.14
print("Hello, 我是%s, 年龄%5d, 我有%5.2f块钱" % (name, age, money))

输出如下：

Hello, 我是张三, 年龄 18, 我有 3.14块钱

%5d表示：age最少占用 5 个字符的位置，18已经占用了 2 个字符，那么需要再前面加 3 个空格，最后的d表示已整数的形式输出。

%5.2f表示：money最少占用 5 个字符的位置，.2 表示保留小数点 2 位，那么小数点前只能占用3位了，当然前面数字大于3位，那么小数点前的限制就不生效了。

一般常用的方式是只限制小数点后的位数：

%.2f：表示不限制宽度，只设置小数点精度为2。

例如：

money = 3.1415
print("我有%.2f块钱" % money)

输出：

我有3.14块钱

5 快速格式化

目前通过%符号占位已经很方便了，还能进行精度控制，但是Python还有更方便的写法。

语法格式：

f"内容{变量}"

通过在字符串前面添加一个 f ，可以在字符串中使用 {} 嵌入变量。

举个栗子：

name = "张三"
age = 18
money = 3.14
print(f"Hello, 我是{name}, 年龄{age}, 我有{money}块钱")

输出：

Hello, 我是张三, 年龄18, 我有3.14块钱

可以看到，这种写法没有精度控制，不理会数据类型，都是原样输出。

2.8 数据输入

前面都时候使用print函数在控制台打印数据，Python还提供了一个函数input，用于读取键盘输入的数据。

1 input()

input函数使用也很简单，直接举栗子：

print("请输入姓名：")
name = input();
print("你的名字是：" + name)

上面的代码input()会读取键盘输入的内容，赋值给name变量。

运行代码后，代码执行到input函数时，会阻塞，等待你在控制台输入，当你输入完成后，回车。代码会继续执行，打印你输入的姓名。

例如我输入zhangsan，执行结果：

请输入姓名：
zhangsan
你的名字是：zhangsan

上面的代码，第一句是多余的，上面的代码还可以写成：

name = input("请输入姓名：");
print("你的名字是：" + name)

2 数据输入的类型

上面从键盘读取的数据的类型都是字符串类型的。

所以如果要获取整数或浮点数类型，需要在获取数据后，对数据进行转换。

age = input("请输入年龄：");
age = int(age)

money = input("请输入余额：")
money = float(money)

print(f"你的年龄是：{age}，余额：{money}")