Python数据类型操作

可变数据类型：Set（集合），List(列表)，Dict（字典）

不可变数据类型：Number（数字），String（字符串），Tuple（元组）

所谓可变与不可变，实际指代的内存空间地址，而不是变量的值。声明变量后，则会生成一个内存空间保存变量的值，当修改变量的值，即重新给变量赋值，可变数据类型内存空间地址不会改变，而不可变数据类型则会重新开辟一块内存空间去保存修改的变量值，即内存空间地址会发生变更。

Set

/*声明变量*/

{变量值} #变量值只能是不可变数据类型

/*常见操作*/

set_data_a = {"1", "班级", '123', 99, 0.3, None,}
set_data_b = {99, "姓名"}
print("数据类型 {}{}".format(type(set_data_a), type(set_data_b)))

# 增加元素 add的参数可以是元素也可以是字典
set_data_a.add("add1")
print("集合A添加元素add1 {}".format(set_data_a))

# 删除元素
set_data_a.remove("add1")
print("集合A移除元素add1 {}".format(set_data_a))

# 查询元素
print("当前A集合元素 {}".format(set_data_a))
print("当前B集合元素 {}".format(set_data_b))

# 取两个集合的并集
print("集合并集 {}".format(set_data_a | set_data_b))

# 取两个集合的交集
print("集合交集 {}".format(set_data_a & set_data_b))

# 取两个集合的差集 取出a集合中不包括a集合与b集合交集的元素 # a集合-a交集
print("集合差集 {}".format(set_data_a - set_data_b))

# 取两个集合的对称差集 取出a,b并集中不包括a与b交集的元素  #ab并集-ab交集
print("集合对称集 {}".format(set_data_a ^ set_data_b))

# 拷贝集合
set_data_c = set_data_a.copy()
print("拷贝A集合到C集合 {}".format(set_data_c))

# 清除A集合值
set_data_a.clear()

print("清空A集合 {}".format(set_data_a))

数据类型 <class 'set'><class 'set'>
集合A添加元素add1 {0.3, 99, '1', '123', 'add1', None, '班级'}
集合A移除元素add1 {0.3, 99, '1', '123', None, '班级'}
当前A集合元素 {0.3, 99, '1', '123', None, '班级'}
当前B集合元素 {'姓名', 99}
集合并集 {0.3, 99, '1', '姓名', '123', None, '班级'}
集合交集 {99}
集合差集 {0.3, '1', None, '123', '班级'}
集合对称集 {0.3, '姓名', '1', None, '123', '班级'}
拷贝A集合到C集合 {0.3, 99, '1', '123', None, '班级'}
清空A集合 set()

List

/*声明变量*/

[变量值] #变量值可以是任意数据类型

/*常见操作*/

list_a = [1, None,(1,2), "列表", "c", "c", 1]
list_b = [1, {"班级":"A"}, "示例"]
list_d = [1, 2, 5, 4, 5, 1]
print("数据类型 {}{}".format(type(list_a), type(list_b)))

# 访问指定小标的元素值  步长
print("a列表最后一个元素值 {}".format(list_a[-1]))
print("a列表第一个元素值 {}".format(list_a[0]))
print("a列表第1-3元素值 {}".format(list_a[1:4]))

# 列表追加元素 默认添加为最后一个元素
list_a.append(100)
print("列表A添加元素100 {}".format(list_a))
list_a.insert(1,200)
print("列表A在第二个元素添加元素200 {}".format(list_a))

# c列表拷贝a列表内容
list_c = list_a.copy()
print("拷贝A列表到C列表 {}".format(list_c))

# 清空a列表内容
list_a.clear()
print("清空a列表内容 {}".format(list_a))
list_a.append("add1")
list_a.append("add2")
list_a.append("add3")
list_a.append("add4")
del list_a[0]
print("删除a列表指定元素 {}".format(list_a))

# 移除a列表元素 pop移除最后一个元素 返回移除的元素值
list_a.remove("add2")
print("remove移除a列表指定元素 {}".format(list_a))
print("pop移除a列表元素 {}".format(list_a.pop()))


# 统计元素出现的次数
print("add3元素出现的次数 {}".format(list_a.count("add3")))

# 列表逆序
print("d列表数据 {}".format(list_d))
list_d.reverse()
print("d列表逆序展示 {}".format(list_d))

# 列表排序
list_d.sort()
print("d列表排序 {}".format(list_d))

# 列表转为集合
print("d列表转为集合 {}".format(set(list_d)))

# 列表交集 并集 差集计算
# way1 将列表转为集合再进行取值，但是如果列表中有可变的数据类型，则不适用此方式，因为set的声明，变量值不能包括可变的数据类型
# way2 保留原本所定义的列表数据类型  循环进行取值
list_a.append('示例')
print("a列表数据 {}".format(list_a))
print("b列表数据 {}".format(list_b))
# 交集
common_list=[]
for i in range(len(list_a)):
    if list_a[i] in list_b:
        common_list.append(list_a[i])
