Python day eleven

　　今天重点：深拷贝与浅拷贝，set集合，函数。

　简单的来说就是，在有指针的情况下，浅拷贝只是增加了一个指针指向已经存在的内存，而深拷贝就是增加一个指针并且申请一个新的内存，使这个增加的指针指向这个新的内存，采用深拷贝的情况下，释放内存的时候就不会出现在浅拷贝时重复释放同一内存的错误！在python中浅copy就是copy函数，而深层copy就是要引用一个模块，也就是copy模快。

import copy
# shallow copy 浅拷贝
husband = ['xiaopan', 123, [15000, 9000]]

wife = husband.copy()
wife[0] = 'xiaomei'
wife[1] = 234
wife[2][1] -= 3000
print(husband)
print(wife)

#deepcopy copy 深拷贝

xiaosan = copy.deepcopy(husband)
xiaosan[0] = 'jinx'
xiaosan[1] = 666
husband[2][1] += 3000
print(xiaosan)
print(wife)

　　这个就是一个例子，在改变深copy之后，wife的输出结果和xiaosan 的是不一样的。

一.深拷贝

源对象和副本对象是不同的两个对象

源对象引用计数不变，副本对象计数器为1（因为是新产生的）

至少有一层是对象复制

二.浅拷贝

源对象和副本对象是同一个对象

源对象（副本对象）引用计数器+1，相当于做一次retain操作

本质：没有产生新的对象

三.完全复制

对于被复制的对象每一层都是对象复制

四.哪些是深拷贝，哪些是浅拷贝

retain：始终是浅复制；返回对象是否可变与被复制的对象保持一致

copy：对于可变对象是深拷贝，返回一个不可变对象

           对于不可变对象为浅拷贝，返回一个不可变对象

mutableCopy：始终是深拷贝，始终返回一个可变对象

转自http://blog.csdn.net/qq_28523871/article/details/50370960

　　然后就是集合了，和数学中的集合的定义是一样的，也就在一个集合中不可以有相同的元素。而且有其他相同的集合之间的关系，也就是交集，并集等

# _author:"Isaac_hu"
# data: 2018/3/10
# 集合的作用： 1 去重  2 关系测试
# 集合的创建只能通过关键字set创建 每个元素只能出现一次
li = ['isaac', 1, 2]
s = set(li)  # 去除重复的
print(s)  # 只有一个字符时会将字符串当成一个list分成单个字符
print(type(s))
s2 = list(s)
print(s2)
# set里面的内容必须是可哈希的，也就是不可变类型，这个也是无序的
# 使用迭代器输出所有的内容，或者使用in 或者 in not判断是否在里面
for i in s:
    print(i)
# set它本身是不可哈希的，可以添加 删除

# 添加 添加一个元素
# s.add('u')
# print(s)
s.add('uu')
print(s)

# 更新 会将更新的内容作为一个集合，整体添加到之前的集合中
# s.update('op')
# print(s)
s.update([2, 'eee'])  # 如果之前有了就不会更新进去
print(s)

# 删除 remove
s.remove(2)
print(s)

# 删除 pop方法。随机删除一个
print(s.pop())

# 清空 clear
s.clear()
print(s)

# 删除 del 从内存中删除

# 集合的等价和不等价
print(set("isaac") == set("issaaaccc"))  # 是等价的

# 集合的属于 和不属于 < , <=  属于，全属于
print(set("abc") < set('abcd'))  #  真  前面的集合是后面的自己

　　列出其中的一些方法：还有一些就是set的交集等；

# _author:"Isaac_hu"
# data: 2018/3/10
a = set([1, 2, 3, 4])
b = set([3, 4, 5, 6])
# 取交集 intersection交集 或者用 & 表示并集
print(a.intersection(b))
print(a & b)

# 取并集 union并集 或者用 | 表示并集
print(a.union(b))
print(a | b)

# 差集 difference 或者用 - 表示并集
print(a.difference(b))  # 等出a与b不相同的部分 in a not in b
print(a - b)

# 对称差集  symmetric_difference 对称的差集 或者用 ^表示并集
print(a.symmetric_difference(b))
print(a ^ b)

# 父集和子集
print(a.issuperset(b))  # a > b
print(a.issubset(b))  # a < b

　　函数：

　　　　函数和数学中的函数是不相同的，在编程语言中函数是一个子过程。而不是编译函数，在python中定义个一个函数需要使用到关键字def。

# _author:"Isaac_hu"
# data: 2018/3/10
import time
# 函数的作用，避免重复代码
# 函数的定义，数学中的函数是function 计算机中的函数 == subroutine , procedures子程序或者叫流程
# 作用 1 减少重复代码  2 方便修改：易于扩展 3 保持代码的一致性

# 创建函数怎么定义使用关键字def 即 define
def hello():
    print("hello world")
hello() # 调用一定要用加括号
# 函数命名规则 与变量的命名规则一样的。区分大小写
def add(a, b):
    print(a+b)
add(5,8)
def logger(n):
    time_format = "%Y-%m-%d %X"
    time_current = time.strftime(time_format)
    with open("日志文件", 'a', encoding="utf-8") as f:
        f.write("%s end action%s 
"%(time_current,n))
def action(n):
    print("starting action%s"%n)

action("开始运行")
logger("开始运行")
action("运行中")
logger("运行中")
action("停止运行")
logger("停止运行")

# _author:"Isaac_hu"
# data: 2018/3/10
# def print_info(name, age, sex='male'):  # 参数必须要对应位置
#     print("name:%s"%name, end=" ")
#     print("age:%d"%age, end=" ")
#     print("sex:%s"%sex, end="
")
# print_info(name='isaac', age = 20)  # 或者用关键字参数来对应
# print_info(name='tom', age=21)
# 默认参数 必须在其他参数后面

# def add(*args):  # *args能够传入不定长参数
#     sum = 0
#     for i in args:
#         sum += i
#     print(sum)
# add(1, 2, 5)  # 无命令参数，存储为元组

def print_info(sex = 'male', *args, **kwargs):  # 有命令参数 存储为字典

    print(kwargs)
    for i in kwargs:
        print('%s: %s'%(i, kwargs[i]))
print_info(1, 2, name='isaac',age = 18)
# 关于不定长的位置，*args左边，**args放右边，无命名的放左边，有命名放右边
# 关于默认默认一定放在最前面

# _author:"Isaac_hu"
# data: 2018/3/10
if True:
    x = 3
print(x)
# def f():
#     a = 10
# print(a)  # 这个是错误的，函数的变量作用域是，函数代码块中

# 变量的四种作用域
# L == local 局部变量 E == enclosing 嵌套作用变量，嵌套的父级
#  G == global 全局变量 B == build in 最外层的定义
x = int(2)  # build in
x = 0  # global
def out():
    o_count = 1  # enclosing
    def inner():
        i_count = 2  # local
        print(i_count)
    # print(i_count)  #找不到
out()
count = 10
def outer():
    global count  # 声明为全局变量，就可以了
    # count + = 1  # 这里，函数的局部变量没有声明，就使用了。
    count = 1  # 内部可以自己申请一个变量用于局部变量
outer()
# nonlocal 用于嵌套作用域变量

# _author:"Isaac_hu"
# data: 2018/3/10
# return 的作用 1.结束函数  2.返回某个对象
def f():
    return "ok"  # 默认None
print(f())

def foo():
    return 1, '123', '[12,123]'
print(foo())
# 注意 ：1 。 函数中没有return 会返回None
#        2. 多个对象封装成一个元组返回

　　emmmmm，很偷懒！