2019-11-14作业

1. 编写函数，求1 + 2 + 3 +…N的和

def ld_sum(n:int):
    """
    (函数的功能：求1~N的和）
    :param n:
    :return:
    """
    s = 0
    for x in range(n + 1):
        s += x
    print("1~%d的和是：%d" % (n, s))

2. 编写一个函数，求多个数中的最大值

def ld_max(*nums):
    """
    (函数功能：求多个数中的最大值）
    :param num: 请输入多个数
    :return:
    """
    x = num[0]
    for y in num:
        if x < y:
            x = y
    print(x)

3. 编写一个函数，实现摇骰子的功能，打印N个骰子的点数和

def dice(n: int):
    """
    (函数功能：打印N个骰子的点数和)
    :param n: 输入几个骰子
    :return:
    """
    from random import randint
    a = randint(1, 6)
    s = 0
    for _ in range(n):
        s += a
    print(s)

4.编写一个函数，交换指定字典的key和value。

def exchange(n:dict):
    """
    (函数功能：交换指定字典的key和value）
    :param n: 指定字典
    :return:
    """
    new_n ={}
    for x in n:
        new_n[n[x]]=x
    n = new_n
    print(n)

5. 编写一个函数，提取指定字符串中所有的字母，然后拼接在一起产生一个新的字符串

def link(*s: str):
    x = ""
    for char1 in s:
        if "A" <= char1 <= "Z" or "a" <= char1 <= "z":
            x += char1
    print(x)

6.写一个函数，求多个数的平均值

def average(*n):
    avg = 0
    sum = 0
    for num in n:
        sum += num
    avg = sum / len(n)
    print("%d个数的平均值是%d" % (n, avg))

2. 写一个函数，默认求10的阶乘，也可以求其他数字的阶乘

def factorial(n=10):
    s = 1
    for num in range(1, n + 1):
        s *= num
    print("%d阶乘是%d" % (n, s))

1. 写一个自己的capitalize函数，能够将指定字符串的首字母变成大写字母

def ld_cap(*char: str):
    char1 = str(char)
    if "a" <= char1[0] <= "z":
        char1[0] = chr(ord(char1[0]) - 32)
    print(char1)

2. 写一个自己的endswith函数，判断一个字符串是否已指定的字符串结束

def endswith(str1: str, str2: str):
    if str2[::-1] == str1[:-len(str2)-1:-1]:
        return True
    else:
        return False

1. 写一个自己的isdigit函数，判断一个字符串是否是纯数字字符串

def ld_isdigit(n: str):
    str1 = str(n)
    count1 = 0
    for num in str1:
        if "0" <= num <= "9":
            count1 += 1
            if count1 == len(str1):
                print("True")
        else:
            print("False")

1.写一个自己的upper函数，将一个字符串中所有的小写字母变成大写字母

def ld_upper(*n: str)
    str1 = str(n)
    str2 = ""
    for value in str1:
        if not "a" <= value <= "z":
            str2 += value
        elif "a" <= value <= "z":
            x = chr(ord(x) - 32)
            str2 += x
    print(str2)

2. 写一个自己的rjust函数，创建一个字符串的长度是指定长度，原字符串在新字符串中右对齐，剩下的部分用指定的字符填充

def riust(str1: str, width: int, char: str):
    length = len(str1)
    return (width - length) * char + str1

3.写一个自己的index函数，统计指定列表中指定元素的所有下标，如果列表中没有指定元素返回 - 1

def ld_index(list1: list, value):
    if value in list1:
        for index in range(len(list1)):
            if value == list1[index]:
                print(index, end=",")
    else:
        print("-1")

1. 写一个自己的len函数，统计指定序列中元素的个数

def id_len(n):
    count = 0
    for num1 in n:
        count += 1
    return count

1. 写一个自己的max函数，获取指定序列中元素的最大值。如果序列是字典，取字典值的最大值

def ld_max(seq):
    max1 = seq[0]
    max2 = 0
    if type(seq) == dict:
        for key in seq:
            if seq[key] > max2:
                max2 = seq[key]
        return max2
    else:
        list1 = list(seq)
        for index in range(len(list1)):
            if list1[index] > max1:
                max1 = list1[index]
    return max1

1. 写一个函数实现自己in操作，判断指定序列中，指定的元素是否存在

def ld_in(seq, value):
    for index in seq:
        if index == value:
            return True
    else:
        return False

1. 写一个自己的replace函数，将指定字符串中指定的旧字符串转换成指定的新字符串

def replace(str1: str, old: str, new: str):
    new1 = str1.split(old)
    s = new.join(new1)
    return s

1.写四个函数，分别实现求两个列表的交集、并集、差集、补集的功能

def set_1(list1: list, list2: list):
    set1 = set(list1)
    set2 = set(list2)
    return set1 & set2


def set_2(list1: list, list2: list):
    set1 = set(list1)
    set2 = set(list2)
    return set1 | set2


def set_3(list1: list, list2: list):
    set1 = set(list1)
    set2 = set(list2)
    return set1 - set2


def set_4(list1: list, list2: list):
    set1 = set(list1)
    set2 = set(list2)
    # set2的补集
    return (set1 | set2) - set2


def set_5(list1: list, list2: list):
    set1 = set(list1)
    set2 = set(list2)
    # set1的补集
    return (set1 | set2) - set1