python基础:(第一章)02--内置函数_头歌第1关:学习-python字符串之内置函数应用

数学运算(7个)

1.abs：求数值的绝对值

>>> abs(-2)
2
1
2

2.divmod：返回两个数值的商和余数

>>> divmod(5,2)
(2, 1)
>> divmod(5.5,2)
(2.0, 1.5)
1
2
3
4

3.max：返回可迭代对象中的元素中的最大值或者所有参数的最大值

>>> max(1,2,3) # 传入3个参数 取3个中较大者
3
>>> max('1234') # 传入1个可迭代对象，取其最大元素值
'4'
>>> max(-1,0) # 数值默认去数值较大者
0
>>> max(-1,0,key = abs) # 传入了求绝对值函数，则参数都会进行求绝对值后再取较大者
-1
1
2
3
4
5
6
7
8

4.min：返回可迭代对象中的元素中的最小值或者所有参数的最小值

>>> min(1,2,3) # 传入3个参数 取3个中较小者
1
>>> min('1234') # 传入1个可迭代对象，取其最小元素值
'1'
>>> min(-1,-2) # 数值默认去数值较小者
-2
>>> min(-1,-2,key = abs)  # 传入了求绝对值函数，则参数都会进行求绝对值后再取较小者
-1
1
2
3
4
5
6
7
8

5.pow() 方法返回 xy（x 的 y 次方） 的值。

import math

math.pow( x, y )
内置的 pow() 方法

pow(x, y[, z])
函数是计算 x 的 y 次方，如果 z 在存在，则再对结果进行取模，其结果等效于 pow(x,y) %z。

注意：pow() 通过内置的方法直接调用，内置方法会把参数作为整型，而 math 模块则会把参数转换为 float。
1
2
3
4
5
6
7
8
9

实例：

#!/usr/bin/python
# -*- coding: UTF-8 -*-
 
import math   # 导入 math 模块
 
print "math.pow(100, 2) : ", math.pow(100, 2)
# 使用内置，查看输出结果区别
print "pow(100, 2) : ", pow(100, 2)
 
print "math.pow(100, -2) : ", math.pow(100, -2)
print "math.pow(2, 4) : ", math.pow(2, 4)
print "math.pow(3, 0) : ", math.pow(3, 0)
以上实例运行后输出结果为：

math.pow(100, 2) :  10000.0
pow(100, 2) :  10000
math.pow(100, -2) :  0.0001
math.pow(2, 4) :  16.0
math.pow(3, 0) :  1.0
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19

6.round：对浮点数进行四舍五入求值

>>> round(1.1314926,1)
1.1
>>> round(1.1314926,5)
1.13149
1
2
3
4

7.sum：对元素类型是数值的可迭代对象中的每个元素求和

# 传入可迭代对象
>>> sum( (1,2,3,4) )
10
# 元素类型必须是数值型
>>> sum( (1.5,2.5,3.5,4.5) )
12.0
>>> sum((1,2,3,4),-10)
0
1
2
3
4
5
6
7
8

类型转换(24个)

1.bool：函数用于将给定参数转换为布尔类型，如果没有参数，返回 False。

>>> bool() #未传入参数
False
>>> bool(0) #数值0、空序列等值为False
False
>>> bool(1)
True
>>> issubclass(bool, int)  # bool 是 int 子类
True
1
2
3
4
5
6
7
8

2.int：函数用于将一个字符串或数字转换为整型，不传入参数时，得到结果0

原型：class int(x, base=10)

>>>int()               # 不传入参数时，得到结果0
0
>>> int(3)
3
>>> int(3.6)
3
>>> int('12',16)        # 如果是带参数base的话，12要以字符串的形式进行输入，12 为 16进制
18
>>> int('0xa',16)  
10  
>>> int('10',8)  
8

1、若 x 为纯数字，则不能有 base 参数，否则报错；其作用为对入参 x 取整
>>> int(2.5,10)
#报错
2.若 x 为 str，则 base 可略可有。base 存在时，视 x 为 base 类型数字，并将其转换为 10 进制数字。
若 x 不符合 base 规则，则报错。
>>> int("3.14",8)
>>> int("1.2")
#均报错，str须为整数

>>>int("9",2)  #报错，因为2进制无9
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

3.float：函数用于将整数和字符串转换成浮点数。

原型：class float([x])

>>>float(1)
1.0
>>> float(112)
112.0
>>> float(-123.6)
-123.6
>>> float('123')     # 字符串
123.0
1
2
3
4
5
6
7
8
9
10

4.complex：函数用于创建一个值为 real + imag * j 的复数或者转化一个字符串或数为复数。如果第一个参数为字符串，则不需要指定第二个参数。

>>> complex() #当两个参数都不提供时，返回复数 0j。
0j
>>> complex('1+2j') #传入字符串创建复数
(1+2j)
>>> complex(1,2) #传入数值创建复数
(1+2j)

>>>complex(1, 2)
(1 + 2j)
 
>>> complex(1)    # 数字
(1 + 0j)
 
>>> complex("1")  # 当做字符串处理
(1 + 0j)
 
# 注意：这个地方在"+"号两边不能有空格，也就是不能写成"1 + 2j"，应该是"1+2j"，否则会报错
>>> complex("1+2j")
(1 + 2j)
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20

5.str：返回一个对象的字符串表现形式(给用户)

>>>s = 'RUNOOB'
>>> str(s)
'RUNOOB'
>>> dict = {'runoob': 'runoob.com', 'google': 'google.com'};
>>> str(dict)
"{'google': 'google.com', 'runoob': 'runoob.com'}"
>>>
1
2
3
4
5
6
7

6.bytearray() 方法返回一个新字节数组。这个数组里的元素是可变的，并且每个元素的值范围: 0 <= x < 256。

语法：
class bytearray([source[, encoding[, errors]]])

参数:
如果 source 为整数，则返回一个长度为 source 的初始化数组；
如果 source 为字符串，则按照指定的 encoding 将字符串转换为字节序列；
如果 source 为可迭代类型，则元素必须为[0 ,255] 中的整数；
如果 source 为与 buffer 接口一致的对象，则此对象也可以被用于初始化 bytearray。
如果没有输入任何参数，默认就是初始化数组为0个元素。

>>>bytearray()
bytearray(b'')
>>> bytearray([1,2,3])
bytearray(b'\x01\x02\x03')
>>> bytearray('runoob', 'utf-8')
bytearray(b'runoob')
>>>
>>> bytearray('中文','utf-8')
bytearray(b'\xe4\xb8\xad\xe6\x96\x87')
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19

7.bytes：

序列操作(8个)

对象操作(7个)

反射操作(8个)

变量操作(2个)

交互操作(2个)

文件操作(1个)

编译执行(4个)

装饰器(3个)