python数据类型之字符串、字典、元组

一、数字类型

1、number类型

Python Number 数据类型用于存储数值。

数据类型是不允许改变的,这就意味着如果改变 Number 数据类型的值，将重新分配内存空间。

以下实例在变量赋值时 Number 对象将被创建：

var1 = 1
var2 = 10

也可以使用del语句删除一些 Number 对象引用。

del语句的语法是：

del var1[,var2[,var3[....,varN]]]]

可以通过使用del语句删除单个或多个对象，例如：

del var
del var_a, var_b

Python 支持四种不同的数值类型：

整型(Int) - 通常被称为是整型或整数，是正或负整数，不带小数点。
在Python 3里，只有一种整数类型 int，表示为长整型，没有 python2 中的 Long。

Python可以处理任意大小的整数，当然包括负整数，在程序中的表示方法和数学上的写法一模一样，例如：1，100，-8080，0，等等。

计算机由于使用二进制，所以，有时候用十六进制表示整数比较方便，十六进制用0x前缀和0-9，a-f表示，例如：0xff00，0xa5b4c3d2，等等。

对于很大的数，例如10000000000，很难数清楚0的个数。Python允许在数字中间以_分隔，因此，写成10_000_000_000和10000000000是完全一样的。十六进制数也可以写成0xa1b2_c3d4。
长整型(long integers) - 无限大小的整数，整数最后是一个大写或小写的L。
浮点型(floating point real values) - 浮点型由整数部分与小数部分组成，浮点型也可以使用科学计数法表示（2.5e2 = 2.5 x 102 = 250），
浮点数也就是小数，之所以称为浮点数，是因为按照科学记数法表示时，一个浮点数的小数点位置是可变的，比如，1.23x109和12.3x108是完全相等的。浮点数可以用数学写法，如1.23，3.14，-9.01，等等。但是对于很大或很小的浮点数，就必须用科学计数法表示，把10用e替代，1.23x109就是1.23e9，或者12.3e8，0.000012可以写成1.2e-5，等等。

整数和浮点数在计算机内部存储的方式是不同的，整数运算永远是精确的（除法难道也是精确的？是的！），而浮点数运算则可能会有四舍五入的误差。
复数(complex numbers) - 复数由实数部分和虚数部分构成，可以用a + bj,或者complex(a,b)表示，复数的实部a和虚部b都是浮点型。

int	long	float	complex
10	51924361L	0.0	3.14j
100	-0x19323L	15.20	45.j
-786	0122L	-21.9	9.322e-36j
080	0xDEFABCECBDAECBFBAEl	32.3+e18	.876j
-0490	535633629843L	-90.	-.6545+0J
-0x260	-052318172735L	-32.54e100	3e+26J
0x69	-4721885298529L	70.2-E12	4.53e-7j

长整型也可以使用小写"L"，但是还是建议您使用大写"L"，避免与数字"1"混淆。Python使用"L"来显示长整型。
Python还支持复数，复数由实数部分和虚数部分构成，可以用a + bj,或者complex(a,b)表示，复数的实部a和虚部b都是浮点型

2、浮点型（float）

浮点型，一般在开发中用于表示小数。

v1 = 3.14
v2 = 9.89

关于浮点型的其他知识点如下：

在类型转换时需要，在浮点型转换为整型时，会将小数部分去掉。
```
v1 = 3.14 
data = int(v1)
print(data) # 3
```

想要保留小数点后N位

v1 = 3.1415926
result = round(v1,3)
print(result) # 3.142

浮点型的坑（所有语言中）

v1 = 0.1
v2 = 0.2
print(v1 + v2) # 0.30000000000000004

在项目中如果遇到精确的小数计算应该怎么办？

import decimalv1 = decimal.Decimal("0.1")
v2 = decimal.Decimal("0.2")
v3 = v1 + v2
print(v3) # 0.3

3、数字类型转换

对数据内置的类型进行转换，数据类型的转换，只需要将数据类型作为函数名即可。

