python基础

对python中copy()函数与deepcopy()函数的理解：

一、python基础教程对copy的讲解

>>> import copy
>>> x = {'username':'wxx','foo':[1,2,3]}
>>> y = x.copy()
>>> y['username'] = 'wcy'
>>> y['foo'].remove(2)
>>> y
{'username': 'wcy', 'foo': [1, 3]}
>>> x
{'username': 'wxx', 'foo': [1, 3]}
>>>

可以看出，当在副本中替换值的时候，原始字典不受影响，但是，如果修改了某个值（原地修改，不是替换），原始的字典也会改变，因为同样的值也存储在原字典中（就像上面例子中的foo列表一样）。

>>> from copy import deepcopy
>>> d = {}
>>> d['name'] = ['xupeng','enqi']
>>> c = d.copy()
>>> dc = deepcopy(d)
>>> d['name'].append('zhen')
>>> c
{'name': ['xupeng', 'enqi', 'zhen']}
>>> dc
{'name': ['xupeng', 'enqi']}

二、参考文章：https://iaman.actor/blog/2016/04/17/copy-in-python
copy 与 deep copy 是作为 copy 模块中的两个 method
对于简单的 object，用 shallow copy 和 deep copy 没区别:

>>> import copy
>>> a = 1
>>> c1 = copy.copy(a) 
#c1 是 a 的shallow copy
>>> c2 = copy.deepcopy(a) 
#c2 是 a 的 deep copy
>>> a = 2
>>> a
2
>>> c1
1
>>> c2
1
#c1 和 c2 都不会随着 a 改变自己的值
>>> c1 == c2
True
>>> cop1 is cop2
True

复杂的 object， 如 list 中套着 list 的情况，shallow copy 中的 子list，并未从原 object 真的「独立」出来。也就是说，如果你改变原 object 的子 list 中的一个元素，你的 copy 就会跟着一起变。这跟我们直觉上对「复制」的理解不同。

>>> import copy
>>> a = [1, 2, [3, 4]]
#a 里边有三个元素：1， 2，[3, 4]
>>> c1 = copy.copy(a)
>>> c2 = copy.deepcopy(a)
>>> c1 == c2
True
>>> c1 is c2
False 
#c1 和 c2 看上去相同，但已不再是同一个object
>>> a[2][0] = "hey!" 
>>> a
[1, 2, ['hey!', 4]]
>>> c1
[1, 2, ['hey!', 4]]
>>> c2
[1, 2, [3, 4]]
#把a内的子list [3, 4] 改掉了一个元素，观察 c1 和 c2

Python 与众不同的变量储存方法

Python 存储变量的方法跟其他 OOP 语言不同。它与其说是把值赋给变量，不如说是给变量建立了一个到具体值的 reference。
当在 Python 中 a = something 应该理解为给 something 贴上了一个标签 a。当再赋值给 a 的时候，就好象把 a 这个标签从原来的 something 上拿下来，贴到其他对象上，建立新的 reference。 这就解释了一些 Python 中可能遇到的诡异情况：

>>> a = [1, 2, 3]
>>> b = a
>>> a = [4, 5, 6] //赋新的值给 a
>>> a
[4, 5, 6]
>>> b
[1, 2, 3]
# a 的值改变后，b 并没有随着 a 变

>>> a = [1, 2, 3]
>>> b = a
>>> a[0], a[1], a[2] = 4, 5, 6 //改变原来 list 中的元素
>>> a
[4, 5, 6]
>>> b
[4, 5, 6]
# a 的值改变后，b 随着 a 变了

上面两段代码中，a 的值都发生了变化。区别在于，第一段代码中是直接赋给了 a 新的值（从 [1, 2, 3] 变为 [4, 5, 6]）；而第二段则是把 list 中每个元素分别改变。

而对 b 的影响则是不同的，一个没有让 b 的值发生改变，另一个变了。怎么用上边的道理来解释这个诡异的不同呢？

