|
1
2
|
>>>anInt
=
1
>>>aComplex
=
1.23
+
4.56j
|
|
1
2
3
4
5
6
7
8
|
>>> anInt
=
1
>>>
id
(anInt)
35934552
>>> anInt
+
=
1
>>> anInt
2
>>>
id
(anInt)
35934528
|
|
1
2
3
4
5
|
>>>
del
anInt
>>>
id
(anInt)
Traceback (most recent call last):
File
"<stdin>"
, line
1
,
in
<module>
NameError: name
'anInt'
is
not
defined
|
|
1
2
3
4
5
6
7
8
9
10
11
12
13
14
|
>>>
0.0
0.0
>>>
-
777.
-
777.0
>>>
96e3
*
1.0
96000.0
>>>
4.3e25
4.3e
+
25
>>>
9.384e
-
23
9.384e
-
23
>>>
float
(
12
)
12.0
>>>
4.2E
-
10
4.2e
-
10
|
-
虚数不能单独存在，它们总是和一个值为0.0的实数部分一起来构成一个复数
-
复数由实数部分和虚数部分组成
-
表示虚数的语法：x + yj
-
实数部分和虚数部分都是浮点型
-
虚数部分必须有后缀j或J
|
1
2
3
4
5
6
7
|
>>> aComplex
=
1.3
+
3j
>>> aComplex.real
1.3
>>> aComplex.imag
3.0
>>> aComplex.conjugate()
(
1.3
-
3j
)
|
-
如果有一个操作数是复数，另一个操作数则被转换为复数
-
否则，如果有一个操作数是浮点型，另一个操作数被转换为浮点型
-
否则，如果有一个操作数是长整型，另一个操作数被转换为长整型
-
否则，两者必须都是普通整型，无须作类型转换
|
1
2
3
4
5
6
|
>>>
1
=
=
1
True
>>>
1
<
5
<
9
True
>>>
1
<
5
and
5
<
9
True
|
-
传统除法
|
1
2
3
4
5
6
|
>>>
3
/
2
1
>>>
1
/
2
0
>>>
1.0
/
2.0
0.5
|
-
真正的除法
|
1
2
3
4
5
|
>>>
from
__future__
import
division
>>>
1
/
2
0.5
>>>
1.0
/
2.0
0.5
|
-
地板除
|
1
2
3
4
5
6
|
>>>
1
/
/
2
0
>>>
1.0
/
/
2.0
0.0
>>>
3
/
/
2
1
|
|
1
2
|
>>>
5
%
2
1
|
-
比其左侧操作数的一元操作符优先级高
-
比其右侧操作数的一元操作符优先级低
|
1
2
3
4
5
6
|
>>>
3
*
*
2
9
>>>
-
3
*
*
2
-
9
>>>
4.0
*
*
-
1.0
0.25
|
-
取反（～）
|
1
2
|
>>> ~
2
-
3
|
-
按位与（&）
|
1
2
|
>>>
2
&
3
2
|
-
或（|）
|
1
2
|
>>>
2
|
3
3
|
-
异或（^）
|
1
2
|
>>>
2
^
3
1
|
-
左移（<<）
|
1
2
|
>>>
2
<<
1
4
|
-
右移（>>）
|
1
2
|
>>>
2
>>
1
1
|
|
1
2
3
4
5
6
7
8
9
10
11
12
13
14
|
>>>
cmp
(
1
,
3
)
-
1
>>>
cmp
(
0xff
,
255
)
0
>>>
str
(
0xff
)
'255'
>>>
str
(
55.3e2
)
'5530.0'
>>>
type
(
0xFF
)
<
type
'int'
>
>>>
type
(
314L
)
<
type
'long'
>
>>>
type
(
2
-
1j
)
<
type
'complex'
>
|
-
用于数字类型转换（工厂函数）
-
用于执行一些常用运算（内建函数）
|
1
2
3
4
|
>>>
type
(
int
)
<
type
'type'
>
>>>
type
(
long
)
<
type
'type'
>
|
-
int(obj, base=10)：将其他类型数值转换为int类型数值或将数值字符串转换为int类型数值
base为进制转换参数，如果是数字类型之间的转换，则不需要提供这个参数，否则会引发异常：
|
1
2
|
>>>
int
(
3.0
)
3
|
|
1
2
3
4
5
6
|
>>>
int
(
'123'
)
123
>>>
int
(
'123'
,
8
)
83
>>>
int
(
'123'
,
16
)
291
|
|
1
2
|
>>>
int
(
'123'
,
0
)
123
|
-
long(obj, base=10)：将其他类型数值转换为long类型数值或将数值字符串转换为long类型数值，与int()的使用方法一样
-
float(obj)：将其他类型数值转换为float类型数值或将数值字符串转换为float类型数值
|
1
2
3
4
|
>>>
float
(
123
)
123.0
>>>
float
(
'123'
)
123.0
|
-
complex(str)或complex(real, imag=0.0)：将complex数值字符串转换为complex类型数值
|
1
2
3
4
|
>>>
complex
(
2.3e
-
10
,
45.3e4
)
>>>
complex
(
'2+3j'
)
(
2
+
3j
)
(
2.3e
-
10
+
453000j
)
|
|
1
2
3
4
|
>>>
type
(
abs
)
<
type
'builtin_function_or_method'
>
>>>
type
(
coerce
)
<
type
'builtin_function_or_method'
>
|
-
abs(num)：返回给定参数的绝对值，如果是参数为复数，则返回复数的模长
|
1
2
3
4
5
6
|
>>>
abs
(
-
1
)
1
>>>
abs
(
10.0
)
10.0
>>>
abs
(
3
+
4j
)
5.0
|
-
coerce(num1, num2)：将num1和num2转换为同一类型，然后以一个元组的形式返回
|
1
2
3
4
5
6
7
8
|
>>>
coerce
(
3
,
3
+
2j
)
((
3
+
0j
), (
3
+
2j
))
>>>
coerce
(
3.0
,
2
)
(
3.0
,
2.0
)
>>>
coerce
(
3
,
2L
)
(
3L
,
2L
)
>>>
coerce
(
3
,
2
)
(
3
,
2
)
|
-
divmod(num1, num2)：接收两个参数，返回一个包含商和余数的元组
|
1
2
3
4
5
6
|
>>>
divmod
(
10
,
3
)
(
3
,
1
)
>>>
divmod
(
10
,
2.5
)
(
4.0
,
0.0
)
>>>
divmod
(
2
+
1j
,
0.5
-
1j
)
((
-
0
+
0j
), (
2
+
1j
))
|
-
pow(num1, num2, mod=1)：取num1的num2次方，如果提供mod参数，则计算结果再对mod取余
|
1
2
3
4
|
>>>
pow
(
2
,
5
)
32
>>>
pow
(
2
,
5
,
15
)
2
|
-
round(flt, ndig=1)：接受一个浮点型flt并对其四舍五入，保存ndig位小数，若不提供ndig参数，则默认小数点后0位
|
1
2
3
4
5
6
|
>>>
round
(
3.499
)
3.0
>>>
round
(
3.599
)
4.0
>>>
round
(
3.49999
,
1
)
3.5
|
-
int()：直接去掉小数部分，结果为整型
-
math.floor()：得到最接近原数但又小于原数的整型（返回值为浮点型）
-
round()：四舍五入
|
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
|
>>>
from
math
import
floor
>>>
def
compare(num):
...
print
'int(%.1f)\t%+.1f'
%
(num,
int
(num))
...
print
'floor(%.1f)\t%+.1f'
%
(num, floor(num))
...
print
'round(%.1f)\t%+.1f'
%
(num,
round
(num))
...
>>> compare(
0.2
)
int
(
0.2
)
+
0.0
floor(
0.2
)
+
0.0
round
(
0.2
)
+
0.0
>>> compare(
0.7
)
int
(
0.7
)
+
0.0
floor(
0.7
)
+
0.0
round
(
0.7
)
+
1.0
>>> compare(
1.2
)
int
(
1.2
)
+
1.0
floor(
1.2
)
+
1.0
round
(
1.2
)
+
1.0
>>> compare(
1.7
)
int
(
1.7
)
+
1.0
floor(
1.7
)
+
1.0
round
(
1.7
)
+
2.0
>>> compare(
-
0.2
)
int
(
-
0.2
)
+
0.0
floor(
-
0.2
)
-
1.0
round
(
-
0.2
)
-
0.0
>>> compare(
-
0.7
)
int
(
-
0.7
)
+
0.0
floor(
-
0.7
)
-
1.0
round
(
-
0.7
)
-
1.0
>>> compare(
-
1.2
)
int
(
-
1.2
)
-
1.0
floor(
-
1.2
)
-
2.0
round
(
-
1.2
)
-
1.0
>>> compare(
-
1.7
)
int
(
-
1.7
)
-
1.0
floor(
-
1.7
)
-
2.0
round
(
-
1.7
)
-
2.0
|
-
oct()：将数值转换为八进制数，返回值为字符串
-
hex()：将数值转换为十六进制数，返回值为字符串
|
1
2
3
4
5
6
7
8
9
|
>>>
hex
(
255
)
'0xff'
>>>
hex
(
3893
)
'0xf35'
>>>
>>>
oct
(
255
)
'0377'
>>>
oct
(
3893
)
'07465'
|
-
chr()：接受一个单字节整型值（0～255），返回一个字符串（其实是一个字符，只是在Python中并没有“字符数据类型”）
-
ord()：接受一个ASCII范围内的字符，返回其对应的整型值
-
unichr()：接受Unicode码值，返回其对应的Unicode字符
如下：
|
1
2
3
4
5
6
7
8
9
|
>>>
chr
(
65
)
'A'
>>>
>>>
ord
(
'A'
)
65
>>>
>>>
unichr
(
1725
)
u
'\u06bd'
>>>
print
unichr
(
1725
)
|
-
没有__nonzero__()方法的对象的布尔值默认是True
-
值为零的任何数字或空集（空列表 空元组和空字典等）在Python中的布尔值都是False
|
1
2
3
4
5
6
|
>>>
bool
(
1
)
True
>>>
bool
(
3
)
True
>>>
bool
([])
False
|
|
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
|
#对象无__nonzero__方法的情况
>>>
class
C:
pass
...
>>> c
=
C()
>>>
bool
(c)
True
#重载__nonzero__方法，使它返回False
>>>
class
C:
...
def
__nonzero__(
self
):
...
return
False
...
>>> c
=
C()
>>>
bool
(c)
False
>>>
bool
(C)
True
|
|
1
2
|
>>>
0.1
0.1
|
-
randint(num1, num2)：返回num1和num2之间的随机整数（能取到下限和上限）
|
1
2
3
4
5
6
7
8
|
>>> random.randint(
1
,
2
)
2
>>> random.randint(
1
,
2
)
2
>>> random.randint(
1
,
2
)
2
>>> random.randint(
1
,
2
)
1
|
-
randrange(num1, num2)：返回值为range(num1, num2)之间的数，即不能取到上限
|
1
2
3
4
5
6
7
|
>>> random.randrange(
1
,
2
)
1
>>> random.randrange(
1
,
2
)
1
>>> random.randrange(
1
,
2
)
1
……
|
-
uniform(num1, num2)：几乎和randint()一样，不过它返回的是二者之间的一个浮点型（不包括范围上限）
|
1
2
3
4
5
6
|
>>> random.uniform(
1
,
2
)
1.2845602051034062
>>> random.uniform(
1
,
2
)
1.0178567905561313
>>> random.uniform(
1
,
2
)
1.8440532614481977
|
-
random()：类似于uniform，不过它不接收参数，并且下限恒等于0.0，上限恒等于1.0
|
1
2
3
4
5
6
|
>>> random.random()
0.04360809434722357
>>> random.random()
0.7386566820354784
>>> random.random()
0.8564193451546396
|
-
choice()：随机返回给定序列的一个元素
|
1
2
3
4
5
6
7
8
9
10
11
12
|
>>> random.choice(
'xpleaf'
)
'l'
>>> random.choice(
'xpleaf'
)
'f'
>>> random.choice(
'xpleaf'
)
'f'
>>> random.choice([
1
,
2
,
3
])
1
>>> random.choice([
1
,
2
,
3
])
1
>>> random.choice([
1
,
2
,
3
])
3
|
