python入门基础-数据类型和输入（input）、输出（了解数据类型的基本使用，简单详细，对新手小白友好！）（3）

前言

这篇文章主要学习python常用数据类型的基本使用，包括整型、浮点型、字符串型、列表、字典、布尔（bool），没有高端的使用技巧，从底层出发带你了解数据类型的本质，对新手小白十分友好，希望可以帮助到各位。

1、基本的数据类型

1.1 为什么要有数据类型？

1. 更好的利用内存
2. 更好的操作数据

1.2 数据类型的分类（按使用频率进行排名）

• int（整型）
• float（浮点型）
• str（字符串）
• list（列表）
• dict（字典）
• bool（布尔）
• tuple（元组）
• set（集合）

1.3 常用数据类型的简单介绍和使用

1.3.1 整型（int）

用于记录整数，进行数学运算；如：

# 整型，也就是整数，如：...,-2,-1,0,1,2,3...
a = 888
b = 4
print(a+b)
print(a-b)
print(a*b)
print(a/b)

输出结果：

892
884
3552
222.0

1.3.2 浮点型（float）

用于记录小数
在python中浮点数的运算通常会出现精度丢失的问题，算出的结果会与正常计算有出入，这时python提供了一些其它模块来解决精度问题，在这里我就不细讲了，这需要一定基础，但是可以用一个简单的办法来处理；如：

精度问题演示：

a = 0.1 # 小数
b = 0.2
print(a+b)

输出结果：

0.30000000000000004

从上面可以看出，0.1+0.2 的答案按理说应该为 0.3 ，但python运行的结果却有所不同，那么如何解决这种问题呢？

解决方法：

a = 0.1*10 # 将小数乘以10变为整数
b = 0.2*10
print(a)
print(b)
print((a+b)/10) # 因为前面乘以了10，所以需要除以10

输出结果：

1.0 
2.0 
0.3 

说明：

因为python中整型的计算没有精度问题，所以我们可以先将小数转为整数的形式，然后在用它进行计算，得到的结果必然为整数，之后再将其转换回来即可；这是一种思维方式，我们需要掌握python的本质，而不是把它学死了

拓展：

整型（int）和 浮点型（float）都和数字有关，这里我们为了方便记忆，将他们统称为数字类型，但记住python是没有数字类型这种数据类型的，这是我们自定义的

我们知道不同数据类型之间的数据是不可以放在一起使用的，但这里整型和浮点型可以一起进行数学运算且计算结果为浮点型，还可以进行大小比较；如：

a = 1
b = 0.1
print(a+b)
print(3>2.5) # 大小比较返回的是布尔值，后面会讲到
print(5<3.6)

输出结果：

1.1
True
False

1.3.3 布尔类型（bool）

布尔类型就只有两个值：
1、True (代表意思是，对的，是的，真的，有的)
2、False (代表的意思是，错的，不是的，假的，没有的)

所有数据中除了 0，0.0，' '，[ ]，( )，{ }，None（空字符串，空列表，空元祖，空字典，空集合）是 False，其他都是 True，因为他们都是空的，代表没有，所以是False，None也代表 没有 的意思
布尔类型通常结合 if语句，用来做判断使用

1.3.4 字符串类型（str）

文字和符号串在一起组成的数据，用来记录和描述一些事物
用引号包裹起来的一串字符就是字符串，可以是成对的单引号（’ ‘），双引号（" "），三引号（’‘’ ‘’'）

如：

a = 1 # 整型，是一个数字
b = '1' # 有引号包裹，是字符串
c = '2'

拓展举例：

a = 1 # 整型，是一个数字
x = 2 
print(a+x) # 整数相加
b = '1' # 有引号包裹，是字符串
c = '2'
print(b+c) # 字符串相加
sex = "阿"
name = "豪"
print(sex+name) # 字符串相加

输出结果：

3
12
阿豪

可以看到，数字类型相加进行的是数学运算，而字符串相加，则是将两个字符串拼接在一起；但当数字和字符串相加时就会报错，因为他们数据类型不同

拓展知识：

字符串用 单引号 或 双引号 包裹本质都是一样的，没有区别；但是要注意两种情况：

1. 单包双，单引号包裹双引号
2. 双包单，双引号包裹单引号

错误写法：

