八大基本数据类型

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

【1】作用

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

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

【2】定义

# (1)整型 --  int
shuzi = 10

#查看内存地址
print(id(shuzi)) #2220708266512

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

# （3）使用场景
# 可以用来进行加减乘除的运算

# 【2】浮点数类型
# （1）用途
# 可以用来表示带小数的数值
# （2）语法
# 变量名 = 浮点数
 height = 175.00
print(type(height))  # <class 'float'>
# （3）场景
# 取款的时候你会发现取款金额和余额都不是整数
# 100.00

【二】字符串类型

【1】用途

# 用来标识文本信息

【2】语法

# 变量名 = 变量值(加引号 ，一个单引号，一个双引号，三个单引号，三个双引号)
name = "song"
print(name, type(name))  # dream <class 'str'>
name = 'song'
print(name, type(name))  # Dream <class 'str'>
name = '''song'''
print(name, type(name))  # Dream <class 'str'>
name = """song"""
print(name, type(name))  # Dream <class 'str'>

# 如果单双引号进行混用
name = "'name'"  # 双引号中混用的单引号
print(name, type(name))  # 'name' <class 'str'>
name = '"name"'  # 单引号中混用的双引号
print(name, type(name))  # "name" <class 'str'>
# 测试在双引号内存出现单独的单引号
name = "name'"
print(name, type(name))  # name' <class 'str'>
name = 'name"'
print(name, type(name))  # name" <class 'str'>

sentence = "my name is dream ,I'm 18 years old,hope you 'wonderful!'"

# 中间的 ' 产生了歧义 按照正常的字符串语法 单双引号应该成对出现
# 所以在单引号内部不能出现单独单引号，但是单引号内部可以出现单独的双引号
# sentence = 'my name is dream ,I'm 18 years old,hope you "wonderful!"'
#  所以在双引号内部不能出现单独双引号，但是双引号内部可以出现单独的单引号
# sentence = "my name is dream ,I"m 18 years old,hope you 'wonderful!'"

# 在三引号内部，如果第一行不写内容默认存在一个换行
sentence = '''my name is dream ,
I'm 18 years old,
hope you 'wonderful!'
'''
print(sentence, type(sentence))  # <class 'str'>

【3】使用方法

# （1）字符串加法
# 字符串可以通过加号 `+` 进行拼接
# 相加其实就是简单的字符串拼接
greeting = "Hello"
name = "Dream"
message = greeting + ", " + name + "!"

print(message)  # Hello, Dream!
# （2）相乘
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】字符串的格式化输出

# 变量可以用来存储值
# (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

# （2）f + {}
# myself_sentence = f"my name is {name},my age is {age}"
name = "Dream"
age = 18
print(f"My name is {name}; My age is {age}")
# My name is Dream; My age is 18

# （3）format输出语法
# 按照位置传值
# myself_sentence = "my name is {},my age is {}".format(name, age)
# 按照关键字传值
myself_sentence = "my age is {age},my name is {name}".format(name=name, age=age)
print(myself_sentence)
name = "Dream"
age = 18
print("My name is {}; My age is {}".format(name, age))
# My name is Dream; My age is 18
# \ 在python中输入数转移符号
# name = "dream \n"
name = "dream\\"  # dream\
print(name)
print(age)

【三】列表类型

【1】作用

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

【2】语法

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

【3】索引取值

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

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

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

【4】列表嵌套及嵌套取值

info_list = [
    "dream", ["15", ["上海"]]
]
# 如果想取到最后一层
print(info_list)  # ['dream', ['15', ['上海']]]
print(info_list[1])  # ['15', ['上海']]
print(info_list[1][1])  # ['上海']
print(info_list[1][1][0])  # 上海

print(f"以下是字典类型")

【四】字典类型

【1】作用

# 可以记录多个值，并且这些值带有各自及的名字
# 字典数据存储的方式 是  key:value

【2】语法

# 里面存的每一个值都是 key:value 的 kv键值对
infO_data = {
    "name": "dream",
    "age": 18,
    "hobby": ["music", "run", "make girlfriends"]
}

【3】取值

• 字典不支持索引取值

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

person_info = {'name': 'Dream', 'age': 18, 'height': 185.3, 'hobby': ["动漫", "小说"]}
# 字典取值(键取值)
name = person_info['name']
print(name)  # 输出结果：Dream

age = person_info['age']
print(age)  # 输出结果：18
# .get(键)取值
print(infO_data.get("name"))  # dream
# .get(key) 取值，如果字典中不存在键对应的值不会报错，而是反悔了一个 None
print(infO_data.get("addr"), type(infO_data.get("addr")))  # None <class 'NoneType'>

（2）字典嵌套及取值

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

# 格式化输出
# sentence = "my name is name ,my age is age ,my id is id ,my location is location , my hobby is music-read-study"
d1 = info['name']
d2 = info['addr']['info'][1]['age']
d3 = info['addr']['info'][3]['编号']
d4 = info['addr']['国家']
d5 = info['addr']['info'][3]['hobby']
d6 = d5[0]
d7 = d5[1]
d8 = d5[2]

print(f"my name is {d1},my age is {d2},my id is {d3},my location is {d4},my hobby is {d6} {d7} {d8}")

【五】布尔类型

【1】作用

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

【2】定义

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

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

(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

【3】python中的真与假

# 哪些情况是真？
# 数字 1 为真 非空列表、非空字典、非空集合等
# 非零数字 非空字符串
# 不存在的情况：空值为假,空的字符串、空的列表、空的字典、空的元组、数字 0
name = ""
name = []
name = {}
name = 2
# name = False
print(bool(name))  # False
name = "11"
print(bool(name))

【六】元组类型

【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 = (1, 'hello', 3.14, True)
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)

（2）解包

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

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

print(a)  # 1
print(b)  # 'hello'
print(c)  # 3.14
print(d)  # True
# name = 'dream'
# age = 18
# print("my name is %s my age is %d" % (name, age))
# 特别注意：元组中有一个元素的时候一定要加 ,
name = ("dream")
print(name, type(name))  # dream <class 'str'>
name = ("dream",)
print(name, type(name))  # ('dream',) <class 'tuple'>
# 字符串类型
name_tuple = ('dream')
# 字符类型 + , ----> 元组类型
name_tuple = ('dream',)
name_tuple = ('dream', 18)
print(name_tuple)
print(type(name_tuple))

# 字符串定义的时候 后面不要 + ,
name_one = 'dream', 

print(name_one)
print(type(name_one))

【七】集合类型

# 集合 ： 无序且去重 在集合里面看不到重复的元素
# {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'}