Python六大基本数据类型

Python常见的数据类型

六个标准的数据类型

• Number(数字)
• String(字符串)
• List(列表)
• Tuple(元组)
• Set(集合)
• Dictionary(字典) --》dict

六大数据类型又可以划分为：

不可变数据（3个）：Number、String、Tuple

可变数据（3个）:List、Dictionary、Set

一、数字类型（Number）

int（整型）、float（浮点型）、complex（复数）

Python3 整型是没有限制大小的，可以当作 Long 类型使用，所以 Python3 没有 Python2 的 Long 类型。**布尔(bool)**是整型的子类型。 ---- 》Boolean

bool类型：0 ==False 1 ==True （注意：布尔值可以相加，相加之后类型就会转换为int类型）

常用的数值函数

abs(x)取得数字的绝对值

ceil(x)返回数字的上入整数

floor(x)返回数字的下舍整数

random.random()返回随机生成的一个实数，它在[0,1)范围内。

random.randint(a,b)返回随机生成一个整数，在a~b之间的整数

import math
import random

# 定义number类型
num1 = 1
num2 = 2.1
num3 = False
print(num1)

print(type(num1), type(num2), type(num3))   # 打印数据类型
print(num1 ** 2)

print(9 / 2)
print(9 // 2.0)    # //获取得到与除数类型是一致，不会进行四舍五入，/返回值类型为float

print(abs(num1))
print(" floor(x)返回数字的下舍整数:", math.floor(4.0))
print(" ceil(x)返回数字的上入整数", math.ceil(5.1))
print(" random.random()返回随机生成的一个实数，它在[0,1)范围内:", random.random())

print("random.randint(a,b)返回随机生成一个整数，在a~b之间的整数:", random.randint(100, 200))
# random.randint(a,b)返回随机生成一个整数，在a~b之间的整数")

print(round(4.7), round(4.78, 1))   # 进行四舍五入

print(math.trunc(4.7))    # 去掉整数部分 math.trunc

二、字符串类型（String）

通过单引号和双引号引起来的值就是字符串str类型。

字符串切片

语法格式：变量[start：end：step] 特别注意规则： 含头不含尾 左闭右开

start:开始索引值 索引值从左到右 从0开始 索引值从右到左，从‐1开始

end：结束索引值

step：步长 默认是1

格式化

# 字符串格式表示方式一
print("%s[%s期，工作年限：%d],欢迎"%("大雨","M211",3))

# 字符串格式表示方式二
print("{1}[{0}期，工作年限：{2}],欢迎".format("大雨","M211",3))

# 字符串格式表示方式三 f 字面量格式化
name="大雨"
q="M211"
year="2"
print(f"{name}[{q}期，工作年限：{year}],欢迎")

字符串常见函数

join:通过分隔符合并一个新的字符

split：通过分隔符截图多个字符，存储在列表中

replace

index

count

# join(seq)
# 以指定的分隔符把seq中的元素合并成一个新字符串 join 加入‐‐‐某个规则符号+合并
join_str="helloworld"
new_str="‐".join(join_str)
print(new_str)

# split()
# 通过分隔符截取字符串 通过分隔符，返回列表数据
names="hefan;大雨;志大叔"
namel=names.split(";")
print(namel,type(namel))
# replace(原字符, 新字符)
# 替换字符串
str_old="1234567"
new_str=str_old.replace("123","000")
print(new_str)
# find(查找字符, 开始索引，结束索引值)查找字符串，找到返回开始索引值，没有找到返回‐1
ss_str="12345678"
print(ss_str.find("8"))
# index ‐‐>find区别在于，index如果没有找到则报错
ss_str="12345678888"
print(ss_str.index("8"))
# count(查询字符, 开始索引，结束索引值) 返回某个字符在指定范围出现次数
print(ss_str.count("0"))
# startswith(匹配字符, 开始索引，结束索引值) 判断是否以某个字符开头
print(ss_str.startswith("123"))
# endswith(匹配字符, 开始索引，结束索引值) 判断是否以某个字符结尾
print(ss_str.endswith("123"))

三、列表类型（List）

列表是经常用到的数据类型，其元素可以是字符串、数字、列表、元组等自定义的对象。列表是以[]定义，用英文逗号分隔开的集合，元素是可以重复的。

list1 = [1, 2, 3, 4, "baby", [1, 2, 3], (1, 2, 3)]
print(list1)
print(type(list1))
# 获取列表中最后一个元素   某个位置元素  或者部分元素  -----》切片 变量名[开始索引:结束索引：步长]
print(list1[-1])
print(list1[:4])
del list1[0]
print(list1)
# 列表也是可以支持运算   + * in/not in
list1 = list1 + ["hefan", "dingdong"]
print(list1)
print(list1 * 3)

"""
list常见内置函数
操作：添加/删除/查找、修改 元素

"""
# 操作：添加元素append()
list2 = [1, 2, 3, 4, 5]
list2.append(6)  # 做增加操作
print(list2)
# 增加0，最前面    insert(index,object)指定位置插入值
list2.insert(0, "大雨")
print(list2)
# 需要批量添加多个值到列表中 6,7,8,9,10
list2.extend([6, 7, 8, 9, 10])
print(list2)
# 删除
# list2.pop()   #不传入索引值，则删除最后一个，否则删除指定索引值的元素  pop()返回删除的值
print(list2)
del_value = list2.pop(0)
print(del_value)
print(list2)
list2.clear()  # 清空列表
print(list2)
list3 = [20, 9, 1, 2, 3, 4, 5, 6]
copy_list = list3.copy()
print(copy_list)
list3.remove(6)  # remove与pop区别？   remove--根据值进行删除 pop---》根据索引删除
print(list3)
# 查找
print(list3.index(2))  # 查找到返回值的索引值，否则抛出异常
# 查找某个元素在列表中出现的次数
print(list3.count(1))
# 列表进行排序
list3.sort()
print(list3)
# 列表反转
list3.reverse()
print(list3)

四、元组(Tuple)

tuple(元组)是不可变数据类型，元组写在()里，元素之间用,隔开，各元素类型可以不相同。

创建空元组tup1=();

创建只包含一个元素的元组,元素后面加逗号 tup1=(12,)

元组跟字符串一样可以支持切片

元组中的元素是不允许修改，但是可以对元组进行连接

删除元组用del

元组运算符（+，*，in/not in）

# 定义元组,元组可以存储多个数据
tup1 = (1, 2, "abc", 2.0)
print(type(tup1))
print(tup1)
# 创建空元组
tup2 = ()
print(type(tup2))
print(tup2)
# 只有一个元素的元组 1
tup3 = (1,)
print(type(tup3))
# 获取元组中某个数据的值或者多个数据的值 ‐‐‐‐‐>切片
print(tup1[0], tup1[:1])
print(tup1[::1])

new_tup = tup1 + tup3
print(new_tup)
del new_tup
# 元组运算符 + * 重复 in 存在 not in 不存在
new_tup = tup3 * 3
print(new_tup)

tup4 = (1, 2, 3, 4, 5, 6)
if 1 in tup3:
    print("存在")
else:
    print("不存在")

good = "棒！"
print(good * 10)

五、集合(Set)

集合Set是一个无序且不可重复的序列，使用{}或set()函数进行创建，如果想创建一个空集合必须用 set() ，{ } 是用来创建一个空字典的。
注意：只支持不可变数据类型string,number,tuple,不支持可变数据类型(dict,set,list)

set1 = {1, 2, 3, 4, (1, 2, 3)}
print(set1)
print(type(set1))
# 创建空集合
null = set()
print(null)
print(type(null))
# 运算
# 交集  A & B  取两个集合的相同元素
A = {1, 2, 3, 4, 5}
B = {6, 7, 8, 9, 10, 5, 4}
print(A, B)
new = A & B
print(new)
print("交集：", A.intersection(B))

# 并集  |  合并A、B集合，返回集合既包含A集合所有元素也会包含B集合的所有元素
new1 = A | B
print(new1)
print("并集", A.union(B))
# 差集  A-B  返回A集合的所有元素，但是不会包含B中的元素
print(A - B)
print("差集", A.difference(B))
# 异或 ^  A^B  返回两个集合相同元素之外的其他元素的集合
print(A ^ B)
print("异或", A.symmetric_difference(B))
#
son = {6, 10}
print(son.issubset(A))

# 8、把元组(1,2,3,4,5,6)元素格式化成字符串
tupl = (1, 2, 3, 4, 5, 6)
new = f"{tupl}"
new1 = "{0}".format(tupl)
print(new)
print(type(new))

六、字典(Dictionary) --》dict

字典以键值对（key: value）的方式存储对象。例如{ key1:value1,key2:value2,…}
1、key不可以重复的，否则取最后的值 key唯一值。key必须是不可变数据类（number,string,tuple）
2、值(value)可以是任意对象，比如None、数值、字符串、字典等。

info = {"name": "修习人生", "class": "M21"}
# 字典中某个元素值  ---->字典不能通过索引位置值来进行取值  取值：变量名[key]
print(info["name"], info["class"])
print(info.get("name"))
# 修改元素的值 --->value
info["class"] = "M21"
info["adree"] = "深圳"
print(info)
# 删除元素
del info["adree"]
print(info)
info1 = info.copy()
info.clear()
print(info)
print(info1)
# 创建一个字典，key确定，值不太确定，设置value-->默认值null
keys = ["name", "class", "adress", "xz"]
info2 = dict.fromkeys(keys, "null")
print(info2)
# 需要循环读取到字典中所有的数据key,value
for x, y in info1.items():
    print(x, y)
# 字典合并  --->更新字典
print(info1)
add = {"xz": 18000, "qwxz": 25000}
info1.update(add)
print(info1)
# 删除
print(info1)
# info1.pop("class")   #根据key进行删除
# print(info1)
info1.popitem()  # 默认删除最后一个元素
print(info1)
info1.clear()
print(info1)
del info1

小结：

列表[ ]（list）：有序可改变集合，允许重复数据。
元组( )（tuple）：有序不可改变集合，允许重复数据。
集合{ }（set）：无序无索引（索引为键值）集合，无重复数据。
字典{ }（dictionary）：无序，可变，有索引集合，无重复数据。