python编程练习

CinzWS

已于 2022-06-01 09:19:56 修改

阅读量1.9k

点赞数

分类专栏： python学习文章标签： python 算法

于 2021-12-19 15:46:49 首次发布

本文链接：https://blog.csdn.net/qq_37619128/article/details/122024283

版权

python学习专栏收录该内容

5 篇文章 2 订阅

订阅专栏

python编程练习（二）

本文所有题目均出自

python3菜鸟教程

仅作为自己练习python编程使用。

1、Python 计算 n 个自然数的立方和

def sumOfSeries(n):
    sum=0
    for i in range(1,n+1):
        sum += i*i*i
    return sum

def main():
    
    # 请输入一个正整数
    n=int(input("请输入一个正整数"))
    
    # 计算n个自然数的立方和
    Sum=sumOfSeries(n)
    
    # 打印输出结果
    print('{0}个自然数的立方和为{1}'.format(n,Sum))
    
if __name__=='__main__':
    main()

输出

请输入一个正整数5
5个自然数的立方和为225

2、Python 计算数组元素之和

定义一个整型数组，并计算元素之和。

# 计算元素之和
def SumArr(arr):
    sum=0
    for _,j in enumerate(arr):
        #print(j)
        sum += j
        
    return sum

def main():
    
    # 定义一个数组
    arr=[12,13,14,15,16,17,18,19]
    
    # 计算元素之和
    Sum=SumArr(arr)
    
    # 打印结果
    print('sum={}'.format(Sum))
    

if __name__=='__main__':
    main()

输出

sum=124

3、Python 数组翻转指定个数的元素

在这里插入图片描述

def Rotate(arr,d,n):
    """
    将长度为 n 的 数组 arr 的前面 d 个元素翻转到数组尾部。
    
    """
    for i in range(d):
        temp=arr[0]
        for i in range(n-1):
            arr[i]=arr[i+1]
        arr[n-1]=temp
        
def printArray(arr,size):
    for i in range(size):
        print ("%d"% arr[i],end=" ")    

def main():
    
    # 定义一个数组
    arr=[12,13,14,15,16,17,18,19]
    
    # 指定翻转个数的元素
    Rotate(arr, 2, len(arr))
    
    
    printArray(arr, len(arr))
    
if __name__=='__main__':
    main()

输出

14 15 16 17 18 19 12 13

4、Python 将列表中的头尾两个元素对调

def SwapList(NewList):
    """
    元素对调
    """
    NewList[0],NewList[-1]=NewList[-1],NewList[0]
    
    return NewList

def main():
    
    # 定义一个数组
    list=[1,2,3,4]
    
    # 元素对调
    NewList=SwapList(list)
    
    # 打印元素
    print('对调后的数组为：{}'.format(NewList))

if __name__=='__main__':
    main()

输出

对调后的数组为：[4, 2, 3, 1]

5、Python 将列表中的指定位置的两个元素对调

定义一个列表，并将列表中的指定位置的两个元素对调。

def SwapPosition(NumList,num1,num2):
    """
    元素对调
    """
    NumList[num1],NumList[num2]=NumList[num2],NumList[num1]
    
    return NumList

    
    
def main():
    
    # 请输入一串数组
    arr=input('请输入数组，每个数以空格分割:')
    NumList=[int(n) for n in arr.split()]
    
    # 请输入要对调的位置
    print('请输入要对调的位置,从1开始，注意最大不能大于{}'.format(len(NumList)))
    num1=int(input('请输入第一个位置:'))-1
    num2=int(input('请输入第二个位置:'))-1
    
    #对调元素
    SwapList=SwapPosition(NumList,num1,num2)
    
    # 打印对调后的数组
    print(SwapList)
    
    
if __name__=="__main__":
    main()

输出

请输入数组，每个数以空格分割:23 65 19 90
请输入要对调的位置,从1开始，注意最大不能大于4
请输入第一个位置:1
请输入第二个位置:3
[19, 65, 23, 90]

6、Python 翻转列表

定义一个列表，并将它翻转。

def Reverse(NumList):
    """
    翻转列表
    """
    NumList.reverse()
    
    return NumList
    
    

