96、Jython 语句和内置函数快速参考

Jython 语句和内置函数快速参考

1. 内置函数概述

Jython 提供了丰富的内置函数，这些函数可以帮助开发者更高效地完成各种任务。以下是部分常用内置函数的介绍：

1.1 绝对值函数 abs

• 功能 ：返回数字的绝对值。
• 语法 ： abs(number)
• 示例 ：

>>> abs(-5.43)
5.43

1.2 调用对象函数 apply

• 功能 ：调用一个对象，可以是函数、类或任何可调用对象。
• 语法 ： apply(object[, args[, kwargs]])
• 示例 ：

>>> def printKWArgs(**kw):
...     print kw
...
>>> apply(printKWArgs, (), globals())
{'__name__': '__main__', 'printKWArgs': <function printKWArgs at 2744202>, '__doc__': None}
>>> def product(x, y):
...     return x * y
...
>>> print apply(product, (3, 4))
12

1.3 判断可调用性函数 callable

• 功能 ：判断对象是否为可调用类型，返回 1 或 0。
• 语法 ： callable(object)
• 示例 ：

>>> def myFunction():
...     return
...
>>> callable(myFunction)
1
>>> callable("a string")
0

1.4 字符转换函数 chr

• 功能 ：对于小于等于 65535 的整数，返回具有指定整数值的字符。
• 语法 ： chr(integer)
• 示例 ：

>>> chr(119)
'w'
>>> chr(88)
'X'
>>> chr(50000)
u'\uC350'

1.5 比较函数 cmp

• 功能 ：比较两个参数，根据大小关系返回 -1、0 或 1。
• 语法 ： cmp(x, y)
• 示例 ：

>>> cmp(1, 3)
-1
>>> cmp(3, 1)
1
>>> cmp(3, 3)
0

1.6 类型转换函数 coerce

• 功能 ：接受两个对象，尝试找到一个共同类型来表示它们的值。
• 语法 ： coerce(x, y)
• 示例 ：

>>> coerce(3.1415, 6) # float and int
(3.1415, 6.0)
>>> results = coerce("a", 2.3)
Traceback (most recent call last):
  File "<stdin>", line 1, in ?
TypeError: number coercion failed

1.7 编译函数 compile

• 功能 ：将字符串编译为代码对象。
• 语法 ： compile(source, filename, mode)
• 示例 ：

>>> co = compile("0 and 'This' or 1 and 'that'", "-", "eval")
>>> exec(co)
>>> eval(co)
'that'
>>> co = compile("for x in range(10):\n\tprint x, ", "<console>", "single")
>>> exec(co)
0 1 2 3 4 5 6 7 8 9

1.8 复数创建函数 complex

• 功能 ：返回一个复数，实部和虚部由参数指定。
• 语法 ： complex(real[, imag])
• 示例 ：

>>> complex(2) # int to complex
(2+0j)
>>> complex(3.1, 0.123) # floats to complex
(3.1+0.123j)
>>> complex("2.1", "0.1234")
(2.1000000000000001+0j)

1.9 删除属性函数 delattr

• 功能 ：从对象中删除指定的属性。
• 语法 ： delattr(object, name)
• 示例 ：

>>> class cache:
...     pass # empty class to store arbitrary objects
...
>>> c = cache()
>>> c.a = 1
>>> c.b = 2
>>> vars(c)
{'a': 1, 'b': 2}
>>> delattr(c, "a")
>>> vars(c)
{'b': 2}

1.10 获取对象属性函数 getattr

• 功能 ：返回对象指定属性的引用。
• 语法 ： getattr(object, name[, default])
• 示例 ：

>>> from time import time
>>> class util:
...     def __init__(self):
...         self.inittime = time()
...
>>> u = util()
>>> getattr(u, "inittime")
9.8829678293E8
>>> getattr(u, "currenttime", time())
9.8829681275E8

1.11 全局变量函数 globals

• 功能 ：返回表示全局命名空间中定义的变量的字典对象。
• 语法 ： globals()
• 示例 ：

>>> num = 1
>>> string = "a String"
>>> globals()
{'num': 1, '__name__': '__main__', '__doc__': None,'string': 'a String'}

1.12 判断属性存在函数 hasattr

