人工智能之编程基础 Python 入门

第五章 基础数据类型（一）

前言

本章节讲述python的基础数据类型，python的基础数据类型主要包括以下

• •  不可变数据（3 个）：Number（数字）、String（字符串）、Tuple（元组）；
• •  可变数据（3 个）：List（列表）、Dictionary（字典）、Set（集合）。

Number（数字）

number（数字）类型用于表示数值数据。Python 提供了多种内置的数字类型，主要包括：

1. 整数 ( int)

int 类型用于表示整数，可以是正数、负数或零。Python 3 的  int 类型没有大小限制（仅受限于可用内存），因此可以处理非常大的整数。

特点：

• • 无大小限制
• • 可以用十进制、二进制、八进制或十六进制表示

示例：

# 十进制

x = 
42

y = -
17

z = 
0




# 二进制 (以 0b 或 0B 开头)

binary_num = 
0b1010  
# 等于十进制的 10




# 八进制 (以 0o 或 0O 开头)

octal_num = 
0o17     
# 等于十进制的 15




# 十六进制 (以 0x 或 0X 开头)

hex_num = 
0xFF       
# 等于十进制的 255




# 大整数

big_num = 
123456789012345678901234567890


print(
type(big_num))  
# <class 'int'>

2. 浮点数 ( float)

float 类型用于表示带有小数点的数字（实数）。它们遵循 IEEE 754 双精度浮点数标准，通常有大约 17 位有效数字。

特点：

• • 有精度限制
• • 可能存在浮点数精度问题
• • 可以用科学计数法表示

示例：

# 普通浮点数

pi = 
3.14159

temperature = -
12.5

price = 
9.99




# 科学计数法

scientific = 
1.5e-3    
# 等于 0.0015

large_float = 
2.5e8    
# 等于 250000000.0




# 浮点数精度问题示例


print(
0.1 + 
0.2)       
# 输出: 0.30000000000000004


print(
0.1 + 
0.2 == 
0.3) 
# 输出: False




# 使用 decimal 模块解决精度问题


from decimal 
import Decimal


print(Decimal(
'0.1') + Decimal(
'0.2') == Decimal(
'0.3'))  
# True

3. 复数 ( complex)

complex 类型用于表示复数，形式为  a + bj，其中  a 是实部， b 是虚部， j 表示虚数单位（√-1）。

特点：

• • 实部和虚部都是浮点数
• • 可以通过  .real 和  .imag 属性访问实部和虚部

示例：

# 复数

z1 = 
3 + 
4j

z2 = -
2.5 + 
1.7j

z3 = 
5j           
# 只有虚部

z4 = 
3.0 + 
0j     
# 只有实部




# 访问实部和虚部


print(z1.real)    
# 3.0


print(z1.imag)    
# 4.0




# 复数运算

z_sum = z1 + z2


print(z_sum)      
# (0.5+5.7j)




# 获取模长


import cmath


print(
abs(z1))    
# 5.0


print(cmath.phase(z1))  
# 获取相位

4. 布尔值 ( bool)

虽然  bool 类型通常被视为逻辑类型，但在 Python 中它是  int 的子类。 True 和  False 分别等价于整数 1 和 0。

示例：

# 布尔值

is_active = 
True

is_done = 
False




# 布尔值是 int 的子类


print(
isinstance(
True, 
int))  
# True


print(
True + 
1)              
# 2


print(
False * 
10)            
# 0




# 在条件语句中的使用


if 
True:

    
print(
"这总是会执行")




if 
1:

    
print(
"非零数值被视为 True")

5. 数字类型的转换

Python 提供了内置函数在不同数字类型之间进行转换。

转换函数：

# int() - 转换为整数


print(
int(
3.7))      
# 3 (向零取整)


print(
int(
"42"))     
# 42


print(
int(
True))     
# 1




# float() - 转换为浮点数


print(
float(
42))     
# 42.0


print(
float(
"3.14")) 
# 3.14


print(
float(
True))   
# 1.0




