Python基础语法（四）—— 列表+元组+字典+字符串

已于 2022-10-15 12:18:35 修改
阅读量647 收藏 7
点赞数 3
分类专栏： Python 文章标签： python 开发语言
于 2022-09-11 22:45:46 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_53946852/article/details/126805921
版权

文章目录

一、列表和元组

列表和元组一组变量的集合，它们可以批量粗存储数据。
元组和列表是非常相似的，只是列表中存放的元素是可以修改的，而元组是不可变的（也就是不能修改），所以创建元组的时候就要设定好，不能修改调整

1. 创建列表

  • 创建列表主要有两种方式
    list1 = []
list2 = list()
print(type(list1))
print(type(list2))
# 执行结果
<class 'list'>
<class 'list'>
  • 设置初始值
    my_list = [10, 3.14, 'hello']
print(my_list)
# 运行结果
[10, 3.14, 'hello']
    Python列表中是可以存放不同类型的元素的，这和C/Java差别比较大

2. 下标访问

我们可以通过下标访问操作符[]来获取列表中的任意元素

  • 从前往后访问下标是从0开始的
  • Python的索引是可以取负数的（从后往前是从-1开始，也就是倒数第一个元素）
  • 如果下标越界就会抛出异常
my_list = [1, 2, 3, 4, 5]
print(my_list[0])
print(my_list[3])
print(my_list[-1])
print(my_list[-5])

计算列表长度，通过len函数

my_list = [1, 2, 3, 4, 5]
print(len(my_list))
# my_list[-1]就相当于 my_list[len(my_list)-1]

3. 切片操作

通过下标能后一次获取一个元素
通过切片则是一次获取一组连续的元素，相当于一个子列表

在这里插入图片描述

语法格式

列表名[起始下标:结束下标:步长]

区间是左闭右开的
[起始下标:结束下标)
步长默认是1，也就是每次夸多少个元素

代码示例

lists = [1, 2, 'hello', 3.14, 'world']
print(lists[0:4:1])
print(lists[0:5:2])
print(lists[-1:-4:-1])
# 运行结果
[1, 2, 'hello', 3.14]
[1, 'hello', 'world']
['world', 3.14, 'hello']

在切片过程中可以省略前后边界

lists = [1, 2, 'hello', 3.14, 'world']
print(lists[1:]) # 省略后边界，表示获取到列表末尾
print(lists[:-1]) # 省略前边界，表示从开头开始获取
print(lists[:]) # 省略两个边界表示获取整个列表

#运行结果
[2, 'hello', 3.14, 'world']
[1, 2, 'hello', 3.14]
[1, 2, 'hello', 3.14, 'world']

lists = [1, 2, 'hello', 3.14, 'world']
print(lists[::-1])
print(lists[::1])
print(lists[::-2])
# 运行结果 
['world', 3.14, 'hello', 2, 1]
[1, 2, 'hello', 3.14, 'world']
['world', 'hello', 1]

如果切片中填的数字越界了，不会有负面效果，只会尽可能的把满足条件的元素获取到

lists = [1, 2, 'hello', 3.14, 'world']
print(lists[:500])
print(lists[100:])
运行结果
[1, 2, 'hello', 3.14, 'world']
[]

4. 变量列表元素

通过for循环遍历整个列表

lists = [1, 2, 'hello', 3.14, 'world']
for tmp in lists:
    print(tmp, end=' ')
print()
for i in range(len(lists)-1, -1, -1):
    print(lists[i], end=' ')

# 运行结果
1 2 hello 3.14 world 
world 3.14 hello 2 1

5. 新增元素

  • 使用append方法，向列表末尾插入一个元素

lists = [1, 2, 'hello', 3.14, 'world']
lists.append(1000)
lists.append('test')
print(lists)

# 运行结果
[1, 2, 'hello', 3.14, 'world', 1000, 'test']
  • 使用insert方法，向任意位置插入一个元素
lists = [1, 2, 'hello', 3.14, 'world']
print(lists)
lists.insert(2, 'hahaha')
print(lists)

# 运行结果
[1, 2, 'hello', 3.14, 'world']
[1, 2, 'hahaha', 'hello', 3.14, 'world']

6. 查看元素

  • 使用in操作符，判断元素是否在列表中存在，相反not in则是判断元素是否不在列表中
