PDS.2-211

问题一

设计一个函数,check_list(x),其中x是Python能够读取的任何数据形式(数字,列表等等)。如果x是列表数据形式,那么该函数将返回True,如果不是列表该函数将返回False。

# grader format
def check_list(x):
    # YOUR CODE HERE
    return (isinstance(x,list))
    raise NotImplementedError()
from nose.tools import assert_equal
assert_equal(check_list([1,2,3]), True)
assert_equal(check_list([]), True)
assert_equal(check_list({'A':[1,2,3,4]}), False)

问题二

设计一个函数,list_length(x),其中x的数据形式是列表(list)。该函数将返回列表的长度。

# grader format
def list_length(x):
    # YOUR CODE HERE
    return(len(x))
    raise NotImplementedError()
from nose.tools import assert_equal
assert_equal(list_length([1,2,3]), 3)
assert_equal(list_length([]), 0)

问题三

基于问题一及问题二,设计函数check_len(x),其中x的数据形式是列表(list)。该函数首先判断x是否为列表,如果是列表则返回该列表的长度,如果不是列表则返回字符串’Not a list’。

# grader format
def check_len(x):
    # YOUR CODE HERE
    if isinstance(x,list):
        return(len(x))
    else:
        return('Not a list')
    raise NotImplementedError()
from nose.tools import assert_equal
assert_equal(check_len([1,2,3]), 3)
assert_equal(check_len([2,4,7,2]), 4)
assert_equal(check_len(12), 'Not a list')

问题四

设计函数max_min(x, extremum),其中x的数据形式是列表(list),extremum是字符串形式的’min’或者’max’。函数首先判断extremum是’min’还是’max’,然后求解并返回列表相应极值。例如max_min([3,4,1], ‘max’)将返回4。

# grader format
def max_min(x, extremum):
    # YOUR CODE HERE
    if extremum=="max":
        return(max(x))
    else:
        return(min(x))
    raise NotImplementedError()
from nose.tools import assert_equal
assert_equal(max_min([3,4,1], 'max'), 4)
assert_equal(max_min([2,4,7,2], 'min'),2)

问题五

设计函数cal_var(x),其中x的数据形式是列表(list),该函数将返回列表x中数字的方差。

方差公式:$\delta^2 = \frac{\sum(X-\mu)^2}{N}$

$\delta^2$ – 方差

$\sum$ – 加和符号

$X$ – 列表中的每个数字

$\mu$ – 列表中数字的平均数

$N$ – 列表中的数字个数

# grader format
def cal_var(x):
    u=0
    for i in x:
        u=u+i
    u=u/len(x)
    s=0
    for i in x:
        s=s+(i-u)**2
    s=s/len(x)
    return(s)
    # YOUR CODE HERE
    raise NotImplementedError()
from nose.tools import assert_equal
assert_equal(cal_var([1,1,1]), 0)
assert_equal(cal_var([0,1,2,3]), 1.25)

PDS.2-212

问题一

设计一个函数,list_index(x, n),其中x的数据形式是列表(list),n是数字,该函数将返回列表x中的第n个元素。如果n大于列表中元素个数,函数将返回’Out of Range’。

# grader format
def list_index(x, n):
    # YOUR CODE HERE
    if n>len(x):
        return( 'Out of Range')
    else:
        return(x[n])
    raise NotImplementedError()
from nose.tools import assert_equal
assert_equal(list_index(['apple',2, 3, 10], 3), 10)
assert_equal(list_index([1], 2), 'Out of Range')

问题二

设计一个函数,list_slice(x, m, n),其中x的数据形式是列表(list),m,n是数字,该函数将返回列表x中的第m个元素到第n个元素。如果m或n大于列表中元素个数,函数将返回’Out of Range’。

# grader format
def list_slice(x, m, n):
    if n>len(x):
        return('Out of Range')
    else:
        return(x[m:n+1])
    raise NotImplementedError()
from nose.tools import assert_equal
assert_equal(list_slice(['apple',2, 3, 10], 0, 2), ['apple', 2, 3])
assert_equal(list_slice([1,2], 0, 3), 'Out of Range')

问题三

设计一个函数,find_digit(x),其中x的数据形式是列表(list),且列表中含有各种类型的数据形式。该函数需要返回在该列表中数据形式为数字的个数。
例如find_digit([1, ‘a’, 3.0, [1, 2]]),将返回2,因为列表x中,只有两个是数字形式的。

