牛客网题库python入门

前言：

本篇文章适合pytho初学者以及学了python之后依旧感觉没有入门的小萌新
本身是计算机专业，上课时，有学过九周的python课，之后，我又多次跟着网上的课程学习python,但我依然觉得自己依旧没有入门，每次遇到编程时，连从哪开始都不知道，非常苦恼。
究其原因，在于没有测试和刷题，对所学的知识混乱，对问题的分析欠缺等等。
如果你想要学习python基础知识，可以试着课程和牛客网python基础题这两项，这些题并不难，题目本身告诉你如何输入和输出了，只需要按照步骤编写就行，一方面，这可以训练你对python的基础语法了解，另一方面，由易入难得过程会增加你的自信。
牛客网

如果遇到哪个知识点不会，可以查看python基础课程参考文档：菜鸟教程

总结

此部分记录对我来说，一些需要值得回顾的题和知识点

1 输入输出

NP1 Hello World!

str="Hello World!"
print(str)

NP2 多行输出

import sys
str1='Hello World!'
str2='Hello Nowcoder!'
#方法一
# print(str1)
# print(str2)
#方法二：
#print(str1+'\n'+str2)
#方法三：
print(str1,str2,sep='\n')

NP3 读入字符串

str=input()
print(str)

NP4 读入整数数字

#强制转换int(要转换的类型)
#判断类型type()
num=int(input())
print(num)
print(type(num))

NP5 格式化输出（一）

name=input()
print("I am "+name+" and I am studying Python in Nowcoder!")

NP6 牛牛的小数输出

import sys
num=float(input())
print("{:.2f}".format(num))

2 类型转换

NP7 小数化整数

import sys
num=float(input())
print(int(num))

NP8 为整数增加小数点

import sys
num=int(input())
print(float(num))
print(type(float(num)))

输出函数类型，用type()

NP9 十六进制数字的大小

import sys
num=input()
print(int(num,16))

int(a,b)，参数b 代表数字进制，默认十进制

3 字符串

NP10 牛牛最好的朋友们

import sys
name1=input()
name2=input()
print(name1+name2)

NP11 单词的长度

import sys
word=input()
print(len(word))

len()获取python中字符串的长度

NP12 格式化输出（二）

import sys
name=input()
# 方法一：
# print(name.lower())
# print(name.upper())
# print(name.title())
#方法二
print(name.lower(),name.upper(),name.title(),sep='\n')

string.capitalize()：把字符串的第一个字符大写
string.title()：返回"标题化"的 string,就是说所有单词都是以大写开始，其余字母均为小写
题中第三行要求所有单词首字母为大写

NP13 格式化输出（三）

import sys
name=input()
print(name.strip())

string.lstrip()：截掉 string 左边的空格
string.rstrip()： 删除 string 字符串末尾的空格
string.strip([obj])：在 string 上执行 lstrip()和 rstrip()

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

使用字符串 * 运算

import sys
str=input()
print(str*100)

NP15 截取用户名前10位

import sys
str=input()
print(str[0:10])

4 列表

NP16 发送offer

没想到败在逗号后面的空格上，第一次只定义一个列表，按照列表一行行输出。看了题解后，定义了两个列表，并把输出的文本定义了一下，便于输出。
（本人觉得应该两个列表更好，一个代表着面试列表，一个代表着offer列表）

import sys
#方法一
offer_list1=['Allen','Tom']
offer_list2=['Allen','Andy']
text1='you have passed our interview and will soon become a member of our company.'
text2='welcome to join us!'
for i in offer_list1:
    print('%s, '%i+text1)
for i in offer_list2:
    print('%s, '%i+text2)
#方法二
# offer_list=['Allen','Tom','Andy','Jack']
# text1='you have passed our interview and will soon become a member of our company.'
# text2='welcome to join us!'
# print( offer_list[0]+', '+text1)
# print( offer_list[1]+', '+text1)
# print( offer_list[0]+', '+text2)
# print( offer_list[2]+', '+text2)

NP17 生成列表

import sys
name=input()
list=name.split()
print(list)

split用法：

Name.split(str,num)

"Name"表示需要拆分的字符串；
split()中有两个参数，“str”表示分隔符，num则表示需要拆分的次数。
如果不传入实际参数，则默认str的值为空格、制表符，num的默认值为-1，即能够拆分的所有次数
split()分割后直接就是列表了，所以直接输出就可

NP18 生成数字列表

