Python 入门核心概念：语法、运算符、函数及变量类型详解

Python 语句中一般以新行作为语句的结束符。但是我们可以使用斜杠 \ 将一行的语句分为多行显示，如下所示： total = item_one + \ item_two + \ item_three。语句中包含 []，{} 或 () 括号就不需要使用多行连接符。如下实例：days = ['Monday', 'Tuesday', 'Wednesday', 'Thursday', 'Friday']

2.5 Python引号

Python 可以使用引号 '、双引号 "、三引号 ''' 或 """ 来表示字符串，引号的开始与结束必须是相同类型的。其中三引号可以由多行组成，能写多行文本的快捷语法，常用于文档字符串，在文件的特定地点，被当做注释。word = 'word'，sentence = "这是一个句子。"，paragraph = """这是一个段落，包含了多个语句"""

2.6 Python注释

python 中单行注释采用 # 开头。python 中多行注释使用三个单引号 ''' 或三个双引号 """。

2.7 Python空行

函数之间或类的方法之间用空行分隔，表示一段新的代码的开始。类和函数入口之间也用一行空行分隔，以突出函数入口的开始。空行与代码缩进不同，空行并不是 Python 语法的一部分。书写时不插入空行，Python 解释器运行也不会出错。但是空行的作用在于分隔两段不同功能或含义的代码，便于日后代码的维护或重构。记住：空行也是程序代码()的一部分。

2.8 等待用户输入

下面的程序执行后就会等待用户输入，按回车键后就会退出：/usr/bin/python raw_input("\n\nPress the enter key to exit.") 以上代码中，"\n\n" 在结果输出前会输出两个新的空行。一旦用户按下 enter（回车）键退出，其他键显示。

2.9 同一行显示多条语句

Python 可以在同一行中使用多条语句，语句之间使用分号 ; 分割，以下是一个简单的实例：#!/usr/bin/python import sys; x = 'runoob'; sys.stdout.write(x + '\n')。执行以上代码，()输出结果为：$ python test.py runoob

2.10 Print输出

print 默认输出是换行的，如果要实现不换行需要在变量末尾加上逗号：

2.11 多个语句构成代码组

缩进相同的一组语句构成一个代码块，我们称之为代码组。像 if、while、def 和 class 这样的复合语句，首行以关键字开始，以冒号 : 结束，该行之后的一行或多行代码构成代码组。我们将首行及后面的代码组称为一个子句（clause）。如下实例：if expression: suite elif expression: suite else: suite

2.12 命令行参数

很多程序可以执行一些操作来查看一些基本信息，Python 可以使用 -h 参数查看各参数帮助信息：

2.13 env的用法

env 的用法是为了防止操作系统用户没有将 python 装在默认的 /usr/bin 路径里。当系统看到这一行的时候，首先会到 env 设置里查找 python 的安装路径，再调用对应路径下的解释器程序完成操作。/usr/bin/python 相当于写死了 python 路径()；/usr/bin/env python 会去环境设置寻找 python 目录，推荐这种写法。

三、Python 运算符

3.1 Python 算数运算符

Python 算术运算符用于执行基本的数学运算，例如加法、减法、乘法和除法。以下是对 Python 算术运算符的详细解释：

运算符	描述	示例	结果
+	加法	a + b	30
-	减法	a - b	-10
*	乘法	a * b	200
/	除法	b / a	2
%	取模（余数）	b % a	0
**	幂运算	a ** b	10 的 20 次方
//	取整除	9 // 2	4

示例解释：

