27.Python练习题

1,列举布尔值为False的值

0 False ‘’   []   {} None

 

2, 写函数：

根据范围获取其中3和7整除的所有数的和，并返回调用者：

符合条件的数字个数以及符合条件的数字的总和 如：def func(start ,end):

 

3,函数的默认返回值是什么？

None

 

4,简述break\continue\return的区别

Break：结束当前循环

Continue:结束本次循环进入下一次循环

Return：结束函数，并返回结果，默认为None

 

5,函数传递参数时，是引用还是复制值，并证明

引用

Name = ‘guanyu’

Def show():

Print(id(name))

print(id(name))

show()

 

6,简述三元运算书写格式以及应用场景

变量=值-if条件-else值二

将简单的条件判断精简写

 

7，简述lambda表达式书写格式以及应用场景

函数名 =lambda 形式：功能 不写函数名也可以

将简单的函数书写成匿名函数，减少代码

 

8，使用set 集合获取两个列表l1=[11,22,33],l2=[22,33,44]中相同的元素集合

l1=[11,22,33]

l2=[22,33,44]

set(l1)&set(l2)

 

9，定义函数统计一个字符串中大写字母，小写字母，数字的个数，并以字典为结果返回给调用者

 

10，简述函数的 位置参数，关键字参数，默认参数，可变长参数的特点以及注意事项

位置参数：按形参的位置传入 叫位置参数就是普通参数

关键字参数：传入实参时制定形参的值

默认参数：形参直接指定默认值的参数

可变长参数：*arge **kwargs,一个只能接收没有位置参数的实参和参入的列表，元组，俩

可以接受关键字参数，和字典格式

11，检查代码，如有错误请改正

# 1.

def func(x,y,z):

    print(x,y,z)

func(1,2,3)

 

#2

def func(x,y,z=5):

    print(x,y,z)

func(1,3,3)

 

#3

def func(x,y,*z):

    print(x,y,z)

func(1,2,3,4,5,6)

 

#4

def func(x,y,*z):

    print(x,y,z)

func(1,2,3,4,5,6,6)

 

#5

def func(x,*z,**y):

    print(x,y,z)

func(1,2,3)

# 你定义的函数 func 使用了混合参数类型：位置参数 x，可变位置参数 *z，和可变关键字参数 **y。在调用 func(1, 2, 3) 时，参数的分配如下：

# x 接收第一个位置参数 1。

# *z 接收剩余的所有位置参数，即 2 和 3，所以 z 是一个包含 2 和 3 的元组。

# **y 接收关键字参数，但由于调用时没有提供任何关键字参数，所以 y 是一个空字典。

# 因此，调用 func(1, 2, 3) 后，函数内部的 x, y, 和 z 的值分别是：

# x 是 1

# y 是 {}（空字典）

# z 是 (2, 3)（包含 2 和 3 的元组）

# 函数 func 的输出将是：

# 1 {} (2, 3)

 

#6

def func(x,*y,**z):

    print(x,y,z)

func(1,name=2,age=3) #键值对会传给字典

 

#7

def func(x,*y,**z):

    print(x,y,z)

func(1,2,3,4,name=2,age=3)

 

#8

def func(x=2,*y,**z):

    print(x,y,z)

func(name=2,age=3)

 

#9

def func(*y,**z):

    print(y,z)

func(1,2,3,4,5)

 

#10

def func(*y,**z):

    print(y,z)

func([1,2,3,4,5])

 

#11

def func(*y,**z):

    print(y,z)

func(*[1,2,3,4,5])

 

#12

def func(*y,**z):

    print(y,z)

func(*[1,2,3,4,5],name='alexa',age=29)

 

#13

def func(*y,**z):

    print(y,z)

func(*[1,2,3,4,5],{'name':'alexa','age':29})  #属于元组的内容

 

#14

def func(*y,**z):

    print(y,z)

func(*[1,2,3,4,5],**{'name':'alexa','age':29})  #属于元组的内容

 

# 15

def func1(x=1,*y,**z):

    print(x,y,z)

    return y

    print(x)

def func2(arg):

    ret = func1(name=arg)

    print(ret)

    result = func2("Fuck")

    print(result)

