基本数据类型

【一】基本数据类型引入

【1】学习变量的目的

• 学习变量有助于我们在程序中存储和操作数据，提高代码的灵活性和可维护性。
• 通过使用变量，我们可以方便地引用和修改数据，使得程序能够动态地响应不同的输入和条件。

【2】学习基本数据类型的目的

• 学习基本数据类型有助于我们理解不同类型的数据在计算机中的表示和操作方式。
• 不同的数据类型适用于不同的场景，了解它们的特性有助于我们编写更加高效和健壮的代码。

【3】基本数据类型介绍

• 数字类型
  • 整数类型(int)
  • 浮点类型(float)
• 字符串类型(str)
• 列表类型(list)
• 字典类型(dict)
• 布尔类型(bool)
• 元祖类型(tuple)
• 集合类型(set)

【4】小结

• 在学习Python的基本数据类型中，我们不仅学会了如何存储和操作数据以提高代码的灵活性和可维护性，而且理解了不同数据类型在计算机中的表示和操作方式。这些包括数值型的整数和浮点数，用于文本的字符串，以及组织数据的列表、字典、布尔值、元组和集合。掌握这些类型有助于我们编写更高效、健壮的代码，应对不同的编程场景。

【二】数字类型

【1】整数类型（int）

（1）作用

• 整数类型用于表示整数，是一种基本的数字类型，广泛用于表示计数,索引等数值

（2）定义

• 在Python中，整数类型的定义是直接赋予一个整数值

name1 = 100
name2 = 200

（3）使用

• 整数类型可以参与各种数学运算，包括加减乘除等

【2】浮点类型（float）

（1）作用

• 浮点类型用于表示小数部分的数值，适用于需要更精确的表示情况。

（2）定义

• 浮点类型的定义是通过数字后面添加小数点

float1 = 1.01
float2 = 2.02

（3）使用

• 浮点类型同样可以参与各种数学运算，也可以与整数进行混合运算。

【三】字符串类型（str）

【1】作用

• 字符串类型用于表示文本信息，是一种非常重要的数据类型，用于处理文字，字符等信息。

【2】定义

（1）定义方式

• 字符串可以用单引号，双引号，或者三引号进行定义

  • 单引号: name1 = 'Hello'

  • 双引号: name2 = "Hello"

  • 三单引号: name3 = '''Hello'''

  • 三双引号: name4 = """Hello"""

（2）引号嵌套的配对问题

sentence1 = "She said, 'Hello!'"
sentence2 = 'She said, "Hello!"'
# 错误的语法
sentence3 = 'She said, 'Hello!''

（3）多行字符串

multi_line_string = """这是一个
多行字符串示例
包含多行文本!"""

【3】使用

• 数字可以进行加减乘除等运算
• 但是字符串只能进行加 乘 操作
• 索引取值

（1）相加

• 字符串相加就是用+将两个字符串进行拼接

greeting = "Hello"
name = "Alice"
message = greeting + ", " + name + "!"
print(message)  # 输出：Hello, Alice!

（2）相乘

• 字符串相乘，就是通过*进行重复拼接

divider = "-" * 20
print(divider)  # 输出：--------------------

• 注意的是两个字符串不能进行相乘，在Python中，字符串相乘的操作是指将一个字符串重复多次，而这个操作需要一个字符串和一个整数（表示重复的次数）。两个字符串之间不能进行相乘操作，尝试这样做会导致类型错误。

（3）索引取值

• 字符串属于序列类型，所谓序列，指的是一块可以存放多个值的连续内存空间，这些值按照一定排序顺序，可通过每个值所在的为之编号访问他们

message = "Hello, World!"

# 访问第一个字符（H）
first_char = message[0]

# 访问最后一个字符（!）
last_char = message[-1]

print("First character:", first_char)  # 输出: H
print("Last character:", last_char)  # 输出: !

（4）格式化输出

• 在Python中，使用f-string是一种常见的格式化输出字符串的方法。

name = "Alice"
age = 25
greeting = f"Hello, my name is {name} and I am {age} years old."
print(greeting)

• 这将输出："Hello, my name is Alice and I am 25 years old." 使用f-string, 可以直接在字符串中插入变量。

【四】列表类型

【1】作用

• 用来存取多个相同属性的值，并且方便存取
• 如果我们需要用一个变量记录多个学生的姓名，列表就很方便记录

【2】定义

# 字符串类型
stu_names=’张三 李四 王五’
# 列表类型
names_list = ['张三', '李四', '王五']

• 存的目的是为了取，此时若想取出第二个学生的姓名实现起来相当麻烦
• 而列表类型就是专门用来记录多个同种属性的值（比如同一个班级多个学生的姓名、同一个人的多个爱好等），并且存取都十分方便

【3】使用

