头歌60道题目，代码，输入输出和解析

     🗡请先单击目录-分类🗡

὎🗡查看自己需要内容🗡὎

目录

 一，分类

二，前言

三、60个代码

 1，集合创建与添加元素√

 2，鸡兔同笼，空格分隔输入和map()√

 ，阶乘和取余√

 4，李白买酒

 5，动物重量排序√

 6，可变参数被坑

 7，字典的添加修改删除

 8， 字典遍历，键与值

 9， 字典通讯录search

10, 字典通讯录modify，不同类型输入检验

11， 字典，键盘输入键值与字典相联系

12， 正整数分解质因数，map()

1, 列表字典嵌套

14， 无穷算圆周率

15， 输入问题1

16， 十进制转其他，函数

17， 存款买房-C

18， 蒙特卡洛（随机数法）算圆周率

19， 梅钦（马青）法算圆周

20， 列表最基本操作√

21， 列表转元组√

22， 列表输出问题1√

2， 列表删除数据（巨坑）√

24， 列表去重√

25， 列表切片√

26， 列表嵌套字典排序√

27， 列表合并与降序（键盘输入）√

28， 列表的增删改√

29， 列表的属性（输入检测）√

0， 集合，键盘输入判断后续操作

1， 回文素数

2，回车结束输入

， 个人所得税

4， 割圆术

5， 二维列表排序√

6， 二鼠打洞

7， 存款买房-B

8，try, except

9, 计算三角形面积

40， 保留多少位小数

41， list基础√

42， list(range())√

4, lambda使用

44， 无空格输出

45， assert()

46, 递归函数

47，迭代器基本操作

48，定义类Animal

49，定义继承类Cat

50，代码的封装

51， 圆类

52，文件

5，判断两文件是否相同

54，random模块

55，datetime模块

总结

 一，分类

-------------------------------------------------目录请看左栏 ------------------------------------------------------

                 ----------------------*列表*-----------------------

                             25，列表切片

  24，列表去重

  26，列表嵌套字典排序

  27，列表合并与降序，键盘输入

  28，列表的增删改

  29，列表的属性，输入检测           

  20，列表基本操作

  21，列表转元组

  22，列表输出问题1

  2，列表删除数据（坑）

           5，二位列表排序

  41，list基础

  42，list(range())

           5，动物重量排序

----------------------*字典元组集合*-----------------------

  7，字典的添加修改删除

  8，字典遍历，键与值

  9，字典通讯录search

          10，字典通讯录modify，不同类型输入检验

 11，键盘输入键，值与字典相联系

          1，元组字典嵌套

           1，集合创建与添加元素

          0，集合，键盘输入判断后续操作

----------------------*算法*-----------------------

14，无穷算圆周率

         4，割圆术

18，蒙特卡洛（随机数）法算圆周

19，梅钦（马青）法算圆周

          ，阶乘和取余

          2，鸡兔同笼，空格分隔输入和map()

 4，李白买酒

         6，二鼠打洞

17，存款买房-C

         7，存款买房-B

         ，个人所得税

         16，十进制转其他（函数）

----------------------*输入输出*-----------------------

 6，可变函数被坑

12，正整数分解质因数，map

15，输入问题1

1，回文素数

2，回车结束输入

8，try, except

9，计算三角形面积

40，保留多少位小数

4，lambda使用

44，无空格输出

45，assert()

46，递归函数

----------------------*类和文件*-----------------------

47，迭代器基本操作

48，定义类Animal

                           49，定义继承类Cat

50，代码的封装

51，圆类

52，文件

5，判断两文件是否相同

54，random模块

55，datetime模块

二，前言

从2022/10/7 ~ 2022/12/7，在头歌平台自学，历时2个月
纯新手代码

敲代码一开始遇到的各种新手无脑BUG，都在注释里

所有代码在vs code和头歌平台都能编译通过，有需要自取

！！！左边也有目录，请自行点击！！！

三、60个代码

1，集合创建与添加元素√

n = int(input())
amp = set() #创建空集合必须 = set()，非空的话 = {值1，值2...} 或者 = ([值1，值2...])    不可变的话  = frozenset([值1, 值, 值, ……, 值n])
for i in range(n):
    amp.add(input())
print(len(amp))

#集合的显著特点可以去掉重复元素

输入输出

5
haha
Ted
thx
haha
Ted

2，鸡兔同笼，空格分隔输入和map()√


在同一行内输入用空格分隔的两个整数，代表头和脚的数量，计算并输出笼中各有多少只鸡和兔，
如无解则输出“Data Error!”，函数无返回值。
输入：5 94
输出：有2 只鸡，12 只兔
输入：100 5
输出：Data Error!

head,feet = map(int,input().split())#不加int,输入的默认为字符串
#1,读入以空格分隔的两个整数，表示头和脚的数量
#2,map(函数,序列)，此处input().split()作为序列，int作为函数，因为是函数名，不是调用函数，所以不需要()
#,至于.split()则默认为空格，换行符，制表符
flag = 1
for i in range(0,head  1):
    if i * 2  (head - i) * 4 == feet:
        flag = 0
        print(有{}只鸡，{}只兔.format(i, head - i))
if(flag):
    print(Data Error!)

输入输出
 

66 142
有61只鸡，5只兔

，阶乘和取余√

import sys#sys库，类似C using namespace std;
 
a = [1]
s = [0]
M = 9982445

for i in range(1, int(1e6)  10):
    a.append((a[-1] * i) % M)
    s.append(s[-1]  a[-1] % M)

for i in sys.stdin:#连续输入
    print(s[int(i)])

输入输出

9
5
15
1000
50612577195
1000000
49861422174847

 4，李白买酒√

大诗人李白，提着酒壶，从家里出来，酒壶中有酒若干。他边走边唱：无事街上走，提壶去买酒，
遇店加一倍，见花喝一斗，五遇店和花，喝光壶中酒，计算并输出壶中原有酒几斗？
#正向：店-花-店-花-店-花-店-花-店-花。
#解题思路：让李白按路线逆向走一遍，逆向：花-店*5，遇花加一斗，遇店减半
wine = 0#最后酒壶空了，记得初始化
for i in range(5):
    wine = 1
    wine /= 2
print(wine)#原来有多少斗酒

0.96875

5，动物重量排序√

list = [] #先声明列表不可少
while 1:
    li = input().split()#1，当类型冲突时，不要规定类型，直接li = input()  
    if len(li) == 0: #1，血的教训：不要用if li == ,要记熟if len(li) == 0  break,这才是回车结束输入的正确方式
        break # ,回车结束输入
    else:
        list.append(li) #2，这个形式要记住，列表名.append(input的变量名)
                        #2，将字符串作为二位列表元素输入
                        #2，因为按字符串输入二维列表的元素，所以判断大小时要先加float()
list_1 = sorted(list,key = lambda x:float(x[1][:-1])*1000 if x[1][-1] == 	t	 else float(x[1][:-2]))
#1，二位列表输出一般逗号分隔
#2，这里被当成字符串处理了，if[1][-1] == 	t	意味着二维第二个元素的最后一个字符为t
#此时按第二个元素t之前的，即0.75t中的0.75*1000的大小排序
#，else float(x[1][:-2])，第二个元素（字符串）kg之前字符串转换为float后的大小
print(list_1)

输入输出 

美人鱼 55kg
帅哥 65kg
怪兽 22t
超人 22001kg
Apex 0.2kg

[[	Apex	, 	0.2kg	], [	美人鱼	, 	55kg	], [	帅哥	, 	65kg	], [	怪兽	, 	22t	], [	超人	, 	22001kg	]]

 6，可变参数被坑√

names = input().split(	 	)

