碼上歡樂
相關內容    簡體    繁體

Python編程練習

本文轉載自   查看原文   2018-04-27 10:17   1035 

函數默認參數為可變類型（[ ]）

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
 
# 下面代碼的輸出結果是什么，請解釋。
def extend_list(val, list=[]):
 list.append(val)
 return list


list1 = extend_list(10)
list2 = extend_list(123, [])
list3 = extend_list('a')

print(list1)
print(list2)
print(list3)

print(list1 is list3)

 

依次輸出：
[10, ‘a’]
[123]
[10, ‘a’]
True
因為list1和list3調用函數extend_list時，沒有傳入list關鍵字參數，使用了函數初始化的list。
返回給list1和list3的都是初始化list的地址，所以值相同。

類的繼承

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
 
# 下面代碼的輸出結果是什么，請解釋。
class Parent(object):
 x = 1

class Child1(Parent):
 pass

class Child2(Parent):
 pass

print(Parent.x, Child1.x, Child2.x)
Child1.x = 2
print(Parent.x, Child1.x, Child2.x)
Parent.x = 3
print(Parent.x, Child1.x, Child2.x)

依次輸出：
1 1 1
1 2 1
3 2 3
因為，Child1、Child2都繼承Parent類。
第一次都輸出Parent的x值，為1。
第二次，Child1擁有自己的屬性x=2,他的輸出變為2。
第三次，Parent的屬性x被賦值為3。不改變Child1自己的屬性x。

列表中多個lambda

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
 
# 以下代碼的輸出結果是什么？請寫出答案並解釋。請修改multipliers的定義，來產生期望的結果。
def multipliers():
 return [lambda x: i * x for i in range(4)]


print([m(2) for m in multipliers()])


# [6, 6, 6, 6]
# i在閉包作用域，Python的閉包是遲綁定，閉包用到變量的值，在內部函數被調用時才能得到。


# 把閉包作用域改為局部作用域
def multipliers1():
 return [lambda x, i=i: i * x for i in range(4)]


# 變成生成器，使用時賦值
def multipliers2():
 return (lambda x: i * x for i in range(4))


print([m(2) for m in multipliers1()])
print([m(2) for m in multipliers2()])
# [0, 2, 4, 6]

打印文件夾中文件的路徑以及包含文件夾中文件的路徑

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
 
# 方法一：（面試要求不使用os.walk）
def print_directory_contents(sPath):
 import os

 for sChild in os.listdir(sPath):
 sChildPath = os.path.join(sPath, sChild)
 if os.path.isdir(sChildPath):
 print_directory_contents(sChildPath)
 else:
 print(sChildPath)
 
# 方法二：（使用os.walk）
def print_directory_contents(sPath):
 import os
 for root, _, filenames in os.walk(sPath):
 for filename in filenames:
 print(os.path.abspath(os.path.join(root, filename)))


print_directory_contents('.')

列表解析

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
 
A0 = dict(zip(('a', 'b', 'c', 'd', 'e'), (1, 2, 3, 4, 5)))
A1 = range(10)
A2 = [i for i in A1 if i in A0]
A3 = [A0[s] for s in A0]
A4 = [i for i in A1 if i in A3]
A5 = {i: i * i for i in A1}
A6 = [[i, i * i] for i in A1]

'''
A0：{'a': 1, 'b': 2, 'c': 3, 'd': 4, 'e': 5}
A1：range(0, 10)
A2：[]
A3：[1, 2, 3, 4, 5]
A4：[1, 2, 3, 4, 5]
A5：{0: 0, 1: 1, 2: 4, 3: 9, 4: 16, 5: 25, 6: 36, 7: 49, 8: 64, 9: 81}
A6：[[0, 0], [1, 1], [2, 4], [3, 9], [4, 16], [5, 25], [6, 36], [7, 49], [8, 64], [9, 81]]
'''

一句話打印出0-100內的偶數

1
2
3
 
print([i for i in range(1, 101) if i % 2 == 0])
print([i for i in range(2, 101, 2)])
print(list(filter(lambda x: True if x % 2 == 0 else False, range(1, 101))))

1,2,3,4,5 能組成幾個互不相同且無重復數字的三位數

1
2
3
 
nums = [1, 2, 3, 4, 5]
l1 = [i * 100 + j * 10 + k for i in nums for j in nums for k in nums if (j != i and k != j and k != i)]
print(l1, len(l1))

