day 14：深浅copy，数据结构 ，函数，set集合，变量作用域、返回值

本节内容：

　　1，深浅copy

　　2，数据结构

　　3，函数

　　4，变量作用域

　　5，返回值，return

一、深浅copy

首先理解当给变量赋值的时候，是给变量存在值所在的内存地址

a = 10000
b = 10000
a_id = id(a)
b_id = id(b)
print(a_id, b_id)  # 当是数值，不是列表等变化的数据类型时，a=b的存储地址是相同

 浅拷贝

import copy
husband = ["xiaohu", [13000, 5000]]
wife = husband.copy()  # 浅拷贝，copy.copy(),shallow 浅的拷贝
wife[0] = "xiaolu"
husband[1][0] -= 3000
print("husband:", husband[1][0])
print("wife:", wife[1][0])

深拷贝

import copy
husband = ["xiaohu", [13000, 5000]]
xiaosan = copy.deepcopy(husband)  # 深拷贝，deepcopy
xiaosan[1][0] -= 3000
husband[1][0] -= 1500
print("husband:", husband[1][0])
print("xiaosan:", xiaosan[1][0])

二、set集合，数据结构

a = [1, 2, 3, 4, 5]
a_set = set(a)
b = [4, 5, 6, 7, 8]
b_set = set(b)

print(a_set.intersection(b_set))  # 交集， a_set和b_set的交集
print(a_set & b_set)  # 4，5

print(a_set.union(b_set))  # 并集，a_set和b_set的并集
print(a_set | b_set)  # 1，2，3，4，5，6，7，8

print(a_set.difference(b_set))  # 差集，a_set中剔除两者交集后的剩余元素
print(a_set - b_set)  # 1，2，3

print(a_set.symmetric_difference(b_set))  # 对称差集，两个的交集反向=除了交集的所有不重复元素
print(a_set ^ b_set)  # 1,2,3,6,7,8

a = [1, 2, 3, 4]
b = [1, 2]
a_set = set(a)
b_set = set(b)

print(a_set.issuperset(b_set))  # 超集，a_set包含b_set
print(a_set > b_set)

print(a_set.issubset(b_set))  # a_set被b_set包含
print(a_set < b_set)

三、函数

1)概念，函数叫方法，但是在英文是，subroutine或者是procedures,都是程序的意思
    减少重复代码
    方便修改，更易扩展
    保持代码一致性（修改的时候不容易出现忘改的现象，修改一处都会修改）
2）创建，是def name():
    a，函数名称不能以数字开头，是字母、数字、下划线的组合
    b，函数名区分大小写
    c，函数名不是能是保留字符
3)参数
1）必须参数，实参和形参必须顺序一一对应
2）关键字参数（在实参）
3）默认参数(在形参中)
4）多个参数，不定长，无命名参数*arg，命名参数**kwargs

import time
time_format = "%Y-%m-%d %H~%M~%S"
current_time = time.strftime(time_format)


# 有参数，形参是n
def logger1(n):
    current_time = time.strftime(time_format)
    with open("%s log %s" % (current_time, n), "a", encoding="utf-8") as f:
        f.write("end action %s \n" % n)
        time.sleep(2)
logger1(1)

a、必须参数

def print_info(name, age):
    info = '''
    name: %s
    age: %s''' % (name, age, sex)
    print(info)


print_info("吴振虎", 18)  # 参数的顺序是一一对应的

b、关键字参数

def print_info(name, age):
    info = '''
    name: %s
    age: %s''' % (name, age)
    print(info)


print_info(age=18, name="吴振虎")  #实参名称要和形参的名称相同

b、默认参数

def print_info(name, age, sex="male"):
    info = '''
    name: %s
    age: %s
    sex: %s''' % (name, age, sex)
    print(info)


print_info("吴振虎", 18)
print_info("刘卫宏", 22, sex="female")  # 当传关键字的时候会改变默认参数的值，不传的时候就是默认参数值，默认参数必须在必须参数的后边

d、不定长参数，

无命名参数，命名参数

# 必须的顺序，形参的顺序默认后是无命名参数，再是命名参数
# 实参的对应顺序，当多种参数的是时候，按照必须参数顺序对应
def have_name_parameter(sex="male", *args, **kwargs):
    print("%s" % sex)
    for i in args:
        print(i)
    for new_i in kwargs:
        print("%s: %s" % (new_i, kwargs[new_i]))
    return 


have_name_parameter(1, 2, 3, job="tester", height=180)
# 1会自动和默认参数对应，2，3，会成为元组进入args，有命名的实参会和**kwargs

 四、变量的作用域

• L：local，局部作用域，即函数中定义的变量；
• E：enclosing，嵌套的父级函数的局部作用域，即包含此函数的上级函数的局部作用域，但不是全局的；
• G：globa，全局变量，就是模块级别定义的变量；
• B：built-in，系统固定模块里面的变量，比如int, bytearray等。 搜索变量的优先级顺序依次是：作用域局部>外层作用域>当前模块中的全局>python内置作用域，也就是LEGB。

注：

　　当想要实现内部变量也可以修改外部变量的时候可以通过global来实现，当是local变量的时候可以通过nonlocal来实现修改enclose范围的变量

# 变量的作用域
x = int(2.9)  # int就是built-in类型变量
count = 10  # 这是global类型变量


def outer():
    global count
    count = 5  # enclose类型变量

    def inner():
        i_count = 3  # local嵌套的变量
        print(i_count)
        
    inner()


outer()

五、返回值

要想获取函数的执行结果，就可以用return语句把结果返回

注意:

1. 函数在执行过程中只要遇到return语句，就会停止执行并返回结果，可以理解为 return 语句代表着函数的结束
2. 如果未在函数中指定return,那这个函数的返回值为None  
3. return多个对象，解释器会把这多个对象组装成一个元组作为一个一个整体结果输出。