Python内置函数___答______可以返回列表元组字典集合字符串以及range对象 python内置函数返回元素个数

一、ptthon内置函数

二、内置函数详细概述

　　2.1  abs(x)：函数返回数字的绝对值。

　　　　注意：

　　　　1）x -- 数值表达式，可以是整数，浮点数，复数。

　　　　2)如果参数是一个复数，则返回它的大小。

1 >>> abs(-2)
2 2

View Code

　　2.2  all(iterable)：函数用于判断给定的可迭代参数 iterable 中的所有元素是否都为 TRUE，如果是返回 True，否则返回 False。元素除了是 0、空、None、False 外都算 True。

　　　　注意：

　　　　　　1）iterable -- 元组或列表。

　　　　　　2）元素除了是 0、空、None、False 外都算 True。

　　　　　　3）空元组、空列表返回值为True

1 >>> all(['a', 'b', 'c', 'd'])  # 列表list，元素都不为空或0
 2 True
 3 >>> all(['a', 'b', '', 'd'])   # 列表list，存在一个为空的元素
 4 False
 5 >>> all([0, 1，2, 3])          # 列表list，存在一个为0的元素
 6 False
 7    
 8 >>> all(('a', 'b', 'c', 'd'))  # 元组tuple，元素都不为空或0
 9 True
10 >>> all(('a', 'b', '', 'd'))   # 元组tuple，存在一个为空的元素
11 False
12 >>> all((0, 1, 2, 3))          # 元组tuple，存在一个为0的元素
13 False
14    
15 >>> all([])             # 空列表
16 True
17 >>> all(())             # 空元组
18 True

View Code

　　2.3  any(iterable)：函数用于判断给定的可迭代参数 iterable 是否全部为 False，则返回 False，如果有一个为 True，则返回 True。元素除了是 0、空、FALSE 外都算 TRUE

　　　　注意：

　　　　　　1）iterable -- 元组或列表。

　　　　　　2）如果都为空、0、false，则返回false，如果不都为空、0、false，则返回true。

1 >>>any(['a', 'b', 'c', 'd'])  # 列表list，元素都不为空或0
 2 True
 3  
 4 >>> any(['a', 'b', '', 'd'])   # 列表list，存在一个为空的元素
 5 True
 6  
 7 >>> any([0, '', False])        # 列表list,元素全为0,'',false
 8 False
 9  
10 >>> any(('a', 'b', 'c', 'd'))  # 元组tuple，元素都不为空或0
11 True
12  
13 >>> any(('a', 'b', '', 'd'))   # 元组tuple，存在一个为空的元素
14 True
15  
16 >>> any((0, '', False))        # 元组tuple，元素全为0,'',false
17 False
18   
19 >>> any([]) # 空列表
20 False
21  
22 >>> any(()) # 空元组
23 False

View Code

　　2.4  ascii(object) 函数类似 repr() 函数, 返回一个表示对象的字符串, 但是对于字符串中的非 ASCII 字符则返回通过 repr() 函数使用 \x, \u 或 \U 编码的字符。 

　　　　注意：

　　　　　　1）object-- 对象。

　　　　　　2）返回字符串。

1 >>> ascii('yusheng_liang')
2 "'yusheng_liang'"

View Code

　　2.5  bin(x) 返回一个整数 int 或者长整数 long int 的二进制表示。

　　　　注意：

　　　　　　1）x-- int 或者 long int 数字。

　　　　　　2）返回字符串。

1 >>>bin(10)
2 '0b1010'
3 >>> bin(20)
4 '0b10100'

View Code

　　2.6  bool(x) 函数用于将给定参数转换为布尔类型，如果没有参数，返回 False。bool 是 int 的子类。

　　　　注意：

　　　　　　1）x-- 要进行转换的参数。

　　　　　　2）返回True或False。

1 >>>bool()
 2 False
 3 >>> bool(0)
 4 False
 5 >>> bool(1)
 6 True
 7 >>> bool(2)
 8 True
 9 >>> issubclass(bool, int)  # bool 是 int 子类
10 True

View Code

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

　　　　bytearray()语法:

　　　　　class bytearray([source[, encoding[, errors]]])　

　　　　参数说明：

　　　　　1）如果 source 为整数，则返回一个长度为 source 的初始化数组；

　　　　　2）如果 source 为字符串，则按照指定的 encoding 将字符串转换为字节序列；

　　　　　3）如果 source 为可迭代类型，则元素必须为[0 ,255] 中的整数；

　　　　　4）如果 source 为与 buffer 接口一致的对象，则此对象也可以被用于初始化 bytearray。

　　　　　5）如果没有输入任何参数，默认就是初始化数组为0个元素。

1 >>>bytearray()
2 bytearray(b'')
3 >>> bytearray([1,2,3])
4 bytearray(b'\x01\x02\x03')
5 >>> bytearray('yusheng_liang', 'utf-8')
6 bytearray(b'yusheng_liang')

View Code

　　2.8  bytes 函数返回一个新的 bytes 对象，该对象是一个 0 <= x < 256 区间内的整数不可变序列。它是 bytearray 的不可变版本。

　　　　bytes()语法