兩個字典相加，不同的key對應的值保留，相同的key對應的值相加

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
 
dicta = {'a': 1, 'b': 2, 'c': 3, 'd': 4, 'f': 'hello'}
dictb = {'a': 2, 'b': 3, 'd': 5, 'e': 7, 'm': 9, 'f': 'world'}


def merge(dic1, dic2):
 d = {}
 for i in dic1:
 if i in dic2:
 d.setdefault(i, (dic1[i] + dic2[i]))
 else:
 d.setdefault(i, dic1[i])
 for i in dictb:
 if i not in d:
 d.setdefault(i, dic2[i])
 return d


print(merge(dicta, dictb))


def merge(dic1, dic2):
 d1keys = list(dic1.keys())
 d2keys = list(dic2.keys())
 keys = sorted(list(set(d1keys + d2keys)))
 ret = {}
 for i in keys:
 if i in d1keys and i in d2keys:
 ret[i] = dic1[i] + dic2[i]
 elif i in d1keys and i not in d2keys:
 ret[i] = dic1[i]
 else:
 ret[i] = dic2[i]
 return ret


print(merge(dicta, dictb))

斐波那契數列

返回Fibonacci數列中的第n項

1
2
3
4
5
6
7
8
9
10
11
12
13
14
 
# 方法一 遞歸法：
def fibo1(n):
 if n <= 1:
 return n
 return fibo1(n - 1) + fibo1(n - 2)

# 方法二 序列解包：
def fibo2(n):
 '''序列解包'''
 a, b = 0, 1
 for i in range(0, n ):
 # print(a, b, a + b)
 a, b = b, a + b
 return a

返回Fibonacci數列中的前n項

1
2
3
4
5
6
7
 
def fibo3(n):
 ret = [0,]
 a, b = 0, 1
 for i in range(0, n):
 a, b = b, a + b
 ret.append(a)
 return ret

求400萬以內最大的斐波那契數和它的下標

1
2
3
4
5
6
7
8
9
10
11
12
 
def fibo(n):

 i, a, b = 1, 1, 2
 ret = [a, ]
 while b <= n:
 a, b = b, a + b
 i += 1
 ret.append(a)
 return a, i, ret


print(fibo(4000000))

求兩個列表list的交集和差集

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
 
l1 = [1, 2, 3, 4]
l2 = [2, 3, ]
# 交集
ret = [i for i in l2 if i in l1]
print(ret)
print(list(set(l1) & set(l2)))

# 差集
ret = [i for i in l1 if i not in l2]
print(ret)
print(list(set(l1) ^ set(l2)))

# 並集
ret = [list(set(l1) | set(l2))]
print(ret)

列表去重(保持原有順序)

1
2
3
4
5
6
7
8
9
10
11
 
l1 = [1, 4, 3, 3, 4, 2, 3, 4, 5, 6, 1]
new_l1 = list(set(l1))
new_l1.sort(key=l1.index)
print(new_l1)

from functools import reduce

l1 = [1, 4, 3, 3, 4, 2, 3, 4, 5, 6, 1]
func = lambda x, y: x if y in x else x + [y]
new_l1 = reduce(func, [[], ] + l1)
print(new_l1)

求數組中沒有重復的數的和

1
2
3
4
5
6
7
8
 
def sums(l):
 s = set(l)
 ret = [i for i in s if l.count(i) == 1]
 print(ret)
 return sum(ret)


print(sums([3, 4, 1, 2, 5, 6, 6, 5, 4, 3, 3]))

給定一個整數數組返回兩個數的索引，使得他們相加和一個目標值相等

1
2
3
4
5
6
7
8
9
10
11
 
def func(list, target):
 for i in range(len(list)):
 num = target - list[i]
 if num in list and i != list.index(num):
 return [i, list.index(num)]
 return None


if __name__ == '__main__':
 nums = [2, 7, 11, 15]
 print(func(nums, 22))

求列表中第二大的元素

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
 
def max2_func(li):
 max = li[0]
 max2 = li[1]
 if max < max2:
 max, max2 = max2, max
 for i in range(2, len(li)):
 if max < li[i]:
 max2, max = max, li[i]
 elif max2 < li[i]:
 max2 = li[i]

 return max2