加法 (+):
- 将两个操作数相加。
- 例如，a + b 的结果是 30，因为 10 + 20 = 30。
减法 (-):
- 将第二个操作数从第一个操作数中减去。
- 例如，a - b 的结果是 -10，因为 10 - 20 = -10。
乘法 (*):
- 将两个操作数相乘。
- 例如，a * b 的结果是 200，因为 10 * 20 = 200。
除法 (/):
- 将第一个操作数除以第二个操作数。
- 在python3中，除法的结果会是浮点数，即使两个整数恰好整除。
- 例如，b / a 的结果是 2，因为 20 / 10 = 2.0。
取模 (%):
- 返回除法的余数。
- 例如，b % a 的结果是 0，因为 20 除以 10 没有余数。
幂运算 ():**
- 返回第一个操作数的第二个操作数次幂。
- 例如，a ** b 的结果是 10 的 20 次方。
取整除 (//):
- 返回除法的整数部分（向下取整）。
- 例如，9 // 2 的结果是 4，因为 9 除以 2 的整数部分是 4。
- 9.0//2.0的结果也是4.0。

注意事项：

在 Python 中，除法运算符 / 始终返回一个浮点数。如果要执行整数除法，可以使用取整除运算符 //。
取模运算符 % 用于获取除法的余数，这在许多编程场景中都很有用。
幂运算符 ** 允许你轻松地计算一个数的幂。

3.2 Python 比较运算符

Python 比较运算符用于比较两个值，并返回一个布尔值（True 或 False），表示比较的结果。以下是 Python 比较运算符的详细解释：

运算符	描述	示例	结果
==	等于	a == b	FALSE
!=	不等于	a != b	TRUE
>	大于	a > b	FALSE
<	小于	a < b	TRUE
>=	大于等于	a >= b	FALSE
<=	小于等于	a <= b	TRUE

示例解释：

等于 (==):
- 检查两个操作数是否相等。
- 如果相等，返回 True；否则，返回 False。
- 例如，a == b 的结果是 False，因为 10 不等于 20。
不等于 (!=):
- 检查两个操作数是否不相等。
- 如果不相等，返回 True；否则，返回 False。
- 例如，a != b 的结果是 True，因为 10 不等于 20。
大于 (>):
- 检查第一个操作数是否大于第二个操作数。
- 如果是，返回 True；否则，返回 False。
- 例如，a > b 的结果是 False，因为 10 不大于 20。
小于 (<):
- 检查第一个操作数是否小于第二个操作数。
- 如果是，返回 True；否则，返回 False。
- 例如，a < b 的结果是 True，因为 10 小于 20。
大于等于 (>=):
- 检查第一个操作数是否大于或等于第二个操作数。
- 如果是，返回 True；否则，返回 False。
- 例如，a >= b 的结果是 False，因为 10 既不大于也不等于 20。
小于等于 (<=):
- 检查第一个操作数是否小于或等于第二个操作数。
- 如果是，返回 True；否则，返回 False。
- 例如，a <= b 的结果是 True，因为 10 小于 20。

重要说明：

比较运算符可以用于比较各种数据类型，包括数字、字符串、列表和元组。
比较运算符的结果始终是一个布尔值（True 或 False）。
在python3中，不再支持“<>”不等于号，请使用“!=”不等于号。

3.3 Python 赋值运算符

Python 赋值运算符用于将值赋给变量。以下是 Python 赋值运算符的详细解释：

运算符	描述	示例	等价于
=	简单赋值运算符	c = 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

示例解释：

简单赋值 (=):
- 将右侧操作数的值赋给左侧操作数。
- 例如，c = a + b 将 a + b 的结果赋给变量 c。
加法赋值 (+=):
- 将右侧操作数的值加到左侧操作数上，并将结果赋给左侧操作数。
- 例如，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。

重要说明：

赋值运算符用于简化代码，特别是当需要修改变量的当前值时。
赋值运算符的左侧必须是一个变量。
赋值运算符的右侧可以是任何有效的表达式。

3.4 Python 位运算符

Python 位运算符用于对整数的二进制位进行操作。以下是对 Python 位运算符的详细解释：

运算符	描述	示例	结果（十进制）	结果（二进制）
&	按位与（AND）	a & b	12	0000 1100
`\	`	按位或（OR）	a \	b
^	按位异或（XOR）	a ^ b	49	0011 0001
~	按位取反（NOT）	~a	-61	1100 0011
<<	左移	a << 2	240	1111 0000
>>	右移	a >> 2	15	0000 1111

示例解释（假设 a = 60，b = 13）：

按位与 (&):
- 将两个操作数的对应位进行与运算。
- 只有当两个位都为 1 时，结果位才为 1。
- a & b 的结果是 12（0000 1100），因为只有最后四位在 a 和 b 中都为 1。
按位或 (|):
- 将两个操作数的对应位进行或运算。
- 只要两个位中有一个为 1，结果位就为 1。
- a | b 的结果是 61（0011 1101），因为 a 和 b 的所有位组合在一起都至少有一个 1。
按位异或 (^):
- 将两个操作数的对应位进行异或运算。
- 只有当两个位不同时，结果位才为 1。
- a ^ b 的结果是 49（0011 0001），因为 a 和 b 的某些位不同。
按位取反 (~):
- 将操作数的每个位取反（0 变为 1，1 变为 0）。
- ~a 的结果是 -61（1100 0011），因为 a 的所有位都被取反。
左移 (<<):
- 将操作数的位向左移动指定的位数。
- 右侧用 0 填充。
- a << 2 的结果是 240（1111 0000），因为 a 的所有位都向左移动了 2 位。
右移 (>>):
- 将操作数的位向右移动指定的位数。
- 左侧用符号位（对于有符号整数）或 0（对于无符号整数）填充。
- a >> 2 的结果是 15（0000 1111），因为 a 的所有位都向右移动了 2 位。

重要说明：

位运算符通常用于低级编程，例如处理硬件或优化性能。
理解二进制表示对于理解位运算符至关重要。
在python中，位运算符可以用于整数类型，布尔类型。

3.5 Python 逻辑运算符

Python 逻辑运算符用于组合多个条件，并返回一个布尔值（True 或 False），表示逻辑运算的结果。以下是对 Python 逻辑运算符的详细解释：

运算符	描述	示例	结果
and	逻辑与	x and y	如果 x 和 y 都为 True，则返回 True
or	逻辑或	x or y	如果 x 或 y 中有一个为 True，则返回 True
not	逻辑非	not x	如果 x 为 False，则返回 True

示例解释（假设 a = 10，b = 20）：

逻辑与 (and):
- 只有当两个操作数都为 True 时，结果才为 True。
- 否则，结果为 False。
- 例如，(a < 15) and (b > 15) 的结果是 True，因为 a < 15 和 b > 15 都为 True。
- 例如，(a < 5) and (b > 15) 的结果是 False，因为 a < 5 为 False。
逻辑或 (or):
- 只要两个操作数中有一个为 True，结果就为 True。
- 只有当两个操作数都为 False 时，结果才为 False。
- 例如，(a < 5) or (b > 15) 的结果是 True，因为 b > 15 为 True。
- 例如，(a < 5) or (b < 15) 的结果是 False，因为 a < 5 和 b < 15 都为 False。
逻辑非 (not):
- 将操作数的布尔值取反。
- 如果操作数为 True，则结果为 False。
- 如果操作数为 False，则结果为 True。
- 例如，not (a < 5) 的结果是 True，因为 a < 5 为 False。

重要说明：

逻辑运算符用于组合多个条件，以便进行更复杂的逻辑判断。
逻辑运算符的结果始终是一个布尔值（True 或 False）。
逻辑运算符具有短路特性：
- 对于 and 运算符，如果第一个操作数为 False，则不会计算第二个操作数。
- 对于 or 运算符，如果第一个操作数为 True，则不会计算第二个操作数。

3.6 Python 成员运算符

Python 成员运算符用于测试一个序列（例如字符串、列表或元组）中是否包含某个特定的值。以下是对 Python 成员运算符的详细解释：

运算符	描述	示例	结果
in	如果在指定的序列中找到值，则返回 True	x in y	如果 x 在序列 y 中，则返回 True
not in	如果在指定的序列中没有找到值，则返回 True	x not in y	如果 x 不在序列 y 中，则返回 True

示例解释：

in 运算符：
- 用于检查一个值是否存在于一个序列中。
- 如果存在，则返回 True；否则，返回 False。
- 例如：

    my_list = [1, 2, 3, 4, 5]
    print(3 in my_list)  输出：True
    print(6 in my_list)  输出：False
    my_string = "hello"
    print("e" in my_string)  输出：True
    print("z" in my_string)  输出：False

not in 运算符：
- 与 in 运算符相反，用于检查一个值是否不存在于一个序列中。
- 如果不存在，则返回 True；否则，返回 False。
- 例如：

    my_list = [1, 2, 3, 4, 5]
    print(6 not in my_list)  输出：True
    print(3 not in my_list)  输出：False
    my_string = "hello"
    print("z" not in my_string)  输出：True
    print("e" not in my_string)  输出：False

重要说明：

成员运算符可以用于各种序列类型，包括字符串、列表、元组、集合和字典。
对于字典，in 和 not in 运算符默认检查键是否存在。
成员运算符在处理大量数据时非常有用，因为它们可以快速检查一个值是否存在于一个序列中。

3.7 Python 身份运算符

在 Python 中，身份运算符用于比较两个对象的内存位置，以确定它们是否是同一个对象。以下是对 Python 身份运算符的详细解释：

3.7.1 身份运算符的定义

身份运算符检查两个变量是否指向内存中的同一对象。
这与比较它们的值不同（值相等），而是比较它们在内存中的位置（内存地址）。

3.7.2 身份运算符

is:
- 如果两个变量引用同一对象，则返回 True。
- 换句话说，x is y 相当于检查 id(x) == id(y)。id()函数返回对象的唯一标识符（内存地址）。
is not:
- 如果两个变量不引用同一对象，则返回 True。
- x is not y 相当于检查 id(x) != id(y)。

3.7.3 使用场景和注意事项

比较 None:
- is 运算符通常用于检查变量是否为 None，因为 None 是一个单例对象。
- 例如：if x is None:。
比较对象身份:
- 当需要确切地知道两个变量是否指向同一个对象时，可以使用is和is not。
注意值相等与身份相等:
- == 运算符比较两个对象的值是否相等。
- is 运算符比较两个对象的身份是否相等（内存地址是否相同）。
- 例如：两个具有相同值的列表，使用“==”会返回true，但是使用“is”有可能会返回false。因为他们是两个不同的列表对象，存储在不同的内存地址。
小整数和字符串的优化:
- Python 为了优化性能，对于某些小整数和字符串可能会重用相同的对象。因此，在这些情况下，即使是不同的变量也可能使用 is 运算符返回 True。
不可变对象:
- 对于不可变对象（例如，元组和字符串），在某些情况下，如果它们具有相同的值，则它们可能共享相同的内存地址。

3.7.4 示例

x = [1, 2, 3]
y = x
z = [1, 2, 3]
print(x is y)  输出：True，因为 x 和 y 引用同一对象
print(x is z)  输出：False，因为 x 和 z 引用不同对象
print(x == z) 输出：True，因为 x 和 z 的值相等
a = 5
b = 5
print(a is b) 输出：True，因为小整数可能会被 Python 重用

3.8 Python 运算符优先级

在 Python 中，运算符的优先级决定了表达式中运算的执行顺序。以下是 Python 运算符优先级的详细说明，从最高优先级到最低优先级排列：

优先级	运算符	描述
1	( )	括号
2	**	指数
3	~, +, -	按位取反、正号、负号
4	*, /, %, //	乘法、除法、取模、地板除
5	+, -	加法、减法
6	<<, >>	左移、右移
7	&	按位与
8	^	按位异或
9	`\	`
10	==, !=, >, >=, <, <=	比较运算符
11	is, is not	身份运算符
12	in, not in	成员运算符
13	not	逻辑非
14	and	逻辑与
15	or	逻辑或

括号 (Parentheses)

( )：括号具有最高优先级，用于显式地控制运算顺序。

指数 (Exponentiation)

**：指数运算符。

按位取反、正号、负号 (Bitwise NOT, Unary Plus, Unary Minus)

~, +, -：按位取反、正号和负号。

乘法、除法、取模和地板除 (Multiplication, Division, Modulo, Floor Division)

*, /, %, //：乘法、除法、取模和地板除。

加法和减法 (Addition and Subtraction)

+, -：加法和减法。

位移运算符 (Bitwise Shift Operators)

<<, >>：左移和右移位运算符。

按位与 (Bitwise AND)

&：按位与。

按位异或 (Bitwise XOR)

^：按位异或。

按位或 (Bitwise OR)

|：按位或。

比较运算符 (Comparison Operators)

==, !=, >, >=, <, <=：等于、不等于、大于、大于等于、小于、小于等于。

身份运算符 (Identity Operators)

is, is not：身份运算符。

成员运算符 (Membership Operators)

in, not in：成员运算符。

逻辑非 (Logical NOT)

not：逻辑非。

逻辑与 (Logical AND)

and：逻辑与。

逻辑或 (Logical OR)

or：逻辑或。

运算符的结合性

当多个运算符具有相同的优先级时，它们的结合性决定了运算的执行顺序。
大多数运算符的结合性是从左到右，但指数运算符 (**) 和赋值运算符的结合性是从右到左。

示例

result = 2 + 3 * 4  乘法优先级高于加法，结果为 14
result = (2 + 3) * 4  使用括号改变运算顺序，结果为 20
result = 2 ** 3 ** 2 #指数运算符从右到左结合，等同于2 ** 9，结果为512

重点说明：

当表达式中存在多个运算符时，Python 会根据优先级从高到低的顺序执行。
可以使用圆括号 () 来显式地控制运算符的执行顺序。圆括号内的表达式会优先计算。
理解运算符优先级对于编写正确和可预测的 Python 代码至关重要。

四、Python函数

4.1 函数定义及函数调用

4.1.1 定义一个函数

你可以定义一个由自己想要功能的函数，以下是简单的规则：

函数代码块以 def 关键词开头，后接函数标识符名称和圆括号 ()。
任何传入参数和自变量必须放在圆括号中间。圆括号之间可以用于定义参数。
函数的第一行语句可以选择性地使用文档字符串——用于存放函数说明。
函数内容以冒号起始，并且缩进。
return [表达式] 结束函数，选择性地返回一个值给调用方。不带表达式的 return 相当于返回 None。

4.1.2 函数调用

定义一个函数只给了函数一个名称，指定了函数里包含的参数，和代码块结构。这个函数的基本结构完成以后，你可以通过另一个函数调用执行，也可以直接从 Python 提示符执行( 1 )。

4.2 参数

4.2.1 必备参数

必备参数须以正确的顺序传入函数。调用时的数量必须和声明时的一样。

4.2.2 关键字参数

关键字参数和函数调用关系紧密，函数调用使用关键字参数来确定传入的参数值。使用关键字参数允许函数调用时参数的顺序与声明时不一致，因为 Python 解释器能够用参数名匹配参数值。

()以下实例在函数 printme() 调用时使用参数名：

#!/usr/bin/python
-*- coding: UTF-8 -*-
可写函数说明
def printinfo(name, age):
    "打印任何传入的字符串"
    print "Name:", nameprint "Age", agereturn

调用 printinfo 函数
printinfo(age=50, name="miki")

以上实例输出结果：

Name: miki
Age 50

4.2.3 默认参数

调用函数时，缺省参数的值如果没有传入，则被认为是默认值。下例会打印默认的 age，如果 age 没有被传入：

#!/usr/bin/python
-*- coding: UTF-8 -*-
可写函数说明
def printinfo(name, age = 35):
    "打印任何传入的字符串"
    print "Name:", nameprint "Age", agereturn

调用 printinfo 函数
printinfo(age=50, name="miki")
printinfo(name="miki")

以上实例输出结果：

Name: miki
Age 50
Name: miki
Age 35

4.2.4 不定长参数

可能需要一个函数能处理比当初声明时更多的参数。这些参数叫做不定长参数，和上述 2 种参数不同，声明时不会命名。基本语法如下：

def functionname([formal_args,] *var_args_tuple):
    "函数_文档字符串"
    function_suitereturn [expression]

加了星号 (*) 的()变量名会存放所有未命名的变量参数。选择不多传参数也可。

如下实例：

#!/usr/bin/python
-*- coding: UTF-8 -*-
# 可写函数说明
def printinfo(arg1, *vartuple):
    "打印任何传入的参数"
    print "输出:"
    print arg1for var in vartuple:print varreturn

调用 printinfo 函数
printinfo(10)
printinfo(70, 60, 50)

以上实例输出结果：

输出:
10
输出:
70
60
50

五、Python变量类型

5.1 变量赋值

Python中变量赋值的一个基本特性：动态类型。

详细解释：

counter = 100：
- 这是一个赋值语句，将整数值 100 赋给变量 counter。
- 在其他一些编程语言中，你可能需要先声明变量 counter 的类型（例如，int counter = 100;）。
- Python不需要这样做。Python会根据你赋给变量的值，自动推断出变量的类型。
赋值整型变量：
- 这是一个注释，用于解释代码的作用。
- 在Python中，以 # 开头的行都是注释，不会被Python解释器执行。
print counter：
- 这是一个打印语句，用于将变量 counter 的值输出到控制台。

5.2 多个变量赋值

Python 允许你同时为多个变量赋值。

例如：a = b = c = 1 也可以为多个对象指定多个变量。

例如：a, b, c = 1, 2, "john" 以上实例，两个整型对象 1 和 2 的分配给变量 a 和 b，字符串对象 "john" 分配给变量 c。

5.3 标准数据类型

Python 有五个标准的数据类型：

Numbers (数字)

String (字符串)

List (列表)

Tuple (元组)

Dictionary (字典)

5.4 Python 数据类型转换

Python 数据类型转换函数详解

int(x [,base])
- 将 x 转换为一个整数。
- base 参数（可选）指定了转换的基数，默认为 10。
- 例如：int("10", 2) 将二进制字符串 "10" 转换为十进制整数 2。
long(x [,base])
- 将 x 转换为一个长整数。
- 在Python3中long类型已经被移除。
- base 参数（可选）指定了转换的基数，默认为 10。
float(x)
- 将 x 转换为一个浮点数。
- 例如：float("3.14") 将字符串 "3.14" 转换为浮点数 3.14。
complex(real [,imag])
- 创建一个复数。
- real 参数（可选）指定实部，默认为 0。
- imag 参数（可选）指定虚部，默认为 0。
- 例如：complex(1, 2) 创建复数 1 + 2j。
str(x)
- 将对象 x 转换为字符串。
- 例如：str(123) 将整数 123 转换为字符串 "123"。
repr(x)
- 将对象 x 转换为表达式字符串。
- 返回一个对象的可打印表示形式。
- 通常，eval(repr(object)) 会返回与 object 相同的值。
eval(str)
- 用来计算字符串中的有效Python表达式，并返回一个对象。
- 例如：eval('2 + 2') 返回4
tuple(s)
- 将序列 s 转换为一个元组。
- 例如：tuple([1, 2, 3]) 将列表 [1, 2, 3] 转换为元组 (1, 2, 3)。
list(s)
- 将序列 s 转换为一个列表。
- 例如：list((1, 2, 3)) 将元组 (1, 2, 3) 转换为列表 [1, 2, 3]。
set(s)
- 转换为可变集合。
- 例如：set([1,2,3])将列表转换为集合{1，2，3}
dict(d)
- 创建一个字典。
- d 必须是一个序列 (key, value) 元组。
- 例如：dict([(1, 'a'), (2, 'b')]) 创建字典 {1: 'a', 2: 'b'}。
frozenset(s)
- 转换为不可变集合。
chr(x)
- 将一个整数转换为一个字符。
- 返回 Unicode 码位为整数 x 的字符。
unichr(x)
- 将一个整数转换为 Unicode 字符。
- 在python3中被chr()取代。
ord(x)
- 将一个字符转换为它的整数数值。
- 返回 Unicode 字符 x 的 Unicode 码位。
hex(x)
- 将一个整数转换为一个十六进制字符串。
- 例如：hex(255) 返回 "0xff"。
oct(x)
- 将一个整数转换为一个八进制字符串。
- 例如：oct(8) 返回‘0o10’。

5.5查看数据类型

这段文字描述了Python中用于类型检查的两个重要函数：type()和isinstance()，以及它们在处理继承关系时的不同行为。

type() 函数

作用：type(object)函数用于返回对象的类型。
特性：
- type()函数不会认为子类是父类的一种类型。
- 这意味着，如果一个对象是子类的实例，type()函数只会返回子类的类型，而不会返回父类的类型。
示例：

Python

class Animal:passclass Dog(Animal):pass dog = Dog() print(type(dog)) 输出：<class '__main__.Dog'> print(type(dog) == Animal) 输出：False

isinstance() 函数

作用：isinstance(object, classinfo)函数用于检查一个对象是否是指定类或其子类的实例。
特性：
- isinstance()函数会认为子类是父类的一种类型。
- 这意味着，如果一个对象是子类的实例，isinstance()函数会返回True，即使你检查的是父类。
示例：

    class Animal:passclass Dog(Animal):pass
    dog = Dog()
    print(isinstance(dog, Dog))  输出：True
    print(isinstance(dog, Animal))  输出：True

区别总结

type()函数是精确匹配，只返回对象的确切类型。
isinstance()函数是模糊匹配，会考虑继承关系。

选择使用哪个函数

如果你需要精确地知道一个对象的类型，可以使用type()函数。
如果你需要检查一个对象是否属于某个类或其子类，可以使用isinstance()函数。

核对数据类型 isinstance(a, int)

isinstance(a, int)用于检查变量a是否为整数类型。
如果a是整数或int的子类的实例，则返回True，否则返回False。

扩展阅读：

Python开发者必备：语法与高级特性精讲	Python开发者必备：语法与高级特性精讲-CSDN博客	Python的基本语法和高级属性
Python 入门核心概念：语法、运算符、函数及变量类型详解	Python 入门核心概念：语法、运算符、函数及变量类型详解-CSDN博客	Python基础知识梳理
Python开发环境搭建终极指南：从零配置到高频问题解决方案	Python开发环境搭建终极指南：从零配置到高频问题解决方案-CSDN博客	Python搭建教程及常见问题
Python自动化测试框架开发指南：从模块封装到持续交付的高效实践	Python自动化测试框架开发指南：从模块封装到持续交付的高效实践-CSDN博客	Python自动化测试框架的完整搭建指南