Python丨序列

熊猫_luoul

已于 2024-05-17 10:09:28 修改

阅读量245

点赞数 5

分类专栏： Python 文章标签： python 开发语言

于 2024-03-07 15:11:05 首次发布

本文链接：https://blog.csdn.net/qq_74315738/article/details/136531754

版权

Python 专栏收录该内容

6 篇文章 0 订阅

订阅专栏

上一周老师补充：

Random随机数

random.random()：用于生成一个0~1.0的随机浮点数

random.uniform(a,b)：用于生成指定范围内的随机浮点数

random.randint(a,b)：用于生成指定范围内的随机整数

求10个随机2位整数的程序，要求在一行内输出，以逗号隔开

import random

random_numbers = [random.randint(10, 99) for _ in range(10)]
print(','.join(str(num) for num in random_numbers))

第三章序列

注：红色标注部分为考试重点

1 序列概述

序列包括：字符串、列表、元组、字典、集合

按照有序和无序分为两类：字符串、列表、元组有序，字典和集合无序；

按照是否可变也分为两类：字符串和元组不可变，其余可变。

#字符串遍历
string='abcd'
for x in string:
   print(x,end=' ')

a b c d 

#列表遍历
arr=[1,2,3,4,5]
for x in arr:
   print(x,end='\t')

1	2	3	4	5

索引

索引分正向索引和反向索引。

正向索引号从0开始，0、1、2、3、...

反向缩影从-1开始，-1、-2、-3、...

切片

语法格式：序列[ start : end : step ]

start表示切片开始的位置，不输入时默认为0
end表示截止位置，默认为序列长度，访问元素不包括end上的元素
step表示切片的步长，默认为1

List[::]：返回整个序列
List[::2]：间隔1个取一个
string[2:5]：指定开始和结束位置
string[::-1]：返回原序列的逆序

重复

字符串、列表、元组序列可以自我复制，其语法格式如下：

sequence * n

其中，n为整数，表示复制的次数

>>> 'ASOUL' * 2   #字符串复制2次
'ASOULASOUL'

>>> ['Jan','Feb','Mar'] * 2    #列表复制2次
['Jan','Feb','Mar','Jan','Feb','Mar']

>>> (1,2,3) * 2    #元组复制2次
(1,2,3,1,2,3)

连接

两个同类型的有序序列通过“+”运算符进行连接，生成更长的新序列

>>> 'Hello' + ' ' + 'World'
'Hello World'

不同类型有序序列转换为相同类型后才能进行连接操作。

序列内置函数

序列类型转换内置函数：

函数	函数功能
list	将可迭代对象转换为列表
tuple	转换为元组
str	转换为字符串

>>> list('Hello')
['H','e','l','l','o']

>>>list(str([1,2,3]))
['[','1',',','2',',','3',']']

>>> Str2 = str(123456.780)
123456.78

最值和求和：max() / min() / sum()

函数max()和min()支持default参数和key参数：

其中default参数用来指定可迭代对象为空时默认返回的最大值或最小值；

key参数用来指定比较大小的依据或规则。

>>> print(max([],default=1))
1

排序：sorted()升序排列

>>> Lst = [3,1,2,4]
>>> sorted(Lst, key=str)
[1,2,3,4]

>>> x = reversed(Lst)
>>>list(x)
[4,2,1,3]

>>> lst=[6,0,1,7,4,3,2,8,5,10,9]
>>> sorted(lst,key=str)
[0, 1, 10, 2, 3, 4, 5, 6, 7, 8, 9]

reversed()函数产生的是一个迭代器，它的元素在遍历的过程中产生，每次产生一个元素，占用的内存空间少；而列表是一次性获得所有元素值，占用内存空间大。

枚举和迭代： enumerate()

>>> x = enumerate('abcd')
>>> list(x)
[(0,'a'),(1,'b'),(2,'c'),(3,'d')]

>>> for index, value in enumerate(range(1,6)):
    print((index, value), end=' ')
(0,1) (1,2) (2,3) (3,4) (4,5)

>>> x=enumerate('abcd')
>>> list(x)
[(0, 'a'), (1, 'b'), (2, 'c'), (3, 'd')]
>>> list(enumerate(['python','greate']))
[(0, 'python'), (1, 'greate')]

