python 列表转字符串_Python基础入门：列表、元组、字符串、字典、集合、序列-阿里云天池 --1列表部分...

最新推荐文章于 2024-05-27 09:20:09 发布
最新推荐文章于 2024-05-27 09:20:09 发布
阅读量78 收藏
点赞数
文章标签： python 列表转字符串
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_39623355/article/details/111628443
版权

Python基础入门：从变量到异常处理-阿里云天池

Python基础入门：列表、元组、字符串、字典、集合、序列-阿里云天池 --2元组部分

Python基础入门：列表、元组、字符串、字典、集合、序列-阿里云天池 --3字符串部分

Python基础入门：列表、元组、字符串、字典、集合、序列-阿里云天池 --4字典部分

Python基础入门：列表、元组、字符串、字典、集合、序列-阿里云天池 --5集合部分

Python基础入门：列表、元组、字符串、字典、集合、序列-阿里云天池 --6序列部分

自学补充基础知识：

“地板除”还是“取整除”？地板除和天花板除floor division和ceil devision

彻底搞懂 OFFSET 偏移量 INDEX 索引 及 OFF-by-ONE 大小差一

Python入门(中)

  1. 简介
  2. 列表
    1. 列表的定义
    2. 列表的创建
    3. 向列表中添加元素
    4. 删除列表中的元素
    5. 获取列表中的元素
    6. 列表的常用操作符
    7. 列表的其它方法
  3. 元组
    1. 创建和访问一个元组
    2. 更新和删除一个元组
    3. 元组相关的操作符
    4. 内置方法
    5. 解压元组
  4. 字符串
    1. 字符串的定义
    2. 字符串的切片与拼接
    3. 字符串的常用内置方法
    4. 字符串格式化
  5. 字典
    1. 可变类型与不可变类型
    2. 字典的定义
    3. 创建和访问字典
    4. 字典的内置方法
  6. 集合
    1. 集合的创建
    2. 访问集合中的值
    3. 集合的内置方法
    4. 集合的转换
    5. 不可变集合
  7. 序列
    1. 针对序列的内置函数

简介

Python 是一种通用编程语言，其在科学计算和机器学习领域具有广泛的应用。如果我们打算利用 Python 来执行机器学习，那么对 Python 有一些基本的了解就是至关重要的。本 Python 入门系列体验就是为这样的初学者精心准备的。

列表

简单数据类型

  • 整型<class 'int'>
  • 浮点型<class 'float'>
  • 布尔型<class 'bool'>

容器数据类型

  • 列表<class 'list'>
  • 元组<class 'tuple'>
  • 字典<class 'dict'>
  • 集合<class 'set'>
  • 字符串<class 'str'>

1. 列表的定义

列表是有序集合，没有固定大小，能够保存任意数量任意类型的 Python 对象，语法为 [元素1, 元素2, ..., 元素n]。

  • 关键点是「中括号 []」和「逗号 ,」
  • 中括号 把所有元素绑在一起
  • 逗号 将每个元素一一分开

2. 列表的创建

  • 创建一个普通列表
x = ['Monday', 'Tuesday', 'Wednesday', 'Thursday', 'Friday']
print(x, type(x))
# ['Monday', 'Tuesday', 'Wednesday', 'Thursday', 'Friday'] <class 'list'>

x = [2, 3, 4, 5, 6, 7]
print(x, type(x))
# [2, 3, 4, 5, 6, 7] <class 'list'>
  • 利用range()创建列表
x = list(range(10))
print(x, type(x))
# [0, 1, 2, 3, 4, 5, 6, 7, 8, 9] <class 'list'>

x = list(range(1, 11, 2))
print(x, type(x))
# [1, 3, 5, 7, 9] <class 'list'>

x = list(range(10, 1, -2))
print(x, type(x))
# [10, 8, 6, 4, 2] <class 'list'>
  • 利用推导式创建列表
x = [0] * 5
print(x, type(x))
# [0, 0, 0, 0, 0] <class 'list'>

x = [0 for i in range(5)]
print(x, type(x))
# [0, 0, 0, 0, 0] <class 'list'>

x = [i for i in range(10)]
print(x, type(x))
# [0, 1, 2, 3, 4, 5, 6, 7, 8, 9] <class 'list'>

x = [i for i in range(1, 10, 2)]
print(x, type(x))
# [1, 3, 5, 7, 9] <class 'list'>

x = [i for i in range(10, 1, -2)]
print(x, type(x))
# [10, 8, 6, 4, 2] <class 'list'>