　　　　　　class bytes([source[, encoding[, errors]]])

　　　　参数说明：

　　　　　1）如果 source 为整数，则返回一个长度为 source 的初始化数组；

　　　　　2）如果 source 为字符串，则按照指定的 encoding 将字符串转换为字节序列；

　　　　　3）如果 source 为可迭代类型，则元素必须为[0 ,255] 中的整数；

　　　　　4）如果 source 为与 buffer 接口一致的对象，则此对象也可以被用于初始化 bytearray。

　　　　　5）如果没有输入任何参数，默认就是初始化数组为0个元素。

1 >>>a = bytes([1,2,3,4])
 2 >>> a
 3 b'\x01\x02\x03\x04'
 4 >>> type(a)
 5 <class 'bytes'>
 6 >>>
 7 >>> a = bytes('hello','ascii')
 8 >>>
 9 >>> a
10 b'hello'
11 >>> type(a)
12 <class 'bytes'>

View Code

　　2.9  callable(object) 函数用于检查一个对象是否是可调用的。如果返回 True，object 仍然可能调用失败；但如果返回 False，调用对象 object 绝对不会成功。

　　　　注意：

　　　　　　1）object-- 对象。

　　　　　　2）可调用返回True，否则返回False

__call__ 方法的类实例, 它都返回 True。

1 >>>callable(0)
 2 False
 3 >>> callable("yusheng_liang")
 4 False
 5  
 6 >>> def add(a, b):
 7 ...     return a + b
 8 ... 
 9 >>> callable(add)             # 函数返回 True
10 True
11 >>> class A:                  # 类
12 ...     def method(self):
13 ...             return 0
14 ... 
15 >>> callable(A)               # 类返回 True
16 True
17 >>> a = A()
18 >>> callable(a)               # 没有实现 __call__, 返回 False
19 False
20 >>> class B:
21 ...     def __call__(self):
22 ...             return 0
23 ... 
24 >>> callable(B)
25 True
26 >>> b = B()
27 >>> callable(b)               # 实现 __call__, 返回 True
28 True

View Code

　　2.10  chr(i) 用一个整数作参数，返回一个对应的字符。

　　　　注意：

　　　　　　1）i-- 可以是10进制也可以是16进制的形式的数字，数字范围为0到1114111（16进制为0x0FFFF）。

　　　　　　2）返回值是当前整数对应的ASCII字符。

1 >>>chr(0x30)
2 '0'
3 >>> chr(97) 
4 'a'
5 >>> chr(8364)
6 '€'

View Code

　　2.11  classmethod 修饰符对应的函数不需要实例化，不需要 self 参数，但第一个参数需要是表示自身类的 cls 参数，可以来调用类的属性，类的方法，实例化对象等。

　　　　注意：

　　　　　　1）无参数。

　　　　　　2）返回函数的类方法。

1 class A(object):
 2     bar = 1
 3     def func1(self):  
 4         print ('foo') 
 5     @classmethod
 6     def func2(cls):
 7         print ('func2')
 8         print (cls.bar)
 9         cls().func1()   # 调用 foo 方法
10  
11 A.func2()               # 不需要实例化
12 
13 #输出结果：
14 #func2
15 #1
16 #foo

View Code

　　2.12  compile() 函数将一个字符串编译为字节代码。

　　　　compile()语法：

　　　　　　compile(source, filename, mode[, flags[, dont_inherit]])

　　　　参数说明：

　　　　　　1）source -- 字符串或者AST（Abstract Syntax Trees）对象。。

　　　　　　2）filename -- 代码文件名称，如果不是从文件读取代码则传递一些可辨认的值。

　　　　　　3）mode -- 指定编译代码的种类。可以指定为 exec, eval, single。

　　　　　　4）flags -- 变量作用域，局部命名空间，如果被提供，可以是任何映射对象。。

　　　　　　5）flags和dont_inherit是用来控制编译源码时的标志

1 >>>str = "for i in range(0,10): print(i)" 
 2 >>> c = compile(str,'','exec')   # 编译为字节代码对象 
 3 >>> c
 4 <code object <module> at 0x10141e0b0, file "", line 1>
 5 >>> exec(c)
 6 0
 7 1
 8 2
 9 3
10 4
11 5
12 6
13 7
14 8
15 9
16 >>> str = "3 * 4 + 5"
17 >>> a = compile(str,'','eval')
18 >>> eval（a)
19 17

View Code

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

　　　　compile()语法：

　　　　　　class complex([real[, imag]])

　　　　参数说明：

　　　　　　1）real--int, long, float或字符串

　　　　　　2）imag--int, long, float

　　　　　　3）返回一个复数。

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

View Code

　　2.14  delattr() 函数用于删除属性。

　　　　delattr()语法：

　　　　　　delattr(object, name)

　　　　参数说明：

　　　　　　1）object--对象。

　　　　　　2）name--删除对象的属性。

1 class Coordinate:
 2     x = 10
 3     y = -5
 4     z = 0
 5  
 6 point1 = Coordinate() 
 7  
 8 print('x = ',point1.x)
 9 print('y = ',point1.y)
