04基本数据类型

【一】数字类型（int/float）

（1）作用

• 整数类型用于表示整数，是一种基本的数字类型，广泛用于表示计数、索引等整数值。
• 浮点类型用于表示带有小数部分的数值，适用于需要更精确表示的情况。

（2）定义

# 【1】整型 -- int
number = 18

# 查看内存地址
print(id(number))  # 140728323794248

# 查看变量类型
print(type(number))  # <class 'int'>

# 查看变量值
print(number)  # 18

# 【2】浮点型 -- float

number_float = 18.0
print(number_float)  # 18.0
print(type(number_float))  # <class 'float'>

# 【3】运算
x = 4.0
y = 2.0

print(x + y)
print(x - y)
print(x * y)
print(x / y)  # 斜杠 ： \  反斜杠 ： /

【二】字符串类型(string)

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

【4】使用

• 数字可以进行加减乘除等运算

（1）相加

• 字符串可以通过加号 + 进行拼接

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

print(message)  # Hello, Dream!

（2）相乘

• 字符串可以通过乘号 * 进行重复

divider = "-" * 20

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

（3）索引取值

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

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

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

msg = 'Hello World'

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

【5】格式化输出

【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】format输出

• 使用 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

【三】列表类型（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）

• 布尔值为Ture: 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】用来存储不变的元素
name = ["dream"]
name[0] = "hope"
print(name)

# 特别注意：元组中有一个元素的时候一定要加 ,
name = ("dream")
print(name, type(name))  # dream <class 'str'>
name = ("dream",)
print(name, type(name))  # ('dream',) <class 'tuple'>
# name[0] = "hope"
# print(name)

# 元组的解包 ； 解压赋值
info = ("dream", 18)
print(info[0])
print(info[1])
name, age = ("dream", 18)
print(name)
print(age)

【七】集合类型（set）

# 集合 ： 无序且去重 在集合里面看不到重复的元素
# {key:value} : 字典
# {key} : 集合

num = {1, 2, 3, 4, 5, 5, 5, 5, 5, 5}
print(num, type(num))

# 集合类型中不能存放的元素类型是 字典和列表 ： 因字典和列表是可变数据类型不能被 hash
num = {1, 2, 3, 'name', 'dream', 4, 1.11, 5, 5, 5, 5, 5, 5}
print(num)
# {1, 2, 3, 4, 1.11, 5, 'dream', 'name'}
# {1, 'name', 3, 2, 4, 1.11, 5, 'dream'}
# {'name', 2, 3, 4, 1, 1.11, 5, 'dream'}