python 学习速查笔记（3）

本章涉及数据类型转换，解释器，运算符，很快就可以结束

Python3 解释器

如果你是Linux
Linux/Unix的系统上，一般默认的 python 版本为 2.x，我们可以将 python3.x 安装在 /usr/local/python3 目录中。

安装完成后，我们可以将路径 /usr/local/python3/bin 添加到您的 Linux/Unix 操作系统的环境变量中，这样您就可以通过 shell 终端输入下面的命令来启动 Python3 。

1
2
3
$ PATH=$PATH:/usr/local/python3/bin/python3    # 设置环境变量
$ python3 --version
Python 3.4.0

如果你是window

在Window系统下你可以通过以下命令来设置Python的环境变量，假设你的Python安装在 C:\Python34 下:

1
set path=%path%;C:\python34

交互式编程

我们可以在命令提示符中输入”Python”命令来启动Python解释器：

1
$ python3

执行以上命令后，出现如下窗口信息：

$ python3
Python 3.4.0 (default, Apr 11 2014, 13:05:11)
[GCC 4.8.2] on linux
Type “help”, “copyright”, “credits” or “license” for more information.

在 python 提示符中输入以下语句，然后按回车键查看运行效果：

1
print ("Hello, Python!");

以上命令执行结果如下：

Hello, Python!

当键入一个多行结构时，续行是必须的。我们可以看下如下 if 语句：

1
2
3
4
5
>>> flag = True
>>> if flag :
...     print("flag 条件为 True!")
... 
flag 条件为 True!

脚本式编程

将如下代码拷贝至 hello.py文件中：

1
print ("Hello, Python!");

通过以下命令执行该脚本：

1
python3 hello.py

输出结果为：

Hello, Python!

在Linux/Unix系统中，你可以在脚本顶部添加以下命令让Python脚本可以像SHELL脚本一样可直接执行：

1
#! /usr/bin/env python3

然后修改脚本权限，使其有执行权限，命令如下：

1
$ chmod +x hello.py

执行以下命令：

1
./hello.py

输出结果为：

Hello, Python!

Python 运算符详解（库存）

以下是 Python 中支持的各类运算符及其功能、实例和注意事项的详细说明。

1. 运算符总览表

运算符类别 运算符示例 功能描述
算术运算符 +, -, *, / 等 基本数学运算
比较运算符 ==, !=, >, < 等 比较两个值的关系
赋值运算符 =, +=, -= 等 给变量赋值
逻辑运算符 and, or, not 布尔逻辑运算
位运算符 &, ` , ^, ~` 等
成员运算符 in, not in 检查元素是否在序列中
身份运算符 is, is not 比较对象的内存地址
运算符优先级 多种运算符组合 决定运算顺序的规则

2. 详细说明与实例

2.1 算术运算符

运算符 描述 实例 结果
+ 加法 3 + 2 5
- 减法 5 - 2 3
* 乘法 3 * 4 12
/ 除法 10 / 2 5.0
% 取模 10 % 3 1
** 幂运算 2 ** 3 8
// 整除 10 // 3 3

