【练习】Python第三次

对函数，内置函数的用法，递归，程序运行顺序的考试

1、列举布尔值为 False 的值

0 False '' [] () {} None

经常使用的场景是 if object 如果object有值就执行，而不用关心object具体是什么。

2、写函数:

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

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

方法一：for循环

def func(start,end):
    sum_l = 0
    count_l = 0
    for i in range(start,end):
        if (i % 3 == 0) and (i % 7 == 0):
            sum_l += i
            count_l += 1
    return count_l,sum_l

print(func(3,22)) #输出(1, 21)

方法二：迭代

def func(start,end,count_l = 0,sum_l = 0):
    if start == end:
        return count_l,sum_l
    if (start % 3 == 0) and (start % 7 == 0):
        sum_l += start
        count_l += 1
    ret = func(start +1,end,count_l,sum_l)
    return ret

print(func(3,22)) #输出(1, 21)

3、函数的默认返回值是什么?
None

4、简述 break / continue / return 的区别
break:结束当前循环
continue：结束本次循环进入下一次循环
return:结束函数，并返回结果，默认为None

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

引用

def test(x):
    print('函数内地址：',id(x))

y = 1
test(y)
print('函数外地址：',id(y))
'''输出：
函数内地址： 1713045968
函数外地址： 1713045968
'''

6、简述三元运算书写格式以及应用场景
变量 = 值一 if 条件一  else 值二
将简单的条件判断精简写

7、简述 lambda 表达式书写格式以及应用场景
函数名  = lambda 形参: 功能    不写函数名也可以
将简单的函数书写成匿名函数，减少代码

题外话：Python语言里面“一切皆对象”

1 是 数字类的对象

'你好' 是字符串类的对象

func() 是函数类的对象

存储方法：

1,x = 1 x指向值为1的内存地址

2,def f()

print('OK')

f函数名指向内容为print('OK')的内存地址

3,匿名函数lambda 在内存中执行完一次就被自动回收，所以比较省资源

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

l1 = [11, 22, 33]
l2 = [22, 33, 44]
s1 = set(l1)
s2 = set(l2)
print(s1.intersection(s2))
print(s1 & s2)

9、定义函数统计一个字符串中大写字母、小写字母、数字的个数，并以字典为结果返回给调用着
提示:可以用 id 进行判断

def show(xx):
    yy = {"数字":0,"大写":0,"小写":0}
    for i in xx:
        i = str(i)
        if i.isdigit():
            yy["数字"] += 1
        elif i.isupper():
            yy["大写"] += 1
        elif i.islower():
            yy["小写"] += 1
    return yy
xx = input(">>>>")
ret = show(xx)
print(ret)

10、简述函数的 位置参数、关键字参数、默认参数、可变长参数的特点以及注意事项
形参：普通参数，默认参数，动态参数
实参：位置参数，关键字参数
注：位置参数必须是在关键字参数前，形参也是普通参数最左，默认参数次之，动态参数最右
位置参数：按形参的位置传入 叫位置参数 就是普通参数
关键字参数：传入实参时指定形参的值
默认参数：形参直接指定默认值的参数
可变长参数：*args **kwargs ,一个星只能接收没有位置参数的的实参或参数的列表，元组，俩个星可以接收关键字参数，和字典格式

11、检查代码，如有错误请改正(禁止运行代码):
a.
def func(x,y,z):
    print(x,y,z)
func(1,2,3)
输出结果为:1 2 3

b.
def func(x,z,y=5):
      print(x,y,z)
func(1,3,3)
输出结果为:1 3 3

c.
def func(x,y,*z):
   print(x,y,z)
func(1,2,3,4,5,6)
输出结果为:1 2 (3,4,5,6)

e.
def func(x,*z,**y):
   print(x,y,z)
func(1,2,3)
输出结果为:1 {} (2,3)

f.
def func(x,*y,**z):
   print(x,y,z)
func(1,name=2,age=3)
输出结果为:1 () {'age': 3, 'name': 2}

g.
def func(x,*y,**z):
   print(x,y,z)
func(1,2,3,4, name=2,age=3)
输出结果为:1 (2,3,4) {"name":2,"age":3}

h.
def func(x=2,*y,**z):
   print(x,y,z)