import sys
num=input()
list=num.split()#将输入的数据分割成字符列表
list_new=[] #定义一个空的新列表
 #从0到列表长度遍历列表
for i in range(0,len(list)): 
    list_new.append(int(list[i]))#将列表元素转换成整型添加到新列表中
print(list_new)

NP19 列表的长度

split()分割字符串后直接返回一个列表，len()得知列表长度

import sys
str=input()
list=str.split()
print(len(list))

NP20 增加派对名单（一）

import sys
str=input()#输入的名字存在str中
name=str.split()#用split()将输入的字符串str分割成列表
#上述两步可简化成一步
#name=input().split()
name.append('Allen')
print(name)

NP21 增加派对名单（二）

import sys
str = input()  # 输入的名字存在str中
name = str.split()  # 用split()将输入的字符串str分割成列表
# 上述两步可简化成一步
# name=input().split()
name.insert(0,'Allen')#第一个参数是索引位置，第二个参数是要插入的对象
print(name)

NP22 删除简历

在 Python 列表中删除元素主要分为以下 3 种场景：
根据目标元素所在位置的索引进行删除，可以使用 del 关键字或者 pop() 方法；
根据元素本身的值进行删除，可使用列表（list类型）提供的 remove() 方法；
将列表中所有元素全部删除，可使用列表（list类型）提供的 clear() 方法。

import sys
list=input().split()
del list[0]
print(list)

NP23 删除好友

题中说多行输入，可以分两次输入，第一次输入朋友的名字，第二次输入吵架朋友的名字

import sys
list=input().split()
name=input()
list.remove(name)
print(list)

NP24 淘汰排名最后的学生

import sys
# name=input().split()
# name.pop()
# name.pop()
# name.pop()
# print(name)
name=input().split()
for i in range(0,3):
    name.pop()
print(name)

NP25 有序的列表

sort 与 sorted 区别：
sort 是应用在 list 上的方法，sorted 可以对所有可迭代的对象进行排序操作。
list 的 sort 方法返回的是对已经存在的列表进行操作，无返回值，而内建函数 sorted 方法返回的是一个新的 list，而不是在原来的基础上进行的操作。

import sys
my_list=['P','y','t','h','o','n']
str1=sorted(my_list)#不会改变原列表，可以复制给新变量
print(str1)
print(my_list)#my_list为原列表，可以看出此时原列表不变
my_list.sort(reverse=True)#无返回值，直接改变原列表，直接输出就行
print(my_list)#此时的my_list是倒序后的结果

NP26 牛牛的反转列表

此题题目有问题，最终输出的只要输出反转后的列表（不输出创建好的原始列表）

import sys
num = [3, 5, 9, 0, 1, 9, 0, 3]
num.reverse()
print(num)

下面为错误示范，可以看出报错是因为输出为空：

NP27 朋友们的喜好

#方法一：
#依次定义三个列表
name = ["Niumei", "YOLO", "Niu Ke Le", "Mona"]
food = ["pizza", "fish", "potato", "beef"]
number = [3, 6, 0, 3]
friends = []#定义friends空列表
#依次把上面定义的列表添加到friends中
friends.append(name)
friends.append(food)
friends.append(number)
print(friends)

# 方法二用循环添加列表到friends列表中
name = ["Niumei", "YOLO", "Niu Ke Le", "Mona"]
food = ["pizza", "fish", "potato", "beef"]
number = [3, 6, 0, 3]
friends = []
str = [name, food, number]#将三个列表定义成一个列表
#依据列表的索引和列表的长度也即（0,3）之间循环
for index in range(len(str)):
    friends.append(str[index])#添加的是对应索引时的列表
print(friends)

NP28 密码游戏

import sys
num=input()
num1=num[:1]
num2=num[1:2]
num3=num[2:3]
num4=num[3:4]
new_num1=(int(num1)+3)%9
new_num2=(int(num2)+3)%9
new_num3=(int(num3)+3)%9
new_num4=(int(num4)+3)%9
print('{}{}{}{}'.format(new_num3,new_num4,new_num1,new_num2))

第一种方法，首先需要获得输入的四个数字，分别为num1，num2,num3,num4,然后把四个数字进行加3和求余9，最后使用format()格式化反转输出。

#方法二
a = input()
str1= str()#定义一个字符串
for i in range(len(a)):
    str1 += str((int(a[i])+3)%9)
print(str1[2],str1[3],str1[0],str1[1],sep='')

NP29 用列表实现栈