首次把 [1, 2, 3] 看成一个物品。a = [1, 2, 3] 就相当于给这个物品上贴上 a 这个标签。而 b = a 就是给这个物品又贴上了一个 b 的标签。

第一种情况：
a = [4, 5, 6] 就相当于把 a 标签从 [1 ,2, 3] 上撕下来，贴到了 [4, 5, 6] 上。

在这个过程中，[1, 2, 3] 这个物品并没有消失。 b 自始至终都好好的贴在 [1, 2, 3] 上，既然这个 reference 也没有改变过。 b 的值自然不变。

第二种情况：
a[0], a[1], a[2] = 4, 5, 6 则是直接改变了 [1, 2, 3] 这个物品本身。把它内部的每一部分都重新改装了一下。内部改装完毕后，[1, 2, 3] 本身变成了 [4, 5, 6]。

而在此过程当中，a 和 b 都没有动，他们还贴在那个物品上。因此自然 a b 的值都变成了 [4, 5, 6]。

言归正传，Copy时候到底发生了什么

先看这里的 shallow copy。 如图所示，cop1 就是给当时的 origin 建立了一个镜像。origin 当中的元素指向哪， cop1 中的元素就也指向哪。这就是官方 doc 中所说的 inserts references into it to the objects found in the original 。

这里的关键在于，origin[2]，也就是 [3, 4] 这个 list。根据 shallow copy 的定义，在 cop1[2] 指向的是同一个 list [3, 4]。那么，如果这里我们改变了这个 list，就会导致 origin 和 cop1 同时改变。这就是为什么上边 origin[2][0] = “hey!” 之后，cop1 也随之变成了 [1, 2, [‘hey!’, 4]]。

再来看 deep copy。 从图中可以看出，cop2 是把 origin 每层都 copy 了一份存储起来。这时候的 origin[2] 和 cop2[2] 虽然值都等于 [3, 4]，但已经不是同一个 list了。

既然完全独立，那无论如何改变其中一个，另一个自然不会随之改变。

python在数据挖掘领域有哪些工具包

参考文章：http://blog.csdn.net/sunflower606/article/details/49738107

布尔值

　　所有标准对象均可以用于布尔测试，同类型的对象之间可以比较大小。每一个对象天生具有布尔True或false值

　　空对象、值为0的任意数字或Null对象None的布尔值都是False
　　下列对象的布尔值都是False:
　　None
　　False(布尔类型)
　　所有的值为0的数
　　0(整型)
　　(浮点型)
　　0L(长整型)
　　0.0+0.0j(复数)
　　“”(空字符串)
　　[] 空列表
　　()(空元组)
　　{}(空字典)
　　值不是上面列出来的任何值的对象的布尔值都是True

IPv4-IPv6

IPv4：IP地址由4个字节构成，共32位。
IPv6：IP地址由16个字节构成，共128位。
IPv6 /特点
（1）IPV6地址长度为128比特，地址空间增大了2的96次方倍；
（2）灵活的IP报文头部格式。使用一系列固定格式的扩展头部取代了IPV4中可变长度的选项字段。IPV6中选项部分的出现方式也有所变化，使路由器可以简单路过选项而不做任何处理，加快了报文处理速度。
（3）IPV6简化了报文头部格式，字段只有7个，加快报文转发，提高了吞吐量；
（4）提高安全性。身份认证和隐私权是IPV6的关键特性。
（5）支持更多的服务类型；
（6）允许协议继续演变，增加新的功能，使之适应未来技术的发展。

OSI

参考：http://www.baike.com/wiki/OSI&prd=button_doc_entry
七层结构：
由低到高：物理层（Physical Layer)，数据链路层（Data Link Layer)，网络层(Network Layer)，传输层（Transport Layer)，会话层（Session Layer），表示层（Presentation Layer)和应用层（Application Layer)

ftp

参考：http://blog.csdn.net/bear_huangzhen/article/details/41806903
FTP工作在TCP/IP模型的应用层，基于的传输协议是TCP，FTP客户端和服务器之间的连接是可靠的，面向连接的，为数据的传输提供了可靠的保证。