func(name=2,age=3)
输出结果为:2 () {'age': 3, 'name': 2}

13、书写输出结果(禁止运行代码):
a.
def func(*y,**z):
   print(y,z)
func(1,2,3,4,5)
输出结果为:(1,2,3,4,5) {}

b.
def func(*y,**z):
   print(y,z)
func([1,2,3,4,5])
输出结果为:([1,2,3,4,5]) {}

c.
def func(*y,**z):
   print(y,z)
func(*[1,2,3,4,5])
输出结果为:(1,2,3,4,5) {}

d.
def func(*y,**z):
   print(y,z)
func(*[1,2,3,4,5],name="alex",age=19)
输出结果为:(1,2,3,4,5) {"name":"alex","age":19}

e.
def func(*y,**z):
   print(y,z)
func(*[1,2,3,4,5], { "name":"alex","age":19})
输出结果为:(1,2,3,4,5,{ "name":"alex","age":19}) {}

注意：给**传参数要么像上一题使用键值对，要么使用**，但是本题不符合这两个条件，只能传给y

f.
def func(*y,**z):
   print(y,z)
func(*[1,2,3,4,5], **{ "name":"alex","age":19})
输出结果为:(1,2,3,4,5) { "name":"alex","age":19}

14、书写执行结果(禁止运行代码)
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)
输出结果为:

1 () {'name': 'Fuck'}
()
None

15、书写执行结果(禁止运行代码)
def func(arg):
   arg.append(55)
li = [11, 22, 33, 44]
func(li)
print(li)
li = func(li)
print(li)

输出结果为:

[11, 22, 33, 44, 55]
None

16、书写执行结果(禁止运行代码)
def f1(arg):
   print(arg+100)
def f2(arg):
   ret = f1(arg+1)
   print(arg)
   print(ret)
ret = f2(7)
print(ret)
输出结果为:

108
7
None
None

17、简述 Python3 中的 range 函数和 Python2.7 中的 range 函数有什么区别
3.x range 不会生成值   只有用的时候才会生成（就是一个生成器）
2.7 range 会直接生成一个列表，值已经生成

18、书写执行结果(禁止运行代码)
a = "oldboy %"
print(a)
输出结果为:oldboy %
b = "oldboy %d %%" % (12,)
print(b)
输出结果为:oldboy 12%

19、简述对象和类的关系
如果值是某类型，那这个值就是这个类的对象

20、书写执行结果(禁止运行代码)
def func(a1):
   return a1 + 100
func = lambda a1: a1 + 200
ret = func(10)
print(ret)
输出结果为:210

21、内置函数 all 和 any 的区别
all 是如果是空的，返回True  如果非空，全真为真否则为假
any 是有一个为真就为真

22、简述文件打开模式 'r' 和 'rb' 的区别
r  是只读模式打开，默认以utf-8格式
rb 是以二进制格式打开

23、将字符串 "老男人" 转换成 UTF-8 编码的字节类型

name = "老男孩"
print(bytes(name,encoding="utf-8"))
print(name.encode(encoding="utf-8"))
'''输出
b'\xe8\x80\x81\xe7\x94\xb7\xe5\xad\xa9'
b'\xe8\x80\x81\xe7\x94\xb7\xe5\xad\xa9'
'''

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

print(bin(12))
print(oct(12))
print(hex(12))

25、简述内置函数 globals()、locals()作用
globals() 获取所有的全局变量
locals() 获取所有局部变量

26、利用内置函数 zip()，实现功能
l1 = ["alex",22,33,44,55]

l2 = ["is",22,33,44,55]
l3 = ["good",22,33,44,55]

l4 = ["guy",22,33,44,55]
请获取字符串 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]
print("_".join(list(zip(l1,l2,l3,l4))[0]))

print(list(zip(l1,l2,l3,l4)))
'''输出：
[('alex', 'is', 'good', 'guy'), (22, 22, 22, 22), (33, 33, 33, 33), (44, 44, 44, 44), (55, 55, 55, 55)]
'''

27、判断输出结果是否相同?并可得到什么结论?
def f1(arg):
   print(id(arg))