int(x) 将x转换为一个整数。
float(x) 将x转换到一个浮点数。
complex(x) 将x转换到一个复数，实数部分为 x，虚数部分为 0。
complex(x, y) 将 x 和 y 转换到一个复数，实数部分为 x，虚数部分为 y。x 和 y 是数字表达式。

以下实例将浮点数变量 a 转换为整数：

>>> a = 1.0
>>> int(a)
1

4、数字运算

二、字符串

1、字符串格式化

https://www.cnblogs.com/wupeiqi/articles/5484747.html

三、None类型

None也是一个数据类型，只有一个值就是None，意味着表是空，相当于其他语言 null 一样

一定程度上可以帮我们节省内存

v1 = []v1 = ['a','b']# 使用None初始化
v1 = Nonev1 = ['a','b']

None可以自动转化成布尔值为false

v1 = None
if v1:print("test")
else:print("do...")  # 执行if None:pass

目前所有转换为布尔值为False的值有：

0
""
[] or list()
() or tuple()
set()
None

四、字典

1、定义字典

字典是有序（3.6+以前无序）、键不重复 且元素只能是键值对的可变的 个容器。键不重复，重复则会被覆盖

如下定义一个字典

# 使用大括号 {} 来创建空字典
test_dic1 = {}
# 使用内建函数 dict() 创建字典：
test_dic2 = dict()
# 创建有值得字典
info = {"age": 12,"status": True,"name": "测试","hobby": ['篮球', '足球'],(11, 22, 33): ["alex", "eric"],True: 5,12: 10
}# 打印字典
print(info)  # {'age': 12, 'status': True, 'name': '测试', 'hobby': ['篮球', '足球'], (11, 22, 33): ['alex', 'eric'], True: 5, 12: 10}
# 查看字典大小
print(len(info))  # 7
# 字典类型
print(type(info))  # <class 'dict'>

字典中对键值得要求：

键：必须可哈希。目前为止学到的可哈希的类型：int/bool/str/tuple；不可哈希的类型：list/set/dict。（集合）
值：任意类型。

如下的字典是不合法的

# 不合法
v1 = {[1, 2, 3]: '周杰伦',"age" : 18
} 
v2 = {{1,2,3}: "哈哈哈",'name':"alex"
} v3 = {{"k1":123,"k2":456}: '呵呵呵',"age":999
}

注意：字典里如何一个key是1或0，另一个是True或False,会替换掉，如下


test = {1: 5, True: 6}
print(test)  # 打印结果是{1: 6}

一般在什么情况下会用到字典呢？

当我们想要表示一组固定信息时，用字典可以更加的直观，例如：

# 用户列表
user_list = [ ("alex","123"), ("admin","666") ]
# 用户列表 字典表示
user_list = [ {"name":"alex","pwd":"123"}, {"name":"eric","pwd":"123"} ]

2、获取字典值

info = {"age": 12,"status": 0,"name": "测试","data": None
}# 获取值
name = info.get("name")
email = info.get("email")  # 如果键不存在返回 None
data = info.get("data")  # 注意:如果值是None 返回结果就是值Noneif name:print("键name存在，值是", name)  # 打印
if email:print("键email存在，值是", email)  # 不打印
if data:print("键data存在，值是", data)  # 不打印

3、所有键

info = {"age": 12,"status": 0,"name": "测试","data": None
}# 所有键
keys = info.keys()
print(keys)'''
python3输出 dict_keys(['age', 'status', 'name', 'data'])
但是python2输出['age', 'status', 'name', 'data']
Python3中返回的是高仿列表，这个高仿的列表可以被循环显示
'''
# 循环
for ele in info.keys():print(ele)
# 当然也可以通过list将高仿的列表转成列表
result = list(keys)
print(result)  # ['age', 'status', 'name', 'data']# 获取所有键 也可以直接用for循环
for item in info:print(item)

4、是否存在键

info = {"age": 12,"status": 0,"name": "测试","data": None
}# 是否存在键
# 方式1（推荐）
if "name" in info:print("info存在键name")
# 方式2
if "name" in info.keys():print("info存在键name")

5、所有值