print("a列表与b列表交集 {}".format(common_list))
# 并集
union_list = []
for i in range(len(list_a)):
    union_list.append(list_a[i])
for j in range(len(list_b)):
    union_list.append(list_b[j])
print("a列表与b列表并集未去重 {}".format(union_list))
union_list_distinct = []
for _ in range(len(union_list)):
    if union_list[_] not in union_list_distinct:
        union_list_distinct.append(union_list[_])
print("a列表与b列表并集去重 {}".format(union_list_distinct))
# 差集
list_a_difference=[]
for diff in range(len(list_a)):
    if list_a[diff] not  in common_list:
        list_a_difference.append(list_a[diff])
print("a列表与b列表差集 {}".format(list_a_difference))
# 存在判断 any与all
if any(l in "示例999" for l in list_a):
    print("示例any判断存在于a列表")
else:
    print("示例any判断不存在于a列表")

if all(l in "示例999" for l in list_a):
    print("示例all判断存在于a列表")
else:
    print("示例all判断不存在于a列表")
list_number = [1,2,3]
list_string = ["这是A","这是B"]
print("number类型列表 {}".format(list_number))
print("string类型列表 {}".format(list_string))
print("number类型列表转为字符串 {}".format("".join([str(x) for x in list_number])))
print("string类型列表转为字符串 {}".format("".join(list_string)))

数据类型 <class 'list'><class 'list'>
a列表最后一个元素值 1
a列表第一个元素值 1
a列表第1-3元素值 [None, (1, 2), '列表']
列表A添加元素100 [1, None, (1, 2), '列表', 'c', 'c', 1, 100]
列表A在第二个元素添加元素200 [1, 200, None, (1, 2), '列表', 'c', 'c', 1, 100]
拷贝A列表到C列表 [1, 200, None, (1, 2), '列表', 'c', 'c', 1, 100]
清空a列表内容 []
删除a列表指定元素 ['add2', 'add3', 'add4']
remove移除a列表指定元素 ['add3', 'add4']
pop移除a列表元素 add4
add3元素出现的次数 1
d列表数据 [1, 2, 5, 4, 5, 1]
d列表逆序展示 [1, 5, 4, 5, 2, 1]
d列表排序 [1, 1, 2, 4, 5, 5]
d列表转为集合 {1, 2, 4, 5}
a列表数据 ['add3', '示例']
b列表数据 [1, {'班级': 'A'}, '示例']
a列表与b列表交集 ['示例']
a列表与b列表并集未去重 ['add3', '示例', 1, {'班级': 'A'}, '示例']
a列表与b列表并集去重 ['add3', '示例', 1, {'班级': 'A'}]
a列表与b列表差集 ['add3']
示例any判断存在于a列表
示例all判断不存在于a列表
number类型列表 [1, 2, 3]
string类型列表 ['这是A', '这是B']
number类型列表转为字符串 123
string类型列表转为字符串 这是A这是B

Dict

/*声明变量*/

{Key:Value} #变量值可以是任意数据类型

/*常见操作*/

dict_a = {"姓名": "张三", "性别": "女"}
dict_b = {"姓名": "张三", "年龄": 19,"班级":19}
print("数据类型 {}{}".format(type(dict_a),type(dict_b)))
# 打印所有字典项
print("字典a的所有字典项 {}".format(dict_a.keys()))
print("字典a的所有字典值 {}".format(dict_a.values()))


# 根据key获取value值
print("根据key获取value值 {}".format(dict_a.get("姓名")))
print("根据value获取key值 {}".format(dict_a["性别"]))

# 根据value获取key值
for key in dict_a:
    if dict_a[key] == "张三":
        print("a字典根据value值获取key {}".format(key))

# 给key重新赋值
dict_a["性别"] = "男"
print("a字典性别项重新赋值 {}".format(dict_a))

# 增加字典
dict_a["年龄"] = 19
dict_a["爱好"] = "音乐"
dict_a["删除"] = "测试"
dict_a["姓名"] = "李四"
dict_b["课程"] = "数学"
print("a字典添加字典项 {}".format(dict_a))

# 删除字典
del dict_a["删除"]
print("a字典删除字典项 {}".format(dict_a))

# 字典合并 会自动去重
print("a字典原数据 {}".format(dict_a))
print("b字典原数据 {}".format(dict_b))

# 并集 将b字典的数据更新在a字典 如果a b 有共同的key 则b字典的value会覆盖a字典value
dict_a.update(dict_b)
print("a字典与b字典并集 {}".format(dict_a))