>>> list(enumerate({'a':97,'b':98,'c':99}.items()))
[(0, ('a', 97)), (1, ('b', 98)), (2, ('c', 99))]

zip()函数：

>>> list(zip('abcd',[1,2,3,4]))
[('a',1),('b',2),('c',3),('d',4)]

>>> x=zip('1234','abc')
>>> list(x)
[('1', 'a'), ('2', 'b'), ('3', 'c')]
//当作为参数的多个可迭代对象长度不同时，以最短的进行匹配。
>>> list(x)
[]

原因：使用list()函数遍历之后，生成了所有的元素，再次访问时为空。

2 字符串

aStr = 'What do you think of this saying"No Pain, No Gain"?'
lindex = aStr.index('\"', 0, len(aStr))
rindex = aStr.rindex('\"', 0, len(aStr))
tempStr = aStr[lindex+1:rindex]
if tempStr.istitle():
    print('It\'s title format')
else:
    print('It\'s not title format')

aList=['Mon.','Tues.','Wed.','Thur.','Fri.','Sat.','Sun.']
for i in range(len(aList)):
    print(aList[i],end='#')

输出结果：
Mon.#Tues.#Wed.#Thur.#Fri.#Sat.#Sun.#

注意若用range(7)则可以输出7个值，而用range(0,7)只有6个

转义字符

转义字符	说明	转义字符	说明
\0	空字符	\'	单引号
\n	换行	\"	双引号
\r	回车	\	续行符
\t	水平制表符	\000	3位八进制数
\\	\	\xhh	2位十六进制

为了避免对本应属于字符串内容的字符进行转义，可以在字符串前加上r或R表示原始字符串，则其中所有字符都表示其原始的含义而不会进行任何转义。

>>> path = r'C:\Windows\notepad.exe'
>>> print(path)
C:\Windows\notepad.exe

>>> Str6='''This is a long sentence.
And it's not over yet."hello"
Still here'''

>>> Str6
'This is a long sentence.\nAnd it\'s not over yet."hello"\nStill here'

>>> print(Str6)
This is a long sentence.
And it's not over yet."hello"
Still here

字符串格式化

{序号:[对齐说明符][符号说明符][最小宽度说明符][.精度说明符][类型说明符]}

>>> "{0} is a {1}.".format("Python", "language")
'Python is a language.'
>>> "{1} is a {0.}".format("Python", "language")
'language is a Python'

>>> x=12345
>>> "%8.2f" % x
12345.00

8.2f是字符串的格式，通过%连接要输出的表达式

import math
r=10
s=math.pi*r*r
l=2*math.pi*r
print('周长为',"%d"%l,'面积为',"%6.2f"%s)
周长为 62 面积为 314.16

#若改为"%8.2f"，则输出结果如下：
周长为 62 面积为   314.16

print("周长为{0}，面积为{1}。".format("%d"%l,"%6.2f"%s))
周长为62，面积为314.16。#没有空格

print("{1:=^6}\t{0:=^8}".format("周长","面积"))
print("{:^8}\t{:^10}".format("%6.2f"%s,"%d"%l))
==面积==	===周长===
 314.16 	    62

{:^10}表示居中对齐，占10个字符位置

{:=^10}表示居中对齐，占10个字符位置，左右两边填充"="字符

字符串常用方法

查找类方法

find()和rfind()方法分别用来查找一个字符串在另一个字符串指定范围内首次和最后一次出现的位置，若不存在则返回-1

index()和rindex()用来返回其位置，不存在则出错

count()用来返回一个字符串在另一个字符串中出现的次数

字符串拆分

split()和rsplit()方法分别用来以指定字符为分隔符，把当前字符串从左往右或从右往左分割成多个字符串，并返回包含分割结果的列表

partition()和rpartiotion()用来以指定字符串为分隔符将原字符串分割为三部分，即分隔符前的字符串、分割字符串以及分隔符后的字符串，如果指定的分隔符不在原字符串中，则分隔为原字符串和两个空字符串，并返回这三个元素的元组。

>>> 'a,,,bb,,ccc'.split(',')
['a', '', '', 'bb', '', 'ccc']

>>> s1='hello \tworld \n\n This is a sample'
>>> s1.split()
['hello', 'world', 'This', 'is', 'a', 'sample']
>>> s1
'hello \tworld \n\n This is a sample'
>>> print(s1)
hello 	world 

 This is a sample

