带你了解九种数据类型，快速上手python。-CSDN博客

本文链接：https://blog.csdn.net/2203_75738159/article/details/131856896

至此结束了我们的九种数据类型，谢谢您的观看！！！

我还会更加努力制作出更好的作品让您们观看。制作不易，请您勿

Python语言包括九种基本的数据类型，我们把它分为以下三类。

数值类型	整数，浮点数，空值，布尔值
字符串类型	字符串
组合类型	元组，列表，字典，集合

一数值类型

1.整数类型

与数学中的整数含义相同，无取值范围；
整数包括二进制、八进制、十进制、十六进制等4种表示形式；
二进制：以0b或0B开头：0b110,-0B110;
八进制：以0o或0O开头：0o123,-0789;
十进制：123，-321,0；
十六进制：以0x或0X开头：0xff,-0Xfa。
如：0b1010 = 0o12 = 10 = 0xa

代码示例：

# 整型
i1 = 10
print(i1, type(i1))
10 <class 'int'>

2.浮点数类型

与数学中的实数含义相同，带有小数及小数的数字，存在取值范围；
浮点数包括常规方法和科学计数法2种方式表示；
科学计数法使用字母e或E作为幂的符号，以10位基数，格式：<a>e<b> 表示 a*10**2；
如：0.0012 = 1.2e-3 ； 34000000.0 = 3.4e7

代码示例：

# 浮点型
PI = 3.1415926
print(PI, type(PI))
# 科学计数法
f1 = 3.14e-2
print(f1, type(f1))
f2 = 3.0e8
print(f2, type(f2))

结果：
3.1415926 <class 'float'>
0.0314 <class 'float'>
300000000.0 <class 'float'>

3.空值

python中一种特殊的值，用None表示，空值的类型也是一种特殊数据类型
None不能理解为0，因为0是有意义的，而None是一个特殊值。
空值通常用作默认值使用
创建一个空值
a = None
print(a)
print(type(a))

# None
n1 = None
print(n1, type(n1))

结果：
None <class 'NoneType'>

4.布尔值

用来存储一个真或假的数值，只有真 True或者假 False两种值
True 和 False 是 Python 中的关键字，当作为 Python 代码输入时，一定要注意字母的大小写，否则解释器会报错（注意大小写）
布尔值可以当作一个整数来对待，即 True 相当于整数值 1，False 相当于整数值 0
下方运算是可以执行的，只用于示例，实际运用中是不可以这样去用的

# 布尔值
b1 = True
print(b1, type(b1))
b2 = False
print(b2, type(b2))
print(False + 1)
print(True + 1)

结果：
True <class 'bool'>
False <class 'bool'>
1
2

二字符串类型

我们要知道 1 和 "1"是两种不同的数据类型，前者是一个数字，可以进行加减乘除的操作，而后者则是个单纯的字符串，也就是常说的文本内容。字符串的一个特点就是在它的两旁有单引号或者双引号。

1. 字符串

1.1 字符串定义

字符串：由0个或多个字符组成的有序字符序列，由一对单引号(' ')或一对双引号(" ")表示，可对字符进行索引，用序号进行访问。
表示方法：由一对单引号或双引号表示，仅表示单行字符串；由一对三单引号或三双引号表示，可表示多行字符串。

1.2 字符串的序号

反向递减序号

-5	-4	-3	-2	-1
a	b	c	d	e
0	1	2	3	4

正向递增序号

s = "12345"
print(s[0], s[3], s[-1])

结果：
1  4  5

1.3 字符串的使用

使用[ ] 获取字符串中一个或多个字符。
字符串索引：s[N] 通过序号获取单个字符。
字符串切片：s[M:N] 获取M到N(不含)子串，使用[M: N :K]根据步长对字符串切片，使用[::-1]对字符串进行逆序。其中，M缺失表示至开头，N缺失表示至结尾。

s = "123abcd456"
print(s[1], s[2], s[-1], s[-5], s[0:8:2],s[::-1])

结果：
2 3 6 c 13bd 654dcba321

1.4 字符串处理函数