print(max2_func([1, 2, 3, 4, 5]))
print(max2_func([5, 5, 4, 4, 3]))

0-99取10個不重復的數字

1
2
3
4
5
6
7
8
9
10
11
12
 
def func(k):
 import random

 ret = set()
 while len(ret) < k:
 s = k - len(ret)
 l = list(set(range(100)) - ret)
 ret = ret | set(random.choices(l, k=s))
 return ret


print(func(10))

99乘法表

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
 
# 方法一
for i in range(1, 10):
 for j in range(1, i + 1):
 print("%s*%s=%s" % (i, j, i * j), end=' ')
 print()

# 方法二
print(["%s*%s=%s" % (i, j, i * j) for i in range(1, 10) for j in range(1, i + 1)])

# 方法三
i, j = 1, 1
while j <= 9:
 if i <= j:
 print("%s*%s=%s" % (i, j, i * j), end=' ')
 i += 1
 else:
 i = 1
 j += 1
 print()

寫一個裝飾器，打印出方法執行時長的信息

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
 
import time
from functools import wraps


def tiemer(func):
 @wraps(func)
 def wrapper(*args, **kwargs):
 start_time = time.time()
 func(*args, **kwargs)
 print('%s 運行了%s' % (func.__name__, time.time() - start_time))

 return wrapper


@tiemer
def f1():
 time.sleep(1)

f1()

寫一個裝飾器，打印函數名

1
2
3
4
5
6
7
8
9
10
11
12
13
14
 
def log(func):
 def wrapper(*args, **kwargs):
 print("call {name}({arg})".format(name=func.__name__, arg=str(*args) or ''))
 func(*args, **kwargs)

 return wrapper


@log
def now(*args, **kwargs):
 print('2013-12-25')


now()

輸入一個字符串，返回倒序排列的結果：如：’abcdef’ 返回 ‘fedcba’

1
2
3
4
5
 
s = 'abcdef'
print(s[::-1])

s1 = ''.join(sorted(s, reverse=True))
print(s1)

返回字段和對應值組成的字典

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
 
# -*- coding: utf-8 -*-
# __author__ = "maple"
# 有一個數據結構如下，編寫函數從該結構數據中返回由指定的字段和對應的值組成的字典。如果指定字段不存在，則跳過該字段。
"""
data = {'time': '2016-08-05T13;13:05',
 'some_id': 'ID1234',
 'grp1': {'fld1': 1, 'fld2': 2},
 'xxx2': {'fld3': 0, 'fld5': 0.4},
 'fld6': 11,
 'fld7': 7,
 'fld46': 8
 }

fields：由"|"連接的以"fld"開頭的字符串，如：'fld2|fld3|fld7|fld19'
"""


def select(data, fields):
 field_list = fields.split('|')

 temp = {}

 for key, values in data.items():
 if isinstance(values, dict):
 temp.update(values)
 else:
 temp[key] = values

 result = {i: temp[i] for i in temp if i in field_list}

 # for key in temp:
 # if key in field_list:
 # result[key] = temp[key]
 return result


if __name__ == '__main__':
 data1 = {'time': '2016-08-05T13;13:05',
 'some_id': 'ID1234',
 'grp1': {'fld1': 1, 'fld2': 2},
 'xxx2': {'fld3': 0, 'fld5': 0.4},
 'fld6': 11,
 'fld7': 7,
 'fld46': 8
 }
 fields1 = 'fld2|fld3|fld7|fld19'
 print(select(data1, fields1))

五猴分桃問題

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
 
def show(n):
 for i in range(1, 6):
 t = (n - 1) / 5
 print('%s 總數為%s個，第%s只猴子拿走%s個' % (i, n, i, t))
 n = 4 * t


def peach():
 pea = 1 # 假設最后一只猴子拿走了1個桃子
 while True:
 num = pea
 for i in range(4):
 num = 5 * num + 1 # 拿之前的總量
 if num % 4: #
 break
 num /= 4 # 前一個猴子拿走的桃子個數
 else:
 show(5 * num + 1)
 break
 pea += 1
 return pea, 5 * num + 1


if __name__ == '__main__':
 pea, num = peach()
 print(pea, num)

羅馬數字轉阿拉伯數字

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
 