10 print('z = ',point1.z)
11  
12 delattr(Coordinate, 'z')
13  
14 print('--删除 z 属性后--')
15 print('x = ',point1.x)
16 print('y = ',point1.y)

View Code

　　2.15  dict() 函数用于创建一个字典。

　　　　dict()语法：

　　　　　　class dict(**kwarg)

　　　　　　class dict(mapping, **kwarg)

　　　　　　class dict(iterable, **kwarg)

　　　　参数说明：

　　　　　　1）**kwarg--关键字

　　　　　　2）mapping--元素的容器

　　　　　　3）iterable--可迭代对象

　　　　　　4）返回值是一个字典。

1 >>>dict()                        # 创建空字典
2 {}
3 >>> dict(a='a', b='b', t='t')     # 传入关键字
4 {'a': 'a', 'b': 'b', 't': 't'}
5 >>> dict(zip(['one', 'two', 'three'], [1, 2, 3]))   # 映射函数方式来构造字典
6 {'three': 3, 'two': 2, 'one': 1} 
7 >>> dict([('one', 1), ('two', 2), ('three', 3)])    # 可迭代对象方式来构造字典
8 {'three': 3, 'two': 2, 'one': 1}
9 >>>

View Code

　　2.16 dir() 函数不带参数时，返回当前范围内的变量、方法和定义的类型列表；带参数时，返回参数的属性、方法列表。如果参数包含方法__dir__()，该方法将被调用。如果参数不包含__dir__()，该方法将最大限度地收集参数信息。

　　　　dir()语法：

　　　　　　dir([object])

　　　　参数说明：

　　　　　　1）object--对象、变量、类型

　　　　　　2）返回模块的属性列表。

1 >>>dir()   #  获得当前模块的属性列表
2 ['__builtins__', '__doc__', '__name__', '__package__', 'arr', 'myslice']
3 >>> dir([ ])    # 查看列表的方法
4 ['__add__', '__class__', '__contains__', '__delattr__', '__delitem__', '__delslice__', '__doc__', '__eq__', '__format__', '__ge__', '__getattribute__', '__getitem__', '__getslice__', '__gt__', '__hash__', '__iadd__', '__imul__', '__init__', '__iter__', '__le__', '__len__', '__lt__', '__mul__', '__ne__', '__new__', '__reduce__', '__reduce_ex__', '__repr__', '__reversed__', '__rmul__', '__setattr__', '__setitem__', '__setslice__', '__sizeof__', '__str__', '__subclasshook__', 'append', 'count', 'extend', 'index', 'insert', 'pop', 'remove', 'reverse', 'sort']

View Code

　　2.17 divmod() 函数接收两个数字类型（非复数）参数，返回一个包含商和余数的元组(a // b, a % b)。

　　　　divmod()语法：

　　　　　　divmod(a, b)

　　　　参数说明：

　　　　　　1）a--数字，非复数

　　　　　　2）b--数字，非复数

　　　　注意：

　　　　　　1）如果参数 a 与 参数 b 都是整数，函数返回的结果相当于 (a // b, a % b)。

　　　　　　2）如果其中一个参数为浮点数时，函数返回的结果相当于 (q, a % b)，q 通常是 math.floor(a / b)，但也有可能是 1 ，比小，不过 q * b + a % b 的值会非常接近 a。

　　　　　　3）如果 a % b 的求余结果不为 0 ，则余数的正负符号跟参数 b 是一样的，若 b 是正数，余数为正数，若 b 为负数，余数也为负数，并且 0 <= abs(a % b) < abs(b)。

1 >>> divmod(7, 2)
2 (3, 1)
3 >>> divmod(8, 2)
4 (4, 0)
5 >>> divmod(8, -2)
6 (-4, 0)
7 >>> divmod(3, 1.3)
8 (2.0, 0.3999999999999999)

View Code

　　2.18  enumerate() 函数用于将一个可遍历的数据对象(如列表、元组或字符串)组合为一个索引序列，同时列出数据和数据下标，一般用在 for 循环当中。

　　　　enumerate()语法：

　　　　　　enumerate(sequence, [start=0])

　　　　参数说明：

　　　　　　1）sequence--一个序列，迭代器或其他支持迭代的对象。

　　　　　　2）start--下标起始位置

　　　　　　3）返回enumerate(枚举)对象。

1 >>>seasons = ['Spring', 'Summer', 'Fall', 'Winter']
 2 >>>list(enumerate(seasons))
 3 [(0, 'Spring'), (1, 'Summer'), (2, 'Fall'), (3, 'Winter')]
 4 >>>list(enumerate(seasons, start=1))       # 小标从 1 开始
 5 [(1, 'Spring'), (2, 'Summer'), (3, 'Fall'), (4, 'Winter')]
 6 #普通的for循环
 7 >>>i = 0
 8 >>>seq = ['one', 'two', 'three']
 9 >>>for element in seq:
10 ...    print(i, seq[i])
11 ...    i += 1
12 ... 
13 0 one
14 1 two
15 2 three
16 
17 #for循环使用enumerate
18 >>>seq = ['one', 'two', 'three']
19 >>>for i, element in enumerate(seq):
20 ...    print(i, seq[i])
21 ... 
22 0 one
23 1 two
24 2 three

View Code

　　2.19   eval（) 函数用来执行一个字符串表达式，并返回表达式的值。

　　　　　　eval（)语法：

