python json 单引号问题 python 单引号字符串

转载

mob64ca13f446df 2024-07-05 11:29:34

文章标签 python json 单引号问题 python 字符串元组 文章分类 Python 后端开发

字符串、列表和元组类型

1.字符串(str)类型

字符串
字符串的下标
字符串切片
字符串类型转换
字符串组成方式
字符串的常见操作

2.列表(list)类型

列表介绍
创建方式
访问列表内的元素
修改元素的值
删除元素
列表的特殊操作
列表的常用函数
排序和反转
切片(截取)
多维列表（嵌套列表）
列表的遍历
列表的内置方法

3.元组类型

元组介绍
元组(tuple)创建
元组与列表相同的操作
元组中不允许的操作

不允许修改、新增元素
不允许删除某个元素（但可以删除整个元组）

列表和元组的转换

元组转为列表
列表转为元组

1.字符串(str)类型

字符串

介绍

字符串是Python中最常用的数据类型之一，使用单引号或双引号来创建字符串，使用三引号创建多行字符串。

创建

s1 = "hello oldamy"
print(s1)

s2 = 'hello oldamy'
print(s2)

s3 = '''hello oldamy'''
print(s3)

注意:

字符串的单引号与双引号都是成对出现的，不能一边单一边双。
所有符号都是英文状态下的
字符串是不可变的序列数据类型，不能直接修改字符串本身，和数字类型一样！

字符串的下标

由于字符串是序列数据结构，所以我们可以通过下标将字符串中某个字母取出来。下标也可称为索引，默认从0开始。

>>> s1 = "hello world"			
>>> s1[1]				
'e'
>>> s1[10]
'd'
>>> s1[-1]
'd'
>>> s1[11]
Traceback (most recent call last):
  File "<stdin>", line 1, in <module>
IndexError: string index out of range

字符串切片

python json 单引号问题 python 单引号字符串_python

在dos命令行中，输入help(slice)，查看切片说明文档。
切片参数：

start起始位置，默认索引从0开始
stop结束位置，默认最后一个元素
step步长，默认为1

>>> help(slice)
Help on class slice in module builtins:

class slice(object)
 |  slice(stop)
 |  slice(start, stop[, step])
 |
 |  Create a slice object.  This is used for extended slicing (e.g. a[0:10:2]).

切片实战
s3 = “hello world”

如何取出world值？
代码如下：

>>> s3 = "hello world"
>>> s3[6:10]			# 注意,左闭右开
'worl'
>>> s3[6:11]
'world'
>>> s3[6:]				# 不写默认取到最后一位
'world'

如何取出hlowrd值？发现是隔一个取一个，则步长为2
代码如下：

>>> s3[::2]
'hlowrd'

s3如何逆序输出？
代码如下：

>>> s3[::-1]
'dlrow olleh'

注意：

索引默认从0开始
切片时左闭右开
当是取单个字符的时候,索引超出范围会报错。而切片时不会报错。
步长不能为0，也不允许为浮点数

字符串类型转换

将字符串转为整数类型

>>> int('1')
1
>>> int('a')	# 报错 注意int()为十进制
Traceback (most recent call last):
  File "<stdin>", line 1, in <module>
ValueError: invalid literal for int() with base 10: 'a'

将整数类型转为字符串

>>> str(1)
'1'

字符串组成方式

+号直接拼接

print('1'+'2')  # 12

%s %d %f

name = 'tly'
age = 18
print('%s年龄%d'%(name,age))    # tly年龄18

str.format()

name = 'tly'
age = 18
print('{}年龄{}'.format(name,18))     # tly年龄18
print('{1}年龄{0}'.format(18,name))   # tly年龄18

f’ ’

name = 'tly'
age = 18
print(f'{name}的年龄是{age}')

字符串的常见操作

S.find(sub) --> 返回该元素最小的索引

>>> s4 = 'hello python'
>>> s4.find('e')
1
>>> s4.find('o')	# 当元素有多个时,返回最小索引
4
>>> s4.find('c')	# 找不到则为-1
-1

S.index(sub) --> 返回该元素最小的索引
实际上，该方法与s.find()实现的功能一样，但是唯一不同的就是当元素不存在时，s.index()方法会报错。所以建议使用s.find()
S.replace(old, new[, count]) --> 替换

>>> s5 = "hello python"
>>> s5.replace('l','a')  	# 将'l'替换成'a',全部替换
'heaao python'

>>> s5
'hello python'			 	# 注意：原来的字符串并没有被改变

>>> s5.replace('l','a',1)	# 只替换一个,则指定count参数为1即可
'healo python'

