Python数学建模-2.2Python基本数据类型

各位小伙伴大家好，今天开始学习司守奎老师的《数学建模算法与应用》啦，我也会边学习边与大家分享书中的内容，希望与大家共同进步哦

Python中的基本数据类型主要包括以下几种：

1. 数字（Numbers）

   • 整型（int）：正或负整数，没有限制大小。例如：100，-8080，0。
   • 浮点型（float）：浮点数，即带有小数点的数字。例如：0.0，-21.9，9.9。
   • 复数（complex）：由实数部分和虚数部分构成的数字，通常形式为 a + bj，其中 a 和 b 是浮点数，j（或 J）表示虚数单位。例如：3+2j，1.5-7.9j。

2. 布尔值（Boolean）

   • 布尔值只有两种：True 或 False。它们用于逻辑运算，如条件判断。

3. 序列类型

   • 字符串（str）：字符序列，用于表示文本信息。例如：'hello'，"world"。
   • 列表（list）：由任意对象组成的有序集合。例如：[1, 2, 3]，['apple', 'banana', 'cherry']。
   • 元组（tuple）：与列表类似，但元组是不可变的。例如：(1, 2, 3)，('apple', 'banana')。

4. 集合类型

   • 集合（set）：无序且不包含重复元素的集合。例如：{1, 2, 3}，{'apple', 'banana'}。

5. 字典（dict）

   • 字典是一个无序的键值对集合。键必须是唯一的，而值可以是任何数据类型。例如：{'name': 'Alice', 'age': 30}。

6. 其他类型

   • None：表示空值或不存在的值。
   • 类型对象：Python中所有的类型本身也是对象，如 int，float，list 等。

这些基本数据类型在Python编程中扮演着非常重要的角色，它们各自有独特的属性和方法，可以满足各种编程需求。

2.2.1数字（Numbers）

在Python中，数字是一种基本数据类型，用于表示数值。Python支持多种数字类型，每种类型都有特定的用途和属性。以下是Python中主要的数字类型：

1. 整型（int）

整型用于表示整数，可以是正数或负数，没有限制大小（在大多数现代系统上）。Python 3中的整数是“长整型”，可以处理任意大小的整数，只要你的机器有足够的内存。

示例：

x = 10     # 十进制数  
y = 0b10   # 二进制数  
z = 0o12   # 八进制数  
w = 0x1A   # 十六进制数

2. 浮点型（float）

浮点型用于表示实数，即带有小数点的数字。它们由整数部分和小数部分组成。

示例：

pi = 3.14159  
e = 2.71828

3. 复数（complex）

复数由实部和虚部组成，通常形式为 a + bj，其中 a 和 b 是浮点数，j（或 J）表示虚数单位。

示例：

c = 3 + 4j  
d = complex(2, -5)  # 使用complex函数创建复数

4.数字运算

Python支持对数字进行各种运算，包括：

