Python小白学习笔记五 函数 1

函数 function

　　pycharm快捷键

Ctrl + P 参数信息（在方法中调用参数）

Ctrl + Q 快速查看文档

Ctrl + Alt + M 提取方法

　　定义

1.用于封装一个特定的功能，表示一个功能或者行为。

2.函数是可以重复执行的语句块, 可以重复调用。

3.函数代码块以 def 关键词开头，后接函数标识符名称和圆括号()。

4.任何传入参数和自变量必须放在圆括号中间。圆括号之间可以用于定义参数。

5.函数的第一行语句可以选择性地使用文档字符串—用于存放函数说明。

6.函数内容以冒号起始，并且缩进。

7.return [表达式] 结束函数，选择性地返回一个值给调用方。不带表达式的return相当于返回 None。　　

作用

　　　　　　提高代码的可重用性和可维护性（代码层次结构更清晰）。

　　定义函数

语法：

def 函数名(形式参数):

     函数体

例如：

def repeated_attack(count):
    """
        重复攻击
    :param count:int类型,攻击次数　
    """
    for __ in range(count):
        print("正蹬")
        print("直拳")
        print("摆拳")
        print("勾拳")
# 数据
# 实际参数
repeated_attack(2)
repeated_attack(3)

1. 1. 说明：

def 关键字：全称是define，意为”定义”。

函数名：对函数体中语句的描述，规则与变量名相同。

形式参数：方法定义者要求调用者提供的信息。

函数体：完成该功能的语句。

1. 1. 函数的第一行语句建议使用文档字符串描述函数的功能与参数。
      1. 语法：函数名(实际参数)
      2. 说明：根据形参传递内容。

调用函数

　　返回值

　　　　　　方法定义者告诉调用者的结果。

1. 1. 语法：

　　　　　　　　return 数据 

说明：

return后没有语句，相当于返回 None。

函数体没有return，相当于返回None。

例如：

# 创建美元转换为人民币的函数
def usd_to_cny(usd):
    """
        美元转换为人民币
    :param usd: 美元
    :return:人民币
    """
    # 2. 逻辑处理 - 美元 * 6.99
    cny = usd * 6.99
    return cny  # 给


# 收
result = usd_to_cny(5)
print(result)

"""
    返回值　－　语法　
"""
# 1. python中函数默认返回None
def func01():
    print("func01执行了")
    # return None

esult = func01()
print(result)  # None

# 2.python中return后面没有数据,默认为None
def func02():
    print("func02执行了")
    return

result = func02()
print(result)  # None

# 3. return可以退出函数(无论多少层循环嵌套,都可以)
def func03():
    print("func03执行了")
    return
    print("func03又执行了")

func03()

可更改(mutable)与不可更改(immutable)对象

　　在 python 中，strings, tuples, 和 numbers 是不可更改的对象，而 list,dict 等则是可以修改的对象。

• • 不可变类型：变量赋值 a=5 后再赋值 a=10，这里实际是新生成一个 int 值对象 10，再让 a 指向它，而 5 被丢弃，不是改变a的值，相当于新生成了a。

  • 可变类型：变量赋值 la=[1,2,3,4] 后再赋值 la[2]=5 则是将 list la 的第三个元素值更改，本身la没有动，只是其内部的一部分值被修改了。

python 函数的参数传递：

• • 不可变类型：类似 c++ 的值传递，如 整数、字符串、元组。如fun（a），传递的只是a的值，没有影响a对象本身。比如在 fun（a）内部修改 a 的值，只是修改另一个复制的对象，不会影响 a 本身。

  • 可变类型：类似 c++ 的引用传递，如 列表，字典。如 fun（la），则是将 la 真正的传过去，修改后fun外部的la也会受影响

　　python 中一切都是对象，严格意义我们不能说值传递还是引用传递，我们应该说传不可变对象和传可变对象。

可变／不可变类型在传参时的区别

　　　　　　1.不可变类型参数有:

数值型(整数，浮点数)

布尔值bool

None 空值

字符串str

元组tuple

     2.可变类型参数有:

列表 list

字典 dict

集合 set

"""
    作用域
        变量起作用的范围
        全局变量：大范围(多个函数)需要操作的数据
        局部变量：小范围(一个函数)需要操作的数据
"""

# -------全局变量--------
# 全局作用域：文件内部
#            全局变量能在整个文件中使用(函数内部可以读取)
b = 20

# -------创建函数--------
def func01():
    # 局部作用域：函数内部
    #           局部变量只能在函数内部使用
    a = 10
    print(b)

# -------调用函数--------
func01()

例如：

