Number（数字）类型与String（字符串）类型的基础认识

Bloodthirsted

已于 2022-10-31 08:13:10 修改

阅读量1.6k

点赞数

文章标签： python 开发语言

于 2022-10-30 14:01:50 首次发布

本文链接：https://blog.csdn.net/Bloodthirsted/article/details/127598961

版权

文章目录

初识Python中的六大数据类型其二

初识Python中的六大数据类型其二

数据类型：每一个变量在使用之前都必须赋值，赋完值后该变量才会被创建，对变量进行赋值时赋值的对象的类型称为变量的类型，即数据类型

Python中的数据类型有以下六种：**Number（数字）、String（字符串）、List（列表）、Tuple（元组）、Set（集合）、Dictionary（字典）**现在先来学习前两个数据类型

一、数字类型（Number）

整数类型：int（取值范围：所有整数）
浮点类型：float（取值范围：所有理数；默认精度为小数点后17位）
布尔类型：bool（取值为True或者False）

复数类型：complx（取值范围：所有虚数）

# type(a)可查看变量a的数据类型

a1 = 12
print("a1的值: ", a1)
print("a1的类型", type(a1))

print("\n----------分割线----------\n")

a2 = 12.5
print("a2的值: ", a2)
print("a2的类型", type(a2))

print("\n----------分割线----------\n")

a3 = True
print("a3的值: ", a3)
print("a3的类型", type(a3))

print("\n----------分割线----------\n")

a4 = 12 + 0.2j
print("a4的值: ", a4)
print("a4的类型", type(a4))

输出结果：

a1的值:  12
a1的类型 <class 'int'>

----------分割线----------

a2的值:  12.5
a2的类型 <class 'float'>

----------分割线----------

a3的值:  True
a3的类型 <class 'bool'>

----------分割线----------

a4的值:  (12+0.2j)
a4的类型 <class 'complex'>

1.1 int类型的进制转换

bin 十进制转为二进制
oct 十进制转为八进制

hex 十进制转为十六进制

# bin(a)把十进制的a转为二进制
a1 = 1024
print("1024的二进制为：", bin(a1), "(二进制以0b开头)")
print()

# oct(a)把十进制的a转为八进制
a2 = 1024
print("1024的八进制为：", oct(a2), "(八进制以0o开头)")
print()

# hex(a)把十进制的a转为十六进制
a3 = 1024
print("1024的十六进制为：", hex(a3), "(十六进制以0x开头)")

输出结果：

1024的二进制为： 0b10000000000 (二进制以0b开头)

1024的八进制为： 0o2000 (八进制以0o开头)

1024的十六进制为： 0x400 (十六进制以0x开头)

1.2 int,float,bool类型之间的强制转换

在float类型与int类型之间强转

# float类型与int类型强转
# float类型转int类型，原float类型的小数部分会丢失
a = 1024.8
print("a的初始值：", a)
print("a的初始类型：", type(a))

print("\n----------分割线----------\n")

a = int(a)
print("a强转为int后的值：", a)
print("a强转为int后的类型：", type(a))

print("\n----------分割线----------\n")

a = float(a)
print("a强转为float后的初始值：", a)
print("a强转为float后的类型：", type(a))

输出结果：

a的初始值： 1024.8
a的初始类型： <class 'float'>

----------分割线----------

a强转为int后的值： 1024
a强转为int后的类型： <class 'int'>

----------分割线----------

a强转为float后的初始值： 1024.0
a强转为float后的类型： <class 'float'>

在int和float类型与bool类型之间强转

# 只要a不为0转为bool类型都为True,若a为零则转后为False
# 但bool值转为int值只有0或1,True=1；False=0
a = 2
print("a的初始值=", a)
a = bool(a)
print("a转为bool后的值=", a)
a = int(a)
print("a转为bool后又转为int的值=", a)

print("\n----------分割线----------\n")

a = -2.5
print("a的初始值=", a)
a = bool(a)
print("a转为bool后的值=", a)
a = float(a)
print("a转为bool后又转为float的值=", a)

print("\n----------分割线----------\n")

a = 0
print("a的初始值=", a)
a = bool(a)
print("a转为bool后的值=", a)
a = int(a)
print("a转为bool后又转为int的值=", a)

输出结果：

a的初始值= 2
a转为bool后的值= True
a转为bool后又转为int的值= 1

----------分割线----------

a的初始值= -2.5
a转为bool后的值= True
a转为bool后又转为float的值= 1.0

----------分割线----------

a的初始值= 0
a转为bool后的值= False
a转为bool后又转为int的值= 0

1.3 初识数字数据类型常用的几个函数

函数	作用
abs(a)	计算a的绝对值
pow(a, b)	计算a的b次方
round(a, n)	对a四舍六入五成偶（五成偶：若与两边相距距离相等则取偶数），保留n位小数（n默认为0）
max(a, b, …)	取最大值
min(a, b, …)	取最小值

# abs(a)计算a的绝对值
a1 = -1
print("-1的绝对值=", abs(a1))
print()

# pow(a, b)计算a的b次方
a2 = 2
b1 = 10
print("2的10次方=", pow(a2, b1))
print()

# round(a)对a取近似值，若与两边相距距离相等则取偶数
a3 = 34.5
print("34.5四舍五入后的值=", round(a3))
print()

# max()取最大值
print("1, 2, 3中的最大值=", max(1, 2, 3))
print()

# min()取最小值
print("9, 10, 6中的最小值=", min(9, 10, 6))

输出结果：

-1的绝对值= 1

