python学习笔记

1411阅读　0评论2012-02-17　小尾巴鱼121121
分类：

学习资料：《简明 Python 教程.pdf》
使用单引号（'）
你可以用单引号指示字符串，就如同'Quote me on this'这样。所有的空白，即空格和制表符都照原样保留。
 使用双引号（"）
在双引号中的字符串与单引号中的字符串的使用完全相同，例如"What's your name?"。
使用三引号（'''或"""）
利用三引号，你可以指示一个多行的字符串。你可以在三引号中自由的使用单引号和双引号。例如：
'''This is a multi-line string. This is the first line.
This is the second line.
"What's your name?," I asked.
He said "Bond, James Bond."
'''
例如：'What\'s your name?' ==> What's your name?
如果你想要指示某些不需要如转义符那样的特别处理的字符串，那么你需要指定一个自然字符串。自然字符串通过给字符串加上前缀r或R来指定。例如r"Newlines are indicated by \n"。
>>>print r"hello\n"
        hello\n   #\n没有被转义
  • Unicode字符串：
Unicode是书写国际文本的标准方法。如果你想要用你的母语如北印度语或阿拉伯语写文本，那么你需要有一个支持Unicode的编辑器。类似地，Python允许你处理Unicode文本——你只需要在字符串前加上前缀u或U。例如，u"This is a Unicode string."。

记住，在你处理文本文件的时候使用Unicode字符串，特别是当你知道这个文件含有用非英语的语言写的文本。
如果你把两个字符串按字面意义相邻放着，他们会被Python自动级连。例如，'What\'s' 'your name?'会被自动转为"What's your name?"
命名规则：1.以字母或下划线开始 2.大小写敏感 3.变量名尽量有意义
  • 对象
记住，Python把在程序中用到的任何东西都称为对象 。这是从广义上说的，因此我们不会说“某某 东西 ”，我们说“某个 对象”
空白在Python中是重要的。事实上行首的空白是重要的(行首空白不能乱用！)。它称为缩进。在逻辑行首的空白（空格和制表符）用来决定逻辑行的缩进层次，从而用来决定语句的分组。这意味着同一层次的语句必须有相同的缩进。每一组这样的语句称为一个块。
考虑跨平台性，在每个缩进层次使用 单个制表符 或 两个或四个空格 。

运算符和表达式

下表为Python中运算符的优先级次序(最下面的优先级最高)，在设计程序时建议使用圆括号，以便能够明确的指出运算的先后次序，使程序易读。
控制流
 if ，while ，for， break ，continue
if语句用来检验一个条件， 如果 条件为真，我们运行一块语句（称为 if-块 ），否则 我们处理另外一块语句（称为 else-块 ）。 else 从句是可选的。
例：if(condition2): #注意加冒号，它告诉Python下面跟着一个语句块
           do something #有缩进，这就是缩进在python中重要的原因
#一个语句块。 与c语言不同的是语句块是用缩进来区分，而不是大括号{}
       elif(condition2):
            do otherthing
else:
     do left thin
注：在Python中没有switch语句。你可以使用if..elif..else语句来完成同样的工作（在某些场合，使用字典会更加快捷。）
只要在一个条件为真的情况下，while语句允许你重复执行一块语句。while语句有一个可选的else从句。
while（condition）：
do something #可以内嵌if语句，但记得要再缩进
... ...
else:
do otherthing
... ...
注：在while循环中使用一个else从句。
for...in是另外一个循环语句，它在一序列的对象上 递归 即逐一使用队列中的每个项目。
for i in range(1, 5): #range(1,5)内建函数给出序列[1, 2, 3, 4]。默认地，range的步长为1。如果我们为range提供第三个数，那么它将成为步长。例如，range(1,5,2)给出[1,3]。记住，range 向上 延伸到第二个数，即它不包含第二个数。
print i #输出1 2 3 4
else: #else部分是可选的它总是在for循环结束后执行一次，除非遇到break语句。
print 'The for loop is over'
注：Python的for循环从根本上不同于C/C++的for循环。
break语句是用来 终止 循环语句的，即哪怕循环条件没有称为False或序列还没有被完全递归，也停止执行循环语句。
while True:
s = raw_input('Enter something : ')
if s == 'quit':  #当输入字串为quit时推出循环
break
print 'Length of the string is', len(s)
print 'Done'
注：如果你从for或while循环中 终止 ，任何对应的循环else块将不执行。
continue语句被用来告诉Python跳过当前循环块中的剩余语句，然后 继续 进行下一轮循环。
while True:
s = raw_input('Enter something : ')
if s == 'quit':
break
if len(s) < 3:
continue
print 'Input is of sufficient length'
# Do other kinds of processing here...
注：continue语句对于for循环也有效。
函数
函数是重用的程序段。它们允许你给一块语句一个名称，然后你可以在你的程序的任何地方使用这个名称任意多次地运行这个语句块。这被称为调用函数，python内有许多内建的函数，如len和range等。
函数通过def关键字定义。def关键字后跟一个函数的标识符名称，然后跟一对圆括号。圆括号之中可以包括一些变量名，该行以冒号结尾。接下来是一块语句，它们是函数体。
def sayHello():
print 'Hello World!' # block belonging to the function
sayHello() # call the function
注：如下函数表示一个空模块函数
def someFunction():
pass
#pass语句在Python中表示一个空的语句块。
函数取得的参数是你提供给函数的值，参数在函数定义的圆括号对内指定，用逗号分割。函数中的参数名称为 形参 而你提供给函数调用的值称为实参 。
def printMax(a, b):
if a > b:
print a, 'is maximum'
else:
print b, 'is maximum'
printMax(3, 4) # directly give literal values
x = 5
y = 7
printMax(x, y) # give variables as arguments
函数内部声明的变量就是局部变量，他们与函数外具有相同名称的其他变量没有任何关系，即变量的作用域不同。所用变量的作用域是它们被定义的块，从被定义点开始。
def func(x): 
print 'x is', x
x = 2 #局部变量，它的作用域只是在函数内部
print 'Changed local x to', x
x = 50
func(x)
print 'x is still', x #外部的变量值并未受到影响
如果你想要为一个定义在函数外的变量赋值，那么你就得告诉Python这个变量名不是局部的，而是全局的。使用global语句完成。
def func():
global x #声明x是外部变量
print 'x is', x
x = 2
print 'Changed local x to', x
x = 50
func()
print 'Value of x is', x #调用函数后外部变量x的值也发生了改变(变为2了)
对于一些函数，你可能希望它的一些参数是 可选 的，如果用户不想要为这些参数提供值的话，这些参数就使用默认值。这个功能借助于默认参数值完成。你可以在函数定义的形参名后加上赋值运算符（=）和默认值，从而给形参指定默认参数值。
def say(message, times = 1): #默认参数为1
print message * times  #打印times次message的串
say('Hello')
say('World', 5)
注：只有在形参表末尾的那些参数可以有默认参数值，即你不能在声明函数形参的时候，先声明有默认值的形参而后声明没有默认值的形参。例如：def func(a, b=5)是有效的，但是def func(a=5, b)是无效的。
如果你的某个函数有许多参数，而你只想指定其中的一部分，那么你可以通过命名来为这些参数赋值——这被称作关键参数 ——使用名字（关键字）而不是位置（我们前面所一直使用的方法）来给函数指定实参。
def func(a, b=5, c=10):
print 'a is', a, 'and b is', b, 'and c is', c
func(3, 7)
func(25, c=24) #使用c=24来指定c的值，而不是位置
func(c=50, a=100) #指定关键参数a和c的值为100和50
return语句用来从一个函数 返回 即跳出函数。我们也可选从函数 返回一个值 。
def maximum(x, y):
if x > y:
return x #x>y返回x的值
else:
return y #y>x返回y的值
print maximum(2, 3) #直接打印函数调用后的返回值
注意：没有返回值的return语句等价于return None。None是Python中表示没有任何东西的特殊类型。例如，如果一个变量的值为None，可以表示它没有值。每个函数结尾如果没用提供return语句，都会自动暗含return None语句。
Python有一个很奇妙的特性，称为 文档字符串 ，它通常被简称为 DocStrings 。它帮助你的程序文档更加简单易懂。文档字符串的惯例是一个多行字符串。
文档字符串的惯例是一个多行字符串，它的首行以大写字母开始，句号结尾。第二行是空行，从第三行开始是详细的描述。使用__doc__（注意双下划线）调用printMax函数的文档字符串属性（属于函数的名称）。请记住Python把每一样东西 都作为对象，包括这个函数。
def printMax(x, y): #函数的定义
'''Prints the maximum of two numbers.#DocString字串，遵循DocString惯例