数据类型 <class 'dict'><class 'dict'>
字典a的所有字典项 dict_keys(['姓名', '性别'])
字典a的所有字典值 dict_values(['张三', '女'])
根据key获取value值 张三
根据value获取key值 女
a字典根据value值获取key 姓名
a字典性别项重新赋值 {'姓名': '张三', '性别': '男'}
a字典添加字典项 {'姓名': '李四', '性别': '男', '年龄': 19, '爱好': '音乐', '删除': '测试'}
a字典删除字典项 {'姓名': '李四', '性别': '男', '年龄': 19, '爱好': '音乐'}
a字典原数据 {'姓名': '李四', '性别': '男', '年龄': 19, '爱好': '音乐'}
b字典原数据 {'姓名': '张三', '年龄': 19, '班级': 19, '课程': '数学'}
a字典与b字典并集 {'姓名': '张三', '性别': '男', '年龄': 19, '爱好': '音乐', '班级': 19, '课程': '数学'}
a字典与b字典交集 {'姓名', '年龄', '班级', '课程'}

Tuple

/*声明变量*/

(变量值1,变量值2) #变量值可以是任意数据类型

/*常见操作*/

注:不能对元组内的元素进行添加，删除和修改

tuple_a = (1, 2, None)
tuple_b = (1,"这是一个元组", [1, 2], {"姓名": "张三"})
print("数据类型 {}{}".format(type(tuple_a), type(tuple_b)))

print("a元组数据 {}".format(tuple_a))
print("b元组数据 {}".format(tuple_b))

# 元组合并 # 不会自动合并交集
tuple_union = tuple_a+tuple_b
print("a元组和b元组合并 {}".format(tuple_union))

数据类型 <class 'tuple'><class 'tuple'>
a元组数据 (1, 2, None)
b元组数据 (1, '这是一个元组', [1, 2], {'姓名': '张三'})
a元组和b元组合并 (1, 2, None, 1, '这是一个元组', [1, 2], {'姓名': '张三'})

Number

注：Python3已废除Long（长整型）

/*常见操作*/

number_int = 17
print("number_int数据类型 {}".format(type(number_int)))
number_float = 17.59999
print("number_float数据类型 {}".format(type(number_float)))
number_complex = (5+7j)
print("number_complex数据类型 {}".format(type(number_complex)))

# 取整操作
import math
print("float原数据 {}".format(number_float))
print("float取整不精确小数 {}".format(int(number_float)))
print("float向上取整 {}".format(math.ceil(number_float)))
print("float四舍五入 {}".format(round(number_float)))

number_int数据类型 <class 'int'>
number_float数据类型 <class 'float'>
number_complex数据类型 <class 'complex'>
float原数据 17.59999
float取整不精确小数 17
float向上取整 18
float四舍五入 18

String

/*声明变量*/

“变量值” #变量值可以是任意数据类型

/*常见操作*/

string_a = "这是一个个字符串a"
string_b = "这是2个字符串b"
string_c = "aBbeazfrgaNb"
string_d = "12318"
print("a,b数据类型 {}{}".format(type(string_a),type(string_b)))
print("字符串a数据 {}".format(string_a))
print("字符串b数据 {}".format(string_b))
print("字符串c数据 {}".format(string_c))
print("字符串d数据 {}".format(string_d))
# 字符串连接
print("连接两个字符串 {}".format(string_a+string_b))
print("字符串值复制 {}".format(string_a*3))

# 字符串截取
print("截取b字符串前4位 {}".format(string_b[:4]))
print("截取b字符串后4位 {}".format(string_b[-4:]))
print("a字符串逆序输出 {}".format(string_a[::-1]))
# 字符串操作
print("a字符串中是否只包括数字 {}".format(string_a.isdigit()))
print("b字符串中是否只包括数字 {}".format(string_b.isdigit()))
print("b字符串中是否只包括数字 {}".format(string_d.isdigit()))
print("c字符串全转为小写 {}".format(string_c.lower()))
print("c字符串全转为大写 {}".format(string_c.upper()))
print("c字符串只保留首字母大写 {}".format(string_c.capitalize()))
# 字符串判断
if "个" in string_a:
    print("该字符存在于a字符串中")
if "好" not in string_a:
    print("该字符不存在于a字符串中")

a,b数据类型 <class 'str'><class 'str'>
字符串a数据 这是一个个字符串a
字符串b数据 这是2个字符串b
字符串c数据 aBbeazfrgaNb
字符串d数据 12318
连接两个字符串 这是一个个字符串a这是2个字符串b
字符串值复制 这是一个个字符串a这是一个个字符串a这是一个个字符串a
截取a字符串前4位 这是2个
截取a字符串后4位 字符串b
a字符串逆序输出 a串符字个个一是这
a字符串中是否只包括数字 False
b字符串中是否只包括数字 False
b字符串中是否只包括数字 True
c字符串全转为小写 abbeazfrganb
c字符串全转为大写 ABBEAZFRGANB
c字符串只保留首字母大写 Abbeazfrganb
该字符存在于a字符串中
该字符不存在于a字符串中