深浅拷贝 集合（定义，方法） 函数（定义，参数，return，作用域） 初识

深浅拷贝

在python中浅拷贝

a=[1,2,3,4,]
b=a.copy()
b[0]='3333'
print(a) #[1, 2, 3, 4]  浅拷贝一层并不会对a造成变化
print(b) #[3333, 2, 3, 4]
c=[[1,2],3,33]
d=c.copy()
# print(d) #[[1, 2], 3, 33]
d[0][1]=55
print(d) #[[1, 55], 3, 33]
print(c) #[[1, 55], 3, 33]  浅拷贝中含有列表了 a列表中的列表会随着b的更改而更改
这是因为 浅拷贝这能拷贝一层 第二层的列表不会被拷贝 如图已经更改了指向所以a也会跟着改变

深拷贝的方式就是;   先引入模块import copy

现在的深拷贝可以拷贝多层    所以b的变化不会影响到a

接下来说说集合

集合可以筛选掉重复的内容  集合里面的元素是一个可哈希的数据，即是可以作为字典的键，所以集合中的元素不能有列表或者元组这些不可哈希元素，但是集合本身是一个非可哈希数据，所以集合不能作为字典的键     还可以用in 和not in判断某元素在不在集合里面

不可变集合通过 a=frozenset（a）创建

a=[1,2,3,4]

通过set 命令可以将a转成集合

b=set(a)

接下来说说集合的增删

增 改

a=[1,2,3,4,5]
b=[5,6,7,8,9,]
a1=set(a)
a1.add('88')  #添加到一个元素到集合中去
b1=set(b)
b1.update(['oppp',44]) #添加列表的两个元素到集合中去
b1.update('wwees')     #不重复的添加该字符串的每一个到集合中去
print(a1) #{1, 2, 3, 4, 5, '88'}
print(b1) #{{5, 6, 7, 8, 9, 'oppp', 44, 's', 'e', 'w'}
删

a=[1,2,3,4,5]
b=[5,6,7,8,9,]

a=set(a)

a.add('1111')
print(a)  #{1, 2, 3, 4, 5, '1111'}
b=set(b)
b.update(['111','2222'])
print(b)    #{5, 6, 7, 8, 9, '2222', '111'}
b.remove('111')  #删除指定的值
print(b.pop()) #随机删除值并返回该值
print(b)
a.clear()   清空集合
print(a)
del a   #从内存上删除a 集合

如果要查看集合 可以用for循环去遍历

然后是集合的关系测试:

a=[1,2,3,4,5]

b=[5,6,7,8,9,]
a=set(a)

b=set(b)

print(a.intersection(b))  #{5}
print(a&b)                       #{5}  这两个都是取交集
print(a.union(b))  #{1, 2, 3, 4, 5, 6, 7, 8, 9}
print(a|b)          #{1, 2, 3, 4, 5, 6, 7, 8, 9}  这两个都是取并集
print(a.difference(b))  #{1, 2, 3, 4}
print(a-b)      #{1, 2, 3, 4}         这两个都是取差集
print(a.symmetric_difference(b))  #{1, 2, 3, 4, 5, 6, 7, 8, 9}
print(a^b)        #{1, 2, 3, 4, 5, 6, 7, 8, 9}      这两个取的是对称差集，也可以说是反向交集
a.issuperset(b)  #判断a>b / a 是b的父集 或超集
a.issubset(b)  #判断a<b  /a 是b的子集

接下来是函数
函数==subroutine 子程序 / procedures 过程
函数的作用：1 减少重复代码
          2 方便修改 更易扩展
          3 保持代码的一致性
用‘def’开头来定义一个函数
函数名字的命名和变量名字的命名规则一样
def test（）：  #‘test（）’就可以被调用函数内容根据自己的需求去写就可以了
函数的参数： 必须参数  关键字参数 默认参数  不定长参数
必须参数 是位置必须一致 如：

def test(name,age):
    print(‘Name’，name)
    print（‘Age’，age）
test('linux',22)  #linux 22  ‘linux’ 和name  22和age 都是位置上一一对应好的 位置不能改
关键字参数  位置可以随意改变：

def test(name,age):
    print('Name',name)
    print('Age',age)
test(age=22,name='lin')  #Name lin  Age 22  #age=22 和 name=‘lin’位置可以随意改变
默认参数 即默认是不变的 其他情况单独更改 

def test(name,age,sex='man'):
    print('Name',name)
    print('Age',age)
    print('Sex',sex)
test(age=22,name='lin')  #Name lin  Age 22  Sex man  test（）括号中可以绘制填两个内容另一个已经默认了 需要改的话直接写入第三个内容就可以了
不定长参数分为两种  分别是 无命名参数和有命名参数
创建方式为 def test（*arge） #无命名参数输入的内容会加入到一个元组里去

无命名参数

def test（**kwarges） #指定命名参数 输入的内容会加入到一个字典中去 

def test(*args):
    for i in args:
        print(i,end='  *  ')
test(1,2,3,45,) #1  *  2  *  3  *  45  *

指定命名参数

def test2(**kwargs):
    for j in kwargs:
        print(j,kwargs[j],end= '--#--')
test2(name='lin',age=22,sex='man')  #name lin--#--age 22--#--sex man--#--
在填写参数时是有优先级的：必须参数>关键字参数>默认参数>无命名参数>指定命名参数
def test3（a,name,sex=man,*args,**kwargs）:
　　pass
test3(1,'lin',1,2,3,age=33,hobby=book)
在函数中还有个return  其作用是结束函数 返回某个对象
 注意 1 函数中如果没有去特殊定义return 默认是返回一个None   
     2 如果return多个对象那么python会将这多个对象封装成一个元组返回

一个对象
def test4():
    a=3333
    return a
b=test4()
print(b) #3333
多个对象

def test4():
    return 1,2,3,3444
b=test4()
print(b) #(1, 2, 3, 3444)
没有对象

def test4():
    return
b=test4()
print(b) #None
接下来的函数中变量的查找顺序 LEGB:
白话就是 ：作用域局部>外层作用域>当前模块中的全局>python内置作用域
图片就是这样

需要注意的是：1 只有模块 类 函数 才能映入新的作用域

            2 对于一个变量内部作用域先声明就会覆盖外部作用域，不声明直接使用就会使用外部作用域的变量
            3 内部作用域要修改外部作用域的值时 全局变量要使用global 关键字 嵌套作用域变量要是用nonlocal关键字， nonlocal是python3新增的关键字 
通过这串代码可以清楚知道每层的作用域是什么

b=int(2.33) #int  built-in
a=1 #global
def outer():
    o_count=22 #enclosing
    def iner():
        i_count=333 #local

到这就结束了 希望给为指教！