def rome_to_arab(s):
 '''
 5、10的左邊只能有一個1
 50、100左邊只能有一個10
 500、1000左邊只能有一個100
 5、50、500 不能放在大數的左邊，放在大數的右邊只能有一個
 1、10、100 可連用最多3個，左邊只能有一個
 '''

 rome_int = {'I': 1, 'V': 5, 'X': 10, 'L': 50, 'C': 100, 'D': 500, 'M': 1000}
 num = rome_int[s[0]]
 for i in range(1, len(s)):
 if rome_int[s[i]] > rome_int[s[i - 1]]:
 num += rome_int[s[i]] - 2 * rome_int[s[i - 1]]
 else:
 num += rome_int[s[i]]
 return num


print(rome_to_arab('XXXIX'))

level(x)根據輸入數值返回對應級別

1
2
3
4
5
6
7
8
9
10
 
def level(x):
 if x <= 0:
 return '數字超出范圍'
 if x > 200:
 return 21
 else:
 return x // 10 if x % 10 == 0 else x // 10 + 1


print(level(1))

輸入年月日，返回天數

1
2
3
4
5
6
7
8
9
10
11
12
13
 
import datetime
import time


def func(date_str): # 直接使用Python內置模塊datetime的格式轉換功能得到結果
 date_int = list(map(lambda x: int(x), date_str.split('-')))
 date = datetime.date(*date_int)

 return date.strftime('%j')
 # return time.strptime(date_str, "%Y-%m-%d").tm_yday


print(func('2017-12-10'))

根據數字長度創建字典

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
 
L = [1, 2, 4, 8, 16, 32, 64, 128, 256, 512, 1024, 32768, 65536, 4294967296]
L_str_list = [str(i) for i in L]
ret = {}

for i in L_str_list:
 if len(i) not in ret:
 ret[len(i)] = [int(i)]
 else:
 ret[len(i)].append(int(i))


# ret = set(map(lambda x: len(x), L_str_list))
# ret = {i: [] for i in ret}
# for i in L_str_list:
# ret[len(i)].append(int(i))
#
print(ret)

根據（row,column）,創建二維數組

1
2
3
4
5
6
7
8
9
10
11
12
13
 
def array(row, col):
 ret = []

 for i in range(row):
 ret.append([(i * j) for j in range(col)])
 return ret


print(array(4, 5))

row = 4
col = 5
print([[(i * j) for j in range(col)] for i in range(row)])

二維數組的成員判斷

在一個二維數組中，每一行都按照從左到右遞增的順序排序，每一列都按照從上到下遞增的順序排序。
請完成一個函數，輸入這樣的一個二維數組和一個整數，判斷數組中是否含有該整數，如果存在返回該整數的位置。

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
 
arr = [[1, 4, 7, 10, 15],
 [2, 5, 8, 12, 19],
 [3, 6, 9, 16, 22],
 [10, 13, 14, 17, 24],
 [18, 21, 23, 26, 30]]


def get_num(num, data=None):
 temp = data.copy()
 i, j = 0, len(temp[0]) - 1
 
 while temp:
 if num > temp[0][-1]:
 del temp[0]
 i += 1
 elif num < temp[0][-1]:
 temp = list(zip(*temp))
 del temp[-1]
 temp = list(zip(*temp))
 j -= 1
 else:
 return i, j

 return False


if __name__ == '__main__':
 print(get_num(18, arr))

數組中找最大和的連續子數組

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
 
def max_son(l):
 left = 0
 right = len(l) - 1
 # mini = l.index(min(l))
 # maxi = l.index(max(l))
 while left < right:
 temp = l[left:right + 1]
 mini = l.index(min(temp))
 maxi = l.index(max(temp))
 print('left %s right %s mini %s maxi %s' % (left, right, mini, maxi))
 # 數組兩端為正數，整個數組和小於最大值，中間數的和小於0，數組元素最少為4個元素
 if sum(l[left:right + 1]) <= l[maxi] and sum(l[left + 1:right]) < 0 and right - left > 2:
 if l[left] < l[right] and sum(l[left:right - 1]) < l[maxi]:
 left += 1
 continue
 elif l[left] > l[right] and sum(l[left + 2:right + 1]) < l[maxi]:
 right -= 1
 continue

 if l[left] < 0: # 保證起始數為正數
 left += 1
 continue
 if l[right] < 0: # 保證截止數為正數
 right -= 1
 continue
 if l[left + 1] < 0 and l[left] <= abs(l[left + 1]): # 保證正數后一位的負數小於他本身
 left += 2
 continue
 if l[right - 1] < 0 and l[right] <= abs(l[right - 1]): # 保證正數前一位的負數小於他本身
 right -= 2
 continue
 if left < mini < right and sum(l[mini:right + 1]) <= 0:
 right = mini
 continue
 if left < mini < right and sum(l[left:mini + 1]) <= 0:
 left = mini
 continue

 return left, right, l[left:right + 1]

 return left, right, [l[maxi]]