对于split()和rsplit()方法：

如果不指定分隔符，则字符串中任意空白符号（空格、换行符、制表符）都将被认为是分隔符，且将连续多个空白字符看成一个。

也可以指定最大分隔次数，具体例子如下

s1='hello \tworld \n\n This is a sample'
s1.split(None,1)#不指定分隔符，最大分隔次数为1
['hello', 'world \n\n This is a sample']

s1.rsplit(None,2)#从右向左分隔
['hello \tworld \n\n This is', 'a', 'sample']

s1.split(maxsplit=6)
['hello', 'world', 'This', 'is', 'a', 'sample']

字符串连接

join()将元素按指定连接符连接起来，形成一个新字符串

fruit=["apple","peach","banana","pear"]
','.join(fruit)
'apple,peach,banana,pear'

字符串大小写

lower()：返回小写字符串

upper()：大写

capitalize()：字符串首字符大写

title()：所有单词首字母大写

swapcase()：大小写交换

字符串替换

>>> s='name, name'
>>> print(s)
name, name
>>> s2=s.replace('name','姓名')
>>> print(s2)
姓名, 姓名

删除空白或指定字符

strip()：删除字符串首尾空白字符或指定字符

rstrip()：只删除右侧

lstrip()：只删除左侧

Str="  aaaTheOrphanOfZhaoaaa "
Str.strip()
'aaaTheOrphanOfZhaoaaa'

Str.strip('a')
'  aaaTheOrphanOfZhaoaaa '#删不掉a因为首尾都是空白字符

Str.lstrip('a ')
'TheOrphanOfZhaoaaa '

Str.rstrip('a o')
'  aaaTheOrphanOfZh'

判断开始、结束字符串

startswith()/endswith()

>>> string="To be or not to be, that's a question"
>>> string.startswith('To')
True

>>> string.startswith('be', 3, 6)#从指定检测范围开始到结束位置6
True

>>> string.endswith('be', 2, 5)
True

>>> string.endswith('be', 2, 8)
False

判断数字、字母、大小写

isalnum()：测试字符串是否为字母或数字

isalpha()：测试字符串是否为字母

isdigit()：测试字符串是否为数字字符

isspace()：是否为空白字符

isupper()：是否为大写字符

islower()：是否为小写字符

注意：
>>> '123.0'.isdigit()
False

字符串对齐

center()：返回指定宽度的新字符串，原字符串居中，可使用指定字符对空白部分进行填充（默认为空格）

ljust()：左对齐

rjust()：右对齐

>>> Str="#musical FanLetter"
>>> Str.center(30,'-')
'------#musical FanLetter------'

>>> Str.rjust(25,'>')
'>>>>>>>#musical FanLetter'

3 列表

列表所有元素放在一对方括号[ ]中，用逗号隔开。同一个列表的数据类型可以不同。

列表创建及修改

>>> List=['Python',9.11,1,[23,39]]
>>> len(List)
4

>>> len(List[3])
2

列表还可以通过解析式生成：

>>> List=[x*x for x in range(5)]
>>> List
[0, 1, 4, 9, 16]

列表元素可以修改：

>>> List=['hello',[23,39]]
>>> List[1][0]=27
>>> List
['hello', [27, 39]]

注：但是如果列表元素中存在元组则该元素不能修改。

列表可以通过copy()方法进行拷贝，但拷贝的列表与原列表不属于同一个存储空间，不为同一个对象，拷贝的对象被修改时，原列表的直接元素不会受到影响，但其包含的列表也会被修改，如下：

>>> List=["zsge",[23,39],1]
>>> aList=List.copy()
>>> aList[1][0]=27
>>> List
['zsge', [27, 39], 1]

若导入copy模块的deepcopy()函数，则List不会被改变

列表元素的增加、删除

列表元素增加

append.()：向列表尾部追加一个元素
extend()：用于将另一个列表中的所有元素追加至当前列表的尾部
insert()：向列表任意位置插入元素

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

>>> Lst.insert(2,3.5)
>>> Lst
[1, 2, 3.5, 3, 4]

>>> Lst.append([5])
>>> Lst
[1, 2, 3.5, 3, 4, [5]]

>>> Lst.extend([6,7])
>>> Lst
[1, 2, 3.5, 3, 4, [5], 6, 7]