def say_hi_multi_parameter(names): #参数加*，会变成整个元组  	，你好！	
    for name in names:#此处不用for而直接print的话，就是整个列表你好
        print(f{name}，你好！) #输出结尾无空格
        #print({}，你好！.format(name)) #这样输出头歌编译过不了

    #遍历输出，观察结果

#调用say_hi_multi_parameter并传入参数
if __name__ == 	__main__	:
    say_hi_multi_parameter(names) #此处用print最后会多个one
#因为print()函数无论如何会返回一个值，当引用的函数没有return,print()

MIke Herry Helen James
MIke，你好！
Herry，你好！
Helen，你好！
James，你好！

7，字典的添加修改删除√

# coding=utf-8

# 创建并初始化menu_dict字典
menu_dict = {}
while True:
    try:
        food = input()#输入字符串
        price = int(input())#输入整型，如果输入了浮点会报错KeyError
        menu_dict[food]= price
    except:
        break

# 请在此添加代码，实现对menu_dict的添加、查、修改等操作，并打印输出相应的值
menu_dict[lamb] = 50
print(menu_dict[fish])
menu_dict[fish] = 100
del menu_dict[noodles]
print(menu_dict)

noodles
65
fish
0
beef
190
^Z
0
{	fish	: 100, 	beef	: 190, 	lamb	: 50}

 ctrl  Z再回车输出

8， 字典遍历，键与值√

# coding=utf-8

# 创建并初始化menu_dict字典
menu_dict = {}
while True:
    try:
        food = input()
        price = int(input())
        menu_dict[food]= price
    except:
        break

# 请在此添加代码，实现对menu_dict的遍历操作并打印输出键与值
for key in menu_dict.keys():
    print(key)
for value in menu_dict.values():
    print(value)

fish
5
apple
7
banana

beef
55
^Z
fish
apple
banana
beef
5
7

55

 输入完后换行，ctrl  z回车输出

9， 字典通讯录search√

def menu(): #三个单引号允许字符串跨多行使用  print开头带个换行，符合题目
    print(			\n欢迎使用PYTHO学生通讯录
1：添加学生
2：删除学生
：修改学生信息
4：搜索学生
5：显示全部学生信息
6：退出并保存			) #而且里面自带换行，但是1:... 2:..这些都得顶格，否则输出也空几个格

dict1 = {	张自强	:[	12652141777	,	材料	],	帅哥	: [	1488240417	, 	自动化	],	美女	: [	1127729147	, 	文法	]}
print(dict1)
menu()
n = int(input())
if n == 4: #易错点:o Record和Error的位置易错
    name = input() #如果有其他数字选项输入，无需读入姓名，直接输出ERROR，name输入的位置在if n == 4:后,审题很重要
    if name in dict1.keys():
        print(name,end = 	 	)#end = 	 	表示空格，而后面直接		表示换行
        print(dict1[name][0],end = 	 	)#dict1[name]就是值，而值是个列表，所以dict1[name][0]表示值的第一个元素
        print(dict1[name][1],		)#dict[name][1]表示值的第二个元素
        print(	Success	)
    else:
        print(	o Record	)
    print(dict1)

else:
    print(	ERROR	)

{	张自强	: [	12652141777	, 	材料	], 	帅哥	: [	1488240417	, 	自动化	], 	美女	: [	1127729147	, 	文法	]}

欢迎使用PYTHO学生通讯录
1：添加学生
2：删除学生
：修改学生信息
4：搜索学生
5：显示全部学生信息
6：退出并保存
4
美女
美女 1127729147 文法
Success
{	张自强	: [	12652141777	, 	材料	], 	帅哥	: [	1488240417	, 	自动化	], 	美女	: [	1127729147	, 	文法	]}

10, 字典通讯录modify，不同类型输入检验√

def menu():
    print(			\n欢迎使用PYTHO学生通讯录
1：添加学生
2：删除学生
：修改学生信息
4：搜索学生
5：显示全部学生信息
6：退出并保存			)
dict1 = {	张自强	: [	12652141777	, 	材料	], 	庚同硕	: [	1488240417	, 	自动化	], 	王岩	: [	1127729147	, 	文法	]}
print(dict1)
menu()

n = int(input())
if n == :
    name = input() #不要缩进两次,会报错
    if name in dict1.keys():
        dict1[name] = [input(),input()] #换行输入
        print(	Success	)
    else:
        print(	o Record	)
    print(dict1)
else:
    print(	ERROR	)

{	张自强	: [	12652141777	, 	材料	], 	庚同硕	: [	1488240417	, 	自动化	], 	王岩	: [	1127729147	, 	文法	]}

欢迎使用PYTHO学生通讯录
1：添加学生
2：删除学生
：修改学生信息
4：搜索学生
5：显示全部学生信息
6：退出并保存

张自强
000111001010
软件工程
Success
{	张自强	: [	000111001010 	, 	软件工程	], 	庚同硕	: [	1488240417	, 	自动化	], 	王岩	: [	1127729147	, 	文法	]}

11， 字典，键盘输入键值与字典相联系√

n = int(input())
name = input().split(	,	)#逗号间隔输入的字符串
number = input().split(	,	)
zidian = dict(zip(name,number)) #此处将键和值的键盘输入联系在一起
 #zip()函数将第i个元素组合在一起
 # 字典dict,元组tuple,列表list，相互转化后加()和名称即可

for i in range(n):#输入7次
    Input = input().split()#空格间隔输入
    if Input[0] == 	key	:
        print(list(zidian.keys())) #key输出方式记熟
    elif Input[0] == 	value	:
        print(list(zidian.values())) #value输出方式记熟
    elif Input[0] == 	print	:
        print(zidian)
    elif Input[0] == 	clear	:
        ()
    elif Input[0] == 	add	:
        zidian[Input[1]] = Input[2]
    elif Input[0] == 	update	:
        zidian[Input[1]] = Input[2]#这里好像没体现update和add的区别
    elif Input[0] == 	del	:
        if Input[1] not in zidian: #不是Input[0]而是[1]
            print(	键不存在	)
        else:
            del zidian[Input[1]]

7
Mike,Alley,Ally,Jams
250b,60q,210a,r
print
{	Mike	: 	250b	, 	Alley	: 	60q	, 	Ally	: 	210a	, 	Jams	: 	r	}
key
[	Mike	, 	Alley	, 	Ally	, 	Jams	]
value
[	250b	, 	60q	, 	210a	, 	r	]
clear
add MrLiu 99a
update MsYang 666
print
{	MrLiu	: 	99a	, 	MsYang	: 	666	}

12， 正整数分解质因数，map()√

# coding=utf-8

# 输入一个正整数
x = int(input())
y = x
result = []
# 下列代码还需要在到最小质因数后，跳出当前，进行下一次质因数的寻
while y > 1: #用>0会出现死循环，y最后会一直为1，所以自己草稿纸上试一遍
    for i in range(2,y  1): #考虑到没有质因数，只能本身的情况，所以y  1
        if y % i == 0:
            y = y // i # //和/相比，可以去掉小数点后0
            result.append(str(i))# 把i转换成str,存到列表,便于后面用join拼接字符串列表
            break #跳出for循环
sorted(result)#从小到大排序

# 输出结果，利用map()函数将结果按照规定字符串格式输出
if len(result) == 1:#如果列表只有一个元素
    print(x,	=	,x)
else:
    print(x,	=	,	*	.join(map(str,result))) #map()两参数，一个是function函数，一个是一个或多个序列
    #	*	.join(map(str,result))表示用*将result列表中的元素按字符串的格式连接起来

65
65 = 5*1
1000
1000 = 2*2*2*5*5*5
992
992 = 2*2*2*2*2*1

 上述代码如果将第1行的break改为continue会出现这样的情况

100
100 = 2*5*10

continue是跳出该次循环，比如for(int i = 0; i < 10; i)如果i = 7时遇到continue，就不执行该次循环continue后的代码，跳到i继续下一次