if __name__ == '__main__':
 # a = [-2, 1, -3, 4, -7, 2, -1, -3, 4]
 # a = [-2, 1, -3, 4, -1, 2, -7, -3, 4]
 # a = [-2, 1, -3, 5, -7, 2, -1, -3, 4]
 # a = [-2, 1, -3, 5, -7, 4, 3, -3, 4]
 # a = [-2, 1, -3, 4, -1, 2, 1, -5, 4]
 a = [-2, 1, -3, 4, -1, 2, 1, -4, 5]
 # a = [8, -9, 2, 7]
 print(max_son(a))

坦克

某次戰役中，為便於信息交互，我軍偵察部門將此次戰役的關鍵高地坐標設定為（x=0，y=0）並規定，每向東增加100米，x加1，每向北增加100米，y加1。同時，我軍情報部門也破譯了敵軍向坦克發送的指揮信號，其中有三種信號（L,R,M）用於控制坦克的運動，L 和 R 分別表示使令坦克向左、向右轉向，M 表示令坦克直線開進100米，其它信號如T用於時間同步，P用於位置較准。

一日，我軍偵察兵發現了敵軍的一輛坦克，偵察兵立即將坦克所在坐標（P, Q）及坦克前進方向（W：西，E：東，N：北，S：南）發送給指揮部，同時啟動信號接收器，將坦克接收到的信號實時同步發往指揮部，指揮部根據這些信息得以實時掌控了該坦克的位置，並使用榴彈炮精准地擊毀了該坦克。

請設計合理的數據結構和算法，根據坦克接收到的信號，推斷出坦克所在的位置。
設計時請考慮可能的擴展情況，並體現出您的設計風格。

假設，偵察兵發送給指揮部的信息如下：
坦克坐標：（11，39）
坦克運行方向：W
坦克接收到的信號為：MTMPRPMTMLMRPRMTPLMMTLMRRMP
其位置應該是（9，43），運動方向為E

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
 
class Tank:
 pointer = 'NESW' # 方向指針
 shift = {'N': 'y+1', 'S': 'y-1', 'W': 'x-1', 'E': 'x+1'} # 位移偏量

 def __init__(self, position, direction):
 self.x, self.y = position
 self.direction = direction
 self.position = (self.x, self.y)

 def signal(self, orders):
 for i in orders:
 if i in 'LR':
 self.turn(i)
 elif i == 'M':
 self.move()
 elif i == 'P':
 self.pd()

 def turn(self, orders):
 i = self.pointer.find(self.direction)
 if orders == 'L':
 i -= 1
 elif orders == 'R':
 i += 1
 self.direction = self.pointer[i % 4]

 def move(self):
 orders = self.shift[self.direction]
 if orders[0] == 'x':
 x = self.x
 self.x = eval(orders)
 else:
 y = self.y
 self.y = eval(orders)
 self.position = (self.x, self.y)

 def pd(self):
 print(self.position, self.direction)


tank = Tank((11, 39), 'W')
tank.signal('MTMPRPMTMLMRPRMTPLMMTLMRRMP')


免責聲明！

本站轉載的文章為個人學習借鑒使用，本站對版權不負任何法律責任。如果侵犯了您的隱私權益，請聯系本站郵箱yoyou2525@163.com刪除。



猜您在找 Python編程練習題 練習三十：Python回文數判斷編程練習。 《Python編程從入門到實踐》練習題 函數的練習3——python編程從入門到實踐 python面向對象編程練習 編程練習：考古遺跡 C語言編程練習（一） JAVA基礎——編程練習（二） Python練習九 python編程練習---兩種思路判斷是否為回文字符串
 
粵ICP備18138465號   © 2018-2025 CODEPRJ.COM