Python刷题之菜狗升职记（暑假版）

kaman_py

已于 2023-07-05 22:29:25 修改

阅读量82

点赞数

文章标签： python 开发语言

于 2023-07-04 20:35:42 首次发布

本文链接：https://blog.csdn.net/kaman_py/article/details/131542462

版权

第一题

def` `func(s, i, j):
  ``if` `i < j:
    ``func(s, i ``+` `1``, j ``-` `1``)
    ``s[i],s[j] ``=` `s[j], s[i]
    
def` `main():
  ``a ``=` `[``10``, ``6``, ``23``, ``-``90``, ``0``, ``3``]
  ``func(a, ``0``, ``len``(a)``-``1``)
  ``for` `i ``in` `range``(``6``):
    ``print` `a[i]
    ``print` `"\n"
    
    
main()

解题思路：

首先我们看到他定义了一个函数func (),形参为s,i,j ,然后对所传递的数进行比较，if i<j 那么调用自身函数func（）将比较后的值进行相加减也就是说，s不便，i小于j的话，那么i+1，j-1 与此同时调换位置假设原本 i为0 ，j为a列表的长度减去1，那么进行比较，1小于4，那么原本s[1],s[4] 的值变为s[4],s[1]，也就是s[1] =6 ,变为s[1]=0,s[5]=0 ,变为s[5] =6,与此类推，直至i>j;

最后a列表的值为 a = [3,0,-90,23,6,10]

第二题

dicts ``=` `{}
dicts[(``1``, ``2``)] ``=` `({``3``, (``4``, ``5``)})
print``(dicts)

解题思路：

字典的格式为dict[key] = value ,然后由上图所示dicts的字典为（1，2），值为({3, (4, 5)}），其中值又包含了一个集合{3}和一个元组(4, 5)

关于value的值（{3, (4, 5)}），因为它不是元组，所以把括号去掉：{3, (4, 5)}，它是一个set，set 内部会自动排序，元组在set里面会往前放，所以变成：{(4, 5), 3}。
所以最后的结果 key：value = （1，2）：{（4，5），3}

第三题

def` `f(a, b):
  ``if` `b ``=``=` `0``:
    ``return` `a
  ``else``:
    ``return` `f(b, a``%``b)
  
a, b ``=` `input``(“Enter two natural numbers: ”)
print` `f(a, b)

解题思路：

知识点补充：

什么因数

因数是指能够整除一个数的正整数

例如，对于数字12，它的因数包括1、2、3、4、6和12，因为这些数都能够整除12，即12可以被它们整除。

因数有两种类型：
1. 真因数：除了1和自身之外的因数称为真因数。例如12的真因数是2、3、4和6。
2. 所有因数：包括1和自身在内的所有因数称为所有因数。例如12的所有因数是1、2、3、4、6和12。
什么是公约数

公约数是指能够整除两个或多个正整数的数。换句话说，如果一个数能够同时整除这些正整数，那么它就是这些正整数的公约数。

让我们举个例子。考虑数字12和18。它们的公约数是能够整除12和18的数。

首先，我们找到12的因数：1、2、3、4、6和12。然后我们找到18的因数：1、2、3、6、9和18。两个数共有的公约数是1、2、3和6，因为这些数能够同时整除12和18。

在这个例子中，最大的公约数是6，因为它是两个数的公约数中最大的一个。

公约数有两种类型：
1. 最大公约数（Greatest Common Divisor，简称GCD）：最大公约数是指能够同时整除两个或多个正整数中最大的那个数。
2. 公共公约数：公共公约数是指能够同时整除两个或多个正整数的所有公约数。

代码解析：

a % b 是求余数

辗转相除法，又称欧几里得算法，以除数和余数反复做除法运算，当余数为 0 时，取当前算式除数为最大公约数。

第四题

为输出一个字典dic = {‘a’:1,'b':2}，下列选项中，做法错误的是（）

解题步骤：

(A) lis1 = ['a','b'] , lis2 = [1,2]

dic = dict(zip(lis1,lis2))

print(dic) ==》{'a':1,'b':2}

(B) ltup = ('a','b')

lis = [1,2]

dic = {tup:lis}

print(dic) ==>因为是元组，所以不可拆分 {('a,'b):[1,2]}

print(dic) ==>{'a':1,'b':2}

(D) lis = ['a','b']

dic = dict.fromkeys(lis)

dic['a'] = 1

dic['b'] = 2

print(dic) ==>注意dict.fromkeys(keys, value)当只传入一个参数时，会将其作为键，默认值为None ，传入为{'a':none,'b':none} ,然后再进行赋值结果为：{'a':1,'b':2}

第五题

res ``=` `[]
for` `i ``in` `'python'``:
  ``if` `i ``=``=` `'h'``:
    ``continue
  ``res.append(i)
print``(''.join(res))

解题步骤:

continue 跳出本次循环，继续下一次循环，即为跳出 i == 'h' 时，

因此res = ['p','y','t','o','n']，最后打印的结果采用 join 函数连接res中的字符，输出的结果为 'pyton'

python中有join()和os.path.join(),其中join()连接字符串数组，os.path.join()将多个路径组合后返回

第六题

class` `Person:
  ``def` `__init__(``self``):
    ``pass
  ``def` `getAge(``self``):
    ``print` `__name__
p ``=` `Person()
p.getAge()

解题步骤：

这段代码定义了一个名为Person的类。该类有一个构造函数__init__，但是在这个例子中，构造函数没有执行任何操作（通过pass语句表示）。

类中还有一个名为getAge的方法，它使用了一个内置的print语句来打印__name__。__name__是一个内置的特殊变量，在不同的上下文中具有不同的值。在这里，__name__指代当前模块的名称。接下来，创建了一个Person类的实例p，并且调用了一个内置的print语句来打印__name__。当__name__被打印时，它代表的是当前模块的名称。

在Python中，每个脚本文件都可以作为一个独立的模块运行，并且每个模块都有一个特殊的__name__变量。当该模块直接被运行时，__name__的值会被设置为__main__。而当该模块被其他模块导入时，__name__的值会是该模块的名称：

举个例子，假设我们有两个文件：main.py 和 module.py。

在module.py中包含以下代码：python复制代码print(__name__)

然后，在main.py中导入了module.py：python复制代码import module

执行main.py时，控制台输出的结果将是module，即被导入模块的名称。这是因为被导入的模块在其内部使用print(__name__)语句时，__name__的值会被设置为模块的名称。

请注意，输出结果并不是文件名，而是模块的名称。模块的名称由所对应的文件名决定，但不一定完全相同。在一些情况下，模块的名称可能会有一些变化，比如使用了别名进行导入等。

当我们直接执行一个脚本文件时，其内部的__name__变量会被设置为__main__；当该文件作为模块被其他文件导入时，__name__变量的值会是该模块的名称。