x = [i ** 2 for i in range(1, 10)]
print(x, type(x))
# [1, 4, 9, 16, 25, 36, 49, 64, 81] <class 'list'>

x = [i for i in range(100) if (i % 2) != 0 and (i % 3) == 0]
print(x, type(x))

# [3, 9, 15, 21, 27, 33, 39, 45, 51, 57, 63, 69, 75, 81, 87, 93, 99] <class 'list'>

注意：

由于list的元素可以是任何对象，因此列表中所保存的是对象的指针。即使保存一个简单的[1,2,3]，也有3个指针和3个整数对象。

指针又是什么意思？？？？

x = [a] * 4操作中，只是创建4个指向list的引用，所以一旦a改变，x中4个a也会随之改变。

x = [[0] * 3] * 4
print(x, type(x))
# [[0, 0, 0], [0, 0, 0], [0, 0, 0], [0, 0, 0]] <class 'list'>

x[0][0] = 1
print(x, type(x))
# [[1, 0, 0], [1, 0, 0], [1, 0, 0], [1, 0, 0]] <class 'list'>

a = [0] * 3
x = [a] * 4
print(x, type(x))
# [[0, 0, 0], [0, 0, 0], [0, 0, 0], [0, 0, 0]] <class 'list'>

x[0][0] = 1
print(x, type(x))
# [[1, 0, 0], [1, 0, 0], [1, 0, 0], [1, 0, 0]] <class 'list'>
  • 创建一个混合列表
mix = [1, 'lsgo', 3.14, [1, 2, 3]]
print(mix, type(mix))  
# [1, 'lsgo', 3.14, [1, 2, 3]] <class 'list'>
  • 创建一个空列表
empty = []
print(empty, type(empty))  # [] <class 'list'>

列表不像元组，列表内容可更改 (mutable)，因此附加 (append, extend)、插入 (insert)、删除 (remove, pop) 这些操作都可以用在它身上。

3. 向列表中添加元素

  • list.append(obj) 在列表末尾添加新的对象，只接受一个参数，参数可以是任何数据类型，被追加的元素在 list 中保持着原结构类型。
x = ['Monday', 'Tuesday', 'Wednesday', 'Thursday', 'Friday']
x.append('Thursday')
print(x)  
# ['Monday', 'Tuesday', 'Wednesday', 'Thursday', 'Friday', 'Thursday']

print(len(x))  # 6

此元素如果是一个 list，那么这个 list 将作为一个整体进行追加，注意append()和extend()的区别。

x = ['Monday', 'Tuesday', 'Wednesday', 'Thursday', 'Friday']
x.append(['Thursday', 'Sunday'])
print(x)  
# ['Monday', 'Tuesday', 'Wednesday', 'Thursday', 'Friday', ['Thursday', 'Sunday']]

print(len(x))  # 6
  • list.extend(seq) 在列表末尾一次性追加另一个序列中的多个值（用新列表扩展原来的列表）
x = ['Monday', 'Tuesday', 'Wednesday', 'Thursday', 'Friday']
x.extend(['Thursday', 'Sunday'])
print(x)  
# ['Monday', 'Tuesday', 'Wednesday', 'Thursday', 'Friday', 'Thursday', 'Sunday']

print(len(x))  # 7

严格来说 append 是追加，把一个东西整体添加在列表后，而 extend 是扩展，把一个东西里的所有元素添加在列表后。

  • list.insert(index, obj) 在编号 index 位置插入 obj。
x = ['Monday', 'Tuesday', 'Wednesday', 'Thursday', 'Friday']
x.insert(2, 'Sunday')
print(x)
# ['Monday', 'Tuesday', 'Sunday', 'Wednesday', 'Thursday', 'Friday']

print(len(x))  # 6

4. 删除列表中的元素

  • list.remove(obj) 移除列表中某个值的第一个匹配项
x = ['Monday', 'Tuesday', 'Wednesday', 'Thursday', 'Friday']
x.remove('Monday')
print(x)  # ['Tuesday', 'Wednesday', 'Thursday', 'Friday']

list.pop([index=-1]) 移除列表中的一个元素（默认最后一个元素），并且返回该元素的值

x = ['Monday', 'Tuesday', 'Wednesday', 'Thursday', 'Friday']
y = x.pop()
print(y)  # Friday

y = x.pop(0)
print(y)  # Monday

y = x.pop(-2)
print(y)  # Wednesday
print(x)  # ['Tuesday', 'Thursday']