• 功能 ：测试对象是否具有指定的属性，返回 1 或 0。
• 语法 ： hasattr(object, name)
• 示例 ：

>>> class add:
...     def __init__(self):
...         pass
...     def methodA(self):
...         pass
...
>>> hasattr(add, "methodA")
1
>>> hasattr(add, "methodB")
0

1.13 哈希值函数 hash

• 功能 ：返回对象的哈希值。
• 语法 ： hash(object)
• 示例 ：

>>> a = 1
>>> hash(1)
1
>>> hash(a)
1
>>> c = "dog"
>>> hash(c)
1528775661

1.14 十六进制转换函数 hex

• 功能 ：返回整数的十六进制表示字符串。
• 语法 ： hex(number)
• 示例 ：

>>> hex(16)
'0x10'
>>> hex(15)
'0xf'

1.15 对象唯一标识函数 id

• 功能 ：返回对象的唯一标识符。
• 语法 ： id(object)
• 示例 ：

>>> string = "A"
>>> id("A")
6262933

1.16 输入函数 input

• 功能 ：与 raw_input 类似，但输入的内容会被求值。
• 语法 ： input([prompt])
• 示例 ：

>>> input("Enter a Jython expression: ")
Enter a Jython expression: 2+3
5  <- the evaluated result of 2++3

1.17 整数转换函数 int

• 功能 ：将参数转换为整数。
• 语法 ： int(x[, base])
• 示例 ：

>>> int(3.5)  # float to int
3
>>> int(5L)  # long to int
5
>>> int(abs(2.2+1.72j))  # complex to int
2
>>> int("012", 8)  # octal string to int
10
>>> int("0x1A", 16)  # hex string to int
26

1.18 字符串驻留函数 intern

• 功能 ：将指定字符串放入长生命周期字符串的 PyStringMap 中，并返回驻留的字符串对象。
• 语法 ： intern(string)
• 示例 ：

>>> string1 = "a"
>>> Istring1 = intern(string1)
>>> id(string1), id(Istring1)
(7347538, 7347538)

1.19 判断实例类型函数 isinstance

• 功能 ：判断实例是否为指定类的实例，返回 1 或 0。
• 语法 ： isinstance(instance, class)
• 示例 ：

>>> import java
>>> hm = java.util.HashMap()
>>> isinstance(hm, java.util.HashMap)
1
>>> isinstance(hm, java.util.AbstractMap)
1
>>> isinstance(hm, java.util.Vector)
0

1.20 长度函数 len

• 功能 ：返回序列或映射类型的长度。
• 语法 ： len(object)
• 示例 ：

>>> len("a string")
8
>>> len([1,2,3,4,5])
5
>>> len(range(0,100,7))
15

1.21 列表创建函数 list

• 功能 ：接受一个序列参数，返回具有相同成员的列表。
• 语法 ： list(sequence)
• 示例 ：

>>> list("abcdefg")
['a', 'b', 'c', 'd', 'e', 'f', 'g']
>>> list(("a", "b", "c", "d", "e", "f", "g"))
['a', 'b', 'c', 'd', 'e', 'f', 'g']

1.22 局部变量函数 locals

• 功能 ：返回包含局部命名空间中定义的变量的 PyStringMap 。
• 语法 ： locals()
• 示例 ：

>>> def aFunction():
...     aVariable = "String var"
...     print locals()
...
>>> aFunction()
{'aVariable': 'String var'}

1.23 长整数转换函数 long

• 功能 ：将参数转换为长整数。
• 语法 ： long(x, base)
• 示例 ：

>>> long(2.7)  # float to long
2L
>>> long(abs(1.1+2.3j))  # complex to long
2L
>>> long("021", 8)  # octal string to long
17L
>>> long("0xff", 16)  # hex string to long
255L

1.24 映射函数 map

• 功能 ：对序列中的每个成员应用指定函数，并返回结果列表。
• 语法 ： map(function, sequence[, sequence, ...])
• 示例 ：

>>> map(None, range(6), ["a", "b", "c"])
[(0, 'a'), (1, 'b'), (2, 'c'), (3, None), (4, None), (5, None)]
>>> def pad(string):
...     return string.rjust(10)
...
>>> map(pad, ["a", "b", "c", "d"])
['         a', '         b', '         c', '         d']

1.25 最大值函数 max

