Python vs. JavaScript: 基本数据类型对比指南

本指南旨在为熟悉 JavaScript 的开发者快速梳理 Python 的基本数据类型，反之亦然。我们将通过对比，深入了解两种语言在处理核心数据时的异同。

参考资料：Python VS JavaScript – What are the Key Differences

---

核心差异速览

特性 (Feature)	Python	JavaScript
数字类型	int (整数) 和 float (浮点数) 分离	Number (统一处理整数和浮点数), BigInt
布尔值	True, False (首字母大写)	true, false (小写)
空值	None (单一空值对象)	null (意在为空) 和 undefined (未定义)
变量声明	直接赋值，无需关键字	需要 let, const, var 关键字
方法/函数命名	snake_case (下划线命名法)	camelCase (驼峰命名法)
类型检查	type() (返回具体类型), isinstance()	typeof (返回字符串), instanceof

---

1. 数字类型 (Numeric Types)

Python

Python 明确区分整数和浮点数。

• int: 整数。Python 的 int 可以处理任意大小的整数，无需担心溢出。
• float: 浮点数（即小数）。

操作与API:

# 创建
integer_val = 100
float_val = 100.5

# 算术运算
add = integer_val + 5 # 105
sub = float_val - 10.5 # 90.0

# 除法
std_division = 10 / 4  # -> 2.5 (结果为 float)
floor_division = 10 // 4 # -> 2 (地板除，结果为 int)

# 类型转换
str_num = "123"
num_from_str = int(str_num) # -> 123 (int)
float_from_int = float(num_from_str) # -> 123.0 (float)

# 从 float 转 int 会直接截断小数部分
int_from_float = int(2.9) # -> 2

# 其他常用 API
print(abs(-99))    # -> 99 (绝对值)
print(round(2.9))  # -> 3 (四舍五入)
print((10.0).is_integer()) # -> True
print((10.5).is_integer()) # -> False

JavaScript

JavaScript 使用单一的 Number 类型来表示所有数字（包括整数和浮点数）。对于超出 Number 安全范围的超大整数，则使用 BigInt。

操作与API:

// 创建
let numberVal = 100;
let floatVal = 100.5;

// 算术运算
let add = numberVal + 5; // 105
let sub = floatVal - 10.5; // 90

// 除法 (只有一种)
let division = 10 / 4; // -> 2.5

// 类型转换
let strNum = "123";
let numFromStr = parseInt(strNum); // -> 123 (Number)
let floatFromStr = parseFloat("123.45"); // -> 123.45 (Number)
let numFromStr2 = Number(strNum); // -> 123 (Number), 更严格的转换

// 创建 BigInt
const bigIntValue = 9007199254740991n;

// 其他常用 API
Math.abs(-99);      // -> 99 (绝对值)
Math.round(2.9);    // -> 3 (四舍五入)
Math.ceil(2.1);     // -> 3 (向上取整)
Math.floor(2.9);    // -> 2 (向下取整)
(123.456).toFixed(2); // -> "123.46" (字符串形式，保留两位小数)
(255).toString(16); // -> "ff" (数字转为16进制字符串)

核心对比