# grader format
def find_digit(x):
    # YOUR CODE HERE
    ans=0
    for i in x:
        if isinstance(i,int)or isinstance(i,float):
            ans=ans+1
    return ans
    raise NotImplementedError()
from nose.tools import assert_equal
assert_equal(find_digit([1, 'a', 3.0, [1, 2]]), 2)
assert_equal(find_digit([[1],[1, 2],'12.0']), 0)

问题四

设计一个函数,list_step(x,n),其中x的数据形式是列表(list),n是数字,该函数需要返回以步长为n提取x中的元素。例如list_step([1, 2, 3, 4, 5], 2)将返回[1,3,5]

# grader format
def list_step(x, n):
    # YOUR CODE HERE
    list1=[]
    j=0
    for i in range(n+1):
        list1.append(x[j])
        j=j+2
        if j>len(x)-1:
            break
    return list1
    raise NotImplementedError()
from nose.tools import assert_equal
assert_equal(list_step([1, 2, 3, 4, 5],2), [1, 3, 5])
assert_equal(list_step([1, 2, 3, 4, 5, 6],2), [1, 3, 5])

问题五

设计一个函数,calculate_median(list_1),list_1是一个全部由数字组成的列表,该函数将返回列表中数字的中位数。如果该列表是空列表,则该函数返回’None”。

# grader format
def calculate_median(list_1):
    # YOUR CODE HERE
    if len(list_1)==0:
        return('None')
    else:
        return(list_1[round(len(list_1)/2)])
    raise NotImplementedError()
from nose.tools import assert_equal
assert_equal(calculate_median([]), 'None')
assert_equal(calculate_median([3,1,5,9,7]),5)

PDS.2-213

问题一

设计函数in_list(x, element),x是一个列表,element是一个元素。该函数将判断x中是否含有该element,如果有则返回True如果没有则返回False。

# grader format
def in_list(x, element):
    # YOUR CODE HERE
    return(element in x)
    raise NotImplementedError()
from nose.tools import assert_equal
assert_equal(in_list([3,4,1,1], 1), True)
assert_equal(in_list(['apple',1, 'banana', 1], 'melon'), False)

问题二

设计函数count_element(x, element),x是一个列表,element是一个元素。该函数返回列表x中,元素element的个数。例如count_element([1,1,2], 1)将返回2,因为[1,1,2]中有两个1。

# grader format
def count_element(x, element):
    # YOUR CODE HERE
    ans=0
    for i in x:
        if i==element:
            ans=ans+1
    return ans
    raise NotImplementedError()
from nose.tools import assert_equal
assert_equal(count_element([3,4,1,1], 1), 2)
assert_equal(count_element(['apple',1, 'banana', 1], 'banana'), 1)

问题三

设计函数element_index(x, element),x是一个列表,element是一个元素。该函数将返回列表x中,元素element的所在位置(即索引)。如果该元素不在x中,则函数返回’Not in the list’。

# grader format
def element_index(x, element):
    # YOUR CODE HERE
    ans=-1
    for i in range(0,len(x)):
        if x[i]==element:
            ans=i
            break
    if ans==-1:
        return 'Not in the list'
    else:
        return ans
    raise NotImplementedError()
from nose.tools import assert_equal
assert_equal(element_index([3, 7, 6, 4], 7), 1)
assert_equal(element_index([3, 7, 6, 4], 10), 'Not in the list')

问题四

设计函数copy_list(x, copy_type),x是一个列表,type是copy的类型(‘good’或者‘bad’)。该函数首先根据type进行复制得到列表y,然后判断并返回复制后的列表与原列表是否相同(x is y)。

# grader format
import copy
def copy_list(x, copy_type):
    # YOUR CODE HERE
    if copy_type=='good':
        y=copy.copy(x)
    else:
        y=x
    return(y is x)
    raise NotImplementedError()
from nose.tools import assert_equal
assert_equal(copy_list([1, 2, 3], 'good'), False)
assert_equal(copy_list([1, 2, 3], 'bad'), True)

问题五

设计函数element_exchange(x, m, n),x是一个列表,m和n是数字分别代表x中第m和第n个元素。该函数返回m与n两个位置上的元素,例如element_exchange([1, 2, 3, 4], 1, 2),该函数将返回[1, 3, 2, 4]。