• 功能 ：返回序列中的最大值。
• 语法 ： max(sequence)
• 示例 ：

>>> max(1,2,3,4,5,6,7,8,9)
9
>>> T = ("strings", "are", "compared", "lexigraphically")
>>> max(T)
'strings'

1.26 最小值函数 min

• 功能 ：返回序列中的最小值。
• 语法 ： min(sequence)
• 示例 ：

>>> min(1,2,3,4,5)
1
>>> T = "min returns the smallest char of a string"
>>> min(T)
' '

1.27 八进制转换函数 oct

• 功能 ：返回整数的八进制表示字符串。
• 语法 ： oct(number)
• 示例 ：

>>> oct(8)
'010'
>>> oct(7)
'07'

1.28 文件打开函数 open

• 功能 ：打开指定文件并返回文件对象。
• 语法 ： open(filename[, mode[, buffering]])
• 示例 ：

>>> # open file in current directory for reading plus writing.
>>> fo = open("config.cfg", "r+")
>>> # Open file for binary reading
>>> fo = open("c:\soot\baf\Baf.class", "rb")

1.29 字符整数转换函数 ord

• 功能 ：返回字符的整数值。
• 语法 ： ord(character)
• 示例 ：

>>> ord('w')
119
>>> ord('X')
88
>>> ord(u'\uC350')
50000

1.30 幂运算函数 pow

• 功能 ：返回 x**y ，如果提供 z ，则返回 x**y % z 。
• 语法 ： pow(x, y[, z])
• 示例 ：

>>> pow(3, 3)
27
>>> pow(3, 3, 2)
1

1.31 范围函数 range

• 功能 ：返回基于起始、终止和步长参数生成的整数列表。
• 语法 ： range([start,] stop [, step])
• 示例 ：

>>> range(4)
[0, 1, 2, 3]
>>> range(3, 6)
[3, 4, 5]
>>> range(2, 10, 2)
[2, 4, 6, 8]

1.32 原始输入函数 raw_input

• 功能 ：从标准输入读取字符串并去除换行符。
• 语法 ： raw_input([prompt])
• 示例 ：

>>> name = raw_input("Enter your name: ")
Enter your name: Bilbo Baggins
>>> print name
Bilbo Baggins

1.33 归约函数 reduce

• 功能 ：将列表的值归约为一个值。
• 语法 ： reduce(function, sequence[, initial])
• 示例 ：

>>> def add(x, y):
...     return x + y
...
>>> reduce(add, [5,4,3,2,1])
15
>>> def stripspaces(x, y):
...     return x.strip() + y.strip()
...
>>> reduce(stripspaces, "A string with spaces")
'Astringwithspaces'

1.34 模块重载函数 reload

• 功能 ：重新加载指定模块。
• 语法 ： reload(module)
• 示例 ：

>>> import math
>>> # If the math module changed- reload it.
>>> reload(math)
<jclass org.python.modules.math at 1401745>

1.35 表示对象函数 repr

• 功能 ：返回对象的字符串表示。
• 语法 ： repr(object)
• 示例 ：

>>> repr(123)
'123'
>>> repr(type)
'<java function type at 4737674>'
>>> repr("A string")
"'A string'"

1.36 四舍五入函数 round

• 功能 ：返回数值参数的浮点数表示，可指定保留的小数位数。
• 语法 ： round(number[, ndigits])
• 示例 ：

>>> round(1.23434, 3L)
1.234
>>> round(23.2124)
23.0
>>> round(2)
2.0

1.37 设置属性函数 setattr

• 功能 ：设置对象的属性值。
• 语法 ： setattr(object, name, value)
• 示例 ：

>>> class split:
...     def __init__(self, token):
...         self.token = token
...
>>> s = split(":")
>>> vars(s)
{'token': ':'}
>>> setattr(s, 'count', 0)
>>> setattr(s, 'token', ",")
>>> vars(s)
{'token': ',', 'count': 0}

1.38 切片函数 slice

• 功能 ：是序列切片语法的同义词。
• 语法 ： slice([start,] stop[, step])
• 示例 ：

>>> L = ["s", "o", "r", "c", "q", "a", "p", "j"]
>>> sliceobj = slice(7, 0, -2)
>>> L[sliceobj]
['j', 'a', 'c', 'o']