info = {"age": 12,"status": 0,"name": "测试","data": None
}# 所有值
values = info.values()
print(values)
'''
python3输出 dict_values([12, 0, '测试', None])
python2输出 [12, 0, '测试', None]
python3输出高仿列表这个高仿的列表可以被循环显示
'''
# 循环
for v in values:print(v)# 当然通过list可以将高仿列表转成列表
value1 = list(values)
print(value1)

6、是否存在值

info = {"age": 12,"status": 0,"name": "测试","data": None
}# 是否存在值
if "测试" in info.values():print("info 存在值 测试")

7、所有键值对

info = {"age": 12,"status": 0,"name": "测试","data": None
}# 所有的键值
item1 = info.items()
print(item1)  # dict_items([('age', 12), ('status', 0), ('name', '测试'), ('data', None)])for item in info.items():print(item[0], item[1])  # item是一个元组 (键，值)for key, value in info.items():print(key, value)  # key代表键，value代表值，将键和值从元组中直接拆分出来了。

8、是否存在键值对

info = {"age": 12,"status": 0,"name": "测试","data": None
}
# 是否存在键值
if ('age', 12) in info.items():print("在")
else:print("不在")

9、设置值

info = {"age": 12,"status": 0,"name": "测试","data": None
}
# 设置值
info.setdefault("email", "test@163.com")
print(info)  # {'age': 12, 'status': 0, 'name': '测试', 'data': None, 'email': 'test@163.com'}info.setdefault("name", "test")  # 如果键存在 则不设置
print(info)  # {'age': 12, 'status': 0, 'name': '测试', 'data': None, 'email': 'test@163.com'}

10、更新键值对

info = {"age": 12,"status": 0,"name": "测试","data": None
}
# 更新值
info.update({"age": 14, "name": "test"})  # info中没有的键直接添加；有的键则更新值
print(info)  # {'age': 14, 'status': 0, 'name': 'test', 'data': None}

11、移除指定键值对

info = {"age": 12,"status": 0,"name": "测试","data": None
}
# 移除指定键值对
info.pop("age")
print(info)  # {'status': 0, 'name': '测试', 'data': None}

12、按照顺序移除（后进先出）

info = {"age": 12,"status": 0,"name": "测试","data": None
}
# 按顺序移除
data = info.popitem()
print(info)  # {'age': 12, 'status': 0, 'name': '测试'}
print(data)  # ('data', None) 被移除的被自动转成了一个元祖

py3.6后，popitem移除最后的值。
py3.6之前，popitem随机删除。

13、求并集

（Python3.9新加入）

v1 = {"k1": 1, "k2": 2}
v2 = {"k2": 22, "k3": 33}v3 = v1 | v2
print(v3) # {'k1': 1, 'k2': 22, 'k3': 33}

14、索引（键）

字典不同于元组和列表，字典的索引是键，而列表和元组则是 0、1、2等数值 。

info = {"age": 12,"status": 0,"name": "测试","data": None
}print(info["age"])  # 输出：12
print(info["xxxx"])  # 报错，通过键为索引去获取之后时，键不存在会报错（以后项目开发时建议使用get方法根据键去获取值）value = info.get("xxxxx")  # None
print(value)

15、根据索引键修改值和添加值和删除键值对

上述示例通过键可以找到字典中的值，通过键也可以对字典进行添加和更新操作

info = {"age": 12,"status": 0,"name": "测试","data": None
}# 增加键值对
info["gender"] = "男"
print(info)  # {'age': 12, 'status': 0, 'name': '测试', 'data': None, 'gender': '男'}# 更新键值对
info["age"] = 18
print(info)  # {'age': 18, 'status': 0, 'name': '测试', 'data': None, 'gender': '男'}# 删除键值对
del info["age"]  # 删除info字典中键为age的那个键值对（键不存在则报错）
print(info)  # 输出： {'status': 0, 'name': '测试', 'data': None, 'gender': '男'}

16、转换