# grader format
def element_exchange(x, m, n):
    # YOUR CODE HERE
    k=x[m]
    x[m]=x[n]
    x[n]=k
    return x
    raise NotImplementedError()
from nose.tools import assert_equal
assert_equal(element_exchange([1, 2, 3], 1, 2), [1, 3, 2])
assert_equal(element_exchange([1, 2, 5, 6], 3, 2), [1, 2, 6, 5])

PDS.2-214

问题一

设计函数add_digit(x, y),x是一个列表,y是一个含有不同元素的列表。该函数需要将y列表中的数字形式(int,float)的元素逐一添加到x列表的尾部,并返回列表x。例如add_digit([‘append’],[1, ‘apple’, 2.0])将返回[‘append’, 1, 2.0]。

# grader format
def add_digit(x, y):
    # YOUR CODE HERE
    for i in y:
        if isinstance(i,int)or isinstance(i,float):
            x.append(i)
    return x
    raise NotImplementedError()
from nose.tools import assert_equal
assert_equal(add_digit([], ['1', '12', '123']), [])
assert_equal(add_digit(['apple'],[1, 'pen', 2]), ['apple', 1, 2])

问题二

设计函数cal_func(x),x是一个列表。该函数计算列表中每个元素$f(x)=x^2+2x+1$的函数值并返回一个含有函数值的列表。例如cal_func([1,2,3]),返回[4, 9,16]。

# grader format
def cal_func(x):
    # YOUR CODE HERE
    y=[]
    for i in x:
        j=i**2+2*i+1
        y.append(j)
    return y
    raise NotImplementedError()
from nose.tools import assert_equal
assert_equal(cal_func([1, 2, 3]), [4, 9,16])
assert_equal(cal_func([0]), [1])

问题三

设计函数insert_element(x,y),x、y是两个列表。该函数将y中元素依次放到x列表中的头部和尾部,并返回更改后的x列表。例如:
insert_element([1,2],[3])将返回[3,1,2]
insert_element([1,2],[3,4])将返回[3,1,2,4]
insert_element([1,2],[3,4,5])将返回[5,3,1,2,4]。

# grader format
def insert_element(x,y):
    # YOUR CODE HERE
    j=-1
    for i in y:
        if j==1:
            j=-j
            x.append(i)
        else:
            j=-j
            x.insert(0,i)
    return x
    raise NotImplementedError()
from nose.tools import assert_equal
assert_equal(insert_element([1,2],[3]), [3,1,2])
assert_equal(insert_element([1,2],[3, 4]), [3,1,2,4])
assert_equal(insert_element([1,2],[3,4,5,6]),[5,3,1,2,4,6])

问题四

设计函数list_concatenate(x,y),x、y是两个列表。该函数将返回x与y结合在一起的列表,例如:list_concatenate([1,2],[3,4])将返回[1,2,3,4]。

# grader format
def list_concatenate(x,y):
    # YOUR CODE HERE
    return x+y
    raise NotImplementedError()
from nose.tools import assert_equal
assert_equal(list_concatenate([1,2],[3]), [1,2,3])
assert_equal(list_concatenate([1,2],[3, 4]), [1,2,3,4])

问题五

设计函数choose_element(x, y, z),x、y、z分别为三个列表。我们需要把x中的第一个元素,y中的第二个元素,以及z中的第三个元素组成一个新的列表并返回该列表。例如choose_element([1,2], [2,3],[1,2,3])将返回[1,3,3]。

# grader format
def choose_element(x,y,z):
    # YOUR CODE HERE
    return([x[0],y[1],z[2]])
    raise NotImplementedError()
from nose.tools import assert_equal
assert_equal(choose_element([1,2],[3,4],[5,6,7,8]), [1,4,7])
assert_equal(choose_element([1,2],[3,'a'], [12,'a',[]]), [1,'a',[]])

PDS.2-215

问题一

设计函数del_index(x, n),其中x是一个列表,n是数字。该函数将删除x列表中第n个元素,例如del_index([‘a’, ‘b’, ‘c’],1)将返回[‘a’,’b’]。

# grader format
def del_index(x, n):
    # YOUR CODE HERE
    x.pop(n)
    return x
    raise NotImplementedError()