num=int(input())
stack = [1, 2, 3, 4, 5]
stack.pop()
print(stack)
stack.pop()
print(stack)
stack.append(num)
print(stack)

两次弹出数据，用循环。

num=int(input())
stack = [1, 2, 3, 4, 5]
for i in range(2):
    stack.pop()
    print(stack)
stack.append(num)
print(stack)

NP30 用列表实现队列

import sys
queue = [1, 2, 3, 4, 5] 
num=int(input())
# queue.pop(0)
# print(queue)
for i in range(2):
    queue.pop(0)#默认是pop(-1),弹出列尾的数，题中要求是首位，按照索引，故为pop(0)
    print(queue)
queue.append(num)
print(queue)

NP31 团队分组

import sys
group_list=['Tom','Allen','Jane','William','Tony']
task1=group_list[0:2]#按索引取前两位
task2=group_list[1:4]#按索引取中间三位
task3=group_list[3:]#按索引取后两位
print(task1,task2,task3,sep='\n')

5 运算符

NP32 牛牛的加减器

import sys
num1=int(input())
num2=int(input())
add=num1+num2
minus=num1-num2
print(add,minus,sep='\n')

把加减运算封装成一个函数

def Add_Sub(x, y):
    sum = x + y
    substract = x - y
    return sum, substract
x = int(input())
y = int(input())
sum, substract = Add_Sub(x, y)
print(sum, substract, sep="\n")

NP33 乘法与幂运算

num1=int(input())#input输入默认是字符串,强制转换为整型
num2=int(input())
sum1=num1*num2
sum2=num1**num2
print(sum1,sum2,sep='\n')

NP34 除法与取模运算

num1=int(input())
num2=int(input())
if num2==0:
    num2=int(input())
else:
    sum1=num1//num2   #商
    sum2=num1%num2    #余数
    sum3=num1/num2
print(sum1,sum2)
print("{:.2f}".format(sum3)) #保留两位小数

#方法二使用函数
def fun(x,y):
    if y!=0:
        a=x//y
        b=x%y
        c=x/y
        print('{} {}\n{:.2f}'.format(a,b,c))
x=int(input())
y=int(input())
fun(x,y)

NP35 朋友的年龄是否相等

num=input().split()
if num[0]==num[1]:
    print("True")
else:
    print("False")

需要注意的点是本题的输出是一行输入两个整数，并且以空格间隔。可以使用split()函数分割。
假设输入的为22 22
经过num=input().split()后，此时的num变为[‘22’,‘22’]
我们可以通过比对列表元素来判断两个元素是否相等。

NP36 谁的数字大

def fun(x,y):
    if x>y:
        print("True","False",sep='\n')
    elif x==y:
        print("False","False",sep='\n')
    else:
        print("False","True",sep='\n')
num=input().split()
first=int(num[0])
second=int(num[1])
fun(first,second)

简洁代码：

x,y=input().split()
print(x>y)
print(x<y)

NP37 不低于与不超过

num=input().split()
k=num[0]
x=num[1]
y=num[2]
print(k<=x)
print(k>=y)

NP38 牛牛的逻辑运算

此题考查；逻辑运算符：

num=input().split()
x=int(num[0])
y=int(num[1])
print(x and y,x or y,not x,not y,sep='\n')

NP39 字符串之间的比较

str1=input()
str2=input()
# print(str1==str2)
# print(str1.lower()==str2.lower())
print(str1==str2,str1.lower()==str2.lower(),sep='\n')

NP40 俱乐部的成员

判断列表元素是否在列表内用in可直接判断

name1=input().split()
name2=input()#待查询的名字
print(name2 in name1)

NP41 二进制位运算

num=input().split()
x=int(num[0])
y=int(num[1])
print(x&y,x|y,sep='\n')

注意审题：题中说位运算，在运算时，是直接把数字看成二进制，直接对二进制每一位进行运算。不是让你把十进制数转换成二进制数…
此题考查的是位运算符：

NP42 公式计算器

num=input().split()
x=int(num[0])
y=int(num[1])
z=int(num[2])
k=int(num[3])
sum=(x+y)*(z-k)
print(sum)

#方法二：
num=input().split()
x=int(num[0])
y=int(num[1])
z=int(num[2])
k=int(num[3])
def fun(x,y,z,k):
    sum=(x+y)*(z-k)
    print(sum)
fun(x,y,z,k)

6 条件语句

NP43 判断布尔值