>>> Lst1=[1,2,3]
>>> Lst1.append('python')
>>> Lst1.extend('hello')
>>> Lst1
[1, 2, 3, 'python', 'h', 'e', 'l', 'l', 'o']

列表元素删除

pop()：删除并返回指定位置上的元素
remove()：删除列表中第一个与指定值相同的元素
del 命令：删除指定位置的元素

>>> List=[1,9,9,6,1,2,1,1]

>>> List.pop(5)#删除并返回第五个元素
2

>>> List.pop()#删除并返回最后一个元素
1
>>> List
[1, 9, 9, 6, 1, 1]

>>> List.remove(1)#删除第一个为1的元素
>>> List
[9, 9, 6, 1, 1]

>>> del List[2]#del命令删除第2个元素
>>> List
[9, 9, 1, 1]

>>> lst3=[1,2,3,4,5,6,7,8]
>>> lst3[len(lst3):]=[9]#在末尾增加元素
>>> lst3
[1, 2, 3, 4, 5, 6, 7, 8, 9]

>>> lst3[:0]=[-1,0]#在头部增加元素
>>> lst3
[-1, 0, 1, 2, 3, 4, 5, 6, 7, 8, 9]

>>> lst3[:2]=[]#删除前两个元素
>>> lst3
[1, 2, 3, 4, 5, 6, 7, 8, 9]

>>> lst3[2:]=[3.5]#覆盖之前的元素
>>> lst3
[1, 2, 3.5]

列表元素的访问与计数

count()：用于返回列表中指定元素出现的次数，若不存在则返回0

index()：返回指定元素在列表中首次出现的元素，若元素不在列表中则出错

aList.index(1,6,9)：元素1在列表aList中自索引号6~9范围中出现的索引

列表排序

sort()：用于按照指定的规则对所有元素进行排序

reverse()：用于将列表所有元素进行逆序

>>> aList=[6,0,1,7,4,3,2,8,5,10,9]
>>> aList.sort()
>>> aList
[0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10]
>>> aList.sort(key=str)
>>> aList
[0, 1, 10, 2, 3, 4, 5, 6, 7, 8, 9]
>>> aList.sort(key=str,reverse=True)
>>> aList
[9, 8, 7, 6, 5, 4, 3, 2, 10, 1, 0]

>>> List1=['ChengYin','ChengBo','ChengZi']
>>> List1.reverse()
>>> List1
['ChengZi', 'ChengBo', 'ChengYin']

sorted()、reversed()函数是序列的内置函数，返回一个新的序列；而sort()、reverse()方法是列表的方法，它对原列表进行更新。

因此字符串和元组是不可变序列，只有sorted()函数，没有sort()方法。

>>> aTuple=(1,4,7,3,8)
>>> aTuple=sorted(aTuple)
>>> aTuple
[1, 3, 4, 7, 8]

>>> aTuple=(1,4,7,3,8)
>>> tuple2=aTuple.sort()
Traceback (most recent call last):
  File "<pyshell#21>", line 1, in <module>
    tuple2=aTuple.sort()
AttributeError: 'tuple' object has no attribute 'sort'

注意：

key=lambda item:(len(str(item)),item)：先按照字符串长度排序，再按照大小排序

如果只有一个参数，则其他默认不变

4 元组

元组不可排序，但可用sorted()函数生成排序之后的列表。

元组的创建

>>> tup1=(1,2,3)
>>> type(tup1)
<class 'tuple'>

当元组只有一个元素时需要在该元素后面添加逗号，否则圆括号被当作运算符：

>>> tup2=(1,)
>>> type(tup2)
<class 'tuple'>
>>> tup3=(1)
>>> type(tup3)
<class 'int'>

元组的元素可以是不同的数据类型。

元组的特性

元组的元素值不可变，但元组中包含的可变元素可以变，如一个元组元素是列表，则字典的值可以改变。其他地方和列表差不多。

>>> aTuple=(1,2,3)
>>> tu2=aTuple+(4,)
>>> tu2
(1, 2, 3, 4)

>>> names=('weilan','xiaoliu','Gabe')
>>> scores=(100,99,98)
>>> print(scores[names.index('Gabe')])
98

5 字典

字典创建

字典中的键不可以重复，但值可以。