而break是跳出整个for循环，需要注意的是，在嵌套循环中，比如个for嵌套，只会跳出最内层，也就是最近的for 

1, 列表字典嵌套√

# coding=utf-8

# 初始化menu1字典，输入两道菜的价格
menu1 = {}
menu1[	fish	]=int(input())
menu1[	pork	]=int(input())

# menu_total列表现在只包含menu1字典
menu_total = [menu1]#初始化声明

# 请在此添加代码，实现编程要求
menu2 = {} #记得要声明
menu2[	fish	] = menu1[	fish	] * 2
menu2[	pork	] = menu1[	pork	] * 2
menu_total = [menu1,menu2]

print(menu_total)

102
51
[{	fish	: 102, 	pork	: 51}, {	fish	: 204, 	pork	: 102}]

14， 无穷算圆周率√

莱布尼茨无穷级数公式：π/4 = 1 - 1/  1/5 - 1/7  1/9 ... 

			
使用无穷级数这个公式计算π值，输入一个小数作为阈值，当最后一项的绝对值小于给定阈值时停止计算并输出得到的π值
			
def no_limited(Float):#参数要有
    接收用户输入的浮点数阈值为参数，返回圆周率值
    #===================Begin====================================
    Sum = 1#初始化不要漏
    n = 1
    from decimal import Decimal #提升计算精度，虽然这个代码里没点用
    while True:
        a = 1 / (4 * n - 1)
        b = 1 / (4 * n  1)
        if Float >= a:
            break
        Sum -= a
        if Float >= b:
            break#1，血泪教训，Sum -= 和 Sum = 要放在对应的if后，否则就会出现多加一次的情况，白白浪费半小时
        Sum = b
        n = 1
    return Sum * 4

if __name__ == 	__main__	:
    Float = float(input())#直接Float = input()是字符串输入，要注意
    SUM = no_limited(Float)
    print({:.8f}.format(SUM))  #保留小数点后八位

0.1
.968254 

0.0000001
.14159245

15， 输入问题1√


输入半径计算圆的周长和面积



import math
r = float(input())#如果不加float，单纯input()，会默认为字符串，容易和后续其他类型冲突，解决1：输入这里加float，解决2：后续加上float()等

circle = 2.0 * math.pi * r
area = math.pi * r * r
print(周长: {:.2f}.format(circle))
print(面积: {:.2f}.format(area))

11.2
周长: 70.7
面积: 94.08

16， 十进制转其他，函数√

def transfer(n,num):# n转换的进制，num十进制正整数
    k = 		# 初始化字符串k
    ###########   Begin  ################
    if(n == 2):
        s = list(bin(num))# unexpected indent为缩进错误
        for i in s[2:]:
            k = k  i# 实现字符的连接
        return k
    elif(n == 8):
        s = list(oct(num))# 直接输出s，二进制前会有0b，八进制0o，十六进制0x
        for i in s[2:]: # 所以从第三个元素开始连接保存下来
            k = k  i
        return k 
    elif(n == 16):
        s = list(hex(num))
        for i in s[2:]:
            k = k  i
        return k.upper()# .upper()将字符串中的小写转换成大写，使16进制中字母均为大写

if __name__==	__main__	:
    n=int(input())
    num=int(input())
    result=transfer(n,num)
    print(result)
# 十进制decimal system, 二进制binary system, 八进制Octal, 十六进制Hexadecimal

2
120
1111000

8
120
170

16
120
78

17， 存款买房-C√


假设你每个月都是月初发工资，同时会收到上一个月的存款利息。假设所需的首付款百分比为0.0（0%），
存款年利率interest_rate 为2.25%（固定），每半年即 6个月 加一次薪水，修改你的程序，计算存够首付需要多少个月。
你的程序要给出以下提示并要求用户输入相应的数值：
1. 请输入总房价：total_cost
2. 请输入年薪：annual_salary
. 请输入月存款比例：portion_saved
4. 每半年加薪比例：semi_annual_raise
5. 请输入存款年利率：
测试用例：
请输入总房价：1000000
请输入年薪：156800
请输入月存款比例：60
请输入加薪比例：7
输出：需要2 个月可以存够首付

total_cost,annual_salary,portion_saved,semi_annual_raise = 0.00,0.00,0.00,0.00
total_cost = float(input())         # total_cost为当前房价
annual_salary = float(input())        # 年薪
portion_saved = float(input()) / 100  # 月存款比例，输入0转为0%
semi_annual_raise = float(input()) /100     # 输入每半年加薪比例，输入7转化为7%
 
portion_down_payment = 0.      # 首付比例，浮点数
down_payment = portion_down_payment * total_cost   # 首付款
print(	首付	,down_payment)#2，它本身格式没说清楚，这里“首付”后没空格
 
current_savings = 0       # 存款金额，从0开始
number_of_months = 0      # 要存款的月数
#####################################Begin############################################
#补充你的代码
# 计算多少个月才能存够首付款，结果为整数，不足1月按1个月计算，即向上取整
monthly_saved = annual_salary / 12 * portion_saved #月存款
while current_savings < down_payment:
    number_of_months = 1
    if number_of_months % 6 == 0:
        monthly_saved *= (1  semi_annual_raise) #涨薪的同时，月存款也增加相应比例
    current_savings = current_savings * (1  0.0225 / 12)  monthly_saved#1，漏了本金，current_saved要乘多1
    #，而且，为什么每12个月存款一直少一点呢，因为当前存款算式的位置不对，不要放在number_of_months后，要放在第一个if后。。这逻辑很混乱，应该是题目没讲清楚
    if number_of_months % 12 == 0:
        print(第{}个月月末有{:,.0f}元存款.format(number_of_months,current_savings))
 
 
######################################End#############################################
 
print(f	需要{number_of_months}个月可以存够首付	)

输入输出

0000
111000
55
7.6
第12个月有64,821元存款
第24个月有141,44元存款
第6个月有21,446元存款
第48个月有7,07元存款
第60个月有461,445元存款
第72个月有606,78元存款
第84个月有776,699元存款
第96个月有975,111元存款
需要98个月可以存够首付

1200000
111000
55
7.6
首付 60000.0
第12个月月末有64,821元存款
第24个月月末有141,44元存款
第6个月月末有21,446元存款
第48个月月末有7,07元存款
需要51个月可以存够首付

 所以说，刚毕业拿着9000月薪，不如在宜居的四五线买房，4年首付就够了，不是非得在一线凑个10年才把首付凑齐，再还债20年才还完的

下面是更简洁的代码（重新敲了一遍）

t, a, p, s = 0, 0, 0, 0 # t总房价，a年薪，p月存款比例，s半年加薪比例
t = float(input())
a = float(input())
p = float(input()) / 100 # 除以100转化成百分比
s = float(input()) / 100

mon_s = a / 12 * p # mon_s月存款
first_p = t * 0. # first_p首付款
current_s = 0 #当前存款
months = 0 #需要存款月数
while current_s < first_p: #当前存款小于首付款
    months = months  1
    if months % 6 == 0:
        mon_s = mon_s * (1  s) #月存款随着每半年涨薪s也涨了
    current_s = current_s * (1  0.0225 / 12)  mon_s # 注意先当前总存款*(1  月利率)，再月存款
    if months % 12 == 0:
        print(第{}个月有{:,.0f}元存款.format(months, current_s))

print(f	需要{months}个月可以存够首付	)

18， 蒙特卡洛（随机数法）算圆周率√

原理

在正方形内部，随机产生n个点，计算点与中心点距离是否大于圆的半径，以此判断是否落在圆内部，设a为落在园内点数，b为正方形内点数（即产生点的总数）a / b ≈ 圆的面积 / 正方形面积，

∴ a / b ≈ (pi * 1 * 1) /  (2 * 2) = pi / 4, ∴ pi = 4 * (a / b)