v = dict([("k1", "v1"), ["k2", "v2"]])print(v)  # { "k1":"v1", "k2":"v2" }
info = {"age": 12, "status": True, "name": "test"}
v1 = list(info)  # ["age","status","name"]
v2 = list(info.keys())  # ["age","status","name"]
v3 = list(info.values())  # [12,True,"test"]
v4 = list(info.items())  # [ ("age",12), ("status",True), ("name","test") ]

17、嵌套

# 字典的键必须可哈希（list/set/dict不可哈希）
info = {(11, 22): 123
}# 错误
info = {(11, [11, 22, ], 22): "alex"
}# 字典的值可以是任意类型
info = {"k1": {12, 3, 5},"k2": {"xx": "x1"}
}# 字典的键和集合的元素在遇到 布尔值 和 1、0 时，需注意重复的情况。如下实际为1:3
info = {1: 0,True: 3
}
# 元组的元素不可以被替换
dic = {'name': 'test','age': 48,'wife': [{'name': 'aaa', 'age': 38}, {'name': 'bbb', 'age': 48}],'children': ['第一个娃', '第二个娃']
}
"""
1. 获取test的妻子名字d1 = dic['wife'][0]['name']print(d1)
2. 获取test的孩子们d2 = dic['children']print(d2)
3. 获取test的第一个孩子d3 = dic['children'][0]print(d3)
4. test的媳妇姓名变更为 cccdic['wife'][0]['name'] = "ccc"print(dic)
5. test再娶一任妻子dic['wife'].append( {"name":"铁锤","age":19} )print(dic)6. 给test添加一个爱好：吹牛逼dic['hobby'] = "吹牛逼"print(dic)
7. 删除test的年龄del dic['age']或dic.pop('age')print(dic)
"""

五、元组

1、定义

列表（list），是一个有序且可变的容器，在里面可以存放多个不同类型的元素。

元组（tuple），是一个有序且不可变的容器，在里面可以存放多个不同类型的元素。

Python 的元组与列表类似，不同之处在于元组的元素不能修改。

元组使用小括号 ( )，列表使用方括号 [ ]。

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

tup1 = ('Google', 'Runoob', 1997, 2000)
tup2 = (1, 2, 3, 4, 5 )
tup3 = "a", "b", "c", "d"   #  不需要括号也可以

创建空元组

tup1 = ()

建议在元组的最后多加一个逗号，用于标识他是一个元组。特别是元组中只包含一个元素时，需要在元素后面添加逗号 , ，否则括号会被当作运算符使用：

>>> tup1 = (50)
>>> type(tup1)     # 不加逗号，类型为整型
<class 'int'>>>> tup1 = (50,)
>>> type(tup1)     # 加上逗号，类型为元组
<class 'tuple'>

元组与字符串类似，下标索引从 0 开始，可以进行截取，组合等。

user_list = ("范德彪","刘华强",'尼古拉斯赵四',)
print( user_list[0] )
print( user_list[2] )
print( user_list[3] )#切片
print( user_list[0:2] )
print( user_list[1:] )
print( user_list[:-1] )#步长演示
user_list = ("范德彪","刘华强",'尼古拉斯赵四',"宋小宝","刘能")
print( user_list[1:4:2] )
print( user_list[0::2] )
print( user_list[1::2] )
print( user_list[4:1:-1] )

2、访问元组

元组可以使用下标索引来访问元组中的值，如下实例:

tup1 = ('Google', 'Runoob', 1997, 2000)
tup2 = (1, 2, 3, 4, 5, 6, 7 )print ("tup1[0]: ", tup1[0])
print ("tup2[1:5]: ", tup2[1:5])结果
tup1[0]:  Google
tup2[1:5]:  (2, 3, 4, 5)

3、获取长度

user_list = ("范德彪","刘华强",'尼古拉斯赵四',)
print( len(user_list) )

4、 for循环