函数及使用	描述
len(x)	长度，返回字符串x的长度
str(x)	任意类型x所对应的字符串形式
hex(x)或oct(x)	整数x的十六进制或八进制小写形式字符串
chr(x)	x为Unicode编码，返回其对应的字符
ord(x)	x为字符，返回其对应的Unicode编码

s = "python"
print(len(s))
print(str(s))
print(chr(68))
print(ord('D'))

结果：
6
python
D
68

1.5 字符串处理方法以及重要操作

1.5.1 字符串的遍历

for i in range(len(s))：通过下标索引来访问字符串中的内容，下标范围（0，len（s）-1）
for c in s: c 代表字符串的每个字符；c 代表字符串的每个字符；不支持索引；不灵活，但简单

1.5.2 字符串的方法（20个）

字符串的方法以及描述
format	格式化字符串
index	找索引找不到报错
find	找索引找不到不报错
startswith	以什么字符开头
endswith	以什么字符结束
split	切割使用字符串切割默认使用空格切割
join	使用连接字符串将后续内容进行拼接
capitalize	字符串首字母大写
title	单词首字母大写
upper	字符串字母全部大写
lower	字符串字母全部小写
swapcase	大小写互换
center	在一定宽度内居中两侧补充字符
ljust	居左右侧填充字符
rjust	居右左侧填充字符
zfill	左侧补0
strip	剔除左右两侧字符
count	统计字符串中字符出现的次数
replace	用什么字符代替其他字符
endoce decode	解码编码

代码示例：

print("{} {} {}".format(1, 2, 3))
print("hello world china".index("he"))
print("hello world china".find("wo"))
print("hello world".startswith("wo"))
print("hello world".endswith("ld", 9, 10))
print("hello world".split("--"))
print("---".join("hello world"))
print("hello world".capitalize())
print("hello world".title())
print("hello world".upper())
print("hello WOrld".lower())
print("hello WOrld".swapcase())
print("helloworld".center(20, "*"))
print("hello world".ljust(20, "*"))
print("hello world".rjust(20, "*"))
print("hello".zfill(30))
print("  -----hello world".strip("-"))
print("  -----hello world       -----".strip("-"))

答案私信我

三组合类型

1 集合类型：一维数组的集合

1.1定义

集合：多个元素的无序组合，使用大括号{}表示，元素间用逗号分隔，建立非集合使用{}或set()函数。
基本功能：集合的两个基本功能分别是去重和成员测试。

1.2 特点

无序：元素间没有顺序，因此，要求元素不能相同，元素必须是不可变类型。
非一致性：元素类型可以不同。无索引：不能对某个元素进行定点索引，可以遍历或随机获取元素。

1.3 集合操作符

操作符	说明
S \| T	并集
S & T	交集
S - T	差集
S ^ T	补集
S <= T 或 S < T	返回True或False，判断S和T的子集关系
S >= T 或 S > T	返回True或False，判断S和T的包含关

1.4 集合处理方法（8个）

集合中存放不可变类型：数字，字符串，布尔值，None，元组
0 和False 1 和True 不可以同时放入
集合的遍历：for e in 集合 e代表的是集合中的元素 if e in 集合 in是成员运算符

集合的处理方法

add 添加元素，如果元素存在，则添加无效 update 合并元素元素指的是集合，如果元素存在，则添加无效 remove 删除元素，一个元素一个元素的删除，不存在就报错 discard 忽略元素，不存在就报错 intersection 交集（你有我也有）相当于& union 并集（你有或者我有）相当于| difference 差集（我有你没有） clear 清空集合

代码示例：（代码仅供参考）

s1 = {1, 2, 6, 7}
s2 = {3, 4}
s1.add(3)
print(s1)

s1.add(3)
print(s1)

s1.update({3, 4, 5})
print(s1)

s1.remove(1)
print(s1)

s1.discard(1)
s1.discard(2)
print(s1)

r = s1.intersection(s2)
print(r)
s1.union(s2)
print(s1)
print(s2)
r2 = s1.difference(s2)  # s1-s2
print(r2)
s1.clear()
s2.clear()
print(s1, s2)

