python 基础练习(三)

最新推荐文章于 2023-02-12 19:51:43 发布

EdVzAs

最新推荐文章于 2023-02-12 19:51:43 发布

阅读量1.2k

点赞数 1

文章标签： python 列表

本文链接：https://blog.csdn.net/weixin_46131409/article/details/104078305

版权

Python 专栏收录该内容

135 篇文章 3 订阅

订阅专栏

1.列举布尔值为False的值
0,False,None,"",[],(),{}

2.写函数：根据范围获取其中3和7整除的所有数的和，并返回调用者：符合条件的数字个数以及符合条件的数字的总和，如：def

func(start,end)：
def func(start,end):
    count=0
    s=0
    for i in range(start,end):
        if  i%3==0 and i%7==0:
            count+=1
            s+=i
            print(i)
    return s,count

print(func(0,100))

3.函数的默认返回值
None

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

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

def test(a):
    print(id(a))
b=1
print(id(b))
test(b)   #两次内存id相同

6.简述三元运算书写格式及应用场景 #"元"意为运算符
变量=值1 if 条件1 else 值2
简写简单的条件判断

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.定义函数统计一个字符串中大写字母、小写字母、数字的个数，并以字典为结果返回

提示：可以用id进行判断

d={'Al':0,'low':0,'num':0}
def tongji(s):
    for i in s :
        if i.isupper():
            d.update(Al=d.get('Al')+1)
        elif i.islower():
            d.update(low=d.get('low') + 1)
        elif i.isnumeric():
            d.update(num=d.get('num')+1)
    return d

t=tongji('Manuel123')
print(t)

def num(st):
    a = 0
    b = 0
    c = 0
    for i in st:
        if i.isupper():     #判断是否是大小字母
            a += 1
        elif i.islower():   #判断是否是小写字母
            b += 1
        elif i.isdigit():   #判断是否是数字
            c += 1
    return a, b, c,

sf = "sefisehfi294723dASE"
cc = num(sf)
print(cc)

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,2,3)
#结果为1,3,2

c.
def func(x,y,*z):
　print(x,y,z)

func(1,2,3,4,5,6)
#结果为1,2,(3,4,5,6,)

d.
def func(x,y,*z):
　print(x,y,z)

func(1,2,3,4,5,6,6)
#结果为1,2,(3,4,5,6,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,(),{'name':2,'age':3}

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

　　pirnt(x,y,z)

func(name=2,age=3)
#结果为2,(),{'name':2,'age':3}

h.
def func(*y,**z):

　　print(y,z)

func([1,2,3,4,5])
#结果为([1,2,3,4,5],){}

i.
def func(*y,**z):

　　print()

func(*[1,2,3,4,5])
#结果为(1,2,3,4,5,){}

j.
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}

k.
def func(*y,**z):

　　pirnt(y,z)

func(*[1,2,3,4,5],{'name':'alex','age':19})
#结果为(1,2,3,4,5,{'name':'alex','age':19}){}

l.
def func(*y,**z):

　　pirnt(y,z)

func(*[1,2,3,4,5],**{'name':'alex','age':19})
#结果为(1,2,3,4,5,){'name':'alex','age':19}

m.
b='oldboy%d%%'%(12,)

print(b)
#结果为oldboy12%

13.书写输出结果(禁止运行代码)

a.
def func(*y,**z):
    print(y,z)

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

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

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

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

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

func(*[1,2,3,4,5],**{"name":"alex","age":19})
输出结果为：1 (1, 2, 3, 4, 5) {'age': 19, 'name': 'alex'}

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 函数有什么区别?
答：区别：在于返回值的不同

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

python2.7.x range 会直接生成一个列表，值已经生成

区别示例：
python2.x中的range返回的是一个列表

>>> range(1,10)  #打印出1-10的数字，python默认从0开始
[1, 2, 3, 4, 5, 6, 7, 8, 9]

python3.x中的range返回的是一个迭代值
#错误的方法

>>> range(1,10)
range(1, 10)

#正确的方法，要想打印出列表，需要加list

>>> list(range(1,10))
[1, 2, 3, 4, 5, 6, 7, 8, 9]

18.书写执行结果（禁止运行代码）

a、
a="oldboy%"
print(a)
输出结果为：1 oldboy%
 
b、
b="oldboy%d%%"%(12,)
print(b)
输出结果为：1 oldboy12%

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

20、书写执行结果（禁止运行代码）

def func(a1):
    return a1 + 100   #func值被系统垃圾回收机制回收。