num=int(input())
if num==1:
    print("Hello World!")
else:
     print("Erros!")

num=input()
if num==1:
    print("Hello World!")
else:
     print("Erros!")

上述两种方法，系统都判对了，但不确定是否真的正确。
（1）题中说输入布尔变量，那么输入的0和1是否就是布尔变量，还需要是否转换。
input()的返回为string类型, input() 在对待纯数字输入时具有自己的特性，它返回所输入的数字的类型（ int, float ）
看到题解中，有人这样转换：
x = bool(int(input())) # 将输入的0或1转换为布尔值并赋值给变量

NP44 判断列表是否为空

my_list=[]
if len(my_list)==0:
    print('my_list is empty!')
else:
    print('my_list is not empty!')

本题既然定义的列表为空列表，所以输出必然为’my_list is empty!'，目的估计为了了解如何判断空列表
判断python列表是否为空，三种方法：
（1）判断列表的长度，列表长度为0代表为空

if len(my_list)==0:
    print('my_list is empty!')

（2）直接使用list作为判断标准，则空列表相当于False

my_list = []
if not my_list:
    print("my_list is empty!")
else:
    print("my_list is not empty!")

(3)使用==进行判断,定义一个空列表，用来判断另外一个列表是否为空列表。

EmptyList = []
list = []
if list==EmptyList:
    print('list is empty')

NP45 禁止重复注册

！！！注意题中不区分大小写，故需要把所有名字转换为全部大写或者全部小写。

current_users=['Niuniu','Niumei','GURR','LOLO']
new_users=['GurR','Niu Ke Le','LoLo','Tuo Rui Chi']

for c in new_users:    #循环列表内的元素，可以直接这样写
    if c.lower() in list(map(lambda x: x.lower(), current_users)):#map()函数对current_users里面的每个元素进行小写转换
        print('The user name {} has already been registered! Please change it and try again!'.format(c))
    else:
        print('Congratulations, the user name {} is available!'.format(c))

map() 会根据提供的函数对指定序列做映射。
第一个参数 function 以参数序列中的每一个元素调用 function 函数，返回包含每次 function 函数返回值的新列表。

NP46 菜品的价格

str=input()
if str=='pizza':
    print("10")
elif str=='rice':
    print("2")
elif str=='yogurt':
    print("5")
else:
    print("8")

题中要求用if-elif-else,除了这种方法外，用字典更方便。

NP47 牛牛的绩点

dict1={"A":4.0,"B":3.0,"C":2.0,"D":1.0,"F":0}#定义等级和绩点的列表
list1=[]
list2=[]
while True:
    grade=input()     #grade接收输入的等级
    if grade=="False":#当为False时，退出输入
        break
    else:
        score=int(input())  #接收输入的score
        list1.append(dict1[grade]*score) #找到字典中等级对应的绩点，然后绩点*学分
        list2.append(score)              #存储所有的学分
print('{:.2f}'.format(sum(list1)/sum(list2)))  #加权后的绩点除以总学分

NP48 验证登录名与密码

user_name=input()
password=input()
if user_name=='admis' and password=='Nowcoder666':
    print("Welcome!")
else:
    print("user id or password is not correct!")

7 循环语句

NP49 字符列表的长度

my_list=['P','y','t','h','o','n']
print("Here is the original list:",my_list,sep='\n')
print()
print("The number that my_list has is:",len(my_list),sep='\n')

NP50 程序员节

user_list=['Niuniu','Niumei','Niu Ke Le' ]
for c in user_list:   #注意在列表中的遍历
    print('Hi, {}! Welcome to Nowcoder!'.format(c))
print("Happy Programmers' Day to everyone!")

NP51 列表的最大与最小

list=[]
for i in range(10,51):   #前闭后开，想要遍历到50，需要写到51
    list.append(i)
print(list)
print("{} {}".format(list[0],list[-1]))

NP52 累加数与平均值

age=input().split()
list=[]
for c in age:
    list.append(int(c))  #for循环遍历是为了让列表的元素变成整型
total=sum(list)          #sum对列表元素求和
avg=sum(list)/len(list)
print("{} {:.1f}".format(total,avg))  #保留一位小数

NP53 前10个偶数

my_list=range(0,19,2)
for c in my_list:
    print(c,sep='\n')

NP54 被5整除的数字

my_list=range(5,51,5)#注意范围，第一个输出5，所以开始为5，最后一个数字为50，stop为51
for c in my_list:
    print(c,sep='\n')

