devbox
从前慢现在也慢
这个屌丝很懒，什么也没留下！
关注作者
热门标签
热门文章
当前位置:   article > 正文

牛客在线编程 Python入门篇_牛客网在线编程

作者：从前慢现在也慢 | 2024-04-09 19:27:10

赞

踩

牛客网在线编程

牛客网在线编程_Python篇_python入门icon-default.png?t=N7T8https://www.nowcoder.com/exam/oj?page=1&tab=Python%E7%AF%87&topicId=314

目录

01 输入输出

02 类型转换

03 字符串

04 列表

05 运算符

06 条件语句

07 循环语句 NP49-NP61

08 元组 NP62-66

09 字典 NP67-75

010 内置函数 NP76 - NP93

011 面向对象 NP94 - NP100

012 正则表达式 NP101 - NP103

01 输入输出

Python输入输出

NP1.Hello World!

  1. # 定义变量str并赋值为'Hello World!'  
  2. str = 'Hello World!'  
  3.   
  4. # 使用print语句打印str的值  
  5. print(str)

NP2.多行输出

  1. # 定义变量str1并赋值为'Hello World!'  
  2. str1 = 'Hello World!'    
  3.  
  4. # 定义变量str2并赋值为'Hello Nowcoder!'  
  5. str2 = 'Hello Nowcoder!'  
  6.   
  7. # 使用print语句打印str1的值  
  8. print(str1)  
  9.   
  10. # 使用print语句打印str2的值  
  11. print(str2)

NP3.读入字符串

  1. # 使用input函数读取输入  
  2. input_string = input()  
  3.   
  4. # 输出读取的字符串  
  5. print(input_string)

NP4.读入整数数字

  1. num = int(input())
  2. print(num,type(num),sep='\n')

NP5.格式化输出

  1. # 获取输入的名字 
  2. name = input()   
  3.  
  4. # 输出对应的英文句子
  5. print("I am " + name + " and I am studying Python in Nowcoder!")

NP6.牛牛的小数输出

  1. # 读入浮点数
  2. num = float(input())  
  3.  
  4. # 保留两位小数输出
  5. print("{:.2f}".format(num))

02 类型转换

Python基本数据类型

NP7 小数化整数

  1. number = float(input()) 
  2. print(int(number))

NP8 为整数增加小数点

  1. num=int(input())
  2. print(float(num),type(float(num)),sep='\n')

NP9 十六进制数字的大小

  1. 解一：
  2. num=input() 
  3. num=int(num,16) 
  4. print(num)
  5.  
  6. 解二：
  7. num=input()
  8. print(int(num,16))
  9.  
  10. 解三：
  11. # 输入十六进制数字  
  12. hex_number = input("请输入一个十六进制数字：")  
  13.   
  14. # 将十六进制数字转换为十进制  
  15. decimal_number = int(hex_number, 16)  
  16.   
  17. # 输出十进制数字  
  18. print("该十六进制数字的十进制表示为：", decimal_number)

03 字符串

Python基本数据类型字符串

NP10 牛牛最好的朋友们

  1. # 通过input()函数接收用户输入的字符串，该函数默认返回字符串类型，赋值给变量a  
  2. a = input()   
  3.   
  4. # 同样通过input()函数接收用户输入的另一个字符串，赋值给变量b  
  5. b = input()   
  6.   
  7. # 使用print()函数和"".join()方法将a和b两个字符串连接起来，"".join([a, b])表示将列表[a, b]中的每个元素连接成一个字符串  
  8. print("".join([a,b]))
  9.  
  10. 或  
  11. str1 = input()  
  12. str2 = input()  
  13. result = str1 + str2 
  14. print(result)

NP11 单词的长度

