python--牛客基础题

输出格式化

1、控制小数点的输出位数

num = float(input())
print("%.2f"%num)  # eg：两位数
print(f"{num:.2f}")# 使用f格式化保留两位小数点
print("{.2f}".format(num)) # 使用format格式化保留两位小数点

'''变量的输出'''
# f前缀格式化输出
print(f"Hi, {name}! Welcome to Nowcoder!")
# format后缀格式化输出
print("Hi, {}! Welcome to Nowcoder!".format(name))
# 拼接输出，注意这个变量需要是str类型
print("Hi, " + name + "! Welcome to Nowcoder!")
# 使用%
print("Hi, %s! Welcome %s to Nowcoder!" %(name,name))
# 只输出变量,两个变量之间自带空格
print(name,name)

'''输出的格式'''
# 输出结尾要求是空格
print("a",end=" ")

2、整数的进度转换

# 输入的是十六进制，转换成10进制
num = input()
print(int(num,base=16))

3、字符串的全小写、全大写和首字母大写

name_one = input()
print(name_one.lower()) #全小写
print(name_one.upper()) #全大写
print(name_one.title()) #首字母大写

4、字符串的去空格

name = input()
print(name.strip()) # strip()只能是去除前后两边的空格，中间的无法去除
print(name.lstrip()) # lstrip()删除左边空格
print(name.rstrip()) # rstrip()删除右边空格
print(name.replace(" ",""))#使用替换函数将空格删除
name.split() #分割函数，默认分割所有的空字符，包括空格、换行、制表符等
# 直接分割赋值的是list类型
data = name.split()
# 使用链表式复制，每个变量的类型是str
x, y = name.split()

5、将字符串的整型转换成整型元素的列表

# 第一种
num = input()
num_list = list(num.split())
# 快捷创建一个列表，值是遍历创建
data = [int(i) for i in num_list]
print(data)
# 第二种 使用map映射函数，map映射函数有比较灵活的用法
data = list(map(int, num_list))
print(data)
# 第三种就是遍历装换整型

6、列表的插入函数

name = input()
name_list = list(name.split())
# 尾部追加
name_list.append("Allen")
# 指定索引位置添加
name_list.insert(0,"Allen")
print(name_list)

7、删除列表的值

name = input()
name_list = list(name.split())
# 删除第一个
del name_list[0]
# 删除整个列表
del name_list

8、列表的排序

my_list = ['P','y','t','h','o','n']
# 临时排序，不会改变原本的列表
print(sorted(my_list))
print(my_list)
# 降序排序，会改变原本的列表排序
my_list.sort(reverse=True)
print(my_list)
# 反转列表，会改变原本列表的排序
my_list.reverse()
print(my_list)

9、输入四位整数，输出的数字：每位数字都要加上3再除以9的余数代替该位数字，然后将第1位和第3位数字交换，第2位和第4位数字交换。输入不会有前置0，但是输出要保持前置0

# 自己的简陋写法
data = int(input())
i = data//1000
y = data//100-i*10
x = data//10-i*100-y*10
z = data%10
data_list = [x,z,i,y]
a = map(str,[(n+3)%9 for n in data_list])
password=""
for s in a:
    password = password+s
print(password)

# 直接格式化输出
data = input()
data_list = []
for i in data:
    data_one = (int(i)+3)%9
    data_list.append(data_one)
print(f"{data_list[2]}{data_list[3]}{data_list[0]}{data_list[1]}")

# 列表值替换，
data = input()
data_list = []
for i in data:
    data_one = (int(i)+3)%9
    data_list.append(data_one)
data_list[0],data_list[2] = data_list[2],data_list[0]
data_list[1],data_list[3] = data_list[3],data_list[1]
# 输出方式很多，可以使用join拼接列表为字符串
print(''.join(map(str,data_list)))

9、矩阵相加，输入n，矩阵的每个元素值相加n次，矩阵可以使用二维列表表示

# 创建原始矩阵
data_list = [[1, 2, 3], [4, 5, 6], [7, 8, 9]]
num = int(input())