NP55 2的次方数

题中要求使用两个for循环

#方法二
my_list=[]
for i in range(1,11):
    my_list.append(2**i)
for c in my_list:
    print(c,sep='\n')

for i in range(1,11):
    c=2**i
    print(c,sep='\n')

NP56 列表解析

print(list(range(0,10)))

http://t.csdn.cn/3w9Z8

NP57 格式化清单

list=['apple', 'ice cream', 'watermelon', 'chips', 'hotdogs', 'hotpot']
while len(list)>0:
    list.pop()
    print(list)

NP58 找到HR

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

NP59 提前结束的循环

num=int(input())
list=[3, 45, 9, 8, 12, 89, 103, 42, 54, 79]
for c in list:
    if c!=num:
        print(c)
    else:
        break

NP60 跳过列表的某个元素

python 将一个列表 转化为空格隔开的字符串

list=[]
for i in range(1,16):
    if i!=13:
        list.append(i)
        continue
    else:
        i=i+1
for c in list:
      print(c,end=" ") #将列表转化为空格隔开的字符串

NP61 牛牛的矩阵相加

方法一：

list=[[1,2,3],[4,5,6],[7,8,9]]
n=int(input())
for x in range(len(list)):  
    for y in range(len(list[x])):
        list[x][y]=list[x][y]*n
print(list)

方法二：

list1 = [1,2,3]
list2 = [4,5,6]
list3 = [7,8,9]
n = int(input())
list4 = [[x*n for x in list1], [y*n for y in list2], [z*n for z in list3]]
print(list4)

方法三：

list1 = [[1, 2, 3], [4, 5, 6], [7, 8, 9]]
n = int(input())
for i in list1:
    for j in range(len(i)):
        i[j] = i[j] * n
print(list1)

8 元组

NP62 运动会双人项目

str1=input()
str2=input()
tup=(str1,str2)
print(tup)

NP63 修改报名名单

entry_form=('Niuniu','Niumei')
print(entry_form)
try:
    entry_form[1] = 'Niukele'
except:
    print('The entry form cannot be modified!')

NP64 输出前三同学的成绩

num=input().split()#将输入的元素转化为列表
# print(num[0:3])#num[0:3]可以获取列表中前三个元素
print(tuple(num[0:3]))#tuple(list)可以将列表转化为元组

NP65 名单中出现过的人

tup=('Tom', 'Tony', 'Allen', 'Cydin', 'Lucy', 'Anna')
name=input()
print(tup)
if name in tup:
    print('Congratulations!')
else:
    print('What a pity!')

NP66 增加元组的长度

tup1=(1,2,3,4,5)
tup2=(6,7,8,9,10)
tup=tup1+tup2
print(tup1,len(tup1),tup,len(tup),sep='\n')

9 字典

NP67 遍历字典

#方法一
operators_dict={'<':'less than','==':'equal'}
print('Here is the original dict:')
for c in operators_dict:
    print('Operator {} means {}.'.format(c,operators_dict[c]))

operators_dict['>']='greater than'
print()
print('The dict was changed to:')
for c in operators_dict:
    print('Operator {} means {}.'.format(c,operators_dict[c]))

方法二
operators_dict={'<':'less than','==':'equal'}
print('Here is the original dict:')
for c in sorted(operators_dict):
    print('Operator {} means {}.'.format(c,operators_dict[c]))

operators_dict['>']='greater than'
print()
print('The dict was changed to:')
for c in sorted(operators_dict):  #sorted()函数排序
    print('Operator {} means {}.'.format(c,operators_dict[c]))

第一次没有使用sorted()排序，系统也判对了，估计因为题目设置的字典本身就是升序。

NP68 毕业生就业调查

survey_list=['Niumei','Niu Ke Le','GURR','LOLO']
result_dict={'Niumei':'Nowcoder','GURR':'HUAWEI'}
for c in survey_list:
    if c in  result_dict:
        print('Hi, {}! Thank you for participating in our graduation survey!'.format(c))
    else:
        print('Hi, {}! Could you take part in our graduation survey?'.format(c))

NP69 姓名与学号

my_dict_1={'name': 'Niuniu','Student ID': 1}
my_dict_2={'name': 'Niumei','Student ID': 2}
my_dict_3={'name': 'Niu Ke Le','Student ID':3}
dict_list=[]
dict_list.append(my_dict_1)
dict_list.append(my_dict_2)
dict_list.append(my_dict_3)
for c in dict_list:
    print("{}'s student id is {}.".format(c['name'],c['Student ID']))

