黑马程序员python数据分析课后答案 黑马python2017讲义

P326---P360

• 增加Shebang符号（程序的运行）
• 变量的引用

• 变量引用的概念
• 调用函数传递实参的引用
• 函数返回值传递引用

• 可变和不可变类型

• 基本概念
• 列表、字典修改和赋值
• 字典key不能是可变类型

• 局部变量与全局变量

• 基本概念和区别
• 变量的生命周期

• 全局变量

• 代码演示
• 函数内部不允许修改局部变量的值
• global关键字修改全局变量
• 全局变量定义的位置及代码结构
• 全局变量命名建议

• 函数的返回值

• 利用元祖返回多个值
• 接受返回元祖函数的方式
• 交换两个变量的值

• 函数参数

• 在函数内部针对参数赋值不会影响外部参数
• 函数内部使用方法可修改外部可变实参的值
• 列表使用+=实际上是调用extend方法

• 缺省参数

• 回顾列表的排序方法明确缺省函数的概念及作用
• 指定缺省函数的默认值
• 缺省参数的注意事项

• 多值参数

• 定义及作用
• 数字累加案例演练
• 元祖和字典的拆包

• 递归

• 特点及基本代码演练
• 递归实现数字累加

增加Shebang符号（程序的运行）

变量的引用

变量引用的概念

通过变量记录了数值的地址

调用函数传递实参的引用

调用 test 函数,本质上传递的是实参保存数据的引用，而不是实参保存的数据，函数传递的是地址

函数返回值传递引用

函数返回值也是通过引用来传递的

def test(num):
    print("在函数内部 %d 对应的内存地址是 %d" %(num,id(num)))
    # 1> 定义一个字符串变量
    result = "hello"
    print("函数要返回数据的内存地址是 %d" % id(result) )
    # 2> 将字符串变量返回,返回的是数据的引用而不是数据本身
    return  result
# 1.定义一个数字变量
a = 10
# 数据的地址本质上就是一个数字
print("a 变量保存的数据地址是 %d" % id(a))
# 2.调用 test 函数,本质上传递的是实参保存数据的引用，而不是实参保存的数据
# 注意：如果函数有返回值，但是没有定义变量接收
# 程序不会报错，但是无法获得返回结果
r = test(a)
print("%s 的内存地址是 %d" %(r,id(r)))

可变和不可变类型

基本概念

在列表中可修改内容单步修改地址，通过方法改变数值

列表、字典修改和赋值

增删改不会修改列表的地址

使用赋值语句的时候会修改地址

字典同列表，只有赋值会修改地址

字典key不能是可变类型

添加不可变类型

使用可变类型会报错

关于hash

局部变量与全局变量

基本概念和区别

变量的生命周期

两个局部变量互不相干

全局变量

代码演示

# 全局变量
num = 10


def demo1():
    print("demo1 ==> %d" % num)


def demo2():
    print("demo2 ==> %d" % num)


demo1()
demo2()

先查找函数内是否有num，在查找全局是否有num

函数内部不允许修改局部变量的值

在Python中不允许修改全局变量的值，如果使用赋值语句会定义一个局部变量，demo1中的num是一个局部变量

global关键字修改全局变量

# global 关键字会告诉解释器后面的变量是一个全局变量
# 再使用赋值语句时，就不会创建局部变量

全局变量定义的位置及代码结构

在调用demo的时候demo只知道num和tile的，并不知道name，因为name在demo之后

# 注意：在开发室，应该吧模块中的所有全局变量定义在顶部
num = 10


def demo():
    print("%d" % num)
    print("%s" % title)
    print("%s" % name)


# 再定义一个全局变量
title = "黑马程序员"

demo()

# 再定义一个全局变量
name = "小明"

全局变量命名建议

修改同一变量名，快捷键shift+f6

函数的返回值

利用元祖返回多个值

返回值不加（）默认是元祖类型

def measure():
    """测量温度和湿度"""
    print("测量开始...")
    temp = 39
    wetness = 50
    print("测量结束...")

    # 元祖-可以包含多个数据，因此可以使用元祖让函数一次返回多个值
    # return (temp, wetness)
    return temp, wetness


result = measure()
print(result)

接受返回元祖函数的方式

如果函数返回的类型是元祖，同时希望单独的处理元祖中的元素
可以使用多个变量，一次接受多个结果
注意：使用多个变量接收结果时，变量个数应该与返回的元祖元素个数一致

def measure():
    """测量温度和湿度"""
    print("测量开始...")
    temp = 39
    wetness = 50
    print("测量结束...")

    # 元祖-可以包含多个数据，因此可以使用元祖让函数一次返回多个值
    # return (temp, wetness)
    return temp, wetness


# 元祖
result = measure()
print(result)


# 需要单独的处理温度或者湿度 - 不方便
print(result[0])
print(result[1])