　　　　　　　　eval（expression[, globals[, locals]])

　　　　　　参数说明：　　　

　　　　　　　　1）expression -- 表达式。

　　　　　　　　2）globals -- 变量作用域，全局命名空间，如果被提供，则必须是一个字典对象。

　　　　　　　　3）locals -- 变量作用域，局部命名空间，如果被提供，可以是任何映射对象。

　　　　　　　　4）返回表达式计算结果。

1 >>>x = 7
 2 >>> eval（ '3 * x' )
 3 21
 4 >>> eval（'pow(2,2)')
 5 4
 6 >>> eval（'2 + 2')
 7 4
 8 >>> n=81
 9 >>> eval（"n + 4")
10 85

View Code

　　2.20  exec 执行储存在字符串或文件中的 Python 语句，相比于 eval，exec可以执行更复杂的 Python 代码。

　　　　　　exec()语法：

　　　　　　　　exec(object[, globals[, locals]])

　　　　　　参数说明：

　　　　　　　　1）object：必选参数，表示需要被指定的Python代码。它必须是字符串或code对象。如果object是一个字符串，该字符串会先被解析为一组Python语句，然后在执行（除非发生语法错误）。如果object是一个code对象，那么它只是被简单的执行。

　　　　　　　　2）globals：可选参数，表示全局命名空间（存放全局变量），如果被提供，则必须是一个字典对象。

　　　　　　　　3）locals：可选参数，表示当前局部命名空间（存放局部变量），如果被提供，可以是任何映射对象。如果该参数被忽略，那么它将会取与globals相同的值。

　　　　　　　　4）exec 返回值永远为 None。

1 >>>exec('print("Hello World")')
 2 Hello World
 3 # 单行语句字符串
 4 >>> exec("print ('runoob.com')")
 5 runoob.com
 6  
 7 #  多行语句字符串
 8 >>> exec ("""for i in range(5):
 9 ...     print ("iter time: %d" % i)
10 ... """)
11 iter time: 0
12 iter time: 1
13 iter time: 2
14 iter time: 3
15 iter time: 4

View Code

list() 来转换。

　　　　filter()语法：

　　　　　　filter(function, iterable) 

　　　　参数说明：

　　　　　　1）接收两个参数，第一个为函数，第二个为序列，序列的每个元素作为参数传递给函数进行判，然后返回 True 或 False，最后将返回 True 的元素放到新列表中。

　　　　　　2）function -- 判断函数。

　　　　　　3）iterable -- 可迭代对象。

　　　　　　4）返回一个迭代器对象。

1 #过滤出列表中的所有奇数
2 def is_odd(n):
3     return n % 2 == 1
4  
5 tmplist = filter(is_odd, [1, 2, 3, 4, 5, 6, 7, 8, 9, 10])
6 newlist = list(tmplist)
7 print(newlist)

View Code

　　2.22  float(x) 函数用于将整数和字符串转换成浮点数。

　　　　float(x)语法：

　　　　　　class float([x])

　　　　参数说明：

　　　　　　1）x -- 整数或字符串。

　　　　　　2）返回浮点数。

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

View Code

　　2.23  format() 字符串格式化，format 函数可以接受不限个参数，位置可以不按顺序。

{} 和 : 来代替以前的 %

　format()实例一：str.format()

1 >>>"{} {}".format("hello", "world")    # 不设置指定位置，按默认顺序
2 'hello world'
3  
4 >>> "{0} {1}".format("hello", "world")  # 设置指定位置
5 'hello world'
6  
7 >>> "{1} {0} {1}".format("hello", "world")  # 设置指定位置
8 'world hello world'

View Code

　format()实例二：设置参数

1 #!/usr/bin/python
 2 # -*- coding: UTF-8 -*-
 3  
 4 print("网站名：{name}, 地址 {url}".format(name="百度", url="www.baidu.com"))
 5  
 6 # 通过字典设置参数
 7 site = {"name": "百度", "url": "www.baidu.com"}
 8 print("网站名：{name}, 地址 {url}".format(**site))
 9  
10 # 通过列表索引设置参数
11 my_list = ['百度', 'www.baidu.com']
12 print("网站名：{0[0]}, 地址 {0[1]}".format(my_list))  # "0" 是必须的
13 
14 结果为：
15 网站名：百度, 地址 www.baidu.com
16 网站名：百度, 地址 www.baidu.com
17 网站名：百度, 地址 www.baidu.com

View Code

str.format() 传入对象

1 #!/usr/bin/python
2 # -*- coding: UTF-8 -*-
3  
4 class AssignValue(object):
5     def __init__(self, value):
6         self.value = value
7 my_value = AssignValue(6)
8 print('value 为: {0.value}'.format(my_value))  # "0" 是可选的

View Code

　format()实例四：数字格式化

1 >>> print("{:.2f}".format(3.1415926));
2 3.14

View Code

 　　2.24 frozenset() 返回一个冻结的集合，冻结后集合不能再添加或删除任何元素。