def main():
    
    # 定义一个数组
    num=input('请输入一个列表，注意每个元素以空格分开')
    numList=[int(n) for n in num.split()]
    
    # 翻转列表
    ReList=Reverse(numList)
    
    # 打印输出
    print('翻转后的列表\r\n {}'.format(ReList))
    
if __name__=="__main__":
    main()

输出

请输入一个列表，注意每个元素以空格分开1 2 3 4 5 6
翻转后的列表
 [6, 5, 4, 3, 2, 1]

7、Python 复制列表

定义一个列表，并将该列表元素复制到另外一个列表上。

def CopyList(numList):
    
    #方法一：
    #copy_list=[]
    #copy_list.extend(numList)
    
    # 方法二：
    # copy_list=numList[:]
    
    # 方法三：
    copy_list=list(numList)
    
    return copy_list
    

def main():
    
    # 定义一个列表
    num=input('请输入一个列表，注意每个元素以空格分开')
    NumList=[int(n) for n in num.split()]
    
    # 复制列表
    copy_list=CopyList(NumList)
    
    # 打印输出
    print('复制后的列表{}'.format(copy_list))

    
    
if __name__=='__main__':
    main()

输出

请输入一个列表，注意每个元素以空格分开1 2 3 4 5
复制后的列表[1, 2, 3, 4, 5]

8、Python 计算元素在列表中出现的次数

定义一个列表，并计算某个元素在列表中出现的次数。

def CountNum(NumList,x):
    """
    统计x在NumList中出现的次数
    """
    # NumList.conut(x)
    count=0
    for i in NumList:
        if (i==x):
            count += 1
    return count
    

def main():
    
    # 定义一个列表
    num=input('请输入一个列表，注意每个元素以空格分开:')
    Numlist=[int(n) for n in num.split()]
    
    # 统计元素在列表中出现的次数
    x=int(input('请输入要查找的元素:'))

    # 统计次数
    n=CountNum(Numlist,x)
    if n==0:
        print('列表中无该元素')
    else:
        # 打印输出
        print('{0}在{1}中\r\n出现的次数为:{2}'.format(x,Numlist,n))
        
    
if __name__=='__main__':
    main()

输出

请输入一个列表，注意每个元素以空格分开:1 2 3 1 2 3
请输入要查找的元素:4
列表中无该元素

9、Python 计算列表元素之和

定义一个数字列表，并计算列表元素之和。

def CountSum(NumList):
    """
    计算列表元素之和
    """
    sum=0
    for i in NumList:
        sum += i
    return sum

def main():
    # 输入列表
    list=input('请输入列表，注意每个元素以空格分开')
    NumList=[int(n) for n in list.split()]
    
    # 计算列表元素之和
    NumSum=CountSum(NumList)
    
    # 打印结果
    print(f'列表元素和为{NumSum}')
    
if __name__=='__main__':
    main()

输出

请输入列表，注意每个元素以空格分开12 15 3 10
列表元素和为40

10、Python 计算列表元素之积

定义一个数字列表，并计算列表元素之积。

def MultiplyList(NumList):
    result=1
    for i in NumList:
        result *= i
    return result

def main():
    # 输入列表
    num=input('请输入列表，注意每个元素以空格分开')
    NumList=[int(i) for i in num.split()]
    
    # 计算结果
    result=MultiplyList(NumList)
    
    # 打印输出
    print(f'列表乘积为{result}')
    
if __name__=='__main__':
    main()

输出

请输入列表，注意每个元素以空格分开1 2 3 4
列表乘积为24

11、Python 查找列表中最小元素

定义一个数字列表，并查找列表中的最小元素。

def ListMin(Numlist):
    """
    找出最小元素
    """
    min=Numlist[0]
    
    for i in Numlist:
        if i<min:
            min=i
    return min

def main():
    
    # 输入列表
    num=input('请输入列表，注意每个元素以空格分开：')
    NumList=[int(n) for n in num.split()]
    
    # 找出最小元素
    MinNum=ListMin(NumList)
    
    # 打印输出
    print(f'最小元素为{MinNum}')
    
if __name__=='__main__':
    main()

输出

请输入列表，注意每个元素以空格分开：1 2 3 4 5 6 1 -1
最小元素为-1

