学习目标：

• 掌握无参数函数的定义和调用
• 掌握带参数函数的定义和调用，例如：普通参数、缺省参数、不定长参数
• 掌握return的使用，例如：中断函数、中断函数同时返回一个结果
• 知道函数调用的执行流程，例如：普通函数调用流程、嵌套调用流程
• 知道局部变量和全局变量的区别
• 知道函数内如何修改全局变量

01_函数的基本使用

学习目标：

• 知道函数的作用
• 掌握无参数函数的定义和调用

1.1 函数基本概念

• 所谓函数，就是把 具有独立功能的代码块 组织为一个整体，在需要的时候 调用
• 函数的使用包含两个步骤：
  • 定义函数 —— 在函数中编写代码，实现功能
  • 调用函数 —— 执行编写的代码
• 函数的作用：
  • 提高代码编写效率, 代码重用
  • 写一次函数代码块，后面使用的时候，只需要调用函数即可，无需重新编写函数代码块

函数定义
def foo():
    print("                            _ooOoo_  ")
    print("                           o8888888o  ")
    print("                           88  .  88  ")
    print("                           (| -_- |)  ")
    print("                            O\ = /O  ")
    print("                        ____/`---'\____  ")
    print("                      .   ' \| |// `.  ")
    print("                       / \||| : |||// \  ")
    print("                     / _||||| -:- |||||- \  ")
    print("                       | | \\\ - /// | |  ")
    print("                     | \_| ''\---/'' | |  ")
    print("                      \ .-\__ `-` ___/-. /  ")
    print("                   ___`. .' /--.--\ `. . __  ")
    print("                ."" '< `.___\_<|>_/___.' >'"".  ")
    print("               | | : `- \`.;`\ _ /`;.`/ - ` : | |  ")
    print("                 \ \ `-. \_ __\ /__ _/ .-` / /  ")
    print("         ======`-.____`-.___\_____/___.-`____.-'======  ")
    print("                            `=---='  ")
    print("  ")
    print("         .............................................  ")
    print("                  佛祖镇楼                  BUG辟易  ")
    print("          佛曰:  ")
    print("                  写字楼里写字间，写字间里程序员；  ")
    print("                  程序人员写程序，又拿程序换酒钱。  ")
    print("                  酒醒只在网上坐，酒醉还来网下眠；  ")
    print("                  酒醉酒醒日复日，网上网下年复年。  ")
    print("                  但愿老死电脑间，不愿鞠躬老板前；  ")
    print("                  奔驰宝马贵者趣，公交自行程序员。  ")
    print("                  别人笑我忒疯癫，我笑自己命太贱；  ")
    print("                  不见满街漂亮妹，哪个归得程序员？")


# 需要使用时，函数调用即可，无需重复编写函数体内容
foo()

print('其他代码')

# 需要使用时，函数调用即可，无需重复编写函数体内容
foo()

1.2 函数的定义和调用

1.2.1 函数的定义

定义函数的格式如下：

def 函数名():
    函数内部的代码块
    ……

• def 是英文 define 的缩写
• 函数名称 的命名应该 符合 标识符的命名规则
  • 可以由 字母、下划线 和 数字 组成
  • 不能以数字开头
  • 不能与关键字重名
  • 建议不要和类型同名

1.2.2 函数的调用

• 函数只是定义，不调用不会自动执行，用户看不到没有效果

• 函数调用的格式：

  函数名字()
  

1.2.3 第一个函数演练

需求

• 编写一个打招呼 say_hello 的函数，封装三行打招呼的代码

• 在函数下方调用打招呼的代码

示例代码：

"""
步骤流程：
函数定义：
1. def 函数名字():
    2. 函数体，打印信息

函数调用：函数名字()
"""


# 函数定义
def say_hello():
    print("hello 1")
    print("hello 2")
    print("hello 3")


print('函数调用前')

say_hello()  # 函数调用

print('函数调用后')

运行结果：

函数调用前
hello 1
hello 2
hello 3
函数调用后