# 输出结果为："name"："fuck") 0 Non

 

# 以下是修正后的代码：

def func1(x=1, *y, **z):

    print(x, y, z)

    return y

 

def func2(arg):

    ret = func1(name=arg)

    print(ret)

    return ret

 

# 调用 func2 并打印结果

result = func2("Fuck")

print(result)

 

 

 

 

 

 

 

 

# 15、书写执行结果(禁止运行代码)

def func(arg):

    arg.append(55)

 

li = [11, 22, 33, 44]

func(li)

print(li)

func(li)

print(li)

 

 

# 16，书写执行结果(禁止运行代码)

def f1(arg):

    print(arg + 100)

 

def f2(arg):

    ret = f1(arg + 1)

    print(arg)

    print(ret)

 

ret = f2(7)

print(ret)

 

 

17、简述Python3中的range函数和Python2..7中的range函数有什

么区别

3.x range不会生成值只有用的时候才会生成

2.7 range会直接生成一个列表,值已经生成

 

# 18、书写执行结果(禁止运行代码)

a = "goodboy %"

print(a)

# 输出结果为: goodboy %

 

b = "goodboy%d%%" % (12,)

print(b)

# 输出结果为: goodboy12%

 

19、简述对象和类的关系

如果值是某类型,那这个值就是这个类的对象

 

20、书写执行结果(禁止运行代码)

def func(al):

    return al + 100

 

func = lambda al: al + 200

ret = func(10)

print(ret)

# 输出结果为:210

 

21、内置函数all和any的区别

all是如果是空的,返回True如果非空,全真为真否侧为假

any是有一个为真就为真

 

22、简述文件打开模式’r’和'rb'的区别

r是只读模式打开,默认以uf-8格式

b是以二进制格式打开

 

 

 

23、将字符串"夏侯惇”转换成UTF-8编码的字节类型

S = '夏侯惇'

print(type(S))  # 这里应该是大写的 S

a = bytes(S, 'utf-8')

encoded_s = S.encode('utf-8')  # 这一行代码可以保留，但需要赋值给一个变量

print(a)

print(encoded_s)

 

24、利用内置函数将十进制数字12,分别转换成二进制、八进制、十六进制表示的字符串

# 十进制数字

decimal_number = 12

 

# 转换为二进制

binary_string = bin(decimal_number)

 

# 转换为八进制

octal_string = oct(decimal_number)

 

# 转换为十六进制

hexadecimal_string = hex(decimal_number)

 

# 打印结果

print(f"二进制: {binary_string}")

print(f"八进制: {octal_string}")

print(f"十六进制: {hexadecimal_string}")

 

