本文的Python解释器版本： Python 3.10.6 (64-bit)
本文的Python开发工具： PyCharm
本文使用的PyCharm快捷键:

• 运行  Ctrl+Shift+F10

Python基础语法

• 一、字面量
• 二、注释
• 三、变量
• • 1、动态类型特性
  • 2、强制类型转换
  • 3、变量的命名规则
• 四、输入与输出
• 五、字符串的扩展
• • 1、字符串的定义方式
  • 2、字符串的拼接
  • 3、字符串的格式化
  • 4、格式化的精度控制
• 六、运算符
• • 1、算术运算符
  • 2、关系运算符
  • 3、逻辑运算符
  • 4、赋值运算符
• 七、一些补充
• • 1、关于前后置++ 或- –
  • 2、关于Python语句结束后要不要加；

一、字面量

字面量:在代码中，被写下来的的固定的值，称之为字面量
下面我们来看一看Python中有那些值呢？

对于我们初学者，我们现在只学习数字与字符串，后面复杂的类型，我们以后再进行学习。

1. 对于数字类型（number），我们只要学习过任何一种编程语言都会对它很熟悉，和C语言不一样的是Python支持复数
   （C99的C语言也开始支持了布尔类型，C99提供了<stdbool.h>头文件，该文件让bool成为_Bool的别名，同时宏定义了true和false，分别是1和0的字面量）
   

2. 字符串(string)，又称文本，是由任意数量的字符如中文、英文、各类符号、数字等组成。所以叫做字符串。
   如：
   ‘Python是最好的编程语言’
   “@#$%^&*”
   “123456789”
   Python中，字符串需要用单引号(‘)双引号(“)包围起来被引号包围起来的数据都是字符串

下面我们来演示一下学习的这些类型，如何在代码中表达？

print()函数，打印内容到屏幕上（与C语言的printf()功能相似，但是使用起来更加方便简洁）

# 【字面量】

# 单引号与双引号括起来的字符都是字符串
'Python语言'
"Python编程"

# 整形
666
# 浮点数
13.14
# 复数
2 + 3j
# 布尔
True


# 打印数字
print(666)
print(13.14)
print("Python编程")
print(2 + 3j)
print(True)

print(1j + 2 + 3j)
print(1 + 3 / 2)

这里需要注意的是在Python 中,3 / 2 = 1.5 而不是1，在C/C++/Java里面整数除以整数最后的结果还是整数。

二、注释

定义: 在程序代码中对程序代码进行解释说明的文字。
作用: 注释不是程序，不能被执行，只是对程序代码进行解释说明，让别人可以看懂程序代码的作用，能够大大增强程序的可读性。
位置: 注释的一般位置都是代码的上边或者右边。

注释的分类

• 单行注释:以#开头，#右边的所有文字当作说明，而不是真正要执行的程序，起辅助说明作用。
  
  注意：#号和注释内容一般建议以一个空格隔开，这样写更看起来更加简洁易懂，不是强制要求！

• 多行注释:以一对三个双引号引起来”“” “””说明一段代码的作用使用方法,多行注释一般对: Python文件、类或方法进行解释

• 单行注释中能使用多行注释,但是会被会被一起注释。
• 多行注释中能使用单行注释也会被会被一起注释。
• 多行注释中不能使用多行注释
  

三、变量

Python支持的数字类型的变量有：int float bool complex 对于字符串有string类型。

1. 不同于C语言的是 Python 中的int类型的变量可以存储的数据理论上是无穷大的，如果数据很大就会自动扩容。
   
   占用字节：通常为4个字节或8个字节，具体大小取决于计算机架构和Python版本。
2. Python里面的浮点数float相当于C语言里面的double类型，是双精度类型的浮点数。
   
   占用字节：通常为8个字节，但在某些系统中可能为4个字节。
3. Python里面的string与C++的string类似，Python里面求字符串长度的函数是len()函数
4. Python里面的bool类型的变量对应的真假判断的逻辑值是True和False与C/C++/Java里面的true false形式不同。
   
   占用大小：占用1个字节

和 C++ / Java 等语言不同, Python 变量的类型不需要显式指定, 而是在赋值的时候确定的，通过type()函数可以查看一个变量的类型。

另外Python中定义变量是不需要加类型的，当然也可以在变量的后面加上类型提示 : 类型，类型提示仅仅起到提示作用，不影响代码的任何逻辑。

a = 2
b: float = 3.14
c: str = "Python"
d = 2 + 3j

print(type(a))
print(type(b))
print(type(c))
print(type(d))

1、动态类型特性

在 Python 中, 一个变量是什么类型, 是可以在 “程序运行” 过程中发生变化的. 这个特性称为 “动态类型” 。