remove 和 pop 都可以删除元素，前者是指定具体要删除的元素，后者是指定一个索引。

  • del var1[, var2 ……] 删除单个或多个对象。

如果知道要删除的元素在列表中的位置，可使用del语句。

x = ['Monday', 'Tuesday', 'Wednesday', 'Thursday', 'Friday']
del x[0:2]
print(x)  # ['Wednesday', 'Thursday', 'Friday']

如果你要从列表中删除一个元素，且不再以任何方式使用它，就使用del语句；如果你要在删除元素后还能继续使用它，就使用方法pop()。

5. 获取列表中的元素

  • 通过元素的索引值，从列表获取单个元素，注意，列表索引值是从0开始的。
  • 通过将索引指定为-1，可让Python返回最后一个列表元素，索引 -2 返回倒数第二个列表元素，以此类推。
x = ['Monday', 'Tuesday', 'Wednesday', ['Thursday', 'Friday']]
print(x[0], type(x[0]))  # Monday <class 'str'>
print(x[-1], type(x[-1]))  # ['Thursday', 'Friday'] <class 'list'>
print(x[-2], type(x[-2]))  # Wednesday <class 'str'>

切片的通用写法是 start : stop : step

  • 情况 1 - "start :"
  • 以 step 为 1 (默认) 从编号 start 往列表尾部切片。
x = ['Monday', 'Tuesday', 'Wednesday', 'Thursday', 'Friday']
print(x[3:])  # ['Thursday', 'Friday']
print(x[-3:])  # ['Wednesday', 'Thursday', 'Friday']
  • 情况 2 - ": stop"
  • 以 step 为 1 (默认) 从列表头部往编号 stop 切片。
week = ['Monday', 'Tuesday', 'Wednesday', 'Thursday', 'Friday']
print(week[:3])  # ['Monday', 'Tuesday', 'Wednesday']
print(week[:-3])  # ['Monday', 'Tuesday']
  • 情况 3 - "start : stop"
  • 以 step 为 1 (默认) 从编号 start 往编号 stop 切片。
week = ['Monday', 'Tuesday', 'Wednesday', 'Thursday', 'Friday']
print(week[1:3])  # ['Tuesday', 'Wednesday']
print(week[-3:-1])  # ['Wednesday', 'Thursday']
  • 情况 4 - "start : stop : step"
  • 以具体的 step 从编号 start 往编号 stop 切片。注意最后把 step 设为 -1，相当于将列表反向排列。
week = ['Monday', 'Tuesday', 'Wednesday', 'Thursday', 'Friday']
print(week[1:4:2])  # ['Tuesday', 'Thursday']
print(week[:4:2])  # ['Monday', 'Wednesday']
print(week[1::2])  # ['Tuesday', 'Thursday']
print(week[::-1])  
# ['Friday', 'Thursday', 'Wednesday', 'Tuesday', 'Monday']
  • 情况 5 - " : "
  • 复制列表中的所有元素（浅拷贝）。
eek = ['Monday', 'Tuesday', 'Wednesday', 'Thursday', 'Friday']
print(week[:])  
# ['Monday', 'Tuesday', 'Wednesday', 'Thursday', 'Friday']

浅拷贝与深拷贝

list1 = [123, 456, 789, 213]
list2 = list1
list3 = list1[:]

print(list2)  # [123, 456, 789, 213]
print(list3)  # [123, 456, 789, 213]
list1.sort()
print(list2)  # [123, 213, 456, 789] 
print(list3)  # [123, 456, 789, 213]

list1 = [[123, 456], [789, 213]]
list2 = list1
list3 = list1[:]
print(list2)  # [[123, 456], [789, 213]]
print(list3)  # [[123, 456], [789, 213]]
list1[0][0] = 111
print(list2)  # [[111, 456], [789, 213]]
print(list3)  # [[111, 456], [789, 213]]

接下来，补充基础知识，浅拷贝和深拷贝

补充基础知识，浅拷贝和深拷贝：python中浅拷贝和深拷贝分析 - anne199534

首先，我们知道Python3中，有6个标准的数据类型，他们又分为可以变和不可变。不可变：Number（数字）、String（字符串）、Tuple（元组）。可以变：List（列表）、Dictionary（字典）、Set（集合）。

不可变和可变类型的知识点在：Python基础入门：列表、元组、字符串、字典、集合、序列-阿里云天池 --4字典部分

一.浅拷贝

a 和 b 是一个独立的对象，但他们的子对象还是指向统一对象（是引用）。

