【6.0】Python基础之基本数据类型

【一】基本数据类型引入

【1】学习变量的目的

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

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

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

【3】基本数据类型介绍

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

【4】小结

• 我们学习变量是为了让计算机能够像人一样去记忆事物的某种状态，而变量的值就是用来存储事物状态的，很明显事物的状态分成不同种类的（比如人的年龄，身高，职位，工资等等）
• 所以变量值也应该有不同的类型

# 用一个变量 name 保存名字 叫 Dream
name = 'Dream'
print(type(name)) # <class 'str'>

# 用一个变量 sex 保存性别 是 男
sex = '男'
print(type(sex)) # <class 'str'>

# 用一个变量 age 保存年龄 是 18
age = 18
print(type(age)) # <class 'int'>

# 用一个变量 age 保存薪资 是 22800.21
salary = 22800.21
print(type(salary)) # <class 'float'>

【二】数字类型(int/float)

【1】整数类型(int)

（1）作用

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

（2）定义

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

num1 = 10
num2 = -5

（3）使用

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

【2】浮点类型(float)

（1）作用

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

（2）定义

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

float1 = 3.14
float2 = -0.5

（3）使用

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

【3】数字类型的应用

（1）数字运算

• 整数和浮点数可以进行常见的数学运算，包括加法、减法、乘法、除法等。

a = 10
b = 3.5
result = a + b

# 结果为浮点数 13.5
print(result)  # 13.5
print(type(result))  # <class 'float'>

（2）比较大小

• 我们可以使用比较运算符（如<、>、<=、>=）来比较数字的大小，得到布尔类型的结果

a = 5
b = 2
compare_result = a > b

# 结果为True
print(compare_result)  # True
print(type(compare_result))  # <class 'bool'>

【三】字符串类型(str)

【1】作用

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

【2】定义

（1）定义方式

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

# 定义方式1：
name_1 = 'Dream'  # (当左边有赋值符号和遍历名的时候，它就是字符串)
# 定义方式2：
name_2 = "Dream"  # (当左边有赋值符号和遍历名的时候，它就是字符串)
# 定义方式3：
name_3 = '''Dream'''  # (当左边有赋值符号和遍历名的时候，它就是字符串)
# 定义方式4：
name_4 = """Dream"""  # (当左边有赋值符号和遍历名的时候，它就是字符串)

• 用引号引起来的部分就是对应变量的值(字符串类型)，并且对于变量名的值
  • 用单引号、双引号、多引号，都可以定义字符串
  • 本质上是没有区别的(这些引号定义字符串的方式是等价的)

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

# 正确示范一：双引号内部，可以使用单引号,并且可以使用多个单引号
msg_1 = "My name is Dream , I'm 18 years old!,hope your life : 'wonderful!'"

# 正确示范二：单引号内部，可以使用双引号,但是只支持双引号，不支持单个的单引号
msg_2 = 'My name is Dream , I am 18 years old!,hope your life : "wonderful!"'

# 错误示范: 单引号内部，嵌套了单引号，会导致语法错误 ---- End of statement expected
msg_3 = 'My name is Dream , I'm 18 years old!,hope your life : "wonderful!"'

• 引号的嵌套需要注意，外层是单引号时，内层应使用双引号，反之亦然。
• 如果需要在字符串中包含引号，可以灵活运用不同类型的引号

（3）多行字符串

• 通过三引号（单引号或双引号）可以定义多行字符串，方便表示包含换行的文本内容

# 三引号内部支持多行文本
msg_1 = '''         
	天下只有两种人。比如一串葡萄到手，一种人挑最好的先吃，另一种人把最好的留到最后吃。
    照例第一种人应该乐观，因为他每吃一颗都是吃剩的葡萄里最好的；
    第二种人应该悲观，因为他每吃一颗都是吃剩的葡萄里最坏的。 
    不过事实却适得其反，缘故是第二种人还有希望，第一种人只有回忆。 
'''