#第一种 遍历二维列表 ，重新复制一个新为二维列表
add_list = []
for i in data_list:
    data = []
    for y in i:
        data.append(y * num)
    add_list.append(data)
print(add_list)

# 第二种 遍历二维列表，更改列表本身的值
for i in data_list:
    for y in range(len(i)):
        i[y] = i[y] * num
print(data_list)

10、修改元祖，元祖是不可以修改的

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

11、输出前三名同学的成绩（有可能没有三名）：元组的切片

data = input()
data_list = data.split()
data_tuple = tuple(data_list)

# 使用if-else语法，判断是否超过3
if len(data_tuple) >= 3:
    print(data_tuple[0:3])
else:
    print(data_tuple)
    
# 第二种：直接切片，元组的切片索引不会越界
 print(data_tuple[0:3])

12、字典的遍历，使用sorted临时排序

# 使用sorted函数临时升序
operators_dict = {"<": "less than", "==": "equal"}
print("Here is the original dict:")
# 第一种遍历，遍历排序后的key列表，通过键名访问字典的值
for key in sorted(operators_dict):
    print(f"Operator {key} means {operators_dict[key]}.")

# 给字典添加新的元素
operators_dict[">"] = "greater than"
print("") # 空行

print("The dict was changed to:")
# 第二种遍历，排序的是键值对，直接获取键值对，无需再访问字典
for key,value in sorted(operators_dict.items()):
    print(f"Operator {key} means {value}.")

13、毕业调查，使用字典的keys()

# 调查名单
survey_list =['Niumei','Niu Ke Le','GURR','LOLO']
# 调查结果
result_dict={'Niumei': 'Nowcoder','GURR': 'HUAWEI'}
for name in survey_list:
    # 如果在字典中，就感谢邀请
    if name in result_dict.keys():
        print(f"Hi, {name}! Thank you for participating in our graduation survey!")
    # 否则，发出邀请
    else:
        print(f"Hi, {name}! Could you take part in our graduation survey?")

14、使用zip将两个列表转换成字典：使用zip函数

# 输入的字符串，每个键名以空格分隔
keys = input().split()
# 输入的字符串，每个键值以空格分隔
values = input().split()
# 使用zip压缩，并转换成字典
data_dict = dict(zip(keys, values))
print(data_dict)

15、使用字典计数：遍历字符串，使用字典统计数量

# 输入字符串
word = input()
word_dict = {}
# 遍历字符串
for i in word:
    # 如果不存在，则添加新的键值对
    if i not in word_dict.keys():
        word_dict[i] = 1
    # 存在，则value+1
    else:
        word_dict[i] = word_dict[i] + 1
print(word_dict)
'''
输入：Nowcoder
输出：
{'N': 1, 'o': 2, 'w': 1, 'c': 1, 'd': 1, 'e': 1, 'r': 1}
'''

16、列表的join函数：join

long_list = []
while True:
    str1 =input()
    # 输入0退出
    if str1 =="0":
        break
    long_list.append(str1)
# join之后类型为str
print(" ".join(long_list))

17、将输入的字符串转换集合：set()

data_list = input().split()
# 转换成set集合，集合是去重的
data_set = set(data_list)
# 使用sorted临时排序输出
print(sorted(data_set))

18、兔子的数量：递归 f(n) = f(n-1)+f(n-2)，第一个月是2，第二月是3，第三个月是5

# x:月份  y：第一个月的数量,如果是第一个月的数量是固定的，那么可以固定y值，就不用作为参数了
def add_sum(x,y):
    # 如果是0月，则是初始值，1只兔子
    if x<=0:
        return 1
    # 如果是第一个月，只有一个月的数量，返回单位数量
    elif x==1:
        return y
    # 大于1个月，递归计算
    else:
        return add_sum(x-1,y)+add_sum(x-2,y)
    
num = int(input())
print(add_sum(num,2))

19、求球的表面积：

import math

