轉載：
老男孩 Python 基礎知識練習（三）：https://www.cnblogs.com/nulige/p/6128674.html
1、列舉布爾值為 False 的值
空，None，0, False, '', [], {}, ()
2、寫函數：
根據范圍獲取其中 3 和 7 整除的所有數的和，並返回調用者：符合條件的數字個數以及符合條件的數字的總和
如： def func(start,end):
1 def func(x,y):
2
3 n = []
4 sum = 0
5 for i in range(x,y):
6 if (i % 3 == 0 and i % 7 == 0):
7 sum += i
8 n.append(i)
9 print(len(n))
10 print(sum)
11
12 func(1,100)
執行結果：
1 4
2 210
3、函數的默認返回值是什么？
None
4、簡述break/continue/return的區別
Break：用於退出所有循環
continue：跳出本次循環，繼續執行下次循環
return：程序返回，不再執行下面的代碼
5、函數傳遞參數時，是引用還是復制值？並證明提示：可以用 id 進行判斷
答：是引用,
ps:
1 def f1(arg):
2 print(id(arg))
3
4 n=1111111
5 print(id(n))
6 f1(n)
執行結果：
1 26219232
2
3 26219232
6、簡述三元運算書寫格式以及應用場景
python的三元運算書寫格式：
變量名 = 變量1 if 條件判斷成立 else 變量2
解釋：條件成立 變量名值為變量1 否則為變量2
7、簡述 lambda 表達式書寫格式以及應用場景
1、書寫格式：函數名=lambda 形參：功能 不寫函數名也可以
2、應用場景
將簡單的函數書寫成 匿數名函數，減少代碼
8、使用 set 集合獲取兩個列表l1=[11,22,33],l2=[22,33,44]中相同的元素集合
法1：
1 l1=[11,22,33]
2 l2=[22,33,44]
3
4 n1=set(l1)
5 n2=set(l2)
6 print(n1.intersection(n2))
執行結果：
1 {33, 22}
法2：
1 l1=[11,22,33]
2 l2=[22,33,44]
3 set(11)&set(12)
9、定義函數統計一個字符串中大寫字母、小寫字母、數字的個數，並以字典為結果返回給調用者
1 def num(st):
2 a = 0
3 b = 0
4 c = 0
5 for i in st:
6 if i.isupper(): #判斷是否是大小字母
7 a += 1
8 elif i.islower(): #判斷是否是小寫字母
9 b += 1
10 elif i.isdigit(): #判斷是否是數字
11 c += 1
12 return a, b, c,
13
14 sf = "sefisehfi294723dASE"
15 cc = num(sf)
16 print(cc)
執行結果：
1 (3, 10, 6)
10、簡述函數的位置參數、關鍵字參數、默認參數、可變長參數的特點以及注意事項
位置參數：按形參的位置傳入，叫位置參數就是普通參數
關鍵字參數：傳入實參時指定形參的值
默認參數：形參直接指定默認值的參數
可變長參數：*args **kwargs，一個只能接收沒有位置參數的實參或參入的列表，元組，倆可以接收關鍵字參數和字典格式。
11、檢查代碼，如有錯誤請改正（禁止運行代碼）：
a.
1 def func(x,y,z):
2 print(x,y,z)
3
4 func(1,2,3)
輸出結果為：
1 1 2 3
b.
1 def func(x,z,y=5): #有賦值的參數，傳入的參數必須在右邊，否則會報錯
2 print(x,y,z)
3 func(1,3,3)
輸出結果為：
1 1 3 3
c.
1 def func(x,y,*z):
2 print(x,y,z)
3
4 func(1,2,3,4,5,6)
輸出結果為：
1 1 2 (3, 4, 5, 6)
d.
1 def func(x,y,*z):
2 print(x,y,z)
3
4 func(1,2,3,4,5,6,6)
輸出結果為：
1 1 2 (3, 4, 5, 6, 6)
e.
1 def func(x,*z,**y):
2 print(x,y,z)
3
4 func(1,2,3)
輸出結果為：
1 1 {} (2, 3)
f.
1 def func(x,*y,**z):
2 print(x,y,z)
3
4 func(1,name=2,age=3)
輸出結果為：
1 1 () {'age': 3, 'name': 2}
g.
1 def func(x,*y,**z):
2 print(x,y,z)
3
4 func(1,2,3,4,name=2,age=3)
輸出結果為：
1 1 (2, 3, 4) {'age': 3, 'name': 2}
h.
1 def func(x=2,*y,**z):
2 print(x,y,z)
3
4 func(name=2,age=3)
輸出結果為：
1 2 () {'age': 3, 'name': 2}
13、書寫輸出結果（禁止運行代碼）：
a.
1 def func(*y,**z):
2 print(y,z)
3
4 func(1,2,3,4,5)
輸出結果為：
1 (1, 2, 3, 4, 5) {}
b.
1 def func(*y,**z):
2 print(y,z)
3
4 func([1,2,3,4,5])
輸出結果為：
1 ([1, 2, 3, 4, 5],) {}
c.
1 def func(*y,**z):
2 print(y,z)
3
4 func(*[1,2,3,4,5])
輸出結果為：
1 (1, 2, 3, 4, 5) {}
d.
1 def func(*y,**z):
2 print(y,z)
3
4 func(*[1,2,3,4,5],name="alex",age=19)
輸出結果為：
1 (1, 2, 3, 4, 5) {'age': 19, 'name': 'alex'}
e.
1 def func(x,*z,**y):
2 print(x,y,z)
3
4 func(1,2,3)
輸出結果為：
1 1 {} (2, 3)
f.
1 def func(*y,**z):
2 print(y,z)
3
4 func(*[1,2,3,4,5],**{"name":"alex","age":19})
輸出結果為：
1 (1, 2, 3, 4, 5) {'age': 19, 'name': 'alex'}
14、書寫執行結果（禁止運行代碼）
1 def func1(x=1,*y,**z):
2 print(x,y,z)
3 return y
4 print(x)
5
6 def func2(arg):
7 ret=func1(name=arg)
8 print(ret)
9
10 result = func2("Fuck")
11 print(result)
輸出結果為：
1 1 () {'name': 'Fuck'}
2 ()
3 None
15、書寫執行結果（禁止運行代碼）
1 def func(arg):
2 arg.append(55)
3
4 li=[11,22,33,44]
5 func(li)
6 print(li)
7 li=func(li)
8 print(li)
輸出結果為：
1 [11, 22, 33, 44, 55]
2
3 None
16、書寫執行結果（禁止運行代碼）
1 def f1(arg):
2 print(arg+100)
3
4 def f2(arg):
5 ret=f1(arg+1)
6 print(arg)
7 print(ret)
8
9 ret=f2(7)
10 print(ret)
輸出結果為：
1 108
2 7
3 None
4 None
17、簡述 Python3 中的 range 函數和 Python2.7 中的 range 函數有什么區別?
答：區別：在於返回值的不同
python3.x range 不會生成值，只有用的時候才會生成
python3.x range 會直接生成一個列表，值已經生成
區別示例：
python2.x中的range返回的是一個列表
1 >>> range(1,10) #打印出1-10的數字，python默認從0開始
2 [1, 2, 3, 4, 5, 6, 7, 8, 9]
python3.x中的range返回的是一個迭代值
#錯誤的方法
1 >>> range(1,10)
2 range(1, 10)
#正確的方法，要想打印出列表，需要加list
1 >>> list(range(1,10))
2 [1, 2, 3, 4, 5, 6, 7, 8, 9]
18、書寫執行結果（禁止運行代碼）
a、
1 a="oldboy%"
2 print(a)
輸出結果為：
1 oldboy%
b、
1 b="oldboy%d%%"%(12,)
2 print(b)
輸出結果為：
1 oldboy12%
19、簡述對象和類的關系
如果值是某類型，那這個值就是這個類的對象
20、書寫執行結果（禁止運行代碼）
1 def func(a1): 2 return a1 + 100 #func值被系統垃圾回收機制回收。 3 4 func = lambda a1:a1 + 200
def func(a1) 5 return a1 + 200 #下面這個func覆蓋掉上面那個a1的值=a1+200=210
6 ret = func(10) 7 print(ret)
輸出結果為：
1 210
21、內置函數 all 和 any 的區別
答：any是任意，而all是全部。
all : 當傳入空可迭代對象時返回True，當可迭代對象中有任意一個不為True，則返回False
any : 當傳入空可迭代對象時返回False，當可迭代對象中有任意一個不為False，則返回True
22、簡述文件打開模式'r'和'rb'的區別
答：
r 是只讀模式打開，默認以utf-8格式
rb 是以二進制格式打開
23、將字符串"老男人"轉換成 UTF-8 編碼的字節類型
1 name = "老男人"
2 #print(bytes(name, encoding='utf-8'))
3 print(bytes(name, encoding='utf-8').decode('utf-8'))
執行結果：
1 老男人
24、利用內置函數將十進制數字12，分別轉換成二進制、八進制、十六進制表示的字符串
1 print(bin(12)) #二進制
2 print(oct(12)) #八進制
3 print(hex(12)) #十六進制
執行結果：
1 0b1100 #二進制
2 0o14 #八進制
3 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"
ps1:
1 l1 = ["alex", 22, 33, 44, 55]
2 l2 = ["is", 22, 33, 44, 55]
3 l3 = ["good", 22, 33, 44, 55]
4 l4 = ["guy", 22, 33, 44, 55]
5
6 #print(list(zip(l1,l2,l3,l4)))
7 n1 = list(zip(l1,l2,l3,l4))
8 n2 = n1[0]
9 n3 = '_'.join(n2)
10 print(n3)
執行結果：
1 alex_is_good_guy
ps2:
1 print("_".join(list(zip(l1,l2,l3,l4))[0]))
27、判斷輸出結果是否相同？並可得到什么結論？
1 def f1(arg):
2 print(id(arg))
3
4 n=1111111
5 print(id(n))
6 f1(n)
輸出的兩個值是否相同：相同
1 執行結果：
2 11277024
3
4 11277024
28、書寫執行結果（禁止運行代碼）
a.
1 NAMELIST=["alex","eric"]
2
3 def func():
4 NAMELIST=123
5
6 func()
7 print(NAMELIST)
輸出結果為：
1 ['alex', 'eric']
b.
1 NAMELIST=["alex","eric"]
2
3 def func():
4 global NAMELIST
5 NAMELIST=123
6
7 func()
8 print(NAMELIST)
輸出結果為：
1 123
c.
1 NAMELIST=["alex","eric"]
2
3 def func():
4 NAMELIST.append("seven")
5
6 func()
7 print(NAMELIST)
輸出結果為：
1 ['alex', 'eric', 'seven']
d.
1 NAMELIST = ["alex", "eric"]
2
3 def func():
4 NAMELIST = 123
5 global NAMELIST
6
7 func()
8 print(NAMELIST)
輸出結果為：
1 123
2
3 D:/python/job8/job.py:335: SyntaxWarning: name 'NAMELIST' is assigned to before global declaration
4 global NAMELIST
29、書寫執行結果（禁止運行代碼）
a.
1 name = "root"
2 def func():
3 name = "seven"
4 def outer():
5 name = "eric"
6 def inner():
7 global name
8 name = "蒙逼了吧..."
9 print(name)
10 print(name)
11
12 ret = func()
13 print(ret)
14 print(name)
輸出結果為：
1 seven
2 None
3 root
b.
1 name = "root"
2 def func():
3 name = "seven"
4 def outer():
5 name = "eric"
6 def inner():
7 global name
8 name = "蒙逼了吧..."
9 print(name)
10 o = outer()
11 print(o)
12 print(name)
13
14 ret = func()
15 print(ret)
16 print(name)
輸出結果為：
1 eric
2 None
3 seven
4 None
5 root
c.
1 name = "root"
2 def func():
3 name = "seven"
4 def outer():
5 name = "eric"
6 def inner():
7 global name
8 name = "蒙逼了吧..."
9 print(name)
10 inner()
11 o = outer()
12 print(o)
13 print(name)
14
15 ret = func()
16 print(ret)
17 print(name)
輸出結果為：
1 eric
2 None
3 seven
4 None
5 蒙逼了吧...
d.
1 name = "root"
2 def func():
3 name = "seven"
4 def outer():
5 name = "eric"
6 def inner():
7 nonlocal name
8 name = "蒙逼了吧..."
9 print(name)
10 inner()
11 o = outer()
12 print(o)
13 print(name)
14
15 ret = func()
16 print(ret)
17 print(name)
輸出結果為：
1 eric
2 None
3 seven
4 None
5 root
30、書寫執行結果並解釋每一步操作
a.
1 name = "蒼老師"
2
3 def outer(func):
4 name = 'alex'
5 func()
6
7 def show():
8 print(name)
9 outer(show)
執行結果：
1 蒼老師
b.
1 name = "蒼老師"
2
3 def outer():
4 name = "波多"
5 def inner():
6 print(name)
7 return inner()
8
9 ret = outer()
10 print(ret)
輸出結果為：
1 波多
2 None
c.
1 name = "蒼老師"
2
3 def outer():
4 name = "波多"
5 def inner():
6 print(name)
7 return inner
8
9 ret = outer()
10 ret()
11 print(ret)
12 result = ret()
13 print(result)
輸出結果為：
1 波多
2 <function outer.<locals>.inner at 0x01225660> #inner內存地址
3 波多
4 None
d.
1 name = "蒼老師"
2
3 def outer():
4 name = "波多"
5 def inner():
6 print(name)
7 return inner
8
9 ret = outer()
10 print(ret)
11 result = ret()
12 print(result)
輸出結果為：
1 <function outer.<locals>.inner at 0x01715660>
2 波多
3 None
e.
1 name = "蒼老師"
2
3 def outer(func):
4 def inner():
5 name = "李傑"
6 func()
7 return inner
8
9 def show():
10 print(name)
11
12 outer(show)()
執行結果：
1 蒼老師
31、書寫執行結果並解釋每一步操作
a.
1 def outer(func,z,y):
2 func(z)
3
4 def show(x):
5 return x * x
6
7 ret = outer(show,9,23)
8
9 print(ret)
輸出結果為：
1 None
b.
1 def outer(func, z, y):
2 return func(z)
3 def show(x):
4 return x * x
5
6 ret = outer(show,9,23)
7 print(ret)
輸出結果為：
1 81
c.
1 def outer(func,z,y):
2 func(z,y)
3
4 f1 = lambda x,y:x+y
5 ret = outer(f1,11,23)
6 print(ret)
輸出結果為：
1 None
d.
1 def outer(func, z, y):
2 return func(z, y)
3
4 f1 = lambda x,y:x + y
5 ret = outer(f1, 11, 23)
6 print(ret)
輸出結果為：
1 34
32、寫輸出結果
a.
1 def f5(arg):
2 arg.append('偷到 500 萬')
3
4 def f4(arg):
5 arg.append('開第四個門')
6 f5(arg)
7 arg.append('關第四個門')
8
9 def f3(arg):
10 arg.append('開第三個門')
11 f4(arg)
12 arg.append('關第三個門')
13
14 def f2(arg):
15 arg.append('開第二個門')
16 f3(arg)
17 arg.append('關第二個門')
18
19 def f1(arg):
20 arg.append('開一個門')
21 f2(arg)
22 arg.append('關一個門')
23
24 user_list = []
25 result = f1(user_list)
26 print(user_list)
27 print(result)
輸出結果為：
1 ['開一個門', '開第二個門', '開第三個門', '開第四個門', '偷到 500 萬', '關第四個門', '關第三個門', '關第二個門', '關一個門']
2 None
b.
1 def f5(arg):
2 arg = arg + 5
3
4 def f4(arg):
5 arg = arg + 4
6 f5(arg)
7 arg = arg + 4
8
9 def f3(arg):
10 arg = arg + 3
11 f4(arg)
12 arg = arg + 3
13
14 def f2(arg):
15 arg = arg + 2
16 f3(arg)
17 arg = arg + 2
18
19 def f1(arg):
20 arg = arg + 1
21 f2(arg)
22 arg = arg + 1
23
24 num = 1
25 result = f1(num)
26 print(num)
27 print(result)
輸出結果為：
1 1
2 None
c.
1 def f5(arg):
2 arg = arg + 5
3 return arg
4
5 def f4(arg):
6 arg = arg + 4
7 f5(arg)
8 arg = arg + 4
9 return arg
10
11 def f3(arg):
12 arg = arg + 3
13 f4(arg)
14 arg = arg + 3
15 return arg
16
17 def f2(arg):
18 arg = arg + 2
19 f3(arg)
20 arg = arg + 2
21 return arg
22
23 def f1(arg):
24 arg = arg + 1
25 f2(arg)
26 arg = arg + 1
27 return arg
28
29 num = 1
30 result = f1(num)
31 print(num)
32 print(result)
輸出結果為：
1 1
2 3
d、利用遞歸實現32 題中c題的功能
1 def fnuc(x,y=0):
2 y += 1
3 if y == 5:
4 return x + y
5 x += y
6 func(x,y)
7 x += y
8 return x
9
10 num = 1
11 result = fnuc(num)
12 print(num)
13 print(result)
33、利用遞歸實現1*2*3*4*5*6*7
ps1:
1 #參數t保存每次計算的結果，n保持遞增，然后進行計算
2
3 def func(n,t):
4 t=t*n
5 if n>=7:
6 return t
7 n+=1
8 return func(n,t)
9
10 print(func(2,1))
執行結果：
1 5040
ps2:
1 from functools import reduce
2 print(reduce(lambda x,y:x*y,[x for x in range(1,8)]))
執行結果：
1 5040
34、寫程序
a.利用filter、自定義函數獲取 l1 中元素大於 33 的所有元素l1=[11,22,33,44,55]
ps1:
1 def f1(args):
2 if args>33:
3 return True
4
5 l1 = [11,22,33,44,55]
6 ret = filter(f1,l1)
7 print(list(ret))
執行結果：
1 [44, 55]
ps2:
filter+lambda方式
1 l1 = [11,22,33,44,55]
2 print(list(filter(lambda x:x>33,l1)))
執行結果：
1 [44, 55]
b.利用filter、lambda 表達式獲取 l1 中元素小於 33 的所有元素l1=[11,22,33,44,55]
1 l1 = [11,22,33,44,55]
2 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 實現同時打開兩個文件（一讀，一寫，並將讀取的內容寫入到寫入模式的文件中）
1 with open("a", "r") as x, open("b","w") as y:
2 y.write(x.read())
36、寫函數：
如有以下兩個列表
l1=[...]
l2=[]
第一個列表中的數字無序不重復排列，第二個列表為空列表
需求：
取出第一個列表的最小值放到第二個列表的首個位置，
取出第一個列表的最小值（僅大於上一次的最小值）放到第二個列表的首個位置，
取出第一個列表的最小值（僅大於上一次的最小值）放到第二個列表的首個位置，
...
依此類推，從而獲取一個有序的列表 l2，並將其返回給函數調用者。
deffunc(l1,l2):
pass
答：
1 l1 = [11,33,44,2,66]
2 l2 = []
3 def foo(x,y):
4 for item in range(len(x)):
5 v = min(x)
6 y.insert(0,v)
7 x.remove(v)
8 return y
9 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()語句是為了驗證推算過程而增加的。
代碼如下：
ps:
1 p = 1
2 print('第10天吃之前就剩1個桃子')
3 for i in range(9, 0, -1):
4 p = (p+1) * 2
5 print('第%s天吃之前還有%s個桃子' % (i, p))
6 print('第1天共摘了%s個桃子' % p)
執行結果：
1 第10天吃之前就剩1個桃子
2 第9天吃之前還有4個桃子
3 第8天吃之前還有10個桃子
4 第7天吃之前還有22個桃子
5 第6天吃之前還有46個桃子
6 第5天吃之前還有94個桃子
7 第4天吃之前還有190個桃子
8 第3天吃之前還有382個桃子
9 第2天吃之前還有766個桃子
10 第1天吃之前還有1534個桃子
11 第1天共摘了1534個桃子
ps2:
1 s = 1
2 func = lambda x: (x + 1) * 2
3 for i in range(9):
4 s = func(s)
5 print(s)
ps3:
1 def func(x, day):
2 day -= 1
3 if day == 0:
4 return x
5 x = (1 + x) * 2
6 ret = func(x, day)
7 return ret
8
9 ret = func(1, 10)
10 print(ret)