NP70 首都

#方法一
cities_dict={'Beijing':'China','Moscow':'Russia','Paris':'France'}
for c in cities_dict:
    print('{} is the capital of {}!'.format(c,cities_dict[c]))

# 方法二
cities_dict = {
    "Beijing": {'Capital': "China"},
    "Moscow": {'Capital': "Russia"},
    "Paris": {'Capital': "France"},
}
for city, country in sorted(cities_dict.items()): #对字典排序
    # print(f'{city} is the capital of {country["Capital"]}!')
    print('{} is the capital of {}!'.format(city,country["Capital"]))

注意：第一种方法是错误的，并没有按照题目描述写，系统竟然也判对了，估计是只检查输出。方法二中的item()值得注意。

NP71 喜欢的颜色

result_dict={'Allen': ['red', 'blue', 'yellow'],'Tom': ['green', 'white', 'blue'],'Andy': ['black', 'pink']}
for name in sorted(result_dict):
    print("{}'s favorite colors are:".format(name))
    for colors in result_dict[name]:
        print(colors)

NP72 生成字典

name=input().split()
key=name
lan=input().split()
value=lan
zipped=dict(zip(key,value))  #要用dict转化为字典
print(zipped)

Python zip() 函数
zip() 函数用于将可迭代的对象作为参数，将对象中对应的元素打包成一个个元组，然后返回由这些元组组成的列表。
如果各个迭代器的元素个数不一致，则返回列表长度与最短的对象相同，利用 * 号操作符，可以将元组解压为列表。

NP73 查字典

!! 把列表元素按照空格隔开一行输出

English_dict={
    "a": ["apple", "abandon", "ant"],
    "b": ["banana", "bee", "become"],
    "c": ["cat", "come"],
    "d": "down",
}
word=input()
if word in English_dict:  #判断输出的字母是否在字典中
    for i in range(len(English_dict[word])):
        print(English_dict[word][i],end=' ')
        #注意输出结尾用end=' ',这样就可以将列表元素输出在同一行
else:
    word=input()

NP74 字典新增

letter = input()
word = input()
word_dict = {
    "a": ["apple", "abandon", "ant"],
    "b": ["banana", "bee", "become"],
    "c": ["cat", "come"],
    "d": "down",
}
word_dict[letter]=word
print(word_dict)

NP75 使用字典计数

输入一行单词，以字典的格式输出各个单词出现的次数

word=input()
res={}
for i in word:
    if i in res:
        res[i] = res[i] + 1
    else:
        res[i] = 1
print(res)

10 内置函数

NP76 列表的最值运算

num=input().split()#使用split()分割成的是字符型的列表
#要把列表中的字符型数字转化为整型
value= list(map(int,num)) 
max_value=max(value)
min_value=min(value)
print(max_value,min_value,sep='\n')

！！！将列表中字符型数字转化为整型数字

一维列表
方法一:

a = ['1', '2', '3']
a = list(map(int, a))

方法二：

a = ['1', '2', '3']
a_new = []
for i in a:
    a_new.append(int(i))

方法三：

a = ['1', '2', '3']
a = [int(i) for i in a]

详细参考这个作者的博客：
将列表字符串类型元素转化为整型

NP77 朋友的年龄和

num=input().split() #将输入的元素转化为列表
value=list(map(int,num))#将列表中的字符型数字转化为整型数字
print(sum(value))

NP78 正数输出器

#方法一
# num=int(input())
# print(abs(num))


#方法二
num=int(input())
if num==0:
    num=input()
else:
    print(abs(num))

方法一中并没有是否输入为零，系统依然判对

NP79 字母转数字

num=input()
print(ord(num))

NP80 数字的十六进制

num=int(input())
print(hex(num))

NP81 数字的二进制表示

num=int(input())
print(bin(num))

NP82 数学幂运算

num=input().split()
x=int(num[0])
y=int(num[1])
print(pow(x,y),pow(y,x),sep='\n')

NP83 错误出现的次数

num=input().split()
value=list(map(int,num))#将列表中的字符型数字转化为整型数字
print(value.count(0))

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

#方法一
name=input().split()
num=0
for i in name:
    if i!='NiuNiu':
        num=num+1
    else:
        print(num)

#方法二调用index函数
name=input().split()
print(name.index('NiuNiu'))

NP85 字符的类型比较