字典中元素的“键”可以是整数、实数、复数、字符串、元组，但不能是列表、集合、字典或其他可变类型。

#用赋值语句创建
>>> aDict={'name':'XGuang','age':19}
>>> aDict
{'name': 'XGuang', 'age': 19}
>>> aDict={}
>>> aDict
{}

#以关键参数的形式创建字典
>>> aDict=dict(name='夏光',age=19)
>>> aDict
{'name': '夏光', 'age': 19}

>>> Dict1=dict([('夏光',19),('微岚',18),('海鸣',28)])
>>> Dict1
{'夏光': 19, '微岚': 18, '海鸣': 28}

>>> Dict2=dict((('夏光',19),('微岚',18),('海鸣',28)))
>>> Dict2
{'夏光': 19, '微岚': 18, '海鸣': 28}

>>> Dict3=dict(夏光=19,微岚=18,海鸣=28)
>>> Dict3
{'夏光': 19, '微岚': 18, '海鸣': 28}

#根据已有数据创建字典
>>> keys=['a','b','c']
>>> values=[1,2,3]
>>> Dict4=dict(zip(keys,values))
>>> Dict4
{'a': 1, 'b': 2, 'c': 3}

使用fromkeys()可以创建一个所有键值都相等的字典：

>>> Dict5={}.fromkeys(['a','b','c'],200)
>>> Dict5
{'a': 200, 'b': 200, 'c': 200}

字典元素访问

字典中每个元素表示一种映射关系或对应关系，根据提供的“键”作为下标可以访问对应的值，若字典中不存在这个“键”则会出错。

>>> aDict={'程':1,'赵':2,'屠':3}
>>> aDict['赵']
2

用get()也可以返回指定键对应的值，且不存在时不报错。

>>> aDict.get('程')
1

import random
x='abcdefghijklmnopqrstuvwsyz'
y=[random.choice(x) for i in range(100)]
z=''.join(y)
d=dict()
#遍历y字符串中所有字母，若字典中不存在该键则增添，并将值赋为1；存在则将值+1
for ch in z:
    d[ch]=d.get(ch,0)+1

aList=list(d.items())
for x in sorted(aList):
    print(x)

注意：d.get(ch,0)不能直接添加键值对，要用d[ch]=d.get(ch,0)才可以。

values()/keys()用来返回字典的值/键，items()返回键值对。

>>> aDict.keys()
dict_keys(['程', '赵', '屠'])
>>> aDict.values()
dict_values([1, 2, 3])
>>> aDict.items()
dict_items([('程', 1), ('赵', 2), ('屠', 3)])

>>> type(aDict.keys())
<class 'dict_keys'>

>>> for x,y in aDict.items():
	print(x,y)

	
程 1
赵 2
屠 3

字典元素添加与修改

#修改元素
>>> aDict['程']=2
>>> aDict
{'程': 2, '赵': 2, '屠': 3}

#添加新元素
>>> Dict2={'郑':6,'徐':7}
>>> aDict.update(Dict2)
>>> aDict
{'程': 2, '赵': 2, '屠': 3, '郑': 6, '徐': 7}

使用setdefault()，若键存在则返回对应值，若不存在则增加键值对，值赋为None或设置的默认值：

>>> aDict.setdefault('郑')#键存在，返回其值
6

>>> aDict.setdefault('何')#键不存在，增加键值对，赋值为None
>>> aDict
{'程': 2, '赵': 2, '屠': 3, '郑': 6, '徐': 7, '何': None}

>>> aDict.setdefault('方',8)#增加键值对，值为给定值
8
>>> aDict
{'程': 2, '赵': 2, '屠': 3, '郑': 6, '徐': 7, '何': None, '方': 8}

>>> aDict.setdefault('徐',9)#键已经存在，不修改其值
7

del命令可以删去指定元素，用clear()方法可以删除字典所有元素

用pop()方法删除指定元素并返回其值，使用时用aDict.pop('aKey',None)，则就算该键不存在也不会报错，增强程序健壮性。

6 集合

集合的创建

创建集合时重复元素只会保留一个

>>> set1=(1,2,3)#直接创建

>>> set2=set('hello!')#使用set()转换
>>> set2
{'l', '!', 'e', 'o', 'h'}

如果原来的数据有不可散列的值则无法转换为集合，如以下情况报错：

aList=[[1,2],[3,4]]