　　　　frozensetA()语法：　

class([iterable])

　　　　参数说明：

　　　　　　1）iterable -- 可迭代的对象，比如列表、字典、元组等等。

　　　　　　2）返回新的 frozenset 对象，如果不提供任何参数，默认会生成空集合。

1 >>>a = frozenset(range(10))     # 生成一个新的不可变集合
2 >>> a
3 frozenset([0, 1, 2, 3, 4, 5, 6, 7, 8, 9])
4 >>> b = frozenset('runoob') 
5 >>> b
6 frozenset(['b', 'r', 'u', 'o', 'n'])   # 创建不可变集合
7 >>>

View Code

　　2.25 getattr() 函数用于返回一个对象属性值。

　　　　getattr()语法：

getattr(object,[,default])

　　　　参数说明：

　　　　　　1）object -- 对象。

　　　　　　2）name -- 字符串，对象属性。

　　　　　　3）default -- 默认返回值，如果不提供该参数，在没有对应属性时，将触发 AttributeError。

1 >>>class A(object):
 2 ...     bar = 1
 3 ... 
 4 >>> a = A()
 5 >>> getattr(a, 'bar')        # 获取属性 bar 值
 6 1
 7 >>> getattr(a, 'bar2')       # 属性 bar2 不存在，触发异常
 8 Traceback (most recent call last):
 9   File "<stdin>", line 1, in <module>
10 AttributeError: 'A' object has no attribute 'bar2'
11 >>> getattr(a, 'bar2', 3)    # 属性 bar2 不存在，但设置了默认值
12 3
13 >>>

View Code

　　2.26 globals() 函数会以字典类型返回当前位置的全部全局变量。

1 >>> a ='yusheng'
2 >>> print(globals())   # globals 函数返回一个全局变量的字典，包括所有导入的变量。
3 {'__name__': '__main__', '__doc__': None, '__package__': None, '__loader__': <class '_frozen_importlib.BuiltinImporter'>, '__spec__': None, '__annotations__': {}, '__builtins__': <module 'builtins' (built-in)>, 'is_add': <function is_add at 0x000000000324FF28>, 'tmlist': <filter object at 0x0000000003242D30>, 'new_list': [1, 3, 5, 7, 9], 'site': {'name': 'tt', 'url': 'uu'}, 'my_list': ['uu', 'ee'], 'fu': <class '__main__.fu'>, 'my_value': <__main__.fu object at 0x0000000003257EF0>, 'a': 'yusheng'}

View Code

　　2.27 hasattr() 函数用于判断对象是否包含对应的属性。

　　　　hasattr()语法：

　　　　　　hasattr(object, name)

　　　　参数说明：

　　　　　　1）object -- 对象。

　　　　　　2）name -- 字符串，属性名。

　　　　　　3）返回值，如果对象有该属性返回 True，否则返回 False。

1 #!/usr/bin/python
 2 # -*- coding: UTF-8 -*-
 3  
 4 class test:
 5     x = 10
 6     y = -5
 7     z = 0
 8  
 9 point1 = test() 
10 print(hasattr(point1, 'x'))
11 print(hasattr(point1, 'no'))  # 没有该属性
12 
13 结果为：
14 True
15 False

View Code

　　2.28  hash() 用于获取取一个对象（字符串或者数值等）的哈希值。

　　　　hash()语法：

　　　　　　hash(object)

　　　　参数说明：

　　　　　　1）object--对象

　　　　　　2）返回值，返回对象的哈希值。

1 >>>hash('test')            # 字符串
2 2314058222102390712
3 >>> hash(1)                 # 数字
4 1
5 >>> hash(str([1,2,3]))      # 集合
6 1335416675971793195
7 >>> hash(str(sorted({'1':1}))) # 字典
8 7666464346782421378

View Code

　　2.29  help() 函数用于查看函数或模块用途的详细说明。

1 >>>help('sys')             # 查看 sys 模块的帮助
 2 ……显示帮助信息……
 3  
 4 >>>help('str')             # 查看 str 数据类型的帮助
 5 ……显示帮助信息……
 6  
 7 >>>a = [1,2,3]
 8 >>>help(a)                 # 查看列表 list 帮助信息
 9 ……显示帮助信息……
10  
11 >>>help(a.append)          # 显示list的append方法的帮助
12 ……显示帮助信息……

View Code

　　2.30  hex() 函数用于将一个指定数字转换为 16 进制数。

1 >>>hex(255)
2 '0xff'
3 >>> hex(-42)
4 '-0x2a'
5 >>> hex(12)
6 '0xc'
7 >>> type(hex(12))
8 <class 'str'>      # 字符串

View Code

　　2.31  id() 函数用于获取对象的内存地址。

1 >>>a = 'runoob'
2 >>> id(a)
3 4531887632
4 >>> b = 1
5 >>> id(b)
6 140588731085608

View Code

　　2.32   input() 函数接受一个标准输入数据，返回为 string 类型

　　注意：在 Python3.x 中 raw_input() 和 input() 进行了整合，去除了 raw_input( )，仅保留了input( )函数，其接收任意任性输入，将所有输入默认为字符串处理，并返回字符串类型。

