头歌实践教学平台——Python程序设计之函数

def pow(x, n):  # 幂运算函数
    """接收一个数字x和一个整数n为参数,返回x的n次幂的结果的浮点数类型
    要求使pow(1.0, x) 和 pow(x, 0.0) 总是返回 1.0"""
    #########################Begin############################### 
    return 1.0*x**n

    #########################End############################### 



if __name__ == '__main__':
    x = float(input())
    n = int(input())
    return_data = pow(x,n)
    print(return_data)

最大公约数

def gcd(a, b):
    """接收两个正整数为参数，返回两个数的最大公约数"""
    #######################Begin############################
    m = max(a, b)
    n = min(a, b)
    r = m % n
    while r != 0:
        m = n
        n = r
        r = m % n
    return n



    #######################End############################

if __name__ == '__main__':
    a = int(input())
    b = int(input())
    return_data = gcd(a,b)
    print(return_data)

最小公倍数

def lcm(a, b):
    """接收两个正整数为参数，以整数类型返回两个数的最小公倍数"""
    ######################Begin###############################
    m = max(a, b)
    while True:
        if m % a == 0 and m % b == 0:
            return m
        m+=1
    return m


    ######################End###############################

if __name__ == '__main__':
    a = int(input())
    b = int(input())
    return_data = lcm(a,b)
    print(return_data)

fabs() 函数

def fabs(x):
    """返回x的绝对值"""
    ######################Begin###############################
    if x>0 :
        return x/1.0
    else:
        return -x/1.0

    ######################End###############################

if __name__ == '__main__':
    x = eval(input())
    return_data = fabs(x)
    print(return_data)

ceil() 函数

import math
def ceil(x):
    """接受一个浮点数或整数，返回大于或等于该数的最小整数"""
    ######################Begin###############################
    return f'{math.ceil(x)}'
 

    ######################End###############################
 
if __name__ == '__main__':
    x = eval(input())
    return_data = ceil(x)
    print(return_data)

floor()函数详解

import math
def floor(x):
    """接受一个浮点数或整数，返回不大于该数的最大整数"""
    ######################Begin###############################
    return f'{math.floor(x)}'
 
 
 
    ######################End###############################
    
if __name__ == '__main__':
    x = eval(input())
    return_data = floor(x)
    print(return_data)

factorial函数详解

import math
def factorial(n):
    """接收一个非负整数n为参数，返回n的阶乘，0的阶乘值为1"""
    ######################Begin###############################
 
    if n == 0:
        return 1
    return f'{math.factorial(n)}'
"""
    s = 1
    i = n
    if n == 0:
        return 1
    while i != 0:
        s = s * i
        i -= 1
    return s
"""
    ######################End###############################
 
if __name__ == '__main__':
    x = int(input())
    return_data = factorial(x)
    print(return_data)

fsum函数

def fsum(iterable):
    """接收一个元素为数值的序列为参数，以浮点数类型返回各元素之和"""
    ######################Begin###############################
    return f'{float(sum(iterable))}'
 
 
 
 
 
    ######################End###############################
 
 
if __name__ == '__main__':
    x = list(map(eval, input().split()))
    return_data = fsum(x)
    print(return_data)

4.3 素数及应用(project)

素数判定

def is_prime(n): 
    """判断素数的函数,接收一个正整数为参数，返回值是布尔类型。参数是素数时返回True，否则返回False"""
    #==================Begin=================================
    # 补充你的代码
    if n < 2 :
        return False
    else:
        for i in range(2,n):
            if n % i ==0:
                return False
        return True
    #===================End================================
 
positive_int = int(input())      # 输入一个正整数
if is_prime(positive_int):
    print(f'{positive_int}是素数') 
else:
    print(f'{positive_int}不是素数')

输出N以内的所有素数