1.39 字符串表示函数 str

• 功能 ：返回对象的字符串表示。
• 语法 ： str(object)
• 示例 ：

>>> str(1)  # int to string
'1'
>>> str(4L)  # long to string
'4'
>>> str(2.2+1.3j)
'(2.2+1.3j)'
>>> from java.util import Vector
>>> str(Vector)
'java.util.Vector'
>>> v = Vector()
>>> str(v)
'[]'
>>> v.add(type)  # put a function in the vector
1
>>> str(v)
'[<java function type at 5229978>]'

1.40 元组创建函数 tuple

• 功能 ：接受一个序列参数，返回具有相同成员的元组。
• 语法 ： tuple(sequence)
• 示例 ：

>>> tuple([1,2,3,4,5])  # list to tuple
(1, 2, 3, 4, 5)
>>> tuple("This is a test")  # string to tuple
('T', 'h', 'i', 's', ' ', 'i', 's', ' ', 'a', ' ', 't', 'e', 's', 't')

1.41 类型函数 type

• 功能 ：返回对象的类型。
• 语法 ： type(object)
• 示例 ：

>>> type("a string")
<jclass org.python.core.PyString at 1923370>

1.42 Unicode 字符函数 unichr

• 功能 ：与 chr 功能相同，为了与 CPython 兼容而存在。
• 语法 ： unichr(i)
• 示例 ：见 chr

1.43 Unicode 字符串创建函数 unicode

• 功能 ：使用指定编码创建新的 PyString 对象。
• 语法 ： unicode(string [, encoding[, errors]])
• 示例 ：

>>> unicode("Abél", "utf_8", "replace")
u'Ab\uFFFDl'

1.44 变量字典函数 vars

• 功能 ：如果指定对象，返回对象内部绑定的名称字典；如果未指定对象，与 locals() 功能相同。
• 语法 ： vars([object])
• 示例 ：

>>> class aClass:
...     def __init__(self):
...         attrib1 = "An instance variable"
...         attrib2 = "Another instance variable"
...
>>> vars(aClass)
{'__init__': <function __init__ at 634037>, '__module__': '__main__', '__doc__': None}
>>> vars()
{'aClass': <class __main__.aClass at 7033304>, '__name__': '__main__', '__doc__': None}

1.45 范围生成器函数 xrange

• 功能 ：与 range 功能相同，但返回一个 xrange 对象，按需生成数字，适合处理极大范围。
• 语法 ： xrange([start,] stop [, step])
• 示例 ：见 range

1.46 拉链函数 zip

• 功能 ：返回一个元组列表，元组长度等于最短的输入序列长度。
• 语法 ： zip(seq1 [, seq2 [...]])
• 示例 ：

>>> zip([1,2,3,4,5,6,7], "abcdefg")
[(1, 'a'), (2, 'b'), (3, 'c'), (4, 'd'), (5, 'e'), (6, 'f'), (7, 'g')]
>>> zip(range(5), range(5,-1,-1))
[(0, 5), (1, 4), (2, 3), (3, 2), (4, 1)]

2. 内置函数总结