代码 

import random

def monte_carlo_pi(num):
    接收正整数为参数，表示随机点的数量，利用蒙特卡洛方法计算圆周率
    返回值为表示圆周率的浮点数
    #====================Begin===================================
    # 补充你的代码
    hits = 0.0
    for i in range(times):
        x,y = random.uniform(-1,1),random.uniform(-1,1)
        length = pow(x ** 2  y ** 2, 1 / 2)
        if length < 1:
            hits = 1
    Pi = 4 * hits / times
    return Pi #1,random.uniform(a,b)返回[a,b]之间随机浮点数，示例如下：import random
    #print(random.uniform(50,100))

    #2，random补充：random.random()返回0与1之间随机浮点数
    #，random补充：random.randint(a,b)返回随机整数，a <=  <= b
    

if __name__ == 	__main__	:
    sd = int(input())             #读入随机数种子
    random.seed(sd)               #设置随机数种子
    times = int(input())          # 输入正整数，表示产生点数量
    print(monte_carlo_pi(times))  # 输出圆周率值，浮点数

输入输出

666
10000
.1284

2
1000000
.14464

19， 梅钦（马青）法算圆周

			
利用梅钦公式计算圆周率的大小
			
import math


def machin_of_pi():
    用梅钦级数计算圆周率，返回圆周率值
    #################Begin####################################
    
    pi = 0.00
    for i in range(20):
        pi = 10 ** 16 * (-1) ** i * 4 / (2 * i  1) * (4 / 5 ** (2 * i  1) - 1 / 29 ** (2 * i  1))
    #1，一个确保精度（小数点后正确位数满足题目）的方法，计算小数点后7位，就计算pi * 10^7,最后再缩小10^7倍即可

    #################End####################################
    return pi / (10 ** 16)
    
if __name__ == 	__main__	:
    cal_pi = machin_of_pi()  # 调用判断类型的函数
    print(cal_pi)            # 输出函数运行结果

.14159265589796

20， 列表最基本操作√

#List.append(), List.insert(index,元素), del List[index], 
#List.pop(index), List.remove(obj), 
#index即下标索引
List = []
while True:
    try:
        a = input()
        List.append(a)
    except:
        break

dele = List.pop()
List.insert(2,dele)
del List[1]
print(dele)
print(List)

输入输出

1qq
2qq
qq
4qq
5qq
^Z
5qq
[	1qq	, 	5qq	, 	qq	, 	4qq	]

 输入完child后回车，ctrl，z一起按，再回车

21， 列表转元组√

# coding=utf-8

# 创建并初始化menu_list列表
menu_list = []
while True:
    try:
        food = input()
        menu_list.append(food)
    except:
        break

# 请在此添加代码，对menu_list进行元组转换以及元组计算等操作，并打印输出元组及元组最大的元素
menu_tuple = tuple(menu_list) #转换成元组，前面还有个变量名，
#不是.函数的，不能直接转换
print(menu_tuple)
print(max(menu_tuple))

输入输出

1qq
2qq
qq
4qq
5qq
^Z
(	1qq	, 	2qq	, 	qq	, 	4qq	, 	5qq	)
5qq

22， 列表输出问题1√

一些物品，不知道有多少个，个个数的话，还多出2个；5个5个数则多出个；
7个7个数也会多出2个。输入一个正整数，从小到大依次输出所有不超过输入数字
且满足条件的物品数量，有多个答案时每行输出一个。
例如输入：200
输出：
2
128

n = int(input())
L = []
##############Begin#####################
Sum = 0
for i in range(10,n1):
    if i% == 2 and i%5== and i%7==2:
        Sum = 1
        L.append(i)
if not Sum:
    print(o solution!)
else:
    for i in L:
        print(i)#此处是print(i)而不是print(L[i])

输入输出1
100
2

输入输出2
200
2
128

2， 列表删除数据（巨坑）√

ls_1 = list(map(int,input().split())) # 2，键盘输入列表元素的方法，熟记
n = int(input())#要删除的元素
if n not in ls_1:
    print(OT FOUD)
else:
    for i in range(len(ls_1)-1,-1,-1): # 1，反向检索元素的值，避免正向检索产生out of range，熟记
        if ls_1[i] == n:
            ls_1.remove(n)
    print(ls_1)

输入输出

4 4 56  77 8 8   4  2 2 2   4 56
4
[56, 77, 8, 8, 4, , 2, 2, 2, , 4, 56]

24， 列表去重√

#coding=utf-8
menu = list(input().split(,))#不要用while: True,否则
#不符合输入逗号间隔的形式


res=[]
for i in menu:
    if i not in res:
        res.append(i)
print(res)

输入输出

ak,oj,leetcode,ak,ak,ak,666,2,2
[	ak	, 	oj	, 	leetcode	, 	666	, 	2	]

25， 列表切片√

menu = []
while True:
    try:
        food = input()
        menu.append(food)
    except:
        break
length = len(menu)
print(menu[-:])
print(menu[0:length:])

因为是字符串，输入完后，回车，再Ctrl  z  回车，即可输出
如果改成int, 就是food = int(input()),最后回车两次即可输出
输入输出

fish
pork
wolf
wife
wifi
chicken
^Z
[	wife	, 	wifi	, 	chicken	]
[	fish	, 	wife	]
或者
1
2

4
5
6
7
^Z
[	5	, 	6	, 	7	]
[	1	, 	4	, 	7	]

如果想以空格间隔在同一行输入，那就得只能改数字且看代码形式

menu = list(map(int, input().split()))
length = len(menu)
print(menu[::])
print(menu[-:])

输入输出

1 2 4 6 7 88 2 1 5
[1, 6, 2]
[2, 1, 5]

26， 列表嵌套字典排序√

n = int(input())
list1 = []

for i in range(n):
    name,age = input().split() #新方法：输入如Tom 18的字符串
    dict1 = {	name	:name,	age	:int(age)} #直接构造的方法;这里要用int(age)
    list1.append(dict1) #得到一个元素为字典的列表
list2 = sorted(list1,key = lambda x:x[	age	]) #lambda新方法，lambda x:x[1]按二维列表第二个元素的ASCII值排序
list = sorted(list1,key = lambda x:x[	name	]) #而lambda x:x[	键	]可以按列表嵌套字典中对应键的值排列
print(list2)
print(list)

输入输出

5
Tom 18
MIke 12
Ton 18
Tomm 18
Ally 19
[{	name	: 	MIke	, 	age	: 12}, {	name	: 	Tom	, 	age	: 18}, {	name	: 	Ton	, 	age	: 18}, {	name	: 	Tomm	, 	age	: 18}, {	name	: 	Ally	, 	age	: 19}]
[{	name	: 	Ally	, 	age	: 19}, {	name	: 	MIke	, 	age	: 12}, {	name	: 	Tom	, 	age	: 18}, {	name	: 	Tomm	, 	age	: 18}, {	name	: 	Ton	, 	age	: 18}]

27， 列表合并与降序（键盘输入）√

list1 = list(map(int,input().split())) #2，map的第一个参数是函数，第二个
从参数是序列
list2 = list(map(int,input().split()))
list1 = list2
list1.sort(reverse = True)#1,reverse不要漏，不要只打出来True
print(list1)

输入输出

7 71 -5 66 1999 1024
520 99 114
[1999, 114, 1024, 520, 99, 7, 71, 66, -5]

28， 列表的增删改√

# coding=utf-8

# 创建并初始化Guests列表
guests = []
while True:
    try:
        guest = input()
        guests.append(guest)
    except:
        break

# 请在此添加代码，对guests列表进行插入、删除等操作
deleted_guest = guests.pop(-1)
guests.insert(2,deleted_guest)
del guests[1]
print(deleted_guest)
print(guests)