2的10次方= 1024

34.5四舍五入后的值= 34

1, 2, 3中的最大值= 3

9, 10, 6中的最小值= 6

二、字符串（String）

在python中被< ‘’ >单引号或< “” >双引号引起来的内容为字符串

2.1 字符串类型的基本格式

Python中单引号和双引号使用完全相同；**三引号< ‘’’ >或< “”" >**指定多行字符串。

a = "这是字符串1"
print("字符串1：")
print(a)

print("\n----------分割线----------\n")

a = '这是字符串2'
print("字符串2：")
print(a)

print("\n----------分割线----------\n")

# 多行字符串由两个三引号所在位置来决定的开始、结尾位置，若三引号所在该行为空则该行输出空行
a = '''这是
占三行的多行
字符串'''
print("多行字符串1：")
print(a)

print("\n----------分割线----------\n")

a = """
这是占四行
的多行字符串
"""
print("多行字符串2：")
print(a)

输出结果：

字符串1：
字符串1

----------分割线----------

字符串2：
字符串2

----------分割线----------

多行字符串1：
这是
占三行的多行
字符串

----------分割线----------

多行字符串2：

这是占四行
的多行字符串

2.2 字符串中的转义

使用反斜杠< \ >可以实现转义，使用r可以让反斜杠不发生转义

# 在字符串中需要保留'或者"时使用< \ >来防止Python将引号识别为字符串的标识
# print('I'm I') 如果代码是这样该程序就会报错（由于前两个引号已被识别为了字符串的标识，所以第三个引号会被识别为下一个字符串标识的开头第一个引号）

# 所以就需要使用< \ >来转义以输出字符串中间的'
print("使用< \ >转义输出< ' >的结果：")
print('I\'m I')

print("\n----------分割线----------\n")

# 使用r让\的转义失效
print("使用r禁止转义后的输出为：")
print(r'I\'m I')

输出：

使用< \ >转义输出< ' >的结果：
I'm I

----------分割线----------

使用r禁止转义后的输出为：
I\'m I

一般为了程序的可读性需要尽量避免使用转义符号，可以在字符串内外使用不同的引号来实现

print("使字符串中包含单引号：")
print("'abc'")

print("\n----------分割线----------\n")

print('使字符串中包含双引号：')
print('"abc"')

输出：

使字符串中包含单引号：
'abc'

----------分割线----------

使字符串中包含双引号：
"abc"

2.3 字符串的连接和重复

字符串可以用 + 运算符连接在一起，用 * 运算符重复

# 两个字符串用+来连接
a = "Py"
b = "thon"
c = a+b
print(c)

# 用*重复字符串
c = c * 5
print(c)

输出：

Python
PythonPythonPythonPythonPython

2.4 字符串强转为数字类型

string类型与int、float、bool类型之间的强转

# string类型与int类型之间强转（若string类型的值不在int范围则会报错）
print('string类型与int类型之间强转：')
# a的初始值
a = '1024'
print('a的初始值为：', a)
print('a的初始类型为：', type(a))
# a强转为str
a = int(a)
print('str的a强转为int后的值为：', a)
print('str的a强转为int后的类型为：', type(a))
# a强转为int
a = str(a)
print('int的a强转为str后的值为：', a)
print('int的a强转为str后的类型为：', type(a))
# string与float之间强转同上，只需将int改为float

print("\n----------分割线----------\n")

# string类型与bool类型之间强转
# 只要str值非空强转为bool都为True
print('string类型与bool类型之间强转：')
# b1的初始值
b1 = 'False'
print('b1的初始值为：', b1)
print('b1的初始类型为：', type(b1))
# str强转为bool
b1 = bool(b1)
print('str的b1强转为bool后的值为：', b1)
print('str的b1强转为bool后的类型为：', type(b1))
# b2的初始值
b2 = ""
print('b2的初始值为：', b2)
print('b2的初始类型为：', type(b2))
# str强转为bool
b2 = bool(b2)
print('str的b2强转为bool后的值为：', b2)
print('str的b2强转为bool后的类型为：', type(b2))

输出：

string类型与int类型之间强转：
a的初始值为： 1024
a的初始类型为： <class 'str'>
str的a强转为int后的值为： 1024
str的a强转为int后的类型为： <class 'int'>
int的a强转为str后的值为： 1024
int的a强转为str后的类型为： <class 'str'>

----------分割线----------

string类型与bool类型之间强转：
b1的初始值为： False
b1的初始类型为： <class 'str'>
str的b1强转为bool后的值为： True
str的b1强转为bool后的类型为： <class 'bool'>
b2的初始值为： 
b2的初始类型为： <class 'str'>
str的b2强转为bool后的值为： False
str的b2强转为bool后的类型为： <class 'bool'>

[扩充]2.5 无法被更改的字符串

Python中的字符串不能更改，向某个索引位置赋值，比如word[0] = 'm’会导致错误
```
# 字符串不能被修改，以下方式所写的程序就会报错
word = 'Python'
word[0] = 'J'
```
但是可以使用以下的操作
```
word = 'Python'
word = 'J' + word[1:]
print(word)
```
输出：
```
Jython
```
字符串word似乎已经被修改为了’Jython’，但事实是前后两个word占用的是不同的内存指针，可以用 id() 这个方法来查看实际的内存指针
```
# id()查看内存指针
word = 'Python'
print(id(word))
word = 'J' + word[1:]
print(word)
print(id(word))
```
输出：
```
2479511264704
Jython
2479512048392
```
这说明 word并没有被修改，而是被配置到了新的内存