The two values must be integers.'''#
x = int(x) # convert to integers, if possible
y = int(y)
if x > y:
print x, 'is maximum'
else:
print y, 'is maximum'
printMax(3, 5) #函数的调用
print printMax.__doc__ #printMax对象调__doc__方法得到文档字符串(DocString)
模块
定义一个函数可以方便重用代码，如果想在其他程序中重用很多函数，可以使用模块。模块就是一个包含了所有你定义的函数和变量的文件(模块文件名必须以.py为扩展名！)
模块可以从其他程序 输入以便利用它的功能。这也是我们使用Python标准库的方法，利用import语句输入模块，会在PYTHONPATH环境变量指定的目录中寻找。
import sys   #利用import语句输入sys模块。会在PYTHONPATH环境变量指定的目录中寻找。
print 'The command line arguments are:'
for i in sys.argv:
print i
print '\n\nThe PYTHONPATH is', sys.path, '\n'
import一个模块(.py--文本文件)是比较耗时的，所以Python用另一种方法：创建字节编译的文件，文件以.pyc为扩展名。这样会更快，且字节编译的文件也是与平台无关。
如果你想要直接输入argv变量到你的程序中（避免在每次使用它时打sys.），那么你可以使用from sys import argv语句。如果你想要输入所有sys模块使用的名字，那么你可以使用from sys import *语句。这对于所有模块都适用。一般说来，应该避免使用from..import而使用import语句，因为这样可以使你的程序更加易读，也可以避免名称的冲突。
每个模块都有一个名称，在模块中可以通过语句来找出模块的名称。
当一个模块被第一次输入的时候，这个模块的主块将被运行。假如我们只想在程序本身被使用的时候运行主块，而在它被别的模块输入的时候不运行主块，这可以通过模块的__name__属性完成。
例：
if __name__ == '__main__': #判断该模块是否为主模块
print 'This program is being run by itself' #主模块时打印该语句
else:
print 'I am being imported from another module' #不是主模块时打印该语句
输出：
$ python using_name.py
This program is being run by itself
$ python
>>> import using_name
I am being imported from another module
>>>
创建自己的模块是十分简单的，我们一直在这样做！每个Python程序也是一个模块。只要确保它具有.py扩展名然后在调用程序中import（只要模块名不需要加.py）就ok了。
注：创建的模块需要在调用的程序同一目录下，或者在PYTHONPATH指定的目录中。
例：
#!/usr/bin/python  
# Filename: mymodule.py
#模块
def sayhi():
    print 'Hi, this is mymodule speaking.'
version = '0.1'
# End of mymodule.py
#!/usr/bin/python
# Filename: callmodule.py
#调用程序
import mymodule #调用mymodule模块
mymodule.sayhi()
print 'Version', mymodule.version #调用mymodule模块中的变量
输出：

$ python mymodule_demo.py
Hi, this is mymodule speaking.
Version 0.1
可以使用内建的dir函数来列出模块定义的标识符。标识符有函数、类和变量。
当你为dir()提供一个模块名的时候[如：dir(sys)]，它返回模块定义的名称列表。如果不提供参数，它返回当前模块中定义的名称列表。
例：
$ python
>>> import sys
>>> dir(sys) 
['__displayhook__', '__doc__', '__excepthook__', '__name__', '__stderr__',
'__stdin__', '__stdout__', '_getframe', 'api_version', 'argv',
'builtin_module_names', 'byteorder', 'call_tracing', 'callstats',...
数据结构
tags： 列表 ，元组 ，字典 ，序列 ，引用 
数据结构基本上就是——它们是可以处理一些 数据的结构 。或者说，它们是用来存储一组相关数据的。在Python中有三种内建的数据结构——列表、元组和字典。
列表(list)是处理一组有序项目的数据结构，列表中的项应该包括在方括号([])内，并用逗号分开(,)。列表是可变的数据类型，你可以添加、删除或是搜索列表中的项目。
例：
#!/usr/bin/python
# Filename: using_list.py
# This is my shopping list
shoplist = ['apple', 'mango', 'carrot', 'banana']
print 'I have', len(shoplist),'items to purchase.'
print 'These items are:' ,# Notice the comma at end of the line
for item in shoplist:
print item, #注意逗号的作用
print '\nI also have to buy rice.'
shoplist.append('rice') #在shoplist后加入项rice
print 'My shopping list is now', shoplist
print 'I will sort my list now'
shoplist.sort() #按名称排序
print 'Sorted shopping list is', shoplist
print 'The first item I will buy is', shoplist[0] #调用shoplist的第一项
olditem = shoplist[0]
del shoplist[0] #删除shoplist的第一项
print 'I bought the', olditem
print 'My shopping list is now', shoplist
输出结果：
$ python using_list.py
I have 4 items to purchase.
These items are: apple mango carrot banana
I also have to buy rice.
My shopping list is now ['apple', 'mango', 'carrot', 'banana', 'rice']
I will sort my list now
Sorted shopping list is ['apple', 'banana', 'carrot', 'mango', 'rice']
The first item I will buy is apple
I bought the apple
My shopping list is now ['banana', 'carrot', 'mango', 'rice']
注：1.你可以在列表中添加任何种类的对象包括数甚至其他列表。
2.我们在print语句的结尾使用了一个逗号来消除每个print语句自动打印的换行符。
元组和列表十分类似，只不过元组和字符串一样是不可变的 即你不能修改元组。元组通过圆括号中用逗号分割的项目定义。元组通常用在使语句或用户定义的函数能够安全地采用一组值的时候，即被使用的元组的值不会改变。
例：
#!/usr/bin/python
# Filename: using_tuple.py
zoo = ('wolf', 'elephant', 'penguin') #zoo元组，用小括号
print 'Number of animals in the zoo is', len(zoo)
new_zoo = ('monkey', 'dolphin', zoo) #new_zoo中包含了zoo元组
print 'Number of animals in the new zoo is', len(new_zoo)
print 'All animals in new zoo are', new_zoo
print 'Animals brought from old zoo are', new_zoo[2] #即zoo元组
print 'Last animal brought from old zoo is', new_zoo[2][2] #即zoo元组的第三个项
输出：
$ python using_tuple.py
Number of animals in the zoo is 3
Number of animals in the new zoo is 3
All animals in new zoo are ('monkey', 'dolphin', ('wolf', 'elephant', 'penguin'))
Animals brought from old zoo are ('wolf', 'elephant', 'penguin')
Last animal brought from old zoo is penguin
注：1.元组中也可以包含其他元组。
2.如果你想要的是一个只包含项目2的元组的时候，你应该指明singleton = (2 , )  后面有个逗号。
3.元组最常用在打印语句中，如：
例：
#!/usr/bin/python
# Filename: print_tuple.py
age = 22
name = 'Swaroop'
print '%s is %d years old' % (name, age) #定制的格式输出要放在%()中，不能使%name,%age
print 'Why is %s playing with that python?' % name
 输出：
$ python print_tuple.py
Swaroop is 22 years old
Why is Swaroop playing with that python?
print语句可以使用跟着%符号的项目元组的字符串。这些字符串具备定制的功能。定制让输出满足某种特定的格式。定制可以是%s表示字符串或%d表示整数。元组必须按照相同的顺序来对应这些定制。
字典是通过键值对的方式存储数据的，键(名字)必须是唯一的不可变的对象(如字符串)，值(详细信息)可以是常量或变量。
键值对在字典中以这样的方式标记：d = {key1 : value1, key2 : value2 }。注意它们的键/值对用冒号分割，而各个对用逗号分割，所有这些都包括在花括号中。字典中键值对是没有顺序的。
字典是dict类的实例/对象。
例：
# Filename: using_dict.py
# 'ab' is short for 'a'ddress'b'ook
ab = { 'Swaroop' : 'swaroopch@byteofpython.info',
'Larry' : 'larry@wall.org',
'Matsumoto' : 'matz@ruby-lang.org',
'Spammer' : 'spammer@hotmail.com'
} #字典的定义方法，键/值用冒号分开，各项用逗号分开，包含在大括号内
print "Swaroop's address is %s" % ab['Swaroop'] #取Swaroop的值，用方括号
# Adding a key/value pair
ab['Guido'] = 'guido@python.org'
# Deleting a key/value pair
del ab['Spammer'] #删除字典里的Spammer键值对
print '\nThere are %d contacts in the address-book\n' % len(ab)
for name, address in ab.items(): #ab对象里的items()方法可以得到该字典中的键和值
print 'Contact %s at %s' % (name, address)
if 'Guido' in ab: # OR ab.has_key('Guido') 查找字典中是否有Guido键
print "\nGuido's address is %s" % ab['Guido'] 
列表、元组和字符串都是序列，序列的两个主要特点是索引操作符([])和切片操作符(：)。索引操作符类似于数组的下标，如：a[0]；切片操作符可取得序列一段数据，如：a[0-5]可取得a[0],a[1],a[2],a[3],a[4]不包括a[5]，取得一个序列的全部可以是a[:]
name = 'swaroop'
print 'characters 1 to 3 is', name[1:3] #得到wa
print 'characters 2 to end is', name[2:] #得到aroop，从第二个到末尾
print 'characters 1 to -1 is', name[1:-1] #得到waroo;name[-1]代表倒数第一个
print 'characters start to end is', name[:] #得到完整的swaroop；name[:]代表全部
当你创建一个对象并给它赋一个变量的时候，这个变量仅仅引用那个对象，而不是表示这个对象本身！也就是说，变量名指向你计算机中存储那个对象的内存。这被称作名称到对象的绑定。
编写一个软件的流程：
1. 什么（分析）
2. 如何（设计）
3. 编写（实施）
4. 测试（测试与调试）
5. 使用（实施或开发）
6. 维护（优化）
开始时实施一个简单的版本。对它进行测试与调试。使用它以确信它如预期那样地工作。再增加任何你想要的特性，根据需要一次次重复这个编写－测试－使用的周期。记住“软件是长出来的，而不是建造的”。
面向对象的编程
类和对象是面向对象编程的两个主要方面。类创建一个新类型，而对象是这个类的实例 。
class Person: #创建一个类
    def __init__(self,name,age): #对对象做一些你希望的初始化，额外的第一个参数为self，这个特别的变量指对象本身
        self.name=name #域
        self.age=age
    def sayHi(self):
        print 'Hello,my name is',self.name
        print 'My age is',self.age
创建类的对象/实例
p=Person('Allen_Fu',24) #加上需要的参数
p.sayHi() #调用类里面的方法
--类与对象中的变量，对其他类和对象中不可见
域有两种：1.类的变量 2.对象的变量
类的变量：由一个类的所有对象(实例)共享使用，变量的改变会影响到所有其他的实例上
对象的变量：他不是共享的，他的改变不会影响其他实例
例：
#name:classvar.py
class obj:
    public = 0 #类的变量，值的改变会影响其他实例
    def __init__(self,var=10):
        self.var=var #对象的变量(他使用self赋值)，不会影响其他实例
    def add(self):
        obj.public+=5
        self.var+=5
        print 'public=',obj.public
        print 'var=',self.var
obja=obj()
obja.add()

objb=obj()
objb.add()
输出：
$ python classvar.py
public= 5
var= 15
public= 10 #类的变量改变
var= 15  #对象的变量不受影响
注：如果你使用的数据成员名称以 双下划线前缀 比如__privatevar，Python的名称管理体系会有效地把它作为私有变量。
面向对象的编程带来的主要好处之一是代码的重用，实现这种重用的方法之一是通过 继承机制。继承完全可以理解成类之间的类型和子类型关系。
如果在继承元组中列了一个以上的类，那么它就被称作 多重继承 。
例：
     如果有个类叫First，子类Second继承它，语句如下
class Second(First): #在子类后面用元组，(First)
.......
包括：标准输入/输出和文件的操作
标准输入/输出可以使用raw_input和print语句来完成
文件的操作：创建一个file类的对象来打开文件[help(file)]，再利用file类的read、readline或write方法来恰当的读写文件，close方法来关闭文件。
例：
#!/usr/bin/python
#name:using_python.py
poem='''\
Programming is fun
When the work is done
if you wanna make your work also fun:
    use Python!