1 >>>a = input("input:")
2 input:123                  # 输入整数
3 >>> type(a)
4 <class 'str'>              # 字符串
5 >>> a = input("input:")    
6 input:runoob              # 正确，字符串表达式
7 >>> type(a)
8 <class 'str'>             # 字符串

View Code

　　2.33  int() 函数用于将一个字符串或数字转换为整型。

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

View Code

　　2.34  isinstance() 函数来判断一个对象是否是一个已知的类型，类似 type()。

　　　　isinstance() 与 type() 区别：type() 不会认为子类是一种父类类型，不考虑继承关系。isinstance() 会认为子类是一种父类类型，考虑继承关系。如果要判断两个类型是否相同推荐使用 isinstance()。

1 >>>a = 2
2 >>> isinstance (a,int)
3 True
4 >>> isinstance (a,str)
5 False
6 >>> isinstance (a,(str,int,list))    # 是元组中的一个返回 True
7 True

View Code

　　2.35 issubclass() 方法用于判断参数 class 是否是类型参数 classinfo 的子类。

1 #!/usr/bin/python
2 # -*- coding: UTF-8 -*-
3  
4 class A:
5     pass
6 class B(A):
7     pass
8     
9 print(issubclass(B,A))    # 返回 True

View Code

　　2.36 iter() 函数用来生成迭代器。

　　　　iter()语法：

[,])

　　　　参数说明：

　　　　　　1）object -- 支持迭代的集合对象。

　　　　　　2）sentinel -- 如果传递了第二个参数，则参数 object 必须是一个可调用的对象（如，函数），此时，iter 创建了一个迭代器对象，每次调用这个迭代器对象的__next__()方法时，都会调用 object。

　　　　　　3）返回值，返回迭代器对象。

1 >>>lst = [1, 2, 3]
2 >>> for i in iter(lst):
3 ...     print(i)
4 ... 
5 1
6 2
7 3

View Code

　　2.37  len() 方法返回对象（字符、列表、元组等）长度或项目个数。

1 >>>str = "runoob"
2 >>> len(str)             # 字符串长度
3 6
4 >>> l = [1,2,3,4,5]
5 >>> len(l)               # 列表元素个数
6 5

View Code

　　2.38 list() 方法用于将元组或字符串转换为列表。

　　　　注意：元组与列表是非常类似的，区别在于元组的元素值不能修改，元组是放在括号中，列表是放于方括号中。

1 #!/usr/bin/python3
 2 
 3 aTuple = (123, 'Google', 'Runoob', 'Taobao')
 4 list1 = list(aTuple)
 5 print ("列表元素 : ", list1)
 6 
 7 str="Hello World"
 8 list2=list(str)
 9 print ("列表元素 : ", list2)
10 
11 结果为：
12 列表元素 :  [123, 'Google', 'Runoob', 'Taobao']
13 列表元素 :  ['H', 'e', 'l', 'l', 'o', ' ', 'W', 'o', 'r', 'l', 'd']

View Code

　　2.39 locals() 函数会以字典类型返回当前位置的全部局部变量。

1 >>>def runoob(arg):    # 两个局部变量：arg、z
2 ...     z = 1
3 ...     print (locals())
4 ... 
5 >>> runoob(4)
6 {'z': 1, 'arg': 4}      # 返回一个名字/值对的字典
7 >>>

View Code

　　2.40 map() 会根据提供的函数对指定序列做映射。

　　　　map()语法：

map(function,,...)

　　　　参数说明：

　　　　　　1）function -- 函数

　　　　　　2）iterable -- 一个或多个序列

1 >>>def square(x) :            # 计算平方数
 2 ...     return x ** 2
 3 ... 
 4 >>> map(square, [1,2,3,4,5])   # 计算列表各个元素的平方
 5 [1, 4, 9, 16, 25]
 6 >>> map(lambda x: x ** 2, [1, 2, 3, 4, 5])  # 使用 lambda 匿名函数
 7 [1, 4, 9, 16, 25]
 8  
 9 # 提供了两个列表，对相同位置的列表数据进行相加
10 >>> map(lambda x, y: x + y, [1, 3, 5, 7, 9], [2, 4, 6, 8, 10])
11 [3, 7, 11, 15, 19]

View Code

　　2.41  max() 方法返回给定参数的最大值，参数可以为序列。

1 #!/usr/bin/python3
2 
3 print ("max(80, 100, 1000) : ", max(80, 100, 1000))
4 print ("max(-20, 100, 400) : ", max(-20, 100, 400))
5 
6 结果为：
7 max(80, 100, 1000) :  1000
8 max(-20, 100, 400) :  400

View Code

　　2.42  memoryview() 函数返回给定参数的内存查看对象(Momory view)。

　　注意：所谓内存查看对象，是指对支持缓冲区协议的数据进行包装，在不需要复制对象基础上允许Python代码访问。

　　memoryview()在python3.x的应用

1 >>>v = memoryview(bytearray("abcefg", 'utf-8'))
2 >>> print(v[1])
3 98
4 >>> print(v[-1])
5 103
6 >>> print(v[1:4])
7 <memory at 0x10f543a08>
8 >>> print(v[1:4].tobytes())
9 b'bce'

