python之数据类型进阶(字符串、列表的切片使用，列表、字典如何修改、插入、删除数据)（超全，超详细！！！）（6）

前言

在开发程序中，会频繁的涉及到对数据的操作，为了提升我们的开发效率，python内置了许多对不同数据进行操作的方法，本章知识点可能会比较多，我会整理一些相对常用的方法，但数据类型的操作方法远不止这些，需要大家自己去扩展

本章说明：：
本篇内容主要讲解各数据类型的进阶操作和使用方法，并扩展一些操作中常见的知识点，一些基础的知识和说明会进行省略，对本篇有疑惑的小伙伴可以先去看我前面的文章；链接如下：
python入门基础-数据类型：http://t.csdnimg.cn/KkYzu

1、数据类型详解

1.1 int（整型）和 float（浮点型）

在 python中所有数值都可以用 int和float 来表示，他们的取值范围是无限的；不用像其他语言一样需要许多不同的方法来表示；在这一点上python就十分方便

1.1.1 扩展点

1. 数字分隔符
   通过下划线分隔数字，提高代码可读性；如：

print(12345)
print(123_45)
print(1_2_34_5)
# 输出结果都为 12345；加下划线只是方便观看，通常用于较大的数值，本身没有任何意义，不会影响原本的值

2. int() 的使用方法

• 将其它进制类型的数字转为十进制
• 将只有数字的字符串转为十进制，注意，字符串必须全部由数字组成，才能转换成功
  如：

print(int(0x110)) # 八进制转十进制，输出结果：272
print(int('110')) # 字符串 110 转为 十进制 110，输出结果：110

1.2 字符串型（str）

若干个字符的集合就是一个字符串（string）
python中字符串必须用单引号 '' 或 双引号 ""包裹，两者没有任何区别
字符串的内容可以是任意字母、标点、特殊符号、中文、英文等全世界所有语言

1.2.1 字符串索引

字符串从左到右每个字符都有一个索引：

1. 从左到右：0 1 2 3 …
2. 从右到左：-1 -2 -3 …

• 通过索引取值

格式：字符串[索引]

a = '我是盲敲代码的阿豪'
print(a[0]) # 取出第一个字符，输出结果：我
b = a[-1] # 取出最后一个字符，输出结果：豪
print(b)

注意：
字符只能通过索引取值，不能修改，如：a[0] = '爱',会报错

• 切片

格式：字符串[起始索引:结束索引:步长]

a = '我是盲敲代码的阿豪'
print(a[0]) # 取出第0个索引的字符
print(a[0:5]) # 取出第0个索引到第 5-1 个索引的字符
print(a[0:5:2]) # 取出第0个索引到第 5-1 个索引，每隔2个的字符
print(a[0:]) # 表示取出从0到最后索引的字符
print(a[0::]) # 表示取出从0到最后索引的字符，步长没写，默认为1
print(a[0::2]) # 取出0到最后索引，每隔2个的字符
print(a[::-1]) # 步长为-1，表示字符串内容倒过来输出

输出结果：

我
我是盲敲代
我盲代
我是盲敲代码的阿豪
我是盲敲代码的阿豪
我盲代的豪
豪阿的码代敲盲是我

1.2.2 字符串与in的用法

判断左边的字符是否存在于右边的字符串内，返回结果为布尔值

print('阿豪' in '我是盲敲代码的阿豪') # True
print('333' in '我是阿豪') # False

1.2.3 len()的用法

统计不同类型数据中元素的个数

print(len('我爱你')) # 输出结果：3
print(len([1,2,3,4])) # 输出结果：4
dic = {
    '名字':'阿豪',
    '年龄':18,
    '爱好':['唱','跳','rap','basketball']
}
print(len(dic)) # 统计字典中的键值对，输出结果：3

1.2.4 str() 的用法

将其它类型的数据强行转换成字符串型

m = str(123) # 将整型转为字符串型
print(m)
print(type(m))

a = str([1,'我爱你','22']) # 将列表转为字符串型
print(a)
print(type(a))

输出结果：

123
<class 'str'>
[1, '我爱你', '22']
<class 'str'>

1.2.5 字符串与for循环的使用

for i in '我爱你': # 将字符串中每个字符绑定给 变量i
    print(i)

输出结果：

我
爱
你

1.2.6 strip()的使用

格式：字符串.strip(指定字符)；去除字符串左右两边指定的字符

print('   我 爱 你   '.strip()) # 没有指定符号，默认为空白符，将字符串两边的空白去除了，注意中间的空白不能去除
print('   我爱你 ***'.strip('*')) # 去除字符串两边的 * 号
print('   我爱你 ***  '.strip('*')) # 这里字符串两边是空白，所以无法去除 * 号
print('   我爱你 ***'.strip('*').strip()) # strip()可以一直叠加，这里先去除两边 * 号，然后在去除两边空白