lists = [1, 2, 'hello', 3.14, 'world']
print('hello' in lists)
print(2 in lists)
print(44 in lists)
print(44 not in lists)

# 运行结果
True
True
False
True
  • 使用index方法。查找元素在列表中的下标，放回一个整数，如果元素不存在就会抛出异常
lists = [1, 2, 'hello', 3.14, 'world']
print(lists.index(2))
print(lists.index('haha')) # 不存在会抛异常

7. 删除元素

  • 使用pop方法删除最末尾的元素，也可以使用下标来删除元素
lists = [1, 2, 'hello', 3.14, 'world']
print(lists.pop())
print(lists)
lists.pop(2)
print(lists)

# 运行结果
world
[1, 2, 'hello', 3.14]
[1, 2, 3.14]
  • 使用 remove，按照值来删除元素
lists = [1, 2, 'hello', 3.14, 'world']
lists.remove(2)
lists.remove('hello')
print(lists)
# 运行结果
[1, 3.14, 'world']

8. 合并列表

  • 使用+能够把两个列表拼接起来，返回一个新列表不会影响到就列表
my_list = [10, 3.14, 'hello']
lists = [1, 2, 'hello', 3.14, 'world']
print(my_list + lists)
print(lists + my_list)

# 运行结果
[10, 3.14, 'hello', 1, 2, 'hello', 3.14, 'world']
[1, 2, 'hello', 3.14, 'world', 10, 3.14, 'hello']
  • 使用 extend方法，相当于把一个列表拼接到另一列表后面
    注意：a.extend(b)，是把b中的内容拼接到a的末尾，不会修改b但是会修改a
my_list = [10, 3.14, 'hello']
lists = [1, 2, 'hello', 3.14, 'world']
my_list.extend(lists)
print(my_list)
print(lists)

# 运行结果
[10, 3.14, 'hello', 1, 2, 'hello', 3.14, 'world']
[1, 2, 'hello', 3.14, 'world']
  • 使用append方法则是把整个列表当成一个元素拼接到后面
my_list = [10, 3.14, 'hello']
lists = [1, 2, 'hello', 3.14, 'world']
my_list.append(lists)
print(my_list)
print(lists)

# 运行结果
[10, 3.14, 'hello', [1, 2, 'hello', 3.14, 'world']]
[1, 2, 'hello', 3.14, 'world']

9. 关于元组

元组的功能和列表相比基本是相同的，只不过元组是不可变的

元组的创建，元组使用 ()来表示

my_tuple = tuple()
a_tuple = ()
print(type(my_tuple))
print(type(a_tuple))
# 运行结果
<class 'tuple'>
<class 'tuple'>

元组的访问

my_tuple = ('a', 10, 3.14)
print(my_tuple[2])
# 运行结果
3.14

元组不能修改，但切片、遍历、in、inde、+ 等操作也是一样支持的，像增删改这些操作就不支持了

my_tuple = ('a', 10, 3.14)
a_tuple = ('hello', 66)
print(my_tuple[:5])
print(my_tuple.index(10))
print(my_tuple + a_tuple)
print('hello' in a_tuple)

# 运行结果
('a', 10, 3.14)
1
('a', 10, 3.14, 'hello', 66)
True

另外，元组在Python中很多时候是默认的集合类型，列如，当一个函数要返回多个返回值的时候

def test():
    return 10, 'hello'


ret = test()
print(type(ret))

# 运行结果
<class 'tuple'>

10. 小结

既然有了列表，为啥还需要元组？

  • 你有一个列表, 现在需要调用一个函数进行一些处理. 但是你有不是特别确认这个函数是否会把你的列表数据弄乱. 那么这时候传一个元组就安全很多
  • 字典是一个键值对结构. 要求字典的键必须是 “可hash对象” (字典本质上也是一个hash表). 而一个可hash对象的前提就是不可变. 因此元组可以作为字典的键, 但是列表不行.
  • 如果元素不需要改变, 则优先考虑元组.
  • 如果元素需要改变, 则优先考虑列表

二、字典

1. 字典是啥？

在Python中字典是一种存储键值对的结构，一个 key 对应一个 value。且这个键(key)一定是唯一的
底层使用的哈希表，它的增删改查都是常数级的。

2. 创建字典

  • 创建空的字典，使用 {}表示字典