• 加法 (+)
• 减法 (-)
• 乘法 (*)
• 除法 (/)
• 取整除（地板除）(//)
• 取模（求余数）(%)
• 幂运算 (**)

以及一些内置函数，如 abs()（求绝对值）、round()（四舍五入）等。 

5.类型转换

你可以使用内置函数将一种数字类型转换为另一种。例如：

• int()：将浮点数转换为整数（会丢弃小数部分），或将字符串转换为整数（如果字符串表示的是有效的整数）。
• float()：将整数或字符串转换为浮点数。
• complex()：创建复数或将其他数字类型转换为复数。

示例：

num_str = "123"  
num_int = int(num_str)  # 将字符串转换为整数  
num_float = float(num_int)  # 将整数转换为浮点数

了解这些数字类型和它们之间的转换可以帮助我们更有效地在Python中进行数值计算和数据处理。

2.2.2 布尔值（Boolean）

在Python中，布尔值（Boolean）是一种数据类型，用于表示逻辑上的真（True）或假（False）。布尔值在编程中非常重要，特别是在条件判断、循环控制以及逻辑运算等方面。

1.布尔值的基本使用

布尔值只有两种状态：True 和 False。你可以直接将它们赋值给变量，或者使用比较运算符或逻辑运算符得到布尔值。

# 直接赋值布尔值  
is_active = True  
is_inactive = False  
  
# 使用比较运算符得到布尔值  
x = 5  
y = 10  
is_x_greater_than_y = x > y  # False，因为5不大于10  
is_x_less_than_y = x < y    # True，因为5小于10  
  
# 逻辑运算符  
and_result = is_x_less_than_y and True  # True，因为两个条件都为True  
or_result = is_x_greater_than_y or is_x_less_than_y  # True，因为至少有一个条件为True  
not_result = not is_x_less_than_y  # False，因为is_x_less_than_y为True，取反后为False

2.布尔值在条件语句中的应用

布尔值经常用于条件语句中，如 if、elif、else 和 while。当条件语句中的表达式求值为 True 时，会执行相应的代码块。

# 使用if语句根据布尔值执行不同操作  
if is_x_less_than_y:  
    print("x is less than y")  
else:  
    print("x is not less than y")  
  
# 使用while语句根据布尔值控制循环  
count = 0  
while count < 5:  
    print(count)  
    count += 1

在上面的 while 循环中，只要 count < 5 这个条件（求值为布尔值）为 True，循环就会继续执行。当 count 达到5时，条件变为 False，循环结束。

3.隐式布尔值

在Python中，有些非布尔值类型的对象在布尔上下文中使用时，会被解释为 True 或 False。例如，空列表、空字符串、空字典、None、数字0等都被视为 False，而其他非零数值、非空容器等则被视为 True。这种行为称为“隐式布尔值”或“真值测试”。

# 隐式布尔值示例  
empty_list = []  
non_empty_list = [1, 2, 3]  
  
if empty_list:  
    print("empty_list is True")  # 这行不会被执行，因为empty_list被视为False  
else:  
    print("empty_list is False")  # 输出：empty_list is False  
  
if non_empty_list:  
    print("non_empty_list is True")  # 输出：non_empty_list is True  
else:  
    print("non_empty_list is False")

理解布尔值及其在Python中的应用是编写逻辑清晰、易于维护代码的关键。布尔值不仅用于简单的条件判断，还是构建复杂逻辑结构和控制流程的基础。

2.2.3序列类型

在Python中，序列类型是一种重要的数据结构，用于存储一系列的元素。这些元素可以是数字、字符、字符串或其他数据类型，并且它们按照特定的顺序排列。Python提供了几种内置的序列类型，每种类型都有其特定的用途和特性。

1.列表（List）

列表是最常用的序列类型之一，它是一个有序的元素集合。列表中的元素可以是任何数据类型，并且列表的长度是可变的。列表使用方括号 [] 表示，元素之间用逗号分隔。

my_list = [1, 2, 3, 'apple', 'banana']  
print(my_list)  # 输出: [1, 2, 3, 'apple', 'banana']

输出结果：

[1, 2, 3, 'apple', 'banana']

列表支持各种操作，如索引、切片、修改、添加和删除元素等。

2.元组（Tuple）

元组与列表类似，也是一个有序的元素集合。不同的是，元组是不可变的，即一旦创建，就不能修改其元素。元组使用圆括号 () 表示，元素之间用逗号分隔。

my_tuple = (1, 2, 3, 'apple', 'banana')  
print(my_tuple)  # 输出: (1, 2, 3, 'apple', 'banana')

输出结果：

(1, 2, 3, 'apple', 'banana')

3. 字符串（String）

字符串也是一种序列类型，用于表示文本数据。字符串中的每个字符都可以看作是序列中的一个元素。字符串是不可变的，但可以通过切片、连接、查找等操作来处理。

my_string = "Hello, World!"  
print(my_string)  # 输出: Hello, World!

输出结果：

Hello, World!

字符串支持许多内置方法，用于处理文本数据，如分割、替换、大小写转换等。

4.序列类型的通用操作

所有序列类型（列表、元组和字符串）都支持一些通用的操作：

• 索引：使用整数来访问序列中的单个元素。
• 切片：使用冒号分隔的索引来访问序列的一个子序列。
• 长度：使用 len() 函数获取序列的长度。
• 加法：将两个序列连接起来。
• 乘法：重复序列多次。
• 成员资格：使用 in 或 not in 运算符检查元素是否存在于序列中。

了解这些序列类型及其操作对于编写有效的Python代码至关重要，因为它们提供了组织和处理数据的基础结构。

2.2.4集合类型

在Python中，集合（Set）是一种无序的、不重复的元素序列。集合类型用于存储唯一的元素，不允许有重复值。集合提供了一种快速查找成员是否存在的方法，同时也支持集合运算，如并集、交集、差集等。

1.创建集合

集合可以使用花括号 {} 或者 set() 函数来创建。但请注意，如果只传入一个可迭代对象（如列表或元组），应使用 set() 函数来避免与字典的创建语法混淆。

# 使用花括号创建集合  
my_set1 = {1, 2, 3, 4}  
print(my_set1)  # 输出: {1, 2, 3, 4}  
  
# 使用set()函数创建集合  
my_set2 = set([1, 2, 2, 3, 4, 4])  
print(my_set2)  # 输出: {1, 2, 3, 4}，重复的元素被自动去除

输出结果：

{1, 2, 3, 4}
{1, 2, 3, 4}【注意：集合中不能有相同元素，如果在创建集合时有重复元素，Python会自动删除重复的元素】

2.集合的基本操作

添加元素：使用 add() 方法向集合中添加一个元素。

# 添加元素  
my_set1 = {1, 2, 3, 4}  
my_set1.add(5)  
print(my_set1)  # 输出: {1, 2, 3, 4, 5}  

输出结果：

{1, 2, 3, 4, 5}

移除元素：使用 remove() 方法从集合中移除一个元素。如果元素不存在，会抛出 KeyError 异常。也可以使用 discard() 方法，如果元素不存在则不会抛出异常。

# 添加元素
my_set1 = {1, 2, 3, 4}
my_set1.add(5)
my_set1.remove(2)
print(my_set1)  # 输出: {1, 3, 4, 5}

输出结果：

 {1, 3, 4, 5}

检查元素：使用 in 或 not in 来检查元素是否存在于集合中。

# 添加元素
my_set1 = {1, 2, 3, 4}
my_set1.add(5)
my_set1.remove(2)
if 3 in my_set1:
    print("3 is in the set")  # 输出: 3 is in the set  

 输出结果：

3 is in the set
集合运算：集合支持并集（|）、交集（&）、差集（-）、对称差集（^）等运算。

# 集合运算
set1 = {1, 2, 3, 4, 5}
set2 = {4, 5, 6, 7, 8}

# 并集
union_set = set1 | set2
print(union_set)  # 输出: {1, 2, 3, 4, 5, 6, 7, 8}

# 交集
intersection_set = set1 & set2
print(intersection_set)  # 输出: {4, 5}

# 差集
difference_set = set1 - set2
print(difference_set)  # 输出: {1, 2, 3}

# 对称差集
symmetric_difference_set = set1 ^ set2
print(symmetric_difference_set)  # 输出: {1, 2, 3, 6, 7, 8}

 输出结果：

{1, 2, 3, 4, 5, 6, 7, 8}
{4, 5}
{1, 2, 3}
{1, 2, 3, 6, 7, 8}

3.集合的其他用法

集合还提供了其他一些有用的方法，例如：

• clear()：清空集合。
• copy()：返回集合的浅拷贝。
• issubset(other)：检查集合是否为另一个集合的子集。
• issuperset(other)：检查集合是否为另一个集合的超集。
• pop()：随机移除并返回集合中的一个元素。
• update(other)：将另一个集合的元素添加到当前集合中。

集合类型在Python中提供了一种高效的数据结构，用于存储和管理唯一元素的集合，同时支持丰富的集合运算，使得在处理某些问题时能够更加简洁和高效。

2.2.5字典（dict）

在Python中，字典（dict）是一种可变的数据结构，用于存储键值对（key-value pairs）。字典是一种映射类型，它允许我们使用键来存储和检索值。键必须是唯一的，而值则可以是任何数据类型，包括列表、元组、字典等复杂数据结构。

1.创建字典

字典使用花括号 {} 来表示，其中键和值之间用冒号 : 分隔，键值对之间用逗号 , 分隔。

# 创建一个空字典  
my_dict = {}  
  
# 创建一个包含键值对的字典  
my_dict = {  
    'name': 'Alice',  
    'age': 30,  
    'city': 'New York'  
}

2.访问字典元素

可以通过键来访问字典中的值。如果键存在于字典中，将返回相应的值；否则，会抛出 KeyError 异常。为了避免这种情况，你可以使用 get() 方法，它允许你指定一个默认值，在键不存在时返回这个默认值。

# 创建一个空字典
my_dict = {}

# 创建一个包含键值对的字典
my_dict = {
    'name': 'Alice',
    'age': 30,
    'city': 'New York'
}
# 访问字典中的值
print(my_dict['name'])  # 输出: Alice

# 使用get()方法访问字典中的值，避免KeyError
print(my_dict.get('name'))  # 输出: Alice
print(my_dict.get('address', 'No address provided'))  # 输出: No address provided

输出结果：

Alice
Alice
No address provided

3.修改字典

我们可以通过给键赋新值来修改字典中的元素。如果键不存在，它将被添加到字典中。

# 创建一个空字典
my_dict = {}

# 创建一个包含键值对的字典
my_dict = {
    'name': 'Alice',
    'age': 30,
    'city': 'New York'
}

# 修改字典中的值
my_dict['age'] = 31
print(my_dict)  # 输出: {'name': 'Alice', 'age': 31, 'city': 'New York'}

# 添加新的键值对
my_dict['job'] = 'Engineer'
print(my_dict)  # 输出: {'name': 'Alice', 'age': 31, 'city': 'New York', 'job': 'Engineer'}

输出结果：

{'name': 'Alice', 'age': 31, 'city': 'New York'}
{'name': 'Alice', 'age': 31, 'city': 'New York', 'job': 'Engineer'} 

4.删除字典元素

可以使用 del 语句或 pop() 方法来删除字典中的元素。

# 创建一个空字典
my_dict = {}

# 创建一个包含键值对的字典
my_dict = {
    'name': 'Alice',
    'age': 30,
    'city': 'New York'
}

# 使用del语句删除键值对
del my_dict['city']
print(my_dict)  # 输出: {'name': 'Alice', 'age': 31, 'job': 'Engineer'}

# 使用pop()方法删除键值对，并返回被删除的值
removed_value = my_dict.pop('age')
print(removed_value)  # 输出: 31
print(my_dict)  # 输出: {'name': 'Alice', 'job': 'Engineer'}

输出结果：

{'name': 'Alice', 'age': 30}
30
{'name': 'Alice'}

5.字典的遍历

你可以遍历字典的键、值或键值对。

# 创建一个空字典
my_dict = {}

# 创建一个包含键值对的字典
my_dict = {
    'name': 'Alice',
    'age': 30,
    'city': 'New York'
}

# 遍历字典的键
for key in my_dict:
    print(key)

# 遍历字典的值
for value in my_dict.values():
    print(value)

# 遍历字典的键值对
for key, value in my_dict.items():
    print(key, value)

输出结果：

name
age
city
Alice
30
New York
name Alice
age 30
city New York

6.字典的其他方法

字典还提供了其他一些有用的方法，例如：

• keys()：返回字典中所有的键。
• values()：返回字典中所有的值。
• items()：返回字典中所有的键值对。
• clear()：清空字典。
• update(other)：用另一个字典的键值对更新当前字典。
• copy()：返回字典的浅拷贝。

字典是Python中非常强大和灵活的数据结构，它允许我们以键为基础来组织和检索数据，使得代码更加清晰和易于维护。

2.2.6其他类型

Python是一种动态类型语言，除了前面提到的序列类型（列表、元组、字符串）、集合类型和字典类型外，还有一些其他的基本数据类型和特殊类型。下面是一些Python中的其他重要类型：

1.None类型

None类型有一个值：None。它表示一个空值或“无”的概念，常用于表示函数没有返回值或变量没有值的情况。

# None值  
n = None

2.类型对象

每个类型本身也是一个对象，它们都是type类型的实例。可以使用type()函数来获取一个对象的类型。

# 获取对象的类型
t = type(10)  # 输出: <class 'int'>
print(t)

输出结果：

<class 'int'>

3.自定义类型

通过定义类，你可以创建自定义类型。类的实例是对象，具有属性和方法。

# 定义一个简单的类
class Person:
    def __init__(self, name, age):
        self.name = name
        self.age = age

    def greet(self):
        print(f"Hello, my name is {self.name} and I am {self.age} years old.")

    # 创建类的实例（对象）

p = Person("Alice", 30)
p.greet()  # 输出: Hello, my name is Alice and I am 30 years old.

 输出结果：

Hello, my name is Alice and I am 30 years old.

4.动态类型

Python是一种动态类型语言，这意味着你不需要在声明变量时指定其类型。变量的类型可以在程序执行过程中改变。

# 动态改变变量类型
x = 10  # x是整数类型
x = "hello"  # 现在x是字符串类型
print(x)

输出结果：

hello

5.特殊方法/魔法方法

Python中的一些方法具有特殊的前缀和后缀，如__init__、__call__等，这些方法被称为特殊方法或魔法方法。它们允许你定义对象的特殊行为，比如对象的创建、调用、比较等。

这些是Python中的一些基本数据类型和其他类型的概述。Python的类型系统非常灵活和强大，它允许程序员以简洁和直观的方式编写代码，并处理各种复杂的数据结构和算法。