输出结果：

我 爱 你
   我爱你 
   我爱你 *** 
我爱你

1.2.7 split()的用法

格式：字符串.split(指定字符)，根据指定字符，将字符串分离成列表

a = '我 爱 你'
print(a.split()) # 没有指定字符，默认以空格分离
a = ' 我爱你 '
print(a.split()) # 以空格分离字符串
a = '我!爱!你'
print(a.split('!')) # 以 ! 分离字符串，变为一个列表

输出结果：

['我', '爱', '你']
['我爱你']
['我', '爱', '你']

1.2.8 lower() 和 upper()的用法

格式：

1. 字符串.lower()，将英文字符串全部变为小写
2. 字符串.upper()，将英文字符串全部变为大写

str1 = 'My NAme is JAke 哈哈哈'
print(str1.lower()) # 英文字母全部变成小写
print(str1.upper()) # 英文字母全部变成大写

输出结果：

my name is jake 哈哈哈
MY NAME IS JAKE 哈哈哈

1.2.9 startswith() 和 endswith() 的用法

格式：

1. 字符串.startswith(指定字符)，判断字符串是否以指定字符开头，返回布尔值
2. 字符串.endswith(指定字符)，判断字符串是否以指定字符结尾，返回布尔值

str1 = 'My NAme is JAke 哈哈哈'
print(str1.startswith('M')) # 输出结果 True
print(str1.startswith('is')) # 输出结果：False
print(str1.endswith('哈哈')) # 输出结果：True

1.2.10 join() 的使用方法

格式：

1. 指定字符.join(字符串)，在字符串中的每个字符中间插入指定字符
2. 指定字符.join(列表)，将列表中每个元素以指定字符连接，形成一个新的字符串

str1 = '我是谁'
print('%'.join(str1)) # 在每个字符串中间插入 %

str2 = ['点赞','关注','收藏']
print('+'.join(str2)) # 将列表每个元素用 + 连接形成一个字符串

输出结果：

我%是%谁
点赞+关注+收藏

1.3 列表（list）

1.3.1 列表的索引操作

这里我不做详细解释，方法跟字符串是一样的；如：

a = [1,2,3,4,5,6]
print(a[0]) # 取出列表中第一个元素
print(a[0:5]) # 取出列表中第0个索引到第5-1个索引的元素，返回一个列表
print(a[0::2]) # 取出第0个索引到最后一个索引，步长为2的元素

输出结果：

1
[1, 2, 3, 4, 5]
[1, 3, 5]

• 列表还可以通过索引更改元素的值，如：

a = [1,2,3,4,5,6]
a[0] = 10 # 将第一0个索引的元素改为 10
a[-1] = '啦啦啦' # 更改最后一个元素的值
print(a) # 输出结果：[10, 2, 3, 4, 5, '啦啦啦']

1.3.2 append() 的用法

格式：列表.append(元素)，在列表末尾添加一个元素（任意数据类型）

a = [1,2,3,4,5]
a.append('哈哈')
a.append(['66,77'])
print(a)

输出结果：

[1, 2, 3, 4, 5, '哈哈', ['66,77']]

1.3.3 extend()的用法

一次性向列表中加入多个元素，格式：

1. 列表.extend(字符串)，将字符串中的每个字符依次加入列表末尾
2. 列表.extend(列表)，将列表中每个元素依次加入列表末尾

a = [1,2,3]
a.extend('我爱你')
a.extend([222,333])
print(a)

输出结果：

[1, 2, 3, '我', '爱', '你', 222, 333]

1.3.4 insert()的用法

格式：列表.insert(索引,元素)，通过索引在指定位置加入元素

a = [1,2,3]
a.insert(0,666) # 在第0个索引的位置插入 666
a.insert(-1,'哈哈') # 在第-1个索引插入 哈哈，相当于替代了原来 -1索引 的位置
print(a)
a.insert(5,'啦啦') # 在第5个索引的位置插入 啦啦
print(a)

输出结果：

[666, 1, 2, '哈哈', 3]
[666, 1, 2, '哈哈', 3, '啦啦']

1.3.5 列表的四种删除方法

1.3.5.1 del 用法

格式：del 列表[开始索引:结束索引:步长] ，通过索引删除列表中的元素，可同时删除多个

a = [1,2,3,4,5]
del a[0] # 删除第0个索引的元素
print(a)

a = [1,2,3,4,5]
del a[0:3] # 删除第0到第3-1个索引的元素
print(a)

