1、Java基本类型

在java里，总共有8种基本类型，分别是：

1. boolean：布尔类型，只有两个值true和false。
2. char：字符类型，占用2个字节，用来表示一个单一的字符。
3. byte：字节类型，占用1个字节，范围为-128到127。
4. short：短整型，占用2个字节，范围为-32,768到32,767。
5. int：整型，占用4个字节，范围为-2^31到2^31-1。
6. long：长整型，占用8个字节，范围为-2^63到2^63-1。
7. float：单精度浮点型，占用4个字节，范围为1.4E-45到3.4028235E38，可以表示小数。
8. double：双精度浮点型，占用8个字节，范围为4.9E-324到1.7976931348623157E308，可以表示更大范围的小数。

2、Python基本类型

Python3 中常见的数据类型有：

• Number（数字）
• String（字符串）
• bool（布尔类型）
• List（列表）
• Tuple（元组）
• Set（集合）
• Dictionary（字典）

其中，Number代表数字，Python3 支持 int、float、bool、complex（复数）。

需要注意的是，在Python 3里，只有一种整数类型 int，没有 python2 中的 Long。

在Python中，int的最大值取决于你的操作系统是32位还是64位。在32位系统中，int的最大值是2^31 - 1，而在64位系统中，int的最大值是2^63 - 1。

import sysif __name__ == '__main__':maxInt = sys.maxsizeprint(maxInt)  # 9223372036854775807

3、Python基本类型代码示例

3.1、complex复数运算

Python的Number类型里面，有一种叫做complex，意即数学上的复数。这种类型java是没有的，python能更加方便的进行科学计算。

# 创建一个实部为3，虚部为4的复数
z1 = complex(3, 4)
print(z1)  # 输出：(3+4j)# 创建一个实部为0，虚部为1的复数
z2 = complex(0, 1)
print(z2)  # 输出：1j# 创建一个实部为-2.5，虚部为0的复数
z3 = complex(-2.5, 0)
print(z3)  # 输出：-2.5# 创建一个实部为5，虚部为0的复数
z4 = complex(5, 0)
print(z4)  # 输出：5.0

3.2、List（列表）

列表是最常用的 Python 数据类型，它可以作为一个方括号内的逗号分隔值出现。

Python的列表相当于Java的List，都是一种有序的可变容器，可以存储任意类型的元素。

if __name__ == '__main__':list = []list.append(1) # adding 1 to the listlist.append("Hello") # adding "Hello" to the listprint(list) # printing [1, 'Hello']print(list[1]) # printing Hellofor e in list: # iterating over the listprint(e)

3.3、Tuple（元组）

Python 的元组与列表类似，不同之处在于元组的元素不能修改。

元组使用小括号 ( )，列表使用方括号 [ ]。

元组创建很简单，只需要在括号中添加元素，并使用逗号隔开即可。

if __name__ == '__main__':tuple = ("hello", 1, True)tuple[0] = 99 # TypeError: 'tuple' object does not support item assignment

Java中没有内置的元组类型。元组是一种可以包含多个不同类型元素的数据结构，可以通过索引或属性来访问其中的元素。

虽然Java没有内置元组类型，但可以通过自定义类或使用第三方库来实现类似的功能。例如，可以创建一个自定义类来表示一个包含多个不同类型元素的组合，或使用第三方库，如javatuples或Pair类库。

以下是使用javatuples库创建元组的示例：

import org.javatuples.Tuple;
import org.javatuples.Tuple2;public class TupleExample {public static void main(String[] args) {// 创建一个包含两个元素的元组（Tuple2）Tuple2<String, Integer> tuple = new Tuple2<>("Hello", 42);// 访问元组中的元素String str = tuple.getValue0();Integer num = tuple.getValue1();// 输出元组的元素System.out.println(str);  // 输出：HelloSystem.out.println(num);  // 输出：42}
}

3.4、Dictionary（字典）

字典是一种可变容器模型，且可存储任意类型对象。类似与Java的HashMap等Map实现。

字典的每个键值 key=>value 对用冒号 : 分割，每个对之间用逗号(,)分割，整个字典包括在花括号 {} 中 ,格式如下所示：

d = {key1 : value1, key2 : value2, key3 : value3 }

 map的更新，删除示例如下：

if __name__ == '__main__':map = {}map.update({'a': 1, 'b': 2, 'c': 3})map.update({'a': 2, 'b': 3, 'c': 4})map['a'] = 3print(map) # print {'a': 3, 'b': 3, 'c': 4}del map['c']print(map)  # print  {'a': 3, 'b': 3}print(len(map)) # print 2

 3.5、Set（集合）

集合（set）是一个无序的不重复元素序列。类似与Java的HashSet等Set实现。

集合中的元素不会重复，并且可以进行交集、并集、差集等常见的集合操作。

# 创建一个空集合
set1 = set()
print(set1)  # 输出：set()# 创建一个包含元素的集合
set2 = {1, 2, 3, 4, 5}
print(set2)  # 输出：{1, 2, 3, 4, 5}# 添加元素到集合
set2.add(6)
print(set2)  # 输出：{1, 2, 3, 4, 5, 6}# 移除集合中的元素
set2.remove(3)
print(set2)  # 输出：{1, 2, 4, 5, 6}# 检查元素是否在集合中
print(4 in set2)  # 输出：True
print(7 in set2)  # 输出：False# 遍历集合
for num in set2:print(num)# 进行集合操作
set3 = {4, 5, 6, 7, 8}
set4 = {6, 7, 8, 9, 10}# 并集
union_set = set3.union(set4)
print(union_set)  # 输出：{4, 5, 6, 7, 8, 9, 10}# 交集
intersection_set = set3.intersection(set4)
print(intersection_set)  # 输出：{6, 7, 8}# 差集
difference_set = set3.difference(set4)
print(difference_set)  # 输出：{4, 5}# 对称差集
symmetric_difference_set = set3.symmetric_difference(set4)
print(symmetric_difference_set)  # 输出：{4, 5, 9, 10}