a = 2
print(type(a))
a = "hello"
print(type(a))

在程序执行过程中, a 的类型刚开始是 int, 后面变成了 str。

C++/Java 这样的语言则不允许这样的操作. 一个变量定义后类型就是固定的了. 这种特性则称为 “静态类型”。

动态类型特性是一把双刃剑：

• 对于中小型程序, 可以大大的解约代码量(比如写一段代码就可以同时支持多种类型)。
  

• 对于大型程序，则提高了模块之间的交互成本. (程序猿 A 提供的代码难以被 B 理解)。

2、强制类型转换

有些时候我们需要的数据类型与我们实际要使用的数据类型不一致，这时我们就要进行强制类型转换以满足我们的要求。

var_str = str(2)
print(type(var_str))
print(var_str)

var_str = float(3.14)
print(type(var_str))
print(var_str)

var_float = float(2)
print(type(var_float))
print(var_float)

var_float = float("12")
print(type(var_float))
print(var_float)

var_int = int("12")
print(type(var_int))
print(var_int)

类型转换不是万能的

1. 任何类型，都可以通过str()，转换成字符串
2. 字符串内必须真的是数字，才可以将字符串转换为数字
3. 浮点数转整数会丢失精度，也就是小数部分。

var_int = int("a")        # 字符串中全部是整数数字才能转化为 int  类型的数据
var_int = int("12.13")    # 字符串中全部是浮点数才能转化为 float 类型的数据

3、变量的命名规则

与C/C++变量命名规则一致，标识符命名中，允许出现：英文，中文，数字，下划线，但是不能以数字开头，也不能与关键字冲突。

注意Python里面可以使用中文作为变量名，但是不建议使用。

变量 = 10
print(变量)

Python中的关键字：

四、输入与输出

Python 使用 print函数输出到控制台。

print('hello')

Python 使用 input() 函数, 从控制台读取用户的输入。

Python从文件中读取的数据，默认是字符串，从input()语句读取的内容，默认结果也是字符串，如果需要数字就需要强制类型转换。

a = input('请输入第一个整数：')
b = input('强输入第二个整数：')

print(a)
print(type(a))
print(b)
print(type(b))

• input 的参数相当于一个 “提示信息”, 也可以没有.
• input 的返回值就是用户输入的内容. 是字符串类型.

五、字符串的扩展

1、字符串的定义方式

字符串在Python中有多种定义形式:

1. 单引号定义法: name = ‘hello world'
2. 双引号定义法: name = "hello world"
3. 三引号定义法: name = """hello world"""

三引号定义法，和多行注释的写法一样，使用变量接收它，它就是字符串
不使用变量接收它，就可以作为多行注释使用。

字符串的引号嵌套问题：
如果我们想要定义的字符串本身是包含:单引号、双引号自身，我们应该如何解决?

一般来说有三种解决办法：