25、简述内置函数globals(0、locals0作用

Globals()获取所有的全局变量

Locals()获取所有局部变量

 

26、利用内置函数zip(),实现功能

请获取字符串s="alex_is_good_guy"

 

l1 = ['alex', 22, 33, 44, 55]

l2 = ['is', 22, 33, 44, 55]

l3 = ['good', 22, 33, 44, 55]

l4 = ['guy', 22, 33, 44, 55]

 

# 提取字符串并拼接,方法1

s = "_".join([l1[0], l2[0], l3[0], l4[0]])

print(s)

 

# 方法2

# 使用 zip 函数将列表组合在一起

zipped_list = list(zip(l1, l2, l3, l4))

# 提取第一个元组并拼接成字符串

s = "_".join(zipped_list[0])

print(s)

 

 

27、判断输出结果是否相同?并可得到什么结论?

输出的两个值是否相同:相同

执行函数是调用变量值不是复制

def fl(arg):

    print(id(arg))

    n = 1111111

    print(id(n))

    f1(n)  # 这里假设 f1 函数已经定义

 

# 假设 f1 函数定义如下

def f1(arg):

    print(id(arg))

 

# 调用 fl 函数

fl(12345)

运行这段代码，你会得到以下输出（具体地址会根据运行环境有所不同）：

4325729616  # id(arg) 的输出

4325730032  # id(n) 的输出

4325730032  # id(arg) 在 f1 函数中的输出

解释：

fl 函数接受一个参数 arg，并打印其内存地址 id(arg)。

在 fl 函数内部，定义了一个变量 n，并打印其内存地址 id(n)。

调用 f1(n)，假设 f1 函数已经定义，并打印传递给它的参数的内存地址 id(arg)。

请确保在调用 fl 函数之前，f1 函数已经被正确定义。

 

解释：

 

fl 函数接受一个参数 arg，并打印其内存地址 id(arg)。

在 fl 函数内部，定义了一个变量 n，并打印其内存地址 id(n)。

调用 f1(n)，假设 f1 函数已经定义，并打印传递给它的参数的内存地址 id(arg)。

请确保在调用 fl 函数之前，f1 函数已经被正确定义。

 

28、书写执行结果(禁止运行代码)

a.

# 定义一个全局变量 NAMELIST

NAMELIST = ["alex", "eric"]

 

def func():

    # 在函数内部定义一个同名局部变量

    NAMELIST = 123

    print("Inside func:", NAMELIST)

 

# 调用函数

func()

 

# 打印全局变量 NAMELIST

print("Outside func:", NAMELIST)

输出结果为:

Inside func: 123

Outside func: ['alex', 'eric']

 

b.

# 定义一个全局变量 NAMELIST
NAMELIST = ["alex", "eric"]

def func():
    # 使用 global 关键字声明 NAMELIST 为全局变量
    global NAMELIST
    # 修改全局变量 NAMELIST 的值
    NAMELIST = 123

# 调用函数
func()

# 打印全局变量 NAMELIST
print(NAMELIST)

输出结果为:123

 

 C.

# 定义一个全局变量 NAMELIST

NAMELIST = ["alex", "eric"]

def func():

    # 在函数内部修改全局变量 NAMELIST，添加元素 "seven"

    NAMELIST.append("seven")

# 调用函数

func()

# 打印全局变量 NAMELISTprint(NAMELIST)

输出结果为:['alex', 'eric', 'seven']

 

29、书写执行结果

#a

# 定义一个全局变量 name
name = "全局作用域的name"

def func():
    name = "seven"
    def outer():
        name = "eric"
        def inner():
            global name
            name = "我是诸葛亮..."
        inner()
        print("outer 中的 name:", name)
    outer()
    print("func 中的 name:", name)

# 调用函数
func()
print("全局作用域的 name:", name)

运行这段代码，你会得到以下输出：

outer 中的 name: eric

func 中的 name: seven

全局作用域的 name: 我是诸葛亮...

 

#b

# 定义一个全局变量 name

name = "root"

def func():

    name = "seven"

 

    def outer():

        name = "eric"

        def inner():

            global name

            name = "我是赵云..."

        inner()

        print("outer 中的 name:", name)

 

    outer()

    print("func 中的 name:", name)

 

ret = func()print("返回值 ret:", ret)print("全局作用域的 name:", name)

运行这段代码，你会得到以下输出：

outer 中的 name: eric

func 中的 name: seven

返回值 ret: None

全局作用域的 name: 我是赵云...

 

#c

# 定义一个全局变量 name

name = "root"

def func():

    name = "seven"

 

    def outer():

        name = "eric"

        def inner():

            global name

            name = "..."

        print("outer 中的 name (调用 inner 之前):", name)

        inner()

        print("outer 中的 name (调用 inner 之后):", name)

 

    outer()

    print("func 中的 name:", name)

 

ret = func()print("返回值 ret:", ret)print("全局作用域的 name (调用 func 之后):", name)

name = "root"print("全局作用域的 name (重新赋值之后):", name)

运行这段代码，你会得到以下输出：

outer 中的 name (调用 inner 之前): eric

outer 中的 name (调用 inner 之后): eric

func 中的 name: seven

返回值 ret: None

全局作用域的 name (调用 func 之后): ...

全局作用域的 name (重新赋值之后): root

 

#d

# 定义一个全局变量 name

name = "全局作用域的name"

def func():

    name = "seven"

 

    def outer():

        name = "eric"

 

        def inner():

            nonlocal name

            name = "我数张飞..."

            print("inner 中的 name:", name)

 

        inner()

        print("outer 中的 name:", name)

 

    outer()

    print("func 中的 name:", name)

 

ret = func()print("返回值 ret:", ret)print("全局作用域的 name:", name)

运行这段代码，你会得到以下输出：

inner 中的 name: 我数张飞...

outer 中的 name: 我数张飞...

func 中的 name: seven

返回值 ret: None

全局作用域的 name: 全局作用域的name

 

30、书写执行结果并解释每一步操作

#a.

# 定义一个全局变量 name
name = "五虎上将"

# 定义一个装饰器函数 outer
def outer(func):
    name = 'alex'
    def wrapper():
        print("执行前")
        func()
        print("执行后")
    return wrapper

# 定义一个被装饰的函数 show
@outer
def show():
    print(name)

# 调用被装饰的函数 show
show()

 

 

#b

name = "司马懿"

def outer():

    name = "很多"

    

    def inner():

        print(name)

    

    return inner

 

ret = outer()

ret()print(ret)

输出结果为：

很多

<function outer.<locals>.inner at 0x7f8b8c0b4e50>

 

#c

name = "孙权"
def outer():
    name = "少年"
    def inner():
        print(name)
    return inner
ret = outer()
ret()
print(ret)
result = ret()
print(result)

输出结果：

少年

<function outer.<locals>.inner at 0x000000000240E0D0>

少年

None

 

#d

name = "华雄"
def outer():
    name = "被斩"
    def inner():
        print(name)
    return inner  # 返回内存地址
ret = outer()
print(ret)
result = ret()  # 执行inner函数, 打印波多
print(result)  # inner无返回值打印的是None

输出结果为：

<function outer.<locals>.inner at 0x00000000024100D0>

被斩

None

 

3，E

name = "颜良"

def outer(func):

    def inner():

        name = "马下"

        func()

    return inner

def show():

    print(name)  # 打印全局的

 

outer(show)()

输出：颜良

 

31，书写执行结果并解释每一步操作

#a

def outer(func, zy):
    def inner(z):
        return func(z)
    return inner(zy)

def show(x):
    return x * x

ret = outer(show, 9)
print(ret)

输出：81

解释：

 

def outer(func, zy):：定义了一个函数 outer，它接受一个函数 func 和一个参数 zy 作为参数。

def inner(z):：在 outer 函数内部定义了一个嵌套函数 inner，它接受一个参数 z。

return func(z)：在 inner 函数内部调用传入的 func 函数，并返回其结果。

return inner(zy)：outer 函数返回 inner 函数调用 zy 的结果。

def show(x):：定义了一个函数 show，它接受一个参数 x 并返回 x * x。

ret = outer(show, 9)：调用 outer 函数，并将 show 函数和参数 9 作为参数传入，结果赋值给 ret。

print(ret)：打印 ret。

#b

def outer(func, z, y):

    return func(z, y)

def show(x):

    return x * x

 

ret = outer(show, 9, 23)print(ret)

def outer(func, z, y):

    return func(z, y)

 

f1 = lambda x, y: x + y

ret = outer(f1, 11, 23)print(ret)

解释：

 

def outer(func, z, y):：定义了一个函数 outer，它接受一个函数 func 和两个参数 z 和 y 作为参数。

return func(z, y)：在 outer 函数内部调用传入的 func 函数，并返回其结果。

def show(x):：定义了一个函数 show，它接受一个参数 x 并返回 x * x。

ret = outer(show, 9, 23)：调用 outer 函数，并将 show 函数和参数 9 和 23 作为参数传入，结果赋值给 ret。

print(ret)：打印 ret。

输出结果为：81

输出 81 是因为在 outer 函数内部调用了 show 函数，但 show 函数只接受一个参数，所以 23 被忽略，show 函数计算 9 * 9 并返回 81。

 

接下来是第二个代码块：

def outer(func, z, y):

    return func(z, y)

 

f1 = lambda x, y: x + y

ret = outer(f1, 11, 23)

print(ret)

 

解释：

 

def outer(func, z, y):：定义了一个函数 outer，它接受一个函数 func 和两个参数 z 和 y 作为参数。

return func(z, y)：在 outer 函数内部调用传入的 func 函数，并返回其结果。

f1 = lambda x, y: x + y：定义了一个 lambda 函数 f1，它接受两个参数 x 和 y 并返回它们的和。

ret = outer(f1, 11, 23)：调用 outer 函数，并将 f1 函数和参数 11 和 23 作为参数传入，结果赋值给 ret。

print(ret)：打印 ret。

输出结果为：34

输出 34 是因为在 outer 函数内部调用了 f1 函数，f1 函数计算 11 + 23 并返回 34。

 

#c

def outer(func, z, y):

    return func(z, y)

 

f1 = lambda x, y: x * y

ret = outer(f1, 11, 23)print(ret)

解释：

 

def outer(func, z, y):：定义了一个函数 outer，它接受一个函数 func 和两个参数 z 和 y 作为参数。

return func(z, y)：在 outer 函数内部调用传入的 func 函数，并返回其结果。

f1 = lambda x, y: x * y：定义了一个 lambda 函数 f1，它接受两个参数 x 和 y 并返回它们的乘积。

ret = outer(f1, 11, 23)：调用 outer 函数，并将 f1 函数和参数 11 和 23 作为参数传入，结果赋值给 ret。

print(ret)：打印 ret。

输出结果为：253

输出 253 是因为在 outer 函数内部调用了 f1 函数，f1 函数计算 11 * 23 并返回 253。

 

#32,

def f5(arg):

    arg.append('找到500万')

def f4(arg):

    arg.append('开第四个门')

    f5(arg)

    arg.append('关第四个门')

def f3(arg):

    arg.append('开第三个门')

    f4(arg)

    arg.append('关第三个门')

def f2(arg):

    arg.append('开第二个门')

    f3(arg)

    arg.append('关第二个门')

def f1(arg):

    arg.append('开一个门')

    f2(arg)

    arg.append('关一个门')

 

user_list = []

result = f1(user_list)print(user_list)print(result)

输出结果为：

['开一个门', '开第二个门', '开第三个门', '开第四个门', '找到500万', '关第四个门', '关第三个门', '关第二个门', '关一个门']

None

 

33、利用递归实现32题中c题的功能

def func(x, y=0):
    y += 1
    if y == 5:
        return x + y
    x += y
    x = func(x, y)
    x += y
    return x

num = 1
result = func(num)
print(num)
print(result)

 

 

#34利用递归实现1*2*3*4*5*6*7=5040

d#1
def factorial(n):
    if n == 1:
        return 1
    else:
        return n * factorial(n - 1)

result = factorial(7)
print(result)

#2
def func(x, y=1):
    if x == 1:
        return y
    y = y * x
    x -= 1
    return func(x, y)

ret = func(7)
print(ret)

#3
from functools import reduce
print(reduce(lambda x, y: x * y, [x for x in range(1, 8)]))

 

 

35、写程序

a.文件操作时with 的作用?

whih 打开文件执行完毕后自动关闭

b.写程序:利用 with实现同时打开两个文件(一读，一写，并将读取的内容写入到写入模式的文件中)

with open("a", "r") as x, open("b", "w") as y:

    y.write(x.read())

 

1. 猴子第一天摘下若干个桃子，当即吃了-半，还不过瘾就多吃了一个。第二天早上又将剩下的桃子吃了一半，还是不过瘾又多吃了一个。以后每天都吃前一天剩下的一半再加一个。到第10天刚好剩-一个。问猴子第一天摘了多少个桃子?1534

方法1

def calculate_peaches(days):
    peaches = 1
    for day in range(days, 1, -1):
        peaches = (peaches + 1) * 2
    return peaches

# 计算第一天摘了多少个桃子
first_day_peaches = calculate_peaches(10)
print(first_day_peaches)

方法2

s = 1

func = lambda x: (x + 1) * 2for i in range(9):

    s = func(s)print(s)

方法3

def func(x, day):

    day -= 1

    if day == 0:

        return x

    x = (x + 1) * 2

    ret = func(x, day)

    return ret

 

ret = func(1, 10)print(ret)