（1）索引取值

• 列表类型使用索引来去对应的值，索从0开始

colors = ["红色", "绿色", "蓝色"]

# 访问第一个元素 '红色'
first_color = colors[0]

# 访问第二个元素 '绿色'
second_color = colors[1]

print("第一个颜色是", first_color)  # 输出: 第一个颜色是 红色
print("第二个颜色是", second_color)  # 输出: 第二个颜色是 绿色

（2）列表嵌套及嵌套取值

• 列表可以嵌套在其他列表之中，形成二维或者多维列表。

# 二维列表
matrix = [[1, 2, 3], [4, 5, 6], [7, 8, 9]]

# 访问第一行的第一个元素
print(matrix[0][0])  # 输出: 1

# 访问第二行的第二个元素
print(matrix[1][1])  # 输出: 5

【五】字典类型

【1】作用

• 如果我们需要用一个变量记多个值，但多个值是不同的属性
  • 比如人的姓名，性别，年龄，身高，爱好，可以用列表存，
  • 而索引不能明确的表示值的含义
• 这就用到了字典类型，字典使用键值对来表示的

person = {
    "name": "Alice",
    "gender": "Female",
    "age": 30,
    "height": "5ft 5in",
    "hobbies": ["Reading", "Hiking", "Painting"]
}

# 访问姓名
print(person["name"])  # 输出: Alice

• 在这个例子中，name, gender, age, height, 和 hobbies 是键，对应的个人信息则是它们的值。

【2】定义

• 用大括号括起来，用':'来分开键值对，多个键值对之间用逗号隔开

my_dict = {
    "key1": "value1",
    "key2": "value2",
    "key3": "value3"
}

【3】使用

(1)字典取值

• 字典不能用索引取值，只能通过字典的键来取值

person = {"name": "Alice", "age": 25, "city": "New York"}

# 通过键 'name' 来访问值 'Alice'
print(person["name"])  # 输出: Alice

# 通过键 'age' 来访问值 25
print(person["age"])  # 输出: 25

（2）字典嵌套取值

student = {
    "info": {
        "name": "Alice",
        "age": 22
    },
    "grades": {
        "math": 90,
        "science": 95
    }
}

# 获取学生的姓名
name = student["info"]["name"]
print(name)  # 输出: Alice

# 获取学生的数学成绩
math_grade = student["grades"]["math"]
print(math_grade)  # 输出: 90

（3）有则修改无则添加

my_dict = {"name": "Alice", "age": 25}

# 修改现有键 'age'
my_dict["age"] = 26

# 添加新的键 'city'，因为它之前不存在
my_dict["city"] = "New York"

print(my_dict)  # 输出: {'name': 'Alice', 'age': 26, 'city': 'New York'}

【六】布尔类型（bool）

【1】作用

• 布尔类型用于表示逻辑值，只有False 和 True俩个值
• 在编程中，布尔类型经常用于控制流程的程序，例如条件判断，循环等

【2】定义

• 布尔在Python中首字母必须大写
• 布尔值的命名规范：结果可能是布尔值的情况，我们都采用is_开头命名

is_adult = True
is_empty = False

【3】使用

（1）条件判断

• 布尔类型经常运用条件语句判断，比如if语句

is_raining = True

if is_raining:
    print("记得带伞!")
else:
    print("今天天气不错!")

（2）比较运算

• 布尔类型还可以用于表达式的判断，比如比较运算

a = 10
b = 20

is_a_greater_than_b = a > b  # False, 因为10不大于20
is_a_less_than_b = a < b    # True, 因为10小于20

print(is_a_greater_than_b)  # 输出: False
print(is_a_less_than_b)     # 输出: True

【补充】Python中的真与假

• 在 Python 中，布尔类型的 True 表示真，False 表示假。
• 在条件判断和逻辑运算中，通常会使用布尔值来确定程序的执行流程。

（1）假的情况（False）

• 布尔值为 False： 显而易见，False 本身就表示假。

is_false = False
if is_false:
    print("This won't be executed.")
else:
    print("This will be executed.")

• 数字零： 数字类型中，整数或浮点数中的零被视为假。

zero_integer = 0
zero_float = 0.0

if zero_integer or zero_float:
    print("This won't be executed.")
else:
    print("This will be executed.")

• 空字符串： 空字符串 '' 被视为假。

empty_string = ''

if empty_string:
    print("This won't be executed.")
else:
    print("This will be executed.")

• 空列表、空字典、空集合等： 对于容器类型，如果它们为空，被视为假。

empty_list = []
empty_dict = {}
empty_set = set()

if empty_list or empty_dict or empty_set:
    print("This won't be executed.")
else:
    print("This will be executed.")

（2）真的情况（True）

• 布尔值为 True： True 本身表示真。