amap = {}
my_map = dict()
print(type(amap))
print(type(my_map))
# 运行结果
<class 'dict'>
<class 'dict'>
  • 也可以在创建的同时指定初始值
  • 键值对之间使用逗号,分割，键和值使用冒号:分割
# 最后一个键值对的逗号可写可不写
student = {
    'name': 'zhangsan',
    'sex': 'boy',
    'age': 18
}
print(student)
# 运行结果
{'name': 'zhangsan', 'sex': 'boy', 'age': 18}

3. 查找key

  • 使用in可以判定key是否在字典中存在，返回 布尔值
    student = {
    'name': 'zhangsan',
    'sex': 'boy',
    'age': 18
}
print('name' in student)
print('phone' in student)
# 运行结果
True
False
  • 使用[]通过类似于取下标的方式，获取到元素的值，只不过此处的下标是 键(key)，这个键可以是整数也可以是字符串或者是其它类型
student = {
    'name': 'zhangsan',
    'sex': 'boy',
    'age': 18,
    666: 'id'
}
print(student['name'])
print(student[666])
# 运行结果
zhangsan
id
  • 注意如果key在字典中不存在就会抛出异常

4. 新增&修改元素

使用 [] 可以根据key来新增/修改value

  • 如果key不存在，对取下标操作赋值，即为新增键值对
student = {
    'name': 'zhangsan',
    'sex': 'boy',
    'age': 18,
    666: 'id'
}

student[666] = 9494
print(student)
# 运行结果
{'name': 'zhangsan', 'sex': 'boy', 'age': 18, 666: 9494}
  • 如果key已经存在，对取下标操作赋值，就是进行修改操作
student = {
    'name': 'zhangsan',
    'sex': 'boy',
    'age': 18,
    666: 'id'
}
student['name'] = 'lisi'
print(student)
# 运行结果
{'name': 'lisi', 'sex': 'boy', 'age': 18, 666: 'id'}

5. 删除元素

  • 使用pop方法根据key删除对应的键值对
student = {
    'name': 'zhangsan',
    'sex': 'boy',
    'age': 18,
    666: 'id'
}
student.pop(666)
print(student)
# 运行结果
{'name': 'zhangsan', 'sex': 'boy', 'age': 18}

6. 遍历字典元素

  • 直接使用for循环能够获取到字典中所有key，进一步的就可以去除每个值了
student = {
    'name': 'zhangsan',
    'sex': 'boy',
    'age': 18,
    666: 'id'
}
for key in student:
    print(key, student[key])

# 运行结果
name zhangsan
sex boy
age 18
666 id

7. 取出所有key和value

  • 使用keys方法可以获取到字典中所有的key
student = {
    'name': 'zhangsan',
    'sex': 'boy',
    'age': 18,
    666: 'id'
}
print(student.keys())
# 运行结果
dict_keys(['name', 'sex', 'age', 666])

此处 dict_keys 是一个特殊的类型, 专门用来表示字典的所有 key. 大部分元组支持的操作对于
dict_keys 同样适用

  • 使用values方法可以获取到所有字典中的所有value
student = {
    'name': 'zhangsan',
    'sex': 'boy',
    'age': 18,
    666: 'id'
}
print(student.values())
# 运行结果
dict_values(['zhangsan', 'boy', 18, 'id'])

此处 dict_values 也是一个特殊的类型, 和 dict_keys 类似

  • 使用items方法可以获取到字典中所有的键值对
student = {
    'name': 'zhangsan',
    'sex': 'boy',
    'age': 18,
    666: 'id'
}
print(student.items())
# 运行结果
dict_items([('name', 'zhangsan'), ('sex', 'boy'), ('age', 18), (666, 'id')])

此处 dict_items 也是一个特殊的类型, 和 dict_keys 类似.

8. 合法的key类型

需要注意的是，不是所有的类型都可以作为字典的key
字典本质上是一个 哈希表, 哈希表的 key 要求是 “可哈希的”, 也就是可以计算出一个哈希值

  • 可以使用hash函数计算某个对象的哈希值
  • 但凡能够计算出哈希值的类型，都可以作为字典的key
print(hash(666)) # 整数
print(hash(3.14)) # 浮点数
print(hash('hello world')) # 字符串
print(hash(False)) # 布尔
print(hash((1, 2, 'test'))) # 元组