n = 1111111
print(id(n))
f1(n)
输出的两个值是否相同:   相同
执行函数是引用变量值，而不是复制

28、书写执行结果(禁止运行代码)
a.
NAMELIST = ["alex", "eric"]
def func():
   NAMELIST = 123
func()
print(NAMELIST)
输出结果为:["alex", "eric"]

b.
NAMELIST = ["alex", "eric"]
def func():
   global NAMELIST
   NAMELIST = 123
func()
print(NAMELIST)
输出结果为:123

c.
NAMELIST = ["alex", "eric"]
def func():
   NAMELIST.append("seven")
func()
print(NAMELIST)
输出结果为:["alex", "eric","seven"]

d.
NAMELIST = ["alex", "eric"]
def func():
   NAMELIST = 123
   global NAMELIST
func()
print(NAMELIST)
输出结果为:警告，可以执行

SyntaxWarning: name 'NAMELIST' is assigned to before global declaration
global NAMELIST
123

29、书写执行结果(禁止运行代码)
a.
name = "root"
def func():
   name = "seven"
   def outer():
       name = "eric"
       def inner():
           global name
           name = "蒙逼了吧..."
       print(name)
   print(name)
ret = func()
print(ret)
print(name)
输出结果为:

seven
None
root

b.
name = "root"
def func():
   name = "seven"
   def outer():
       name = "eric"
       def inner():
           global name
           name = "蒙逼了吧..."
       print(name)
   o = outer()
   print(o)
   print(name)
ret = func()
print(ret)
print(name)
输出结果为:

eric
None
seven
None
root

c.
name = "root"
def func():
   name = "seven"
   def outer():
       name = "eric"
       def inner():
               global name
               name = "    ..."
       print(name)
       inner()
   o = outer()
   print(o)
   print(name)
ret = func()
print(ret)
print(name)
输出结果为:

eric
None
seven
None
...

d.

name = "root"
def func():
    name = "seven"
    def outer():
        name = "eric"
        def inner():
            nonlocal name
            name = "蒙逼了吧..."
            print(name)
        inner()
    o = outer()
    print(o)
    print(name)
ret = func()
print(ret)
print(name)

输出结果为:

蒙逼了吧...
None
seven
None
root

30、书写执行结果并解释每一步操作
a.
name = "苍老师"
def outer(func):
   name = 'alex'
   func() #结果，就是执行的show
def show():
   print(name)
outer(show)
结果：苍老师

b.
name = "苍老师"
def outer():
   name = "波多"
   def inner():
       print(name)
   return inner()
ret = outer()
print(ret)
输出结果为:

波多
None

c.

name = "苍老师"
def outer():
   name = "波多"
   def inner():
       print(name)
   return inner
ret = outer()
ret()         #输出"波多"
print(ret)    #输出inner内存地址
result = ret()#输出"波多"
print(result) #输出 None

输出结果为:

波多
<function outer.<locals>.inner at 0x00000000025E26A8>
波多
None

d.
name = "苍老师"
def outer():
   name = "波多"
   def inner():
       print(name)
   return inner    #返回内存地址
ret = outer()
print(ret)           #打印inner内存地址
result = ret()     #执行inner函数，打印波多
print(result)      #inner无返回值 打印的是None
输出结果为:

<function outer.<locals>.inner at 0x00000000026026A8>
波多
None

e.
name = "苍老师"
def outer(func):
   def inner():
       name = "李杰"
       func()
   return inner
def show():
   print(name)#打印全局的
outer(show)()
输出结果为:苍老师

31、书写执行结果并解释每一步操作
a.
def outer(func,z,y):
   func(z)  #不管这里运行什么，outer函数本身没有return，只能默认返回None
def show(x):
   return x * x
ret = outer(show,9,23)
print(ret)
输出结果为:None

b.
def outer(func,z,y):
   return func(z)
def show(x):
   return x * x
ret = outer(show,9,23)
print(ret)
输出结果为:81

c.
def outer(func,z,y):
   func(z,y)
f1 = lambda x,y: x + y
ret = outer(f1,11,23)
print(ret)
输出结果为:None

d.
def outer(func,z,y):
   return func(z,y)
f1 = lambda x,y: x + y
ret = outer(f1,11,23)
print(ret)
输出结果为:34