浅拷贝后，改变原始对象中为可变类型的元素的值，会同时影响拷贝对象；

改变原始对象中为不可变类型的元素的值，不会响拷贝对象。

#定义一个列表，第一个元素是可变类型
>>> A = [[1,2],'fei',90]

#浅拷贝
>>> B = copy.copy(A)

#对象地址是否相同
>>> A is B
False

#第一个元素地址是否相同
>>> A[0] is B[0]
True

#第二个元素地址是否相同
>>> A[1] is B[1]
True

#改变第一个可变类型的值，查看复制对象变化
>>> A[0][0] = 2
>>> A
[[2, 2], 'fei', 90]

#复制对象也跟着改变了
>>> B
[[2, 2], 'fei', 90]

#改变第二个不可变类型的值，查看复制对象变化
>>> A[1] = 'anne'
>>> A
[[2, 2], 'anne', 90]

#复制对象没有改变
>>> B
[[2, 2], 'fei', 90]

二.深拷贝

a 和 b 完全拷贝了父对象及其子对象，两者是完全独立的。

深拷贝，除了顶层拷贝，还对子元素也进行了拷贝。

经过深拷贝后，原始对象和拷贝对象所有的可变元素地址都没有相同的了。

#深拷贝
>>> C = copy.deepcopy(A)

#对象地址是否相同
>>> A is C
False

#第一个元素地址是否相同
>>> A[0] is C[0]
False

#第二个元素地址是否相同
>>> A[1] is C[1]
True

#改变第一个元素，查看复制元素变化
>>> A[0][0] = 2
>>> A
[[2, 2], 'fei', 90]

#复制元素不变，对复制元素没影响
>>> C
[[1, 2], 'fei', 90]

#改变第二个元素，查看复制元素变化
>>> A[1] = 'Anne' >>> A
[[2, 2], 'Anne', 90]

#复制元素不变，对复制元素没影响
>>> C
[[1, 2], 'fei', 90]

在这里看到一个让我困惑的问题，A is B

三.赋值引用

a 和 b 都指向同一个对象

#赋值引用
>>> A = [[1,2],'fei',90]
>>> D = A

#对象地址是否相同
>>> A is D
True

#第一个元素地址是否相同
>>> A[0] is D[0]
True

#第二个元素地址是否相同
>>> A[1] is D[1]
True

#改变A中第一个元素，查看是否影响D
>>> A[0][0] = 2
>>> A
[[2, 2], 'fei', 90]

#D中第一个元素也跟着改变
>>> D
[[2, 2], 'fei', 90]

#改变D中第二个元素，查看是否影响A
>>> D[1] = 'anne'

#A中第二个元素也改变了
>>> A
[[2, 2], 'anne', 90]
>>> D
[[2, 2], 'anne', 90]

cba2fa641abba3631d43a48eeaf48dfd.png

6. 列表的常用操作符

  • 等号操作符：==
  • 连接操作符 +
  • 重复操作符 *
  • 成员关系操作符 in、not in

「等号 ==」，只有成员、成员位置都相同时才返回True。

列表拼接有两种方式，用「加号 +」和「乘号 *」，前者首尾拼接，后者复制拼接。

list1 = [123, 456]
list2 = [456, 123]
list3 = [123, 456]

print(list1 == list2)  # False
print(list1 == list3)  # True

list4 = list1 + list2  # extend()
print(list4)  # [123, 456, 456, 123]

list5 = list3 * 3
print(list5)  # [123, 456, 123, 456, 123, 456]

list3 *= 3
print(list3)  # [123, 456, 123, 456, 123, 456]

print(123 in list3)  # True
print(456 not in list3)  # False

前面三种方法（append,extend,insert）可对列表增加元素，它们没有返回值，是直接修改了原数据对象。 而将两个list相加，需要创建新的 list 对象，从而需要消耗额外的内存，特别是当 list 较大时，尽量不要使用 “+” 来添加list。

7. 列表的其它方法

list.count(obj) 统计某个元素在列表中出现的次数

list1 = [123, 456] * 3
print(list1)  # [123, 456, 123, 456, 123, 456]
num = list1.count(123)
print(num)  # 3

list.index(x[, start[, end]])从列表中找出某个值第一个匹配项的索引位置。

list1 = [123, 456] * 5
print(list1.index(123))  # 0
print(list1.index(123, 1))  # 2
print(list1.index(123, 3, 7))  # 4

list.reverse()反向列表中元素