结果：
{1, 2, 3, 6, 7}
{1, 2, 3, 6, 7}
{1, 2, 3, 4, 5, 6, 7}
{2, 3, 4, 5, 6, 7}
{3, 4, 5, 6, 7}
{3, 4}
{3, 4, 5, 6, 7}
{3, 4}
{5, 6, 7}
set() set()

2 元组类型（序列）

Python中的元组与列表类似，是序列类型的一种，不同之处在于元组的元素一旦创建不能修改。元组使用小括号()表示，元素间用逗号分隔，小括号可以省略。

2.1 元组的定义

元组创建很简单，只需要在括号内添加元素，并使用逗号分开即可

2.2 访问元组中的值

可以使用可以使用遍历下标索引来访问元组中的值（len可以返回元组长度)，也可以使用中括号的形式截取字符，还可以利用for循环语句来遍历元组中的值

2.3 元组常见操作（2个）

count ：统计元素出现的次数 print(t.count(元素))
index ：返回元素索引找不到报错 print(t.index(元素))

3 列表类型（序列）

我们可以对列表这样去理解, 就把列表当成一个大桶, 当我们有一堆东西需要找个地方临时存放在一起, 以便后续进行排序, 筛选,提取等操作时, 就弄一个列表, 先放进去。

序列类型的一种，元素间的有序组合，类型不限，创建后可以随时被修改列表使用中括号[]表示，元素间用逗号分隔，括号不可省略列表可以将多个数据有序地组织在一起，更方便调用

3.1 列表的定义

将一些元素放在[]用逗号隔开

3.2 列表的特性

列表属于可变类型列表可以改变
列表中元素可以是任何类型

3.3 列表常用函数

函数名	含义
len(list)	返回列表元素个数
max(list)	返回列表元素的最大值
min(list)	返回列表元素的最小值
list(seq)	将元组转换为列表
id(list)	获取列表对象的内存地址

3.4 列表的常用方法（10个）

列表的常用方法
append	末尾插入只可以插入一个
insert	在指定位置插入
extend	将列表元素依次放入原列表后面
pop	默认删除最后一个元素并返回出来 pop可以通过index指定删除下标内容
remove	删除元素找不到报错
clear	清空列表
count	统计元素出现的次数
index	返回元素索引找不到报错
sort	原列表排序升序
sort(reverse = True)	降序

3.5 列表的原则（做题很有用）

删除不可以改变原列表
删除也不可以改变原列表的索引
删除要从后面删不会改变原列表和原列表的索引

代码示例：（代码仅供参考）

l = [1, 2, 3, 4, 5, 6, 7, 8]
# append 末尾插入  只可以插入一个
l.append(10)
print(l)
#  insert 在指定的地方插入内容
l.insert(4, 4.5)
print(l)
#  extend 将列表元素依次放入原列表
l.extend([11, 12, 13])
print(l)
# pop 默认删除最后一个元素 并返回出来
l.pop()
print(l)
# pop 通过index删除指定下表内容
# 如果列表为空 或者越界 返回错误
l.pop(4)
print(l)
# remove删除指定元素 没有返回值
#   找不到报错
#  每次只删除一个 第一个
l.remove(11)
print(l)
# clear 清空列表
l.clear()
print(l)
# count 统计元素出现的次数
l.append(5)
l.append(100)
l.append(20)
print(l)
l1 = l.count(5)
print(l1)
# index 返回元素索引 找不到会报错
l2 = l.index(20)
print(l2)
l3 = l.index(100)
print(l3)
# reverse  原列表倒序
l.reverse()
print(l)
# sort  原列表排序 默认升序   reverse = True 默认降序
l.sort()
print(l)
l.sort(reverse=True)
print(l)

结果：
[1, 2, 3, 4, 5, 6, 7, 8, 10]
[1, 2, 3, 4, 4.5, 5, 6, 7, 8, 10]
[1, 2, 3, 4, 4.5, 5, 6, 7, 8, 10, 11, 12, 13]
[1, 2, 3, 4, 4.5, 5, 6, 7, 8, 10, 11, 12]
[1, 2, 3, 4, 5, 6, 7, 8, 10, 11, 12]
[1, 2, 3, 4, 5, 6, 7, 8, 10, 12]
[]
[5, 100, 20]
1
2
1
[20, 100, 5]
[5, 20, 100]
[100, 20, 5]