输入输出

2qq  
1qq
qq
6qq
5qq
^Z
5qq
[	2qq	, 	5qq	, 	qq 	, 	6qq	]

29， 列表的属性（输入检测）√

#coding=utf-8

#List.remove(	值	)  
List = []
n = int(input())

for i in range(n):
    Listinput = input().split()#作为输入的检测
    operate = Listinput[0] #检测每次循环第一次输入是否为题目要求的条件
    if operate == 	insert	:#直接用单引号引起来的字符串表示
        List.insert(int(Listinput[1]),int(Listinput[2]))#两个整数的输入要加int
    elif operate == 	remove	:
        List.remove(int(Listinput[1]))
    elif operate == 	append	:
        List.append(int(Listinput[1]))
    elif operate == 	sort	:
        List.sort()
    elif operate == 	pop	:
        List.pop()
    elif operate == 	reverse	:
        List.reverse()
    elif operate == 	print	:
        print(List)

15
append 4
append -9
append 85
print
[4, -9, 85]
insert 2 0
remove -9
sort
print
[0, 4, 85]
append 890
append 2
print
[0, 4, 85, 890, 2]
pop
reverse
print
[890, 85, 4, 0]
print
[890, 85, 4, 0]

0， 集合，键盘输入判断后续操作

n = int(input())
name = input() #但注意name和myset的输入，split只能出现一次
myset = set(name.split()) #这样可以把空格隔开的中文加入集合
    
for i in range(n):
    lp = input().split() #还有，设lp，意味着list_input,尽量不要写太复杂的名称，影响思路
    if lp[0] == 	print	:
        list_myset = sorted(list(myset)) #这里有问题，不要用 = list(myset).sort(),非常混乱，除非你分开
        print(list_myset)
    elif lp[0] == 	del	:
        myset.remove(lp[1])
    elif lp[0] == 	clear	:
        ()
    elif lp[0] == 	add	:
        myset.add(lp[1])
    elif lp[0] == 	update	:
        myset.update(lp[1:])

6
吴亦凡 陈伟霆 李嘉欣 刘德华 周星驰 吴彦祖
print
[	刘德华	, 	吴亦凡	, 	吴彦祖	, 	周星驰	, 	李嘉欣	, 	陈伟霆	]
del 周星驰
add 大哥
print
[	刘德华	, 	吴亦凡	, 	吴彦祖	, 	大哥	, 	李嘉欣	, 	陈伟霆	]
update Gaga 朋友 美女
print
[	Gaga	, 	刘德华	, 	吴亦凡	, 	吴彦祖	, 	大哥	, 	朋友	, 	李嘉欣	, 	美女	, 	陈伟霆	]

1， 回文素数

输入一个正整数，输出小于这个数的所有回文素数

import math
def is_prime(n):
    判断素数的函数,接收一个正整数为参数，参数是素数时返回True，否则返回False。减小判定区间，减少循环次数，提升效率
    #======================Begin=================================
    # 补充你的代码
    #=========================End==============================
    a = True
    if n == 1:
        a = False
    for i in range(2,int(math.sqrt(n))  1): #这里的int不要老漏
        if n % i == 0:
            a = False
    return a


def plalindrome_prime(number):
    接收一个正整数参数number，遍历从0到number之间的所有整数，
    若某个数是素数，且转为字符串后是回文字符串，则称其中回文素数
    出并在同一行中输出小于number的所有回文素数，每个数字后一个空格，函数无返回值。
    #======================Begin=================================
    for i in range(2,number):
        if is_prime(i):
            b = str(i)
            reverse_b = b[::-1] #逆序输出字符串，表示b[-1:-len(a)-1:-1],包左不包右
            if b == reverse_b:
                print(b,end = 	 	)
                        


    #=========================End==============================


positive_int = int(input())         
plalindrome_prime(positive_int)      

565
2  5 7 11 101 11 151 181 191 1 5 7 8

 2，回车结束输入

list = [] #先声明列表不可少
while 1:
    li = input().split()#1，当类型冲突时，不要规定类型，直接li = input()  
    if len(li) == 0: #4，血的教训：不要用if li == ,要记熟if len(li) == 0  break,这才是回车结束输入的正确方式
        break # ,回车结束输入
    else:
        list.append(li) #2，这个形式要记住，列表名.append(input的变量名)
list_1 = sorted(list,key = lambda x:float(x[1][:-1])*1000 if x[1][-1] == 	t	 else float (x[1][:-2]))
print(list_1)

鸽子 kg
河马 0.9t
帅哥 70kg
师傅 90kg

[[	鸽子	, 	kg	], [	帅哥	, 	70kg	], [	师傅	, 	90kg	], [	河马	, 	0.9t	]]

 

， 个人所得税

用户输入应发工资薪金所得、五险一金金额和个税免征额，输出应缴税款和实发工
    结果保留小数点后两位。当输入数字小于0 或等于0 时，输出“error”。
    实发工资 = 应发工资 - 五险一金 - 个人所得税
    建议使用以下变量名：
    salary：每月应发工资薪金
    insurance_fund：五险一金
    exemption：个税免征额
    educted_amount：速算扣除数
    测试用例
    输入（冒号前是提示性文字，冒号后的数字为用户输入）
    请输入应发工资薪金金额：16000
    请输入五险一金金额：4000
    请输入个税免征额：5000
    输出
    应缴税款490.00 元，实发工资11510.00 元。
    
    # ====================Begin===================================
def income_tax():
    salary,insurance_fund,exemption = 0.00,0.00,0.00
    salary = float(input())#关键1：浮点数未初始化
    insurance_fund = float(input())
    exemption = float(input())
    if salary <= 0 or insurance_fund <= 0 or exemption <= 0:
        print(error)
    tax_forehead = salary - insurance_fund - exemption
    tax = 0.00
    if tax_forehead <= 000 and tax_forehead > 0:#最开始漏了一种小于0的条件，所以初始应声明加初始化为0，减少出错率
        tax = tax_forehead * 0.0 - 0
    elif tax_forehead <= 12000 and tax_forehead > 000:
        tax = tax_forehead * 0.10 - 210
    elif tax_forehead <=25000 and tax_forehead > 12000:
        tax = tax_forehead * 0.20 - 1410
    elif tax_forehead <=5000 and tax_forehead > 25000:
        tax = tax_forehead * 0.25 - 2660
    elif tax_forehead <= 55000 and tax_forehead > 25000:
        tax = tax_forehead * 0.0 - 4410
    elif tax_forehead <=80000 and tax_forehead > 55000:
        tax = tax_forehead * 0.5 - 7160
    elif tax_forehead > 80000:
        tax = tax_forehead * 0.45 - 15160
    true_salary = salary - tax - insurance_fund;#关键2：同时要注意，你把过程想复杂了，直接拿tax_forehead * 相应的税率即可
    print(应缴税款{:.2f}元，实发工资{:.2f}元。.format(tax,true_salary))#改动
if __name__ == __main__:
        income_tax()#关键：这步要记熟
    # ======================End=================================
    # 调用函数完成计算和输出

1000
2100
500
应缴税款50.00元，实发工资1070.00元。

 

4， 割圆术

			
编程实现割圆法计算圆周率，并输出分割不同次数时边数、圆周率值以及计算所得圆周率值与math库中的圆周率值的偏差。
			

import math

def cutting_circle(n):      # n为分割次数
    接收表示分割次数的整数n为参数，计算分割n次时正多边形的边数和圆周率值，返回边数和圆周率值
    x = 1  # 初始边长
    sides = 6  # 初始边数
    #######################Begin############################
    # 补充你的代码
    def length(x):#由当前边长计算下一边长
        h = 1 - math.sqrt(1 - (x / 2)**2)#2，python中多少次方用**表示
        return math.sqrt(h**2  (x / 2)**2)#，math.sqrt可算平方根，pow可算其他的
    for i in range(n): #函数最后只能return一个参数
        sides *= 2    #当前边数
        x = length(x) #当前边长
        pi = x * sides
    
    ########################End###########################
    return pi / 2#4，注意初始条件，半径为1，所以圆初始周长近似于2 * .14 * 1，所以要除以2