12、Python 查找列表中最大元素

定义一个数字列表，并查找列表中的最大元素。

def ListMax(Numlist):
    """
    找出最大元素
    """
    max=Numlist[0]
    
    for i in Numlist:
        if i>max:
            max=i
    return max

def main():
    
    # 输入列表
    num=input('请输入列表，注意每个元素以空格分开：')
    NumList=[int(n) for n in num.split()]
    
    # 找出最大元素
    MaxNum=ListMax(NumList)
    
    # 打印输出
    print(f'最大元素为{MaxNum}')
    
if __name__=='__main__':
    main()

输出

请输入列表，注意每个元素以空格分开：10 20 4
最小元素为20

13、Python 移除字符串中的指定位置字符

给定一个字符串，然后移除指定位置的字符。

def RemoveString(str,num):
    return str[:num]+str[num+1:]

def main():
    
    #  输入字符串
    str=input('请输入字符串')
    
    # 输入要移除的位置
    n=int(input('请输入要移除的位置,注意从'))
    
    # 移除指定字符串
    ReStr=RemoveString(str,n)
    
    # 打印输出
    print('输入的字符串为{0}\r\n输出的字符串为{1}'.format(str,ReStr))
    
if __name__=='__main__':
    main()

输出

请输入字符串swqwref
请输入要移除的位置2
输入的字符串为swqwref
输出的字符串为swwref

14、Python 判断字符串是否存在子字符串

给定一个字符串，然后判断指定的子字符串是否存在于该字符串中。

def check(str,sub_str):
    """
    判断字符串是否存在子字符串
    """
    if sub_str in str:
        return True
    else:
        return False
    
def main():
    
    # 输入字符串
    str=input('请输入字符串：')
    
    # 输入子字符串
    sub_str=input('输入子字符串：')
    
    # 判断是否存在
    if check(str,sub_str):
        print(f'存在子字符串')
    else:
        print(f'不存在子字符串')

if __name__=='__main__':
    main()

输出

请输入字符串：qazwsxedc
输入子字符串：edc
存在子字符串

15、Python 将字符串作为代码执行

给定一个字符串代码，然后使用 exec() 来执行字符串代码。

def sum_add_code():
    SUM="""
def sum_add(list_num):
    sum=0
    for i in list_num:
        sum +=int(i)
    return sum
    
print(sum_add([1,2,3,4]))
    
    """
    exec(SUM)

sum_add_code()

输出

16、Python 对字符串切片及翻转

给定一个字符串，从头部或尾部截取指定数量的字符串，然后将其翻转拼接。

def rotate(input,d):
    
    Lfirst=input[0:d]
    Lsecond=input[d:]
    Rfirst=input[0:len(input)-d]
    Rsecond=input[len(input)-d:]
    
    print('头部切片翻转：',(Lsecond+Lfirst))
    print('尾部切片翻转：',(Rsecond+Rfirst))
    
if __name__=='__main__':
    input='csdn soft'
    d=2 # 截取两个字符
    rotate(input,d)

输出

头部切片翻转： dn softcs
尾部切片翻转： ftcsdn so

17、Python 按键(key)对字典进行排序

def dictionairy():
    
    # 声明字典
    key_value={}
    
    # 初始化
    key_value[2] = 10
    key_value[1] = 2 
    key_value[5] = 12 
    key_value[4] = 24
    key_value[6] = 18      
    key_value[3] = 323
    
    print('按键(key)排序：')
    
    # sorted(key_value)返回重新排序的列表
    # 字典按键排序
    for i in sorted(key_value):
        print((i,key_value[i]),end=' ')
        
def main():
    # 调用函数
    dictionairy()
    
# 主函数
if __name__=="__main__":
    main()

输出

按键(key)排序：
(1, 2) (2, 10) (3, 323) (4, 24) (5, 12) (6, 18)

18、Python 按值(value)对字典进行排序