S.split(sep=None) --> 以sep来分割字符串,并返回列表。sep默认为None,分割默认为空格

>>> s6 = 'hello everyboby ye!'
>>> s6.split(' ')
['hello', 'everyboby', 'ye!']

S.startswith(prefix[, start[, end]]) --> 判断字符串是否以前缀开始，返回为bool值。

>>> s7 = "hello world"
>>> s7.startswith("he")
True

S.endswith(suffix[, start[, end]]) --> 判断字符串是否以尾缀结束，返回为bool值。

>>> s7
'hello world'
>>> s7.endswith('ld')
True

S.lower() --> 将字符串全部转为小写
S.upper() --> 将字符串全部转为大写
S.strip([chars]) --> 默认去掉字符串左右的空格

>>> s8 = '  hello world   '
>>> s8.strip()
'hello world'

S.isalpha() --> 判断字符串是否全为字母，返回的是bool值
S.isdigit() --> 判断字符串是否全为数字，返回的是bool值
S.isalnum() --> 判断字符串是否全为数字或者字母，不存在特殊字符，返回的是bool值
S.join(iterable) --> 将序列中的元素以指定的字符连接生成一个新的字符串

li = ["你好","世界"]
s = ','.join(li)
print(s)

2.列表(list)类型

列表介绍

列表是 Python 中最基本也是最常用的数据结构之一，它是一个有序可重复的元素集合，可进行修改、切片、追加、删除、嵌套、迭代、成员判断等操作。
从数据结构角度看，Python 的列表是一个可变长度的顺序存储结构，每一个位置存放的都是对象的指针。
列表中的每个元素都被分配一个数字作为索引，用来表示该元素在列表内所排在的位置。第一个元素的索引是0，第二个索引是1，依此类推。
对于这个列表 alist = [1, “a”, [11,22], {“k1”:“v1”}]，其在内存内的存储方式是这样的：

创建方式

创建一个列表，只要把逗号分隔的不同的数据项使用** **括起来即可

>>> li = []		# 定义一个空的列表 注意 命名不能是list
>>> li
[]
>>> li1 = [1,'amy',3.14]	# 任何数据类型都可存储
>>> li1
[1, 'amy', 3.14]
>>> li2 = list()	
>>> li2
[]
>>> li3 = list('hello')		# list(iterable)
>>> li3
['h', 'e', 'l', 'l', 'o']

注意：

变量名最好不要使用 list
列表里的元素可以是任意类型
iterable 表示可迭代的对象，简单来说就是可以一个一个元素取出来的。比如：str

访问列表内的元素

列表从0开始为它的每一个元素顺序创建下标索引，直到总长度减一 。要访问它的某个元素，以方括号加下标值的方式即可。
注意要确保索引不越界，一旦访问的 索引超过范围，会抛出异常。所以，一定要记得最后一个元素的索引是len(list)-1。

>>> li = ["t", "l", "y"]
>>> li[0]
't'
>>> li[1]
'l'
>>> li[2]
'y'
>>> li[3]
Traceback (most recent call last):
  File "<pyshell#7>", line 1, in <module>
    lis[3]
IndexError: list index out of range

修改元素的值

直接对元素进行重新赋值。

>>> li1 = [1,2,3]
>>> li1[1]
2

>>> li1[1] = 5
>>> li1
[1, 5, 3]

>>> li1[1:] = [6,7]
>>> li1
[1, 6, 7]

li = ['a','b','c']
li[0] = 'A'
print(li)

删除元素

直接取出元素，再通过 del语句 或者 list.remove() 或者 list.pop() 进行删除

>>> lis = ["a", "b", "c"]
>>> del lis[0]      # 根据索引删除（del li[idx]）
# ['b', 'c']

>>> lis.remove("b") # 根据元素删除
# ['a','c']

>>> lis.pop()       # 最后一个开始删除
# 删掉'c'  # ['a','b']

l1 = [1, 'hello', 2]
l2 = l1.pop(1)  # 根据索引来删除 1为索引
print(l2)   # [1,2]

列表的特殊操作

# 语句 							结果 								描述
[1, 2, 3] + [4, 5, 6] 		   # [1, 2, 3, 4, 5, 6] 				组合两个列表
l1 = [1, 2, 3]
l2 = [4, 5, 6]
print(l1.__add__(l2))  		   # 底层调用了__add__方法

['tly'] * 4 		   		   # ['tly', 'tly', 'tly', 'tly'] 	     列表的乘法
l1 = ['tly']
print(l1.__mul__(4))