msg_2 = """
	天下只有两种人。比如一串葡萄到手，一种人挑最好的先吃，另一种人把最好的留到最后吃。
    照例第一种人应该乐观，因为他每吃一颗都是吃剩的葡萄里最好的；
    第二种人应该悲观，因为他每吃一颗都是吃剩的葡萄里最坏的。 
    不过事实却适得其反，缘故是第二种人还有希望，第一种人只有回忆。 
"""

【3】使用

• 数字可以进行加减乘除等运算
• 字符串呢？也可以，但只能进行"相加"和"相乘"运算。

（1）相加

• 字符串可以通过加号 + 进行拼接
• 相加其实就是简单的字符串拼接

greeting = "Hello"
name = "Dream"
message = greeting + ", " + name + "!"

print(message)  # Hello, Dream!

（2）相乘

• 字符串可以通过乘号 * 进行重复
• 相乘就相当于将字符串相加了5次

divider = "-" * 20

print(divider) # --------------------

（3）索引取值

• 字符串属于序列类型，所谓序列，指的是一块可存放多个值的连续内存空间，这些值按一定顺序排列，可通过每个值所在位置的编号（称为索引）访问它们。

msg = 'Hello World'

print(len(msg))  # 11
# 取索引为 0 的位置的元素
print(msg[0])  # H
# 取索引位置为 10 的元素 （上面打印的长度为11，但是我们是从 0 开始计数的，所以是 11-1=10）
print(msg[10])  # d

• Python 还支持索引值是负数，此类索引是从右向左计数，换句话说，从最后一个元素开始计数，从索引值 -1 开始，如图 所示。

msg = 'Hello World'

print(len(msg))  # 11
# 取索引为 -1 的位置的元素
print(msg[-1])  # d
# 取索引位置为 -11 的元素 （上面打印的长度为11，但是我们是从 -1 开始计数的，所以是 -11）
print(msg[-11])  # H

（4）格式化输出

• 之前讲到过 print() 函数的用法，这只是最简单最初级的形式，print() 还有很多高级的玩法，比如格式化输出。

[1] % 输出

• 使用 % 运算符进行格式化输出，可以在字符串中插入占位符，然后通过 % 运算符传入相应的值。

# 格式化输出语法一 ： %
name = "Dream"
age = 18
height = 175.5

# 使用 %s 占位符，输出字符串
print("My name is %s." % name)  
# My name is Dream.

# 使用 %d 占位符，输出整数
print("My age is %d." % age)  
# My age is 18.

# 使用 %f 占位符，输出浮点数，默认保留六位小数
print("My height is %f." % height)  
# My height is 175.500000.

# 使用 %.2f 占位符，保留两位小数
print("My height is %.2f." % height)  
# My height is 175.50.

# 使用 %x 占位符，输出十六进制整数
number = 255
print("Number in hex: %x." % number)  
# Number in hex: ff.

# 两个以上的占位符格式化输出
print("My name is %s; My age is %d" % (name, age)) 
# My name is Dream; My age is 18

• 在上例中，%s 和 %d 是占位符，分别表示字符串和整数，而 (name, age) 是传入这两个占位符的实际值。
• 占位符类型
  • %s：字符串
  • %d：整数
  • %f：浮点数
  • %x：十六进制整数

[2] formate 输出

• 使用 format 方法进行格式化输出，通过花括号 {} 表示占位符，然后调用 format 方法传入实际值

name = "Dream"
age = 18
# 格式化输出语法三 ： formate
print("My name is {}; My age is {}".format(name, age))
# My name is Dream; My age is 18

• 在这个例子中，{} 是占位符，它会按顺序依次填充传入 format 方法的值

[3] f + {} 输出

• 使用 f-string（f + {}）进行格式化输出，通过在字符串前加上 f 或 F 前缀，然后在字符串中使用 {} 表示占位符，并在 {} 中直接引用变量。

name = "Dream"
age = 18
# 格式化输出语法二 ： f + {}
print(f"My name is {name}; My age is {age}")
# My name is Dream; My age is 18

（5）字符串的转义

• 在字符串中，转义字符用于表示一些特殊字符或执行一些特殊操作，常用的转义字符如下：