if __name__ == 	__main__	:
    times = int(input())          # 割圆次数
    Sides = 6 * 2**times #format传参数时，一定要存在这个参数，不然报错
    Pi = cutting_circle(times)
    print(分割{}次，边数为{}，圆周率为{:.6f}.format(times,Sides,Pi))
    print(math库中的圆周率常量值为{:.6f}.format(math.pi))#1，不论千分位的逗号还是浮点数保留6位，大括号里的冒号:不可少

1
分割1次，边数为12，圆周率为.105829
math库中的圆周率常量值为.14159

5
分割5次，边数为192，圆周率为.141452
math库中的圆周率常量值为.14159

100
分割100次，边数为760590601697640898021922256，圆周率为.14159
math库中的圆周率常量值为.14159

 

5， 二维列表排序√

list1 = [(	dungeon	,7),(	winterfell	,4),(	bran	,9),(	meelo	,6)]
list2 =  [[ 	Angle	, 	0121701100106	,99], [ 	Jack	, 	0121701100107	,86], [ 	Tom	, 	0121701100109	,65], [ 	Smith	, 	0121701100111	, 100], [	Bob	, 	0121701100115	,77], [	Lily	, 	0121701100117	, 59]]
m = int(input())
n = int(input())
new_list1 = sorted(list1,key = lambda x:x[1],reverse = False) # 1,不要漏key
new_list2 = sorted(list2,key = lambda x:x[0],reverse = False) #5，此时的lambda用于对列表中所有元素排序的准则，此处：按第一个元素的ASCII值排序
new_list = sorted(list2,key = lambda x:x[2],reverse = False)
print(new_list1[:m]) #2，a[:n]取出列表的前n个元素，且当n > len(a)时不会报错
print(new_list2[:n]) #，用法补充：a[:-]取出a从第0个到倒数第三个元素之前的元素
print(new_list[n:]) #4，补充：a[2:]取出第二个元素之后的元素，即从第三个开始取

输入输出 

2
[(	winterfell	, 4), (	meelo	, 6), (	dungeon	, 7)]
[[	Angle	, 	0121701100106	, 99], [	Bob	, 	0121701100115	, 77]]
[[	Bob	, 	0121701100115	, 77], [	Jack	, 	0121701100107	, 86], [	Angle	, 	0121701100106	, 99], [	Smith	, 	0121701100111	, 100]]

6， 二鼠打洞

有一堵十尺厚的墙，两只老鼠从两边向中间打洞。大老鼠第一天打洞一尺，小老鼠也是打洞一尺。
大老鼠每天的打洞进度是前一天的一倍，小老鼠每天的进度是前一天的一半。计算并输出它们几天可以相逢，
相逢时各打了多少尺。
输入格式：输入1 个整数，代表墙的厚度，单位为尺
输出格式：
第一行输出1 个整数，表示相遇时所需的天数
第二行输出2 个浮点数，分别为小鼠和大鼠打洞的距离，单位为尺，保留小数点后1 位数字。

n = int(input())
sMouse,sRat,dMouse,dRat = 1,1,0,0
day,time = 0,1#还是要声明的
#错误代码sMouse = 1, sRat = 1, dMouse = 0, dRat = 0, day = 1#小大鼠速度，小大鼠打洞距离
while n > 0:
    if n - sMouse - sRat < 0:#某一天打完
        time = n / (sMouse  sRat)#当天消耗时间
    n -= (sMouse  sRat)#不要漏
    dMouse = sMouse * time
    dRat = sRat * time
    sMouse /= 2
    sRat *= 2
    day = 1
print(day)
print({:.1f} {:.1f}.format(dMouse,dRat))

10
4
1.8 8.2

 

7， 存款买房-B

只有在第6、12、18……等月份时才加薪）。
写一个程序计算需要多少个月才能攒够钱付首付款。与之前一样，假设所需的首付款百分比为0.0（0%）。
你的程序要给出以下提示并要求用户输入相应的数值：
1. 请输入总房价：total_cost
2. 请输入年薪：annual_salary
. 请输入月存款比例：portion_saved
4. 每半年加薪比例：semi_annual_raise
测试用例
请输入总房价：1000000
请输入年薪：156800
请输入月存款比例：60
请输入加薪比例：7
输出：需要 个月可以存够首付

#2，简单的注释很重要，便于DEBUG和复盘
total_cost,annual_salary,portion_saved,semi_annual_raise = 0.00,0.00,0.00,0.00#1，初始化不能忘，习惯性初始化可以节省你十几个小时
total_cost = float(input())         # total_cost为当前房价
annual_salary = float(input())        # 年薪
portion_saved = float(input()) / 100  # 月存款比例，输入0转为0%
semi_annual_raise = float(input()) /100     # 输入每半年加薪比例，输入7转化为7%
portion_down_payment = 0.      # 首付比例，浮点数
down_payment = total_cost * portion_down_payment
print(	首付 %.1f	%down_payment)
current_savings = 0 # 存款金额，从0开始
number_of_months = 0
monthly_salary = annual_salary/12 #月工资
monthly_deposit = monthly_salary * portion_saved # 月存款
# 计算多少个月才能存够首付款，结果为整数，不足1月按1个月计算，即向上取整                                                             
while current_savings < down_payment:
    current_savings = monthly_deposit
    number_of_months = 1       
    if number_of_months % 6 == 0:
        monthly_deposit *= (semi_annual_raise  1.00)                                        
    if number_of_months % 12 == 0:
        print(第{}个月月末有{:,.0f}元存款.format(number_of_months, current_savings))#4，s = {:,}.format(1000000),可以给数字加千位符--->所以还得系统记忆下新函数的用法，CSD的就行;;;然后。.0f表示保留0位小数点


print(f	需要{number_of_months}个月可以存够首付	)#，记熟如此输出没有空格

220000
50000
60
20
首付 966000.0
第12个月月末有21,000元存款
第24个月月末有56,640元存款
需要5个月可以存够首付

 

 8，try, except

def Div(x,y):
    try:
        n = x / y
        print(n)
    except:
        print(被0除！\none)



if __name__ == 	__main__	:
    x=int(input())
    y=int(input())
    Div(x,y)

6
1
2.7692076920769

 

9, 计算三角形面积

import math
def area(a,b,c):#利用海伦公式的半周长p，以及try,except
    try:
        p = (a  b  c) / 2#如果三角形不存在，p-某边会出现<=0情况
        s = math.sqrt(p*(p-a)*(p-b)*(p-c))#注意是连续*
    except:
        print()#except:后面跟什么好像和输出都没关系
    return s


if __name__==	__main__	:
    a,b,c=eval(input())
    k = area(a,b,c)
    if(k > 0):
        print({0:.f}.format(area(a,b,c)))
    else:
        print(出现如下问题： 数据错误，不能构成三角形\n0.000)

12,6,18
出现如下问题： 数据错误，不能构成三角形
0.000

,5,7
6.495

 

40， 保留多少位小数

# coding=utf-8

from math import pi as PI

n = int(input())

# 请在此添加代码，实现圆的面积计算，并输出面积结果
area = PI * n ** 2
print(	%.2f	%area) #python保留多少位小数输出，注意中间不要逗号，有两个百分号

4
50.27

 

41， list基础√

#List.append(), List.insert(index,元素), del List[index], 
#List.pop(index), List.remove(obj), 
#index即下标索引
List = []
while True:
    try:
        a = input()
        List.append(a)
    except:
        break