1. 单引号定义法，可以内含双引号。
2. 双引号定义法，可以内含单引号
3. 可以使用转移字符(\）来将引号解除效用，变成普通字符串

name1 = '"这里包含了双引号"'
print(name1)
name2 = "'这里包含了单引号'"
print(name2)
name3 = "这里使用了转义字符\'\"号"
print(name3)

2、字符串的拼接

在Python中，字符串与字符串之间可以通过+来完成拼接，但是字符串变量无法与非字符串变量进行拼接，因为类型不一致。

name1 = 'hello'
name2 = "world"
print(name1+name2+"!")

3、字符串的格式化

a、利用占位符进行格式化：
和C语言一样，Python的字符串格式化，也可以使用占位符的方式进行格式化。

%占位符

多个变量占位，变量要用括号括起来并按照占位的顺序填入

year: int = 99
Type: str = "bool"
description = "C语言在C%d后才支持%s类型" % (year, Type)
print(description)

在格式化的过程中，数字类型要被转成字符串后然后进行拼接。

b、快速格式化：

Python支持通过语法:f"内容{变量}"的格式来快速格式化，这种写法不做精度控制也不理会类型，适用于快速格式化字符串

year = 99
type1 = "bool"
# f是format 格式化
print(f"C语言直到C{year},才支持{type1}类型")  

c、格式化表达式：

在无需使用变量进行数据存储的时候，可以直接格式化表达式，简化代码。

print("2*4计算结果:%d" % (2 * 4))
print(f"3*4计算结果:{3 * 4}")
print("计算结果类型:%s" % type(3 * 4))

4、格式化的精度控制

在一些特殊场景下面，我们要对数据的精度进行处理，这时就要用到精度处理了，Python的精度处理与C语言是一样的。

Python可以使用辅助符号m.n来控制数据的宽度和精度

• m，控制宽度，要求的是数字，设置的宽度小于数字自身不生效。
• n，控制小数点精度，要求是数字，会进行小数的四舍五入。(这一点与C语言不同)

num1 = 11
num2 = 11.245
print(num1)
print(num2)
print("数字是11，宽度是5：%5d" % num1)
print("数字是11,245，宽度是7,精度是2：%7.2f" % num2)
print("数字是11,245，宽度是7,精度是3：%7.3f" % num2)

六、运算符

1、算术运算符

注意：
**是求乘方. 不光能算整数次方, 还能算小数次方

# 【运算符】
a = 3 + 2
b = 5 - 2
c = 2.5 * 2
d = 10 / 2
e = 10 // 3
f = 10 % 3
g = 2 ** 2

print(a)
print(b)
print(c)
print(d)
print(e)
print(f)
print(g)

# 【赋值运算符与复合运算符】
num = 1
num += 1
print(num)
num -= 1
print(num)
num *= 2
print(num)
num /= 2
print(num)
num **= 2
print(num)
print("----------------------------------------")
num = 10
num //= 3
print(num)
print("----------------------------------------")
num = 10
num %= 3
print(num)
print("----------------------------------------")

2、关系运算符

像 < <= > >= == != 这一系列的运算符称为 关系运算符, 它们是在比较操作数之间的关系。

• 如果关系符合, 则表达式返回 True. 如果关系不符合, 则表达式返回 False

a: int = 10
b: int = 20

print(a > b)
print(a >= b)
print(a < b)
print(a <= b)
print(a == b)
print(a != b)

• 关系运算符不光针对整数/浮点数进行比较, 还能针对字符串进行比较.(对字符串的比较采用的是，按照ASCII码进行比较)

a: str = "hello"
b: str = "world"


print(a > b)
print(a >= b)
print(a < b)
print(a <= b)
print(a == b)
print(a != b)

1. Python可以直接使用 == 或者 != 即可对字符串内容判定相等. (这一点和 C / Java 不同).

2. 对于浮点数来说, 不要使用 == 判定相等，浮点数在计算机中的表示并不是精确的! 在计算过程中, 就容易出现非常小的误差

print(0.1 + 0.2)
print(0.1 + 0.2 == 0.3)

浮点数正确的比较方式: 不再严格比较相等了, 而是判定差值小于允许的误差范围.

a: float = 0.1
b: float = 0.2
print(-0.00000001 < a + b - 0.3 < 0.00000001)

Python中支持 < x + y < 这种连续判断，C/C++/Java中是不支持的。

3、逻辑运算符

像 and or not 这一系列的运算符称为 逻辑运算符。

• and 并且. 两侧操作数均为 True, 最终结果为 True. 否则为 False. (一假则假)
• or 或者. 两侧操作数均为 False, 最终结果为 False. 否则为 True. (一真则真)
• not 逻辑取反. 操作数本身为 True, 则返回 False. 本身为 False, 则返回 True.

a: int = 10
b: int = 20
c: int = 30
print(a < b and b < c)
print(a < b or b < c)
print(not a > b)

关于短路求值

和其他编程语言类似, Python 也存在短路求值的规则.

• 对于 and, 如果左侧表达式为 False, 则整体一定为 False, 右侧表达式不再执行.
• 对于 or, 如果左侧表达式为 True, 则整体一定为 True, 右侧表达式不再执行.

print(10 > 20 and 10 / 0 == 1)
print(10 < 20 or 10 / 0 == 1)

4、赋值运算符

赋值运算符，表示赋值. 这个我们已经用过很多次了，不在进行介绍，我们来看看两种特殊情况的赋值。

• 链式赋值

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

一般不建议使用链式赋值，尽量一行代码就只是包含一个操作!

• 多元赋值

a, b = 10, 20
print(a)
print(b)

多元赋值还是有一定的意义的，能帮我们解决一些特殊问题，比如完成两个变量的交换。

a, b = 10, 20
print(a, b)

# 交换a, b的值
a, b = b, a
print(a, b)

七、一些补充

1、关于前后置++ 或- –

Python 中不支持++ --这样的自增自减操作的！

++a之所以没有语法报错,是 Python解释器把++当成了两个正号，--a也是不会报错,把--当成了两个负号，负负得正,最终的值仍然不变。

但是后置++和后置--都是语法上报错的!

2、关于Python语句结束后要不要加；

在Python中，一个语句写完了之后，可以加上分号,也可以不加。通常情况下都是不加的.如果加了，也不算错。

如果把多个语句写到同一行了，这个时候语句之间,务必要加上分号的.(这种写在一行的写法并不推荐)