6:函数和深浅拷贝

#深浅拷贝
浅拷贝---只创建第一层的内存空间，里面的元素是引用对象
　　　　　copy对象是不可变类型比如元祖，不会创建新的内存空间只是引用对象
深拷贝---会递归创建全部新的内存空间

#深拷贝copy.deepcopy---会递归拷贝全部的内存空间
import  copy

a=b=[1,2]
c=copy.deepcopy(a)
print(id(a),id(b),id(c))
a.append(3)
print(a)
print(b)
print(c)

2286111498048 2286111498048 2286109872256
[1, 2, 3]
[1, 2, 3]
[1, 2]

a1=[1,2]
b1=[2,3]
c1=[a1,b1]
d1=copy.deepcopy(c1)
print(id(c1),id(d1))
a1.append(3)
print(c1)
print(d1)

2286111497280 2286111497984
[[1, 2, 3], [2, 3]]
[[1, 2], [2, 3]]

 

 

#浅拷贝只拷贝第一层空间
a1=[1,2]
b1=[2,3]
c1=[a1,b1]
d1=copy.copy(c1)
print(id(c1),id(d1))
a1.append(3)
print(c1)
print(d1)

2286111514752 2286111497280
[[1, 2, 3], [2, 3]]
[[1, 2, 3], [2, 3]]

copy对象是不可变类型比如元祖，不会创建新的内存空间只是引用对象

a=[1,2]
b=[2,3]
c=(a,b)
d=copy.copy(c)
print(id(c),id(d))
a.append(3)
print(c[0],d[0])

2171736306048 2171736306048
[1, 2, 3] [1, 2, 3]

一：函数
def 已小写字母数字下划线组成不能以数字开头--区分大小写的
return 在函数中相当于结束符,表示函数到此结束
*args  不定长参数  args--接收参数形成一个元组
**kwargs 关键字参数 kwargs--是个字典
注意:不定长和关键字参数都可以为空
    函数参数顺序 普通 默认 不定长 关键字参数
    info_1(a,b='j',*args,**kwargs):

二：全局和局部变量
1.全局变量在模块中都可以调用  局部变量只能在函数内
2.全局和局部变量同名存在时,函数中优先调用局部变量，局部变量没有时调用全局变量
3.global--应用全局变量一般用于传递(在函数最前面) nonlocal--外部嵌套函数内的变量

三：return
1：在函数中相当于结束符,表示函数到此结束
2：return返回多个对象封装成一个元祖
def info_2(*args):
    c=[1,2]
    d={'name':'lijia','age':12}
    return args,c,d


print(info_2(1,2))

((1, 2), [1, 2], {'name': 'lijia', 'age': 12})

四：函数作为参数和返回值


五：递归---定义出口
def info_02(n):
    if n==1:
        return n
    return n*info_02(n-1)

print(info_02(5))

120

六：匿名函数
local=lambda x,y:x**y
print(local(2,3))

8

七：高阶函数
1:map两个参数，一个是函数，一个是迭代器(对序列中的每个元素做函数操作),返回的是迭代器对象<map object at 0x00507410>
li=[1,3,5,7]
for i,j in enumerate(li):
    li[i]=j*j
print(li)

print(map(lambda x:x*x,li))
print(list(map(lambda x:x*x,li)))

[1, 9, 25, 49]
<map object at 0x00547410>
[1, 81, 625, 2401]

2:filter()也接收一个函数和一个序列。和map()不同的是，filter()把传入的函数依次作用于每个元素，然后根据返回值是True还是False决定保留还是丢弃该元素。
对于序列中的元素进行筛选，最终获取符合条件的序列

li1=[1,3,5,6,8]
print(list(filter(lambda x:x%2!=0,li1)))

[1, 3, 5]

3:reduce函数也是一个参数为函数，一个为可迭代对象的高阶函数，其返回值为一个值而不是迭代器对象，故其常用与叠加、叠乘等
from functools import reduce

print(reduce(lambda x,y:x*y,range(1,5)))

#默认参数
def da_lao(sex='男'):
    print('我的性别是:{}'.format(sex))


da_lao()
da_lao('女')

#求和
def sum(m,n,k=1):
    sum=0
    for i in range(m,n,k):
        sum+=i
    return sum
print(sum(1,101,2))

def check_list(list):
    if len(list)>2:
        list1=list[0:2]
        return list1


list=[1,2,3,4]
print(check_list(list))


def add(*args):
    print(args)
    str=''
    for item in args:
        str+=item
    print(str)

add('li','jia','jia')

def ku(**kwargs):
    print(kwargs)

ku(x=1,y=2)


def add_sum(a,*L,**kwargs):
    sum=0
    for item in L:
        sum+=item
    print(sum)
    print(a)
    print(kwargs)

add_sum(1,2,3,x=1,y=2)


a=11
def dd():
    global a
    a=12
    print(a)

dd()
print(a)



我的性别是:男
我的性别是:女
2500
[1, 2]
('li', 'jia', 'jia')
lijiajia
{'x': 1, 'y': 2}
5
1
{'x': 1, 'y': 2}
12
11

直接传字典和元祖
def info(*args):
    print(args)

def info_01(**kwargs):
    print(kwargs)


info(*(1,2))

info_01(**{'name':'lijia','age':'12'})

(1, 2)
{'name': 'lijia', 'age': '12'}

八：主函数
if __name__ == '__main__':