3 in [1, 2, 3] 				   # True 						   判断元素是否存在于列表中
l1 = [1, 2, 3]
print(l1.__contains__(3))

列表的常用函数

返回长度 len()
返回最大值 max()
返回最小值 min()

# 函数 		  		作用
>>> l1 = [1, 2, 3]
>>> len(l1) 		# 返回列表元素个数，也就是获取列表长度 l1.__len__()
3
>>> max(l1) 		# 返回列表元素最大值  max(l1)  max(1,2,3,4)
3
>>> min(l1) 		# 返回列表元素最小值
1
>>> list('hello') 	# 将序列转换为列表
['h', 'e', 'l', 'l', 'o']

>>> s = list((1, "a", "b", 2))
>>> s
[1, 'a', 'b', 2]

>>> max(s)          # 不能混合不同类型进行最大最小求值
Traceback (most recent call last):
  File "<pyshell#20>", line 1, in <module>
    max(s)
TypeError: '>' not supported between instances of 'str' and 'int'

排序和反转

list.reverse() -----> 将列表反转
list.sort(reverse=Fasle) -----> 排序，默认升序
reverse=True 降序

>>> li = [1,2,3,4,5,2,1,3,1]
>>> li.reverse()			# 将列表反转 修改本身 *IN PLACE*
>>> li
[1, 3, 1, 2, 5, 4, 3, 2, 1]
>>> li.sort()				# 排序，默认升序 L.sort(key=None, reverse=False)
>>> li
[1, 1, 1, 2, 2, 3, 3, 4, 5]
>>> li.sort(reverse=True)	# reverse=True 降序
>>> li
[5, 4, 3, 3, 2, 2, 1, 1, 1]

切片(截取)

切片指的是对序列进行截取，选取序列中的某一段。
切片的语法是： list[start:end:step]
以冒号分割索引，start代表起点索引，end代表结束点索引，step为步长默认为1。省略start表示以0开始，省略end表示到列表的结尾。注意，区间是左闭右开的！
如果提供的是负整数下标，则从列表的最后开始往头部查找。例如-1表示最后一个元素，-3表示倒数第三个元素。
切片过程中还可以设置步长，以第二个冒号分割，例如list[3:9:2]，表示每隔多少距离取一个元素。

>>> l3 = ['a','b','c','d','e','f']
>>> l3[1]							# 取'b'					注意：index默认从0开始
'b'
>>> l3[2]							# 取'c'
'c'
>>> l3[1:3]							# 取['b', 'c']			注意：左闭右开
['b', 'c']
>>> l3[:3]							# 取['a', 'b', 'c']		注意：start不写默认从头开始
['a', 'b', 'c']
>>> l3[2:]							# 取['c', 'd', 'e', 'f']	注意：end不写默认到最后			
['c', 'd', 'e', 'f']
>>> l3[:]							# 取全部			
['a', 'b', 'c', 'd', 'e', 'f']
>>> l3[::2]							# 取['a', 'c', 'e']		注意：步长为2
['a', 'c', 'e']
>>> l3[::-1]						# 逆序		
['f', 'e', 'd', 'c', 'b', 'a']

多维列表（嵌套列表）

>>> a = [[1,2,3],[4,5,6],[7,8,9]]
>>>a[0]
[1,2,3]

>>> a[0][1]
2

列表的遍历

列表有好几种遍历方式：

a = [1,2,3,4,5,6]
for i in a:            		 # 遍历每一个元素本身
    print(i)

for i in range(len(a)):    	 # 遍历列表的下标，通过下标取值
    print(i, a[i])

x = 5
if x in a:      			 # 进行是否属于列表成员的判断。该运算速度非常快。
    print("True")
else:
    print("False")

列表的内置方法

• append(obj) 在列表末尾添加新的对象
• count(obj)统计某个元素在列表中出现的次数
• extend(seq) 在列表末尾一次性追加另一个序列中的多个值（用新列表扩展原来的列表）
• index(obj) 从列表中找出某个值第一个匹配项的索引位置
• insert(index, obj) 将对象插入列表
• pop(obj=list[-1]) 移除列表中的一个元素（默认最后一个元素），并且返回该元素的值
• remove(obj) 移除列表中某个值的第一个匹配项
• reverse() 反向列表中元素
• sort([func]) 对原列表进行排序
• copy() 复制列表
• clear() 清空列表，等于del lis[:]

>>> li = [1,2,3]
>>> li.append([3,3])
>>> li
[1, 2, 3, [3, 3]]

>>> li = [1,2,3,[3,3]]
>>> li.count(3) 
1

>>> li = [1,2,3]
>>> li.extend([4,5])   
>>> li
[1, 2, 3, 4, 5]