# complex() - 转换为复数


print(
complex(
3, 
4)) 
# (3+4j)


print(
complex(
"2+3j")) 
# (2+3j)

6. 数字类型的检查和操作

# 检查类型

x = 
42

y = 
3.14

z = 
2 + 
3j




print(
type(x))  
# <class 'int'>


print(
type(y))  
# <class 'float'>


print(
type(z))  
# <class 'complex'>




# isinstance() 检查


print(
isinstance(x, 
int))      
# True


print(
isinstance(y, 
float))    
# True


print(
isinstance(z, 
complex))  
# True




# 常用数学运算

a, b = 
10, 
3


print(a + b)   
# 13


print(a - b)   
# 7


print(a * b)   
# 30


print(a / b)   
# 3.333... (结果总是 float)


print(a // b)  
# 3 (整除)


print(a % b)   
# 1 (取余)


print(a ** b)  
# 1000 (幂运算)

7. 内置数学函数

Python 提供了许多内置的数学函数：

# 基本数学函数


print(
abs(-
5))        
# 5


print(
round(
3.14159, 
2))  
# 3.14


print(
pow(
2, 
3))      
# 8


print(
max(
1, 
5, 
3))   
# 5


print(
min(
1, 
5, 
3))   
# 1




# 需要导入 math 模块


import math




print(math.pi)        
# 3.141592653589793


print(math.e)         
# 2.718281828459045


print(math.sqrt(
16))  
# 4.0


print(math.floor(
3.7)) 
# 3


print(math.ceil(
3.2))  
# 4


print(math.log(
10))    
# 自然对数


print(math.log10(
100)) 
# 以10为底的对数

String（字符串）

字符串（String） 在python中是一种用于表示文本数据的基本数据类型。字符串是由一系列字符组成的不可变序列。

1. 字符串的创建

Python 中有多种方式创建字符串：

# 使用单引号

s1 = 
'Hello World'




# 使用双引号

s2 = 
"Hello World"




# 使用三重引号（可以跨行）

s3 = 
"""这是一个

多行字符串"""



s4 = 
'''也可以

这样写'''




# 空字符串

empty_str = 
""

注意：单引号和双引号功能相同，选择一种风格并保持一致。三重引号常用于文档字符串（docstring）或多行文本。

2. 字符串的特性

• • **不可变性（Immutable）**：字符串一旦创建就不能被修改。任何“修改”操作实际上都会创建一个新的字符串对象。
• • **有序性（Ordered）**：字符串中的字符有固定的顺序，可以通过索引访问。
• • **可迭代（Iterable）**：可以使用  for 循环遍历字符串中的每个字符。

3. 字符串索引与切片

索引（Indexing）

text = 
"Python"


print(text[
0])    
# P (第一个字符)


print(text[-
1])   
# n (最后一个字符)


print(text[
5])    
# n

切片（Slicing）

语法： string[start:end:step]

text = 
"Hello World"




# 基本切片


print(text[
0:
5])      
# Hello (索引0到4)


print(text[
6:])       
# World (从索引6到末尾)


print(text[:
5])       
# Hello (从开头到索引4)




# 步长


print(text[::
2])      
# HloWrd (每隔一个字符)


print(text[::-
1])     
# dlroW olleH (反转字符串)




# 负索引切片


print(text[-
5:])      
# World

4. 字符串的常用操作

拼接（Concatenation）

# 使用 + 操作符

greeting = 
"Hello" + 
" " + 
"World"




# 使用 join() 方法（推荐，效率更高）

words = [
"Hello", 
"Beautiful", 
"World"]

sentence = 
" ".join(words)  
# "Hello Beautiful World"

重复

repeat = "Ha" * 3  # "HaHaHa"

长度

length = len("Python")  # 6

5. 常用字符串方法

Python 提供了丰富的内置方法来操作字符串：

text = 
"  Hello World  "




# 大小写转换


print(text.upper())           
# "  HELLO WORLD  "


print(text.lower())           
# "  hello world  "


print(text.capitalize())      
# "  hello world  " -> "  hello world  " (首字母大写)


print(text.title())           
# "  Hello World  "




# 去除空白


print(text.strip())           
# "Hello World"


print(text.lstrip())          
# "Hello World  " (左)


print(text.rstrip())          
# "  Hello World" (右)




# 查找与替换


print(text.find(
"World"))     
# 8 (找到的索引，未找到返回-1)


print(text.replace(
"World", 
"Python"))  
# "  Hello Python  "




# 判断方法


print(
"Hello".isalpha())      
# True (是否全是字母)


print(
"123".isdigit())        
# True (是否全是数字)


print(
"hello".startswith(
"he")) 
# True


print(
"world".endswith(
"ld"))   
# True




# 分割与合并

sentence = 
"apple,banana,orange"

fruits = sentence.split(
",")  
# ['apple', 'banana', 'orange']



joined = 
"-".join([
"a", 
"b", 
"c"])  
# "a-b-c"

6. 字符串格式化

1. f-string（推荐，Python 3.6+）

name = 
"Alice"

age = 
25

message = 
f"我的名字是 
{name}，今年 
{age} 岁。"


print(message)  
# 我的名字是 Alice，今年 25 岁。

2.  .format() 方法

message = 
"我的名字是 {}，今年 {} 岁。".
format(name, age)

message = 
"我的名字是 {n}，今年 {a} 岁。".
format(n=name, a=age)

3. % 格式化（较老的方式）

message = "我的名字是 %s，今年 %d 岁。" % (name, age)

7. 转义字符

使用反斜杠  \ 来表示特殊字符：

print(
"Hello\nWorld")   
# 换行


print(
"He said: \"Hello\"")  
# He said: "Hello"


print(
"C:\\Users\\Name")     
# 路径

**原始字符串（Raw String）**：在字符串前加  r，忽略转义字符。

path = r"C:\Users\Name\Documents"  # 不需要双写反斜杠

8. 字符串的不可变性示例

text = 
"Hello"


# text[0] = "h"  # ❌ 错误！字符串不可变




# 正确的做法是创建新字符串

new_text = 
"h" + text[
1:]  
# "hello"

9. 实用技巧

遍历字符串

for char 
in 
"Python":

    
print(char)

检查子字符串

if 
"hello" 
in 
"hello world":

    
print(
"找到了！")

统计字符

text = 
"hello"


print(text.count(
"l"))  
# 2

Tuple（元组）

在 Python 中， 元组（Tuple） 是一种有序、不可变的序列数据类型。它与列表（List）非常相似，但最大的区别在于 一旦创建，元组的内容不能被修改。

1. 元组的创建

元组可以通过以下几种方式创建：

# 使用圆括号 ()

t1 = (
1, 
2, 
3, 
4, 
5)

t2 = (
"apple", 
"banana", 
"cherry")

t3 = (
1, 
"hello", 
3.14, 
True)




# 单个元素的元组需要加逗号

single = (
42,)  
# 注意逗号，否则会被当作普通括号


print(
type(single))  
# <class 'tuple'>




# 省略括号（但不推荐，可读性差）

t4 = 
1, 
2, 
3


print(
type(t4))  
# <class 'tuple'>




# 空元组

empty_tuple = ()




# 使用 tuple() 构造函数

t5 = 
tuple([
1, 
2, 
3])      
# 从列表创建

t6 = 
tuple(
"hello")        
# 从字符串创建 -> ('h', 'e', 'l', 'l', 'o')

2. 元组的特性

3. 元组的访问

索引（Indexing）

t = (
10, 
20, 
30, 
40, 
50)


print(t[
0])    
# 10


print(t[-
1])   
# 50 (最后一个)

切片（Slicing）

print(t[
1:
4])    
# (20, 30, 40)


print(t[::
2])    
# (10, 30, 50)


print(t[::-
1])   
# (50, 40, 30, 20, 10) 反转

4. 元组的操作

拼接（Concatenation）

t1 = (
1, 
2)

t2 = (
3, 
4)

t3 = t1 + t2  
# (1, 2, 3, 4)

重复

t = (1, 2) * 3  # (1, 2, 1, 2, 1, 2)

成员检查

if 
2 
in t:

    
print(
"2 在元组中")

长度

length = len(t)  # 获取元组长度

5. 元组的常用方法

由于元组不可变，它的方法很少：

t = (
1, 
2, 
3, 
2, 
4, 
2)




# count() - 统计某个元素出现的次数


print(t.count(
2))  
# 3




# index() - 查找元素第一次出现的索引


print(t.index(
3))  
# 2


# print(t.index(99))  # ValueError: tuple.index(x): x not in tuple

6. 元组的解包（Unpacking）

元组解包是 Python 中非常强大和常用的功能。

# 基本解包

coordinates = (
3, 
4)

x, y = coordinates


print(x, y)  
# 3 4




# 函数返回多个值


def 
get_name_age():

    
return 
"Alice", 
25



name, age = get_name_age()




# 忽略某些值

data = (
1, 
2, 
3, 
4, 
5)

a, b, *rest = data  
# a=1, b=2, rest=[3,4,5]


print(rest)  
# [3, 4, 5]




# 只取首尾

first, *middle, last = (
1, 
2, 
3, 
4, 
5)


print(first, middle, last)  
# 1 [2, 3, 4] 5

7. 元组的应用场景

1. 1.  作为字典的键

# ✅ 元组可以作为字典的键

locations = {

    (
0, 
0): 
"原点",

    (
3, 
4): 
"点A",

    (-
1, 
2): 
"点B"

}

1. 2.  函数返回多个值

def 
min_max(
numbers):

    
return 
min(numbers), 
max(numbers)



minimum, maximum = min_max([
1, 
2, 
3, 
4, 
5])

1. 3.  数据保护

# 防止意外修改

days_of_week = (
"Monday", 
"Tuesday", 
"Wednesday", 
"Thursday", 
"Friday", 
"Saturday", 
"Sunday")


# days_of_week[0] = "Mon"  # ❌ 会报错，保护数据

1. 4.  格式化字符串

print("坐标: %d, %d" % (3, 4))

8. 注意事项

• • 不可变性是浅层的：如果元组包含可变对象（如列表），那么该对象的内容仍然可以被修改。

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

t[
1].append(
5)  
# ✅ 允许，因为修改的是列表


print(t)        
# (1, [2, 3, 5], 4)




# t[1] = [2, 3, 4]  # ❌ 不允许，因为要替换元组元素

总结

本文主要对python的基本数据类型中的不可变数据类型进行相关的学习，下章节针对可变数据类型继续相关的学习。希望大家一起努力学习，掌握基础才能更深的灵活运用后期的人工智能的实践工作。

资料关注

相关资料免费获取:
公众号：咚咚王

《Python编程：从入门到实践》
《利用Python进行数据分析》
《算法导论中文第三版》
《概率论与数理统计（第四版） (盛骤) 》
《程序员的数学》
《线性代数应该这样学第3版》
《微积分和数学分析引论》
《（西瓜书）周志华-机器学习》
《TensorFlow机器学习实战指南》
《Sklearn与TensorFlow机器学习实用指南》
《模式识别（第四版）》
《深度学习 deep learning》伊恩·古德费洛著 花书
《Python深度学习第二版(中文版)【纯文本】 (登封大数据 (Francois Choliet)) (Z-Library)》
《深入浅出神经网络与深度学习+(迈克尔·尼尔森（Michael+Nielsen） 》
《自然语言处理综论 第2版》
《Natural-Language-Processing-with-PyTorch》
《计算机视觉-算法与应用(中文版)》
《Learning OpenCV 4》
《AIGC：智能创作时代》杜雨+&+张孜铭
《AIGC原理与实践：零基础学大语言模型、扩散模型和多模态模型》
《从零构建大语言模型（中文版）》
《实战AI大模型》
《AI 3.0》