1. 类型分离 vs. 统一: Python 对 int 和 float 做了区分，而 JavaScript 用 Number 统一处理，这简化了 JS 的数字操作，但也意味着需要开发者自己注意整数和浮点数运算的精度问题。
2. 除法: Python 提供了两种除法运算符 (/ 和 //)，可以清晰地表达意图，而 JS 只有一种。
3. 大整数: Python 的 int 类型原生支持任意精度的大整数，而 JS 在 ES2020 后才通过 BigInt 类型支持。
4. API 设计: Python 倾向于使用全局函数（如 abs(), round()）进行通用的数学运算。而 JavaScript 则将这类功能大量集中在 Math 对象中，同时在 Number 原型上提供了一些特定于格式化的方法（如 toFixed()）。

---

2. 文本类型 (String / Text)

Python

使用 str 类型。创建时单引号 (') 和双引号 (") 等效。

操作与API:

# 创建
single_quote = 'hello'
double_quote = "world"
# f-string (推荐的格式化方式)
name = "Alice"
greeting = f"Hello, {name}!" # -> "Hello, Alice!"

# 操作
concatenation = single_quote + " " + double_quote # -> "hello world"
repetition = "Go! " * 3 # -> "Go! Go! Go! "

# 常用 API (snake_case)
s = "  Python Developer  "
s.upper()         # -> "  PYTHON DEVELOPER  "
s.lower()         # -> "  python developer  "
s.strip()         # -> "Python Developer"
s.startswith('Py')# -> True
s.split(' ')      # -> ['', '', 'Python', 'Developer', '', '']

# 切片
py_part = s.strip()[0:6] # -> "Python"

# 更多常用 API
s_clean = s.strip()
print(s_clean.find("Dev"))       # -> 7 (查找子串位置，找不到返回-1)
print(s_clean.replace(" ", "_")) # -> "Python_Developer"
print("a,b,c".split(","))       # -> ['a', 'b', 'c']
print("_".join(['a', 'b', 'c'])) # -> "a_b_c"
print("123".isdigit())           # -> True
print("abc".isalpha())           # -> True

JavaScript

使用 String 类型。单引号、双引号和反引号（``）都可以创建字符串。

操作与API:

// 创建
let singleQuote = 'hello';
let doubleQuote = "world";
// Template Literals (模板字符串)
let name = "Alice";
let greeting = `Hello, ${name}!`; // -> "Hello, Alice!"

// 操作 (只有拼接)
let concatenation = singleQuote + " " + doubleQuote; // -> "hello world"

// 常用 API (camelCase)
let s = "  JavaScript Developer  ";
s.toUpperCase();         // -> "  JAVASCRIPT DEVELOPER  "
s.toLowerCase();         // -> "  javascript developer  "
s.trim();                // -> "JavaScript Developer"
s.startsWith('Java');    // -> true
s.split(' ');            // -> ["", "", "JavaScript", "Developer", "", ""]

// 截取子串
let jsPart = s.trim().substring(0, 10); // -> "JavaScript"

// 更多常用 API
let sClean = s.trim();
sClean.includes("Dev");      // -> true (ES6, 检查是否包含)
sClean.indexOf("Dev");       // -> 11 (查找子串位置，找不到返回-1)
sClean.replace(" ", "_");    // -> "JavaScript_Developer"
"a,b,c".split(",");          // -> ["a", "b", "c"]
["a", "b", "c"].join("_");   // -> "a_b_c"
"5".padStart(3, "0");        // -> "005"
"5".padEnd(3, "0");          // -> "500"

核心对比

1. 方法命名: Python 的字符串方法遵循 snake_case (e.g., startswith)，而 JS 遵循 camelCase (e.g., startsWith)。
2. 字符串格式化: Python 的 f-string 和 JS 的模板字符串功能相似，都是现代、推荐的格式化方法。
3. 独有操作: Python 可以用 * 对字符串进行重复操作，这在 JS 中是不支持的。Python 的切片语法 ([start:end:step]) 也比 JS 的 substring 或 slice 更强大灵活。
4. 查找与连接: Python 的 str.join() 设计非常独特且高效，它由分隔符字符串调用，将一个序列连接起来。而 JS 的 join 是数组的一个方法。在查找方面，JS 的 includes() 方法比 Python 的 in 操作符（虽然此处未展示）在意图上更明确。

---

2.1. 字符串切片 (String Slicing)

字符串切片是从字符串中提取子字符串的常用操作。Python 在这方面提供了非常强大和简洁的语法。

参考资料：String Slicing in Python - GeeksforGeeks

Python

Python 使用 [start:end:step] 语法进行切片，非常灵活。

• start: 起始索引（包含），如果省略则默认为 0。
• end: 结束索引（不包含），如果省略则默认为字符串末尾。
• step: 步长，即每隔多少个字符取一个。如果省略则默认为 1。

操作与API:

s = "Hello, Python!"

# 基本切片
print(s[0:5])      # -> "Hello"
print(s[7:13])     # -> "Python"
print(s[:5])       # -> "Hello" (从头开始)
print(s[7:])       # -> "Python!" (到结尾)

# 使用步长
print(s[::2])      # -> "Hlo yhn" (每隔一个字符取一个)

# 使用负数索引
print(s[-1])       # -> "!" (获取最后一个字符)
print(s[-6:])      # -> "Python!" (从倒数第6个字符到结尾)
print(s[:-1])      # -> "Hello, Python" (除最后一个字符外的所有字符)

# 反转字符串 (最经典的用法)
print(s[::-1])     # -> "!nohtyP ,olleH"

JavaScript

JavaScript 没有与 Python 对应的切片语法，而是使用内置的方法来实现。最常用的是 slice() 和 substring()。

• slice(beginIndex, endIndex): 提取字符串的一部分并返回一个新字符串。endIndex 是可选的，并且不被包含在内。支持负数索引，表示从字符串末尾算起。
• substring(indexStart, indexEnd): 与 slice() 类似，但不支持负数索引（会将负数视为 0）。

操作与API:

let s = "Hello, JavaScript!";

// 使用 slice() (推荐)
s.slice(0, 5);       // -> "Hello"
s.slice(7, 17);      // -> "JavaScript"
s.slice(7);          // -> "JavaScript!" (到结尾)

// slice() 支持负数索引
s.slice(-1);         // -> "!" (获取最后一个字符)
s.slice(-10);        // -> "JavaScript!" (从倒数第10个字符到结尾)
s.slice(0, -1);      // -> "Hello, JavaScript"

// 使用 substring()
s.substring(0, 5);   // -> "Hello"

// substring() 不支持负数索引
s.substring(-10, 5); // 负数被视为0 -> s.substring(0, 5) -> "Hello"

// JS 没有直接反转字符串的单步方法，需要组合使用
s.split('').reverse().join(''); // -> "!tpircSavaJ ,olleH"

核心对比

1. 语法 vs. 方法: 这是最核心的区别。Python 使用一种内置、强大且优雅的 [] 语法来进行切片，而 JavaScript 必须依赖 .slice() 等方法调用。
2. 功能与简洁性: Python 的 step 参数使其在功能上更为强大，例如 s[::2] 或 s[::-1] 这样的操作在 JavaScript 中需要更复杂的代码才能实现。特别是字符串反转，Python 的写法极为简洁。
3. 负数索引: Python 的切片语法对负数索引提供了统一且符合直觉的支持。在 JavaScript 中，只有 slice() 方法支持负数索引，而 substring() 则不支持，这可能导致混淆。
4. 不可变性: 在这一点上两者是相同的。无论是 Python 的切片还是 JavaScript 的 slice()/substring() 方法，都不会修改原始字符串，而是返回一个新的子字符串。

---

3. 布尔类型 (Boolean)

Python

使用 bool 类型，其值必须是 True 或 False，首字母大写。

重要特性: 在 Python 中，bool 是 int 的一个子类。True 的行为类似于 1，False 类似于 0。

is_active = True
has_permission = False

print(True == 1) # -> True
print(False == 0) # -> True
print(True + 3)   # -> 4

JavaScript

使用 boolean 类型，其值为 true 或 false，全小写。

let isActive = true;
let hasPermission = false;

console.log(true == 1); // -> true
console.log(false == 0); // -> true
console.log(true + 3);   // -> 4

核心对比

最直观的区别就是 大小写：Python 是 True/False，JavaScript 是 true/false。这是一个非常常见的初学者错误。从行为上看，两者在与数字进行比较和计算时表现相似。

---

4. 空值类型 (None / Nullish)

Python

Python 只有一个表示"无"或"空"的值：None。它是一个特殊的、独一无二的对象，其类型是 NoneType。

# 当函数没有返回值时，默认返回 None
def do_nothing():
    pass

result = do_nothing() # result is None

# 检查是否为 None
if result is None:
    print("No value returned")

JavaScript

JavaScript 有两个表示"无"或"空"的值：null 和 undefined。

• undefined: 通常表示一个变量已被声明，但尚未被赋值。
• null: 通常由开发者主动赋值，用来表示一个变量意在为空。

let a; // a is undefined
let b = null; // b is null

// 函数参数未提供时也是 undefined
function greet(name) {
    console.log(`Hello, ${name}`);
}
greet(); // 输出 "Hello, undefined"

核心对比

这是两种语言的一个关键哲学差异。Python 的 None 简化了对"空"的判断。而 JavaScript 的 null 和 undefined 提供了更细致的区分，但也常常是 bug 的来源，需要开发者理解并正确处理 == 和 === 在检查它们时的不同行为。

---

5. 类型检查

Python

• type(): 返回一个对象的精确类型。
• isinstance(): 检查一个对象是否是某个类或其子类的实例，通常更推荐使用它来进行类型检查。

num = 10
is_int = isinstance(num, int) # -> True
is_float = isinstance(num, float) # -> False
is_num = isinstance(num, (int, float)) # -> True

type(num) == int # -> True

JavaScript

• typeof: 一个操作符，返回一个表示操作数类型的字符串（例如 "number", "string", "boolean"）。
• instanceof: 检查一个对象是否是某个构造函数的实例。

let num = 10;
typeof num; // -> "number"

let s = "hello";
typeof s; // -> "string"

// typeof 的一个著名怪癖
typeof null; // -> "object"

class Person {}
let p = new Person();
p instanceof Person; // -> true

核心对比

1. 返回值: Python 的 type() 返回一个类型对象，而 JS 的 typeof 返回一个字符串。
2. 可靠性: JS 的 typeof 对于 null 和数组 ("object") 等情况的返回值可能不符合直觉。Python 的 isinstance() 通常是进行类型判断的黄金标准，因为它能正确处理继承关系。