def dictionairy():
    
    # 声明字典
    key_value={}
    
    # 初始化
    key_value[2] = 10
    key_value[1] = 2 
    key_value[5] = 12 
    key_value[4] = 24
    key_value[6] = 18      
    key_value[3] = 323
    
    print('按键(value)排序：')
    print(sorted(key_value.items(),key=lambda kv:(kv[1],kv[0])))
    """
    sorted(d.items(), key=lambda x: x[1]) 中 d.items() 为待排序的对象；
    key=lambda x: x[1] 为对前面的对象中的第二维数据（即value）的值进行排序。
    key=lambda 变量：变量[维数] 。维数可以按照自己的需要进行设置。
    """
    
def main():
    dictionairy()

if __name__=="__main__":
    main()

输出

按键(value)排序：
[(1, 2), (2, 10), (5, 12), (6, 18), (4, 24), (3, 323)]

19、Python 按字典列表进行排序

lis = [{ "name" : "Taobao", "age" : 100},  
{ "name" : "csdn", "age" : 7 }, 
{ "name" : "Google", "age" : 100 }, 
{ "name" : "Wiki" , "age" : 200 }] 

# 通过age升序排序
print("列表通过age升序排序：")
print(sorted(lis,key=lambda x:x['age']))

print('\r\n')

# 先按age排序，再按name排序
print('列表通过age和name排序：')
print(sorted(lis,key=lambda x:(x['age'],['name'])))

print('\r\n')

# 按age降序排序
print('列表通过age降序排序：')
print(sorted(lis,key=lambda x:x['age'],reverse=True))

输出

列表通过age升序排序：
[{'name': 'csdn', 'age': 7}, {'name': 'Taobao', 'age': 100}, {'name': 'Google', 'age': 100}, {'name': 'Wiki', 'age': 200}]


列表通过age和name排序：
[{'name': 'csdn', 'age': 7}, {'name': 'Taobao', 'age': 100}, {'name': 'Google', 'age': 100}, {'name': 'Wiki', 'age': 200}]


列表通过age降序排序：
[{'name': 'Wiki', 'age': 200}, {'name': 'Taobao', 'age': 100}, {'name': 'Google', 'age': 100}, {'name': 'csdn', 'age': 7}]

20、Python 计算字典值之和

给定一个字典，然后计算它们所有数字值的和。

def SumDict(myDict):
    """
    求字典值之和
    """
    sum=0
    for _,j in myDict.items():
        sum += j
    return sum

def main():
    
    # 创建一个字典
    dict={'a':100,'b':200,'c':300}
    
    # 求和
    sum=SumDict(dict)
    
    # 打印输出
    print('sum={}'.format(sum))
    
if __name__=='__main__':
    main()

输出

sum=600

21、Python 移除字典点键值(key/value)对

给定一个字典， 移除字典点键值(key/value)对

def RemoveDict(myDict,remove_str):
    
    # 方法1.del
    # del myDict[remove_str]
    # NewDict=myDict
    
    # 方法2.pop()
    myDict.pop(remove_str)
    NewDict=myDict
    
    # 方法3.items()
    NewDict = {key:val for key, val in myDict.items() if key !=remove_str }
    
    return NewDict

def main():
    
    # 创建一个字典
    test_dict = {"csdn" : 1, "Google" : 2, "Taobao" : 3, "Zhihu" : 4}
    
    # 输入要移除的键值对
    remove_str='Zhihu'
    
    # 打印原始字典
    print('原始字典：\r\n'+str(test_dict))
    
    # 移除后新字典
    new_dict=RemoveDict(test_dict,remove_str)
    
    # 打印输出
    print('新字典:\r\n'+str(new_dict))
    
if __name__=="__main__":
    main()

输出

原始字典：
{'csdn': 1, 'Google': 2, 'Taobao': 3, 'Zhihu': 4}
新字典:
{'csdn': 1, 'Google': 2, 'Taobao': 3}

CinzWS

关注

0
点赞
踩
11

收藏

觉得还不错? 一键收藏
打赏
0
评论
python编程练习

python编程练习（二）本文所有题目均出自python3菜鸟教程，题目链接见：(https://www.runoob.com/python3/python3-examples.html)仅作为自己练习python编程使用。1、Python 计算 n 个自然数的立方和def sumOfSeries(n): sum=0 for i in range(1,n+1): sum += i*i*i return sumdef main(): #
复制链接

扫一扫