基本数据类型

数据类型

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

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

【1】整数类型(int)

(1) 作用

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

(2) 定义

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

num1 = 10
num2 = -5

(3) 使用

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

  a = 10  
  b = 5  
    
  # 加法  
  c = a + b  
  print(c)  # 输出：15  
    
  # 减法  
  c = a - b  
  print(c)  # 输出：5  
    
  # 乘法  
  c = a * b  
  print(c)  # 输出：50  
    
  # 除法  
  c = a / b  
  print(c)  # 输出：2.0（这是浮点数结果，即使除数是整数）  
    
  # 取余操作  
  c = a % b  
  print(c)  # 输出：0（因为10除以5的余数是0）
  

【2】浮点类型(float)

（1）作用

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

（2）定义

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

float1 = 3.14
float2 = -0.5

（3）使用

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

【二】字符串类型(str)

(1) 作用

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

(2) 定义

#支持单引号、双引号、三引号进行定义
name = 'Dream'
name_1 = "Dream"
name_2 = """Dream"""
name_3 = '''Dream'''

# 正确示范一：双引号内部，可以使用单引号,并且可以使用多个单引号
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!"'

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

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

(3) 使用

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

#相加
greeting = "Hello"
name = "Dream"
message = greeting + ", " + name + "!"

print(message)  # Hello, Dream!
#相乘
字符串可以通过乘号 * 进行重复
相乘就相当于将字符串相加了5次
divider = "-" * 20

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

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

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

msg = 'Hello World'

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

(4) 格式化输出

# 格式化输出语法一 ： %
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}
集合类型是一种灵活且强大的数据类型，特别适用于需要执行集合运算、去除重复元素的场景。

__EOF__

本文作者：Fredette
本文链接：https://www.cnblogs.com/Fredette/p/17859447.html
关于博主：评论和私信会在第一时间回复。或者直接私信我。
版权声明：本博客所有文章除特别声明外，均采用 BY-NC-SA 许可协议。转载请注明出处！
声援博主：如果您觉得文章对您有帮助，可以点击文章右下角【推荐】一下。您的鼓励是博主的最大动力！