>>> li = [1,2,3,2,3]
>>> li.index(3) 
2

>>> li = ['happy','year']
>>> li.insert(1,'new')	
>>> li
['happy', 'new', 'year']

>>> li = [1,2,3]
>>> li.clear() 
>>> li

注意：其中的类似 append，insert, remove 等方法会修改列表本身，并且没有返回值（严格的说是返回None）。

3.元组类型

元组介绍

用圆括号括起来的是元组。
元组也是序列结构，但是是一种不可变序列，可以简单的理解为内容不可变的列表。

元组(tuple)创建

>>> tu = ()
>>> tu
()

>>> tu1 = tuple()
>>> tu1
()

>>> type(tu)
<class 'tuple'>
>>> type(tu1)
<class 'tuple'>

元组与列表相同的操作

使用方括号加下标访问元素

>>> tu = (1,2,3,4,5)
>>> tu[1]
2

切片(形成新元组对象)

>>> tu
(1, 2, 3, 4, 5)
>>> tu[2:4]
(3, 4)

tuple.count()/tuple.index()

>>> tu1 = (1,2,3,4,5,5,5,4)
>>> tu1.count(5)
3
>>> tu1.index(5)
4

列表中还有list.reverse()与list.sort(),但是元组没有，但是要实现反转与排序可以使用python中的内置函数:reversed()，sorted()

>>> tu1
(1, 2, 3, 4, 5, 5, 5, 4)
>>> reversed(tu1)
<reversed object at 0x000001B9FE543C88>
>>> tuple(reversed(tu1))
(4, 5, 5, 5, 4, 3, 2, 1)

>>> tu = (1,2,3,5,4,3)
>>> sorted(tu)			# 升序
[1, 2, 3, 3, 4, 5]

len()/max()/min()/tuple()

元组中不允许的操作

不允许修改、新增元素

>>> tup = (1,2,3)
>>> tup[2] = 5
Traceback (most recent call last):
  File "<stdin>", line 1, in <module>
TypeError: 'tuple' object does not support item assignment

一旦想改变该元组,就只能重新开辟一块内存,创建新的元组

>>> tup = (1,2,3)
>>> new_tup = tup+(4,)
>>> new_tup
(1, 2, 3, 4)

注意：元组只保证它的一级子元素不可变，对于嵌套的元素内部，不保证不可变
如下：

>>> tup = (1,2,3,['amy',5])			# 将'amy'改为4
>>> tup[3][0] = 4
>>> tup
(1, 2, 3, [4, 5])

>>> tup1 = (1,2,3,('amy',5))		# 将'amy'改为4
>>> tup1[3][0] = 4
Traceback (most recent call last):
  File "<stdin>", line 1, in <module>
TypeError: 'tuple' object does not support item assignment

不允许删除某个元素（但可以删除整个元组）

实际上，所有会对元组内部元素发生修改动作的方法。例如，元组没有remove，append，pop等方法

列表和元组的转换

元组转为列表

>>> tu = (1,2,3)
>>> list(tu)
[1, 2, 3]

列表转为元组

>>> li = [1,2,3]
>>> tuple(li)
(1, 2, 3)

本文章为转载内容，我们尊重原作者对文章享有的著作权。如有内容错误或侵权问题，欢迎原作者联系我们进行内容更正或删除文章。

上一篇：已有docker服务设置自启动 docker自动启动

下一篇：centos8 编译r8125网卡驱动 linux编译网卡驱动ko

提问和评论都可以，用心的回复会被更多人看到评论

发布评论

相关文章

官方博客	全部文章	热门标签	班级博客
了解我们	网站地图	意见反馈

鸿蒙开发者社区	51CTO学堂
51CTO	软考资讯

python json 单引号 问题 python 单引号字符串

python json 单引号 问题 python 单引号字符串

字符串、列表和元组类型

1.字符串(str)类型

字符串

字符串的下标

字符串切片

字符串类型转换

字符串组成方式

字符串的常见操作

2.列表(list)类型

列表介绍

创建方式

访问列表内的元素

修改元素的值

删除元素

列表的特殊操作

列表的常用函数

排序和反转

切片(截取)

多维列表（嵌套列表）

列表的遍历

列表的内置方法

3.元组类型

元组介绍

元组(tuple)创建

元组与列表相同的操作

元组中不允许的操作

不允许修改、新增元素

不允许删除某个元素（但可以删除整个元组）

列表和元组的转换

元组转为列表

列表转为元组

51CTO博客

python json 单引号问题 python 单引号字符串

python json 单引号问题 python 单引号字符串