32、写输出结果
a.
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

b.
def f5(arg):
   arg = arg + 5
def f4(arg):
   arg = arg + 4
   f5(arg)
   arg = arg + 4
def f3(arg):
   arg = arg + 3
   f4(arg)
   arg = arg + 3
def f2(arg):
   arg = arg + 2
   f3(arg)
   arg = arg + 2
def f1(arg):
   arg = arg + 1
   f2(arg)
   arg = arg + 1
num = 1
result = f1(num)
print(num)
print(result)
输出结果为:1 None

c.
def f5(arg):
   arg = arg + 5
   return arg
def f4(arg):
   arg = arg + 4
   f5(arg)
   arg = arg + 4
   return arg
def f3(arg):
   arg = arg + 3
   f4(arg)
   arg = arg + 3
   return arg
def f2(arg):
   arg = arg + 2
   f3(arg)
   arg = arg + 2
   return arg
def f1(arg):
   arg = arg + 1
   f2(arg)
   arg = arg + 1
   return arg
num = 1
result = f1(num)
print(num)
print(result)
输出结果为:

1

3

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

下面的程序不是实现32题中的C题的功能，因为C题也没体现出递归的想法

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

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

一共迭代了6次

传入值

x=1——x=1——x=1——x=1——x=1——x=1

y=0——y=1——y=2——y=3——y=4——y=5

返回值

x=最终——x=10——x=9——x=8——x=7——x=6

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

第一种：思路不清

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

num = 8
result = func(num)
print(result)

第二种：思路清晰

def func(x):
    if x == 1:
        return 1
    return x*func(x-1)

result = func(7)
print(result)

reduce+lambda写法

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

35、写程序
a. 利用 filter、自定义函数 获取 l1 中元素大于 33 的所有元素 l1 = [11, 22, 33, 44, 55]

l1 = [11, 22, 33, 44, 55]
def dy(x):
    if x>33:
        return x
print(list(filter(dy,l1)))

b.利用 filter、lambda 表达式 获取 l1 中元素小于 33 的所有元素 l1 = [11, 22, 33, 44, 55]

l1 = [11, 22, 33, 44, 55]
print(list(filter(lambda x:x<33,l1)))

c.利用 map、自定义函数 将所有是奇数的元素加 100 l1 = [11, 22, 33, 44, 55]

l1 = [11, 22, 33, 44, 55]
def dy(x):
    if x%2 == 1:
        return x+100
    else:
        return x
print(list(map(dy,l1)))

d.利用 map、lambda 表达式 将所有是偶数的元素加 100 l1 = [11, 22, 33, 44, 55]

l1 = [11, 22, 33, 44, 55]
print(list(map(lambda x:x+100 if x%2 == 0 else x,l1)))

36、写程序
a. 文件操作时 with 的作用?
with  打开文件执行完毕后自动关闭

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

with open("a","r",encoding='utf-8') as x,open("b","w") as y:
    y.write(x.read())

37、写函数: 如有以下两个列表
l1 = [...]
l2 = []
第一个列表中的数字无序不重复排列，第二个列表为空列表
需求:
取出第一个列表的最小值 放到第二个列表的首个位置，
取出第一个列表的最小值(仅大于上一次的最小值) 放到第二个列表的首个位置，
取出第一个列表的最小值(仅大于上一次的最小值) 放到第二个列表的首个位置， ...
依此类推，从而获取一个有序的列表 l2，并将其返回给函数调用者。

l1 = [1,5,4,6,8,3,2,9,0]
l2 = []
def func(la,lb):
    if len(la) ==0:
        return lb
    a = min(la)
    la.remove(a)
    lb.insert(0,a)
    ret = func(la,lb)
    return ret
func(l1,l2)
print(l2)
#输出：[9, 8, 6, 5, 4, 3, 2, 1, 0]

第二种使用pop方法

l1 = [3,2,1,7,6,8]
l2 = []

def sort1():
    while True:
        if l1:
            for index,i in enumerate(l1):
                if i == max(l1):
                    l2.append(l1.pop(index))
        else:
            return
sort1()
print(l2)
#输出：[8, 7, 6, 3, 2, 1]

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

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

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

输出：1534