注意事项：

  • 除法(/)总是返回浮点数
  • 整除(//)向下取整
  • 幂运算(**)优先级高于其他算术运算符
    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
    12
    13
    14
    15
    16
    17
    18
    19
    #!/usr/bin/python3
    a = 21
    b = 10
    c = 0
    c = a + b
    print ("1 - c 的值为：", c)
    c += a
    print ("2 - c 的值为：", c)
    c *= a
    print ("3 - c 的值为：", c)
    c /= a 
    print ("4 - c 的值为：", c)
    c = 2
    c %= a
    print ("5 - c 的值为：", c)
    c **= a
    print ("6 - c 的值为：", c)
    c //= a
    print ("7 - c 的值为：", c)

2.2 比较运算符

运算符 描述 实例 结果
== 等于 3 == 2 False
!= 不等于 3 != 2 True
> 大于 3 > 2 True
< 小于 3 < 2 False
>= 大于等于 3 >= 3 True
<= 小于等于 3 <= 2 False

注意事项：

  • 可以链式比较：1 < 2 < 3 等价于 1 < 2 and 2 < 3
  • 比较字符串时按字典序

2.3 赋值运算符

运算符 描述 实例 等价于
= 赋值 x = 5 -
+= 加后赋值 x += 3 x = x + 3
-= 减后赋值 x -= 2 x = x - 2
*= 乘后赋值 x *= 4 x = x * 4
/= 除后赋值 x /= 2 x = x / 2
%= 取模赋值 x %= 3 x = x % 3
**= 幂赋值 x **= 2 x = x ** 2
//= 整除赋值 x //= 2 x = x // 2

注意事项：

  • 增强赋值运算符更高效
  • 可变对象的增强赋值可能就地修改对象

2.4 逻辑运算符

运算符 描述 实例 结果
and 逻辑与 True and False False
or 逻辑或 True or False True
not 逻辑非 not True False

注意事项：

  • 短路特性：and和or会提前终止计算
  • 返回最后一个求值的操作数，不一定是布尔值

2.5 位运算符

按位运算符是把数字看作二进制来进行计算的。Python中的按位运算法则如下：

运算符 描述 实例 结果
& 按位与 5 & 3 1
` ` 按位或 `5
^ 按位异或 5 ^ 3 6
~ 按位取反 ~5 -6
<< 左移 5 << 1 10
>> 右移 5 >> 1 2

这里可能会显示错误，按位或运算符为“|”

&按位与运算符：参与运算的两个值,如果两个相应位都为1,则该位的结果为1,否则为0 (a & b) 输出结果 12 ，二进制解释： 0000 1100
|按位或运算符：只要对应的二个二进位有一个为1时，结果位就为1。 (a | b) 输出结果 61 ，二进制解释： 0011 1101
^按位异或运算符：当两对应的二进位相异时，结果为1 (a ^ b) 输出结果 49 ，二进制解释： 0011 0001
~按位取反运算符：对数据的每个二进制位取反,即把1变为0,把0变为1。x 类似于 -x-1 (a ) 输出结果 -61 ，二进制解释： 1100 0011， 在一个有符号二进制数的补码形式。
<<左移动运算符：运算数的各二进位全部左移若干位，由”<<”右边的数指定移动的位数，高位丢弃，低位补0。 a << 2 输出结果 240 ，二进制解释： 1111 0000
>>右移动运算符：把”>>”左边的运算数的各二进位全部右移若干位，”>>”右边的数指定移动的位数 a >> 2 输出结果 15 ，二进制解释： 0000 1111

注意事项：

  • 操作数会被转换为二进制形式
  • 负数以补码形式表示

2.6 成员运算符

除了以上的一些运算符之外，Python还支持成员运算符，测试实例中包含了一系列的成员，包括字符串，列表或元组。

运算符 描述 实例 结果
in 在序列中 'a' in ['a', 'b'] True
not in 不在序列中 'c' not in 'abc' False

in如果在指定的序列中找到值返回 True，否则返回 False。x 在 y 序列中 , 如果 x 在 y 序列中返回 True。
not in如果在指定的序列中没有找到值返回 True，否则返回 False。x 不在 y 序列中 , 如果 x 不在 y 序列中返回 True。

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
#!/usr/bin/python3
 
a = 10
b = 20
list = [1, 2, 3, 4, 5 ]
 
if ( a in list ):
   print ("1 - 变量 a 在给定的列表中 list 中")
else:
   print ("1 - 变量 a 不在给定的列表中 list 中")
 
if ( b not in list ):
   print ("2 - 变量 b 不在给定的列表中 list 中")
else:
   print ("2 - 变量 b 在给定的列表中 list 中")
 
# 修改变量 a 的值
a = 2
if ( a in list ):
   print ("3 - 变量 a 在给定的列表中 list 中")
else:
   print ("3 - 变量 a 不在给定的列表中 list 中")

注意事项：

  • 适用于字符串、列表、元组、字典(检查键)等
  • 字典中只检查键，不检查值

2.7 身份运算符

身份运算符用于比较两个对象的存储单元

运算符 描述 实例 结果
is 是同一对象 a is b 取决于对象ID
is not 不是同一对象 a is not b 取决于对象ID

is is 是判断两个标识符是不是引用自一个对象 x is y, 类似 id(x) == id(y) , 如果引用的是同一个对象则返回 True，否则返回 False
is not is not 是判断两个标识符是不是引用自不同对象 x is not y ， 类似 id(x) != id(y)。如果引用的不是同一个对象则返回结果 True，否则返回 False。

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
#!/usr/bin/python3
 
a = 20
b = 20
 
if ( a is b ):
   print ("1 - a 和 b 有相同的标识")
else:
   print ("1 - a 和 b 没有相同的标识")
 
if ( id(a) == id(b) ):
   print ("2 - a 和 b 有相同的标识")
else:
   print ("2 - a 和 b 没有相同的标识")
 
# 修改变量 b 的值
b = 30
if ( a is b ):
   print ("3 - a 和 b 有相同的标识")
else:
   print ("3 - a 和 b 没有相同的标识")
 
if ( a is not b ):
   print ("4 - a 和 b 没有相同的标识")
else:
   print ("4 - a 和 b 有相同的标识")#!/usr/bin/python3
 
a = 20
b = 20
 
if ( a is b ):
   print ("1 - a 和 b 有相同的标识")
else:
   print ("1 - a 和 b 没有相同的标识")
 
if ( id(a) == id(b) ):
   print ("2 - a 和 b 有相同的标识")
else:
   print ("2 - a 和 b 没有相同的标识")
 
# 修改变量 b 的值
b = 30
if ( a is b ):
   print ("3 - a 和 b 有相同的标识")
else:
   print ("3 - a 和 b 没有相同的标识")
 
if ( a is not b ):
   print ("4 - a 和 b 没有相同的标识")
else:
   print ("4 - a 和 b 有相同的标识")

实例输出结果为：

1 - a 和 b 有相同的标识
2 - a 和 b 有相同的标识
3 - a 和 b 没有相同的标识
4 - a 和 b 没有相同的标识

is 用于判断两个变量引用对象是否为同一个， == 用于判断引用变量的值是否相等。

注意事项：

  • 比较的是对象的内存地址
  • 小整数和短字符串会被Python缓存

2.8 运算符优先级

优先级 运算符
1 () (括号)
2 ** (幂)
3 +x, -x, ~x (一元运算符)
4 *, /, //, %
5 +, -
6 <<, >>
7 &
8 ^
9 `
10 ==, !=, >, <, >=, <=
11 is, is not, in, not in
12 not
13 and
14 or

注意事项：

  • 使用括号可以明确优先级
  • 同级别运算符从左到右计算(幂运算除外)

3. 综合实例

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
# 算术运算符
print(2 + 3 * 4)  # 输出: 14 (先乘后加)
print((2 + 3) * 4)  # 输出: 20 (括号优先)

# 比较和逻辑运算符
a = 5
print(3 < a < 7)  # 输出: True (链式比较)
print(a == 5 and not a < 4)  # 输出: True

# 位运算符
x = 10  # 1010
y = 4   # 0100
print(x & y)  # 输出: 0 (0000)
print(x | y)  # 输出: 14 (1110)

# 成员和身份运算符
lst = [1, 2, 3]
print(2 in lst)  # 输出: True
a = [1, 2]
b = a
print(a is b)  # 输出: True
print(a == [1, 2])  # 输出: True
print(a is [1, 2])  # 输出: False

4. 重要注意事项

  1. 不可变对象与可变对象：

    • 对于不可变对象(数字、字符串、元组)，运算符通常会创建新对象
    • 对于可变对象(列表、字典)，某些运算符(如+=)可能就地修改对象

  2. 浮点数精度问题：

    1
    2
    print(0.1 + 0.2 == 0.3)  # 输出: False
    print(round(0.1 + 0.2, 1) == 0.3)  # 正确比较方式

  3. 短路特性：

    1
    2
    3
    4
    5
    6
    def func():
        print("函数被调用")
        return True

    False and func()  # func()不会被调用
    True or func()    # func()不会被调用

  4. is与==的区别：

    • is比较对象标识(内存地址)
    • ==比较对象值

  5. 增强赋值的陷阱：

    1
    2
    3
    4
    lst = [1, 2]
    lst2 = lst
    lst += [3]  # 会修改lst和lst2
    lst = lst + [4]  # 创建新列表，不影响lst2

Python 运算符输出数据类型表

以下是 Python 中各类运算符运算结果的数据类型规则说明：

1. 算术运算符结果类型

运算符 操作数类型组合 结果类型 示例
+ int + int int 3 + 2 → 5 (int)
+ int + float float 3 + 2.0 → 5.0 (float)
+ float + float float 3.0 + 2.0 → 5.0
- 同上规则 同上规则 5 - 2.0 → 3.0
* 同上规则 同上规则 3 * 2.0 → 6.0
/ 任何数字组合 float 10 / 2 → 5.0
// int // int int 10 // 3 → 3
// 含float的操作数 float 10.0 // 3 → 3.0
% 同除法规则 同除法规则 10 % 3 → 1 (int)
** 同乘法规则 同乘法规则 2 ** 3 → 8 (int)

注意：字符串乘法(str * int)返回字符串

2. 比较运算符结果类型

运算符 结果类型 说明
== bool 所有比较运算都返回布尔值
!= bool
> bool
< bool
>= bool
<= bool

3. 赋值运算符结果类型

运算符 结果类型 说明
= 右侧表达式类型 返回赋值的值
+= 同算术运算规则 可能就地修改可变对象
其他复合赋值 同算术运算规则

4. 逻辑运算符结果类型

运算符 操作数类型 结果类型 说明
and 任意 最后一个求值的操作数 短路求值
or 任意 最后一个求值的操作数 短路求值
not 任意 bool 总是返回布尔值

示例：

1
2
3
print(3 and 'hello')  # 'hello' (str)
print(0 or [])        # [] (list)
print(not 5)          # False (bool)

5. 位运算符结果类型

运算符 结果类型 说明
& int 操作数会被转换为整数
` ` int
^ int
~ int
<< int
>> int

6. 成员运算符结果类型

运算符 结果类型 说明
in bool 总是返回布尔值
not in bool

7. 身份运算符结果类型

运算符 结果类型 说明
is bool 比较对象标识
is not bool

8. 特殊运算类型规则

运算 结果类型规则 示例
字符串拼接(+) str 'a' + 'b' → 'ab'
列表拼接(+) list [1] + [2] → [1, 2]
序列重复(*) 与左操作数相同 'a'*3 → 'aaa'
字典合并(` `) dict (Python 3.9+)

类型转换规则总结

  1. 算术运算：

    • 只要有float参与，结果就是float
    • 除法(/)总是返回float
    • 整数运算可能自动转换为长整数(超出普通int范围时)

  2. 混合类型运算：

    1
    2
    3
    print(type(3 + 4.0))     # <class 'float'>
    print(type(True + 2))    # <class 'int'> (True=1)
    print(type(False * 3.5)) # <class 'float'> (False=0)

  3. 布尔上下文：

    • 在需要布尔值的上下文中，非零数字、非空序列/映射等被视为True
    • 逻辑运算符可能返回非布尔值

重要提示：使用type()函数可以检查任何表达式的结果类型：

1
2
3
print(type(3 / 2))    # <class 'float'>
print(type(3 // 2))   # <class 'int'>
print(type('a' * 3))  # <class 'str'>

就到这里吧，得快点学习了