print(len(input())

NP12 格式化输出（二）

  1. name=input()
  2. print(name.lower(),name.upper(),name.title(),sep='\n')

NP13 格式化输出（三）

  1. # 从标准输入（通常是键盘）读取用户输入，并将输入的内容赋值给变量name  
  2. name = input()  
  3.   
  4. # 使用strip()函数去除name变量值的两侧的空白字符（包括空格、制表符、换行符等），并将处理后的结果打印出来  
  5. print(name.strip())
  6.  
  7. 或：
  8. name = input().strip()
  9. print(name)

NP14 不用循环语句的重复输出

print(input()*100)

NP15 截取用户名前10位

  1. s = input()
  2. print(s[0:10])

04 列表

Python组合数据类型列表

NP16 发送offer

  1. offer_list = ['Allen','Tom']
  2. for i in offer_list:
  3.     print(i + ', you have passed our interview and will soon become a member of our company.')
  4. offer_list.remove('Tom')
  5. offer_list.append('Andy')
  6. for j in offer_list:
  7.     print(j + ', welcome to join us!')

NP17 生成列表

  1. print(list(input().split(' ')))
  2. 或
  3. list=input()
  4. print(list.split(" "))

[敲打]NP18 生成数字列表

  1. print([int(i) for i in input().split(" ")])
  2. 解析：
  3. int(i)将每个字符串元素转换为整数。
  4. [int(i) for i in input().split(" ")]是一个列表解析，它遍历字符串列表并将每个元素转换为整数。
  5.  
  6. 或
  7. input_str = input()  # 读取输入行  
  8. num_list = input_str.split()  # 将输入行按空格分割成字符串列表  
  9. int_list = [int(num) for num in num_list]  # 将字符串列表转换为整数列表  
  10. print(int_list)  # 打印整数列表

NP19 列表的长度

  1. print(len(input().split(" ")))
  2. 解析：split函数的用法是分隔字符串返回一个列表，因此不用再使用list函数进行转化 len函数返回长度

NP20 增加派对名单（一）

  1. lst = input().split(" ")
  2. lst.append('Allen')
  3. print(lst)
  4. 解析：获取用户输入的一行字符串，并将其以空格为分隔符分割成一个列表。然后，将字符串'Allen'添加到这个列表的末尾，最后将修改后的列表输出到控制台

[敲打]NP21 增加派对名单（二）

  1. list = input().split(" ")  
  2. list.insert(0,'Allen')  
  3. print(list)
  4. 解析：使用insert()方法将字符串'Allen'插入到列表的第一个位置（索引为0）

NP22 删除简历

  1. lst = input().split(" ")
  2. lst.pop(0)
  3. print(lst)
  4. 解析：使用pop(0)方法删除列表的第一个元素

NP23 删除好友

  1. list = input().split(" ")
  2. name = input()
  3. list.remove(name)
  4. print(list)
  5. 解析：获取用户输入的一行字符串，并通过将字符串以空格为分隔符分割成列表的方式将其存储在变量list中。然后，程序获取用户输入的一个名字，并将其存储在变量name中。接下来，使用remove()方法从列表list中删除该字母

NP24 淘汰排名最后的学生

  1. name = input().split(" ")
  2. for i in range(3):name.pop(-1)  
  3. print(name)
  4.  
  5. 或：
  6. list = input().split(" ")
  7. for i in range(3):
  8.     list.pop()
  9. print(list)

NP25 有序的列表

  1. # 创建一个列表，包含六个元素，分别为'P', 'y', 't', 'h', 'o', 'n'  
  2. my_list = ['P','y','t','h','o','n']   
  3.   
  4. # 使用sorted函数将my_list中的元素进行排序，并打印排序后的结果  
  5. print(sorted(my_list))  
  6.   
  7. # 打印my_list中的元素，此时元素顺序未改变  
  8. print(my_list)  
  9.   
  10. # 使用sort方法对my_list中的元素进行降序排列，打印排列后的结果  
  11. my_list.sort(reverse=True)  
  12. print(my_list)

NP26 牛牛的反转列表

  1. # 创建一个包含一些整数的列表 num  
  2. num = [3, 5, 9, 0, 1, 9, 0, 3]  
  3.   
  4. # 使用reverse()方法将列表中的元素反向排列  
  5. num.reverse()  
  6.   
  7. # 打印反转后的列表  
  8. print(num)

NP27 朋友们的喜好

  1. # 创建一个名为name的列表，包含四个字符串元素  
  2. name = ['Niumei', 'YOLO', 'Niu Ke Le', 'Mona']  
  3.   
  4. # 创建一个空的列表，用于存储朋友信息  
  5. friends = []  
  6.   
  7. # 将name列表添加到friends列表中，此时friends变为[name]  
  8. friends.append(name)  
  9.   
  10. # 创建一个名为food的列表，包含四个字符串元素，表示食物  
  11. food = ['pizza', 'fish', 'potato', 'beef']  
  12.   
  13. # 将food列表添加到friends列表中，此时friends变为[name, food]  
  14. friends.append(food)  
  15.   
  16. # 创建一个名为number的列表，包含四个整数元素  
  17. number = [3, 6, 0, 3]  
  18.   
  19. # 将number列表添加到friends列表中，此时friends变为[name, food, number]  
  20. friends.append(number)  
  21.   
  22. # 打印输出friends列表  
  23. print(friends)

[欠扁]NP28 密码游戏

  1. # 从用户输入获取一个字符串，并将其存储在变量num中  
  2. num = input()  
  3.   
  4. # 创建一个空列表ls  
  5. ls = []  
  6.   
  7. # 对于变量num中的每个字符i，执行以下操作：  
  8. # 将i转换为整数，然后加3，然后对9取余数，并将结果添加到ls列表中  
  9. for i in num:ls.append((int(i)+3)%9)  
  10.   
  11. # 输出ls列表中第2、3、0和1个元素，然后按照顺序重新排列并连接的字符串  
  12. # 输出格式为"{ls[2]}{ls[3]}{ls[0]}{ls[1]}"  
  13. print(f"{ls[2]}{ls[3]}{ls[0]}{ls[1]}")

NP29 用列表实现栈

  1. # 创建一个列表，表示一个栈，包含元素1, 2, 3, 4, 5  
  2. stack = [1, 2, 3, 4, 5]  
  3.   
  4. # 从用户获取输入，并将其转换为整数，然后存储在变量x中  
  5. x = int(input())  
  6.   
  7. # 循环两次  
  8. for i in range(0, 2):  
  9.     # 在每次循环中，从栈顶移除一个元素  
  10.     stack.pop()  
  11.     # 打印移除元素后的栈  
  12.     print(stack)  
  13.   
  14. # 将x（之前用户输入的整数）作为元素添加到栈顶  
  15. stack.append(x)  
  16. # 打印添加新元素后的栈  
  17. print(stack)

NP30 用列表实现队列

  1. # 创建一个列表，表示一个队列，包含元素1, 2, 3, 4, 5  
  2. queue = [1, 2, 3, 4, 5]  
  3.   
  4. # 循环两次  
  5. for i in range(0, 2):  
  6.     # 从队列的头部移除一个元素  
  7.     queue.pop(0)  
  8.     # 打印移除元素后的队列  
  9.     print(queue)  
  10.   
  11. # 从用户获取输入，并将其转换为整数，然后存储在变量num中  
  12. num = int(input())  
  13.   
  14. # 将num（之前用户输入的整数）作为元素添加到队列的尾部  
  15. queue.append(num)  
  16. # 打印添加新元素后的队列  
  17. print(queue)

NP31 团队分组

  1. # 创建一个包含五个字符串的列表，这些字符串代表人的名字  
  2. group_list = ['Tom', 'Allen', 'Jane', 'William', 'Tony']  
  3.   
  4. # 打印列表中的前两个元素（索引从0开始,不包含2）  
  5. print(group_list[0:2])  
  6.   
  7. # 打印列表中从第二个元素到第四个元素（不包含4）  
  8. print(group_list[1:4])  
  9.   
  10. # 打印列表中从第四个元素到第五个元素（不包含5）  
  11. print(group_list[3:5])

05运算符

Python中的运算符

NP32 牛牛的加减器

  1. x=int(input()) 
  2. y=int(input()) 
  3. print(x+y) 
  4. print(x-y)

NP33 乘法与幂运算

  1. x = int(input())
  2. y = int(input())
  3. print(x*y)
  4. print(x**y)

NP34 除法与取模运算

  1. # 从用户输入接收第一个整数  
  2. x = int(input())  
  3.   
  4. # 从用户输入接收第二个整数  
  5. y = int(input())  
  6.   
  7. # 打印整除结果，'end'参数设置输出的结束字符为空，即输出后不换行  
  8. print(x//y, end=" ")  
  9.   
  10. # 打印求余数结果  
  11. print(x%y)  
  12.   
  13. # 打印浮点除法结果，保留两位小数，使用字符串格式化方法'{:.2f}'  
  14. print('{:.2f}'.format(x/y))

NP35 朋友的年龄是否相等

  1. # 从标准输入（通常是键盘）读取输入，使用split函数以空格为分隔符将输入分割成一个字符串列表  
  2. # 然后使用map函数和int函数将列表中的每个元素从字符串类型转换为整数类型  
  3. # 最后，使用解包操作符将结果赋值给变量x和y  
  4. x, y = map(int,input().split(" "))  
  5.   
  6. # 输出x是否等于y的结果。在这里，==是等于运算符，用于比较两个值是否相等  
  7. print(x==y)

NP36 谁的数字大

  1. x, y = map(int, input().split(" "))
  2. print(x>y, x<y, sep="\n")

NP37 不低于与不超过

  1. k, x, y = input().split(" ")
  2. print(k <= x)
  3. print(k >= y)

NP38 牛牛的逻辑运算

  1. # 使用map函数将输入的字符串（通过split函数分割为多个字符串）转换为整数  
  2. # map函数会遍历输入的序列，对每个元素执行int函数，然后返回一个迭代器  
  3. x, y = map(int, input().split())  
  4.   
  5. # 打印x和y这两个变量的值。在Python中，'and'和'or'运算符在布尔上下文中使用，如果其左侧的值为真，则返回右侧的值  
  6. print(x and y)  
  7.   
  8. # 打印x或y的值。如果x为真，则返回x，否则返回y  
  9. print(x or y)  
  10.   
  11. # 打印x的否定值。在Python中，'not'运算符对布尔值取反，如果x为真，则输出False，否则输出True  
  12. print(not x)  
  13.   
  14. # 打印y的否定值。如果y为真，则输出False，否则输出True  
  15. print(not y)
  16. 注意：and、or和not这些逻辑运算符在Python中是基于布尔逻辑的。当其操作数不是布尔值时，Python会自动进行类型转换，将它们转换为布尔值。例如，如果x是0或者空字符串，那么x会被视为假（False），否则为真（True）。

NP39 字符串之间的比较 

  1. s1 = input()
  2. s2  =input()
  3. print(s1 == s2)
  4. print(bool(s1.lower() == s2.lower()))

NP40 俱乐部的成员

  1. s = input().split(" ")
  2. name = input()
  3. print(name in s)
  4.  
  5. 或：
  6. str_list =map(str,input().split())
  7. name=input()
  8. print(name in str_list)

NP41 二进制位运算

  1. x, y = map(int, input().split(" "))
  2. print(x & y)
  3. print(x | y)
  4.  
  5. 或：
  6. x,y =input().split()
  7. print(int(x,10) & int(y,10))#十进制写法
  8. print(int(x,10) | int(y,10))

NP42 公式计算器

  1. x, y, z, k = map(int, input().split(" "))
  2. print((x+y)*(z-k))

06 条件语句

Python语言流程控制结构

NP43 判断布尔值

  1. # 定义一个变量num，并将其值设置为bool(int(input()))的返回值  
  2. num = bool(int(input()))  
  3.   
  4. # 如果num的值等于True  
  5. if num==True:  
  6.     # 打印"Hello World!"  
  7.     print("Hello World!")  
  8. # 如果num的值不等于True，那么执行下面的elif语句  
  9. elif num==False:  
  10.     # 打印"Erros!"  
  11.     print("Erros!")

NP44 判断列表是否为空

  1. my_list = []
  2. if len(my_list) == 0:print('my_list is empty!')
  3. else:print('my_list is not empty!')
  4.  
  5.  
  6. 或：
  7. my_list = []
  8. if (my_list):
  9.     print('my_list is not empty!')
  10. else:
  11.      print('my_list is empty!')

NP45 禁止重复注册

  1. #为了不区分大小写把判断的都转成大写
  2. current_users=[i.upper() for i in ['Niuniu','Niumei','GURR','LOLO']]#因为输出的字符串要保持原来的样子，这个列表内容不能改
  3. new_users=['GurR','Niu Ke Le','LoLo','Tuo Rui Chi']
  4. for i in new_users:
  5.   # 通过upper()来调整大写后再判断
  6.   if i.upper() in current_users:  
  7.     print(f"The user name {i} has already been registered! Please change it and try again!")
  8.   else:print(f"Congratulations, the user name {i} is available!")

NP46 菜品的价格

  1. s = input()
  2. if s == 'pizza':print(10)
  3. elif s == 'rice':print(2)
  4. elif s == 'yogurt':print(5)
  5. else:print(8)

NP47 牛牛的绩点

  1.  
  2. # 创建一个字典，将学生成绩与对应的学分关联起来  
  3. d = {'A': 4.0, 'B': 3.0, 'C': 2.0, 'D': 1.0, 'F': 0}  
  4.   
  5. # 初始化一个变量s，用于累加学生的分数  
  6. # 初始化一个变量c，用于累加学生的学分  
  7. s = 0  
  8. c = 0  
  9.   
  10. # 进入无限循环，直到接收到"False"输入  
  11. while True:  
  12.   # 从用户获取学生成绩，并将其存储在变量grade中  
  13.   grade = input()  
  14.   
  15.   # 如果用户输入的是"False"，则跳出循环  
  16.   if grade == "False":  
  17.     break  
  18.   
  19.   # 从用户获取该学生的学分，并将其转换为整数并存储在变量credit中  
  20.   credit = int(input())  
  21.   
  22.   # 将学分加到总学分的累加器c中  
  23.   c += credit  
  24.   
  25.   # 从字典d中获取与成绩grade对应的学分，并将其乘以该学生的学分并加到总分s的累加器中  
  26.   s += d.get(grade)*credit  
  27.   
  28.   # 计算当前的平均分，并保留两位小数并输出  
  29. print('{:.2f}'.format(s/c))

NP48 验证登录名与密码

  1. id = input()
  2. password = input()
  3. if id == 'admis' and password == 'Nowcoder666':
  4.   print('Welcome!')
  5. else:
  6.   print("user id or password is not correct!")
  7.  
  8. 或：
  9. name = input()
  10. password = input()
  11. if name == password:
  12.     print("Welcome!")
  13. else:
  14.     print("user id or password is not correct!")

07 循环语句 NP49-NP61

Python循环

NP49 字符列表的长度

  1. my_list=['P','y','t','h','o','n']
  2. print('Here is the original list:')
  3. print(my_list)
  4. print()
  5. print('The number that my_list has is:')
  6. print(len(my_list))
  7.  
  8. 或：
  9. my_list = ['P','y','t','h','o','n']
  10. print('Here is the original list:', my_list,sep='\n')
  11. print()
  12. print('The number that my_list has is:',len(my_list),sep='\n')

NP50 程序员节

  1. users_list = [ 'Niuniu','Niumei','Niu Ke Le']
  2. for i in users_list:
  3.     print('Hi, {}! Welcome to Nowcoder!'.format(i))
  4. print("Happy Programmers' Day to everyone!")

NP51 列表的最大与最小

  1. # 创建一个列表（list），通过使用列表推导式（list comprehension）。列表推导式是一种简洁的、强大的构造列表的方法。  
  2. # 这里的列表推导式 [i for i in range(10,51)] 的意思是，对于 range(10,51) 中的每一个元素 i，都把它添加到列表中。  
  3. # range(10,51) 生成的是一个从10开始到50结束的整数序列（包括10，但不包括51）。  
  4. list=[i for i in range(10,51)]  
  5.   
  6. # 使用 print() 函数打印这个列表。在Python中，我们经常使用 print() 函数来查看变量的值，或者查看程序运行的结果。  
  7. print (list)  
  8.   
  9. # 使用 str() 函数将列表的第一个元素（索引为0）和最后一个元素（索引为-1）转换为字符串，然后打印出来。  
  10. # 在Python中，索引是从0开始的，所以 list[0] 是列表的第一个元素，list[-1] 是列表的最后一个元素。  
  11. # 转换为字符串是为了在打印时保持格式的一致性。  
  12. print(str(list[0]),str(list[-1]))

NP52 累加数与平均值

  1. # 从用户输入中读取一系列的整数，每个整数以空格分隔  
  2. ls = list(map(int, input().split(" ")))  
  3.   
  4. # 初始化一个变量s为0，用于后续的数值累加  
  5. s = 0  
  6.   
  7. # 遍历列表ls中的每个元素  
  8. for i in ls:  
  9.     # 将每个元素累加到变量s中  
  10.     s += i  
  11.   
  12. # 输出结果，首先输出s的值，然后输出s除以列表ls长度的结果，保留一位小数  
  13. print("{} {:.1f}".format(s, s/len(ls)))

NP53 前10个偶数

  1. # 创建一个列表，其中的元素是0到19之间的偶数  
  2. my_list = [i for i in range(0,20) if i%2==0]  
  3.   
  4. # 遍历列表中的每个元素  
  5. for i in my_list:  
  6.     # 打印当前元素  
  7.     print(i)

NP54 被5整除的数字

  1. my_list=[i for i in range(1,51) if i%5==0]
  2. for i in my_list:
  3.     print(i)

NP55 2的次方数

  1. # 创建一个空列表，用于存储计算结果  
  2. my_list = []  
  3.   
  4. # 循环遍历1到10之间的整数  
  5. for i in range(1, 11):  
  6.     # 将2的i次方数添加到列表中  
  7.     my_list.append(2**i)  
  8.       
  9.     # 打印2的i次方数  
  10.     print(2**i)

NP56 列表解析

  1. # 创建一个列表，其中包含从0到9（包含0，不包含10）的整数  
  2. list = [i for i in range(10)]  
  3.   
  4. # 打印这个列表，将列表中的每个元素转换为字符串并连接起来，然后输出  
  5. print(list)

NP57 格式化清单

  1. ls = ['apple', 'ice cream', 'watermelon', 'chips', 'hotdogs', 'hotpot']
  2. while True:
  3.   ls.pop()
  4.   print(ls)
  5.   if len(ls) == 0:
  6.     break
  7.  
  8. 或：
  9. food_list = ['apple', 'ice cream', 'watermelon', 'chips', 'hotdogs', 'hotpot']
  10. while len(food_list):
  11.     food_list.pop()
  12.     print(food_list)

NP58 找到HR

  1. user_list=['Niuniu','Niumei','HR','Niu Ke Le','GURR' , 'LOLO' ]
  2. for name in user_list:
  3.     if name=='HR':
  4.         print("Hi, {}! Would you like to hire someone?".format(name))
  5.     else:
  6.         print("Hi, {}! Welcome to Nowcoder!".format(name))

NP59 提前结束的循环

  1. list=[3, 45, 9, 8, 12, 89, 103, 42, 54, 79]
  2. x = int(input())
  3. for i in list:
  4.     if i==x:
  5.         break
  6.     print(i)

NP60 跳过列表的某个元素

  1. for i in range(1,16):
  2.     if i==13:
  3.         continue
  4.     else:
  5.         print(i,end=' ')

NP61 牛牛的矩阵相加

  1. # 从标准输入（通常是键盘）获取一个整数，并将其存储在变量n中  
  2. n = int(input())  
  3.   
  4. # 打印一个二维列表，该列表由其他三个二维列表的元素计算得到  
  5. print([[j*n for j in i] for i in [[1, 2, 3], [4, 5, 6], [7, 8, 9]]])

08 元组 NP62-66

Python元组

NP62 运动会双人项目

  1. t = (input(), input())
  2. print(t)
  3. 解析：t=(input(),input())：这一行代码首先调用了内置函数input()两次，然后将这两个输入的结果作为一个元组（tuple）存储在变量t中。input()函数在Python中通常用于获取用户输入的字符串。
  4. print(t)：这一行代码的作用是打印变量t的值。因为t是一个元组，所以它会打印出元组中的两个元素。

NP63 修改报名名单

  1. entry_form = ('Niuniu','Niumei')
  2. print(entry_form)
  3. try:
  4.     entry_form[1] = 'Niukele'
  5. except:
  6.     print('The entry form cannot be modified!')

NP64 输出前三同学的成绩

  1. # 从用户输入中获取字符串，并将其存储在变量s中  
  2. s = input().split()  
  3.   
  4. # 将列表s转换为一个元组，并将这个元组存储在变量names中。元组是一个不可变的序列，包含多个元素  
  5. names = tuple(s)  
  6.   
  7. # 打印names元组中的前三个元素。Python中的slice操作可以用于获取序列的一部分  
  8. print(names[0:3])

NP65 名单中出现过的人

  1. name_list=tuple(['Tom', 'Tony', 'Allen', 'Cydin', 'Lucy', 'Anna'])
  2. print(name_list)
  3. name = input()
  4. if name in name_list:
  5.     print('Congratulations!')        
  6. else:
  7.     print('What a pity!')

NP66 增加元组的长度

  1. # 创建一个元组，包含从1到5的整数  
  2. t = tuple(range(1, 6))  
  3. # 打印这个元组  
  4. print(t)  
  5. # 打印这个元组的长度（元素个数）  
  6. print(len(t))  
  7.   
  8. # 创建一个新的元组，将原来的元组与从6到10的整数范围组合在一起  
  9. t1 = t + tuple(range(6, 11))  
  10. # 打印新的元组  
  11. print(t1)  
  12. # 打印新的元组的长度（元素个数）  
  13. print(len(t1))

09 字典 NP67-75

Python组合数据类型字典

NP67 遍历字典

  1. # 创建一个字典，字典的键是运算符，对应的值是运算符的含义  
  2. operators_dict = {'<': 'less than','==': 'equal'}  
  3.   
  4. # 打印原始的字典  
  5. print('Here is the original dict:')  
  6.   
  7. # 遍历字典，按照键的字母顺序排序  
  8. # 对于每个键值对，输出键（即运算符）和对应的值（即该运算符的含义）  
  9. for key,value in sorted(operators_dict.items()):  
  10.     print(f'Operator {key} means {value}.')  
  11.   
  12. # 在字典中添加一个新的键值对，键是'>'，对应的值是'greater than'  
  13. operators_dict['>']= 'greater than'  
  14.   
  15. # 打印一个空行，用于分隔不同的输出内容  
  16. print()  
  17.   
  18. # 打印修改后的字典  
  19. print('The dict was changed to:')  
  20.   
  21. # 再次遍历字典，对于每个键值对，输出键（即运算符）和对应的值（即该运算符的含义）  
  22. for key,value in sorted(operators_dict.items()):  
  23.     print(f'Operator {key} means {value}.')
  24.   
  25. #解析：
  26. #items()方法返回一个包含字典中所有项的视图对象。
  27. #每个项都是一个元组，形如 (key, value)。
  28. #这个视图对象也可以迭代，所以你也可以使用它来遍历字典的项。

NP68 毕业生就业调查

  1. # 创建一个列表，包含四个字符串元素  
  2. survey_list = ['Niumei', 'Niu Ke Le', 'GURR', 'LOLO']  
  3.   
  4. # 创建一个字典，其中键是列表中的字符串，值是对应的公司名称  
  5. result_dict = {'Niumei': 'Nowcoder', 'GURR': 'HUAWEI'}  
  6.   
  7. # 遍历列表中的每个元素  
  8. for i in survey_list:  
  9.   # 检查当前元素是否在字典的键中  
  10.   if i in result_dict.keys():  
  11.     # 如果在，打印一条消息，感谢该人员参与了我们的毕业调查  
  12.     print(f'Hi, {i}! Thank you for participating in our graduation survey!')  
  13.   else:  
  14.     # 如果不在，打印一条消息，邀请该人员参加我们的毕业调查  
  15.     print(f'Hi, {i}! Could you take part in our graduation survey?')
  16.  
  17. #解析：
  18. #keys()方法返回一个包含字典中所有键的视图对象。
  19. #这个视图对象可以迭代，所以你可以使用它来遍历字典的键

NP69 姓名与学号

  1. # 创建一个字典，名为my_dict_1，其中包含'name'键和'Student ID'键，对应的值分别是'Niuniu'和1  
  2. my_dict_1 = {'name': 'Niuniu','Student ID': 1}  
  3.   
  4. # 创建一个字典，名为my_dict_2，其中包含'name'键和'Student ID'键，对应的值分别是'Niumei'和2  
  5. my_dict_2 = {'name': 'Niumei','Student ID': 2}  
  6.   
  7. # 创建一个字典，名为my_dict_3，其中包含'name'键和'Student ID'键，对应的值分别是'Niu Ke Le'和3  
  8. my_dict_3 = {'name': 'Niu Ke Le','Student ID': 3}  
  9.   
  10. # 创建一个空列表，名为dict_list，用于存储上面创建的字典  
  11. dict_list = []  
  12.   
  13. # 将my_dict_1添加到dict_list中  
  14. dict_list.append(my_dict_1)  
  15.   
  16. # 将my_dict_2添加到dict_list中  
  17. dict_list.append(my_dict_2)  
  18.   
  19. # 将my_dict_3添加到dict_list中  
  20. dict_list.append(my_dict_3)  
  21.   
  22. # 遍历dict_list中的每个字典i  
  23. for i in dict_list:  
  24.     # 从字典i中取出'name'对应的值作为key，取出'Student ID'对应的值作为value  
  25.     key,value=i['name'],i['Student ID']  
  26.     # 打印出"key's student id is value."这样的字符串，其中key是学生的名字，value是学生的学生ID  
  27.     print(f"{key}'s student id is {value}.")

NP70 首都

  1. # 定义一个字典，字典的键是城市名，对应的值是另一个字典，这个子字典包含了每个城市的详细信息  
  2. cities_dict = {'Beijing': {"Capital": 'China'},'Moscow': {"Capital": 'Russia'},'Paris': {"Capital": 'France'}}  
  3.   
  4. # 使用for循环遍历字典中的每个城市名  
  5. for city in sorted(cities_dict.keys()):  
  6.   
  7.     # 从字典中取出当前城市对应的值（子字典），然后从子字典中取出"Capital"对应的值，这个值就是当前城市的首都  
  8.     c=cities_dict[city]["Capital"]  
  9.   
  10.     # 打印出城市和其首都的信息  
  11.     print(f"{city} is the capital of {c}!")

NP71 喜欢的颜色

  1. # 创建一个字典，键是人的名字，值是他们喜欢的颜色的列表  
  2. result_dict = {'Allen': ['red', 'blue', 'yellow'],'Tom': ['green', 'white', 'blue'],'Andy': ['black', 'pink']}  
  3.   
  4. # 遍历字典的键（也就是人的名字），键的列表可以通过字典的 .keys() 方法获得  
  5. for name in sorted(result_dict.keys()):  
  6.     # 对于每个人名，打印出他们的名字和最喜欢的颜色的信息  
  7.     print("%s's favorite colors are: " %name)  
  8.   
  9.     # 遍历与该人名关联的颜色列表  
  10.     for colour in result_dict[name]:  
  11.         # 打印出每个颜色  
  12.         print(colour)

NP72 生成字典

  1. # 从用户输入中获取一个字符串，并将其以空格为分隔符进行分割，生成一个包含多个字符串的列表  
  2. name=input().split()  
  3.   
  4. # 与上述操作相同，从用户输入中获取一个字符串，并将其以空格为分隔符进行分割，生成一个包含多个字符串的列表  
  5. language=input().split()  
  6.   
  7. # 使用zip函数将name和language两个列表进行配对，生成一个由元组构成的列表  
  8. # zip函数会根据两个列表的长度，将对应位置的元素进行配对  
  9. dic=dict(zip(name,language))  
  10.   
  11. # 打印出刚刚生成的字典  
  12. print(dic)

NP73 查字典

  1. # 创建一个字典，其中包含了各个字母作为键，对应的单词列表作为值  
  2. dic = {'a': ['apple', 'abandon', 'ant'], 'b': ['banana', 'bee', 'become'], 'c': ['cat', 'come'], 'd': 'down'}  
  3.   
  4. # 从用户输入中获取一个字符串，这个字符串将被视为字典的键，用于查找对应的单词列表  
  5. word = input()  
  6.   
  7. # 遍历字典中对应的值（即单词列表），然后遍历这个列表中的每个单词  
  8. for i in dic[word]:  
  9.     # 打印出当前单词，并在单词后面添加一个空格，但不换行  
  10.     print(i,end=" ")

NP74 字典新增

  1. # 从用户输入中获取一个字符串，并将其存储在变量"letter"中  
  2. letter = input()  
  3.   
  4. # 同样地，再从用户输入中获取一个字符串，并将其存储在变量"word"中  
  5. word = input()  
  6.   
  7. # 创建一个字典"d"，该字典的键是字母，值是与之对应的单词列表  
  8. d = {  
  9.     "a": ["apple", "abandon", "ant"],  
  10.     "b": ["banana", "bee", "become"],  
  11.     "c": ["cat", "come"],  
  12.     "d": "down",  
  13. }  
  14.   
  15. # 将用户输入的"word"字符串赋值给字典"d"中对应的键"letter"的值  
  16. d[letter] = word  
  17.   
  18. # 打印出修改后的字典"d"  
  19. print (d)

NP75 使用字典计数

  1. # 从用户输入中读取一个字符串，并将其转化为列表形式。例如，如果用户输入"abcabc"，那么list1将会是['a', 'b', 'c', 'a', 'b', 'c']  
  2. list1=list(input())  
  3.   
  4. # 创建一个空字典dict1  
  5. dict1={}  
  6.   
  7. # 遍历list1中的每个元素  
  8. for i in list1:  
  9.     # 如果当前元素已经在字典中作为键存在  
  10.     if i in dict1:  
  11.         # 增加该元素在字典中的值（出现次数）  
  12.         dict1[i]+=1   
  13.     else:  
  14.         # 如果当前元素在字典中作为键不存在，则在字典中添加该元素，并将其值设为1（表示第一次出现）  
  15.         dict1[i]=1  
  16.   
  17. # 打印最终的字典  
  18. print(dict1)

010 内置函数 NP76 - NP93

NP76 列表的最值运算

  1. # 从用户获取输入，使用split函数将输入字符串按照空格分割成一个列表，并将该列表赋值给变量num  
  2. num = input().split()  
  3.   
  4. # 创建一个空的列表，并将其赋值给变量list  
  5. list= []  
  6.   
  7. # 遍历num列表中的每个元素。在每次循环中，将列表中的当前元素赋值给变量n  
  8. for n in num:  
  9.     # 将n转换为整数，并添加到list列表中  
  10.     list.append(int(n))  
  11.   
  12. # 找出list中的最大值和最小值，并打印出来。使用sep参数指定打印两个值时要使用的分隔符为换行符  
  13. print(max(list),min(list),sep='\n')

NP77 朋友的年龄和

  1. # 从用户输入中获取数据，以空格作为分隔符  
  2. ls = [int(i) for i in input().split(" ")]  
  3.   
  4. # 计算列表中所有元素的和并打印输出  
  5. print(sum(ls))

NP78 正数输出器

  1. # 使用eval函数接收用户输入的字符串，并将其转换为整数或浮点数赋值给num变量  
  2. num = eval(input())  
  3.   
  4. # 调用abs函数计算num的绝对值，并将结果打印到控制台  
  5. print(abs(num))
  6.  
  7. # 解析：eval()函数将输入字符串转换为整数或浮点数，abs()函数转换变量绝对值

NP79 字母转数字

print(ord(input()))

NP80 数字的十六进制

  1. print(hex(int(input())))
  2.  
  3. # 解析：input()函数用于从用户获取输入，int()函数将输入的字符串转换为整数类型，hex()函数将整数转换为十六进制字符串，最后使用print()函数将结果输出。

NP81 数字的二进制表示

  1. print(bin(int(input())))
  2.  
  3. # 解析：input()函数用于从用户获取输入，int()函数将输入的字符串转换为整数类型，bin()函数将整数转换为二进制字符串，最后使用print()函数将结果输出。

NP82 数学幂运算

  1. x,y=list(map(int,input().split()))
  2. print(pow(x,y),pow(y,x),sep='\n')
  3.  
  4. # 解析：map()函数将输入的字符串列表中的每个元素转换为整数类型，然后使用split()函数将字符串按照空格分割成多个子字符串。通过解构赋值，将整数x和y分别赋值给变量x和y。接下来，使用pow()函数计算x的y次幂和y的x次幂，使用print()函数将两个结果打印出来，使用'\n'作为分隔符，以便在输出结果时换行显示

NP83 错误出现的次数

  1. s = input().split(" ")
  2. print(s.count("0")) #统计9出现的次数

NP84 列表中第一次出现的位置

  1. #读取用户的输入，使用空格作为分隔符将其分割为一个列表，这个聊表被赋值给变量s
  2. s = list(input().split(" "))
  3.  
  4. print(s.index('NiuNiu'))

NP85 字符的类型比较

  1. s = input()
  2. print(s.isalpha())
  3. print(s.isdigit())
  4. print(s.isspace())
  5.  
  6. 或：
  7. s = input()
  8. print(s.isalpha(),s.isdigit(),s.isspace(),sep="\n")

NP86 字符子串的查找

  1. long_str = input()
  2.  
  3. #find()方法查找，如果找到则返回NiuNiu在long_str中的起始索引(从0开始)，如果没有找到，则返回-1
  4. ，如果如果print(long_str.find('NiuNiu'))

NP87 子串的数量

  1. patten = input()
  2. print(patten.count('Niu'))

NP88 句子拆分

  1. s = input()
  2. print(s.split(' '))

NP89 单词造句

  1. lst = []
  2. while True:
  3.     w = input()
  4.     if w == '0':
  5.         break
  6.     lst.append(w)
  7. print(' '.join(lst))
  8.  
  9. 或：
  10. list = []
  11. while True:
  12.     w = input()
  13.     if w != "0":
  14.         list.append(w)  
  15.     else:
  16.         break
  17. print(" ".join(list))

NP90 修正错误的字母

  1. s = input()
  2. print(s.replace('a*', 'ab'))

NP91 小数位修正

  1. f = float(input())
  2. print(round(f, 2))

NP92 公式计算器

  1. s = eval(input())
  2. print(s)

NP93 创建集合

  1. s = input().split(' ')
  2.  
  3. #set()：将s中的元素转换为集合，以消除重复元素
  4. #sorted()：对集合中的元素进行排序
  5. print(sorted(set(s)))

011 面向对象 NP94 - NP100

Python中的类和对象

NP94 函数求差

  1. def cal(a, b):
  2.   return a - b
  3. x = int(input())
  4. y = int(input())
  5. print(cal(x, y))
  6. print(cal(y, x))

NP95 兔子的数量

  1. def f(n):
  2.   if n==1:
  3.     return 2
  4.   if n==2:
  5.     return 3
  6.   else:
  7.     return f(n-1)+f(n-2)
  8. n=int(input())
  9. print(f(n))
  10.  
  11. 或：
  12. # 定义一个函数f，参数为n  
  13. def f(n):  
  14.     # 如果n等于1，返回2  
  15.     if n==1:  
  16.         return 2  
  17.     # 如果n等于2，返回3  
  18.     elif n==2:  
  19.         return 3  
  20.     # 如果n大于2，返回f(n-1)和f(n-2)的和，即前两项斐波那契数的和  
  21.     else:  
  22.         return f(n-1)+f(n-2)  
  23.   
  24. # 输出函数f的结果，输入值为用户输入的整数  
  25. print(f(int(input())))

NP96 球的表面积

  1. import math
  2. def ball(n):
  3.     return 4*math.pi*(n**2)
  4. for n in [1, 2, 4, 9, 10, 13]:
  5.     print(round(ball(n),2))

NP97 班级管理

  1. class Student(object):
  2.     def __init__(self, name, sid, score, rank):
  3.         self.name = name
  4.         self.id = sid
  5.         self.score = score
  6.         self.a = rank
  7.         self.alen = len(rank.split(" "))
  8. name = input()
  9. sid = int(input())
  10. score = int(input())
  11. a = input()
  12. d = Student(name, sid, score, a)
  13. print(d.name+"'s student number is "+str(d.id)+", and his grade is "+str(d.score)+". He submitted "+str(d.alen)+" assignments, each with a grade of "+d.a)

NP98 修改属性1

  1. class Employee(object):
  2.     def __init__(self,name,salary):
  3.         self.name=name
  4.         self.salary=salary
  5.     def printclass(self):
  6.         print("{}'salary is {}, and his age is {}".format(self.name,self.salary,self.age))
  7. name=input()
  8. salary=int(input())
  9. age=int(input())
  10. try:
  11.     e=Employee(name,salary,age)
  12.     e.printclass()
  13. except:
  14.     print('Error! No age')
  15.  
  16. try:
  17.     emp=Employee(name,salary)
  18.     emp.age=age
  19.     emp.printclass()
  20. except:
  21.      print('Error! No age')

NP99 修改属性2

  1. # 定义一个名为Employee的类，表示员工  
  2. class Employee:  
  3.     # 定义类的初始化函数，接受两个参数：name和salary，分别表示员工的姓名和薪水  
  4.     # 在初始化函数中，我们使用self来指向当前实例，以便于为该实例的属性赋值  
  5.     def __init__(self, name=None, salary=None):  
  6.         self.name = name  # 为当前实例的name属性赋值为输入的name  
  7.         self.salary = salary  # 为当前实例的salary属性赋值为输入的salary  
  8.   
  9.     # 定义一个方法，用于打印员工的姓名和薪水  
  10.     def printclass(self):  
  11.         # 使用字符串格式化来创建一个字符串，包含员工的姓名和薪水信息  
  12.         # %s表示字符串，%d表示整数，self.name和self.salary分别是Employee类的实例属性，表示员工的姓名和薪水  
  13.         return "%s'salary is %d, and his age is %d" % (self.name, self.salary, self.age)  
  14.   
  15.   
  16. # 判断当前运行的文件是否为主文件（直接运行），如果是则执行以下代码  
  17. if __name__ == "__main__":  
  18.     # 从用户输入中获取员工的姓名  
  19.     name = input()  
  20.     # 从用户输入中获取员工的薪水，并将其转换为整数类型  
  21.     salary = int(input())  
  22.     # 从用户输入中获取员工的年龄，并将其转换为整数类型  
  23.     age = int(input())  
  24.     # 使用获取的员工姓名和薪水创建一个Employee类的实例e  
  25.     e = Employee(name, salary)  
  26.     # 检查实例e是否具有age属性，如果e没有age属性（is False），则执行以下代码  
  27.     if hasattr(e, "age") is False:  
  28.         # 打印e是否具有age属性的结果（True或False）  
  29.         print(hasattr(e, "age"))  
  30.         # 为实例e添加一个名为age的属性，并将其值设置为输入的年龄  
  31.         setattr(e, "age", age)  
  32.     # 调用实例e的printclass方法，并打印返回的字符串  
  33.     print(e.printclass())

NP100 重载运算

  1. # 定义一个名为Coordinate的类，它用于表示二维坐标
  2. class Coordinate:
  3.     # 定义类的初始化函数，它接收两个参数：x和y，代表坐标的x和y轴
  4.     def __init__(self, x, y):
  5.         # 将输入的x和y值分别赋值给对象的x和y属性
  6.         self.x = x
  7.         self.y = y
  8.  
  9.     # 定义一个字符串函数，它用于打印坐标的x和y值
  10.     def str(self):
  11.         # 通过print函数打印对象的x和y属性值，此函数未返回任何值，直接在控制台输出
  12.         print((self.x, self.y))
  13.  
  14.     # 定义一个添加函数，用于将两个坐标相加
  15.     def add(self):
  16.         # 将x和y的值分别用split()函数进行分割，这个函数默认会按照空格进行分割，然后map(int, ...)将分割出的每个字符串转化为整数
  17.         # 这样做是因为默认情况下，input()函数接收的是字符串格式，我们需要将其转化为整数才能进行相加操作
  18.         a = list(map(int, self.x.split()))  # 将self.x按照空格分割，并将得到的每个字符串转化为整数，然后转化为列表形式
  19.         b = list(map(int, self.y.split()))  # 将self.y按照空格分割，并将得到的每个字符串转化为整数，然后转化为列表形式
  20.         # 将两个列表中的第一个元素相加作为新的x值，将两个列表中的第二个元素相加作为新的y值
  21.         self.x = a[0] + b[0]
  22.         self.y = a[1] + b[1]
  23.  
  24.  
  25. # 从用户处接收两个输入值，分别赋值给x和y变量
  26. x = input()
  27. y = input()
  28.  
  29. # 创建一个Coordinate类的实例，将x和y的值分别赋值给对象的x和y属性
  30. c = Coordinate(x, y)
  31.  
  32. # 调用对象的add()方法，将两个坐标相加
  33. c.add()
  34.  
  35. # 调用对象的str()方法，将相加后的坐标打印出来
  36. c.str()

012 正则表达式 NP101 - NP103

NP101 正则查找网址

  1. import re
  2. http = input()
  3. result = re.match('https://www',http,re.I)
  4. print(result.span())

NP102 提取数字电话

  1. # 导入Python的正则表达式模块  
  2. import re  
  3.   
  4. # 使用正则表达式 '[^\\d]' 来匹配输入字符串中的所有非数字字符  
  5. # '[^\\d]' 是一个正则表达式，'\\d' 代表数字，'[^]' 表示非此字符，所以 '[^\\d]' 代表非数字字符  
  6. # 're.sub()' 函数用于替换字符串中的匹配项，第一个参数为匹配项，第二个参数为替换项，第三个参数为原始字符串  
  7. # 这里的替换项为空字符串 '' ，所以这个函数的作用是删除输入字符串中所有的非数字字符  
  8. print(re.sub('[^\d]', '', input()))

NP103 截断电话号码

  1. import re
  2. s = input()
  3. r = re.match('[0-9-]+',s)
  4. print(r.group())

又是学了又忘了的一天，我可真棒~

声明：本文内容由网友自发贡献，不代表【wpsshop博客】立场，版权归原作者所有，本站不承担相应法律责任。如您发现有侵权的内容，请联系我们。转载请注明出处：https://www.wpsshop.cn/w/从前慢现在也慢/article/detail/394696?site=
推荐阅读
相关标签

Copyright © 2003-2013 www.wpsshop.cn 版权所有，并保留所有权利。

  

闽ICP备14008679号