x = [123, 456, 789]
x.reverse()
print(x)  # [789, 456, 123]

list.sort(key=None, reverse=False) 对原列表进行排序。

  • key -- 主要是用来进行比较的元素，只有一个参数，具体的函数的参数就是取自于可迭代对象中，指定可迭代对象中的一个元素来进行排序。
  • reverse -- 排序规则，reverse = True 降序， reverse = False 升序（默认）。
  • 该方法没有返回值，但是会对列表的对象进行排序。
x = [123, 456, 789, 213]
x.sort()
print(x)
# [123, 213, 456, 789]

x.sort(reverse=True)
print(x)
# [789, 456, 213, 123]


# 获取列表的第二个元素
def takeSecond(elem):
    return elem[1]


x = [(2, 2), (3, 4), (4, 1), (1, 3)]
x.sort(key=takeSecond)
print(x)
# [(4, 1), (2, 2), (1, 3), (3, 4)]

x.sort(key=lambda a: a[0])
print(x)
# [(1, 3), (2, 2), (3, 4), (4, 1)]
weixin_39623355
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
Python-列表转字符串
12-21
问题描述 对于长度为5位的一个01串，每一位都可能是0或1，一共有32种可能。它们的前几个是： 00000 00001 00010 00011 00100 请按从小到大的顺序输出这32种01串。 输入格式 本试题没有输入。 输出格式 输出32行，按从小到大的顺序每行一个长度为5的01串。 样例输出 00000 00001 00010 00011 代码实现： for i in range(0,32): li=list() #新建一个空列表 n=i for j in range(0,5): li.append(str(n%2)) #转为字符串的形式存入
python碎片|python字符串与列表的相互转换
CITYDATA
11-11 232
字符串转列表 str1 = "hi hello world" print(str1.split(" ")) 输出： ['hi', 'hello', 'world'] 列表转字符串 l = ["hi","hello","world"] print(" ".join(l)) 输出： hi hello world
【Python】 如何将列表转换为字符串
PythonWeb实践
05-27 1634
列表是一个有序的元素集合，可以包含不同类型的元素，而字符串则是一个字符序列。有时，我们可能需要将列表中的元素连接起来，形成一个单一的字符串。理解这些方法的原理和使用场景，可以帮助你在实际编程中做出更好的选择。记住，代码的可读性和性能同样重要，选择合适的方法可以使你的代码更加健壮和高效。> 【痕迹】QQ+微信朋友圈和聊天记录分析工具1.0.4 （1）纯Python语言实现，使用Flask后端，本地分析，不上传个人数据。方法是字符串对象的方法，它可以将序列中的元素以指定的字符连接生成一个新的字符串。
【Python】将列表转化为字符串
littlegengjie的博客
10-09 1万+
可以使用字符串的方法将列表中的元素连接成一个字符串。例如，我们有一个列表 l1，如果想把它转化为字符串，则可以使用以下方法： 其中，参数 表示将元素之间用空字符串连接起来，也可以使用其他字符作为连接符。例如，如果想用逗号进行连接，则可以使用 。通过列表推导式和函数，将列表中的每个元素转换为字符串，然后再使用方法连接起来。 3、使用函数和函数： 使用函数将函数应用到列表的每个元素上，然后使用方法连接起来。 这些方法都可以将列表转化为字符串，你可以根据实际需求选择适合的方法。
python数据类型的转换_Python - 几种数据类型的转换
weixin_39611754的博客
11-20 106
前言在处理数据的时候，经常需要转换数据的格式，来方便数据遍历等操作。字符串转字典dict_string = "{'name':'linux','age':18}"to_dict = eval(dict_string)print(type(to_dict))也可以用json进行转换import json #如果是Python2.6应该是simplejsondict_string = "{'nam...
Python字符串、列表、元组、字典、集合的补充实例详解
09-18
主要介绍了Python字符串、列表、元组、字典、集合,结合实例形式详细分析了Python字符串、列表、元组、字典、集合常见函数使用方法及相关操作注意事项,需要的朋友可以参考下
python字符串,元组,列表,字典互转代码实例详解
09-17
### Python字符串、元组、列表、字典互转详解 在Python编程中，字符串、元组、列表和字典是最常见的几种数据结构。这些数据类型之间的转换是编程中经常用到的操作之一。本文将详细介绍这四种数据类型的转换方法，并...
在Python中字符串、列表、元组、字典之间的相互转换
09-18
本文将详细讨论如何在字符串(str)、列表(list)、元组(tuple)和字典(dict)之间进行转换。 1. 字符串转换为列表 字符串可以使用内置的`list()`方法转换为列表。例如： ```python str_1 = "1235" list_1 = list...
Python 基础课程《6.列表、元组、字符串》
最新发布
05-28
### Python基础课程知识点详解：列表、元组、字符串 #### 一、序列的介绍 在Python编程语言中，**序列**是一种重要的数据类型，用于存储一系列有序的数据项。Python提供了几种不同的序列类型，包括列表（List）、...
python中list转字符串
weixin_30364325的博客
06-09 141
命令：''.join(list) 其中，引号中是字符之间的分割符，如“,”，“;”，“\t”等等 如： list = [1, 2, 3, 4, 5] ''.join(list) 结果即为：12345 ','.join(list) 结果即为：1,2,3,4,5 转载于:https://www.cnblogs.com/huwang-sun/p/6972990.html...
python 把列表转化为字符串的方法
12-25
列表转化为字符串 如下所示： >>> list1=['ak','uk',4] >>> list2=[str(i) for i in list1] #使用列表推导式把列表中的单个元素全部转化为str类型 >>> list2 #查看转化后的列表 ['ak', 'uk', '4'] >>> list3=' '.join(list2) #把列表中的元素放在空串中，元素间用空格隔开 >>> list3 #查看生成的长串 'ak uk 4' 用print方法直接直接打印出串中的元素，不显示格式 >>> a=["1","2","3","4","5"] #列表中的元素全是str类型 >>> print("
python列表转为字符串
热门推荐
Yangcp_的博客
08-11 5万+
python列表转化为字符串
python list转成字符串
AA3315182的博客
09-13 950
python 点滴进步记录
python 列表转字符串_阅读《python编程-从入门到实践》笔记分享
weixin_39625975的博客
11-27 120
各位小伙伴，我叫Santiago一名来自重庆的大三学生，目前在学习物联网和云计算专业，以后我会不定期的在这里上传我的python学习笔记，希望与大家一起学习python，一起进步，如果笔记中有错误，希望大家即时给我指出，在下甚是感激！1. Print()函数的主要目的是以字符串的形式输出结果。2. 基本形式是print（“要输出的字符串”或者 变量）3. 在python编程当中，有时...
python列表 字符串 转换
vampirem的专栏
11-27 1867
列表转字符串 python中的列表l = ['1','2','3','4']转成str型'1,2,3,4' ','.join(l) 这个方法，列表里都是字符串的话可以这样用。列表里是整数的情况可以用： >>> s='' >>> l=[1,2,3,4] >>> n=0 >>> while n ... s += str(l[n]) ... n += 1 >>> s
Python编程学习笔记：列表
weixin_30566063的博客
07-16 170
Python编程学习笔记：列表Python容器包括列表、元组、集合与字典。这些数据结构中都涉及到很多的方法，在这里对比较常用的一些方法进行介绍，不用每个方法都记住，熟悉常用的记牢就可以啦。我们先来看列表。一、列表的创建方式# -*- coding: utf-8 -*- # __author : Demon # date : 1/16/18 8:19 PM # 列表的创建 empty_list_01...
Python 中将一个列表转换为字符串
wjianwei666的专栏
03-08 1315
使用`str.join()`方法可以将列表中的所有元素连接成一个字符串，元素之间用指定的分隔符（如逗号、空格等）分隔。以上就是几种将Python列表转换为字符串的方法，你可以根据具体需求来选择最适合你的方法。这是一种比较原始的方法，但不失为一种理解每个元素如何被转换为字符串的好方法。`map()`函数可以应用于列表中的每个元素，将它们转换为字符串。print(my_string) # 输出："123"### 使用`map()`和`str()`函数。### 使用`str.join()`方法。
python列表转字符串_python字符串（str）和列表（list）的互相转换
weixin_39917485的博客
11-24 441
一、字符串(str)转列表（list）>>> str1 = "12345">>> list1 = list(str1)>>> print list1['1', '2', '3', '4', '5']>>>>>> str2 = "123 sjhid dhi">>> list2 = str2.split() # or list2 = str2.split(" ")>>> print list2['12...
Python基础数据结构详解：列表、元组、字符串等
本课程名为"Python的基本数据结构（课件）"，主要介绍了Python语言中几种核心的数据结构，包括列表（list）、元组（tuple）、字符串（string）、集合（set）和字典（dict）。这些数据结构在Python编程中扮演着关键...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

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

余额充值