print("我是"阿豪") # 没有成对，这里出现了三个双引号，因为python默认让前面两个双引号成对了，导致后面的字符并没有被引起来，发生语法错误

正确写法：

print("我是'阿豪") # 双包单
print('我是"阿豪') # 单包双

输出结果：

我是'阿豪
我是"阿豪

在这里除了使用成对的引号进行包裹外，我们还可以通过其它方法解决引号不成对报错问题；如：

• 转义符号：\ ，将字符串中的特殊字符转义掉，变为普通字符串，以免出现语法错误

print("我是\"阿豪")

输出结果：

我是"阿豪

• 除了上面使用的 转义符 \ 外，python还有许多其他特殊字符，如：

1. 换行符：\n ，让字符串换行输出
2. 制表符：\t ，一个制表符代表一个 Tab键，也就是四个空格
3. 原始字符串：r ，将代码按原文输出，不受特殊转义符和特殊字符的影响

例子：

print("我是\n阿豪") # 换行输出
print("我是\t阿豪") # 插入4个空格
print(r"我是\n!\"阿豪") # 按原文输出

输出结果：

我是
阿豪
我是	阿豪
我是\n!\"阿豪在这里插入代码片

• 当字符串使用成对三引号时，可以实现换行输出，带格式输出；如：

print('''我是阿豪
我在遛狗！    
 路过商店，买了.....     汽水
        哈哈哈！！！！！
            22333
''')

输出结果：

我是阿豪
我在遛狗！    
 路过商店，买了.....     汽水
        哈哈哈！！！！！
            22333

• 除了使用三引号进行换行带格式输出，还有其他方法可以实现该效果，也就是在字符串每行的末尾加 \；但一般我们使用三引号，而不使用该方法；如：

content="我是阿豪\
啊   !!!\
    !!!啦啦啦\
"
print(content)

输出结果：

我是阿豪啊   !!!    !!!啦啦啦

这里只加 \ 只能实现换行书写，没办法带格式输出，必须加上换行符 \n；如：

content="我是阿豪\n\
啊   !!!\n\
    !!!啦啦啦\n\
"
print(content)

输出结果：

我是阿豪
啊   !!!
    !!!啦啦啦

• 字符串不但可以相加，还可以与整数相乘；不能乘以小数，如：

a = '阿豪'
b= '666'
print(a+b) # 字符串相加，拼接起来
print(a*5) # 字符串乘以整数，重复打印该字符串5次

输出结果：

阿豪666
阿豪阿豪阿豪阿豪阿豪

1.3.5 列表（list）

按照位置记录多个值，每个值在列表中都有自己的位置(索引)，我们可以通过索引来的到这个值

• 定义列表，使用中括号 [] ，其中每个值用逗号 , 隔开，值可以是任意数据类型；如：

a = ['阿豪1','阿豪2',666,3.2]
print(a)

输出结果：

['阿豪1', '阿豪2', 666, 3.2]

• python中列表的使用通常是通过索引来取出其中对应的值的；如：

首先我们需要知道，列表中值的位置是怎样规定的：
从左往右，值的索引依次为：0,1,2,3,4,5,6,…
从右往左，值的索引依次为：-1,-2,-3,-4,-5,-6…

例子：

a = ['阿豪1','阿豪2',666,3.2]
print(a[0]) # 输出左边第一个值
print(a[-1]) # 输出右边第一个值

输出结果：

阿豪1
3.2

• 列表嵌套

在前面我们说过，列表中可以放任意数据类型的值，那么能不能再放一个列表呢？答案如下：

a = [666,'阿豪'] 
b = ['阿豪1','阿豪2',a] # 将列表 a 作为值放入 列表 b
print(b)

输出结果：

['阿豪1', '阿豪2', [666, '阿豪']]

可以看到，输出结果中显示，在 列表b 中又嵌套了一个列表，且我们同样可以用索引的方式取出其中的列表以及列表中的值；如：

a = [666,'阿豪']
b = ['阿豪1','阿豪2',a]
print(b[-1]) # 取出列表 a
print(b[-1][0]) # 取出列表a 中的第一个值

输出结果：

[666, '阿豪']
666

• 索引越界，列表无法取到没有该位置(索引)的数据

a = [666,'阿豪']
print(a[2]) # 会报错，因为这里没有 索引2 这个位置的数据，简单说就是 列表a 只有两个数据，你想取出第三个数据，肯定不可能呀！

• 列表可以通过索引修改对应的值；如：

a = [66,'阿豪',[0]]
a[1] = '阿豪666' # 将列表第二个值修改
print(a)
a[2][0] = 55 # 通过嵌套索引，修改列表a 中嵌套的列表中的值
print(a)

输出结果：

[66, '阿豪666', [0]]
[66, '阿豪666', [55]]

总结：
列表中可以放任意数据类型的值，且每个值都有自己的位置，可以通过索引去取出对应的值，列表可以无限嵌套列表，同样可以通过嵌套索引取出其中的值；列表无法取出没有该索引的数据

a = [1,'666',[2,3],[],[],[],[]] # 无限嵌套列表
print(a[2][1]) # 索引嵌套

1.3.6 字典（dict）

使用大括号 {} 包裹，里面的值是一个个 键值对，中间用逗号 , 隔开
格式：{键:值,键:值,…}
其中：
键 只能是整型，浮点型，字符串型，布尔型，None，元组；一般我们只会使用字符串型，字典的键是唯一的，不能重复
值 可以是任意数据类型

如下：

a = {
    '名字':'阿豪', # 冒号左边的是键，右边是值
    '年龄':'18',
    '身高':175,
    '爱好':'打篮球'
}  # 键值对可以换行书写，但必须用 逗号 隔开
print(a)

输出结果：

{'名字': '阿豪', '年龄': '18', '身高': 175, '爱好': '打篮球'}

• 字典取值，我们使用字典，目的是为了使用 值，而键是对这个值起到说明的作用，所以python中字典是通过 键来取值的；如：

a = {
    '名字':'阿豪',
    '年龄':'18',
    '身高':175,
    '爱好':'打篮球'
}
print(a['爱好']) 

输出结果：

打篮球

• 前面提到 键 是唯一的，为什么呢？如下：

a = {
    '名字':'阿豪',
    '名字':'阿呆',
    '身高':175,
    '爱好':'打篮球'
}
print(a)
print(a['名字'])

输出结果：

{'名字': '阿呆', '身高': 175, '爱好': '打篮球'}
阿呆

从上面可以看到，字典中出现了两个相同的 键，却只输出了一个，这是因为当字典出现多个相同的键时，python会默认输出最后一个出现的键；相当于前面的都被覆盖掉了

拓展：
从前面我们学到，列表和字典中的值都可以为任意数据类型，因此我们可以列表和字典的各种嵌套，俗称套娃；如：

a = {
    '名字':'阿豪',
    '爱好':'打篮球'
} # 字典
b = [1,2,3] # 列表
c = [a,b] # 列表嵌套列表和字典
print(c[0]['爱好']) # 取出字典b中的值
print(c[1][0]) # 取出列表a 中的值

输出结果：

打篮球
1

1.4 用户交互：输入和输出

输入：将数据给计算机，计算机接受你的数据
输出：计算机将一些数据输出，打印在屏幕上

1.4.1 输出

print(666) # 将数据打印在屏幕上

• 使用print同时输出多个数据,中间用逗号 , 隔开；如：

print('阿豪','ok',666)

输出结果：

阿豪 ok 666

• 使用 print 输出多个数据时，输出结果默认会用逗号,隔开；若不想用 逗号,隔开，则可以使用 sep=‘隔开的字符’ ；如：

print('阿豪','ok',666,sep='**')

输出结果：

阿豪**ok**666

可以看到，输出结果使用指定的字符进行了分隔，该字符可以为任何内容

• 每运行一次 print，输出结果默认进行了换行(\n)，若不想换行可以使用 end='以什么结尾'；如：

print(1) # 直接输出，以 换行符（\n）结尾
print(2)
print('阿豪','ok',666,end='**') # 以 ** 结尾输出 
print('哈哈哈！！！')

1
2
阿豪 ok 666**哈哈哈！！！

从输出结果可以看到，前面直接用 print输出后，结果默认进行了换行，而我使用 end 指定了以什么内容结尾，而不是以 换行符（\n）结尾

1.4.2 输入

格式：input()
只要程序执行到 input ，程序会暂停住，不往下执行，等待你输入数据给计算机，输入完成后，回车（enter），计算机就会的到你输入的数据，程序继续执行

如：

a = input() # 使用变量来保存你输入的数据
print(a) # 打印你输入的数据

输出结果：

阿豪，666，啦啦

这里需要注意，不管你输入什么内容，input 接收到的数据都是 字符串（str）类型的数据

• 给 input 的输入加入 提示信息
  如下：

在这里插入代码片

从上面可以看到运行代码后，输入区域生成了提示信息，提示我们输入的内容，提示信息可以为任意内容，且不会被 计算机接收，只会在屏幕上看到，计算机接收到的依然是你输入的内容

拓展：

type()：查看数据类型

如：

b = '阿豪'
c = [1,3]
print(type(a))
print(type(b))
print(type(c))

输出结果：

<class 'int'>
<class 'str'>
<class 'list'>