name=input()
print(name.isalpha(),name.isdigit(),name.isspace(),sep='\n')

NP86 字符子串的查找

long_str=input()
print(long_str.find('NiuNiu'))

知识点：find()函数

NP87 子串的数量

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

NP88 句子拆分

sentence=input().split()
print(sentence)

NP89 单词造句

word=[]
while True:
    msg = input()
    if msg == "0":
        break
    else:
        word.append(msg)
sentence=' '.join(word) #注意，引号里面是空格，这是把列表中的单词以空格隔开链接
print(sentence)

注意join(函数的用法

仔细看看实例，以一种字符把一个元组或列表的元素连接起来

NP90 修正错误的字母

name=input()
print (name.replace('a*','ab'))

NP91 小数位修正

num=float(input())
print(round(num,2))

NP92 公式计算器

num=input()
print(eval(num))

描述
eval() 函数用来执行一个字符串表达式，并返回表达式的值。
字符串表达式可以包含变量、函数调用、运算符和其他 Python 语法元素。
语法
以下是 eval() 方法的语法:

eval(expression[, globals[, locals]])

参数
expression – 表达式。
globals – 变量作用域，全局命名空间，如果被提供，则必须是一个字典对象。
locals – 变量作用域，局部命名空间，如果被提供，可以是任何映射对象。
eval() 函数将字符串 expression 解析为 Python 表达式，并在指定的命名空间中执行它。
返回值
eval() 函数将字符串转换为相应的对象，并返回表达式的结果。

NP93 创建集合

#定义接受数据与集合的变量
name=input().split()
collection=set()
#使用for循环遍历分割空格后的字符串，利用set的特性去重
for i in name:
    collection.add(i)
#使用sorted函数进行排序输出
print(sorted(collection))

11 面向对象

NP94 函数求差

def cal(x,y):
    return x-y
num1=int(input())
num2=int(input())
print(cal(num1,num2),cal(num2,num1),sep='\n')

NP95 兔子的数量（递归函数）

def f(n):
    if n==1:
        return 2
    elif n==2:
        return 3
    else:
        return f(n-1)+f(n-2)
n=int(input())
print(f(n))

NP96 球的表面积

import math
circle_r=[1, 2, 4, 9, 10, 13]
for r in circle_r:
    V=4*math.pi*r**2
    print("{:.2f}".format(V))#格式化把结果输出为两位小数

注意：其中的pi用法

NP97 班级管理

class Student(object):
    def __init__(self, name, student_id, score, grade):
        self.name = name
        self.student_id = student_id
        self.score = score
        self.grade = grade
        self.times = len(grade.split(" "))

    def printclass(self):
        print( "{}'s student number is {}, and his grade is {}. He submitted {} assignments, each with a grade of {}".format(self.name,self.student_id,self.score,self.times,self.grade) ) 

name=input()
student_id=input()
score=int(input())
grade=input()

student=Student(name,student_id,score,grade)
student.printclass()  #这个地方这样写，printclass函数里面写print

# print(student.printclass()) #如果这个地方写print,printclass函数里面写return

注意：学习类和类的实例化，注意init两侧是下划线，是两个，不是一个，否则会报TypeError: Student() takes no arguments错误

NP98 修改属性1

class Employee(object):
    def __init__(self,name,salary):
        self.name=name
        self.salary=salary
    def printclass(self):
        try:
            print(f"{self.name}'salary is {self.salary}, and his age is {self.age}")
        except AttributeError:
            print("Error! No age")
#数据输入：姓名，薪水，年龄
name=input()
salary=int(input())
age=int(input())

#先使用name和salary创建实例e
e=Employee(name,salary)
e.printclass()

#直接在实例e上添加属性年龄age
e.age=age
e.printclass()

属性的添加有两种方式：直接在类定义中添加（类里的属性所有实例化的对象都可以拥有此属性也可以修改），另一种方式就是对象添加，这个添加的对象只对该对象有效，其他对象没有此属性

NP99 修改属性2

class Employee(object):
    def __init__(self,name,salary):
        self.name=name
        self.salary=salary
    def printclass(self):
        print("{}'salary is {}, and his age is {}".format(self.name,self.salary,self.age))

name=input()
salary=int(input())
age=int(input())

#实例化
e=Employee(name,salary)
if hasattr(e, 'age')==True:  #hasattr函数，判断实例中是否有某个属性
    e.printclass()
else:
    print(hasattr(e, 'age'))#输出e有没有属性age，True或者False
    setattr(e, 'age', age)   #settattr函数，为实例添加age属性和属性的值
    e.printclass()  

NP100 重载运算

class Coordinate(object):
    def __init__(self,x,y):
        self.x=x
        self.y=y
    def __str__(self):
        return((self.x,self.y))
    def __add__(self,other):
        return (self.x+other.x,self.y+other.y)

x1,y1=list(map(int,input().split(' ')))
x2,y2=list(map(int,input().split(' ')))
c1=Coordinate(x1,y1)
c2=Coordinate(x2,y2)
c3 = c1.__add__(c2)  #注意调用用法
print(c3.__str__())

#方法二
# num1=input().split(' ')
# num2=input().split(' ')
# c1=Coordinate(int(num1[0]),int(num1[1]))
# c2=Coordinate(int(num2[0]),int(num2[1]))
# c3 = c1.__add__(c2)  #注意调用用法
# print(c3.__str__())

注意：函数的调用用法！

object.add(self, other)
调用这些方法来实现双目算术运算 (+, -, *, @, /, //, %, divmod(), pow(), **, <<, >>, &, ^, |)。 例如，求表达式 x + y 的值，其中 x 是具有 add() 方法的类的一个实例，则会调用 type(x).add(x, y)。

12 正则表达式

NP101 正则查找网址

import re
netaddress=input()
print(re.match('https://www', netaddress).span())

可以看出：当re.match()在起始位置上匹配上的话，会返回"<re.Match object; span=(0, 3), match=‘www’>"，这里返回的是一个 MatchObject
那么什么是：MatchObject呢？
Match object是re方法match()和seatch()返回的对象。
MatchObject 实例也有几个方法和属性；最重要的那些如下所示：

group() 返回被 RE 匹配的字符串
start() 返回匹配开始的位置
end() 返回匹配结束的位置
span()返回一个元组包含匹配 (开始,结束) 的位置
该如何处理MatchObject呢
处理这样的返回内容：<re.Match object; span=(0, 3), match=‘www’>
我们可以使用span()方法与group()方法进行处理，这也是我们在编程时常用见到的。
具体操作过程如下：
span方法操作：

import re
print(re.match('www', 'www.runoob.com').span())  # 在起始位置匹配，这里将返回一个元组包含(开始,结束) 的位置
print(re.match('com', 'www.runoob.com'))  # 不在起始位置匹配

返回结果如下：

(0, 3)
None

group（）方法操作如下：

import re
print(re.match('www', 'www.runoob.com').group())  # 在起始位置匹配，这里将返回我们匹配成功的内容
print(re.match('com', 'www.runoob.com'))  # 不在起始位置匹配

返回结果：

www
None

NP102 提取数字电话

import re
phone=input()
num = re.sub(r'\D', "", phone) #可以预先在正则表达式前添加 r ，然后这些转义只会被解析为正常地转义
print(num)

Python正则表达式报错：invalid escape sequence ‘\d’ (无效的转义字符’\d’)
python3.7 + 正则表达式

报错 " invalid escape sequence ‘\d’ " (无效的转义字符’\d’)。

报错 " invalid escape sequence ‘\d’ " (无效的转义字符’\d’)。

原因是Python 3将字符串文字解释为Unicode字符串，因此 \d 被视为转义的Unicode字符。解决办法有两种。

方法1:
在字符串字面值中使用两个反斜线， 表示正则表达式受到保护，不被字节码编译器解释。即把 \ 都变成 \ 。

输出：

<re.Match object; span=(0, 40), match=‘Hello 1234567 World_This is a Regex Demo’>
1234567

方法2:
可以预先在正则表达式前添加 r ，然后这些转义只会被解析为正常地转义，如下所示：

输出：

<re.Match object; span=(0, 40), match=‘Hello 1234567 World_This is a Regex Demo’>
1234567

参考链接：Python正则表达式报错：invalid escape sequence ‘\d’ (无效的转义字符’\d’)

NP103 截断电话号码

import re
phone=input()
#方法一
num=re.sub(r'#.*$', "", phone)  
#sub删除后方的注释信息
print(num)
#方法二 使用re.match进行匹配
num=re.match('[0-9-]+',phone).group()
print(num)

#代表注释信息的开始#
.匹配任意字符，除了换行符，当re.DOTALL标记被指定时，则可以匹配包括换行符的任意字符
*代表匹配0个或多个表达式
$ 匹配字符串的末尾