"""
    全局变量与局部变量
"""
a = 10

def func01():
    # 在函数内部,只能读取全局变量
    a = 20  # 创建局部变量,没有修改全局变量
    print(a)  # 20

func01()
print(a)  # 10

def func02():
    global a  # 如果在局部变量修改全局变量,必须通过global声明
    a = 20
    print(a)

func02()
print(a)
# 注意:
c = [10]
def func03():
    c[0] = 20  # 没有修改全局变量c(修改的的是列表的元素)
    print(c)  # [20]

func03()
print(c)  # [10]

 

传参说明：

不可变类型的数据传参时，函数内部不会改变原数据的值。

可变类型的数据传参时，函数内部可以改变原数据。

相关练习：

练1：

def calculate_weight(sum_liang):
    """
    两换算为xx斤零xx两
    :param sum_liang: 输入初始值
    :return: 返回xx斤零xx两
    """
    jin = sum_liang //16
    liang = sum_liang %16
    return jin,liang
sum_liang = int(input("请输入两："))
jin,liang = calculate_weight(sum_liang)
print("%d两是%s斤零%s两" % (sum_liang,jin,liang))

练2：

def calculate_area(top,down,hight):
    calculate_area = (top + down) * hight / 2
    return calculate_area
top = int(input("请输入上低："))
down = int(input("请输入下低："))
hight = int(input("请输入高："))
calculate_area = calculate_area(top,down,hight)
print("梯形的面积为%d" % (calculate_area))

练3：

def iq_grade(age_of_mind,age_of_real):
    iq_grade = age_of_mind / age_of_real * 100
    if iq_grade >= 140:
        return "天才"
    if iq_grade >= 120:   #如果上一个条件满足,return执行后,退出函数
        return "超常"
    if iq_grade >= 110:
        return "聪慧"
    if iq_grade >= 90:
        return "正常"
    if iq_grade >= 80:
        return "迟钝"
    return "低能"

age_of_mind = int(input("请输入心理年龄："))
age_of_real = int(input("请输入实际年龄："))
iq_grade = iq_grade(age_of_mind,age_of_real)
print(iq_grade)

练4（较难理解，可参考文字注释）：

# 员工列表(员工编号 部门编号 姓名 工资)
dict_employees = {
    1001: {"did": 9002, "name": "师父", "money": 60000},
    1002: {"did": 9001, "name": "孙悟空", "money": 50000},
    1003: {"did": 9002, "name": "猪八戒", "money": 20000},
    1004: {"did": 9001, "name": "沙僧", "money": 30000},
    1005: {"did": 9001, "name": "小白龙", "money": 15000},
}

# 部门列表(部门编号,部门名称)
list_departments = [
    {"did": 9001, "title": "教学部"},
    {"did": 9002, "title": "销售部"},
    {"did": 9003, "title": "品保部"},
]
#通过函数解决以下问题
# 1.打印所有员工信息,
def print_all_employees():
    """
    :return: 输出dict_employees 的所有信息
    """
    for cid, info in dict_employees.items():#遍历dict_employees的所有信息
        print_single_employee(cid, info) # 输出dict_employees 的所有信息
def print_single_employee(cid, info):
    print(f"{info['name']}的员工编号是{cid},部门编号是{info['did']},月薪{info['money']}元.")

# 2. 打印所有月薪大于2w的员工信息,
def print_gt_2w_employees():    #根据题目信息命名函数名
    for key, value in dict_employees.items(): #遍历,比较大小,输出符合要求的员工信息
        if value['money'] > 20000:
            print_single_employee(key, value)

# 3. 在部门列表中查找编号最小的部门
def get_min_by_did(): #根据题目信息命名函数名
    min_value = list_departments[0] #将list_departments中的第一个值设定为最小值
    for i in range(1, len(list_departments)):
        if min_value["did"] > list_departments[i]["did"]: #将list_departments中剩余的值域最小值
            # 进行比较大小，并将结果重新赋值给min_value
            min_value = list_departments[i]
    return min_value

# 4. 根据部门编号对部门列表升序排列
def order_by_did():
    # (1)取
    for r in range(len(list_departments) - 1):
        # (2)比
        for c in range(r + 1, len(list_departments)):
            # (3) 发现更小
            if list_departments[r]["did"] > list_departments[c]["did"]:
                # (4) 交换
                list_departments[r], list_departments[c] = list_departments[c], list_departments[r]
    return list_departments

# 测试
print_all_employees()  # 1.
print_gt_2w_employees()  #2.
result = get_min_by_did()
print(result)  #3.
result = order_by_did()
print(result)  #4