dele = List.pop()
List.insert(2,dele)
del List[1]
print(dele)
print(List)

42， list(range())√

# coding=utf-8

# 创建并读入range函数的相应参数
lower = int(input()) #下限整数
upper = int(input()) #上限整数
step = int(input()) #间隔步长

# 请在此添加代码，实现编程要求
data_list = list(range(lower,upper,step))
length = len(data_list)
difference = max(data_list) - min(data_list)
print(data_list)#输出列表
print(length)#列表元素个数
print(difference)#最大最小值差值

输入输出

2
1

[2, 5, 8, 11]
4
9

4, lambda使用

# coding=utf-8
a = int(input())
b = int(input())

# 请在此添加代码，使用lambda来创建匿名函数，能够判断输入的两个数值的大小
MAXIMUM = lambda a,b:max(a,b)
MIIMUM = lambda a,b:min(a,b) #注意lambda后不需要要括号	()	


# 输出较大的值和较小的值
print(	较大的值是：%d	 % MAXIMUM(a,b))
print(	较小的值是：%d	 % MIIMUM(a,b))

-99
17
较大的值是：17
较小的值是：-99

45， assert()

def mysum(x):
    Sum = 0
    try:
        for i in range(1,x1):
            Sum = 1 / i
        assert(Sum >= 1)#注意assert()的位置
    except:
        print(出现了问题... n必须是正整数)
    else:
        print(一切正常...)
    return Sum

########## End ##########


if __name__ == 	__main__	:
    x=eval(input())
    print(mysum(x))

2
一切正常...
1.5

10
一切正常...
2.92896825968258

 

46, 递归函数求阶乘

# coding=utf-8

# 输入正整数n
n = int(input())

# 请在此添加代码，对输入的正整数n进行阶乘运算，并输出计算结果。
def fact(n):
    if n == 0:
        return 1
    else:
        return n * fact(n - 1) #递归函数方法
print(fact(n)) #输出别忘了

5
120

 

47，迭代器基本操作

List = []#创建一个空列表
member = input()#读取键盘输入的成员
for i in member.split(	,	):#循环遍历用“，”分隔成员
    result = i#分隔后的元素保存到result中
    List.append(result)#把成员元素添加到list列表中
#请在此添加代码，将List转换为迭代器的代码
#********** Begin *********#
Iteralist = iter(List)
#********** End **********#
while True:
    try:
        #请在此添加代码，用next()函数遍历IterList的代码

        num = next(Iteralist)#遍历到Iteralist元素

        result = int(num) * 2#Iteralist元素乘2保存到result中
        print(result)
    except StopIteration:
        break

6,7,19,21,4
12
14
8
42
68

 

 48，定义类Animal

 ########## Begin ##########
class Animal:
    def __init__(self,name,kind):
        self.__name = name
        self.__kind = kind
    @property#把下方的方法都变成了静态属性
    def getame(self):
        return self.__name
    def getKind(self):
        return self.__kind
    def changeKind(self,kind):
        self.__kind = kind
    def delKind(self):
        del self.__kind
    KID = property(getKind,changeKind,delKind,动物类别)
 #property()把方法变成静态属性

if __name__ == 	__main__	:
    a1 = Animal(parrot,bird)
    #print(a1.getame)#注意字母大小写，静态属性引用不许需要()
    print(a1.getame)#对象名.方法
    print(a1.KID)#对象名.属性
    a1.KID = Polytelis
    print(a1.KID)
    del a1.KID

parrot
bird
Polytelis

 

49，定义继承类Cat

 ########## Begin ##########
class Animal:
    def __init__(self,name,kind):
        self.__name = name
        self.__kind = kind
    @property#把下方的方法都变成了静态属性
    def getame(self):
        return self.__name
    def getKind(self):
        return self.__kind
    def changeKind(self,kind):#私有属性除了定义参数里，前面不加__,其他地方都要
        self.__kind = kind
    def delKind(self):
        del self.__kind
    KID = property(getKind,changeKind,delKind,动物类别)
    def talk(self):
        print(I can speak.)
    def myprint(self):
        print(name={0},kind={1}.format(self.__name,self.__kind))
 #property()把方法变成静态属性
class Cat(Animal):#python中缩进是常犯错误
    def __init__(self,name,kind,food,enemy):#这里要增加food和enemy两个属性
        super().__init__(name,kind)#实现子类与父类的联系，除了super().还可以Animal.  也就是父类名.__init__(self......)
        self.__food = food
        self.__enemy = enemy
    def talk(self):
        print(喵喵)
    def catprint(self):
        print(food={0},enemy={1}.format(self.__food,self.__enemy))
    def catchmouse(self):
        print(I catch a mouse.)#建议直接复制题目，比如这次漏了一个点
    def myprint(self):#函数后面必须带self
        (self)
        ()#子类本身的用self.函数(),父类中的用父类名.函数()这样的形式
    
    
        

if __name__ == 	__main__	:
    a1 = Animal(parrot,bird)
    #print(a1.getame)#注意字母大小写，静态属性引用不许需要()
    print(a1.getame)#对象名.方法
    print(a1.KID)#对象名.属性
    a1.KID = Polytelis
    print(a1.KID)
    del a1.KID

    a2 = Animal(octopus, fish)
    ()
    ()
#下面这行，通过子类Cat创建c1实例,参数可直接写在括号里面
    c1 = Cat(cat,feline,[fish,meat,milk,icecream],[老鹰,豹子])#这一行报错:missing four required positional arguments是因为调用时少了四个参数，要在括号中把参数加上
    ()
    ()
    ()
    ()
    

parrot
bird
Polytelis
I can speak.
name=octopus,kind=fish
喵喵
food=[	fish	, 	meat	, 	milk	, 	icecream	],enemy=[	老鹰	, 	豹子	]
name=cat,kind=feline
food=[	fish	, 	meat	, 	milk	, 	icecream	],enemy=[	老鹰	, 	豹子	]
I catch a mouse.

 

 50，代码的封装

# coding=utf-8

# 输入两个正整数a,b
a = int(input())
b = int(input()) #最大公约数你会了，最大公约*最小公倍=两数乘积

# 请在此添加代码，求两个正整数的最小公倍数
def _gcd(a,b): #private函数
    i = 1
    while(i > 0): #while也是需要冒号	:	的
        i = a % b
        if i == 0:
            return b
        elif i == 1:
            return 1
        else:
            a = b
            b = i
def lcm(a,b): #public函数
    PlusSum = int(a * b / _gcd(a,b))
    return PlusSum

# 调用函数，并输出a,b的最小公倍数
print(lcm(a,b))

14
21
42

 

51， 圆类

#测试代码：计算n个球体的表面积和体积之和，以及m个圆柱体的表面积和体积之和。
PI = .14
class Ball():
    def __init__(self,r):
        self.r = r
    def S(self):
        self.s = 4 * PI * r * r
        return self.s
    def V(self):#类中不加self的属性是全局的，不加self是本地变量，加self是实例变量
        self.v = 4 /  * PI * r * r * r
        return self.v

class Cylinder():
    def __init__(self,r,h):
        self.r = r
        self.h = h
    def S(self):
        self.s = PI * self.r * self.r * 2  PI * 2 * self.r * self.h
        return self.s
    def V(self):
        self.v = PI * self.r * self.r * self.h
        return self.v

if __name__==	__main__	:
    ls_ball=eval(input())  #以列表方式输入n个球的半径
    ls_cylinder=eval(input())  #以嵌套列表的方式输入m个半径和高
    #计算并输出n个球的表面积和体积之和，小数点保留2位
    s1 = 0
    v1 = 0
    s2 = 0
    v2 = 0
    for r in ls_ball:
        a = Ball(r)
        s1 = a.S()
        v1 = a.V() 
    print(球的表面积之和={:.2f} 球的体积之和={:.2f}.format(s1,v1))
    for i in ls_cylinder:
        b = Cylinder(i[0],i[1])
        s2 = b.S()
        v2 = b.V()

    print(圆柱体的表面积之和={:.2f} 圆柱体的体积之和={:.2f}.format(s2,v2))
    #计算并输出m个圆柱体的表面积和体积之和，小数点保留2位