func = lambda a1:a1 + 200

def func(a1)   
     return a1 + 200    #下面这个func覆盖掉上面那个a1的值=a1+200=210

ret = func(10) 
print(ret)    
输出结果为：210

21.内置函数all和any的区别
all:如果为空，则为真，如果非空，全真则为真
any:有一个为真则为真

22.简述文件打开模式‘r’和‘rb’的区别
‘r’：只读模式，解码方式默认为‘utf-8’
‘rb’：以二进制方式读文件,通常处理非txt文件

23.将‘老男人’转换成utf-8编码的字节类型

a='老男人'
b=a.encode('utf8')
c=bytes(a,'utf8')
print(b)
print(c)

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

print(bin(12))   #二进制
print(oct(12))   #八进制
print(hex(12))   #十六进制
执行结果：
0b1100      #二进制
0o14        #八进制
0xc         #十六进制

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(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)]
n1 = list(zip(l1,l2,l3,l4))
n2 = n1[0]
n3 = '_'.join(n2)
print(n3)

print("_".join(list(zip(l1,l2,l3,l4))[0]))

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

def f1(arg):
    print(id(arg))

n=1111111
print(id(n))
f1(n)

相同,均为11277024；函数实参是在引用值

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)
#结果为:D:/python/job8/job.py:335: SyntaxWarning: name 'NAMELIST' is assigned to before global declaration global NAMELIST

29.书写执行结果（禁止运行代码）

a.
name = "root"
def func():
    name = "seven"
    def outer():   #outer()未运行
        name = "eric"
        def inner():   #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)
#结果为：
eric
None
seven
None
root

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

a.
name = "苍老师"

def outer(func):
    name = 'alex'
    func()

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)
result = ret()
print(result)
#结果为：
波多
<function outer.<locals>.inner at 0x01225660>   #inner内存地址
波多
None

d.
name = "苍老师"

def outer():
    name = "波多"
    def inner():
        print(name)
    return inner

ret = outer()
print(ret)
result = ret()
print(result)
#结果为：
<function outer.<locals>.inner at 0x01715660>
波多
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)

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

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

num = 1
result = fnuc(num)
print(num)
print(result)

33.利用递归实现1234567

#参数t保存每次计算的结果，n保持递增，然后进行计算
def func(n,t):
    t=t*n
    if n>=7:
        return t
    n+=1
    return func(n,t)

print(func(2,1))   #结果为5040

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

34.写程序
a.利用filter、自定义函数获取 l1 中元素大于 33 的所有元素l1=

[11,22,33,44,55]
def f1(args):
    if args>33:
        return True

l1 = [11,22,33,44,55]
ret = filter(f1,l1)
print(list(ret))   #结果为1   [44,55]

l1 = [11,22,33,44,55]
print(list(filter(lambda x:x>33,l1)))   #结果为1   [44,55]

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)))   #结果为1   [11,22]

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

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

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

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

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

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

l1 = [11,33,44,2,66]
l2 = []
def foo(x,y):
      for item in range(len(x)):
                  v = min(x)
                  y.insert(0,v)
                   x.remove(v)
        return y
print(foo(l1,l2))

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

解题思路：

这题得倒着推。第10天还没吃，就剩1个，说明第9天吃完一半再吃1个还剩1个，假设第9天还没吃之前有桃子p个，可得：p * 1/2 - 1 = 1，可得 p = 4。以此类推，即可手算出。

代码思路：第10天还没吃之前的桃子数量初始化 p = 1，之后从9至1循环9次，根据上述公式反推为 p = (p+1) * 2 可得第1天还没吃之前的桃子数量。for循环中的print()语句是为了验证推算过程而增加的。

p = 1
print('第10天吃之前就剩1个桃子')
for i in range(9, 0, -1):
    p = (p+1) * 2
    print('第%s天吃之前还有%s个桃子' % (i, p))
print('第1天共摘了%s个桃子' % p)
#结果为：
第10天吃之前就剩1个桃子
第9天吃之前还有4个桃子
第8天吃之前还有10个桃子
第7天吃之前还有22个桃子
第6天吃之前还有46个桃子
第5天吃之前还有94个桃子
第4天吃之前还有190个桃子
第3天吃之前还有382个桃子
第2天吃之前还有766个桃子
第1天吃之前还有1534个桃子
第1天共摘了1534个桃子

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

def func(x, day):
    day -= 1
    if day == 0:
        return x
    x = (1 + x) * 2
    ret = func(x, day)
    return ret

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