02_函数执行过程、文档注释

学习目标：

• 知道函数调用的执行流程
• 能够知道函数文档的编写格式

---

2.1 函数执行流程

2.1.1 函数执行流程

• 如果不主动调用函数，函数是不会主动执行的
• 函数调用时，默认往前面找函数的定义，如果没有找到函数定义，则报错：
  • NameError: name 'say_hello' is not defined (名称错误：say_hello 这个名字没有被定义)

函数执行流程：

2.1.2 Debug 的单步调试

• F7 Step Into 可以单步执行代码，如果是函数，会进入函数内部

•  F8 Step Over 可以单步执行代码，如果函数，直接执行函数，不会进入函数内部

2.2 函数的文档注释

• 在开发中，如果希望给函数添加文档注释，应该在 定义函数 的下方，使用 连续的一对三引号

• 在 连续的一对三引号 之间编写对函数的说明文字

  def func_sum():
      """求和 1+2"""
      add_result = 1 + 2
      print(add_result)
  
  func_sum()
  

• 在 函数调用 位置，使用快捷键 Ctrl + Q 可以查看函数的说明信息

03_函数的参数1：普通参数

学习目标：

• 掌握带参数函数的使用

---

3.1 函数参数的作用

假如开发一个 func_sum 的函数，函数能够实现 两个数字的求和 功能：

# 函数定义
def func_sum():
    """两个数字的求和"""
    num1 = 10
    num2 = 20
    result = num1 + num2
    print("%d + %d = %d" % (num1, num2, result))


# 函数调用
func_sum()

• 以上函数只能处理 固定数值 的相加

• 函数参数，可以解决上面的问题，可以传递数据给函数内部，增加函数的 通用性

3.2 带参数函数的使用

3.2.1 带参数函数的定义和调用

• 函数定义时的参数叫 形参，函数调用时的参数叫 实参

• 带参数函数的定义格式：

  def 函数名字(形参1，形参2，……):
      函数体代码块
  

• 带参数函数的调用格式：

  函数名字(实参1，实参2，……)
  

示例代码：

# 带参数函数的函数定义
def func_sum(num1, num2):
    """两个数字的求和"""
    result = num1 + num2
    print("%d + %d = %d" % (num1, num2, result))


# 带参数函数的调用
func_sum(20, 30)

3.2.2 函数执行流程

• 函数调用时，按照函数定义的形参顺序，实参 一一对应 传递给形参

3.2.3 形参的作用域

• 作用域：变量起作用的范围

• 形参的作用域：只在定义函数的代码块 中

# 形参作用域仅在函数内部, 所以不同函数的同名参数，互不影响
def func_sum(num1, num2):
    result = num1 + num2
    print(result)


def func_sub(num1, num2):
    result = num1 - num2
    print(result)


func_sum(1, 3)
func_sub(4, 4)

04_函数的返回值

学习目标：

• 掌握return关键的使用，例如：中断函数、中断函数同时返回一个结果

---

4.1 函数返回值的作用

• 开发中，有时会希望 一个函数执行结束后，告诉调用者一个结果，以便调用者针对具体的结果做后续的处理
• 返回值 是 函数给调用方提供的结果

前面接触到返回值的例子：

"""
返回值变量 = input()
返回值变量 = len(容器变量)
"""

# 从键盘输入一个内容，内容返回给name赋值
name = input('请输入你的名字：')
print(name)

my_str = 'hello'
# 获取my_str内容的元素个数，返回给n赋值
n = len(my_str)
print(n)

4.2 return关键字的使用

4.2.1 通过return给函数设置返回值

• return 关键字只能使用在函数中

• 在函数中使用 return 关键字可以中断函数，同时也返回一个结果

• 调用函数一方，可以 使用变量 来 接收 函数的返回结果

"""
函数定义格式：
def 函数名():
    return 结果

函数调用格式：
返回值变量 = 函数名()
"""