View Code

　　2.43  min() 方法返回给定参数的最小值，参数可以为序列。

1 #!/usr/bin/python3
2 
3 print ("min(80, 100, 1000) : ", min(80, 100, 1000))
4 print ("min(-20, 100, 400) : ", min(-20, 100, 400))
5 
6 结果为：
7 min(80, 100, 1000) :  80
8 min(-20, 100, 400) :  -20

View Code

　　2.44 next() 返回迭代器的下一个项目。

　　　　next()语法：

next(iterator[,default])

　　　　参数说明：

　　　　　　1）iterator -- 可迭代对象

　　　　　　2）default -- 可选，用于设置在没有下一个元素时返回该默认值，如果不设置，又没有下一个元素则会触发 StopIteration 异常。

1 #!/usr/bin/python
 2 # -*- coding: UTF-8 -*-
 3  
 4 # 首先获得Iterator对象:
 5 it = iter([1, 2, 3, 4, 5])
 6 # 循环:
 7 while True:
 8     try:
 9         # 获得下一个值:
10         x = next(it)
11         print(x)
12     except StopIteration:
13         # 遇到StopIteration就退出循环
14         break
15 
16 结果为：
17 1
18 2
19 3
20 4
21 5

View Code

　　2.45 oct() 函数将一个整数转换成8进制字符串

1 >>>oct(10)
2 '012'
3 >>> oct(20)
4 '024'
5 >>> oct(15)
6 '017'
7 >>>

View Code

　　2.46  open() 函数用于打开一个文件，并返回文件对象，在对文件进行处理过程都需要使用到这个函数，如果该文件无法被打开，会抛出 OSError。

　　　　注意：使用 open() 函数一定要保证关闭文件对象，即调用 close() 函数。

　　　　open()语法：

open(file,='r',=-1,=None,=None,=None,=True,=None)

　　　　参数说明：

　　　　　　1）file: 必需，文件路径（相对或者绝对路径）。

　　　　　　2）mode: 可选，文件打开模式

　　　　　　3）buffering: 设置缓冲

　　　　　　4）encoding: 一般使用utf8

　　　　　　5）errors: 报错级别

　　　　　　6）newline: 区分换行符

　　　　　　7）closefd: 传入的file参数类型

　　　　　　8）opener:

1 >>>f = open('test.txt')
2 >>> f.read()
3 'RUNOOB1\nRUNOOB2\n'

View Code

　　2.47 ord() 函数是 chr() 函数（对于 8 位的 ASCII 字符串）的配对函数，它以一个字符串（Unicode 字符）作为参数，返回对应的 ASCII 数值，或者 Unicode 数值。

1 >>>ord('a')
2 97
3 >>> ord('€')
4 8364
5 >>>

View Code

　　2.48  pow() 方法返回 x^y（x的y次方） 的值。

1 >>> pow(100,2)
2 10000
3 >>> pow(-110,2)
4 12100
5 >>> pow(100,-2)
6 0.0001
7 >>>

View Code

　　2.49 print() 方法用于打印输出，最常见的一个函数。

1 >>> print('my name is yusheng_liang')
2 my name is yusheng_liang
3 >>> print(123)
4 123
5 >>>

View Code

　　2.50 property() 函数的作用是在新式类中返回属性值。

 

　　2.51  Python3 range() 函数返回的是一个可迭代对象（类型是对象），而不是列表类型， 所以打印的时候不会打印列表。

　　　　range()语法：

range(stop)

　　　　　　range(start,[,])

　　　　参数说明：　　　　　　

　　　　　　1）start: 计数从 start 开始。默认是从 0 开始。例如range（5）等价于range（0， 5）;

　　　　　　2）stop: 计数到 stop 结束，但不包括 stop。例如：range（0， 5） 是[0, 1, 2, 3, 4]没有5

　　　　　　3）step：步长，默认为1。例如：range（0， 5） 等价于 range(0, 5, 1)

 

　　range()实例一：

1 >>>range(5)
 2 range(0, 5)
 3 >>> for i in range(5):
 4 ...     print(i)
 5 ... 
 6 0
 7 1
 8 2
 9 3
10 4
11 >>> list(range(5))
12 [0, 1, 2, 3, 4]
13 >>> list(range(0))
14 []
15 >>>

View Code

　　range()实例二：有两个参数或三个参数的情况

1 >>>list(range(0, 30, 5))
2 [0, 5, 10, 15, 20, 25]
3 >>> list(range(0, 10, 2))
4 [0, 2, 4, 6, 8]
5 >>> list(range(0, -10, -1))
6 [0, -1, -2, -3, -4, -5, -6, -7, -8, -9]
7 >>> list(range(1, 0))
8 []
9 >>>

View Code

 　　2.52  repr() 函数将对象转化为供解释器读取的形式。

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

View Code

　　2.53 reversed 函数返回一个反转的迭代器。

1 #!/usr/bin/env python3
 2  
 3 # 字符串
 4 seqString = 'Runoob'
 5 print(list(reversed(seqString)))
 6  
 7 # 元组
 8 seqTuple = ('R', 'u', 'n', 'o', 'o', 'b')
 9 print(list(reversed(seqTuple)))