aSet=set(aList)

使用frozenset()函数创建不可变集合：

>>> fSet=frozenset('Next to Normal')
>>> fSet
frozenset({'x', 'r', 'N', 'l', 'e', 'o', 't', 'a', 'm', ' '})
>>> type(fSet)
<class 'frozenset'>

集合操作

集合元素的增加

add()：添加新元素，若该元素已存在则忽略，不会报错

update()：合并另一个集合中的元素并自动去除重复元素

>>> s1={'a','b','c'}
>>> s1.add('d')
>>> s1
{'b', 'd', 'c', 'a'}
>>> s1.update('a','e')
>>> s1
{'c', 'd', 'a', 'b', 'e'}

集合元素的删除

remove()：若指定元素不存在，则出错

discard()：若不存在则忽略该操作

pop()：随机删除并返回一个元素，若集合为空则报错

clear()：清除所有元素

>>> s1.discard('e')
>>> s1
{'c', 'd', 'a', 'b'}
>>> s1.remove('d')
>>> s1
{'c', 'a', 'b'}
>>> s1.pop()
'c'
>>> s1.clear()
>>> s1
set()

集合运算

集合的运算包括交集、并集、差集。

用运算符表达式进行运算：

>>> s1={1,2,3,4,5}
>>> s2={3,4,5,6,7}

>>> s1|s2              #并集
{1, 2, 3, 4, 5, 6, 7}
>>> s1&s2              #交集
{3, 4, 5}
>>> s1-s2              #差集
{1, 2}
>>> s1^s2              #对称差集
{1, 2, 6, 7}

用集合方法实现：

>>> s1.union(s2)
{1, 2, 3, 4, 5, 6, 7}
>>> s1.intersection(s2)
{3, 4, 5}
>>> s1.difference(s2)
{1, 2}
>>> s1.symmetric_difference(s2)
{1, 2, 6, 7}

关系运算

>>> s1<s2
False

实验思考题

1、编写程序，实现输入任意字符串，按ASCII码从小到大顺序输出，如输入edabg，输出abdeg。

string = (input("请输入一串字母："))
print( ''.join(sorted(string)))

2、编写程序，随机生成20个整数，保存在列表L1中，输出列表，并输出其最大值、最小值、平均值。

import random
L1 = [random.randint(1,100) for i in range (20)]
print(L1)
print("max:",max(L1),"\nmin:",min(L1),"\naverage:",sum(L1)/20)

3、已知pList = [('AXP','American Express Company','78.51'),('BA','The Boeing Company','184.76'),('CAT','Caterpillar Inc','96.39'),('CSC0','Cisco Systems, Inc','33.71'),('CVX','Chevron Corporation','106.09')]为公司股票市值，其中包括公司简称、公司名称和股票市值、编写程序输出公司简称及股票市值。

pList = [('AXP','American Express Company','78.51'),
         ('BA','The Boeing Company','184.76'),
         ('CAT','Caterpillar Inc','96.39'),
         ('CSC0','Cisco Systems, Inc','33.71'),
         ('CVX','Chevron Corporation','106.09')]
for item in pList:
    print(f"公司简称：{item[0]}，股票市值：{item[2]}")

字典没有排序方法，所以若要按字母顺序输出可以将其用items()方法解包为键值对，再用sorted()函数排序：

>>> pList = [('AXP','American Express Company','78.51'),
         ('BA','The Boeing Company','184.76'),
         ('CAT','Caterpillar Inc','96.39'),
         ('CSC0','Cisco Systems, Inc','33.71'),
         ('CVX','Chevron Corporation','106.09')]
>>> List_name=[]
>>> List_value=[]
>>> for x in pList:
	List_name.append(x[0])
	List_value.append(x[2])

	
>>> aDict=dict(zip(List_name,List_value))
>>> for i,j in sorted(aDict。items()):
	print(i,':',j)
	
AXP : 78.51
BA : 184.76
CAT : 96.39
CSC0 : 33.71
CVX : 106.09

4、编写一个求解s1 $(s1=1+\frac{1}{2}+\frac{1}{3}+...+\frac{1}{m})$ 的值的程序，要求使用input()函数输入m的值，输出s1的值。

m = int(input("请输入m的值："))
sum = 0
for i in range(1,m+1):
    sum += 1/i
print(sum)