# 如果函数返回的类型是元祖，同时希望单独的处理元祖中的元素
# 可以使用多个变量，一次接受多个结果
# 注意：使用多个变量接收结果时，变量个数应该与返回的元祖元素个数一致
gl_temp,gl_wetness = measure()


print(gl_temp)
print(gl_wetness)

交换两个变量的值

a = 6
b = 100

# 解法1：-使用其他变量
# c = a
# a = b
# b = c

# 解放2：-不使用其他变量
# a = a + b
# b = a - b
# a = a - b

# 解法3：-Python 专有
# ()可以省略，作为元祖
a, b = (b, a)

print(a)
print(b)

函数参数

在函数内部针对参数赋值不会影响外部参数

无论是可变不可变类型都不会影响函数外部实参的值

def demo(num):

    print("函数内部的代码")

    # 在函数内部，针对参数使用赋值语句
    num = 100

    print(num)
    print("函数执行完成")


gl_num = 99
demo(gl_num)
print(gl_num)

在函数内部不会修改外部实参变量

def demo(num,num_list):

    print("函数内部的代码")

    # 在函数内部，针对参数使用赋值语句
    num = 100
    num_list = [1, 2, 3]

    print(num)
    print(num_list)
    print("函数执行完成")


gl_num = 99
gl_list = [4, 5, 6]
demo(gl_num, gl_list)
print(gl_num)
print(gl_list)

函数内部使用方法可修改外部可变实参的值

def demo(num_list):
    print("函数内部的代码")

    # 使用方法修改列表的内容
    num_list.append(9)

    print(num_list)
    print("函数执行完成")


gl_list = [1, 2, 3]
demo(gl_list)
print(gl_list)

列表使用+=实际上是调用extend方法

def demo(num, num_list):

    print("函数开始")

    # num = num + num
    # 列表使用+=本质上是使用extend方法
    # 等同于 num_list.extend(num.extend)
    # 而不是 num_list = num_list + num_list
    num += num
    num_list += num_list

    print(num)
    print(num_list)

    print("函数完成")


gl_num = 9
gl_list = [1, 2, 3]


demo(gl_num, gl_list)
print(gl_num)
print(gl_list)

缺省参数

回顾列表的排序方法明确缺省函数的概念及作用

缺省函数的作用就是设置默认值

gl_list = [6, 3, 9]

# 默认按照升序排序 - 可能会多! 
# gl_list.sort()

# 如果需要降序排序，需要执行reverse参数
gl_list.sort(reverse=True)
print(gl_list)

指定缺省函数的默认值

只要在参数后面指定默认值就行

def print_info(name, gender=True):
    """

    :param name: 班上同学的姓名
    :param gender: True男生 False 女生
    :return:
    """

    gender_text = "男生"
    if not gender:
        gender_text = "女生"

    print("%s 是 %s " % (name, gender_text))


# 假设班上男生居多
print_info("小明")
print_info("老王")
print_info("小美", False)

缺省参数的注意事项

含有多个参数传参，给具体参数传参，要给形参赋值，不然按默认顺序赋值

def print_info(name, title="学生", gender=True):
    """

    :param title:职位
    :param name: 班上同学的姓名
    :param gender: True男生 False 女生
    :return:
    """

    gender_text = "男生"
    if not gender:
        gender_text = "女生"

    print("[%s]%s 是 %s " % (title, name, gender_text))


# 假设班上男生居多
print_info("小明")
print_info("老王")
print_info("小美", gender=False)

多值参数

定义及作用

def demo(num, *nums, **person):

    print(num)
    print(nums)
    print(person)


# demo(1)
demo(1, 2, 3, 4, 5, name="小明", age=18)

数字累加案例演练

两种写法

def sum_numbers(*args):
    num = 0
    print(args)
    # 循环遍历
    for n in args:
        num += n
    return num


result = sum_numbers(1, 2, 3, 4, 5)
print(result)

元祖和字典的拆包

def demo(*args, **kwargs):

    print(args)
    print(kwargs)


gl_nums = (1, 2, 3)
gl_dict = {"name": "小明","age": 18}

demo(*gl_nums, **gl_dict)

# demo(1, 2, 3, name="小明", age=18)

递归

特点及基本代码演练

def sum_number(num):

    print(num)
    # 递归的出口
    if num == 1:
        return

    # 自己调用自己
    sum_number(num - 1)


sum_number(3)

递归实现数字累加

# 定义一个函数 sum_numbers
# 能够接受一个 num 的整数参数
# 计算 1 + 2 + ... num 的结果


def sum_numbers(num):
    # 1.出口
    if num == 1:
        return 1

    # 2.数字的累加 num + (1...num - 1)
    # 假设 sum_numbers 能够正确处理 1...num - 1
    temp = sum_numbers(num - 1)

    return num + temp


result = sum_numbers(6)
print(result)