def func_sum(num1, num2):
    """两个数字的求和"""
    result = num1 + num2
    return result  # 中断函数，同时也返回一个结果


# 函数调用：返回值变量 = 函数名()
ret = func_sum(20, 30)
print(ret)

函数调用执行流程：

4.2.2 函数默认返回值

• 函数内部没有任何return语句，默认返回None，表示没有任何数据

• return不设置返回值，默认也返回None

# 函数定义，函数内部没有任何return语句
def normal_func():
    print('^_^')


# 函数定义，return不设置返回值
def return_test():
    return


# 函数调用
ret1 = normal_func()
print(ret1)  # None

ret2 = return_test()
print(ret2)  # None

4.2.3 return中断函数

• 函数一旦执行return，函数内return下一句往后的代码不会执行

# 函数定义
def func():
    print('不努力，你来黑马程序员干嘛？')
    return
    print('我想玩游戏')


# 函数调用
func()

运行结果：

不努力，你来黑马程序员干嘛？

05_4种函数的类型

学习目标：

• 知道4 种函数类型的分类

---

5.1 4 种函数类型的分类

• 函数根据有没有参数，有没有返回值，可以相互组合，一共有4种
  • 无参数，无返回值
  • 无参数，有返回值
  • 有参数，无返回值
  • 有参数，有返回值

• 定义函数时，是 根据实际的功能需求来设计 的，所以不同开发人员编写的函数类型各不相同

5.2 无参数，无返回值的函数

"""无参数，无返回值的格式

函数定义：
def 函数名():
    函数体

函数调用：
函数名()
"""


# 函数定义
def menu():
    """功能菜单"""
    print('='*20)
    print('= 1. 添加学生')
    print('= 2. 删除学生')
    print('= 3. 查询学生')
    print('=' * 20)


# 函数调用
menu()

5.3 无参数，有返回值的函数

"""无参数，有返回值的函数

函数定义：
def 函数名字():
    return 返回结果

函数调用：
返回值变量 = 函数名字()
"""


# 函数定义
def get_pi():
    """
    获取圆周率
    :return:　返回圆周率
    """
    return 3.14


# 函数调用
pi = get_pi()
print('圆周率为:%f' % pi)

5.4 有参数，无返回值的函数

"""有参数，无返回值的函数
函数定义：
def 函数名字(形参1，形参2，……)：
    函数体

函数调用：
函数名(实参1，实参2，……)
"""


# 函数定义
def print_char(num, char):
    """
    功能：打印指定数量的字符
    :param num: 打印字符的个数，整型
    :param char: 打印的字符，字符串格式
    :return: None
    """
    print(num * char)


# 函数调用
print_char(5, '^_^ ')

5.5 有参数，有返回值的函数

"""有参数，有返回值的函数
函数定义：
def 函数名字(形参1，形参2，……):
    函数体
    return 返回结果

函数调用：
返回变量 = 函数名字(实参1，实参2，……)
"""


# 函数定义
def func_sum(n):
    """
    功能：实现1~n累加和
    :param n: n 控制累加的范围
    :return: 累加后的最终结果
    """
    # 1. 设置条件变量
    i = 1
    _sum = 0
    # 2. while 条件(i <= n):
    while i <= n:
        # 3. 累加
        _sum += i
        # 4. 条件变量改变
        i += 1

    # 5. 循环外面，返回累加的最终结果
    return _sum


# 函数调用
ret = func_sum(100)
print(ret)

06_函数的嵌套调用

学习目标：

• 知道函数嵌套调用的执行流程

---

6.1 函数的嵌套调用

• 一个函数里面 又调用 了 另外一个函数，这就是 函数嵌套调用

# 定义fun01函数
def fun01():
    print('开始调用fun01')
    print('结束调用fun01')


# 定义fun02函数，在代码块中间调用fun01
def fun02():
    print('开始调用fun02')
    # 调用fun01
    fun01()
    print('结束调用fun02')


# 函数调用
fun02()

