>>> x = [1, 2, 3]
>>> x
[1, 2, 3]
>>> y = x
>>> y
[1, 2, 3]
>>> x.append(4)
>>> x
[1, 2, 3, 4]
>>> y
[1, 2, 3, 4]
>>> z = [10, 12, 14]
>>> z
[10, 12, 14]
>>> w = [z, z]
>>> w
[ [10, 12, 14], [10, 12, 14] ]
>>> z .append( 17 )
>>> z
[10, 12, 14, 17]
>>> w
[[10, 12, 14, 17], [[10, 12, 14, 17]]
若不想通过引用, 而对赋值变量分配新的内存空间, 则需要使用浅拷贝或深度copy贝.
from copy import copy, deepcopy
>>> x = [14, 15, 21]
>>> x
[14, 15, 21]
>>> y = x
>>> y
[14, 15, 21]
>>> x is y // is 为内置
True
>>> z = copy( x ) // 只进行浅拷贝( 一层拷贝 )
>>> z
[14, 15, 21]
>>> z is x
False
>>> m = [ 1, 2, 3 ] // 内存中生成三个结点组成的链表, 链表首地址赋给m, 结点的值域中的值分别为1, 2, 3.
>>> n = [m, m] // 内存中生成两个结点组成的链表, 链表首地址赋给n, 两个结点的值域都指向链表m
>>> p = deepcopy( n ) //
//------------------------------------------------------------
Python 中的类和对象.
Python中的类和对象的实现都是以字典为基础的. 从内存的角度看, Python中类与字典的实现机制是一样的. Python, Object-C等语言都是把类( 或结构 )中的field作为字符串储存在字典中的.
lex.py 文件:
class lexicon:
def __init__( self, filename = 'words' ) : // self 是从Object-C中" 借来"的
infile = open( filename, 'r' )
words = infile.readlines()
self.words = [ ] // Python对象的内存最初被初始化为空, 当调用此self.words = ... 时就会为其中添加一个名为words的成员. 这一点与C/C++等在语言是不 同的后者在为对象分配完内存空间后, 此空间包含哪些成员变量, 它们又是如何分布的就已经确定了.
for word in words :
length = len( word ) - 1
self.words.append( word[ : length ] )
def ContainsWord( self, word ) :
return self.words[ bisect( self.words, word ) - 1 ] == word
Python实际类对象通过一个字典来建模, C/C++的所有事情都是在编译时完成的.
使用:
>>> from lex import lexicon
>>> el = lexicon()
>>> lexicon.__dict__ // 此句可以得到与lexicon相对应的字典内存分布说明. 其含有所有嵌入在内部的符号的列表.
>>> el.words = [ ] // Python 无"私有成员变量" 或 "私有成员函数" 的概念. 此句清空了lexicon类对象el的self.world成员变量, 此成员变量在__init__函数中曾被初始化.
>>> el.__dict__
[ 'words' : [ ] ]
//-------------------------------------------------------------
>>> o = object() // Python将自动产生一个Object对象
>>> o
<...>
>>> o.__dict__
{ }
>>> o.a = 17 // o.__dict__[ 'a' ] = 17
>>> o.b = "hello" // o.__dict__[ 'b' ] = "hello"
>>> o.c = False // o.__dict__[ 'c' ] = False
>>> o.__dict__
{ 'a':17, 'b':"hello", 'c':False }
Python所使用的对象是动态可扩展的, C/C++ , Java的所有任何代码其对象大小在对象一产生后就已经确定了.
Python是一种动态执行可扩展语言, 在C/C++中函数调用要借助Activation Record, 但Python则无此机制.
Lecture26
Python的XML解析与Internet编程.
Python是较"年轻"的语言, 所以它内置了一些Internet编程所需的函数.
对XML的解析有两种方式:
1. 基于流的方式: 不将全部信息完整地存储到内存中，在任何时候只存储整个文本流的一个子集．
课程中自定义XML文件结构：
...
...
from urllib2 import urlopen
from xml.sax import make.parser
import sys
def ListFeedTitles( url ) :
infile = urlopen( url ) :
parser = make.parser()
parset.setContentHandler( RSSHandler() )
parser.parse( infile )
class ContentHandler:
def __init__(self) :
ContentHandler.__init__(self)
self.__inItem = False
self.__inTitle = False // 变量前加双下划线，表此变量为类成员变量．Python中类的私有变量前必须强制加双下划线，可以在类内部直接引用但在类外部引用会 // 出错．
def Characters(sellf, data) :
if self.__inTitle:
sys.stdout.write( data )
def startElement( self, tag, attrs ) :
if tag == "item" : self.__inItem = True
if tag == "title" and self.__inItem :
self.__inTitle = True
def endElement( self, tag )
if tag == "title" and self.__inTitle :
sys.stdout.write("\n")
self.__inTitle = False
if tag == "item"
self.__inItem = False
// 上例中的startElement与endElement主要作用是维护__inTitle和__inItem两个成员变量．
2. 称为SAX方法
将XML的文档数据整个完整地存储到内存中．( XML文档整个是一个树型结构 )
因此，可以在内存中对XML的相关数据进行修改、增删。
这样一来，可以实现网页浏览时的交互操作：比如，购物网站上用户点击按钮将物品装入购物篮中等。
Lecture27
Haskell是与Scheme类似的函数式编程语言. 官网:http://www.haskell.org/haskellwiki/Haskell
从2003年出现开始, 逐渐由一种研究型语言走向实际开发应用.
与Scheme一样, 函数式编程不考虑机器如何来执行, 执行顺序如何, 而给出了问题求解的数学公式就可以直接由此得到全部的程序.
与Scheme一样, 函数可以作为一个类型在程序中传递. ( 编程原本中将函数作为类型来