a = [1,2,3,4,5]
del a[0::2] # 删除第0到最后一个索引的元素，每隔2个元素
print(a)

输出结果：

[2, 3, 4, 5]
[4, 5]
[2, 4]

1.3.5.2 pop() 用法

格式：列表.pop(索引)，删除列表中指定索引位置的元素

a = [1,2,3,4,5]
a.pop() # 不指定索引，默认删除最后一个元素
a.pop(0) # 删除第0个索引位置的元素
print(a)

输出结果：

[2, 3, 4]

1.3.5.3 remove() 用法

格式：列表.remove(元素)，删除列表中指定元素，当有多个相同元素时，默认删除第一个匹配的元素，注意不能删除列表中没有的元素，会报错

a = [1,2,2,2,'阿豪']
a.remove('阿豪') # 删除元素 阿豪
a.remove(2) # 列表中有多个 2 ，只删除第一个匹配的元素 2
print(a)

输出结果：

[1, 2, 2]

1.3.5.4 clear() 用法

格式：列表.clear()，删除列表中所有的元素，返回一个空列表

a = [1,2,2,2,'阿豪']
a.clear() # 删除所有元素
print(a) # 得到一个空列表

输出结果：

[]

1.3.6 reverse() 的用法

格式：列表.reverse()，将列表中的元素颠倒顺序

a = [1,2,3,4,'阿豪']
a.reverse() # 颠倒列表元素顺序
print(a)

输出结果：

['阿豪', 4, 3, 2, 1]

1.3.7 sort() 用法

给列表中的元素排序，排序时列表中的所有元素必须为同一数据类型，不能混搭，否则报错
格式：列表.sort(reverse=True或False)
reverse用来指定升序还是降序，True为降序，False为升序；不写默认为升序

a = [11,22,2,36,6,44]
a.sort() # 默认为升序，相当于a.sort(reverse=False)，从小到大排序
print(a)

a = [11,22,2,36,6,44]
a.sort(reverse=True) # 降序，从大到小排序
print(a)

输出结果：

[2, 6, 11, 22, 36, 44]
[44, 36, 22, 11, 6, 2]

1.4 字典（dict）

格式：{键:值,键:值,...}，由{}包裹的一个个键值对组成

• 键可以是字符串，整型，浮点，元祖，布尔常用字符串 不能是列表，集合，字典
• 字典的值可以是任意数据类型
• 字典的键是唯一的，不能重复

1.4.1 通过键 取值和修改值

格式：

1. 字典[键]，取出字典中 键对应的值,若键不存在，会报错
2. 字典[键] = 值 ，修改字典中键对应的值，若键不存在，则在字典末尾增加一个键值对

dic = {
    '名字':'阿豪',
    '年龄':18,
    '爱好':['唱','跳','rap','basketball']
}
print(dic['名字']) # 取值
print(dic['爱好'][2])
dic['名字'] = '啦啦啦' # 修改值
dic['年龄'] = '2.5'
dic['身高'] = 180 # 键不存在，在字典末尾增加一个键值对
print(dic)

输出结果：

阿豪
rap
{'名字': '啦啦啦', '年龄': '2.5', '爱好': ['唱', '跳', 'rap', 'basketball'],'身高': 180}

1.4.2 get() 的用法（推荐使用）

格式:字典.get(键,替代值)
作用同样是通过字典的键取出对应的值，替代值是在键不存在时输出的，这样就不会报错；若字典的键存在则输出原本的值，不会输出替代值；替代值不写默认为None

dic = {
    '名字':'阿豪',
    '年龄':18,
    '爱好':['唱','跳','rap','basketball']
}
print(dic.get('名字')) # 替代值可不写，字典键存在输出对应值
print(dic.get('年龄','该键存在，不用替代')) # 字典键存在输出原值，替代值不输出
print(dic.get('啦啦','哈哈哈')) # 键不存在，输出替代值
print(dic.get('爱好121')) # 键不存在，替代值没写，默认输出 None

阿豪
18
哈哈哈
None

1.4.3 字典和 in 的用法

判断该键是否存在于字典内

dic = {
    '名字':'阿豪',
    '年龄':18,
    '爱好':['唱','跳','rap','basketball']
}
print('名字' in dic) # 输出结果：True
print('啦啦' in dic) # 输出结果：False

1.4.4 字典与for循环

dic = {
    '名字':'阿豪',
    '年龄':18,
    '爱好':['唱','跳','rap','basketball']
}
for i in dic: # 将字典中每个键绑定给 变量i
    print(i)

输出结果：

名字
年龄
爱好

1.4.5 pop() 的用法