# 运行结果
666
322818021289917443
8827197857303815004
0
6581628079282140115
  • 列表和字典无法计算哈希值
print(hash([1, 2, 3, 'ha']))
print(hash({'name' : 'zhangsan'}))

小结

  • 字典也是一个常用的结构，字典的所有操作都是围绕key来展开的
  • 字典的键Key是唯一的

三、字符串

1. 字符串的定义

在Python中，用引号引起来的都是字符串。

string1 = "hello"
string2 = "hello"
string3 = """hello
python"""
string4 = '''hello
python'''
string5 = input("->")
string6 = str(666)

print(isinstance(string4, str)) # isinstance函数可以用来判断数据是否为某一个数据类型，返回值为
True或False

2. 字符串的拼接

name = "test"
str1 = "===" + name + "==="
str2 = "===%s==="%(name)
str3 = "==={}===".format(name)

print(str1)
print(str2)
print(str3)

# 输出都一样
===test===
===test===
===test===

3. 字符串的索引

遍历字符串

str = "hello world"
for tmp in str:
    print(tmp,end=" ")

将字符串遍历打印,并对应打印出下标

# enumerate() 函数用于将一个可遍历的数据对象(如列表、元组或字符串)组合为一个索引序列

str = "hello world"
for index, c in enumerate(str):
    print(f'str[{index}] ch={c}')


# 输出
str[0] ch=h
str[1] ch=e
str[2] ch=l
str[3] ch=l
str[4] ch=o
str[5] ch= 
str[6] ch=w
str[7] ch=o
str[8] ch=r
str[9] ch=l
str[10] ch=d

4. 字符串的切片

字符串，列表，元组都属于序列，所以都可以切片
切片规则
[起始下标:结束下标:步长]

str = "hello-world"
print(str[:5]) # 从0到4个字符，不包含第5个
print(str[6:20]) #从第6个一直到最后

print(str[0:-1]) # 取第一个到倒数第2个不包含最后一个
print(str[3:]) # 从第3个取到最后一个
print(str[:]) # 全取
print(str[1:6:2]) # 取第1个到第6个步长为2

print(str[::-1]) # 字符串逆序

# 输出
hello
world
hello-worl
lo-world
hello-world
el-
dlrow-olleh

5. 字符串的常见操作

str = "hello world, Python"

# 调用len()函数来算长度
print(str.__len__()) # 使用字符串的__len__()方法来算字符串的长度
print(str.capitalize()) # 整个字符串的首字母大写
print(str.title()) # 每个单词的首字母大写
print(str.upper()) # 全大写
print(str.lower()) # 全小写
print("HAHAhehe".swapcase()) # 字符串里大小写互换
print(str.center(50, "*")) # 一共50个字符,字符串放中间，不够的两边补*
print(str.ljust(50, "*")) # 一共50个字符,字符串放中间，不够的右边补*
print(str.rjust(50, "*")) # 一共50个字符,字符串放中间，不够的左边补*
print(" haha\n".strip()) # 删除字符串左边和右边的空格或换行
print(" haha\n".lstrip()) # 删除字符串左边的空格或换行
print(" haha\n".rstrip()) # 删除字符串右边的空格或换行
print(str.endswith("you")) # 判断字符串是否以you结尾
print(str.startswith("hello")) # 判断字符串是否以hello开始
print(str.count("e")) # 统计字符串里e出现了多少次
print(str.find("nice")) # 找出nice在字符串的第1个下标，找不到会返回-1
print(str.rfind("e")) # 找出最后一个e字符在字符串的下标，找不到会返回-1
print(str.index("he")) # 与find类似，区别是找不到会有异常（报错）
print(str.rindex("e")) # 与rfind类似，区别是找不到会有异常（报错）

print(str.isalnum())    # 检测字符串是否由字母和数字组成
print(str.isalpha())    # 是否只由字母组成
print(str.isdecimal())  #检查字符串是否只包含十进制字符
print(str.isdigit())    # 检测字符串是否只由数字组成,只对 0 和 正数有效
print(str.islower())    # 检测字符串是否由小写字母
print(str.isnumeric())  # 法检测字符串是否只由数字组成
print(str.isspace())    #  方法检测字符串是否只由空格组成

输出

