Python内置函数
 
Python abs()函数
Python all() 函数
Python any() 函数
Python basestring() 函数
Python bin() 函数
Python bool() 函数
Python bytearray() 函数
Python callable() 函数
Python chr() 函数
Python classmethod 修饰符
Python cmp() 函数
Python compile() 函数
Python complex() 函数
Python delattr() 函数
Python dict() 函数
Python dir() 函数
Python divmod() 函数
Python enumerate() 函数
Python eval() 函数
Python execfile() 函数
Python file() 函数
Python filter() 函数
Python float() 函数
Python format 格式化函数
Python frozenset() 函数
Python getattr() 函数
Python globals() 函数
Python hasattr() 函数
Python hash() 函数
Python hash() 函数
Python hex() 函数
Python id() 函数
Python3 input() 函数
Python int() 函数
Python issubclass() 函数
Python iter() 函数
Python len()方法
Python List list()方法
Python locals() 函数
Python long() 函数
Python map() 函数
Python max() 函数
Python min() 函数
Python next() 函数
Python object()函数
Python oct() 函数
Python open() 函数
Python ord() 函数
Python pow() 函数
Python print() 函数
Python property() 函数
Python range() 函数用法
Python raw_input() 函数
Python reduce() 函数
Python reload() 函数
Python repr() 函数
Python List reverse()方法
Python round() 函数
Python set() 函数
Python setattr() 函数
Python slice() 函数
Python sorted() 函数
Python staticmethod() 函数
Python str() 函数
Python sum() 函数
Python super() 函数
Python Tuple(元组) tuple()方法
Python type() 函数
Python unichr() 函数
Python unicode() 函数
Python vars() 函数
Python xrange() 函数
Python3 zip() 函数
Python __import__() 函数
Python exec 内置语句

 
Python abs()函数
 
描述：
 abs() 函数返回数字的绝对值。
 
abs() 方法的语法:
 abs( x )
 
参数：
 
 
 
x – 数值表达式。
 
 
返回值：
 函数返回x（数字）的绝对值。
 
实例：
 
print "abs(-45) : ", abs(-45)
print "abs(100.12) : ", abs(100.12)
print "abs(119L) : ", abs(119L)
 
输出结果：
 
abs(-45) :  45
abs(100.12) :  100.12
abs(119L) :  119
 
Python all() 函数
 
描述：
 all() 函数用于判断给定的可迭代参数 iterable 中的所有元素是否都为 True，如果是返回 True，否则返回 False。
 元素除了是 0、空、None、False 外都算 True。
 
以下是 all() 方法的语法:
 all(iterable)
 
参数：
 
 
 
iterable – 元组或列表。
 
 
返回值：
 如果iterable的所有元素不为0、’’、False或者iterable为空，all(iterable)返回True，否则返回False；
 注意：空元组、空列表返回值为True，这里要特别注意。
 
all(['a', 'b', 'c', 'd'])  # 列表list，元素都不为空或0

True

all(['a', 'b', '', 'd'])   # 列表list，存在一个为空的元素

False

all([0, 1，2, 3])          # 列表list，存在一个为0的元素

False  

all(('a', 'b', 'c', 'd'))  # 元组tuple，元素都不为空或0

True

all(('a', 'b', '', 'd'))   # 元组tuple，存在一个为空的元素

False

all((0, 1, 2, 3))          # 元组tuple，存在一个为0的元素

False  

all([])             # 空列表

True

all(())             # 空元组

True
 
Python any() 函数
 
描述：
 any() 函数用于判断给定的可迭代参数 iterable 是否全部为 False，则返回 False，如果有一个为 True，则返回 True。
 元素除了是 0、空、False 外都算 True。
 
any() 方法的语法:
 any(iterable)
 
参数：
 
 
 
iterable – 元组或列表。
 
 
返回值：
 如果都为空、0、false，则返回false，如果不都为空、0、false，则返回true。
 
实例：
 
any(['a', 'b', 'c', 'd'])  # 列表list，元素都不为空或0
True
 
any(['a', 'b', '', 'd'])   # 列表list，存在一个为空的元素
True
 
any([0, '', False])        # 列表list,元素全为0,'',false
False
 
any(('a', 'b', 'c', 'd'))  # 元组tuple，元素都不为空或0
True
 
any(('a', 'b', '', 'd'))   # 元组tuple，存在一个为空的元素
True
 
any((0, '', False))        # 元组tuple，元素全为0,'',false
False
  
any([]) # 空列表
False
 
any(()) # 空元组
False
 
Python basestring() 函数
 
描述：
 basestring() 方法是 str 和 unicode 的超类（父类），也是抽象类，因此不能被调用和实例化，但可以被用来判断一个对象是否为 str 或者 unicode 的实例，isinstance(obj, basestring) 等价于 isinstance(obj, (str, unicode))。
 
basestring() 方法的语法:
 basestring()
 
参数：
 无
 
返回值：
 无
 
实例：
 
isinstance("Hello world", str)
True

isinstance("Hello world", basestring)
True
 
Python bin() 函数
 
描述：
 bin() 返回一个整数 int 或者长整数 long int 的二进制表示。
 
bin() 方法的语法:
 bin(x)
 
参数：
 
 
 
x – int 或者 long int 数字
 
 
返回值：
 字符串
 
实例：
 
bin(10)
'0b1010'
bin(20)
'0b10100'
 
Python bool() 函数
 
描述：
 
bool() 函数用于将给定参数转换为布尔类型，如果没有参数，返回 False。
 bool 是 int 的子类。
 
bool() 方法的语法:
 class bool([x])
 
参数：
 
 
 
x – 要进行转换的参数。
 
 
返回值：
 返回 Ture 或 False。
 
实例：
 
bool()
False

bool(0)
False

bool(1)
True

bool(2)
True

issubclass(bool, int)  # bool 是 int 子类
True
 
Python bytearray() 函数
 
描述：
 bytearray() 方法返回一个新字节数组。这个数组里的元素是可变的，并且每个元素的值范围: 0 <= x < 256。
 
bytearray()方法语法：
 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')
>>>
 
Python callable() 函数
 
描述：
 callable() 函数用于检查一个对象是否是可调用的。如果返回 True，object 仍然可能调用失败；但如果返回 False，调用对象 object 绝对不会成功。
 对于函数、方法、lambda 函式、 类以及实现了 call 方法的类实例, 它都返回 True。
 
callable()方法语法：
 callable(object)
 
参数：
 object – 对象
 
返回值：
 可调用返回 True，否则返回 False。
 
实例：
 
>>>callable(0)
False
>>> callable("runoob")
False
 
>>> def add(a, b):
...     return a + b
... 
>>> callable(add)             # 函数返回 True
True
>>> class A:                  # 类
...     def method(self):
...             return 0
... 
>>> callable(A)               # 类返回 True
True
>>> a = A()
>>> callable(a)               # 没有实现 __call__, 返回 False
False
>>> class B:
...     def __call__(self):
...             return 0
... 
>>> callable(B)
True
>>> b = B()
>>> callable(b)               # 实现 __call__, 返回 True
True
 
Python chr() 函数
 
描述：
 chr() 用一个范围在 range（256）内的（就是0～255）整数作参数，返回一个对应的字符。
 
chr() 方法的语法:
 chr(i)
 
参数:
 
 
 
i – 可以是10进制也可以是16进制的形式的数字。
 
 
返回值:
 返回值是当前整数对应的 ASCII 字符。
 
实例:
 
>>>print chr(0x30), chr(0x31), chr(0x61)   # 十六进制
0 1 a
>>> print chr(48), chr(49), chr(97)         # 十进制
0 1 a
 
Python classmethod 修饰符
 
描述:
 classmethod 修饰符对应的函数不需要实例化，不需要 self 参数，但第一个参数需要是表示自身类的 cls 参数，可以来调用类的属性，类的方法，实例化对象等。
 
classmethod 语法：
 classmethod
 
参数:
 无。
 
返回值:
 返回函数的类方法。
 
实例:
 class A(object):
 bar = 1
 def func1(self):
 print (‘foo’)
 @classmethod
 def func2(cls):
 print (‘func2’)
 print (cls.bar)
 cls().func1() # 调用 foo 方法
 
A.func2()               # 不需要实例化
 
输出结果为：
 
func2
1
foo
 
Python cmp() 函数
 
描述:
 cmp(x,y) 函数用于比较2个对象，如果 x < y 返回 -1, 如果 x == y 返回 0, 如果 x > y 返回 1。
 
cmp() 方法的语法:
 cmp( x, y )
 
参数:
 
 
 
x – 数值表达式。
 y – 数值表达式。
 
 
返回值
 如果 x < y 返回 -1, 如果 x == y 返回 0, 如果 x > y 返回 1。
 
以下展示了使用 cmp() 方法的实例：
 
print "cmp(80, 100) : ", cmp(80, 100)
print "cmp(180, 100) : ", cmp(180, 100)
print "cmp(-80, 100) : ", cmp(-80, 100)
print "cmp(80, -100) : ", cmp(80, -100)
 
以上实例运行后输出结果为：
 
cmp(80, 100) :  -1
cmp(180, 100) :  1
cmp(-80, 100) :  -1
cmp(80, -100) :  1
 
Python 3.X 的版本中已经没有 cmp 函数，如果你需要实现比较功能，需要引入 operator 模块，适合任何对象，包含的方法有：
 
operator.lt(a, b)
 operator.le(a, b)
 operator.eq(a, b)
 operator.ne(a, b)
 operator.ge(a, b)
 operator.gt(a, b)
 operator.lt(a, b)
 operator.le(a, b)
 operator.eq(a, b)
 operator.ne(a, b)
 operator.ge(a, b)
 operator.gt(a, b)
 实例
 
import operator
operator.eq('hello', 'name');
operator.eq('hello', 'hello');
 
结果：
 
False
True
 
Python compile() 函数
 
描述:
 compile() 函数将一个字符串编译为字节代码。
 
compile() 方法的语法:
 compile(source, filename, mode[, flags[, dont_inherit]])
 
参数:
 
 
 
source – 字符串或者AST（Abstract Syntax Trees）对象。。
 filename – 代码文件名称，如果不是从文件读取代码则传递一些可辨认的值。
 mode – 指定编译代码的种类。可以指定为 exec, eval, single。
 flags – 变量作用域，局部命名空间，如果被提供，可以是任何映射对象。。
 flags和dont_inherit是用来控制编译源码时的标志
 
 
返回值
 返回表达式执行结果。
 
以下展示了使用 compile 函数的实例：
 
>>>str = "for i in range(0,10): print(i)" 
>>> c = compile(str,'','exec')   # 编译为字节代码对象 
>>> c
<code object <module> at 0x10141e0b0, file "", line 1>
>>> exec(c)
0
1
2
3
4
5
6
7
8
9
>>> str = "3 * 4 + 5"
>>> a = compile(str,'','eval')
>>> eval(a)
17
 
Python complex() 函数
 
描述
 
complex() 函数用于创建一个值为 real + imag * j 的复数或者转化一个字符串或数为复数。如果第一个参数为字符串，则不需要指定第二个参数。。
 
complex 语法：
 class complex([real[, imag]])
 
参数说明：
 
 
 
real – int, long, float或字符串；
 imag – int, long, float；
 
 
返回值
 返回一个复数。
 
以下实例展示了 complex 的使用方法：
 
>>>complex(1, 2)
(1 + 2j)
 
>>> complex(1)    # 数字
(1 + 0j)
 
>>> complex("1")  # 当做字符串处理
(1 + 0j)
 
# 注意：这个地方在"+"号两边不能有空格，也就是不能写成"1 + 2j"，应该是"1+2j"，否则会报错
>>> complex("1+2j")
(1 + 2j)
 
Python delattr() 函数
 
描述:
 
delattr 函数用于删除属性。
 delattr(x, ‘foobar’) 相等于 del x.foobar。
 
delattr 语法：
 delattr(object, name)
 
参数：
 
 
 
object – 对象。
 name – 必须是对象的属性。
 
 
返回值：
 无。
 
以下实例展示了 delattr 的使用方法：
 
#!/usr/bin/python
# -*- coding: UTF-8 -*-
 
class Coordinate:
    x = 10
    y = -5
    z = 0
 
point1 = Coordinate() 
 
print('x = ',point1.x)
print('y = ',point1.y)
print('z = ',point1.z)
 
delattr(Coordinate, 'z')
 
print('--删除 z 属性后--')
print('x = ',point1.x)
print('y = ',point1.y)
 
# 触发错误
print('z = ',point1.z)

输出结果：

('x = ', 10)
('y = ', -5)
('z = ', 0)
--删除 z 属性后--
('x = ', 10)
('y = ', -5)
Traceback (most recent call last):
  File "test.py", line 22, in <module>
    print('z = ',point1.z)
AttributeError: Coordinate instance has no attribute 'z'
 
Python dict() 函数
 
描述:
 dict() 函数用于创建一个字典。
 
dict 语法：
 class dict(**kwarg)
 class dict(mapping, **kwarg)
 class dict(iterable, **kwarg)
 
参数说明：
 
 
 
**kwargs – 关键字
 mapping – 元素的容器。
 iterable – 可迭代对象。
 
 
返回值:
 返回一个字典。
 
以下实例展示了 dict 的使用方法：
 
>>>dict()                        # 创建空字典
{}
>>> dict(a='a', b='b', t='t')     # 传入关键字
{'a': 'a', 'b': 'b', 't': 't'}
>>> dict(zip(['one', 'two', 'three'], [1, 2, 3]))   # 映射函数方式来构造字典
{'three': 3, 'two': 2, 'one': 1} 
>>> dict([('one', 1), ('two', 2), ('three', 3)])    # 可迭代对象方式来构造字典
{'three': 3, 'two': 2, 'one': 1}
>>>
 
Python dir() 函数
 
描述:
 dir() 函数不带参数时，返回当前范围内的变量、方法和定义的类型列表；带参数时，返回参数的属性、方法列表。如果参数包含方法__dir__()，该方法将被调用。如果参数不包含__dir__()，该方法将最大限度地收集参数信息。
 