is_true = True
if is_true:
    print("This will be executed.")
else:
    print("This won't be executed.")

• 非零数字： 除了零之外的任何整数或浮点数都被视为真。

non_zero_integer = 42
non_zero_float = 3.14

if non_zero_integer and non_zero_float:
    print("This will be executed.")
else:
    print("This won't be executed.")

• 非空字符串： 非空字符串被视为真。

non_empty_string = 'Hello, World!'

if non_empty_string:
    print("This will be executed.")
else:
    print("This won't be executed.")

• 非空列表、非空字典、非空集合等： 如果容器类型中包含元素，被视为真。

non_empty_list = [1, 2, 3]
non_empty_dict = {'key': 'value'}
non_empty_set = {1, 2, 3}

if non_empty_list and non_empty_dict and non_empty_set:
    print("This will be executed.")
else:
    print("This won't be executed.")

【七】元组类型（tuple）

【1】作用

• 元组（tuple）是一种不可变的序列类型，类似于列表，用于存储多个有哦需元素。
• 元组与列表的主要区别在于元组的元素不能被修改，是不可表数据类型
• 元组通常用于存储相关联的数据，保存数据的完整性

【2】定义

• 元组通过小括号 () 定义，其中的元素可以是不同的数据类型，用逗号 , 分隔。
• 可以使用索引访问元组的元素。

my_tuple = (1, "Hello", 3.14)
print(my_tuple[0])  # 输出: 1
print(my_tuple[1])  # 输出: Hello

【3】使用

（1）元组的不可变性

my_tuple = (1, 2, 3)
my_tuple[0] = 4  # 尝试修改元组会导致TypeError

• 如果元组包含可变数据类型，如列表，那么这个可变对象内部的内容是可以被修改的，但是元组本身所指向的对象（即列表的引用）不可变。例如：

my_tuple = (1, 2, [3, 4])

# 不能改变元组的元素（即不能更改元组的结构，比如添加或删除元素）
# my_tuple[0] = 100  # 错误!

# 可以修改元组内部的列表元素
my_tuple[2][0] = 300  # 正确!
print(my_tuple)  # 输出: (1, 2, [300, 4])

• 当修改元组内的可变元素（如列表）时，元组的内存地址保持不变。例如：

my_tuple = (1, 2, [3, 4])
print("原始地址:", id(my_tuple))

# 修改列表元素
my_tuple[2][0] = 300
print("修改后的地址:", id(my_tuple))

（2）元组的基本操作

• 元组支持的基本操作，如切片，拼接等,例如，可以通过切片获取元组的一部分，或者将两个元组拼接成一个新的元组。尽管元组本身是不可变的，这些操作会产生一个新的元组对象，而不是修改原来的元组。

tuple1 = (1, 2, 3)
tuple2 = (4, 5, 6)

# 切片操作
slice_of_tuple1 = tuple1[1:3]  # 结果为(2, 3)

# 拼接操作
concatenated_tuple = tuple1 + tuple2  # 结果为(1, 2, 3, 4, 5, 6)

（3）元组解包

• 元组解包是一种将元组中的元素分配给多个变量的方法。

my_tuple = (1, "Hello", 3.14)
a, b, c = my_tuple  # a = 1, b = "Hello", c = 3.14

（4）元组的应用场景

• 用于函数返回多个值
• 元组作为字典的键

def min_max(numbers):
    return min(numbers), max(numbers)  # 返回一个元组

min_val, max_val = min_max([1, 2, 3, 4, 5])  # 元组解包


coordinates = {(0, 0): "origin", (1, 1): "point1"}

【八】集合类型

【1】作用

• 集合是一种无需，不重复的数据类型，用于存储索格独立的元素
• 集合通常用于去除重复元素，执行集合运算（如并集，交集，差集）

【2】定义

• 集合通过大括号{}定义，其中的元素是不可重复的，可以包含不同的数据类型
• 可以使用set()构造函数来创建集合

my_set = {1, 2, 3, "hello"}
my_list = [1, 2, 3, 3]
my_set = set(my_list)  # {1, 2, 3}

（2）集合运算

• 集合支持多种集合运算，如并集、交集、差集等。

set_a = {1, 2, 3, 4}
set_b = {3, 4, 5, 6}

# 并集
union_set = set_a.union(set_b)

# 交集
intersection_set = set_a.intersection(set_b)

# 差集
difference_set = set_a.difference(set_b)

（3）集合的不可重复性

• 集合中的元素是不可重复的，即相同的元素不会重复存储。

unique_set = {1, 2, 3, 1, 2, 4, 5}
print(unique_set)  # {1, 2, 3, 4, 5}

• 集合类型是一种灵活且强大的数据类型，特别适用于需要执行集合运算、去除重复元素的场景。