snmp

参考：http://www.ppkao.com/daan/185896/CE70D82C755162E3DCFB11836EA811A8
snmp所采用的传输层协议为UDP.

软件设计中划分模块的准则是：高内聚低耦合

参考：https://www.cnblogs.com/robnetcn/archive/2012/04/15/2449008.html
高内聚低耦合：
内聚性又称块内联系。指模块的功能强度的度量，即一个模块内部各个元素彼此结合的紧密程度的度量。若一个模块内各元素（语名之间、程序段之间）联系的越紧密，则它的内聚性就越高。
有个例子很容易明白：一个程序有50个函数，这个程序执行得非常好；然而一旦你修改其中一个函数，其他49个函数都需要做修改，这就是高耦合的后果。
一旦你理解了它，你编写概要设计的时候设计类或者模块自然会考虑到“高内聚，低耦合”。

Wi-Fi 802.11g工作频段为2.4GHz频段

参考：http://www.dianziaihaozhe.com/tianxian/WiFi/2981.html

哪种协议用来解析IP地址到MAC地址的对应关系：ARP

参考：http://www.ppkao.com/tiku/daan/2411928/2130CB1A4C4FBCD2A558A055A02F5486
Linux查进程：ps aux | grep program_filter_word
杀进程：kill -9 端口号

PEP 8

参考1：https://www.python.org/dev/peps/pep-0008/
参考2：https://www.douban.com/note/134971609/

时间

参考：https://www.cnblogs.com/emanlee/p/4399147.html

import time
import datetime
print(time.ctime())
print(datetime.datetime.utcnow())
now = datetime.datetime.now()
print(now)
print(now.strftime('%Y-%m-%d %H:%M:%S') )
----------------------------------------------------------
Thu Dec 28 22:28:59 2017
2017-12-28 14:28:59.273363#英国时间
2017-12-28 22:28:59.273363
2017-12-28 22:28:59#时间格式化
#协调世界时，又称世界统一时间、世界标准时间、国际协调时间。由于英文（CUT）和法文（TUC）的缩写不同，作为妥协，简称UTC。
#暴露什么时候写了

说说exec()

参考：https://www.cnblogs.com/rim99/p/6980120.html
exec()是Python的built-in函数。其作用很好描述，就是执行以string类型存储的Python代码。

>>> i = 2
>>> j = 3
>>> exec("ans = i + j")
>>> print("Answer is: ", ans)
Answer is:  5
>>>

在上个例子里面，ans变量并没有显式的定义，但仍然可以在print函数中调用。这是exec语句执行了”ans = i + j”中的代码，定义了ans变量。

乍一看，这个功能很像C语言里的define宏定义：都是在代码里面插入可变的代码段。但其实还不一样，再看一个例子。

>>> i = 5
>>> j = 7
>>> n = 0
>>> while n < i:
...     print("looping")
...     if j > i:
...         break
...     n += 1
... 
looping
>>> 

假设使用exec函数

>>> i = 5
>>> j = 7
>>> n = 0
>>> while n < i:
...     print("looping")
...     exec("""if j > 5:
...           \n    break""")
...     n += 1
... 
looping
Traceback (most recent call last):
  File "<stdin>", line 4, in <module>
  File "<string>", line 3
SyntaxError: "break" outside loop

在这里，exec函数为什么失效了呢?

根据Python文档，解释器会在执行到break语句时，会跳出离该句最近的while、for循环，如果解释器无法找到while、for循环，就会报错。因此，此处报错，说明了Python解释器没有找到exec之前的while循环。

实际上，仔细看文档会发现，解释器遇到exec函数时，会独立执行字符串内的语句。如果还有传参，那都是定义变量的字典。解释器，不会寻找字符串外的语法结构。也就是说，在这个例子中，解释器会独立执行语句

if j > i:
    break

python2和python3区别

参考：https://www.cnblogs.com/codingmylife/archive/2010/06/06/1752807.html
未完待续。。。
后面更精彩…