dir 语法：
 dir([object])
 
参数说明：
 
 
 
object – 对象、变量、类型。
 
 
返回值:
 返回模块的属性列表。
 
以下实例展示了 dir 的使用方法：
 
>>>dir()   #  获得当前模块的属性列表
['__builtins__', '__doc__', '__name__', '__package__', 'arr', 'myslice']
>>> dir([ ])    # 查看列表的方法
['__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']
>>>
 
Python divmod() 函数
 
描述：
 python divmod() 函数把除数和余数运算结果结合起来，返回一个包含商和余数的元组(a // b, a % b)。
 
函数语法:
 divmod(a, b)
 Python divmod() 函数
 
Python 内置函数 Python 内置函数
 
python divmod() 函数把除数和余数运算结果结合起来，返回一个包含商和余数的元组(a // b, a % b)。
 
在 python 2.3 版本之前不允许处理复数。
 函数语法
 
divmod(a, b)
 
参数说明：
 
 
 
a: 数字
 b: 数字
 
 
实例
 
>>>divmod(7, 2)
(3, 1)
>>> divmod(8, 2)
(4, 0)
>>> divmod(1+2j,1+0.5j)
((1+0j), 1.5j)
 
Python enumerate() 函数
 
描述:
 enumerate() 函数用于将一个可遍历的数据对象(如列表、元组或字符串)组合为一个索引序列，同时列出数据和数据下标，一般用在 for 循环当中。
 
enumerate() 方法的语法:
 enumerate(sequence, [start=0])
 
参数:
 
 
 
sequence – 一个序列、迭代器或其他支持迭代对象。
 start – 下标起始位置。
 
 
返回值:
 返回 enumerate(枚举) 对象。
 
以下展示了使用 enumerate() 方法的实例：
 
>>>seasons = ['Spring', 'Summer', 'Fall', 'Winter']
>>> list(enumerate(seasons))
[(0, 'Spring'), (1, 'Summer'), (2, 'Fall'), (3, 'Winter')]
>>> list(enumerate(seasons, start=1))       # 下标从 1 开始
[(1, 'Spring'), (2, 'Summer'), (3, 'Fall'), (4, 'Winter')]
 
普通的 for 循环
 
>>>i = 0
>>> seq = ['one', 'two', 'three']
>>> for element in seq:
...     print i, seq[i]
...     i +=1
... 
0 one
1 two
2 three
 
for 循环使用 enumerate
 
>>>seq = ['one', 'two', 'three']
>>> for i, element in enumerate(seq):
...     print i, element
... 
0 one
1 two
2 three
 
Python eval() 函数
 
描述:
 eval() 函数用来执行一个字符串表达式，并返回表达式的值。
 
eval() 方法的语法:
 eval(expression[, globals[, locals]])
 
参数:
 
 
 
expression – 表达式。
 globals – 变量作用域，全局命名空间，如果被提供，则必须是一个字典对象。
 locals – 变量作用域，局部命名空间，如果被提供，可以是任何映射对象。
 
 
返回值:
 返回表达式计算结果。
 
以下展示了使用 eval() 方法的实例：
 
>>>x = 7
>>> eval( '3 * x' )
21
>>> eval('pow(2,2)')
4
>>> eval('2 + 2')
4
>>> n=81
>>> eval("n + 4")
85
 
Python execfile() 函数
 
描述：
 
execfile() 函数可以用来执行一个文件。
 
execfile() 方法的语法:
 execfile(filename[, globals[, locals]])
 
参数
 
 
 
filename – 文件名。
 globals – 变量作用域，全局命名空间，如果被提供，则必须是一个字典对象。
 locals – 变量作用域，局部命名空间，如果被提供，可以是任何映射对象。
 
 
返回值
 返回表达式执行结果。
 
以下展示了使用 execfile 函数的实例：
 
假设文件 hello.py，内容如下：
 
print('runoob');
 
execfile 调用该文件
 
>>>execfile('hello.py')
runoob
 
Python file() 函数
 
描述
 file() 函数用于创建一个 file 对象，它有一个别名叫 open()，更形象一些，它们是内置函数。参数是以字符串的形式传递的。
 更多文件操作可参考：Python 文件I/O。
 
file() 方法的语法:
 file(name[, mode[, buffering]])
 
参数
 
 
 
name – 文件名
 mode – 打开模式
 buffering – 0 表示不缓冲,如果为 1 表示进行行缓冲，大于 1 为缓冲区大小。
 
 
返回值
 文件对象。
 实例
 
测试文件 test.txt，内容如下：
 
RUNOOB1
RUNOOB2

>>>f = file('test.txt')
>>> f.read()
'RUNOOB1\nRUNOOB2\n'
 
Python filter() 函数
 
描述
 filter() 函数用于过滤序列，过滤掉不符合条件的元素，返回由符合条件元素组成的新列表。
 该接收两个参数，第一个为函数，第二个为序列，序列的每个元素作为参数传递给函数进行判，然后返回 True 或 False，最后将返回 True 的元素放到新列表中。
 
注意: Pyhton2.7 返回列表，Python3.x 返回迭代器对象，具体内容可以查看：Python3 filter() 函数
 
filter() 方法的语法:
 filter(function, iterable)
 
参数
 
 
 
function – 判断函数。
 iterable – 可迭代对象。
 
 
返回值
 返回列表。
 
以下展示了使用 filter 函数的实例：
 过滤出列表中的所有奇数：
 
def is_odd(n):
    return n % 2 == 1
 
newlist = filter(is_odd, [1, 2, 3, 4, 5, 6, 7, 8, 9, 10])
print(newlist)
 
输出结果 ：
 
[1, 3, 5, 7, 9]
 
过滤出1~100中平方根是整数的数：
 
import math
def is_sqr(x):
    return math.sqrt(x) % 1 == 0
 
newlist = filter(is_sqr, range(1, 101))
print(newlist)
 
输出结果 ：
 
[1, 4, 9, 16, 25, 36, 49, 64, 81, 100]
 
Python float() 函数
 
描述
 float() 函数用于将整数和字符串转换成浮点数。
 
float()方法语法：
 class float([x])
 
参数
 
 
 
x – 整数或字符串
 
 
返回值
 返回浮点数。
 
以下实例展示了 float() 的使用方法：
 
>>>float(1)
1.0
>>> float(112)
112.0
>>> float(-123.6)
-123.6
>>> float('123')     # 字符串
123.0
 
Python format 格式化函数
 
以下实例展示了format（）的使用方法：
 
"{} {}".format("hello", "world")    # 不设置指定位置，按默认顺序
"{0} {1}".format("hello", "world")  # 设置指定位置
"{1} {0} {1}".format("hello", "world")  # 设置指定位置
 
输出结果：
 
'hello world'
'hello world'
'world hello world'
 
Python frozenset() 函数
 
描述
 
frozenset() 返回一个冻结的集合，冻结后集合不能再添加或删除任何元素。
 
frozenset() 函数语法：
 
class frozenset([iterable])
 
参数
 
 
 
iterable – 可迭代的对象，比如列表、字典、元组等等。
 
 
返回值
 
返回新的 frozenset 对象，如果不提供任何参数，默认会生成空集合。
 
以下实例展示了 frozenset() 的使用方法：
 
>>>a = frozenset(range(10))     # 生成一个新的不可变集合
>>> a
frozenset([0, 1, 2, 3, 4, 5, 6, 7, 8, 9])
>>> b = frozenset('runoob') 
>>> b
frozenset(['b', 'r', 'u', 'o', 'n'])   # 创建不可变集合
>>>
 
Python getattr() 函数
 
描述
 getattr() 函数用于返回一个对象属性值。
 
getattr 语法：
 
getattr(object, name[, default])
 
参数
 
 
 
object – 对象。
 name – 字符串，对象属性。
 default – 默认返回值，如果不提供该参数，在没有对应属性时，将触发 AttributeError。
 返回值
 返回对象属性值。
 
 
以下实例展示了 getattr 的使用方法：
 
>>>class A(object):
...     bar = 1
... 
>>> a = A()
>>> getattr(a, 'bar')        # 获取属性 bar 值
1
>>> getattr(a, 'bar2')       # 属性 bar2 不存在，触发异常
Traceback (most recent call last):
  File "<stdin>", line 1, in <module>
AttributeError: 'A' object has no attribute 'bar2'
>>> getattr(a, 'bar2', 3)    # 属性 bar2 不存在，但设置了默认值
3
>>>
 
Python globals() 函数
 
描述
 
globals() 函数会以字典类型返回当前位置的全部全局变量。
 
globals() 函数语法：
 
globals()
 
参数
 
无
 
返回值
 
返回全局变量的字典。
 
以下实例展示了 globals() 的使用方法：
 
>>>a='runoob'
>>> print(globals()) # globals 函数返回一个全局变量的字典，包括所有导入的变量。
{'__builtins__': <module '__builtin__' (built-in)>, '__name__': '__main__', '__doc__': None, 'a': 'runoob', '__package__': None}
 
Python hasattr() 函数
 
描述
 
hasattr() 函数用于判断对象是否包含对应的属性。
 
hasattr 语法：
 
hasattr(object, name)
 
参数
 
 
 
object – 对象。
 name – 字符串，属性名。
 返回值
 如果对象有该属性返回 True，否则返回 False。
 
 
以下实例展示了 hasattr 的使用方法：
 
#!/usr/bin/python
# -*- coding: UTF-8 -*-
 
class Coordinate:
    x = 10
    y = -5
    z = 0
 
point1 = Coordinate() 
print(hasattr(point1, 'x'))
print(hasattr(point1, 'y'))
print(hasattr(point1, 'z'))
print(hasattr(point1, 'no'))  # 没有该属性
 
输出结果：
 
True
True
True
False
 
Python hash() 函数
 
描述
 
hash() 用于获取取一个对象（字符串或者数值等）的哈希值。
 
hash 语法：
 
hash(object)
 
参数说明：
 
 
 
object – 对象；
 返回值
 返回对象的哈希值。
 
 
以下实例展示了 hash 的使用方法：
 
>>>hash('test')            # 字符串
2314058222102390712
>>> hash(1)                 # 数字
1
>>> hash(str([1,2,3]))      # 集合
1335416675971793195
>>> hash(str(sorted({'1':1}))) # 字典
7666464346782421378
>>>
 
Python hash() 函数
 
描述
 hash() 用于获取取一个对象（字符串或者数值等）的哈希值。
 
hash 语法：
 
hash(object)
 
参数说明：
 
 
 
object – 对象；
 返回值
 返回对象的哈希值。
 
 
以下实例展示了 hash 的使用方法：
 
>>>hash('test')            # 字符串
2314058222102390712
>>> hash(1)                 # 数字
1
>>> hash(str([1,2,3]))      # 集合
1335416675971793195
>>> hash(str(sorted({'1':1}))) # 字典
7666464346782421378
>>>
 
Python hex() 函数
 
描述
 
hex() 函数用于将10进制整数转换成16进制，以字符串形式表示。
 
hex 语法：
 
hex(x)
 
参数说明：
 
 
 
x – 10进制整数
 返回值
 返回16进制数，以字符串形式表示。
 
 
以下实例展示了 hex 的使用方法：
 
>>>hex(255)
'0xff'
>>> hex(-42)
'-0x2a'
>>> hex(1L)
'0x1L'
>>> hex(12)
'0xc'
>>> type(hex(12))
<class 'str'>      # 字符串
 
Python id() 函数
 
描述
 
id() 函数用于获取对象的内存地址。
 
id 语法：
 
id([object])
 
参数说明：
 
 
 
object – 对象。
 返回值
 返回对象的内存地址。
 
 
以下实例展示了 id 的使用方法：
 
>>>a = 'runoob'
>>> id(a)
4531887632
>>> b = 1
>>> id(b)
140588731085608
 
Python3 input() 函数
 
Python3.x 中 input() 函数接受一个标准输入数据，返回为 string 类型。
 注意：在 Python3.x 中 raw_input() 和 input() 进行了整合，去除了 raw_input( )，仅保留了input( )函数，其接收任意任性输入，将所有输入默认为字符串处理，并返回字符串类型。
 
函数语法
 
input([prompt])
 
参数说明：
 
 
 
prompt: 提示信息
 
 
input() 需要输入 python 表达式
 
>>>a = input("input:")
input:123                  # 输入整数
>>> type(a)
<class 'str'>              # 字符串
>>> a = input("input:")    
input:runoob              # 正确，字符串表达式
>>> type(a)
<class 'str'>             # 字符串
 
Python int() 函数
 
描述
 
int() 函数用于将一个字符串或数字转换为整型。
 
以下是 int() 方法的语法:
 
class int(x, base=10)
 
参数
 
 
 
x – 字符串或数字。
 base – 进制数，默认十进制。
 返回值
 返回整型数据。
 
 
以下展示了使用 int() 方法的实例：
 
>>>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
 
#Python isinstance() 函数
 
描述
 isinstance() 函数来判断一个对象是否是一个已知的类型，类似 type()。
 isinstance() 与 type() 区别：
 type() 不会认为子类是一种父类类型，不考虑继承关系。
 isinstance() 会认为子类是一种父类类型，考虑继承关系。
 如果要判断两个类型是否相同推荐使用 isinstance()。
 
以下是 isinstance() 方法的语法:
 
isinstance(object, classinfo)
 
参数
 
 
 
object – 实例对象。
 classinfo – 可以是直接或间接类名、基本类型或者由它们组成的元组。
 返回值
 如果对象的类型与参数二的类型（classinfo）相同则返回 True，否则返回 False。。
 
 
以下展示了使用 isinstance 函数的实例：
 
>>>a = 2
>>> isinstance (a,int)
True
>>> isinstance (a,str)
False
>>> isinstance (a,(str,int,list))    # 是元组中的一个返回 True
True
 
type() 与 isinstance()区别：
 
class A:
    pass
 
class B(A):
    pass
 
isinstance(A(), A)    # returns True
type(A()) == A        # returns True
isinstance(B(), A)    # returns True
type(B()) == A        # returns False
 
Python issubclass() 函数
 
描述
 
issubclass() 方法用于判断参数 class 是否是类型参数 classinfo 的子类。
 
以下是 issubclass() 方法的语法:
 
issubclass(class, classinfo)
 
参数
 
 
 
class – 类。
 classinfo – 类。
 返回值
 如果 class 是 classinfo 的子类返回 True，否则返回 False。
 
 
以下展示了使用 issubclass 函数的实例：
 
#!/usr/bin/python
# -*- coding: UTF-8 -*-
 
class A:
    pass
class B(A):
    pass
    
print(issubclass(B,A))    # 返回 True
 
Python iter() 函数
 
描述
 
iter() 函数用来生成迭代器。
 
以下是 iter() 方法的语法:
 
iter(object[, sentinel])
 
参数
 
 
 
object – 支持迭代的集合对象。
 sentinel – 如果传递了第二个参数，则参数 object 必须是一个可调用的对象（如，函数），此时，iter 创建了一个迭代器对象，每次调用这个迭代器对象的__next__()方法时，都会调用 object。
 打开模式
 返回值
 迭代器对象。
 
 
实例
 
>>>lst = [1, 2, 3]
>>> for i in iter(lst):
...     print(i)
... 
1
2
3
 
Python len()方法
 
描述
 
Python len() 方法返回对象（字符、列表、元组等）长度或项目个数。
 
len()方法语法：
 
len( s )
 
参数
 
 
 
s – 对象。
 返回值
 返回对象长度。
 
 
以下实例展示了 len() 的使用方法：
 
>>>str = "runoob"
>>> len(str)             # 字符串长度
6
>>> l = [1,2,3,4,5]
>>> len(l)               # 列表元素个数
5
 
Python List list()方法
 
描述
 list() 方法用于将元组转换为列表。
 
注：元组与列表是非常类似的，区别在于元组的元素值不能修改，元组是放在括号中，列表是放于方括号中。
 
list()方法语法：
 
list( tup )
 
参数
 
 
 
tup – 要转换为列表的元组。
 返回值
 返回列表。
 
 
以下实例展示了 list()函数的使用方法：
 
#!/usr/bin/python
# -*- coding: UTF-8 -*-
 
aTuple = (123, 'xyz', 'zara', 'abc');
aList = list(aTuple)
 
print "列表元素 : ", aList
以上实例输出结果如下：

列表元素 :  [123, 'xyz', 'zara', 'abc']
 
Python locals() 函数
 
描述
 
locals() 函数会以字典类型返回当前位置的全部局部变量。
 对于函数, 方法, lambda 函式, 类, 以及实现了 call 方法的类实例, 它都返回 True。
 
locals() 函数语法：
 
locals()
 
参数
 
无
 
返回值
 
返回字典类型的局部变量。
 
以下实例展示了 locals() 的使用方法：
 
>>>def runoob(arg):    # 两个局部变量：arg、z
...     z = 1
...     print (locals())
... 
>>> runoob(4)
{'z': 1, 'arg': 4}      # 返回一个名字/值对的字典
>>>
 
Python long() 函数
 
描述
 
long() 函数将数字或字符串转换为一个长整型。
 
long() 函数语法：
 
class long(x, base=10)
 
参数
 
 
 
x – 字符串或数字。
 base – 可选，进制数，默认十进制。
 返回值
 返回长整型数。
 
 
以下实例展示了 long() 的使用方法：
 
>>>long()
0L
>>> long(1)
1L
>>> long('123')
123L
>>> 
>>>
 
Python map() 函数
 
描述
 
map() 会根据提供的函数对指定序列做映射。
 第一个参数 function 以参数序列中的每一个元素调用 function 函数，返回包含每次 function 函数返回值的新列表。
 
map() 函数语法：
 
map(function, iterable, …)
 
参数
 
 
 
function – 函数
 iterable – 一个或多个序列
 
 
返回值
 
Python 2.x 返回列表。
 Python 3.x 返回迭代器。
 
以下实例展示了 map() 的使用方法：
 
>>>def square(x) :            # 计算平方数
...     return x ** 2
... 
>>> map(square, [1,2,3,4,5])   # 计算列表各个元素的平方
[1, 4, 9, 16, 25]
>>> map(lambda x: x ** 2, [1, 2, 3, 4, 5])  # 使用 lambda 匿名函数
[1, 4, 9, 16, 25]

# 提供了两个列表，对相同位置的列表数据进行相加
>>> map(lambda x, y: x + y, [1, 3, 5, 7, 9], [2, 4, 6, 8, 10])
[3, 7, 11, 15, 19]
 
Python max() 函数
 
描述
 
max() 方法返回给定参数的最大值，参数可以为序列。
 
以下是 max() 方法的语法:
 
max( x, y, z, … )
 
参数
 
 
 
x – 数值表达式。
 y – 数值表达式。
 z – 数值表达式。
 
 
返回值
 
返回给定参数的最大值。
 
以下展示了使用 max() 方法的实例：
 
实例(Python 2.0+)
#!/usr/bin/python
 
print "max(80, 100, 1000) : ", max(80, 100, 1000)
print "max(-20, 100, 400) : ", max(-20, 100, 400)
print "max(-80, -20, -10) : ", max(-80, -20, -10)
print "max(0, 100, -400) : ", max(0, 100, -400)

实例（Python 3.0+）
print ("max(80, 100, 1000) : ", max(80, 100, 1000))
print ("max(-20, 100, 400) : ", max(-20, 100, 400))
print ("max(-80, -20, -10) : ", max(-80, -20, -10))
print ("max(0, 100, -400) : ", max(0, 100, -400))
 
以上实例运行后输出结果为：
 
max(80, 100, 1000) :  1000
max(-20, 100, 400) :  400
max(-80, -20, -10) :  -10
max(0, 100, -400) :  100
 
#　Python memoryview() 函数
 
描述
 
memoryview() 函数返回给定参数的内存查看对象(Momory view)。
 所谓内存查看对象，是指对支持缓冲区协议的数据进行包装，在不需要复制对象基础上允许Python代码访问。
 
memoryview 语法：
 
memoryview(obj)
 
参数说明：
 
 
 
obj – 对象
 返回值
 返回元组列表。
 
 
以下实例展示了 memoryview 的使用方法：
 
Python2.x 应用：
 
>>>v = memoryview('abcefg')
>>> v[1]
'b'
>>> v[-1]
'g'
>>> v[1:4]
<memory at 0x77ab28>
>>> v[1:4].tobytes()
'bce'
 
Python3.x 应用：
 
>>>v = memoryview(bytearray("abcefg", 'utf-8'))
>>> print(v[1])
98
>>> print(v[-1])
103
>>> print(v[1:4])
<memory at 0x10f543a08>
>>> print(v[1:4].tobytes())
b'bce'
>>>
 
Python min() 函数
 
描述
 
min() 方法返回给定参数的最小值，参数可以为序列。
 
以下是 min() 方法的语法:
 
min( x, y, z, … )
 
参数
 
 
 
x – 数值表达式。
 y – 数值表达式。
 z – 数值表达式。
 
 
返回值
 
返回给定参数的最小值。
 
以下展示了使用 min() 方法的实例：
 
#!/usr/bin/python

print "min(80, 100, 1000) : ", min(80, 100, 1000)
print "min(-20, 100, 400) : ", min(-20, 100, 400)
print "min(-80, -20, -10) : ", min(-80, -20, -10)
print "min(0, 100, -400) : ", min(0, 100, -400)
 
以上实例运行后输出结果为：
 
min(80, 100, 1000) :  80
min(-20, 100, 400) :  -20
min(-80, -20, -10) :  -80
min(0, 100, -400) :  -400
 
Python next() 函数
 
描述
 
next() 返回迭代器的下一个项目。
 
next 语法：
 
next(iterator[, default])
 
参数说明：
 
 
 
iterator – 可迭代对象
 default – 可选，用于设置在没有下一个元素时返回该默认值，如果不设置，又没有下一个元素则会触发 StopIteration 异常。
 
 
返回值
 
返回对象帮助信息。
 
以下实例展示了 next 的使用方法：
 
#!/usr/bin/python
# -*- coding: UTF-8 -*-
 
# 首先获得Iterator对象:
it = iter([1, 2, 3, 4, 5])
# 循环:
while True:
    try:
        # 获得下一个值:
        x = next(it)
        print(x)
    except StopIteration:
        # 遇到StopIteration就退出循环
        break
 
输出结果为：
 
1
2
3
4
5
 
Python object()函数
 
Python object() 函数
 
Python oct() 函数
 
描述
 
oct() 函数将一个整数转换成8进制字符串。
 
oct 语法：
 
oct(x)
 
参数说明：
 
 
 
x – 整数。
 返回值
 返回8进制字符串。
 
 
以下实例展示了 oct 的使用方法：
 
>>>oct(10)
'012'
>>> oct(20)
'024'
>>> oct(15)
'017'
>>>
 
Python open() 函数
 
python open() 函数用于打开一个文件，创建一个 file 对象，相关的方法才可以调用它进行读写。
 
更多文件操作可参考：Python 文件I/O
 
函数语法
 
open(name[, mode[, buffering]])
 
参数说明：
 
 
 
name : 一个包含了你要访问的文件名称的字符串值。
 mode : mode 决定了打开文件的模式：只读，写入，追加等。所有可取值见如下的完全列表。这个参数是非强制的，默认文件访问模式为只读®。
 buffering : 如果 buffering 的值被设为 0，就不会有寄存。如果 buffering 的值取 1，访问文件时会寄存行。如果将 buffering 的值设为大于 1 的整数，表明了这就是的寄存区的缓冲大小。如果取负值，寄存区的缓冲大小则为系统默认。
 
 
不同模式打开文件的完全列表：
 
模式
描述
r
以只读方式打开文件。文件的指针将会放在文件的开头。这是默认模式。
rb
以二进制格式打开一个文件用于只读。文件指针将会放在文件的开头。这是默认模式。
r+
打开一个文件用于读写。文件指针将会放在文件的开头。
rb+
以二进制格式打开一个文件用于读写。文件指针将会放在文件的开头。
w
打开一个文件只用于写入。如果该文件已存在则打开文件，并从开头开始编辑，即原有内容会被删除。如果该文件不存在，创建新文件。
wb
以二进制格式打开一个文件只用于写入。如果该文件已存在则打开文件，并从开头开始编辑，即原有内容会被删除。如果该文件不存在，创建新文件。
w+
打开一个文件用于读写。如果该文件已存在则打开文件，并从开头开始编辑，即原有内容会被删除。如果该文件不存在，创建新文件。
wb+
以二进制格式打开一个文件用于读写。如果该文件已存在则打开文件，并从开头开始编辑，即原有内容会被删除。如果该文件不存在，创建新文件。
a
打开一个文件用于追加。如果该文件已存在，文件指针将会放在文件的结尾。也就是说，新的内容将会被写入到已有内容之后。如果该文件不存在，创建新文件进行写入。
ab
以二进制格式打开一个文件用于追加。如果该文件已存在，文件指针将会放在文件的结尾。也就是说，新的内容将会被写入到已有内容之后。如果该文件不存在，创建新文件进行写入。
a+
打开一个文件用于读写。如果该文件已存在，文件指针将会放在文件的结尾。文件打开时会是追加模式。如果该文件不存在，创建新文件用于读写。
ab+
以二进制格式打开一个文件用于追加。如果该文件已存在，文件指针将会放在文件的结尾。如果该文件不存在，创建新文件用于读写。
file 对象方法
 
file.read([size])：size 未指定则返回整个文件，如果文件大小 >2 倍内存则有问题，f.read()读到文件尾时返回""(空字串)。
 
file.readline()：返回一行。
 
file.readlines([size]) ：返回包含size行的列表, size 未指定则返回全部行。
 
for line in f: print line ：通过迭代器访问。
 
f.write(“hello\n”)：如果要写入字符串以外的数据,先将他转换为字符串。
 
f.tell()：返回一个整数,表示当前文件指针的位置(就是到文件头的比特数)。
 
f.seek(偏移量,[起始位置])：用来移动文件指针。
 
偏移量: 单位为比特，可正可负
 起始位置: 0 - 文件头, 默认值; 1 - 当前位置; 2 - 文件尾
 f.close() 关闭文件
 
Python ord() 函数
 
描述
 
ord() 函数是 chr() 函数（对于8位的ASCII字符串）或 unichr() 函数（对于Unicode对象）的配对函数，它以一个字符（长度为1的字符串）作为参数，返回对应的 ASCII 数值，或者 Unicode 数值，如果所给的 Unicode 字符超出了你的 Python 定义范围，则会引发一个 TypeError 的异常。
 
以下是 ord() 方法的语法:
 
ord©
 
参数
 
 
 
c – 字符。
 返回值
 返回值是对应的十进制整数。
 
 
以下展示了使用 ord() 方法的实例：
 
>>>ord('a')
97
>>> ord('b')
98
>>> ord('c')
99
 
Python pow() 函数
 
描述
 
pow() 方法返回 xy（x的y次方） 的值。
 
以下是 math 模块 pow() 方法的语法:
 
import math
 
math.pow( x, y )
 
内置的 pow() 方法
 
pow(x, y[, z])
 
函数是计算x的y次方，如果z在存在，则再对结果进行取模，其结果等效于pow(x,y) %z
 注意：pow() 通过内置的方法直接调用，内置方法会把参数作为整型，而 math 模块则会把参数转换为 float。
 
参数
 
 
 
x – 数值表达式。
 y – 数值表达式。
 z – 数值表达式。
 
 
返回值
 
返回 xy（x的y次方） 的值。
 
以下展示了使用 pow() 方法的实例：
 
#!/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
 
Python print() 函数
 
描述
 
print() 方法用于打印输出，最常见的一个函数。
 print 在 Python3.x 是一个函数，但在 Python2.x 版本不是一个函数，只是一个关键字。
 
以下是 print() 方法的语法:
 
print(*objects, sep=’ ‘, end=’\n’, file=sys.stdout)
 
参数
 
 
 
objects – 复数，表示可以一次输出多个对象。输出多个对象时，需要用 , 分隔。
 sep – 用来间隔多个对象，默认值是一个空格。
 end – 用来设定以什么结尾。默认值是换行符 \n，我们可以换成其他字符串。
 file – 要写入的文件对象。
 
 
返回值
 
无。
 
以下展示了使用 print 函数的实例：
 Python3 下测试
 
>>>print(1)  
1  
>>> print("Hello World")  
Hello World  
 
>>> a = 1
>>> b = 'runoob'
>>> print(a,b)
1 runoob
 
>>> print("aaa""bbb")
aaabbb
>>> print("aaa","bbb")
aaa bbb
>>> 
 
>>> print("I","Love","Python",sep=".")  # 设置间隔符
I.Love.Python
 
Python property() 函数
 
描述
 
property() 函数的作用是在新式类中返回属性值。
 
以下是 property() 方法的语法:
 
class property([fget[, fset[, fdel[, doc]]]])
 
参数
 
 
 
fget – 获取属性值的函数
 fset – 设置属性值的函数
 fdel – 删除属性值函数
 doc – 属性描述信息
 
 
返回值
 
返回新式类属性。
 
实例
 
定义一个可控属性值 x
class C(object):
    def __init__(self):
        self._x = None
 
    def getx(self):
        return self._x
 
    def setx(self, value):
        self._x = value
 
    def delx(self):
        del self._x
 
    x = property(getx, setx, delx, "I'm the 'x' property.")
 
如果 c 是 C 的实例化, c.x 将触发 getter,c.x = value 将触发 setter ， del c.x 触发 deleter。
 如果给定 doc 参数，其将成为这个属性值的 docstring，否则 property 函数就会复制 fget 函数的 docstring（如果有的话）。
 将 property 函数用作装饰器可以很方便的创建只读属性：
 
class Parrot(object):
    def __init__(self):
        self._voltage = 100000
 
    @property
    def voltage(self):
        """Get the current voltage."""
        return self._voltage
 
上面的代码将 voltage() 方法转化成同名只读属性的 getter 方法。
 property 的 getter,setter 和 deleter 方法同样可以用作装饰器：
 
class C(object):
    def __init__(self):
        self._x = None
 
    @property
    def x(self):
        """I'm the 'x' property."""
        return self._x
 
    @x.setter
    def x(self, value):
        self._x = value
 
    @x.deleter
    def x(self):
        del self._x
 
这个代码和第一个例子完全相同，但要注意这些额外函数的名字和 property 下的一样，例如这里的 x。
 
Python range() 函数用法
 
描述
 python range() 函数可创建一个整数列表，一般用在 for 循环中。
 
函数语法
 
range(start, stop[, step])
 
参数说明：
 
 
 
start: 计数从 start 开始。默认是从 0 开始。例如range（5）等价于range（0， 5）;
 stop: 计数到 stop 结束，但不包括 stop。例如：range（0， 5） 是[0, 1, 2, 3, 4]没有5
 step：步长，默认为1。例如：range（0， 5） 等价于 range(0, 5, 1)
 
 
实例
 
>>>range(10)        # 从 0 开始到 10
[0, 1, 2, 3, 4, 5, 6, 7, 8, 9]
>>> range(1, 11)     # 从 1 开始到 11
[1, 2, 3, 4, 5, 6, 7, 8, 9, 10]
>>> range(0, 30, 5)  # 步长为 5
[0, 5, 10, 15, 20, 25]
>>> range(0, 10, 3)  # 步长为 3
[0, 3, 6, 9]
>>> range(0, -10, -1) # 负数
[0, -1, -2, -3, -4, -5, -6, -7, -8, -9]
>>> range(0)
[]
>>> range(1, 0)
[]
 
以下是 range 在 for 中的使用，循环出runoob 的每个字母:
 
>>>x = 'runoob'
>>> for i in range(len(x)) :
...     print(x[i])
... 
r
u
n
o
o
b
>>>
 
Python raw_input() 函数
 
描述
 python raw_input() 用来获取控制台的输入。
 raw_input() 将所有输入作为字符串看待，返回字符串类型。
 
注意： input() 和 raw_input() 这两个函数均能接收 字符串 ，但 raw_input() 直接读取控制台的输入（任何类型的输入它都可以接收）。而对于 input() ，它希望能够读取一个合法的 python 表达式，即你输入字符串的时候必须使用引号将它括起来，否则它会引发一个 SyntaxError 。
 除非对 input() 有特别需要，否则一般情况下我们都是推荐使用 raw_input() 来与用户交互。
 
注意： python3 里 input() 默认接收到的是 str 类型。
 
函数语法
 
raw_input([prompt])
 
参数说明：
 
 
 
prompt: 可选，字符串，可作为一个提示语。
 
 
实例
 raw_input() 将所有输入作为字符串看待
 
>>>a = raw_input("input:")
input:123
>>> type(a)
<type 'str'>              # 字符串
>>> a = raw_input("input:")
input:runoob
>>> type(a)
<type 'str'>              # 字符串
>>>
 
input() 需要输入 python 表达式
 
>>>a = input("input:")
input:123                  # 输入整数
>>> type(a)
<type 'int'>               # 整型
>>> a = input("input:")    
input:"runoob"           # 正确，字符串表达式
>>> type(a)
<type 'str'>             # 字符串
>>> a = input("input:")
input:runoob               # 报错，不是表达式
Traceback (most recent call last):
  File "<stdin>", line 1, in <module>
  File "<string>", line 1, in <module>
NameError: name 'runoob' is not defined
<type 'str'>
 
Python reduce() 函数
 
描述
 
reduce() 函数会对参数序列中元素进行累积。
 函数将一个数据集合（链表，元组等）中的所有数据进行下列操作：用传给 reduce 中的函数 function（有两个参数）先对集合中的第 1、2 个元素进行操作，得到的结果再与第三个数据用 function 函数运算，最后得到一个结果。
 
reduce() 函数语法：
 
reduce(function, iterable[, initializer])
 
参数
 
 
 
function – 函数，有两个参数
 iterable – 可迭代对象
 initializer – 可选，初始参数
 
 
返回值
 
返回函数计算结果。
 
以下实例展示了 reduce() 的使用方法：
 
>>>def add(x, y) :            # 两数相加
...     return x + y
... 
>>> reduce(add, [1,2,3,4,5])   # 计算列表和：1+2+3+4+5
15
>>> reduce(lambda x, y: x+y, [1,2,3,4,5])  # 使用 lambda 匿名函数
15
 
Python reload() 函数
 
Python3.0+ 重要!!!
 
说明：Python 3.0 把 reload 内置函数移到了 imp 标准库模块中。它仍然像以前一样重载文件，但是，必须导入它才能使用。
 
方法一：
 
from imp import reload
 reload(module)
 方法二：
 
import imp
 imp.reload(module)
 
描述
 
reload() 用于重新载入之前载入的模块。
 
reload() 函数语法：
 
reload(module)
 
参数
 
module – 模块对象。
 
返回值
 
返回模块对象。
 
以下实例展示了 reload() 的使用方法：
 
重新载入 sys 模块，并设置默认编码为 utf8
>>>import sys
>>> sys.getdefaultencoding()            # 当前默认编码
'ascii'
>>> reload(sys)                         # 使用 reload
<module 'sys' (built-in)>
>>> sys.setdefaultencoding('utf8')      # 设置编码
>>> sys.getdefaultencoding()
'utf8'
>>>
 
Python repr() 函数
 
描述
 
repr() 函数将对象转化为供解释器读取的形式。
 
以下是 repr() 方法的语法:
 
repr(object)
 
参数
 
 
 
object – 对象。
 
 
返回值
 
返回一个对象的 string 格式。
 
以下展示了使用 repr() 方法的实例：
 
>>>s = 'RUNOOB'
>>> repr(s)
"'RUNOOB'"
>>> dict = {'runoob': 'runoob.com', 'google': 'google.com'};
>>> repr(dict)
"{'google': 'google.com', 'runoob': 'runoob.com'}"
>>>
 
Python List reverse()方法
 
描述
 
reverse() 函数用于反向列表中元素。
 
reverse()方法语法：
 
list.reverse()
 
参数
 
 
 
NA。
 
 
返回值
 
该方法没有返回值，但是会对列表的元素进行反向排序。
 
以下实例展示了 reverse()函数的使用方法：
 
#!/usr/bin/python

aList = [123, 'xyz', 'zara', 'abc', 'xyz']

aList.reverse()
print "List : ", aList
以上实例输出结果如下：

List :  ['xyz', 'abc', 'zara', 'xyz', 123]
 
Python round() 函数
 
描述
 
round() 方法返回浮点数x的四舍五入值。
 
以下是 round() 方法的语法:
 
round( x [, n] )
 
参数
 
 
 
x – 数值表达式。
 n – 数值表达式。
 
 
返回值
 返回浮点数x的四舍五入值。
 
以下展示了使用 round() 方法的实例：
 
#!/usr/bin/python

print "round(80.23456, 2) : ", round(80.23456, 2)
print "round(100.000056, 3) : ", round(100.000056, 3)
print "round(-100.000056, 3) : ", round(-100.000056, 3)
 
以上实例运行后输出结果为：
 
round(80.23456, 2) :  80.23
round(100.000056, 3) :  100.0
round(-100.000056, 3) :  -100.0
 
Python set() 函数
 
描述
 
set() 函数创建一个无序不重复元素集，可进行关系测试，删除重复数据，还可以计算交集、差集、并集等。
 
set 语法：
 
class set([iterable])
 
参数说明：
 
 
 
iterable – 可迭代对象对象；
 
 
返回值
 
返回新的集合对象。
 
以下实例展示了 set 的使用方法：
 
>>>x = set('runoob')
>>> y = set('google')
>>> x, y
(set(['b', 'r', 'u', 'o', 'n']), set(['e', 'o', 'g', 'l']))   # 重复的被删除
>>> x & y         # 交集
set(['o'])
>>> x | y         # 并集
set(['b', 'e', 'g', 'l', 'o', 'n', 'r', 'u'])
>>> x - y         # 差集
set(['r', 'b', 'u', 'n'])
>>>
 
Python setattr() 函数
 
描述
 setattr() 函数对应函数 getattr()，用于设置属性值，该属性不一定是存在的。
 
setattr() 语法：
 
setattr(object, name, value)
 
参数
 
 
 
object – 对象。
 name – 字符串，对象属性。
 value – 属性值。
 
 
返回值
 无。
 
以下实例展示了 setattr() 函数的使用方法：
 
对已存在的属性进行赋值：
 
>>>class A(object):
...     bar = 1
... 
>>> a = A()
>>> getattr(a, 'bar')          # 获取属性 bar 值
1
>>> setattr(a, 'bar', 5)       # 设置属性 bar 值
>>> a.bar
5
 
如果属性不存在会创建一个新的对象属性，并对属性赋值：
 
>>>class A():
...     name = "runoob"
... 
>>> a = A()
>>> setattr(a, "age", 28)
>>> print(a.age)
28
>>>
 
Python slice() 函数
 
描述
 
slice() 函数实现切片对象，主要用在切片操作函数里的参数传递。
 
slice 语法：
 
class slice(stop)
 class slice(start, stop[, step])
 
参数说明：
 
 
 
start – 起始位置
 stop – 结束位置
 step – 间距
 
 
返回值
 
返回一个切片对象。
 
以下实例展示了 slice 的使用方法：
 
>>>myslice = slice(5)    # 设置截取5个元素的切片
>>> myslice
slice(None, 5, None)
>>> arr = range(10)
>>> arr
[0, 1, 2, 3, 4, 5, 6, 7, 8, 9]
>>> arr[myslice]         # 截取 5 个元素
[0, 1, 2, 3, 4]
>>>
 
Python sorted() 函数
 
描述
 
sorted() 函数对所有可迭代的对象进行排序操作。
 sort 与 sorted 区别：
 sort 是应用在 list 上的方法，sorted 可以对所有可迭代的对象进行排序操作。
 list 的 sort 方法返回的是对已经存在的列表进行操作，无返回值，而内建函数 sorted 方法返回的是一个新的 list，而不是在原来的基础上进行的操作。
 
sorted 语法：
 
sorted(iterable[, cmp[, key[, reverse]]])
 
参数说明：
 
 
 
iterable – 可迭代对象。
 cmp – 比较的函数，这个具有两个参数，参数的值都是从可迭代对象中取出，此函数必须遵守的规则为，大于则返回1，小于则返回-1，等于则返回0。
 key – 主要是用来进行比较的元素，只有一个参数，具体的函数的参数就是取自于可迭代对象中，指定可迭代对象中的一个元素来进行排序。
 reverse – 排序规则，reverse = True 降序 ， reverse = False 升序（默认）。
 
 
返回值
 
返回重新排序的列表。
 
以下实例展示了 sorted 的使用方法：
 
>>>a = [5,7,6,3,4,1,2]
>>> b = sorted(a)       # 保留原列表
>>> a 
[5, 7, 6, 3, 4, 1, 2]
>>> b
[1, 2, 3, 4, 5, 6, 7]
 
>>> L=[('b',2),('a',1),('c',3),('d',4)]
>>> sorted(L, cmp=lambda x,y:cmp(x[1],y[1]))   # 利用cmp函数
[('a', 1), ('b', 2), ('c', 3), ('d', 4)]
>>> sorted(L, key=lambda x:x[1])               # 利用key
[('a', 1), ('b', 2), ('c', 3), ('d', 4)]
 
 
>>> students = [('john', 'A', 15), ('jane', 'B', 12), ('dave', 'B', 10)]
>>> sorted(students, key=lambda s: s[2])            # 按年龄排序
[('dave', 'B', 10), ('jane', 'B', 12), ('john', 'A', 15)]
 
>>> sorted(students, key=lambda s: s[2], reverse=True)       # 按降序
[('john', 'A', 15), ('jane', 'B', 12), ('dave', 'B', 10)]
>>>
 
Python staticmethod() 函数
 
描述
 python staticmethod 返回函数的静态方法。
 该方法不强制要求传递参数，如下声明一个静态方法：
 
class C(object):
    @staticmethod
    def f(arg1, arg2, ...):
        ...
 
以上实例声明了静态方法 f，类可以不用实例化就可以调用该方法 C.f()，当然也可以实例化后调用 C().f()。
 
函数语法
 staticmethod(function)
 
参数说明：
 
无
 
#!/usr/bin/python
# -*- coding: UTF-8 -*-
 
class C(object):
    @staticmethod
    def f():
        print('Python');
 
C.f();          # 静态方法无需实例化
cobj = C()
cobj.f()        # 也可以实例化后调用
 
以上实例输出结果为：
 
Python
Python
 
Python str() 函数
 
描述
 
str() 函数将对象转化为适于人阅读的形式。
 
以下是 str() 方法的语法:
 
class str(object=’’)
 
参数
 
 
 
object – 对象。
 返回值
 返回一个对象的string格式。
 
 
以下展示了使用 str() 方法的实例：
 
>>>s = 'RUNOOB'
>>> str(s)
'RUNOOB'
>>> dict = {'runoob': 'runoob.com', 'google': 'google.com'};
>>> str(dict)
"{'google': 'google.com', 'runoob': 'runoob.com'}"
>>>
 
Python sum() 函数
 
描述
 
sum() 方法对系列进行求和计算。
 
以下是 sum() 方法的语法:
 
sum(iterable[, start])
 
参数
 
 
 
iterable – 可迭代对象，如：列表、元组、集合。
 start – 指定相加的参数，如果没有设置这个值，默认为0。
 
 
返回值
 
返回计算结果。
 
以下展示了使用 sum 函数的实例：
 
>>>sum([0,1,2])  
3  
>>> sum((2, 3, 4), 1)        # 元组计算总和后再加 1
10
>>> sum([0,1,2,3,4], 2)      # 列表计算总和后再加 2
12
 
Python super() 函数
 
描述
 super() 函数是用于调用父类(超类)的一个方法。
 
super 是用来解决多重继承问题的，直接用类名调用父类方法在使用单继承的时候没问题，但是如果使用多继承，会涉及到查找顺序（MRO）、重复调用（钻石继承）等种种问题。
 
MRO 就是类的方法解析顺序表, 其实也就是继承父类方法时的顺序表。
 
以下是 super() 方法的语法:
 
super(type[, object-or-type])
 
参数
 
 
 
type – 类。
 object-or-type – 类，一般是 self
 
 
Python3.x 和 Python2.x 的一个区别是: Python 3 可以使用直接使用 super().xxx 代替 super(Class, self).xxx :
 
Python3.x 实例：
 
class A:
     def add(self, x):
         y = x+1
         print(y)
class B(A):
    def add(self, x):
        super().add(x)
b = B()
b.add(2)  # 3
 
Python2.x 实例：
 
#!/usr/bin/python
# -*- coding: UTF-8 -*-
 
class A(object):   # Python2.x 记得继承 object
    def add(self, x):
         y = x+1
         print(y)
class B(A):
    def add(self, x):
        super(B, self).add(x)
b = B()
b.add(2)  # 3
 
返回值
 
无。
 
以下展示了使用 super 函数的实例：
 
#!/usr/bin/python
# -*- coding: UTF-8 -*-
 
class FooParent(object):
    def __init__(self):
        self.parent = 'I\'m the parent.'
        print ('Parent')
    
    def bar(self,message):
        print ("%s from Parent" % message)
 
class FooChild(FooParent):
    def __init__(self):
        # super(FooChild,self) 首先找到 FooChild 的父类（就是类 FooParent），然后把类B的对象 FooChild 转换为类 FooParent 的对象
        super(FooChild,self).__init__()    
        print ('Child')
        
    def bar(self,message):
        super(FooChild, self).bar(message)
        print ('Child bar fuction')
        print (self.parent)
 
if __name__ == '__main__':
    fooChild = FooChild()
    fooChild.bar('HelloWorld')
 
执行结果：
 
Parent
Child
HelloWorld from Parent
Child bar fuction
I'm the parent.
 
Python Tuple(元组) tuple()方法
 
描述
 
Python 元组 tuple() 函数将列表转换为元组。
 
tuple()方法语法：
 
tuple( seq )
 
参数
 
 
 
seq – 要转换为元组的序列。
 
 
返回值
 
返回元组。
 
以下实例展示了 tuple()函数的使用方法：
 
实例 1
 
>>>tuple([1,2,3,4])
 
(1, 2, 3, 4)
 
>>> tuple({1:2,3:4})    #针对字典 会返回字典的key组成的tuple
 
(1, 3)
 
>>> tuple((1,2,3,4))    #元组会返回元组自身
 
(1, 2, 3, 4)
 
实例 2
 
#!/usr/bin/python
 
aList = [123, 'xyz', 'zara', 'abc'];
aTuple = tuple(aList)
 
print "Tuple elements : ", aTuple
 
以上实例输出结果为：
 
Tuple elements :  (123, 'xyz', 'zara', 'abc')
 
Python type() 函数
 
描述
 
type() 函数如果你只有第一个参数则返回对象的类型，三个参数返回新的类型对象。
 isinstance() 与 type() 区别：
 type() 不会认为子类是一种父类类型，不考虑继承关系。
 isinstance() 会认为子类是一种父类类型，考虑继承关系。
 如果要判断两个类型是否相同推荐使用 isinstance()。
 
以下是 type() 方法的语法:
 
type(object)
 type(name, bases, dict)
 
参数
 
 
 
name – 类的名称。
 bases – 基类的元组。
 dict – 字典，类内定义的命名空间变量。
 
 
返回值
 
一个参数返回对象类型, 三个参数，返回新的类型对象。
 
以下展示了使用 type 函数的实例：
 
# 一个参数实例
>>> type(1)
<type 'int'>
>>> type('runoob')
<type 'str'>
>>> type([2])
<type 'list'>
>>> type({0:'zero'})
<type 'dict'>
>>> x = 1          
>>> type( x ) == int    # 判断类型是否相等
True
 
# 三个参数
>>> class X(object):
...     a = 1
...
>>> X = type('X', (object,), dict(a=1))  # 产生一个新的类型 X
>>> X
<class '__main__.X'>
type() 与 isinstance()区别：
class A:
    pass
 
class B(A):
    pass
 
isinstance(A(), A)    # returns True
type(A()) == A        # returns True
isinstance(B(), A)    # returns True
type(B()) == A        # returns False
 
type() 与 isinstance()区别：
 
class A:
    pass
 
class B(A):
    pass
 
isinstance(A(), A)    # returns True
type(A()) == A        # returns True
isinstance(B(), A)    # returns True
type(B()) == A        # returns False
 
Python unichr() 函数
 
描述
 
unichr() 函数 和 chr()函数功能基本一样， 只不过是返回 unicode 的字符。
 
以下是 unichr() 方法的语法:
 
unichr(i)
 
参数
 
 
 
i – 可以是10进制也可以是16进制的形式的数字。
 
 
返回值
 
返回 unicode 的字符。
 
以下展示了使用 unichr() 方法的实例：
 
>>>unichr(97)
u'a'
>>> unichr(98)
u'b'
>>> unichr(99)
u'c'
 
Python unicode() 函数
 
unicode()
 
Python vars() 函数
 
描述
 
vars() 函数返回对象object的属性和属性值的字典对象。
 
vars() 函数语法：
 
vars([object])
 
参数
 
 
 
object – 对象
 
 
返回值
 
返回对象object的属性和属性值的字典对象，如果没有参数，就打印当前调用位置的属性和属性值 类似 locals()。
 
以下实例展示了 vars() 的使用方法：
 
>>>print(vars())
{'__builtins__': <module '__builtin__' (built-in)>, '__name__': '__main__', '__doc__': None, '__package__': None}
>>> class Runoob:
...     a = 1
... 
>>> print(vars(Runoob))
{'a': 1, '__module__': '__main__', '__doc__': None}
>>> runoob = Runoob()
>>> print(vars(runoob))
{}
 
Python xrange() 函数
 
描述
 
xrange() 函数用法与 range 完全相同，所不同的是生成的不是一个数组，而是一个生成器。
 
xrange 语法：
 
xrange(stop)
 xrange(start, stop[, step])
 
参数说明：
 
 
 
start: 计数从 start 开始。默认是从 0 开始。例如 xrange(5) 等价于 xrange(0， 5)
 stop: 计数到 stop 结束，但不包括 stop。例如：xrange(0， 5) 是 [0, 1, 2, 3, 4] 没有 5
 step：步长，默认为1。例如：xrange(0， 5) 等价于 xrange(0, 5, 1)
 
 
返回值
 
返回生成器。
 
以下实例展示了 xrange 的使用方法：
 
>>>xrange(8)
xrange(8)
>>> list(xrange(8))
[0, 1, 2, 3, 4, 5, 6, 7]
>>> range(8)                 # range 使用
[0, 1, 2, 3, 4, 5, 6, 7]
>>> xrange(3, 5)
xrange(3, 5)
>>> list(xrange(3,5))
[3, 4]
>>> range(3,5)               # 使用 range
[3, 4]
>>> xrange(0,6,2)
xrange(0, 6, 2)              # 步长为 2
>>> list(xrange(0,6,2))
[0, 2, 4]
>>>
 
Python3 zip() 函数
 
描述
 zip() 函数用于将可迭代的对象作为参数，将对象中对应的元素打包成一个个元组，然后返回由这些元组组成的对象，这样做的好处是节约了不少的内存。
 我们可以使用 list() 转换来输出列表。
 如果各个迭代器的元素个数不一致，则返回列表长度与最短的对象相同，利用 * 号操作符，可以将元组解压为列表。
 
zip 语法：
 
zip([iterable, …])
 
参数说明：
 
 
 
iterabl – 一个或多个迭代器;
 
 
返回值
 
返回一个对象。
 
以下实例展示了 zip 的使用方法：
 
>>>a = [1,2,3]
>>> b = [4,5,6]
>>> c = [4,5,6,7,8]
>>> zipped = zip(a,b)     # 返回一个对象
>>> zipped
<zip object at 0x103abc288>
>>> list(zipped)  # list() 转换为列表
[(1, 4), (2, 5), (3, 6)]
>>> list(zip(a,c))              # 元素个数与最短的列表一致
[(1, 4), (2, 5), (3, 6)]
 
>>> a1, a2 = zip(*zip(a,b))          # 与 zip 相反，zip(*) 可理解为解压，返回二维矩阵式
>>> list(a1)
[1, 2, 3]
>>> list(a2)
[4, 5, 6]
>>>
 
Python import() 函数
 
描述
 
import() 函数用于动态加载类和函数 。
 如果一个模块经常变化就可以使用 import() 来动态载入。
 
import 语法：
 
import(name[, globals[, locals[, fromlist[, level]]]])
 
参数说明：
 
 
 
name – 模块名
 
 
返回值
 
返回元组列表。
 
以下实例展示了 import 的使用方法：
 
a.py 文件代码：
 
#!/usr/bin/env python    
#encoding: utf-8  
 
import os  
 
print ('在 a.py 文件中 %s' % id(os))
 
test.py 文件代码：
 
#!/usr/bin/env python    
#encoding: utf-8  
 
import sys  
__import__('a')        # 导入 a.py 模块
 
执行 test.py 文件，输出结果为：
 
在 a.py 文件中 4394716136
 
Python exec 内置语句
 
描述
 
exec 执行储存在字符串或文件中的Python语句，相比于 eval，exec可以执行更复杂的 Python 代码。
 需要说明的是在 Python2 中exec不是函数，而是一个内置语句(statement)，但是Python 2中有一个 execfile() 函数。可以理解为 Python 3 把 exec 这个 statement 和 execfile() 函数的功能够整合到一个新的 exec() 函数中去了。
 
以下是 exec 的语法:
 
exec obj
 
参数
 
 
 
obj – 要执行的表达式。
 
 
返回值
 exec 返回值永远为 None。
 
以下展示了使用 exec 的实例：
 
实例 1
 
>>>exec 'print "Hello World"'
Hello World
# 单行语句字符串
>>> exec "print 'runoob.com'"
runoob.com
 
#  多行语句字符串
>>> exec """for i in range(5):
...   print "iter time: %d" % i
... """
iter time: 0
iter time: 1
iter time: 2
iter time: 3
iter time: 4
 
实例 2
 
x = 10
expr = """
z = 30
sum = x + y + z
print(sum)
"""
def func():
    y = 20
    exec(expr)
    exec(expr, {'x': 1, 'y': 2})
    exec(expr, {'x': 1, 'y': 2}, {'y': 3, 'z': 4})
    
func()
 
输出结果：
 
60
33
34
 
其余参考原文
 菜鸟教程

 
 
                                      公众号  关注一波  不定期分享视频资料
 
 
 
                                                               
 
一、简介
 
1、概述：
 
JavaScript是目前web开发中不可缺少的脚本语言，js不需要编译即可运行，运行在客户端，需要通过浏览器来解析执行JavaScript代码。
 
诞生于1995年，当时的主要目的是验证表单的数据是否合法。
 
JavaScript本来应该叫Livescript，但是在发布前夕，想搭上当时超热的java顺风车，临时把名字改为了JavaScript。（也就是说js跟java没有关系，当时只是想借助java的名气）。
 
js组成部分：
 
 
 
（1）核心（ECMAScript）：这一部分主要是js的基本语法。
 
（2）BOM：Brower Object Model（浏览器对象模型），主要是获取浏览器信息或操作浏览器的，例如：浏览器的前进与后退、浏览器弹出提示框、浏览器地址栏输入网址跳转等操作等。
 
（3）DOM：Document Object Model（文档对象模型），此处的文档暂且理解为html，html加载到浏览器的内存中，可以使用js的DOM技术对内存中的html节点进行修改，用户从浏览器看到的是js动态修改后的页面。（增删改查）
 
2、特点：
 
交互性（它可以做的就是信息的动态交互）
安全性（不允许直接访问本地硬盘）
跨平台性（只要是可以解析js的浏览器都可以执行，和平台无关）
3、和Java区别：
 
 
4、作用
 
avaScript 被用来改进设计、验证表单、检测浏览器、创建cookies，等等。JavaScript 是因特网上最流行的脚本语言，并且可在所有主要的浏览器中运行，比如： Internet Explorer、 Maxthon、Mozilla、Firefox、Netscape、Chrome和 Opera等。
 
在目前学习阶段只要记住最常用的二个：（1）运态修改html及css代码 （2）验证表单
 
5、书写位置
 
5.1、内嵌式：
 
理论上js可以书写在页面的任意位置。
 
<script>
 
alert("内嵌式")
 
</script>
 
5.2、外链式：
 
首先新建一个文件类型为.js的文件，然后在该文件中写js语句，通过script标签对引入到html页面中。
 
<script src="js文件路径地址">这里不能写js语句</script>
 
5.3、行内式：
 
直接书写在标签身上，是一个简写的事件，所以又称之为事件属性。     onclick单击事件
 
<input type="button" value="点我呀!" onclick="alert('点我干啥!^6^');">
<button onclick="alert('恭喜你,中 500 万.');">点我呀!</button>
 
6、注释：
 
单行注释：		//	注释语句		快捷键ctrl+/
多行注释：		/* 注释语句 */    快捷键ctrl+shift+/   
注意：多行注释相互不能嵌套使用，只能在多行注释里面使用单行注释！
 
7、数据类型：
 
Js中的数据类型：
  
 
数值型：number（凡是数字都是数值型，不区分整数和小数）
字符串：string（凡是引号包裹起来的内容全部都是字符串）
布尔：boolean（true、false）
对象类型：object（特殊取值null）
未定义型：undefined
 
对比java中的数据类型：
 
整数：byte short int long
小数：float double
字符：char 
布尔：boolean
字符串：String
 
8、变量：
 
8.1、定义：就是存放数据的、内疗可以存储任意数据
 
8.2、声明变量：
  
 
var 变量名称 = 存储的数据;   	(variable 变量)
 
8.3、变量命名规范：
 
1.	只能由字母、数字、_（下划线）、$（美元符号）组成。
2.	不能以数字开头。
3.	命名中不能出现-（js会理解成减号进行减法的操作），不能和关键字冲突。
 
js是弱类型语言，不重视类型的定义，但js会根据为变量赋值的情况自定判断该变量是何种类型：
 
数值型：var i = 1;	var d = 2.35;
字符串：var str = "用心学习";
布尔型：var b = true;
 
对比Java:java是强类型的语言，注重类型的定义，Java定义类型如下：
 
整型：int i = 1;
浮点型：double d = 2.35;
字符串：String str = “用心学习”;
布尔型：boolean b = true;
 
总结：js中变量的定义。只要加一个var就行。java则使用什么类型的变量就要定义什么类型的。
 
9、检测数据类型：
 
typeof(value); 或者typeof value;     返回这个变量的类型. 
说明 : 同一个变量, 可以进行不同类型的数据赋值.
 
<script type="text/javascript">
    
    var a;
    alert(typeof a);  // undefined

    a = 998;
    alert(typeof a); // number

    a = "用心学习";
    alert(typeof a); // string

    a = true;
    alert(typeof a); // boolean
    
</script>
 
10、算术运算符
 
+	-	*	/	%	++	--
 
注意：
 
1.	由于js中的小数和整数都是number类型，不存在类似整数除以整数还是整数的结论。
2.	字符串和其他的数据使用+号运算，会连接成一个新的字符串。
3.	字符串使用除了+以外的运算符：如果字符串本身是一个数字，那么会自动转成number进行运算
，否则就会返回一个NaN的结果，表示这不是一个数字。NaN：not a number
 
<script>

    alert(1234 / 1000 * 1000); // 1234
  
    var s = "12";
     s -= 10;
    alert(s);  // 2
 
    var s = "aa";
    s -= 10;
    alert(s);  // NaN       Not a Number 不是一个数字

    var s = "12";
    s += 10;
    alert(s);       // 1210 

</script>
 
11、关系（比较）运算符
 
>		>=		<		<=  	!=		
==	等于（只比较内容）	===	恒等于（比较内容的同时还要比较数据类型）
注意：关系运算符返回的结果只有两个：true / false
 
<script>

    // 请问1 : 3 > 5, 结果为 ?
    alert(3 > 5);   // false

    // 请问2 : “22” == 22  结果为 ?
    alert("22" == 22); // true  (仅仅判断数值)

    // 请问3 : “22” === 22  结果为 ?
    alert("22" === 22);  // false  (恒等于, 数值和类型都要相等)
    
</script>
 
12、逻辑运算符
 
&&	 	与		true&&false		====>false
|| 		或		true||false			====>true
！ 		非		!true				====>false
false（理解）：false,  0,  null,  undefined 
true（理解）：true, 非0,  非null,  非undefined

针对 && 顺口溜: 找第一个出现的假值. (一假即假)
针对 || 顺口溜: 找第一个出现的真值. (一真即真)
 
演示一：
 
<script>

    // 短路与 (一假即假)
    // 口诀 : 找第一个为假的值.

    // 请问1 :  8 < 7 && 3 < 4, 结果为 ?
    alert(8 < 7 && 3 < 4);  // false

    // 请问2 :  -2 && 6 + 6 && null 结果为 ?
    alert(-2 && 6 + 6 && null); // null

    // 请问3 :  1 + 1 && 0 && 5  结果为 ?
    alert(1 + 1 && 0 && 5); // 0

</script>
 
演示二:
 
<script>

    // 短路或 : 一真即真.
    // 口诀 : 找第一个为真的值.

    // 请问1 :  0 || 23 结果为 ?
    alert(0 || 23); // 23

    // 请问2 :  0 || false || true  结果为 ?
    alert(0 || false || true); // true

    // 请问3 :  null || 10 < 8 || 10 + 10结果为 ?
    alert(null || 10 < 8 || 10 + 10);  // 20

    // 请问4 :  null || 10 < 8 || false结果为 ?
    alert(null || 10 < 8 || false); // false
    
</script>
 
13、三元运算符：
 
条件？表达式1：表达式2
如果条件为true，返回表达式1的结果
如果条件为false，返回表达式2的结果
 
演示：
 
<script>

    // 请问1 :  3 ? “aaa” : “bbb” 结果为 ?
    alert(3 ? "aaa" : "bbb");       // aaa

    // 请问2 :  0 ? “ccc” : “ddd”  结果为 ?
    alert(0 ? "ccc" : "ddd");       // ddd
    
</script>
 
14、if条件语句
 
这个和Java中if语句一样。
 
演示：
 
<script>

      var score = 59;

      if (score >= 90) {
          alert("优秀");
      } else if (score >= 80) {
          alert("良好");
      } else if (score >= 60) {
          alert("及格");
      } else {
          alert("不及格");
      }

  </script>
 
15、switch分支结构
 
这个和java中switch结构一样。只是Java中表达式为：常量 整型（去long）、字符、字符串
 
演示：
 
<script>

      var score = 59;

      // 需求 : 将需要一个整型数值, 不想要小数点.
      // window 对象的 parseInt 方法.
      score = window.parseInt(score / 10 + "");
      // alert(score);

      switch (score) {
          case 10:
          case 9:
              alert("优秀!");
              break;
          case 8:
              alert("良好!");
              break;
          case 7:
          case 6:
              alert("及格!");
              break;
          default:
              alert("不及格!");
              break;
      }

  </script>
 
16、循环结构 while、do-while. for;
 
while(循环条件){循环体;}
do{循环体;}while(循环条件);
for(循环变量赋初值；循环条件；循环变量增值){循环语句;}
console.log（...）; 以日志的形式在控制台输出结果！
 
演示：
 
<script>

    // 需求 : 统计 1~100 之间能够被3和7整除的数字个数

    var count = 0;

    // 1. 遍历 1~100 之间的所有整型数值
    for (var i = 1; i <= 100; i++) {

        // 2. 判断
        if (i % 3 == 0 && i % 7 == 0) {
            // alert(i);
            console.log(i);
            // 3. 累加个数
            count++;
        }
    }

    // 4. 查看结果
    // alert(count);
    console.log(count);

 
console.log显示如下：
 
 
17、循环嵌套
 
演示案例9*9乘法表
 
 <style>
        table {
            /* 将 table 表格的线变成了细线 */
            border-collapse: collapse;
            /*color: red;*/
            border-color: red;
        }
    </style>

    <script>

        // 需求 : 九九乘法口诀表
        document.write("<table border='1px solid red' cellspacing='0' cellpadding='8px'>");
        document.write("<caption>九九乘法口诀表</caption>");
        for (var i = 1; i <= 9; i++) {
            document.write("<tr>");
            for (var j = 1; j <= i; j++) {
                document.write("<td>");
                document.write(j + "*" + i + "=" + (j*i) + "&nbsp;&nbsp;&nbsp;&nbsp;");
                document.write("</td>");
            }
            document.write("</tr>");
        }
        document.write("</table>");

    </script>

 
18、自定义函数
 
函数是命名的独立的语句段，这个语句段可以被当作一个整体来引用和执行：
 
格式：
 
function 函数名(形式参数){函数体}
调用函数：函数名(实际参数);
 
18.1、函数只有被调用后才会执行
 
18.2、如果函数需要返回值、直接使用return 返回、不会像java一样要考虑返回值的类型
 
<script type="text/javascript">

    // 定义一个函数 : function
    function demo2() {
        return 666;
    }

    // 调用函数 :
    alert(demo2());

</script>
 
18.3、如果函数需要传递参数、不需要指定参数的类型、直接使用变量即可
 
<script type="text/javascript">

    // 定义一个函数 : function
    function demo3(a, b) {
        return a + b;
    }

    // 调用函数 :
    alert(demo3(10, 20));//显示30

</script>
 
18.4、js中出现二个重名的函数名、后者会把前面的覆盖掉
 
对比java、java有重载（同名不同参）、重写（同名同参同返回值类型、方法体不一样）
 
演示：
 
<script type="text/javascript">

    // 定义一个函数 : function
    function demo4(a, b) {
        alert("调用1...");
    }

   function demo4() {
       alert("调用2...");
   }

    demo4(10, 20);
    demo4();

</script>
 
会显示二次下面的图片：
 
 
19、匿名函数
 
匿名函数是没有名字的函数
 
function(形式参数){函数体}
调用方式：将匿名函数赋值给一个变量，通过变量名调用函数
定义函数并赋值给变量：var fn = function(形式参数){函数体}
调用函数：fn(实际参数);
 
演示：
 
<script type="text/javascript">

    // 匿名函数 : 没有名称的函数
    var func = function(i, u) {
        alert(i + " love " + u);
    }

    // 调用函数 :
   func("柳岩", "小白");//显示柳岩love小白

</script>
 
20、案例-轮播图
 
说明1 : script 标签需要放在 body 标签之后.

说明2 : window.setInterval(“字符串函数名称()”, 时间毫秒数);

说明3 : window.setInterval(函数名称, 时间毫秒数);

说明4 : window.setInterval(匿名函数, 时间毫秒数);            推荐使用
 
<head>
    <meta charset="UTF-8">
    <title>轮播图</title>

    <style>

        div {
            width: 80%;
            margin: 50px auto;
        }

        img {
            width: 100%;
        }

    </style>

</head>
<body>
    <div class="container">
        <img src="../img/01.jpg" alt="图片">
    </div>
</body>
 
实现一：
 
<script>

    // 需求 : 动态获取页面中的 img 标签, 然后修改 img 标签的 src 属性.
    // 1. 获取 img 标签
    var img = document.getElementById("img");
    // alert(img);

    // 定义一个变量
    var count = 1;

    // 1.2 定义一个函数
    function changeImageSrc() {
        count++;
        img.src = "../img/0"+count+".jpg";

        // 判断
        if (count == 8) {
            count = 0;
        }
    }

    // 2. 循环切换图片
    // window.setInterval(函数, 时间毫秒); 在指定的时间毫秒间隔, 不断调用第一个参数传入的函数.
    // 调用方式一 :
    // window.setInterval("changeImageSrc()", 1000);
    // 调用方式二 :
    window.setInterval(changeImageSrc, 1000);

</script>
 
实现二：
 
<script>

    // 需求 : 动态获取页面中的 img 标签, 然后修改 img 标签的 src 属性.
    // 1. 获取 img 标签
    var img = document.getElementById("img");
    // alert(img);

    // 定义一个变量
    var count = 1;

    // 2. 循环切换图片
    // window.setInterval(匿名函数, 时间毫秒); 在指定的时间毫秒间隔, 不断调用第一个参数传入的匿名函数.
    window.setInterval(function() {
        count++;
        img.src = "../img/0"+count+".jpg";

        // 判断
        if (count == 8) {
            count = 0;
        }
    }, 1000);

</script>
 
21、js事件
 
21.1、事件概述：
 
事件三要素：
1.	事件源：被监听的html元素（就是这个事件加给谁），就是某个（某些）html标签
2.	事件类型：某类动作，例如点击事件，移入移除事件，敲击键盘事件等
3.	执行指令：事件触发后需要执行的代码，一般使用函数进行封装
语法格式：事件源.事件类型=执行指令
 
21.2、常用的事件：
 
 
案例：
 
<!DOCTYPE html>
<html lang="en">
<head>
    <meta charset="UTF-8">
    <title>事件</title>

    <script>
        // 窗口 : window 对象提供了一个事件类型  onload 页面加载完成事件.
        // 事件源 : window    事件类型 : 页面加载完成事件 (onload)  执行指令: 就是赋值的 function 函数.
        window.onload = function () {

            // 获取页面的 btn 按钮
            var btn = document.getElementById("btn");
            // alert(btn);

            // 给 btn 按钮绑定一个事件 (单击事件 onclick)
            // 事件源 : btn按钮    事件类型 : 单击事件 (onclick)  执行指令: 就是赋值的 function 函数.
            btn.onclick = function () {
                alert("恭喜你, 中了 500 万!");
            }
        }

    </script>

</head>
<body>
    <button id="btn">按钮</button>
</body>
</html>
 
到此基础结束。
 
 
 
==============《轮播图图片路径问题》================
 
 
 
 
 
                                                       =================================
 
                    公众号  关注一波  （一叶知秋博客）不定期分享视频资料
 
                                                       
 
 
 
 

Python 是一种代表简单思想的语言，其语法相对简单，很容易上手。不过，如果就此小视 Python 语法的精妙和深邃，那就大错特错了。本文精心筛选了最能展现 Python 语法之精妙的十个知识点，并附上详细的实例代码。如能在实战中融会贯通、灵活使用，必将使代码更为精炼、高效，同时也会极大提升代码B格，使之看上去更老练，读起来更优雅。
 
1. for - else
 
什么？不是 if 和 else 才是原配吗？No，你可能不知道，else 是个脚踩两只船的家伙，for 和 else 也是一对，而且是合法的。十大装B语法，for-else 绝对算得上南无湾！不信，请看：
 
>>> for i in [1,2,3,4]:
	print(i)
else:
	print(i, '我是else')
	
1
2
3
4
4 我是else
 
如果在 for 和 else 之间（循环体内）有第三者 if 插足，也不会影响 for 和 else 的关系。因为 for 的级别比 if 高，else 又是一个攀附权贵的家伙，根本不在乎是否有 if，以及是否执行了满足 if 条件的语句。else 的眼里只有 for，只要 for 顺利执行完毕，else 就会屁颠儿屁颠儿地跑一遍：
 
>>> for i in [1,2,3,4]:
	if i > 2:
		print(i)
else:
	print(i, '我是else')

3
4
4 我是else
 
那么，如何拆散 for 和 else 这对冤家呢？只有当 for 循环被 break 语句中断之后，才会跳过 else 语句：
 
>>> for i in [1,2,3,4]:
	if i>2:
		print(i)
		break
else:
	print(i, '我是else')

3
 
2. 一颗星(*)和两颗星(**)
 
有没有发现，星(*)真是一个神奇的符号！想一想，没有它，C语言还有啥好玩的？同样，因为有它，Python 才会如此的仪态万方、风姿绰约、楚楚动人！Python 函数支持默认参数和可变参数，一颗星表示不限数量的单值参数，两颗星表示不限数量的键值对参数。
 
我们还是举例说明吧：设计一个函数，返回多个输入数值的和。我们固然可以把这些输入数值做成一个list传给函数，但这个方法，远没有使用一颗星的可变参数来得优雅：
 
>>> def multi_sum(*args):
	s = 0
	for item in args:
		s += item
	return s

>>> multi_sum(3,4,5)
12
 
Python 函数允许同时全部或部分使用固定参数、默认参数、单值（一颗星）可变参数、键值对（两颗星）可变参数，使用时必须按照前述顺序书写。
 
>>> def do_something(name, age, gender='男', *args, **kwds):
	print('姓名：%s，年龄：%d，性别：%s'%(name, age, gender))
	print(args)
	print(kwds)

>>> do_something('xufive', 50, '男', 175, 75, math=99, english=90)
姓名：xufive，年龄：50，性别：男
(175, 75)
{'math': 99, 'english': 90}
 
此外，一颗星和两颗星还可用于列表、元组、字典的解包，看起来更像C语言：
 
>>> a = (1,2,3)
>>> print(a)
(1, 2, 3)
>>> print(*a)
1 2 3
>>> b = [1,2,3]
>>> print(b)
[1, 2, 3]
>>> print(*b)
1 2 3
>>> c = {'name':'xufive', 'age':51}
>>> print(c)
{'name': 'xufive', 'age': 51}
>>> print(*c)
name age
>>> print('name:{name}, age:{age}'.format(**c))
name:xufive, age:51
 
3. 三元表达式
 
熟悉 C/C++ 的程序员，初上手 python 时，一定会怀念经典的三元操作符，因为想表达同样的思想，用python 写起来似乎更麻烦。比如：
 
>>> y = 5
>>> if y < 0:
	print('y是一个负数')
else:
	print('y是一个非负数')

y是一个非负数
 
其实，python 是支持三元表达式的，只是稍微怪异了一点，类似于我们山东人讲话。比如，山东人最喜欢用倒装句：打球去吧，要是不下雨的话；下雨，咱就去自习室。翻译成三元表达式就是：
 
 
 
打球去吧 if 不下雨 else 去自习室
 
 
来看看三元表达式具体的使用：
 
>>> y = 5
>>> print('y是一个负数' if y < 0 else 'y是一个非负数')
y是一个非负数
 
python 的三元表达式也可以用来赋值：
 
>>> y = 5
>>> x = -1 if y < 0 else 1
>>> x
1
 
4. with - as
 
with 这个词儿，英文里面不难翻译，但在 Python 语法中怎么翻译，我还真想不出来，大致上是一种上下文管理协议。作为初学者，不用关注 with 的各种方法以及机制如何，只需要了解它的应用场景就可以了。with 语句适合一些事先需要准备，事后需要处理的任务，比如，文件操作，需要先打开文件，操作完成后需要关闭文件。如果不使用with，文件操作通常得这样：
 
fp = open(r"D:\CSDN\Column\temp\mpmap.py", 'r')
try:
    contents = fp.readlines()
finally:
    fp.close()
 
如果使用 with - as，那就优雅多了：
 
>>> with open(r"D:\CSDN\Column\temp\mpmap.py", 'r') as fp:
	contents = fp.readlines()
 
5. 列表推导式
 
在各种稀奇古怪的语法中，列表推导式的使用频率应该时最高的，对于代码的简化效果也非常明显。比如，求列表各元素的平方，通常应该这样写（当然也有其他写法，比如使用map函数）：
 
>>> a = [1, 2, 3, 4, 5]
>>> result = list()
>>> for i in a:
	result.append(i*i)

>>> result
[1, 4, 9, 16, 25]
 
如果使用列表推导式，看起来就舒服多了：
 
>>> a = [1, 2, 3, 4, 5]
>>> result = [i*i for i in a]
>>> result
[1, 4, 9, 16, 25]
 
事实上，推导式不仅支持列表，也支持字典、集合、元组等对象。有兴趣的话，可以自行研究。我有一篇博文《一行 Python 代码能实现什么丧心病狂的功能？》，里面的例子，都是列表推导式实现的。
 
6. 列表索引的各种骚操作
 
Python 引入负整数作为数组的索引，这绝对是喜大普奔之举。想想看，在C/C++中，想要数组最后一个元素，得先取得数组长度，减一之后做索引，严重影响了思维的连贯性。Python语言之所以获得成功，我个人觉得，在诸多因素里面，列表操作的便捷性是不容忽视的一点。请看：
 
>>> a = [0, 1, 2, 3, 4, 5]
>>> a[2:4]
[2, 3]
>>> a[3:]
[3, 4, 5]
>>> a[1:]
[1, 2, 3, 4, 5]
>>> a[:]
[0, 1, 2, 3, 4, 5]
>>> a[::2]
[0, 2, 4]
>>> a[1::2]
[1, 3, 5]
>>> a[-1]
5
>>> a[-2]
4
>>> a[1:-1]
[1, 2, 3, 4]
>>> a[::-1]
[5, 4, 3, 2, 1, 0]
 
如果说，这些你都很熟悉，也经常用，那么接下来这个用法，你一定会感觉很神奇：
 
>>> a = [0, 1, 2, 3, 4, 5]
>>> b = ['a', 'b']
>>> a[2:2] = b
>>> a
[0, 1, 'a', 'b', 2, 3, 4, 5]
>>> a[3:6] = b
>>> a
[0, 1, 'a', 'a', 'b', 4, 5]
 
7. lambda函数
 
lambda 听起来很高大上，其实就是匿名函数（了解js的同学一定很熟悉匿名函数）。匿名函数的应用场景是什么呢？就是仅在定义匿名函数的地方使用这个函数，其他地方用不到，所以就不需要给它取个阿猫阿狗之类的名字了。下面是一个求和的匿名函数，输入参数有两个，x和y，函数体就是x+y，省略了return关键字。
 
>>> lambda x,y: x+y
<function <lambda> at 0x000001B2DE5BD598>
>>> (lambda x,y: x+y)(3,4) # 因为匿名函数没有名字，使用的时候要用括号把它包起来
 
匿名函数一般不会单独使用，而是配合其他方法，为其他方法提供内置的算法或判断条件。比如，使用排序函数sorted对多维数组或者字典排序时，就可以指定排序规则。
 
>>> a = [{'name':'B', 'age':50}, {'name':'A', 'age':30}, {'name':'C', 'age':40}]
>>> sorted(a, key=lambda x:x['name']) # 按姓名排序
[{'name': 'A', 'age': 30}, {'name': 'B', 'age': 50}, {'name': 'C', 'age': 40}]
>>> sorted(a, key=lambda x:x['age']) # 按年龄排序
[{'name': 'A', 'age': 30}, {'name': 'C', 'age': 40}, {'name': 'B', 'age': 50}]
 
再举一个数组元素求平方的例子，这次用map函数：
 
>>> a = [1,2,3]
>>> for item in map(lambda x:x*x, a):
	print(item, end=', ')

1, 4, 9, 
 
8. yield 以及生成器和迭代器
 
yield 这词儿，真不好翻译，翻词典也没用。我干脆就读作“一爱得”，算是外来词汇吧。要理解 yield，得先了解 generator（生成器）。要了解generator，得先知道 iterator（迭代器）。哈哈哈，绕晕了吧？算了，我还是说白话吧。
 
话说py2时代，range()返回的是list，但如果range(10000000)的话，会消耗大量内存资源，所以，py2又搞了一个xrange()来解决这个问题。py3则只保留了xrange()，但写作range()。xrange()返回的就是一个迭代器，它可以像list那样被遍历，但又不占用多少内存。generator（生成器）是一种特殊的迭代器，只能被遍历一次，遍历结束，就自动消失了。总之，不管是迭代器还是生成器，都是为了避免使用list，从而节省内存。那么，如何得到迭代器和生成器呢？
 
python内置了迭代函数 iter，用于生成迭代器，用法如下：
 
>>> a = [1,2,3]
>>> a_iter = iter(a)
>>> a_iter
<list_iterator object at 0x000001B2DE434BA8>
>>> for i in a_iter:
	print(i, end=', ')

1, 2, 3, 
 
yield 则是用于构造生成器的。比如，我们要写一个函数，返回从0到某正整数的所有整数的平方，传统的代码写法是这样的：
 
>>> def get_square(n):
	result = list()
	for i in range(n):
		result.append(pow(i,2))
	return result

>>> print(get_square(5))
[0, 1, 4, 9, 16]
 
但是如果计算1亿以内的所有整数的平方，这个函数的内存开销会非常大，这是 yield 就可以大显身手了：
 
>>> def get_square(n):
	for i in range(n):
		yield(pow(i,2))

>>> a = get_square(5)
>>> a
<generator object get_square at 0x000001B2DE5CACF0>
>>> for i in a:
	print(i, end=', ')

0, 1, 4, 9, 16, 
 
如果再次遍历，则不会有输出了。
 
9. 装饰器
 
刚弄明白迭代器和生成器，这又来个装饰器，Python 咋这么多器呢？的确，Python 为我们提供了很多的武器，装饰器就是最有力的武器之一。装饰器很强大，我在这里尝试从需求的角度，用一个简单的例子，说明装饰器的使用方法和制造工艺。
 
假如我们需要定义很多个函数，在每个函数运行的时候要显示这个函数的运行时长，解决方案有很多。比如，可以在调用每个函数之前读一下时间戳，每个函数运行结束后再读一下时间戳，求差即可；也可以在每个函数体内的开始和结束位置上读时间戳，最后求差。不过，这两个方法，都没有使用装饰器那么简单、优雅。下面的例子，很好地展示了这一点。
 
>>> import time
>>> def timer(func):
	def wrapper(*args,**kwds):
		t0 = time.time()
		func(*args,**kwds)
		t1 = time.time()
		print('耗时%0.3f'%(t1-t0,))
	return wrapper

>>> @timer
def do_something(delay):
	print('函数do_something开始')
	time.sleep(delay)
	print('函数do_something结束')

	
>>> do_something(3)
函数do_something开始
函数do_something结束
耗时3.077
 
timer() 是我们定义的装饰器函数，使用@把它附加在任何一个函数（比如do_something）定义之前，就等于把新定义的函数，当成了装饰器函数的输入参数。运行 do_something() 函数，可以理解为执行了timer(do_something) 。细节虽然复杂，不过这么理解不会偏差太大，且更易于把握装饰器的制造和使用。
 
10. 巧用断言assert
 
所谓断言，就是声明表达式的布尔值必须为真的判定，否则将触发 AssertionError 异常。严格来讲，assert是调试手段，不宜使用在生产环境中，但这不影响我们用断言来实现一些特定功能，比如，输入参数的格式、类型验证等。
 
>>> def i_want_to_sleep(delay):
	assert(isinstance(delay, (int,float))), '函数参数必须为整数或浮点数'
	print('开始睡觉')
	time.sleep(delay)
	print('睡醒了')

	
>>> i_want_to_sleep(1.1)
开始睡觉
睡醒了
>>> i_want_to_sleep(2)
开始睡觉
睡醒了
>>> i_want_to_sleep('2')
Traceback (most recent call last):
  File "<pyshell#247>", line 1, in <module>
    i_want_to_sleep('2')
  File "<pyshell#244>", line 2, in i_want_to_sleep
    assert(isinstance(delay, (int,float))), '函数参数必须为整数或浮点数'
AssertionError: 函数参数必须为整数或浮点数
 
后记
 
近期有很多朋友通过私信咨询有关Python学习问题。为便于交流，我在CSDN的app上创建了“Python作业辅导”大本营，面向Python初学者，为大家提供咨询服务、辅导Python作业。欢迎有兴趣的同学使用微信扫码加入。
 
 
从博客到公众号，每一篇、每一题、每一句、每一行代码，都坚持原创，绝不复制抄袭，这是我坚守的原则。如果喜欢，请关注我的微信公众号“Python作业辅导员”。
 

 
利用BP神经网络进行函数拟合
 
摘要
关键词
问题描述
算法设计
结果分析与讨论
结论
Python源代码

 
摘要
 
数据拟合是在假设模型结构已知的条件下最优确定模型中未知参数使预测值与数据吻合度最高，本文选取线性项加激活函数组成一个非线性模型，利用神经网络算法最优确定模型中的未知参数，利用随机搜索的方式确定函数模型，从而达到很好的拟合效果
 
关键词
 
BP神经网络 随机搜索 随机重启 参数优化 数据拟合 RELU
 
问题描述
 
数据拟合问题普遍存在，拟合问题本质上是在假设模型结构已知的条件下最优确定模型中未知参数以使得模型预测与数据的吻合度最高，即数据拟合问题往往描述为一个参数优化问题。
 复杂工业过程对于模型精度的要求，线性模型往往不能满足。因此模型结构假设为非线性更为合理。此处我们假设模型结构为：
 
 
算法设计
 
BP神经网络是一种按照误差逆向传播训练的多层前馈神经网络。神经网络理论上可以拟合任意曲线，这一点已经得到了严格的数学证明。
 
三层神经网络模型 
 通常一个多层神经网络由L层构成，其中有1层输出层，1层输入层，L-2层隐藏层。输入层是神经网络的第一层，表示一列矩阵或多列矩阵的输入。输出层是神经网络的最后一层，表示网络的输出结果，通常是一列矩阵。隐藏层有L-2层，表示每一层神经元通过前向传播算法计算的结果矩阵。
 在本程序中，采用3层神经网络。输入矩阵X=[X1,X2]，题目中给出的模型需要对输入矩阵X进行增广，然后乘以参数，其实相当于神经网络中的偏置项bi，i=1，2。因此在本程序中无需对输入矩阵进行增广。wi，wi, i=1，2；bi，i=1，2分别是输入层与隐藏层之间，隐藏层与输出层之间的连接权重和偏置项。设，n=1，i=1，2，3，…，M，表示隐藏层的第i个神经元的输出。
激活函数
 本程序中采用的激活函数为RELU函数，即函数模型中的，目的是去除整个神经网络输出的线性化，使得整个神经网络模型呈非线性化。
损失函数
 本程序中采用的损失函数为MSE（均方误差），利用均方误差和激活函数的导数来更新权重和偏置。
 
 前向传播算法是指依次向前计算相邻隐藏层之间的连接输出，直到模型的最终输出值。其特点作用于相邻层的两个神经元之间的计算，且前一层神经元的输出是后一层的神经元的输入。
 设对于第n层的第i个神经元，有n-1层的M（M为超参数）个神经元与该神经元有突触相连，则第n层第i个神经元的输入为：
 第n层的第i个神经元的输出为：
反向传播算法
 结合前向传播的两个式子，得到第n层第i个神经元的输入与第n-1层第i个神经元的输出的关系为：
梯度下降算法
 得到每一个隐藏层的连接权重和偏置项的梯度后，利用学习率和梯度下降算法更新每一层的连接权重和偏置项：
学习率更新策略
 在配合梯度下降优化的过程中，如果学习率设置过大，则容易导致模型过拟合；如果设置过小，会使得模型优化的速度变得很缓慢。为此加入衰减因子和学习次数来计算模型每次学习的学习率：
 
归一化与反归一化
 
 
随机重启算法
 为了防止更新参数时陷入局部极小，采用随机重启的方式更换初始参数状态。
超参数M的确定
 本程序的超参数M的确定方法为随机搜索法，最终确定M的取值为20。
编程环境和程序主要函数说明
 全部内容均在JetBrains发布的PyCharm社区版（版本号2019.2.5）编程环境中完成，使用的语言为Python，解释器为Python3.8。
 
#产生数据，并将产生的数据方阵降维，方便计算处理
 def init(inpit_n_row):
 
#激活函数
 def relu(x):
 
#激活函数RELU的导数
 def d_relu(x):
 
#归一化数据
 def normalize(data):
 
#反归一化数据
 def d_normalize(norm_data, data):
 
#计算损失函数：平方损失函数
 def quadratic_cost(y_, y):
 
#评价函数RSSE
 def rsse(y_predict, y):
 
#前向传播算法
 def prediction(l0, W, B):
 
#反向传播算法：根据损失函数优化各个隐藏层的权重
 def optimizer(Layers, W, B, y, learn_rate):
 
#训练BP神经网络
 def train(X, y, W, B, method, learn_rate):
 
#拟合曲面可视化
 def visualize(y, inpit_n_row, input_n_col, hidden_n_1):
 
#为了解决陷入局部极小值，随机重启
 def random_restart():
 
#main（）函数
 if name == ‘main’:
 
结果分析与讨论
 

 
 
 
 
 对于3232的训练集，需要几千次的迭代，即可使模型的RSSE值降到0.1以下，需要10000-32000次左右的迭代，即可使模型的RSSE值降到0.001以下；对于1010的测试集，需要30-90次的迭代即可使其RSSE值降到0.1以下，需要200-300次左右的迭代，即可使其的RSSE值降到0.001以下。
 (2)抗噪测试
 加入高斯白噪声：a = (np.random.random() - 0.5)/5
 
 
 加入野值：
 b = （np.random.randint(0, 9) - 0.5）/ 9
 post = np.random.randint(0, inpit_n_row - 1)
 y[post] += b
 
 
 由此可见，模型的抗噪能力良好。
 
结论
 
神经网络具有实现任何复杂非线性映射的功能。
BP神经网络的的学习速度慢，因其本质上是梯度下降法，必然会出现锯齿现象。
随机重启、模拟退火这些算法可以有效地解决陷入局部极值的问题。
 
Python源代码
 
import numpy as np
import matplotlib.pyplot as plt
from mpl_toolkits.mplot3d import Axes3D

plt.rcParams['axes.unicode_minus'] = False
plt.rcParams['font.sans-serif'] = ['SimHei']


#产生数据，并将产生的数据方阵降维，方便计算处理
def init(inpit_n_row):
    X1 = np.linspace(-2, 2, int(inpit_n_row**0.5))
    X2 = np.linspace(-2, 2, int(inpit_n_row**0.5))
    X1, X2 = np.meshgrid(X1, X2)
    X1 = X1.reshape(-1)
    X2 = X2.reshape(-1)
    x, y = [], []
    for i in range(inpit_n_row):
        # 增加高斯白噪声
        #a = np.random.random() - 0.5
        #a /= 5
        x.append([X1[i], X2[i]])
        Y = (1 + np.sin(2 * X1[i] + 3 * X2[i])) / (3.5 + np.sin(X1[i] - X2[i])) # + a
        y.append(Y)
    # 增加野值
    '''b = np.random.randint(0, 9) - 0.5
    b /= 9
    post = np.random.randint(0, inpit_n_row - 1)
    y[post] += b'''
    x = np.array(x)
    y = np.array([y]).T
    return x,y


# 激活函数
def relu(x):
    return np.maximum(0,x)

# 激活函数RELU的导数
def d_relu(x):
    x[x<0] = 0
    return x


# 归一化数据
def normalize(data):
    data_min, data_max = data.min(), data.max()
    data = (data - data_min) / (data_max - data_min)
    return data


# 反归一化数据
def d_normalize(norm_data, data):
    data_min, data_max = data.min(), data.max()
    return norm_data * (data_max - data_min) + data_min


# 计算损失函数：平方损失函数
def quadratic_cost(y_, y):
    inpit_n_row = len(y)
    return np.sum(1 / inpit_n_row * np.square(y_ - y))


# 评价函数RSSE
def rsse(y_predict, y):
    y_ = np.mean(y)
    return np.sum(np.square(y_predict - y))/np.sum(np.square(y-y_))


# 前向传播算法
def prediction(l0, W, B):
    Layers = [l0]
    for i in range(len(W)):
        Layers.append(relu(x=Layers[-1].dot(W[i]) + B[i]))
    return Layers


# 反向传播算法：根据损失函数优化各个隐藏层的权重
def optimizer(Layers, W, B, y, learn_rate):
    l_error_arr = [(y - Layers[-1]) * d_relu(x=Layers[-1])]
    for i in range(len(W) - 1, 0, -1):
        l_error_arr.append(l_error_arr[-1].dot(W[i].T) * d_relu(x=Layers[i]))
    j = 0  # l_delta_arr = [err3, err2, err1]
    for i in range(len(W) - 1, -1, -1):
        W[i] += learn_rate * Layers[i].T.dot(l_error_arr[j])  # W3 += h2 * err3
        B[i] += learn_rate * l_error_arr[j]  # B3 += err3
        j += 1


# 训练BP神经网络
def train(X, y, W, B, method, learn_rate):
    #norm_X, norm_y = normalize(data=X), normalize(data=y)  # 归一化处理
    norm_X = X
    norm_y = y  # 由于测试模型无负值，无需归一化处理，可极大提高效率

    #加了噪声之后，需降低精度要求，降低至0.1即可
    end_loss = 0.001
    step_arr, loss_arr, rsse_arr = [], [], []
    step = 1
    if method == '训练集':
        error = '偏差'
    else:
        error = '方差'
    while True:
        Layers = prediction(l0=norm_X, W=W, B=B)
        rsse_now = rsse(y_predict=Layers[-1], y=norm_y)
        learn_rate_decay = learn_rate # * 1.0 / (1 + step * 0.001)
        optimizer(Layers=Layers, W=W, B=B, y=y, learn_rate=learn_rate_decay)
        cur_loss = quadratic_cost(y_=Layers[-1], y=norm_y)
        if step % 1000 == 0:
            step_arr.append(step)
            loss_arr.append(cur_loss)
            rsse_arr.append(rsse_now)
            print('经过{}次迭代，{}当前{}为{}，RSSE为{}'.format(step, method, error, cur_loss, rsse_now))
        if rsse_now < end_loss:
            # prediction_ys = d_normalize(norm_data=Layers[-1], data=y)  # 反归一化结果
            print('经过{}次迭代，{}最终{}为{}，RSSE为{}'.format(step, method, error, cur_loss, rsse_now))
            return 0, Layers[-1]
        if len(rsse_arr) >= 2 and rsse_arr[-2] - rsse_arr[-1] < 1e-5 or step > 50000:
            print('此初始权重可能导致算法陷入局部极值，故随机重启，重新迭代')
            return -1, []
        step += 1


# 拟合曲面可视化
def visualize(y, inpit_n_row, input_n_col, hidden_n_1):
    z = []
    for i in y:
        for j in i:
            z.append(j)
    z = np.array(z).reshape(int(inpit_n_row**0.5), int(inpit_n_row**0.5))
    # 代入训练好的模型测试
    flag = -1
    while flag == -1:
        np.random.seed(random_restart())
        # 产生测试集
        test_n_row = 100
        x_test, y_test = init(test_n_row)
        W1 = np.random.randn(input_n_col, hidden_n_1) / np.sqrt(test_n_row)
        b1 = np.zeros((test_n_row, hidden_n_1))
        # 输出层权重矩阵
        W2 = np.random.randn(hidden_n_1, 1) / np.sqrt(test_n_row)
        b2 = np.zeros((test_n_row, 1))
        w, b = [W1, W2], [b1, b2]
        flag, y_test = train(x_test, y_test, w, b, '测试集', learn_rate=0.15)
    z_test = []
    for i in y_test:
        for j in i:
            z_test.append(j)
    z_test = np.array(z_test).reshape(int(test_n_row ** 0.5), int(test_n_row ** 0.5))
    # 拟合曲面可视化
    X1 = np.linspace(-2, 2, int(inpit_n_row**0.5))
    X2 = np.linspace(-2, 2, int(inpit_n_row**0.5))
    X1, X2 = np.meshgrid(X1, X2)
    Z = (1 + np.sin(2 * X1 + 3 * X2)) / (3.5 + np.sin(X1 - X2))
    fig = plt.figure()
    ax = Axes3D(fig)
    # 画出真实函数
    ax.set_xlabel('X1')
    ax.set_ylabel('X2')
    ax.set_zlabel('y')
    ax.plot_surface(X1, X2, Z, color='red')
    # 画出预测函数
    fig = plt.figure()
    ax = Axes3D(fig)
    ax.set_xlabel('X1')
    ax.set_ylabel('X2')
    ax.set_zlabel('y_predict')
    ax.plot_surface(X1, X2, z, color='blue')
    # 画出测试结果
    X1 = np.linspace(-2, 2, int(test_n_row ** 0.5))
    X2 = np.linspace(-2, 2, int(test_n_row ** 0.5))
    X1, X2 = np.meshgrid(X1, X2)
    fig = plt.figure()
    ax = Axes3D(fig)
    ax.set_xlabel('X1')
    ax.set_ylabel('X2')
    ax.set_zlabel('y_test')
    ax.plot_surface(X1, X2, z_test, color='yellow')
    plt.show()


# 为了解决陷入局部极小值，随机重启
def random_restart():
    return np.random.randint(0, 23768)


if __name__ == '__main__':
    # 样本点个数
    inpit_n_row = 1024
    # 输入维度
    input_n_col = 2
    # 神经元个数
    hidden_n_1 = 20
    flag = -1
    while flag == -1:
        np.random.seed(random_restart())
        x, y = init(inpit_n_row)
        # 第一个隐藏层权重矩阵
        W1 = np.random.randn(input_n_col, hidden_n_1) / np.sqrt(inpit_n_row)
        b1 = np.zeros((inpit_n_row, hidden_n_1))
        # 输出层权重矩阵
        W2 = np.random.randn(hidden_n_1, 1) / np.sqrt(inpit_n_row)
        b2 = np.zeros((inpit_n_row, 1))
        W, B = [W1, W2], [b1, b2]
        flag, y = train(x, y, W, B, '训练集', learn_rate=0.001)  # 开始训练BP神经网络
    visualize(y, inpit_n_row, input_n_col, hidden_n_1)