• 如果函数 func02 中，调用了另外一个函数 func01

  • 那么执行到调用 func01 函数时，会先把函数 func01 中的任务都执行完
  • 才会回到 func02 中调用函数 func01 的位置，继续执行后续的代码

6.2 函数嵌套的应用

6.2.1 打印多行分隔线

需求：

(1) 设计一个函数，打印一行分隔线：可指定数量，可指定分隔线字符的样式 如： 一行分隔线字符的数量为5，字符样式为'^_^ '

 ^_^ ^_^ ^_^ ^_^ ^_^

(2) 设计一个函数，打印n行分隔线，可指定一行分隔线字符的数量，可指定分隔线字符的样式 如：3行分隔线，一行分隔线字符的数量为5，字符样式为'^_^ '

 ^_^ ^_^ ^_^ ^_^ ^_^
 ^_^ ^_^ ^_^ ^_^ ^_^
 ^_^ ^_^ ^_^ ^_^ ^_^

示例代码：

def print_char(num, char):
    """
    功能：打印指定数量字符的分隔线
    :param num: 字符的数量
    :param char: 字符样式
    :return: None
    """
    print(num * char)


def print_lines(n, num, char):
    """
    功能：打印n行分隔线
    :param n: 打印的行数
    :param num: 一行分隔线字符的数量
    :param char: 分隔线的字符样式
    :return: None
    """
    # 1. 设置条件变量 i = 0
    i = 0
    # 2. while 条件：
    while i < n:
        # 3. 打印一行的分隔线
        print_char(num, char)

        # 4. 条件变量的改变
        i += 1

# 函数调用
print_lines(3, '^_^ ', 5)

6.2.2 求三个数的平均值

需求：

(1) 设计一个函数求三个数的和

(2) 设计一个函数求三个数的平均值

示例代码：

"""
1. 设计一个函数求三个数的和
2. 设计一个函数求三个数的平均值
"""

def sum_3_number(a, b, c):
    """求3个数的和"""
    return a + b + c

def avg_3_number(a, b, c):
    """求3个数的平均值"""

    # 先对3数求和，返回值为求和后的结果
    sum_result = sum_3_number(a, b, c)
    # 接着，再求平均值
    avg_result = sum_result / 3

    # 最终平均值结果作为函数返回值
    return avg_result

# 调用函数，完成对3个数求平均值
result = avg_3_number(11, 2, 55)
print("average is %.2f" % result)

07_局部变量和全局变量

学习目标：

• 知道局部变量和全局变量的区别
• 知道函数内如何修改全局变量

---

7.1 局部变量

• 局部变量：函数定义的形参，函数内部定义的变量
• 不同的函数，可以定义相同的名字的局部变量，但是各用个的不会产生影响
• 局部变量的作用域只在函数内部
• 局部变量的目的是 存储需要临时保存的数据

# 函数定义
def func(temp):
    a = 10
    print(a)


# 函数调用
func(22)

# NameError: name 'a' is not defined
# print('函数的外部：', a)    # err
# print('函数的外部: ', temp)    # err

7.2 全局变量

7.2.1 全局变量

• 在函数外部定义的变量叫做 全局变量
• 全局变量能够在所有的函数中进行访问(不修改)

# 定义全局变量
num = 10


def func():
    print('func num = ', num)


func()  # 函数调用
print('函数的外面 num = ', num)

运行结果：

func num =  10
函数的外面 num =  10

7.2.2 函数内修改全局变量

(1) 默认不能直接修改全局变量

# 定义全局变量
num = 10


def func():
    # 函数内给一个变量赋值时，重新生成一个局部变量num
    # 函数内的num和外面的num没有关系
    num = 250
    print('func num = ', num)  # 获取是函数内的num


func()  # 函数调用

# 函数外获取的是全局变量的值
print('函数的外面 num = ', num)

• 函数内赋值变量 时，默认为定义并赋值局部变量
• 函数内获取的是函数内局部变量的值，函数外获取的是全局变量的值