格式：字典.pop(键)，通过键删除字典中对应的键值对，键不存在会报错

dic = {
    '名字':'阿豪',
    '年龄':18,
    '爱好':['唱','跳','rap','basketball']
}
dic.pop('爱好') # 删除 爱好 对应的键值对
print(dic)

输出结果：

{'名字': '阿豪', '年龄': 18}

1.4.6 了解点：keys()、values()、items()

格式：

1. 字典.keys() ，取出字典中所有的键
2. 字典.values()，取出字典中所有的值
3. 字典.items()，取出字典中所有的键值对

dic = {
    '名字':'阿豪',
    '年龄':18,
    '爱好':['唱','跳','rap','basketball']
}
print(dic.keys())
print(dic.values())
print(dic.items())

输出结果：

dict_keys(['名字', '年龄', '爱好'])
dict_values(['阿豪', 18, ['唱', '跳', 'rap', 'basketball']])
dict_items([('名字', '阿豪'), ('年龄', 18), ('爱好', ['唱', '跳', 'rap', 'basketball'])])

• 通过上面三种方法得到的结果，可以通过for循环遍历出来，如：

dic = {
    '名字':'阿豪',
    '年龄':18,
    '爱好':['唱','跳','rap','basketball']
}
for a in dic.keys(): # 将字典中每个键遍历出来
    print(a)
for b in dic.values(): # 将字典中每个值遍历出来
    print(b)
for c,d in dic.items(): # 将字典中的每个键值对遍历出来
    print(c,d)

输出结果：

名字
年龄
爱好
阿豪
18
['唱', '跳', 'rap', 'basketball']
名字 阿豪
年龄 18
爱好 ['唱', '跳', 'rap', 'basketball']

1.5 集合（set）

• 集合使用频率较低，一般用于特定场景，格式：{元素,元素,元素,...}
• 集合的特点：
  1、每个元素必须是不可变数据类型（字符串，元组，布尔，整型，浮点型）
  2、集合内没有重复的元素
  3、集合内的元素是无序的，元素的位置没有固定顺序

1.5.1 set()的用法

格式：

1. set(字符串)，将字符串转为集合，每个字符都为集合的一个元素
2. set(列表)，将列表转为集合，列表每个元素变为集合的每个元素

a = set('123') # 变为集合后，元素顺序随机排列
print(a)

b = {1,3,3,3,7} # 元素不能重复，输出后只有一个3
c = set([1,2,2,2,4,5]) # 元素不能重复，只会保留一个 2
print(b)
print(c)

输出结果：

{'1', '2', '3'}
{1, 3, 7}
{1, 2, 4, 5}

1.5.2 拓展：集合使用场景

1. 利用集合去除重复元素，如：

a = [1,2,3,4,4,2,3,7]
a = set(a) # 先将列表转为集合去重
a = list(a) # 将去重后的集合又转为列表
print(a) # 输出结果：[1, 2, 3, 4, 7]

2. 用于数学关系运算，基本用不上，了解即可

friends1 = {"zero" , "kevin" , "jason" , "egon"} # 用户1好友
friends2 = { "Jy" , "ricky" , "jason" , "egon"} # 用户2好友

# 1.合集/并集(|)：求两个用户所有的好友（重复好友只留一个）
print(friends1 | friends2)
# 输出结果：{'kevin', 'ricky', 'zero', 'jason', 'Jy', 'egon'}

# 2.交集(&)：求两个用户的共同好友
print(friends1 & friends2)
# 输出结果：{'jason', 'egon'}

# 3.差集(-)：
print(friends1 - friends2)  # 求用户1独有的好友
# 输出结果：{'kevin', 'zero'}
print(friends2 - friends1)  # 求用户2独有的好友
# 输出结果：{'ricky', 'Jy'}

# 4.对称差集(^) # 求两个用户独有的好友们（即去掉共有的好友）
print(friends1 ^ friends2)
# 输出结果：{'kevin', 'zero', 'ricky', 'Jy'}

# 5.值是否相等(==)，返回布尔值
print(friends1 == friends2)
# 输出结果：False

# 6.父集：一个集合是否包含另外一个集合
# 6.1 包含则返回True
print({1, 2, 3} > {1, 2})
# 输出结果：True
print({1, 2, 3} >= {1, 2})
# 输出结果：True
# 6.2 不存在包含关系，则返回False
print({1, 2, 3} > {1, 3, 4, 5})
# 输出结果：False
print({1, 2, 3} >= {1, 3, 4, 5})
# 输出结果：False

# 7.子集
print({1, 2} < {1, 2, 3})
# 输出结果：True
print({1, 2} <= {1, 2, 3})
# 输出结果：True

