Python中深浅拷贝 垃圾回收与 super继承(六)

import copy
a = [1, 2, 3, 4, [‘a‘, ‘b‘]]  #原始对象

b = a  #赋值，传对象的引用
c = copy.copy(a)  #对象拷贝，浅拷贝
d = copy.deepcopy(a)  #对象拷贝，深拷贝

a.append(5)  #修改对象a
a[4].append(‘c‘)  #修改对象a中的[‘a‘, ‘b‘]数组对象

print(‘a = ‘, a)
print( ‘b = ‘, b)
print( ‘c = ‘, c)
print(‘d = ‘, d)

输出结果：
a =  [1, 2, 3, 4, [‘a‘, ‘b‘, ‘c‘], 5]  #a执行两次值追加操作
b =  [1, 2, 3, 4, [‘a‘, ‘b‘, ‘c‘], 5]  #赋值是对象的引用，b指向仍然是a，因此与a内容保持一致
c =  [1, 2, 3, 4, [‘a‘, ‘b‘, ‘c‘]]  #对象的浅拷贝外部list重新生成新的空间，但是嵌套数组的内存地址不变
d =  [1, 2, 3, 4, [‘a‘, ‘b‘]]  #深拷贝是所有的数组都新生成一个内存空间，与原来的脱离关系

is判定
    判定值相等,内存地址也相等
a = 10
b = 10
a is b
Ture    常用的1-256计算机共用一个内存地址
        
a = 9999999
b = 9999999
a is b
False    数值较大的数类似长整型,计算机会生成新的内存地址

var与let
    var 定义的变量可以重新被定义
    let 定义的变量不能重新被定义

#read
f = open("a.txt")  
lines = f.read()  
print(lines)  
print(type(lines))  
f.close() 
#输出
# hello 
# python!
<type ‘str‘> #字符串类型  

#readline
f = open("a.txt")  
line = f.readline()  
print(type(line))  
while line:  
  print line,  
  line = f.readline()  
f.close() 
#输出
#<type ‘str‘> 
<type ‘str‘> #字符串类型  
# hello 
# python!

#readlines
f = open("a.txt")  
lines = f.readlines()  
print(type(lines))  
for line in lines:  
   print(line)  
f.close()
#输出
<type ‘list‘> 
# hello 
# python!

class Animal(object):   #Animal为父类
    def __init__(self, name):
        self.name = name
    def greet(self):
        print ‘Hello, I am %s.‘ % self.name
 
class Dog(Animal):  #Dog为子类
    def greet(self):  #Dog重定义了greet方法并继承了父类的方法
        super(Dog, self).greet()   # Python3 可使用 super().greet()
        print ‘WangWang...‘
        
>>> dog = Dog(‘dog‘)  #实例化
>>> dog.greet()   #调用greet方法
Hello, I am dog.
WangWang..

class Base(object):
    def __init__(self, a, b):
        self.a = a
        self.b = b
 
class A(Base):
    def __init__(self, a, b, c):
        super(A, self).__init__(a, b)  # 初始化子类继承父类super(子类名,self).__init__(父类参数)
        self.c = c
    

class Base(object):
    def __init__(self):
        print "enter Base"
        print "leave Base"
  
class A(Base):  #继承base
    def __init__(self):
        print "enter A"
        super(A, self).__init__()
        print "leave A"
 
class B(Base):  #继承base
    def __init__(self):
        print "enter B"
        super(B, self).__init__()
        print "leave B"
 
class C(A, B):  #多重继承自A,B   
    def __init__(self):
        print "enter C"
        super(C, self).__init__()  #super第一个参数可以是继承链中任意类名字
        print "leave C"
        
#输出
>>> c = C()
enter C
enter A
enter B
enter Base
leave Base
leave B
leave A
leave C