运行结果：

func num =  250
函数的外面 num =  10

(2) 通过global声明修改全局变量

• 如果在函数中修改全局变量，那么就需要先使用global进行声明，再进行修改

# 定义全局变量
num = 10


def func():
    # global num 告诉解释器，函数内部使用的num就是外面的全局变量num
    global num
    num = 250   # 修改全局变量
    print('func num = ', num)


func()  # 函数调用
print('函数的外面 num = ', num)

运行结果：

func num =  250
函数的外面 num =  250

08_函数的参数2：参数详解

学习目标：

• 知道位置参数和关键字参数的区别

• 掌握缺省参数函数的定义和调用

• 掌握不定长参数函数的定义和调用

---

8.1 位置参数

• 函数调用时，按形参的位置，从左往右，一一匹配传递参数
• 位置参数必须一一对应，缺一不可

# 函数定义
def func(num1, num2):
    print('num1 = ', num1)
    print('num2 = ', num2)


# 函数调用
func(1, 2)

8.2 关键字参数

• 函数调用时，通过 形参=值 方式为函数形参传值，不用按照位置为函数形参传值，这种方式叫关键字参数
• 注意：
  • 关键字参数必须在位置参数的右边
  • 对同一个形参不能重复传值

# 函数定义
def func(num1, num2):
    print('num1 = ', num1)
    print('num2 = ', num2)


# 函数调用
func(num2=1, num1=2)

8.3 缺省参数

• 形参设定默认值，称为缺省参数，也叫默认参数
• 注意：
  • 调用函数时，如果没有传入默认参数对应的实参，则使用默认值
  • 默认参数必须在普通参数的后边

# 默认参数必须在普通参数的后边
def func(a, b=20, c=10):
    print(a, b, c)


# 函数调用
func(1)  # a=1,b=20,c=10
func(1, 2)  # a=1,b=2,c=10
func(1, 3, 2)  # a=1,b=3,c=2

8.4 不定长参数

8.4.1 元组型不定长参数

• 函数可以定义 不定长参数，用于接收任意数量的位置实参
• 形参变量名前面加上一个*，这个参数则为元组型不定长参数
  • 形参变量名一般叫： args
• 函数体使用不定长参数，直接使用变量名即可，无需加*
• 不定长参数的本质是 将传递的参数包装成了元组

# *args 为不定长参数，可以接收0~多个实参
# 把实参的1,2,3, 包装成元组(1, 2, 3)再传递, 等价于args = (1, 2, 3)
def func(*args):
    # 函数内部使用，无需加*
    print(args, type(args))


# 函数调用
func(1, 2, 3)   # (1, 2, 3) 

8.4.2 字典型不定长参数

• 不定长参数还有一种形式 可以接收任意数量的关键字实参
• 定义参数时需要在形参名前添加**，则为字典型不定长参数，在函数体使用不定长参数，直接使用变量名即可，无需加*
  • 形参变量名一般叫： kwargs
• 这种不定长参数会将 关键字参数包装成字典

# 把实参包装成 {'city': 'sz', 'age': 18}给kwargs传递
# kwargs = {'city': 'sz', 'age': 18}
def func(name, **kwargs):
    # 存在形参name, name不会被包装到字典中
    print(name)
    print(kwargs)  # 函数内部使用，无需加*


# 实参的写法： 变量=数据，变量=数据
func(name='mike', city='sz', age=18)

注意:

• 已经存在的形参, 其对应的关键字实参 不会被包装到字典中
• 字典型可变形参必须在形参列表的最后边

函数——练习题

能力目标

• 能够使用切片语法获取字符串指定区间内的子串
• 能够说出函数定义的语法格式
• 能够说出函数调用的语法格式
• 知道return关键字可以使函数返回一个结果
• 能说出局部变量的特点(定义方式，作用范围)
• 能说出全局变量的特点(定义方式，作用范围)
• 能够说出位置参数和关键字参数区别
• 知道如何编写出带有缺省参数的函数
• 知道如何定义带有不定长参数的函数