转义字符	说明
\n	换行符，将光标位置移到下一行开头。
\r	回车符，将光标位置移到本行开头。
\t	水平制表符，也即 Tab 键，一般相当于四个空格。
\a	蜂鸣器响铃。注意不是喇叭发声，现在的计算机很多都不带蜂鸣器了，所以响铃不一定有效。
\b	退格（Backspace），将光标位置移到前一列。
\	反斜线
'	单引号
"	双引号
\	在字符串行尾的续行符，即一行未完，转到下一行继续写。

# 换行符
print("Hello\nWorld")
# Hello
# World

# 制表符
print("Name\tAge")
# Name    Age

# 反斜线
print("This is a backslash: \\")
# This is a backslash: \

# 单引号
print("I'm a programmer.")
# I'm a programmer.

# 双引号
print("He said, \"Hello.\"")
# He said, "Hello."

# 回车符与退格符
print("One\rTwo\bThree")
# Two Three

【四】列表类型(list)

【1】作用

• 用来存取多个相同属性的值，并且方便存取
• 如果我们需要用一个变量记录多个学生的姓名，用数字类型是无法实现，字符串类型则可以记录下来

【2】定义

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

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

【3】使用

（1）索引取值

• 列表类型是用索引来对应值，索引代表的是数据的位置，从0开始计数

# 列表类型
names_list = ['张三', '李四', '王五']

# 索引取值
first_student = names_list[0]
print(first_student)  # 输出结果：张三

second_student = names_list[1]
print(second_student)  # 输出结果：李四

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

• 列表可以嵌套在其他列表中，形成二维或多维数组，通过嵌套的方式可以方便地处理复杂的数据结构。

# 列表嵌套
class1 = ['张三', '李四', '王五']
class2 = ['Tom', 'Jerry', 'Spike']
classes = [class1, class2]

# 嵌套取值
student_1_class_1 = classes[0][0]
print(student_1_class_1)  # 输出结果：张三

student_2_class_2 = classes[1][1]
print(student_2_class_2)  # 输出结果：Jerry

【五】字典类型(dict)

【1】作用

• 如果我们需要用一个变量记录多个值，但多个值是不同属性的
  • 比如人的姓名、年龄、身高，用列表可以存，但列表是用索引对应值的，而索引不能明确地表示值的含义
• 这就用到字典类型，字典类型是用key：value形式来存储数据
  • 其中key可以对value有描述性的功能，能够明确的描述详细信息

【2】定义

• 大括号括起来，内部可以存放多个元素，元素与元素之间使用逗号隔开，是以K:V键值对的形式存储
  • K:
    • 是对V的描述性信息（一般情况是字符串）
  • V:
    • 真正的数据，其实相当于变量值,也是任意的数据类型

person_info = {'name': 'Dream', 'age': 18, 'height': 185.3, 'hobby': ["动漫", "小说"]}
print(person_info)  # {'name': 'Dream', 'age': 18, 'height': 185.3, 'hobby': ['动漫', '小说']}
print(type(person_info))  # <class 'dict'>

【3】使用

（1）字典取值(键取值)

• 字典不能通过索引取值，只能通过字典的K取值

person_info = {'name': 'Dream', 'age': 18, 'height': 185.3, 'hobby': ["动漫", "小说"]}

# 字典取值(键取值)
name = person_info['name']
print(name)  # 输出结果：Dream

age = person_info['age']
print(age)  # 输出结果：18

（2）字典嵌套及取值

# 字典嵌套及取值
student1 = {'name': 'Tom', 'age': 18}
student2 = {'name': 'Jerry', 'age': 19}
classroom = {'student1': student1, 'student2': student2}

# 取值
student1_name = classroom['student1']['name']
print(student1_name)  # 输出结果：Tom

student2_age = classroom['student2']['age']
print(student2_age)  # 输出结果：19

info = {
    'name': 'Dream',
    'addr': {
        '国家': '中国',
        'info': [666, 999, {'编号': 466722, 'hobby': ['read', 'study', 'music']}]
    }
}