from nose.tools import assert_equal
assert_equal(del_index(['1', '12', '123'], 1), ['1', '123'])
assert_equal(del_index([2,1,2,1],2),[2,1,1])

问题二

设计函数del_element(x, element),其中x是一个列表,element是列表中的一个元素。该函数将删除x列表中的该element元素,例如del_element([‘a’, ‘b’, ‘c’],’c’),将返回[‘a’,’b’]。

# grader format
def del_element(x, n):
    # YOUR CODE HERE
    x.remove(n)
    return x
    raise NotImplementedError()
from nose.tools import assert_equal
assert_equal(del_element(['1', '12', '123'], '1'), ['12', '123'])
assert_equal(del_element([2,1,2,1],2),[1,2,1])

问题三

设计函数del_repeat(x, y),其中x、y是两个列表。del_repeat(x,y)将删除x,y中的重复元素,并将新的x、y两个列表相结合形成新的列表,并返回该新列表。例如del_repeat([1,2,3],[2,4,3,7])将返回[1,4,7]。

# grader format
def del_repeat(x, y):
    # YOUR CODE HERE
    z=[]
    for i in x:
        if not i in y:
            z.append(i)
    for i in y:
        if not i in x:
            z.append(i)
    return z
    raise NotImplementedError()
from nose.tools import assert_equal
assert_equal(del_repeat([1,2,3],[1,2,3]), [])
assert_equal(del_repeat([1,2,3],[2,5,6,3]), [1,5,6])
assert_equal(del_repeat([1,2,3],[2,4,3,7]),[1,4,7])

问题四

设计函数switch_elements(list_1, i, j),其中list_1是一个列表,i、j分别表示位置索引。该函数将交换list_1中i和j上元素的位置,例如switch_elements([1,2], 0, 1)将返回[2,1]。

# grader format
def switch_elements(list_1, i, j):
    # YOUR CODE HERE
    k=list_1[i]
    list_1[i]=list_1[j]
    list_1[j]=k
    return list_1
    raise NotImplementedError()
from nose.tools import assert_equal
assert_equal(switch_elements([1,2], 0, 1), [2,1])
assert_equal(switch_elements(['Alibaba','Google','Facebook', 'Baidu'], 1, 3), ['Alibaba','Baidu','Facebook', 'Google'])

问题五

设计函数switch_three_elements(list_1, i, j, k),其中list_1是一个列表,i、j、k分别表示位置索引,该函数将依次替换元素。例如:
switch_three_elements([1,2,3], 0,1,2)将返回[2,3,1];
switch_elements([1,2,3,4],0,1,3)将返回[2,4,3,1]。

# grader format
def switch_three_elements(list_1, i, j, k):
    # YOUR CODE HERE
    a=list_1[i]
    list_1[i]=list_1[j]
    list_1[j]=a
    a=list_1[j]
    list_1[j]=list_1[k]
    list_1[k]=a
    return list_1
    raise NotImplementedError()
from nose.tools import assert_equal
assert_equal(switch_three_elements([1,2,3], 0,1,2), [2,3,1])
assert_equal(switch_three_elements([1,2,3,4],0,1,3), [2,4,3,1])

PDS.2-216

问题一

设计函数sort_element(x),其中x是一个列表。该函数将对列表中的元素从小到大排序并返回排序后的列表,例如sort_element([1, 7, 3, 4])将返回[1,3,4,7]。

# grader format
def sort_element(x):
    # YOUR CODE HERE
    x.sort()
    return x
    raise NotImplementedError()
from nose.tools import assert_equal
assert_equal(sort_element([1, 7, 3, 4]), [1, 3, 4, 7])
assert_equal(sort_element([2,1,2,1]),[1,1,2,2])

问题二

设计函数reverse_element(x),其中x是一个列表。该函数将对列表中的元素从大到小排序并返回排序后的列表,例如reverse_element([1, 7, 3, 4])将返回[7,4,3,1]。

# grader format
def sort_element(x):
    # YOUR CODE HERE
    x.sort()
    x.reverse()
    return x
    raise NotImplementedError()
from nose.tools import assert_equal
assert_equal(sort_element([1, 7, 3, 4]), [7, 4, 3, 1])
assert_equal(sort_element([2,1,2,1]),[2,2,1,1])

问题三