关卡一：基础题 1. 函数是什么，函数的作用，函数怎么使用？

参考答案

函数：是把具有独立功能的代码块组织为一个整体；
函数的作用：在开发程序时，使用函数可以提高编写的效率以及代码的 重用
函数的使用：
            1.定义函数 —— 在函数中编写代码，实现功能
            2.调用函数 —— 执行编写的代码

2. 定义、调用函数的格式分别是什么？

参考答案

# 定义格式
def 函数名():
  函数体
  
# 调用格式
函数名()

3. 函数中形参和实参分别是什么？

参考答案

形参：定义函数时设置的参数，是用来 代替真实数据 的，在函数内部 作为变量使用
实参：调用函数时设置的 真实数据，会被传递到 函数内部

4. 函数中如何设置返回值？如果不设置返回值，函数默认会返回什么？

参考答案

在函数中使用 return 关键字可以返回结果
不设置返回值, 会返回None, 表示没有任何数据

5.什么是局部变量？什么是全局变量？

参考答案

局部变量，就是在 函数内部定义的变量
局部变量的作用域只在函数内部
在函数外边定义的变量叫做 全局变量
全局变量能够在所有的函数中进行访问

6.函数内部如何修改全局变量？

参考答案

函数内赋值变量时，默认为定义并赋值局部变量
如果在函数中修改全局变量，那么就需要使用global进行声明

7. Python中函数的参数都有哪些类型？

参考答案

位置参数
关键字参数
缺省参数(默认参数)
不定长参数
    元组型不定长参数
    字典型不定长参数

关卡二：综合题 1. 设计一个程序

• 现有字符串如下，请使用切片提取出ceg words = "abcdefghi"

参考答案

a = "abcdefghi"
b = a[2:7:2]  # 方法一
b = a[-7:-1:2]  # 方法二
print(b)

2. 设计一个程序

现有字符串： str1 = '1234567890'，根据题目要求，将截取后的新字符串赋值给str2

• 截取字符串的第一位到第三位的字符

• 截取字符串最后三位的字符

• 截取字符串的全部字符

• 截取字符串的第七个字符到结尾

• 截取字符串的第一位到倒数第三位之间的字符

• 截取字符串的第三个字符

• 截取字符串的倒数第一个字符

• 截取与原字符串顺序相反的字符串

• 截取字符串倒数第三位与倒数第一位之间的字符

• 截取字符串的第一位字符到最后一位字符之间的字符，每隔一个字符截取一次。

参考答案

str1 = "1234567890"
# 截取字符串的第一位到第三位的字符
str2 = str1[:3]
# 截取字符串最后三位的字符
str2 = str1[-3:]
# 截取字符串的全部字符
str2 = str1[:]
# 截取字符串的第七个字符到结尾
str2 = str1[6:]
# 截取字符串的第一位到倒数第三位之间的字符
str2 = str1[1:-3]
# 截取字符串的第三个字符
str2 = str1[2]
# 截取字符串的倒数第一个字符
str2 = str1[-1]
# 截取与原字符串顺序相反的字符串
str2 = str1[::-1]
# 截取字符串倒数第三位与倒数第一位之间的字符
str2 = str1[-3:-1]
# 截取字符串的第一位字符到最后一位字符之间的字符，每隔一个字符截取一次。(结果应该为2468)
str2 = str1[1: -2:2]
print(str2)
# 注意：如果对于第几位有歧义 属于正常 按照自己的意愿得到结果即可

3. 设计一个程序

• 将下列两个列表合并，将合并后的列表去重，之后降序并输出

  list1 = [11, 45, 34, 51, 90] list2 = [4, 16, 23, 0]

参考答案

list1 = [11, 45, 34, 51, 90]
list2 = [4, 16, 23, 0]
# 列表拼接
list3 = list1 + list2
# 列表去重
list4 = set(list3)
list5 = list(list4)
# 列表降序输出
list5.sort(reverse=True)
print(list5)