3.6 列表的反转

代码实现

l = [5, 56, 52, 25, 65]
for i in l:
    l.reverse()
print(l)


结果：
[65, 25, 52, 56, 5]

3.7 列表的切片训练

代码实现

s = "abcdefg"
# 索引下标只需要使用一个数字
print(s[0], s[6])
# 索引下标 起点:
print(s[0:])
# 索引下标两个 起点 ： 终点（不包含）
print(s[0:7])
# 索引下标 三个 起点 终点 步长
# print(s[start:end:step])
print(s[0:7:1])
print(s[0:7:2])
# 第三个数为-1 默认倒序
print(s[::-1])
# 如果第三个数为-1 前面使用负的索引
print(s[-1:-7:-1])
print(s[-1:-8:-1])
# [0, len-1]  [-1, -len]
print(s[-7])

结果：
a g
abcdefg
abcdefg
abcdefg
aceg
gfedcba
gfedcb
gfedcba
a

4 字典类型

4.1 字典介绍

字典是另一种存储数据的格式。字典的每个元素都由两部分组成（列表的每个元素只有一个部分），前一部分称为键，后一部分称为值，中间用冒号相连。
字典类型是键值对的集合，反映了数据之间的映射关系
字典使用大括号{}表示，键值间用冒号分隔，键值对间用逗号分隔
访问字典中键对应的值使用[] 内部使用键的名称
如果设置字典中的键值对使用dict[key]=value 如果key不存在则添加一个键值对如果key存在则value 覆盖
键的键值对：键是不可改变的类型(字符串元组数字布尔)

4.2 字典的遍历

获取字典的键 key ：for key in d1.keys():
获取字典的值 value ： for value in d1.values():
获取字典的键值对 items ： for key, value in d1.items():

# 获取字典的键 key
for key in d1.keys():
    print(key, d1[key])
# 获取字典的值 value
for value in d1.values():
    print(value)
# 获取字典的键值对 items
for key, value in d1.items():
    print(key,value)

4.3 字典的常用方法（10个）

字典的常用方法
keys	返回所有的键
values	返回所有的值
items	返回所有的键值对
update	合并一个字典到原始的字典
get	返回键对应的值
setdefault	设置键值对键不存在返回None
pop	删除指定的键值对并返回键值对的值
popitem	删除最后一个键值对返回删除的键值对元组
clear	删除所有的键值对
fromkeys	静态方法：类名调用

d1 = {
    "name":"耿耀",
    "addr":"鹤壁",
    "like":"美女",
    "age":"21"
}
d2 = {
    "ht":"168",
    "wt":"153"
}
d3 = {
    "age":"22"
}
d1.update(d2)
d1.update(d3)
print(d1)
# get 返回键对应的值
# 如果键不存在返回None
# 或者返回默认值， 第二个参数
d = d1.get("age")
d4 = d1.get("sex")
d5 = d1.get("sex","女")
print(d)
print(d4)
print(d5)
# setdefault获取某个key的value，如key不存在于字典中，将会添加key并将value设为默认值。
d6 = d1.setdefault("sex","女")
print(d6)
print(d1)
# setdefault 如果键值对存在，则放弃设置
d7 = d1.setdefault("age","23")
print(d7)
print(d1)
print(d1.pop('sex'))
print(d1.popitem())
d1.clear()
print(d1)

结果：
{'name': '耿耀', 'addr': '鹤壁', 'like': '美女', 'age': '22', 'ht': '168', 'wt': '153'}
22
None
女
女
{'name': '耿耀', 'addr': '鹤壁', 'like': '美女', 'age': '22', 'ht': '168', 'wt': '153', 'sex': '女'}
22
{'name': '耿耀', 'addr': '鹤壁', 'like': '美女', 'age': '22', 'ht': '168', 'wt': '153', 'sex': '女'}
女
('wt', '153')
{}