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