函数名	功能描述	语法
abs	返回数字的绝对值	abs(number)
apply	调用一个对象	apply(object[, args[, kwargs]])
callable	判断对象是否可调用	callable(object)
chr	返回指定整数对应的字符	chr(integer)
cmp	比较两个对象	cmp(x, y)
coerce	尝试将两个对象转换为相同类型	coerce(x, y)
compile	将字符串编译为代码对象	compile(source, filename, mode)
complex	创建复数	complex(real[, imag])
delattr	删除对象的指定属性	delattr(object, name)
dir	返回对象的属性列表	dir([object])
divmod	返回商和余数	divmod(x, y)
eval	计算表达式的值	eval(source[, globals[, locals]])
execfile	执行指定文件中的代码	execfile(filename[, globals[, locals]])
filter	过滤序列中的元素	filter(function, sequence)
float	将对象转换为浮点数	float(x)
getattr	获取对象的属性	getattr(object, name[, default])
globals	返回全局命名空间的字典	globals()
hasattr	判断对象是否有指定属性	hasattr(object, name)
hash	返回对象的哈希值	hash(object)
hex	返回整数的十六进制表示	hex(number)
id	返回对象的唯一标识符	id(object)
input	获取用户输入并求值	input([prompt])
int	将对象转换为整数	int(x[, base])
intern	字符串驻留	intern(string)
isinstance	判断对象是否为指定类的实例	isinstance(instance, class)
len	返回对象的长度	len(object)
list	将序列转换为列表	list(sequence)
locals	返回局部命名空间的字典	locals()
long	将对象转换为长整数	long(x, base)
map	对序列中的每个元素应用函数	map(function, sequence[, sequence, ...])
max	返回序列中的最大值	max(sequence)
min	返回序列中的最小值	min(sequence)
oct	返回整数的八进制表示	oct(number)
open	打开文件	open(filename[, mode[, buffering]])
ord	返回字符的整数表示	ord(character)
pow	幂运算	pow(x, y[, z])
range	生成整数序列	range([start,] stop [, step])
raw_input	获取用户输入	raw_input([prompt])
reduce	对序列进行归约操作	reduce(function, sequence[, initial])
reload	重新加载模块	reload(module)
repr	返回对象的字符串表示	repr(object)
round	四舍五入	round(number[, ndigits])
setattr	设置对象的属性	setattr(object, name, value)
slice	创建切片对象	slice([start,] stop[, step])
str	将对象转换为字符串	str(object)
tuple	将序列转换为元组	tuple(sequence)
type	返回对象的类型	type(object)
unichr	返回指定整数对应的 Unicode 字符	unichr(i)
unicode	创建 Unicode 字符串	unicode(string [, encoding[, errors]])
vars	返回对象的属性字典	vars([object])
xrange	生成整数序列（按需生成）	xrange([start,] stop [, step])
zip	将多个序列打包成元组列表	zip(seq1 [, seq2 [...]])

3. 内置函数调用流程图

graph TD;
    A[开始] --> B{选择函数};
    B --> C{abs};
    B --> D{apply};
    B --> E{callable};
    B --> F{chr};
    B --> G{cmp};
    B --> H{coerce};
    B --> I{compile};
    B --> J{complex};
    B --> K{delattr};
    B --> L{dir};
    B --> M{divmod};
    B --> N{eval};
    B --> O{execfile};
    B --> P{filter};
    B --> Q{float};
    B --> R{getattr};
    B --> S{globals};
    B --> T{hasattr};
    B --> U{hash};
    B --> V{hex};
    B --> W{id};
    B --> X{input};
    B --> Y{int};
    B --> Z{intern};
    B --> AA{isinstance};
    B --> AB{len};
    B --> AC{list};
    B --> AD{locals};
    B --> AE{long};
    B --> AF{map};
    B --> AG{max};
    B --> AH{min};
    B --> AI{oct};
    B --> AJ{open};
    B --> AK{ord};
    B --> AL{pow};
    B --> AM{range};
    B --> AN{raw_input};
    B --> AO{reduce};
    B --> AP{reload};
    B --> AQ{repr};
    B --> AR{round};
    B --> AS{setattr};
    B --> AT{slice};
    B --> AU{str};
    B --> AV{tuple};
    B --> AW{type};
    B --> AX{unichr};
    B --> AY{unicode};
    B --> AZ{vars};
    B --> BA{xrange};
    B --> BB{zip};
    C --> C1[返回绝对值];
    D --> D1[调用对象];
    E --> E1[判断可调用性];
    F --> F1[返回字符];
    G --> G1[比较对象];
    H --> H1[类型转换];
    I --> I1[编译代码];
    J --> J1[创建复数];
    K --> K1[删除属性];
    L --> L1[返回属性列表];
    M --> M1[返回商和余数];
    N --> N1[计算表达式];
    O --> O1[执行文件];
    P --> P1[过滤元素];
    Q --> Q1[转换为浮点数];
    R --> R1[获取属性];
    S --> S1[返回全局字典];
    T --> T1[判断属性存在];
    U --> U1[返回哈希值];
    V --> V1[返回十六进制];
    W --> W1[返回唯一标识];
    X --> X1[获取输入并求值];
    Y --> Y1[转换为整数];
    Z --> Z1[字符串驻留];
    AA --> AA1[判断实例类型];
    AB --> AB1[返回长度];
    AC --> AC1[转换为列表];
    AD --> AD1[返回局部字典];
    AE --> AE1[转换为长整数];
    AF --> AF1[应用函数到序列];
    AG --> AG1[返回最大值];
    AH --> AH1[返回最小值];
    AI --> AI1[返回八进制];
    AJ --> AJ1[打开文件];
    AK --> AK1[返回字符整数];
    AL --> AL1[幂运算];
    AM --> AM1[生成整数序列];
    AN --> AN1[获取输入];
    AO --> AO1[归约序列];
    AP --> AP1[重新加载模块];
    AQ --> AQ1[返回字符串表示];
    AR --> AR1[四舍五入];
    AS --> AS1[设置属性];
    AT --> AT1[创建切片对象];
    AU --> AU1[转换为字符串];
    AV --> AV1[转换为元组];
    AW --> AW1[返回对象类型];
    AX --> AX1[返回 Unicode 字符];
    AY --> AY1[创建 Unicode 字符串];
    AZ --> AZ1[返回属性字典];
    BA --> BA1[生成按需整数序列];
    BB --> BB1[打包序列];
    C1 --> BC[结束];
    D1 --> BC;
    E1 --> BC;
    F1 --> BC;
    G1 --> BC;
    H1 --> BC;
    I1 --> BC;
    J1 --> BC;
    K1 --> BC;
    L1 --> BC;
    M1 --> BC;
    N1 --> BC;
    O1 --> BC;
    P1 --> BC;
    Q1 --> BC;
    R1 --> BC;
    S1 --> BC;
    T1 --> BC;
    U1 --> BC;
    V1 --> BC;
    W1 --> BC;
    X1 --> BC;
    Y1 --> BC;
    Z1 --> BC;
    AA1 --> BC;
    AB1 --> BC;
    AC1 --> BC;
    AD1 --> BC;
    AE1 --> BC;
    AF1 --> BC;
    AG1 --> BC;
    AH1 --> BC;
    AI1 --> BC;
    AJ1 --> BC;
    AK1 --> BC;
    AL1 --> BC;
    AM1 --> BC;
    AN1 --> BC;
    AO1 --> BC;
    AP1 --> BC;
    AQ1 --> BC;
    AR1 --> BC;
    AS1 --> BC;
    AT1 --> BC;
    AU1 --> BC;
    AV1 --> BC;
    AW1 --> BC;
    AX1 --> BC;
    AY1 --> BC;
    AZ1 --> BC;
    BA1 --> BC;
    BB1 --> BC;