# 1. music在大字典里的位置
d1 = info['addr']  
print(d1)
# {'国家': '中国', 'info': [666, 999, {'编号': 466722, 'hobby': ['read', 'study', 'music']}]}

# 2. music在小字典里的位置
d2 = d1['info']  
print(d2)
# [666, 999, {'编号': 466722, 'hobby': ['read', 'study', 'music']}]

# 3. music在列表里的位置
d3 = d2[2]  
print(d3)
# {'编号': 466722, 'hobby': ['read', 'study', 'music']}

# 4. music在小字典里的位置
d4 = d3['hobby']  
print(d4)
# ['read', 'study', 'music']

# 5. music在列表里的位置
d5 = d4[2]  
print(d5)
# music

# 整合
d6 = info['addr']['info'][2]['hobby'][2]
print(d6)
# music

【六】布尔类型(bool)

【1】作用

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

【2】定义

• 布尔类型只有两个取值：True 和 False。在 Python 中，首字母必须大写
• 布尔值的命名规范：结果可能是布尔值的情况，我们都采用 is 开头 命名

# 定义布尔类型
is_student = True
is_adult = False

【3】使用

（1）条件判断

• 布尔类型常常用于条件判断，例如 if 语句中

# 使用布尔类型进行条件判断
is_raining = True

if is_raining:
    print("Remember to bring an umbrella!")
else:
    print("Enjoy the weather!")

（2）比较运算

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

# 使用布尔类型进行比较运算
x = 5
y = 10

is_greater = x > y
print(is_greater)  # 输出结果：False

【补充】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, True)

# 访问元组元素
first_element = my_tuple[0]
second_element = my_tuple[1]

print(first_element)  # 1
print(second_element)  # 'hello'

【3】使用

（1）元组的不可变性

• 由于元组是不可变的，不能对元素进行修改、删除或添加。

# 尝试修改元组的元素（会报错）
my_tuple[0] = 42  # TypeError: 'tuple' object does not support item assignment

# 尝试删除元组的元素（会报错）
del my_tuple[1]  # TypeError: 'tuple' object doesn't support item deletion

# 尝试添加元素到元组（会报错）
my_tuple.append('new_element')  # AttributeError: 'tuple' object has no attribute 'append'

（2）元组的基本操作

• 元组支持基本的操作，如切片、拼接等。

# 切片操作
sliced_tuple = my_tuple[1:3]
print(sliced_tuple)  # ('hello', 3.14)

# 拼接操作
new_tuple = my_tuple + ('world', False)
print(new_tuple)  # (1, 'hello', 3.14, True, 'world', False)

（3）元组解包

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

# 元组解包
a, b, c, d = my_tuple

print(a)  # 1
print(b)  # 'hello'
print(c)  # 3.14
print(d)  # True

（4）元组的应用场景

• 用于函数返回多个值
• 保持数据的不可变性，适用于一些常量集合的场景
• 元组作为字典的键（因为元组是不可变的）

# 函数返回多个值
def get_coordinates():
    return 10, 20, 30

x, y, z = get_coordinates()
print(x, y, z)  # 10 20 30

# 元组作为字典的键
coordinates_dict = {(1, 2, 3): 'Point A', (4, 5, 6): 'Point B'}
print(coordinates_dict[(1, 2, 3)])  # Point A

• 元组是一个灵活且强大的数据类型，适用于许多场景，特别是需要不可变性的情况。

【八】集合类型(set)

【1】作用

• 集合（set）是一种无序、不重复的数据类型，用于存储多个独立的元素。
• 集合通常用于去除重复元素，执行集合运算（如并集、交集、差集等），以及检查成员资格。

【2】定义

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

# 定义集合
my_set = {1, 2, 3, 4, 5}

# 使用构造函数创建集合
another_set = set([3, 4, 5, 6, 7])

【3】使用

（1）集合的基本操作

• 集合支持基本的操作，如添加元素、删除元素、成员测试等。

# 添加元素
my_set.add(6)

# 删除元素
my_set.remove(3)

# 成员测试
is_member = 2 in my_set

（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}

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