Day-10 - 作业（2018-10-11）

写一个函数将一个指定的列表中的元素逆序(如[1, 2, 3] -> [3, 2, 1])(注意:不要使 表自带的逆序函数)

def reverse_list(any_list: list):
    """
    声明一个函数，使指定列表的元素反序
    :param any_list:  指定一个列表
    :return: 指定的列表
    """
    for index in range(len(any_list)):
        # 不停地将最后一个元素弹出，并将其插入到index下标中
        last_item = any_list.pop(-1)
        any_list.insert(index, last_item)


list1 = [1, 2, 3, 4, 5, 6, 7]
reverse_list(list1)
print(list1)

写一个函数，提取出字符串中所有奇数位上的字符

def yxy_odd(any_str: str):
    """
    声明一个函数，将指定字符串奇数位上的字符提取出来
    :param any_str: 字符串
    :return: 列表
    """
    list1 = []
    for index in range(len(any_str)):
        if not index & 1:
            list1.append(any_str[index])

    return list1


str1 = 'abcdefg'
str2 = yxy_odd(str1)
print(str2)  # ['a', 'c', 'e', 'g']

写一个匿名函数，判断指定的年是否是闰

re = lambda year: (year % 4 == 0 and year % 100 !=0) or year % 400 == 0
print(re(2000))
print(re(1990))
print(re(1992))

使用递归打印:

n = 3
的时候


    @
  @ @ @
@ @ @ @ @


n = 4
的时候:


      @
    @ @ @
  @ @ @ @ @
@ @ @ @ @ @ @

def print_at(n: int, i: int):
    """
    定义一个函数，打印三角形
    :param n: 数字，整数
    :param i: 数字，i=n
    :return:
    """
    if n == 1:
        print('@'.center(2*i-1,' '))
        return
    print_at(n-1, i)
    print(('@'*(2*n - 1)).center(2*i-1,' '))

print_at(4,4)

写函数, 利用递归获取斐波那契数列中的第10个数，并将该值返回给调用者。

def fb_num(n):
    if n <= 2:
        return 1
    return fb_num(n-1) + fb_num(n-2)


num = fb_num(10)
print(num)  # 55

写一个函数，获取列表中的成绩的平均值，和最高分

def yxy_score(scores: list) -> tuple:
    """
    声明一个函数，用来计算列表中成绩的平均值和最高分,返回一个元组
    :param scores: 成绩，列表
    :return: 元组，第一个值为平均值，第二个值为最高分
    """
    average = sum(scores)/len(scores)
    max_num = max(scores)
    return average, max_num


list1 = [90, 89, 98, 100, 95]
score = yxy_score(list1)
print('平均分：%s, 最高分: %s' % (score[0],score[1]))  # 平均分：94.4, 最高分: 100

写函数，检查获取传入列表或元组对象的所有奇数位索引对应的元素，并将其作为新的列表返回给调用者

def odd_item(items: list or tuple) -> list:
    """
    声明一个函数，获取列表或者元组奇数位索引的元素，并返回一个新列表
    :param items: list or tuple
    :return:
    """
    list1 = []
    for item in items[::2]:
        list1.append(item)
    return list1


list1 = [1, 2, 3, 4, 5, 6]
tuple1 = ('a', 'b', 'c', 'd', 'e', 'f')
print(odd_item(list1))  # [1, 3, 5]
print(odd_item(tuple1))  # ['a', 'c', 'e']

实现属于自己的字典update方法：用一个字典去更新另一个字典的元素(不能使用自带的update方法)
yt_update(字典1， 字典2)

def yxy_update(original_dict: dict, update_dict: dict) -> dict:
    """
    声明一个函数，用update_dict字典中的元素更新original_dict字典，并返回更新结果
    :param original_dict: 字典
    :param update_dict: 字典
    :return: 字典
    """
    for new_key in update_dict:
        original_dict[new_key] = update_dict[new_key]

    return original_dict


dict1 = {'a':1 , 'b': 2, 'c': 3, 'd': 4}
dict2 = {'f': 200, 'g': 300, 'b': 400, 'h': 500}
new_dict = yxy_update(dict1, dict2)
print(new_dict)  # {'a': 1, 'b': 400, 'c': 3, 'd': 4, 'f': 200, 'g': 300, 'h': 500}

实现属于自己的items方法：将字典转换成列表，字典中的键值对转换成元祖。（不能使用items方法）
yt_items(字典)
例如：{'a': 1, 'b': 2, 'c': 3} - --> [('a', 1), ('b', 2), ('c', 3)]

def yxy_items(dict1: dict) -> list:
    """
    声明一个函数，将字典转换成列表，字典中的键值对转换成元组
    :param dict1: 字典
    :return: 列表，元素为元组
    """
    list1 = []
    for key in dict1:
        # 元组不能添加，只能赋值
        tuple1 = (key, dict1[key])
        list1.append(tuple1)

    return list1


dict1 = {'a': 1, 'b': 2, 'c': 3}
list1 = yxy_items(dict1)
print(list1)  # [('a', 1), ('b', 2), ('c', 3)]