以上是部分 Jython 内置函数的详细介绍，通过合理使用这些函数，可以大大提高编程效率。在实际开发中，开发者可以根据具体需求选择合适的函数来完成任务。

4. Jython 语句概述

Jython 中的语句是构建程序逻辑的基础，不同的语句具有不同的功能，能够满足各种编程需求。以下是部分常用 Jython 语句的介绍：

4.1 断言语句 assert

• 功能 ：测试表达式是否为真，如果为假则抛出异常。如果提供两个表达式，它们被视为逻辑或关系，只要其中一个为真就不会抛出异常。设置 __debug__ = 0 或使用 -O 命令行开关可以禁用断言。
• 语法 ： "assert" expression [, expression]
• 示例 ：

>>> a = 21
>>> assert a < 10
Traceback (innermost last):
  File "<console>", line 1, in ?
AssertionError: 

4.2 跳出循环语句 break

• 功能 ：终止当前循环的执行，继续执行循环块之后的代码。如果循环有 else 子句， break 语句会跳过 else 子句。
• 语法 ： "break"
• 示例 ：

>>> for x in (1, 2, 3, 4):
...     if x == 3:
...         break
...     print x
...
1
2

4.3 类定义语句 class

• 功能 ：开始一个类的定义。
• 语法 ： "class" name[(base - class - name(s))]:
• 示例 ：

>>> class test:   # no base class
...     pass      # place holder
...
>>> t = test()    # Calls class to create an instance

4.4 继续循环语句 continue

• 功能 ：暂停当前循环块的执行，开始下一次循环迭代。
• 语法 ： "continue"
• 示例 ：

>>> for x in (1, 2, 3, 4):
...     if x == 3:
...         continue
...     print x
...
1
2
4

4.5 函数定义语句 def