19
Hello world, python
Hello World, Python
HELLO WORLD, PYTHON
hello world, python
hahaHEHE
***************hello world, Python****************
hello world, Python*******************************
*******************************hello world, Python
haha
haha

 haha
False
True
1
-1
1
0
1
False
False
False
False
False
False
False

数字,字符串,元组是不可变类型.下面的操作可以替换字符串的值，但原字符串没有改变

str = "hello-world"

myStr = str.replace('l', 'L', 2) # 从左到右，把小写l替换成大写L，并且最多只替换2个
print(str)	# 原值不变
print(myStr)	# 改变的值赋值给了myStr变量，所以这里看到的是替换后的值

字符串分割

print("12:30:48".split(":"))# 以:为分隔号,分隔成列表
print("hello\nworld".splitlines()) # 以\n为分隔号，分隔成列表

# 输出
['12', '30', '48']
['hello', 'world']

字符串的join操作


print("=".join(['a', 'b', 'c'])) # 把列表里的元素以前面引号里的分隔符合成字符串

# 输出
a=b=c
爱敲代码的三毛
关注
  • 3
    点赞
  • 踩
  • 7
    收藏
    觉得还不错? 一键收藏
  • 打赏
    打赏
  • 0
    评论
专栏目录
Python基础语法03--列表、字典、元组、集合
nikeylee的博客
09-29 673
python基础
1，python中列表，元组，字典相关语法
帅boy的博客
09-08 209
Python的6组标准数据类型： · Number(数字） · String(字符串) · List(列表） a=[n1,n2,n3…]有序可变可重复 · Tuple(元组）b=(n1,n2,n3…)有序不可变可重复 · set(集合）c={n1,n2,n3…}无序可变不重复 · Dictionary(字典）s={key:value,key:value,key:value…}实际上它是一个特殊的集合 List相关语法： list L=[ ] L.append()默认添加到List的尾部。 L.insert
Python语法(数据类型,列表,元组,字典,集合）
最新发布
zmzyzm的博客
10-15 327
Python语法(数据类型,列表,元组,字典,集合）
Python语法基础三（介绍列表，元组，字典，集合及其常用方法）
lucky_myj的博客
09-08 459
Python语法基础三（介绍列表，元组，字典，集合及其常用方法） 一、列表 作为Python内置的一种数据类型，是一种有序的集合，可随时增，删，改其中的元素。列表中的元素不必全是相同的类型(与C语言强大的地方) 如： list1 = [‘Mari’, ‘Tom’, 100, 1234] 常见列表操作 1、列表的长度 格式： len(列表名) 如： namesList = [‘xiaoWang’, ‘xiaoHuang’, ‘xiaoLi’] len(namesList) 2、列表的访问 用索引来访问lis
列表，元组字符串，字典操作语法表
m0_46066407的博客
04-07 135
1.列表操作： 2.元组操作： 3.字典操作： 4.字符串操作： python更多详细资料：密码423b https://pan.baidu.com/s/1eS7U2v4
在Python中字符串、列表、元组、字典之间的相互转换
09-18
本文将详细讨论如何在字符串(str)、列表(list)、元组(tuple)和字典(dict)之间进行转换。 1. 字符串转换为列表 字符串可以使用内置的`list()`方法转换为列表。例如： ```python str_1 = "1235" list_1 = list...
python字符串,元组,列表,字典互转代码实例详解
09-17
主要介绍了python字符串,元组,列表,字典互转代码实例详解,需要的朋友可以参考下
Python字符串、列表、元组、字典、集合的补充实例详解
09-18
主要介绍了Python字符串、列表、元组、字典、集合,结合实例形式详细分析了Python字符串、列表、元组、字典、集合常见函数使用方法及相关操作注意事项,需要的朋友可以参考下
Python字符串、元组、列表、字典互相转换的方法
09-21
以下是关于字符串、元组、列表和字典互相转换的详细说明： 1. 字典转字符串： 使用内置函数`str()`可以将字典转换为字符串形式，输出结果为`<type 'str'>`，内容为字典的表示形式。例如： ```python dict = {'...
Python基础语法（列表，元组，字典）案例详解
辰兮要努力
04-01 8037
本章节继续介绍python容器（列表，元组，字典），分享给刚学python的小伙伴，一起学习，共同进步 字符串详解：Phython基础语法之字符串 文章目录一.列表基础语法二.列表的相关操作三.列表的嵌套四.元组五.字典介绍六.字典的常见操作七.遍历 前面学习的字符串可以用来存储一串信息，那么想一想，怎样存储咱们班所有同学的名字呢？ 定义100个变量，每个变量存放一个学生的姓名可.........
python基础：列表，元组，字典的用法
weixin_50235838的博客
02-23 657
除非十点四十
day12—列表、元组、字典基本语法
weixin_30787531的博客
10-06 87
一、list类中提供的方法 **********************灰魔法************************** 1. 原来值最后追加 append() li = [11, 22, 33, 22, 44] li.append(5) li.append("alex") li.append([1234,2323]) print(li) # [11, 22...
Python元组、列表、字典、字符串常用方法超详细总结！！！
Code皮皮虾的博客
09-05 3301
文章目录1、列表 list1.1、len()1.2、max()和min()1.3、reverse()1.4、sort()1.5、clear()1.6、remove()1.7、insert()和pop()2、元组 tuple2.1、len()2.2、count()2.4、index()3、字典3.1、clear()3.2、keys()和values()3.3、items()3.4、get()3.5、pop()3.6、setdefault()4、字符串4.1、replace()4.2、split()4.3、st
Python的元组、列表、字典
qq_41657790的博客
07-17 300
开发工具与关键技术：Python IDEL、Python 作者：曾浩源 撰写时间：2019年07月17日 python的元组、列表、字典数据类型是python的数据结构。 一、元组 tuple 用小括号“( )”表示 首先元组，个人觉得元组就像java中的数组。 列表属于可变序列，可以任意修改列表中的元素。元组属于不可变序列，不能修改元组中的元素。因此，元组没有增加元素、修改元素、删除元素相关的...
【Python】列表元组与字符串
CharlieTang的博客
07-30 312
学习目标列表列表的定义列表的创建向列表中添加元素删除列表中的元素获取列表中的元素列表的常用操作符列表的其他方法练习题 列表 简单数据类型 整型<class 'int'> 浮点型<class 'float'> 布尔型<class 'bool'> 容器数据类型 列表<class 'list'> 元组<class 'tuple'> 字典<class 'dict'> 集合<class 'set'> 字符串<class '
python之旅（三）—— 列表、元组、字典、集合、字符串
qingtian_111的博客
11-16 293
python学习之旅（三）1. 列表1.1 创建列表1.2 访问列表1.3 更新列表1.3.1 增加列表元素 在这一篇中，我将会对列表、元组、字典、集合的增、删、改、查操作进行学习，以及对字符串的各种操作进行简单地整合。 1. 列表 列表中的元素个数与元素内容都是可以改变的。我们可以通过列表来对数据进行批量操作。下面将讲讲列表的创建、访问与更新。 1.1 创建列表 创建列表的语法格式如下： 方法1...
python3 列表、字符串、字典、集合、元组的常用基本操作
夏之微风的博客
08-31 696
列表、字符串、字典、集合的常用基本操作前言列表 List列表的创建列表的索引列表的添加列表的删除列表的排序二维列表的切片字符串字典集合 前言 最近一直在做leetcode和牛客网的题目，感觉是时候整理一波了。本文会时长更新，尽量将所用到的所有的关于列表、字符串、字典集合的常用基本操作覆盖在里面，方便以后查阅。 列表 List 列表的创建 1 初始化一个空列表 a=[] 2 初始化一个长度为N，值为0的列表 N=7 a=[0]*N print(a) # output: [0, 0, 0, 0, 0, 0,
元组、列表、字典、字符串的遍历
持之以恒，不需要特别的关注，成为持续不间断的坚持
07-20 966
一、元组 tup = ('tuple1','tuple2','tuple3','tuple4','tuple5') （1）利用for....in...直接遍历，元组元素不可直接修改，需要转换之后修改再赋值 for x in tup: print x （2）借助xrange或range函数利用下标遍历 for x in xrange(len(tup)): print tup[x
python的元组能作为字典的key吗？为什么？
z_erduo的博客
10-08 4670
python的元组可以作为字典的key？

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包

打赏作者

爱敲代码的三毛

你的鼓励将是我创作的最大动力

¥1 ¥2 ¥4 ¥6 ¥10 ¥20
扫码支付：¥1
获取中
扫码支付

您的余额不足，请更换扫码支付或充值

打赏作者

实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值