码迷,mamicode.com
首页 > 编程语言 > 详细

【04】Python 深拷贝浅拷贝 函数 递归 集合

时间:2018-09-13 22:32:52      阅读:255      评论:0      收藏:0      [点我收藏+]

标签:and   其他   turn   函数   ase   ==   默认   ima   union   

1 深拷贝浅拷贝

1.1 删除奇数

1 l1 = [1,1,1,1,2,3,4,5]
2 l2 = l1 #浅拷贝, l和l2实际指向同一个内存地址
3 print(id(l1)) #查看内存地址
4 print(id(l2))
5 for i in l2:
6     if i%2!=0:
7         l1.remove(i) #删除奇数
8 print(l1) #循环删list的时候,会导致下标错位,结果是不对的

运行结果如下:

42001160
42001160
[1, 1, 2, 4]

1.2 浅拷贝

import copy
l1 = [1,1,1,1,2,3,4,5]
l2 = l1 #浅拷贝, l和l2实际指向同一个内存地址
l3 = l1.copy() #浅拷贝
print(id(l1), id(l2), id(l3))
ll1 = [[1,2,3],[4,5,6]]
ll2 = ll1 #浅拷贝, l和l2实际指向同一个内存地址
ll3 = ll1.copy() #浅拷贝
print(id(ll1), id(ll2), id(ll3))

运行结果如下:

36164360 36164360 36164552
36165704 36165704 36165640

  • 解析

1、b = a: 赋值引用,a 和 b 都指向同一个对象

 技术分享图片

2、b = a.copy(): 浅拷贝, a 和 b 是一个独立的对象,但他们的子对象还是指向统一对象(是引用)。

 技术分享图片

1.3 深拷贝

 1 import copy 2 l = [1,1,1,2,3,4,5] 3 l2 = copy.deepcopy(l)# 深拷贝 

  • 解析

b = copy.deepcopy(a): 深度拷贝, a 和 b 完全拷贝了父对象及其子对象,两者是完全独立的。

技术分享图片

 

2 函数

2.1 函数定义 

 1 def db_connect(ip,port=3306): #1.位置参数,必填;2.默认值参数 2 print(ip,port) #函数体 

 1 def my3():
 2     a = 1
 3     b = 2
 4     c = 3
 5     return a,b,c
 6 
 7 b,c,d = my3()
 8 s = my3()
 9 print(b,c,d)
10 print(s)

运行结果:

1 2 3
(1, 2, 3)

2.2 return作用

1、结束函数,只要函数里面遇到return,函数立即结束运行
2、返回函数处理的结果

  • 例:判断一个字符串是否是小数(含正小数和负小数)
 1 def check_float(s):
 2     ‘‘‘
 3     这个函数的作用就是判断传入的字符串是否是合法的小数
 4     :param s: 传入一个字符串
 5     :return: True/false
 6     ‘‘‘
 7     s = str(s)
 8     if s.count(.)==1:
 9         s_split = s.split(.)
10         left,right = s_split
11         if left.isdigit() and right.isdigit():
12             return True
13         elif left.startswith(-) and left[1:].isdigit() 14             and right.isdigit():
15             return True
16     return False #上面的几个条件未满足,则会走到这一步
17 
18 print(check_float(1.3))
19 print(check_float(-1.3))
20 print(check_float(01.3))
21 print(check_float(-1.3))
22 print(check_float(-a.3))
23 print(check_float(a.3))
24 print(check_float(1.3a3))
25 print(check_float(---.3a3))

2.3 可变参数

 1 def send_sms(*args): #可变参数,参数组
 2     #1、不是必传的
 3     #2、它把传入的元素全部都放到了一个元组里面
 4     #3、不限制参数个数
 5     #4、它用在参数比较多的情况下
 6     for p in args:
 7         print(p)
 8 
 9 send_sms()
10 print(-----------------------------)
11 send_sms(1861231231)
12 print(-----------------------------)
13 send_sms(1861231231,1232342,42342342)

运行结果:

-----------------------------
1861231231
-----------------------------
1861231231
1232342
42342342

2.4 关键字参数

1 def send_sms2(**kwargs):
2     #1、不是必传的
3     #2、不限制参数个数
4     print(kwargs)
5 
6 send_sms2()
7 send_sms2(name=xiaohei,sex=nan)
8 send_sms2(addr=北京,country=中国,c=abc,f=kkk)

运行结果:

{}
{‘name‘: ‘xiaohei‘, ‘sex‘: ‘nan‘}
{‘addr‘: ‘北京‘, ‘country‘: ‘中国‘, ‘c‘: ‘abc‘, ‘f‘: ‘kkk‘}

2.5 参数顺序

1 def my(name,country=China,*args,**kwargs):
2     #1、位置参数 2、默认值参数 3、可变参数 4、关键字
3     print(name)
4     print(country)
5     print(args)
6     print(kwargs)
7 my(xiaojun,Japan,beijing,天通苑,color=红色,
8    age=32)