'''
f=file('test.txt','w') #创建file类的对象
f.write(poem)
f.close()

f=file('test.txt')
while True:
    line=f.readline() #一行一行的读取数据
    if len(line)==0:
        break
    print line,
f.close()
Python提供一个标准的模块，称为pickle；还有cPickle模块，用c语言写的，速度更快。
异常
即某些非正常情况。
我们可以使用try..except语句来处理异常。我们把通常的语句放在try-块中，而把我们的错误处理语句放在except-块中。
例：
#!/usr/bin/python
# Filename: try_except.py
import sys
try:
s = raw_input('Enter something --> ')
except EOFError:
print '\nWhy did you do an EOF on me?' #在linux中按下-D , windows下按下-Z后会出现
sys.exit() # exit the program
except:
print '\nSome error/exception occurred.'
# here, we are not exiting the program
print 'Done'
还可以让try..catch块关联上一个else从句。当没有异常发生的时候，else从句将被执行。
try..finally无论发生了什么样的异常finally后的语句都会执行。
Python标准库
Python标准库是随Python附带安装的，它包含大量极其有用的模块，可完成大量任务。
sys模块包含系统对应的功能。
这个模块包含普遍的操作系统功能。可以做到与平台无关。
比较常用的：
● os.name字符串指示你正在使用的平台。比如对于Windows，它是'nt'，而对于Linux/Unix用户，它是'posix'。
● os.getcwd()函数得到当前工作目录，即当前Python脚本工作的目录路径。
● os.getenv()和os.putenv()函数分别用来读取和设置环境变量。
● os.listdir()返回指定目录下的所有文件和目录名。
● os.remove()函数用来删除一个文件。
● os.system()函数用来运行shell命令。
● os.linesep字符串给出当前平台使用的行终止符。例如，Windows使用'\r\n'，Linux使用'\n'而Mac使用'\r'。
● os.path.split()函数返回一个路径的目录名和文件名。
>>> os.path.split('/home/swaroop/byte/code/poem.txt')
('/home/swaroop/byte/code', 'poem.txt')
● os.path.isfile()和os.path.isdir()函数分别检验给出的路径是一个文件还是目录。类似地，os.path.exists()函数用来检验给出的路径是否真地存在。
附加Python的内容
在类中有一些特殊的方法具有特殊的意义，比如__init__和__del__方法等。
一些常用的特殊方法：《python参考手册》上有大量的特殊方法列表
通过列表综合，可以从一个已有的列表导出一个新的列表。例如，你有一个数的列表，而你想要得到一个对应的列表，使其中所有大于2的数都是原来的2倍。
例：
#!/usr/bin/python
# Filename: list_comprehension.py
listone = [2, 3, 4]
listtwo = [2*i for i in listone if i > 2] #列表综述
print listtwo
输出：
$ python list_comprehension.py
[6, 8]
注：listtwo = [2*i for i in listone if i > 2] 一句可以用下面代替：
listtwo=[]
for i in listone:
    if i>2:
        listtwo.append(2*i)
可见利用列表综述使代码更简洁。
当要使函数接收元组或字典形式的参数的时候，有一种特殊的方法，它分别使用*和**前缀。这种方法在函数需要获取可变数量的参数的时候特别有用。
>>> def powersum(power, *args):
... '''Return the sum of each argument raised to specified power.'''
... total = 0
... for i in args:
... total += pow(i, power)
... return total
...
>>> powersum(2, 3, 4)
25
>>> powersum(2, 10)
100
  • lambda形式
lambda语句被用来创建新的函数对象，并且在运行时返回它们。
例：
#!/usr/bin/python
# Filename: lambda.py
def make_repeater(n):
return lambda s: s*n
twice = make_repeater(2) #创造一个twice的函数 -->twice(s):return s*2
print twice('word')
print twice(5)
输出
$ python lambda.py
wordword
10
注：lambda语句用来创建函数对象。本质上，lambda需要一个参数，后面仅跟单个表达式作为函数体，而表达式的值被这个新建的函数返回。
  • exec和eval语句
exec语句用来执行储存在字符串或文件中的Python语句。例如，我们可以在运行时生成一个包含Python代码的字符串，然后使用exec语句执行这些语句。下面是一个简单的例子。
>>> exec 'print "Hello World"'
Hello World
eval语句用来计算存储在字符串中的有效Python表达式。下面是一个简单的例子。
>>> eval('2*3')
6
  • assert语句
assert语句用来声明某个条件是真的，当assert语句失败的时候，会引发一个AssertionError。
repr函数用来取得对象的规范字符串表示。反引号（也称转换符）可以完成相同的功能。





















上一篇：JXTA Java Standard Edition v2.5 Programmers Guide中文翻译(二)
下一篇：修改windows操作系统默认编码