10  
11 # range
12 seqRange = range(5, 9)
13 print(list(reversed(seqRange)))
14  
15 # 列表
16 seqList = [1, 2, 4, 3, 5]
17 print(list(reversed(seqList)))
18 
19 结果为：
20 ['b', 'o', 'o', 'n', 'u', 'R']
21 ['b', 'o', 'o', 'n', 'u', 'R']
22 [8, 7, 6, 5]
23 [5, 3, 4, 2, 1]

View Code

　　2.54 round() 方法返回浮点数x的四舍五入值。

　　　　round()语法：

round([,])

　　　　参数说明：

　　　　　　1）x -- 数字表达式。

　　　　　　2）n -- 表示从小数点位数，其中 x 需要四舍五入，默认值为 0。

1 print ("round(56.659,1) : ", round(56.659,1))
2 print ("round(80.264, 2) : ", round(80.264, 2))
3 
4 结果为：
5 round(56.659,1) :  56.7
6 round(80.264, 2) :  80.26

View Code

　　2.55  set()函数创建一个无序不重复元素集，可进行关系测试，删除重复数据，还可以计算交集、差集、并集等。

1 >>>x = set('runoob')
 2 >>> y = set('google')
 3 >>> x, y
 4 (set(['b', 'r', 'u', 'o', 'n']), set(['e', 'o', 'g', 'l']))   # 重复的被删除
 5 >>> x & y         # 交集
 6 set(['o'])
 7 >>> x | y         # 并集
 8 set(['b', 'e', 'g', 'l', 'o', 'n', 'r', 'u'])
 9 >>> x - y         # 差集
10 set(['r', 'b', 'u', 'n'])

View Code

　　2.56 setattr() 函数对应函数 getattr()，用于设置属性值，该属性不一定是存在的。

1 >>>class A(object):
2 ...     bar = 1
3 ... 
4 >>> a = A()
5 >>> getattr(a, 'bar')          # 获取属性 bar 值
6 1
7 >>> setattr(a, 'bar', 5)       # 设置属性 bar 值
8 >>> a.bar
9 5

View Code

　　2.57 slice() 函数实现切片对象，主要用在切片操作函数里的参数传递。

 

　　2.58 sorted() 函数对所有可迭代的对象进行排序操作。

1 >>>sorted([5, 2, 3, 1, 4])
2 [1, 2, 3, 4, 5]                      # 默认为升序

View Code

　　2.59   staticmethod 返回函数的静态方法。

 

　　2.60  str() 函数将对象转化为适于人阅读的形式。

 

　　2.61 sum() 方法对系列进行求和计算。

1 >>>sum([0,1,2])  
2 3  
3 >>> sum((2, 3, 4), 1)        # 元组计算总和后再加 1
4 10
5 >>> sum([0,1,2,3,4], 2)      # 列表计算总和后再加 2
6 12

View Code

　　2.62 super() 函数是用于调用父类(超类)的一个方法。

　　　　注意：super 是用来解决多重继承问题的，直接用类名调用父类方法在使用单继承的时候没问题，但是如果使用多继承，会涉及到查找顺序（MRO）、重复调用（钻石继承）等种种问题。

　　　　MRO 就是类的方法解析顺序表, 其实也就是继承父类方法时的顺序表。

python 3.x实例：

1 class A:
2      def add(self, x):
3          y = x+1
4          print(y)
5 class B(A):
6     def add(self, x):
7         super().add(x)
8 b = B()
9 b.add(2)  # 3

View Code

　　2.63 tuple 函数将列表转换为元组。

 

　　2.64 type() 函数如果你只有第一个参数则返回对象的类型，三个参数返回新的类型对象。

1 # 一个参数实例
 2 >>> type(1)
 3 <type 'int'>
 4 >>> type('runoob')
 5 <type 'str'>
 6 >>> type([2])
 7 <type 'list'>
 8 >>> type({0:'zero'})
 9 <type 'dict'>
10 >>> x = 1          
11 >>> type( x ) == int    # 判断类型是否相等
12 True
13  
14 # 三个参数
15 >>> class X(object):
16 ...     a = 1
17 ...
18 >>> X = type('X', (object,), dict(a=1))  # 产生一个新的类型 X
19 >>> X
20 <class '__main__.X'>

View Code

　　2.65 vars() 函数返回对象object的属性和属性值的字典对象。

1 >>>print(vars())
 2 {'__builtins__': <module '__builtin__' (built-in)>, '__name__': '__main__', '__doc__': None, '__package__': None}
 3 >>> class yy:
 4 ...     a = 1
 5 ... 
 6 >>> print(vars(yy))
 7 {'a': 1, '__module__': '__main__', '__doc__': None}
 8 >>> run = yy()
 9 >>> print(vars(yy))
10 {}

View Code

　　2.66 zip() 函数用于将可迭代的对象作为参数，将对象中对应的元素打包成一个个元组，然后返回由这些元组组成的对象，这样做的好处是节约了不少的内存。

 

　　2.67  __import__() 函数用于动态加载类和函数 。