# 球的表面积公式：4πr^2
def area(radius):
    return 4 * math.pi * pow(radius, 2)


data = [1, 2, 4, 9, 10, 13]
# 遍历打印
for i in data:
    print(f"{area(i):.2f}")

20、创建学生类：

class Student:
    # 初始化函数  学生姓名（str）、学号（str）、分数（int）、每次作业等级（list[str]）
    def __init__(self, name, no, grade_num, grade):
        self.name = name
        self.no = no
        self.grade_num = grade_num
        self.grade = grade

    # 输出函数
    def toInfo(self):
        print(
            f"{self.name}'s student number is {self.no}, and his grade is {self.grade_num}. He submitted {len(self.grade)} assignments, each with a grade of {' '.join(self.grade)}"
        )

# 输入参数
name = input()
no = input()
grade_num = int(input())
grade = input().split()

# 新建一个对象
student = Student(name, no, grade_num, grade)
# 打印
student.toInfo()

21、修改类的属性：直接obi.field=value（修改属性值也是如此）

'''
getattr(obj, name[, default]) : 访问对象的属性。
hasattr(obj,name) : 检查是否存在一个属性。
setattr(obj,name,value) : 设置一个属性。如果属性不存在，会创建一个新属性。
delattr(obj, name) : 删除属性。
'''

class Employee:
    # 初始化
    def __init__(self, name, salary):
        self.name = name
        self.salary = salary

    # printclass方法
    def printclass(self):
        # 第一种方法，使用hasattr判定是否存在属性
        if not hasattr(self, "age"):
            print("Error! No age")
        else:
            print(f"{self.name}'salary is {self.salary}, and his age is {self.age}")
         
        
        # 第二种方法，使用try……except……
        try:
            print(f"{self.name}'salary is {self.salary}, and his age is {self.age}")
        except:
            print("Error! No age")

# 输入数据
name = input()
salary = int(input())
age = int(input())

# 实例化对象
emp = Employee(name, salary)
# 第一次打印
emp.printclass()

# 第一种方式：直接添加属性
emp.age = age
# 第二种方式，使用setattr()方法添加
setattr(emp,"age",age)

# 第二次打印
emp.printclass()

22、类的重载运算

class Coordinate:
    def __init__(self, x, y):
        self.x = x
        self.y = y

    def __str__(self):
        print(f'({self.x}, {self.y})')

    def __add__(self, coordinate):
        self.x = self.x + coordinate.x
        self.y = self.y + coordinate.y


list1 = list(map(int, input().split()))
list2 = list(map(int, input().split()))
# 新建对象
coordinate1 = Coordinate(list1[0], list1[1])
coordinate2 = Coordinate(list2[0], list2[1])
# 先add后输出
coordinate1.__add__(coordinate2)
coordinate1.__str__()
'''
输入：
1 2
3 4
输出：(4, 6)
'''

23、正则表达式

'''
尝试从字符串的起始位置匹配一个模式，如果不是起始位置匹配成功的话，match()就返回none。
re.match(pattern, string, flags=0)
pattern：  匹配的正则表达式
string:：要匹配的字符串。
flags：标志位，用于控制正则表达式的匹配方式，如：是否区分大小写，多行匹配等等
''' 

import re
url= input()
# 必须加上span，意思是起始位置开始匹配
print(re.match('https://www',url).span())
'''
输入：https://www.Nowcoder.com
输出：(0, 11)
'''


'''
re.sub用于替换字符串中的匹配项
re.sub(pattern, repl, string, count=0, flags=0)
pattern : 正则中的模式字符串。
repl : 替换的字符串，也可为一个函数。
string : 要被查找替换的原始字符串。
count : 模式匹配后替换的最大次数，默认 0 表示替换所有的匹配。
flags : 编译时用的匹配模式，数字形式。
'''
import re

phone = input()
# 将所有的非数字替换成""
num = re.sub(r"[^0-9]", "", phone)
print(num)

'''
输入：2022-063-109NiuMei
输出：2022063109
'''