[.,16,12,1]
[[1,12],[.2,5],[2,15]]
球的表面积之和=517.4 球的体积之和=2457.79
圆柱体的表面积之和=459.95 圆柱体的体积之和=86.85

 

52，文件

src/Step1, C:\Users\1\Desktop\python\src\Step1

hello,world
hello,Python
hello,man

人生苦短，要学Python21ekjkj

 文件.py

#coding=utf-8

#输入n
n = int(input())

with open(	src/Step1/	) as file_object:
    lines = file_object.readlines()

# 请在此添加代码，实现编程要求
#********** Begin *********#
i = 0
for line in lines:
    print(line.rstrip())
    i = i  1
    if i == n:
        break

文件2.py

#coding=utf-8

#输入字符串
s = input()

# 请在此添加代码，将字符串s输入到中
#********** Begin *********#
with open(	src/Step1/	,	a	) as example:
    example.write(s)

#********** End **********#

#输出中的内容
with open(	src/Step1/	,encoding = 	utf-8	) as file_object:
    lines = file_object.readlines()#注意，上面with open()中，最后不加encoding = 	utf-8	
for line in lines:#的话，打开的文件中有中文就会报错
    print(line.rstrip())#因为txt文件是utf-8编码，文本文件方式打开时，编码需转utf-8

 文件.py

			
1、使用open函数打开文件（src/step1/poit1）
2、使用read函数读出整个文件。
、输出所读文件内容。
4、关闭文件。
5、使用read函数读出文件的前10个字并输出。
6、返回文件头，读取一行并输出。
7、使用tell输出当前文件指针的位置。
8、定义一个字符串变量保存如下信息：‘人生苦短，要学Python’
9、以写方式打开一个文件，保存上述信息(src/step1/)。关闭该文件。
10、打开刚才保存的文件，使用readlines读出并输出文件内容。
			

#--------------------begin ------------------------
f1=open(	src/Step1/	,	r	,encoding=utf8)
fff = f1.read()
print(fff)#文件是流，读了一个就向前移动一个，如果想从头开始读，要么
#关闭了再开一次，要么f1.seek(0),移动到最开始的位置
()

f1=open(	src/Step1/	,	r	,encoding=utf8)
fff2 = f1.read(10)
print(fff2)
f1.seek(0)#移动到最开始的位置，不用关闭再打开
fff = f1.readline()
print(fff)
fff4 = ()
print(fff4)
()

fff5 = 	人生苦短，要学Python	
f2=open(	src/Step1/	,	w	,encoding=utf8)
f2.writelines(fff5)
()

f2=open(	src/Step1/	,	r	,encoding=utf8)
fff6 = f2.readlines()
print(fff6)

5，判断两文件是否相同

# 判断两个文件是否相同。要求用函数实现文件比较功能，在main函数中进行验证。
# 下述函数完成文件是否相同的比较功能
def compareFile(list1,list2):

    #请在此添加代码，实现文件是否相同的判断
    # 如果相等返回[1,0,0]
    # 如果不相等返回[0,a,b] a,b表示第一个不相等字符所在的行号和列号
    #********** Begin *********#
    len1 = len(list1)
    len2 = len(list2)
    minlen1 = min(len1,len2)#返回两个列表较小的行数作为循环次数
    for i in range(minlen1):
        if list1[i] != list2[i]:
            minlen2 = min(len(list1[i]),len(list2[i]))#返回出现不同的行数中，较小的列数;这行漏len(list1[i])的len了
            for j in range(minlen2):
                if list1[i][j] != list2[i][j]:
                    return [0,i1,j1]#记住主函数直接等于这里列表的方式
            else:#else两处缩进很重要
                return [0,i1,1]#此时只能是这一行长度不等
    else:
        if len1 != len2:
            return [0,minlen11,1]#i1,minlen11里的1容易漏
        else:
            return [1,0,0]

    #********** End *********#

# 定义函数main，完成文件名输入、比较函数调用和结果输出功能
def main():
    # 输入两个文件所在路径和文件名，如：d:\temp\
    str1=input(		)
    str2=input(		)
    #请在此添加代码，完成相应功能
    #********** Begin *********#
    file1 = open(str1,	r	)
    file2 = open(str2,	r	)#只读的方式打开文件
    #用readlines方法把文件读入一个列表对象
    isfile1 = file1.readlines()
    isfile2 = file2.readlines()
    ()
    ()
    result,row,col = compareFile(isfile1,isfile2)
    if result == 1:
        print(这两个文件相等)
    else:
        print(这两个文件在{0}行{1}列开始不相等.format(row,col))

    #********** End *********#

main()

 54，random模块

import math
import random
import os
#help(math)
print(random.random())#0-1浮点数
print(random.randint(15,66))#(a,b)间整数
print(random.uniform(15.2,19.9))#(a,b)间浮点数
print((abcde))
print(([1,,5,7,9]))
print(os.path.abspath())#返回当前路径C:\Users\1\Desktop\新python

0.027212955187900456
51
18.22669587469007
b
7
C:\Users\1\Desktop\新python

 

55，datetime模块

from datetime import datetime, date, time

print(1--------)
print(())#返回当天日期时间
t = ()
print(datetime.date(t))#返回当天日期
print((t))#返回当天时间

print(2--------)
print((t))#返回“星期，月，日，时，分，秒，年”格式的字符串
print(datetime.utcnow())#返回当前utc日期和时间
print(stamp(t))#返回当天时间戳
print(datetime.fromtimestamp(stamp(t)))#根据时间戳返回当天 datetime
print(datetime.utcfromtimestamp(stamp(t)))#根据时间戳返回UTC datetime

print(--------)
date1 = date(2018,2,12)
time1 = time(20,5,48)
print(datetimebine(date1,time1))#绑定日期，时间，生成新得datetime对象

print(4--------)
newDatetime = datetime.strptime(12/2/18 20:59, 	%d/%m/%y %H:%M	)#用字符串和指定格式生成新的datetime对象
print(newDatetime)

print(5--------)
for tv in tuple(t):#遍历
    print(tv)
print(t.isocalendar())#ISO格式的日期
print(t.strftime(%Y年%m月%d日 %H:%M:%S %p))#指定格式输出日期函数

1--------
202-01-01 02:0:5.686662
202-01-01
02:0:5.687660
2--------
Sun Jan  1 02:0:5 202
2022-12-1 18:0:5.688658
16725098.68766
202-01-01 02:0:5.687660
2022-12-1 18:0:5.687660
--------
2018-02-12 20:5:48
4--------
2018-02-12 20:59:00
5--------
202
1
1
2

5
6
1
-1
datetime.IsoCalendarDate(year=2022, week=52, weekday=7)
202年01月01日 02:0:5 AM

总结

turtle库，jieba库还没学，

random库，datetime库，.format()，字典，元组等不熟悉

文件和类不太行

两个月估计才000行代码量，离10000的入门还有距离

再给大家补充个我复习的方法

首先我们期末试考头歌上的代码可能会多点，所以我就先把这60道代码，先粘贴到VS code测试1，分为测试1和2，先看懂代码，然后自己再在测试2敲一遍，输出一样就算过，看图：

最后附上二级资源：

Python计算机二级过考指南_._的博客-CSD博客_输入: \10,@

【备考】计算机python二级过考指南（考点典例）_._的博客-CSD博客_计算机二级python

祝大家二级全部优秀

字，求个收藏点赞😀