# in 运算符
user_list = ("范德彪","刘华强",'尼古拉斯赵四',"宋小宝","刘能")
for item in user_list:print(item)# 下标user_list = ("范德彪","刘华强",'尼古拉斯赵四',"宋小宝","刘能")
for item in user_list:if item == '刘华强':continueprint(name)#目前：只有 str、list、tuple 可以被for循环。 "xxx"  [11,22,33]  (111,22,33) 
# len + range + for + 索引
user_list = ("范德彪","刘华强",'尼古拉斯赵四',"宋小宝","刘能")
for index in range(len(user_list)):item = user_list[index]print(item)

5、修改元组

元组中的元素值是不允许修改的，但我们可以对元组进行连接组合，如下实例:

tup1 = (12, 34.56)
tup2 = ('abc', 'xyz')# 以下修改元组元素操作是非法的。
# tup1[0] = 100# 创建一个新的元组
tup3 = tup1 + tup2
print (tup3) # (12, 34.56, 'abc', 'xyz')

6、删除元组

元组中的元素值是不允许删除的，但我们可以使用del语句来删除整个元组，如下实例:

#!/usr/bin/python3tup = ('Google', 'Runoob', 1997, 2000)print (tup)
del tup
print ("删除后的元组 tup : ")
print (tup)以上实例元组被删除后，输出变量会有异常信息，输出如下所示：
删除后的元组 tup : 
Traceback (most recent call last):File "test.py", line 8, in <module>print (tup)
NameError: name 'tup' is not defined

7、元组运算符

与字符串一样，元组之间可以使用 +、+=和 * 号进行运算。这就意味着他们可以组合和复制，运算后会生成一个新的元组。

相加：两个列表相加获取生成一个新的列表。

data = ("赵四","刘能") + ("宋晓峰","范德彪")
print(data) # ("赵四","刘能","宋晓峰","范德彪")v1 = ("赵四","刘能")
v2 = ("宋晓峰","范德彪")
v3 = v1 + v2
print(v3) # ("赵四","刘能","宋晓峰","范德彪")

相乘，列表*整型将列表中的元素再创建N份并生成一个新的列表。

data = ("赵四","刘能") * 2
print(data) # ("赵四","刘能","赵四","刘能")v1 = ("赵四","刘能")
v2 = v1 * 2
print(v1) # ("赵四","刘能")
print(v2) # ("赵四","刘能","赵四","刘能")

8、元组索引，截取

因为元组也是一个序列，所以我们可以访问元组中的指定位置的元素，也可以截取索引中的一段元素，如下所示：元组：>>> tup = ('Google', 'Runoob', 'Taobao', 'Wiki', 'Weibo','Weixin')
>>> tup[1]
'Runoob'
>>> tup[-2]
'Weibo'
>>> tup[1:]
('Runoob', 'Taobao', 'Wiki', 'Weibo', 'Weixin')
>>> tup[1:4]
('Runoob', 'Taobao', 'Wiki')
>>>

9、转换

其他类型转换为元组，使用tuple(其他类型)，目前只有字符串和列表可以转换为元组。

name = "测试"
data = tuple(name)
print(data) # 输出 ("测","试")name = ["测试",18,"pythonav"]
data = tuple(name)
print(data) # 输出 ("测试",18,"pythonav")

10、嵌套

由于元组和列表都可以充当容器，他们内部可以放很多元素，并且也支持元素内的各种嵌套。

tu = ( 'a', 'b', ('c','d') )
tu1 = tu[0]
tu2 = tu[1]
tu3 = tu[2][0]
tu4 = tu[2][1]
tu5 = tu[2][1][3]print(tu1) # a
print(tu2) # b
print(tu3) # c
print(tu4) # d

11、关于元组是不可变的

所谓元组的不可变指的是元组所指向的内存中的内容不可变。

>>> tup = ('r', 'u', 'n', 'o', 'o', 'b')
>>> tup[0] = 'g'     # 不支持修改元素
Traceback (most recent call last):File "<stdin>", line 1, in <module>
TypeError: 'tuple' object does not support item assignment
>>> id(tup)     # 查看内存地址
4440687904
>>> tup = (1,2,3)
>>> id(tup)
4441088800    # 内存地址不一样了

从以上实例可以看出，重新赋值的元组 tup，绑定到新的对象了，不是修改了原来的对象。