• 功能 ：开始一个函数或方法的定义。
• 语法 ： "def" name(([parameters]): code - block
• 示例 ：

>>> def caseless_srch_n_replace(string, srch, rplc):
...     return string.lower().replace(srch, rplc)
...
>>> S = "Some UseLess text"
>>> caseless_srch_n_replace(S, "useless", "useful")
'some useful text'

4.6 删除变量语句 del

• 功能 ：从调用 del 语句的命名空间中删除变量。
• 语法 ： "del" identifier
• 示例 ：

>>> a = "foo"
>>> print a
foo
>>> del a
>>> print a
Traceback (innermost last):
  File "<console>", line 1, in ?
NameError: a

4.7 执行语句 exec

• 功能 ：执行字符串、打开的文件对象或代码对象。可选的第二和第三个表达式分别表示全局和局部命名空间。如果只提供全局命名空间，局部命名空间默认与之相同。如果都不提供，则使用当前命名空间。
• 语法 ： "exec" expression ["in" expression ["," expression]]
• 示例 ：

>>> exec("print 'The exec method is used to print this'")
The exec method is used to print this

4.8 循环语句 for

• 功能 ：对序列中的每个成员重复执行关联的代码块，直到序列遍历完或遇到 break 语句。循环结束后，如果有 else 子句，会执行 else 子句中的代码。
• 语法 ： "for" variable "in" expression":" code - block ["else:"] code - block
• 示例 ：

>>> for x in (1, 2, 3):
...     print x, "in first code - block"
... else:
...     print "In second code - block"
...
1 in first code - block
2 in first code - block
3 in first code - block
In second code - block

4.9 全局变量声明语句 global

• 功能 ：明确指定变量从全局命名空间引用，而不是局部命名空间。
• 语法 ： "global" identifier ["," identifier]*
• 示例 ：

>>> var = 10
>>> def test():
...     global var
...     print var  # try and print the global identifier 'var'
...     var = 20   # assign to 'var' in local namespace
...
>>> test()
10

4.10 条件语句 if

• 功能 ：根据表达式的真假条件执行不同的代码块。代码块可以为 if 、 elif 和 else 语句定义。只有第一个表达式为真的代码块会被执行，如果所有表达式都为假，则执行 else 代码块。
• 语法 ： "if" expression: code - block "elif" expression: code - block "else": code - block
• 示例 ：

>>> a, b = 0, 1
>>> if a == b:
...     print "variable a equals variable b"
... elif a > b:
...     print "variable a is greater than b"
... else:
...     print "variable a is less than b"
...
variable a is less than b

4.11 导入语句 import

• 功能 ：导入指定的 Jython 包、Jython 模块、Java 包或 Java 类。可以使用 as 修饰符为导入的名称指定别名。
• 语法 ：
• import module - name
• from module - name import names
• import module - name as new - name
• 示例 ：

>>> import sys
>>> from java import util
>>> import os as myOS
>>> from sys import packageManager as pm

4.12 空语句 pass

• 功能 ：作为占位符，不执行任何操作。
• 语法 ： "pass"
• 示例 ：

>>> for x in (1, 2, 3, 4):
...     pass
...
>>> def doNothing():
...     pass

4.13 打印语句 print

• 功能 ：计算表达式的值，必要时将结果转换为字符串，并将字符串写入 sys.stdout 或指定的类文件对象。
• 语法 ：
• "print" [expression]
• "print >> " fileLikeObject,, [expression]
• 示例 ：

>>> print "Hello world"
Hello world
>>> print >> myFile, "Hello world"

4.14 抛出异常语句 raise

• 功能 ：抛出一个异常。可以跟随三个可选表达式，分别表示异常类型、异常值和异常回溯信息。
• 语法 ： "raise" [expression [, expression [, traceback]]]
• 示例 ：

>>> raise ValueError, "No value provided"
Traceback (innermost last):
  File "<console>", line 1, in ?
ValueError: no value provided

4.15 返回语句 return

• 功能 ：终止当前方法或函数的执行，并返回表达式的值。如果没有表达式，则返回 None 。
• 语法 ： "return" [expression]
• 示例 ：

>>> def someFunction():
...     return "This string is the return value"
...
>>> print someFunction()
This string is the return value

4.16 异常处理语句 try/except

• 功能 ：Jython 的异常处理机制，类似于 Java 的 try/catch 语句。 try 块中的代码执行直到完成或出现错误，如果出现错误，控制权会立即转移到合适的 except 子句处理异常。如果使用 try/finally 语法， finally 块无论是否有异常都会执行。
• 语法 ：
• "try:" code - block "except" [expression ["," target]] ":" code - block ["else:" code - block]
• "try:" code - block "finally:" code - block
• 示例 ：

>>> try:
...     1/0
... except ZeroDivisionError, e:
...     print "You cannot divide by zero: ", e
...
You cannot divide by zero: integer division or modulo
>>>
>>> try:
...     pass
... finally:
...     print "This block always executes"
...
This block always executes

4.17 循环语句 while

• 功能 ：只要表达式为真，就重复执行关联的代码块，直到表达式为假或遇到 break 语句。
• 语法 ： "while" expression ":"
• 示例 ：

>>> x = 10
>>> while x > 0:
...     print x,
...     x -= 1
...
10 9 8 7 6 5 4 3 2 1

5. Jython 语句总结

语句名	功能描述	语法
assert	测试表达式是否为真，为假则抛出异常	"assert" expression [, expression]
break	终止当前循环	"break"
class	定义一个类	"class" name[(base - class - name(s))]:
continue	跳过当前循环迭代，继续下一次迭代	"continue"
def	定义一个函数或方法	"def" name(([parameters]): code - block
del	从命名空间中删除变量	"del" identifier
exec	执行字符串、文件对象或代码对象	"exec" expression ["in" expression ["," expression]]
for	对序列中的每个元素执行代码块	"for" variable "in" expression":" code - block ["else:"] code - block
global	声明变量为全局变量	"global" identifier ["," identifier]*
if	根据条件执行不同代码块	"if" expression: code - block "elif" expression: code - block "else": code - block
import	导入模块、包或类	import module - name OR from module - name import names OR import module - name as new - name
pass	空语句，作为占位符	"pass"
print	打印表达式的值	"print" [expression] OR "print >> " fileLikeObject,, [expression]
raise	抛出异常	"raise" [expression [, expression [, traceback]]]
return	从函数或方法中返回值	"return" [expression]
try/except	异常处理	"try:" code - block "except" [expression ["," target]] ":" code - block ["else:" code - block] OR "try:" code - block "finally:" code - block
while	当条件为真时执行循环	"while" expression ":"

6. Jython 语句执行流程图

graph TD;
    A[开始] --> B{选择语句};
    B --> C{assert};
    B --> D{break};
    B --> E{class};
    B --> F{continue};
    B --> G{def};
    B --> H{del};
    B --> I{exec};
    B --> J{for};
    B --> K{global};
    B --> L{if};
    B --> M{import};
    B --> N{pass};
    B --> O{print};
    B --> P{raise};
    B --> Q{return};
    B --> R{try/except};
    B --> S{while};
    C --> C1[测试表达式，为假抛异常];
    D --> D1[终止循环];
    E --> E1[定义类];
    F --> F1[跳过当前迭代];
    G --> G1[定义函数或方法];
    H --> H1[删除变量];
    I --> I1[执行代码];
    J --> J1[遍历序列执行代码];
    K --> K1[声明全局变量];
    L --> L1[根据条件执行代码块];
    M --> M1[导入模块或类];
    N --> N1[空操作];
    O --> O1[打印表达式值];
    P --> P1[抛出异常];
    Q --> Q1[返回值];
    R --> R1[异常处理];
    S --> S1[条件为真执行循环];
    C1 --> T[结束];
    D1 --> T;
    E1 --> T;
    F1 --> T;
    G1 --> T;
    H1 --> T;
    I1 --> T;
    J1 --> T;
    K1 --> T;
    L1 --> T;
    M1 --> T;
    N1 --> T;
    O1 --> T;
    P1 --> T;
    Q1 --> T;
    R1 --> T;
    S1 --> T;

Jython 的内置函数和语句为开发者提供了强大的工具集，能够帮助开发者高效地编写代码。通过熟悉这些函数和语句的功能、语法和使用示例，开发者可以更好地利用 Jython 进行编程开发。在实际应用中，根据具体需求灵活运用这些函数和语句，可以提高代码的质量和效率。