3. 集合同样可以使用 in、for循环、len()等，使用方法不变
4. 集合不能使用切片的方法，通过索引取值或修改值

1.6 元组（tuple）

格式：(元素,元素,元素,…)，与列表相似，只是把 [] 换成了 ()，元素可以为任意数据类型

a = [1,2,3] # 列表
b = (4,5,6) # 元组
print(type(a))
print(type(b))

1.6.1 通过索引取值

元组也可以使用切片的方法取值，但不能修改值，而列表可以，在这点上他们有区别

a = (1,2,3,4,5)
print(a[0])
print(a[0:3])
print(a[::2])
# a[0] = 666,不能修改值，会报错

输出结果：

1
(1, 2, 3)
(1, 3, 5)

• 元组同样可以使用，in、for循环、len()等方法

1.6.2 注意事项

1. 当元组中只有一个元素时，必须在后面加上逗号 ,，若不加逗号，那么就变为其它数据类型了

a = (1,)
print(type(a)) # 元组

b = (1)
print(type(b)) # 整型

c = ([1,2])
print(type(c)) # 列表

2. 元组并不是所有数据类型都不能通过索引进行修改，我们可以用索引修改元组中嵌套的列表、字典等元素；如：

a = (1,'哈哈',[11,21],{'name':'阿豪'},{1,2,'啊哈哈'})
a[2][0] = 666 # 修改元组中嵌套的列表中的元素
a[3]['name'] = '阿呆' # 修改元组中嵌套字典中的值
print(a)

输出结果：

(1, '哈哈', [666, 21], {'name': '阿呆'}, {1, 2, '啊哈哈'})

1.7 可变数据类型和不可变数据类型

• 什么是可变和不可变数据类型？

1. 值发生改变后，内存地址也改变了，这种数据类型就叫做不可变数据类型；例如:字符串，整型，浮点型，元祖
   2. 值发生了改变，内存地址没有变化的，这种数据类型就叫做可变数据类型；例如:列表，字典，集合

# 不可变数据类型
a = '阿豪'
print(id(a)) # id：1445321439536
a= '阿呆'
print(id(a)) # id：1445321439920
# 可以看到字符串a 的值变化后，内存地址也变了

# 可变数据类型
b = [1,2,3]
print(id(b)) # id：1445323983296
b[0] = 666 # [666,2,3]
print(id(b)) # id：1445323983296
# 可以看到列表b 的元组值变化后，内存地址依旧不变

• 为什么要分可变和不可变数据类型？

1. 为了更好的分配内存空间
2. 为了更好的操作数据

推荐：
对内存地址id不熟悉的同学可以去看这篇文章：http://t.csdnimg.cn/ZtRbs

2、了解点：进制

2.1 常见进制

计算机底层所使用的是二进制语言；在python中我们可能会接触到的几种进制如下：

1. 二进制
   由 0 和 1 两个数字组成，书写时以 0b 或 0B 开头；如：101 对应十进制 5
2. 八进制
   由 0~7 共八个数字组成，以 0o 或 0O 开头
   注意第一个字符为数字 0，第二个字符为字母 o
3. 十进制
   我们日常使用的整数就是十进制形式的，他由 0~9 共十个数字排列组合而
   注意，使用十进制整数不能以 0 开头，除非数值本身为 0
4. 十六进制
   由 0-9 十个数字和 A-F(或a-f) 六个字母组成，书写时以 0X 或 0x 开头

案例：

# 了解即可
# 十六进制
hex1 = 0x45
hex2 = 0x4AF
print('十六进制：',hex1)
print('十六进制：',hex2)

#二进制
bin1 = 0b101
bin2 = 0b110
print('二进制：',bin1)
print('二进制：',bin2)

#八进制
oct1 = 0o26
oct2 = 0o41
print('八进制：',oct1)
print('八进制：',oct2)

输出结果：

十六进制： 69
十六进制： 1199
二进制： 5
二进制： 6
八进制： 22
八进制： 33

说明：
可以看到，上面输出不同进制的结果都为十进制，这里我们作为扩展点了解即可，在日常开发中基本用不到

2.2 进制转换

• bin(十进制数字)：将十进制转为二进制
• oct(十进制数字)：将十进制转为八进制
• hex(十进制数字)：将十进制转为十六进制
• int(其它进制的数字)：将其他进制的数字转为十进制

例子：

print(bin(110)) # 十进制转二进制
print(oct(110)) # 十进制转八进制
print(hex(110)) # 十进制转十六进制
print(int(0b110)) # 二进制转十进制

输出结果：

0b1101110
0o156
0x6e
6