def is_prime(n):
    """判断素数的函数,接收一个正整数为参数，参数是素数时返回True，否则返回False。减小判定区间，减少循环次数，提升效率"""
    #======================Begin=================================
    # 补充你的代码
    if n < 2 :
        return False
    else:
        a = int(n**(1/2)+1)
        for i in range(2,a):
            if n % i ==0:
                return False
        return True
    #=======================End================================
 
def output_prime(number):
    """接收一个正整数为参数，遍历从0到number之间的所有整数
    在一行中输出不大于number的所有素数，每个数字后一个空格，函数无返回值。"""
    #======================Begin=================================
    # 补充你的代码
    for i in range(number+1):
        if is_prime(i):
            print(i,end=" ")
    #=======================End================================
 
positive_int = int(input())  
output_prime(positive_int)

寻找回文素数

def is_prime(n):
    """判断素数的函数,接收一个正整数为参数，参数是素数时返回True，否则返回False。减小判定区间，减少循环次数，提升效率"""
    #======================Begin=================================
    # 补充你的代码
    if n < 2 :
        return False
    elif n == 2:
        return True
    else:
        a= int(n**(1/2)+1)
        for i in range(2,a+1):
            if n % i ==0:
                return False
        return True
    #=========================End==============================
 
def plalindrome_prime(number):
    """接收一个正整数参数number，遍历从0到number之间的所有整数，
    若某个数是素数，且转为字符串后是回文字符串，则称其中回文素数
    找出并在同一行中输出小于number的所有回文素数，每个数字后一个空格，函数无返回值。"""
    #======================Begin=================================
    # 补充你的代码
    for i in range(number):
        if is_prime(i) and str(i) ==str(i)[::-1]:
            print(i,end = " ")
    #=========================End==============================
 
positive_int = int(input())
plalindrome_prime(positive_int)

寻找反素数

def is_prime(n):
    """判断素数的函数,接收一个正整数为参数，参数是素数时返回True，否则返回False。减小判定区间，减少循环次数，提升效率"""
    #======================Begin=================================
    # 补充你的代码
    if n < 2 :
        return False
    elif n == 2:
        return True
    else:
        a= int(n**(1/2)+1)
        for i in range(2,a+1):
            if n % i ==0:
                return False
        return True
    #========================End===============================
 
def reverse_prime(number):
    """接收一个正整数参数，找出并在同一行内输出所有小于number的反素数，每个数字后一个空格。
    反素数指某数i及其逆序数都是素数，但数i对应的字符串不是回文字符串。函数无返回值"""
    #======================Begin=================================
    # 补充你的代码
    for i in range(number):
        if is_prime(i) and is_prime(int(str(i)[::-1])) and str(i) !=str(i)[::-1]:
            print(i,end = " ")          
    #========================End===============================
positive_int = int(input())         
reverse_prime(positive_int)

哥德巴赫猜想

def is_prime(n):
    """判断素数的函数,接收一个正整数为参数，参数是素数时返回True，否则返回False"""
    # ====================Begin===================================
    # 补充你的代码
    if n < 2:
        return False
    elif n == 2:
        return True
    else:
        a = int(n ** (1 / 2) + 1)
        for i in range(2, a + 1):
            if n % i == 0:
                return False
        return True
    # ======================End=================================
 
def goldbach_conjecture(num):
    """ 哥德巴赫猜想, 接收一个不小于4的正整数为参数。
    当参数为不小于4的偶数时，将其分解为两个素数的加和，按小数+数的格式输出。
    有多种组合时全部输出，但不输出重复的组合，例如输出8=3+5，不输出8=5+3。
    参数为奇数或小于4时，输出'Data error!'
    """
    # ====================Begin===================================
    # 补充你的代码
 
    if 4<=num and num % 2 == 0:
        for i in range(1,num + 1):
            n = num - i
            if is_prime(i) and is_prime(n) and i<=n :
                print(f"{num}={i}+{n}")
    else:
        print('Data error!')
 
    # ======================End=================================
 
if __name__ == '__main__':
    positive_even = int(input())  # 输入一个正数
    goldbach_conjecture(positive_even)