设计函数concatenate_sort(x, y),其中x、y是两个列表。该函数将合并x与y列表,然后对新列表进行从小到大排序。

# grader format
def concatenate_sort(x, y):
    # YOUR CODE HERE
    z=x+y
    z.sort
    return(z)
    raise NotImplementedError()
# YOUR CODE HERE
#raise NotImplementedError()

问题四

设计函数select_sort(x),其中x是一个列表。该函数将提取x中第0,2,4,6….位置上的元素,然后对这些提取后的元素进行从小到大排序。

# grader format
def select_sort(x):
    # YOUR CODE HERE
    y=[]
    for i in range(0,len(x),2):
        y.append(x[i])
    y.sort()
    return y
    raise NotImplementedError()
from nose.tools import assert_equal
assert_equal(select_sort([1, 7, 3, 4]), [1, 3])
assert_equal(select_sort([1, 7, 3, 4, 9, 2,10,0]), [1, 3, 9, 10])

问题五

设计函数sum_odd(x),其中x是一个列表。该函数将提取x中的奇数以及3的倍数,然后将这些提取后的数相加,例如sum_odd([1,6,2,4,7]),该函数将返回14(1,7是奇数,6是3的倍数)

# grader format
def sum_odd(x):
    # YOUR CODE HERE
    ans=0
    for i in x:
        if i%2==1or i%3==0:
            ans=ans+i
    return ans
    raise NotImplementedError()
from nose.tools import assert_equal
assert_equal(sum_odd([1,6,2,4,7]), 14)
assert_equal(sum_odd([3,12,8]),15)

PDS.2-217

问题一

设计函数check_tuple(x),其中x是某一种数据形式(数字,列表,元组等)。该函数将判断x是否为元组,如果是则返回字符串’A Tuple’,如果不是元组则返回’Not A Tuple’。

# grader format
def check_tuple(x):
    # YOUR CODE HERE
    if isinstance(x,tuple):
        return 'A Tuple'
    else:
        return 'Not A Tuple'
    raise NotImplementedError()
from nose.tools import assert_equal
assert_equal(check_tuple('x'), 'Not A Tuple')
assert_equal(check_tuple((1,2)),'A Tuple')

问题二

设计函数change_tuple(x, pos, element),其中x是某一个元组,pos数字表示索引,element某种数据形式。该函数将元组中pos上的元素替换为element,并返回一个新的元组。例如change_tuple((3,4,5,7),2,10)将返回(3,4,10,7)。

# grader format
def change_tuple(x, pos, element):
    # YOUR CODE HERE
    seq=list(x)
    seq[pos]=element
    x=tuple(seq)
    return x
    raise NotImplementedError()
from nose.tools import assert_equal
assert_equal(change_tuple((3,4,5,7),2,10), (3,4,10,7))
assert_equal(change_tuple((3,4,5,7),0,'first'), ('first',4,5,7))

问题三

设计函数list_transform(x),其中x是两维列表(之后会学习到)。该函数将两维列表转换成一维列表,例如list_transform([[1,2],[3,4]])将返回[1,2,3,4]。

# grader format
def list_transform(x):
    # YOUR CODE HERE
    seq=list(x)
    y=[]
    for i in seq:
        y=y+i
    return y
    raise NotImplementedError()
from nose.tools import assert_equal
assert_equal(list_transform([[1,2],[3,4]]), [1,2,3,4])
assert_equal(list_transform([[1],[2,3],[4,5,6]]),[1,2,3,4,5,6])

问题四

设计函数rolling_average(x,n),x是一个列表,n是数字,该函数将返回列表中数字的移动平均。例如rolling_average([1,2,3,4],2)将返回[1.5,2.5,3.5],因为n=2,所以返回后的第一个元素是(1+2)/2,第二个元素是(2+3)/2,第三个元素是(3+4)/2。

# YOUR CODE HERE
def rolling_average(x,n):
    y=[]
    for j in range(round(len(x)/2)+1):
        a=0
        for i in range(n):
            a=a+x[i+j]
        y.append(a/n)
    return y
    raise NotImplementedError()
from nose.tools import assert_equal
assert_equal(rolling_average([1,2,3,4],2), [1.5,2.5,3.5])
#By不做评论
说点什么
欢迎留言~
支持Markdown语法
暂时没有评论。
Loading...