4. 设计一个程序

• 现有：typle1 = ("tom","kaisa","alisi","xiaoming","songshu") 我想获得“alisi”这个内容

参考答案

typle1 = ("tom","kaisa","alisi","xiaoming","songshu")
#1. 用元组取下标为2的值
print(typle1[2])
#2. 可以利用切片从下标2开始取到下标3之前
print(typle1[2:3][0])
#3. 可以用for循环来遍历所有的值，判断，如果有一个是alisi，那就输出
for i in typle1:
  if i == "alisi":
    print(i)

5. 设计一个程序

• 定义一个函数max，接受的参数类型是数值，最终返回两个数中的最大值

参考答案

def max(a, b):  # 定义函数并接收两个形参
    if a > b:  # 通过if判断得到较大的值返回结果
        return a
    else:
        return b

6. 设计一个程序:

• 用函数实现一个判断用户输入的年份是否是闰年的程序，在函数中打印结果。

  训练提示

  1.能被400整除的年份 2.能被4整除，但是不能被100整除的年份 以上2种方法满足一种即为闰年

参考答案

def judge_year(x):  # 定义函数并接收年份参数
    if (x % 4 == 0 and x % 100 != 0) or x % 400 == 0:  # 判断改年份是否是闰年
        print("这是一个闰年")
print("闰年的判断")
a = int(input("请输入年份:"))  # 定义一个变量保存用户要判断的年份
judge_year(a)  # 调用函数

7 设计一个程序:

• 定义一个函数，计算两个数之和。调用者在得到结果的时候需要判断是否大于20，如果大于则输出，超过10的加法太难了

参考答案

def func(num1, num2):  # 定义函数并接收两个参数
    sum1 = num1 + num2  # 将这两个参数相加并将值保存
    if sum1 > 20:  # 判断相加结果是否超过20
        print(f'和是{sum1}：超过10的加法太难了')
    else:
        print(sum1)
cmd_num1 = int(input('请输入数字：'))
cmd_num2 = int(input('请输入数字：'))
func(cmd_num1, cmd_num2)

8. 设计一个程序:

• 完成一个函数，给定三个值。判断你给的值是否可以组成一个三角形

训练提示

三角形成立必须两边之和大于第三边

第一步：定义函数，并接受三个参数

第二步：任意相加其中的两条边判断是否大于第三边，要保证三条边中任意两边之和都大于第三边

参考答案

def trigon(a, b, c):
    if a + b - c > 0 and a + c - b > 0 and b + c - a > 0:
        return "ok"
    else:
        return "no"
print(trigon(5, 10, 15))

关卡三：扩展题 1. 设计一个程序:

• 定义一个函数，接受三个参数，分别为字符串s、数值a1、数值a2，将字符串s从下标a1开始的a2个字符删除，并把结果返回，a2默认值为0

  训练提示

  1、函数的定义

  2、函数的参数

  3、字符串的切割

例如：

s = "123456789", a1 = 2,a2 = 4 结果为: "12789"

参考答案

def cut_str(s, a1, a2=0):
    length = len(s)
    if a1+1>length or a1>a2:
        return s
    else:
        s1 = s[:a1]
        s2 = s[a1+a2:]
        return s1+s2

2. 设计一个程序:

定义一个函数

• 接收参数 num 和 command

• command 为 True 则返回0-n(包含n)以内的偶数组成的列表

• command 为 False 则返回0-n(包含n)以内的奇数组成的列表

• 默认返回全是奇数的列表

def get_list(num, command=False):
    ret = []
    i = 0
    while i <= num:
        if command:  # 返回偶数
            if i % 2 == 0:
                ret.append(i)
        else:  # 返回奇数
            if i % 2 != 0:
                ret.append(i)
        i += 1
    return ret
result = get_list(10, False)
print(result)

提示：

• 函数里创建一个空列表，遍历0-num的数字，每当有一个奇数/偶数就添加到列表，最终返回列表