运行结果:

xiaojun
Japan
(‘beijing‘, ‘天通苑‘)
{‘color‘: ‘红色‘, ‘age‘: 32}

2.6 全局变量

 1 name = wangcan#全局变量
 2 names = []
 3 def get_name():
 4     names.append(hahaha)
 5     name = hailong
 6     print(1、函数里面的name,name) 
 7 
 8 def get_name2():
 9     global name #声明name是全局变量
10     print(2、get_name2,name)
11 
12 get_name2() 
13 get_name()
14 print(names)
15 print(3、函数外面的name,name) 
#运行结果:
2、get_name2 wangcan
1、函数里面的name hailong
[‘hahaha‘]
3、函数外面的name wangcan

  

1 name = wangcan#全局变量
2 def get_name3():
3     name = 我是谁 #不会对全局变量产生作用
4     print(name)
5 get_name3()
6 print(name)
#运行结果:
我是谁
wangcan

2.7 函数调用

1 def db_connect(ip, user, password, db, port):
2     print(ip)
3     print(user)
4     print(password)
5     print(db)
6     print(port)
7 
8 db_connect(user = abc, port= 3306, db = 1, ip = 234234, password = 123456) #记不住顺序可以这样调用
9 db_connect(192,root, db = 2, password = 234, port = 45)#这样也行, 混搭, 但‘192‘,‘root‘必须按顺序写在前面

 

3 递归

函数自己调用自己
递归最多999次
效率没有循环高
1 #阶乘 1 × 2 × 3 × ... × n
2 def fact(n):
3     if n==1:
4         return 1
5     return n * fact(n - 1)

 

4 集合

1、天生可以去重
2、集合是无序

  • 集合定义

 1 jihe = set() 

  • 集合例子

 1 l=[1,1,2,2,3,3] 2 res = set(l) 3 print(res) 

#运行结果:集合
{1, 2, 3}

 

4.1 交集、并集、差集、对称差集

 1 xingneng =[tanailing,杨帆,liurongxin,小黑]
 2 zdh = [tanailing,杨帆,liurongxin,小军,海龙]
 3 xingneng = set(xingneng)
 4 zdh = set(zdh)
 5 #取交集
 6 res1 = xingneng.intersection(zdh)#取交集
 7 res2 = xingneng &  zdh   #取交集
 8 #取并集
 9 res3 = xingneng.union(zdh) #取并集,把2个集合合并到一起,然后去重
10 res4 = xingneng | zdh
11 #取差集
12 res5 = xingneng.difference(zdh) #取差集,在a里面有,在b里面没有的
13 res6 = xingneng - zdh #取差集
14 #取对称差集
15 res7 =xingneng.symmetric_difference(zdh)#两个里不重复的值
16 res8 = xingneng ^ zdh
17 
18 print(res1)
19 print(res2)
20 print(res3)
21 print(res4)
22 print(res5)
23 print(res6)
24 print(res7)
25 print(res8)
#运行结果
{‘liurongxin‘, ‘杨帆‘, ‘tanailing‘}
{‘liurongxin‘, ‘杨帆‘, ‘tanailing‘}
{‘tanailing‘, ‘liurongxin‘, ‘小军‘, ‘海龙‘, ‘杨帆‘, ‘小黑‘}
{‘tanailing‘, ‘liurongxin‘, ‘小军‘, ‘海龙‘, ‘杨帆‘, ‘小黑‘}
{‘小黑‘}
{‘小黑‘}
{‘海龙‘, ‘小军‘, ‘小黑‘}
{‘海龙‘, ‘小军‘, ‘小黑‘}

  

4.2 其他方法

1 import string
2 l1 = set(string.ascii_lowercase)
3 l2 = {a,b,c}
4 print(l2.issubset(l1)) #子集
5 print(l1.issuperset(l2)) #父集
6 print(l1.isdisjoint(l2)) #有交集,返回False, 没有交集,返回True
#运行结果
True
True
False
1 l2 = {a,b,c}
2 l2.add(s) #
3 print(l2)
4 
5 l2.remove(a) #
6 print(l2)
7 
8 l2.pop()#随机删
9 print(l2)
#运行结果:
{‘c‘, ‘a‘, ‘b‘, ‘s‘}
{‘c‘, ‘b‘, ‘s‘}
{‘b‘, ‘s‘}

 

 

【04】Python 深拷贝浅拷贝 函数 递归 集合

标签:and   其他   turn   函数   ase   ==   默认   ima   union   

原文地址:https://www.cnblogs.com/momolei/p/9622524.html

(0)
(0)
   
举报
评论 一句话评论(0
登录后才能评论!
© 2014 mamicode.com 版权所有  联系我们:gaon5@hotmail.com
迷上了代码!