python基础之函数

 

python 函数

函数是组织好的，可重复使用的，用来实现单一，或相关联功能的代码段。

函数能提高应用的模块性，和代码的重复利用率。你已经知道Python提供了许多内建函数，比如print()。但你也可以自己创建函数，这被叫做用户自定义函数。

---

定义一个函数

在Python中，定义一个函数要使用def语句，依次写出函数名、括号、括号中的参数和冒号:，然后，在缩进块中编写函数体，函数的返回值用return语句返回。

函数式编程和面向过程编程的区别：

• 函数式：将某功能代码封装到函数中，日后便无需重复编写，仅调用函数即可
• 面向对象：对函数进行分类和封装，让开发“更快更好更强...”

你可以定义一个由自己想要功能的函数，以下是简单的规则：

• 函数代码块以 def 关键词开头，后接函数标识符名称和圆括号()。
• 任何传入参数和自变量必须放在圆括号中间。圆括号之间可以用于定义参数。
• 函数的第一行语句可以选择性地使用文档字符串—用于存放函数说明。
• 函数内容以冒号起始，并且缩进。
• return [表达式] 结束函数，选择性地返回一个值给调用方。不带表达式的return相当于返回 None。

语法

def functionname( parameters ):
   "函数_文档字符串"
   function_suite
   return [expression]

 

默认情况下，参数值和参数名称是按函数声明中定义的的顺序匹配起来的。

请注意，函数体内部的语句在执行时，一旦执行到return时，函数就执行完毕，并将结果返回。因此，函数内部通过条件判断和循环可以实现非常复杂的逻辑。

如果没有return语句，函数执行完毕后也会返回结果，只是结果为None。

return None可以简写为return。

定义和使用

 

def 函数名(参数):
       
    ...
    函数体
    ...
    返回值

 

 

函数的定义主要有如下要点：

• def：表示函数的关键字
• 函数名：函数的名称，日后根据函数名调用函数
• 函数体：函数中进行一系列的逻辑计算，如：发送邮件、计算出 [11,22,38,888,2]中的最大数等...
• 参数：为函数体提供数据
• 返回值：当函数执行完毕后，可以给调用者返回数据。

 

返回值

函数是一个功能块，该功能到底执行成功与否，需要通过返回值来告知调用者。

实例

以下为一个简单的Python函数，它将一个字符串作为传入参数，再打印到标准显示设备上。

def printme( str ):
   "打印传入的字符串到标准显示设备上"
   print str
   return

 

空函数

如果想定义一个什么事也不做的空函数，可以用pass语句：

def nop():
    pass

 pass语句什么都不做，那有什么用？实际上pass可以用来作为占位符，比如现在还没想好怎么写函数的代码，就可以先放一个pass，让代码能运行起来。

小结

定义函数时，需要确定函数名和参数个数；

如果有必要，可以先对参数的数据类型做检查；

函数体内部可以用return随时返回函数结果；

函数执行完毕也没有return语句时，自动return None。

函数可以同时返回多个值，但其实就是一个tuple。

 

>>> def my_fun(): ... print "I am coding." ... return ... print "I finished." ... >>> my_fun() I am coding. 

看出玄机了吗？在函数中，本来有两个print语句，但是中间插入了一个return，仅仅是一个return。当执行函数的时候，只执行了第一个print语句，第二个并没有执行。这是因为第一个之后，遇到了return，它告诉函数要返回，即中断函数体内的流程，离开这个函数。结果第二个print就没有被执行。所以，return在这里就有了一个作用，结束正在执行的函数，有点类似循环中的break的作用。

函数调用

定义一个函数只给了函数一个名称，指定了函数里包含的参数，和代码块结构。

这个函数的基本结构完成以后，你可以通过另一个函数调用执行，也可以直接从Python提示符执行。

如下实例调用了printme（）函数：

#!/usr/bin/python
# -*- coding: UTF-8 -*-
 
# 定义函数
def printme( str ):
   "打印任何传入的字符串"
   print str;
   return;
 
# 调用函数
printme("我要调用用户自定义函数!");
printme("再次调用同一函数");

 以上实例输出结果：

我要调用用户自定义函数!
再次调用同一函数

 

参数和变量

参数

在别的程序员嘴里，你或许听说过“形参”、“实参”、“参数”等名词，到底指什么呢？

在定义函数的时候（def来定义函数，称为def语句），函数名后面的括号里如果有变量，它们通常被称为“形参”。调用函数的时候，给函数提供的值叫做“实参”，或者“参数”。

其实，根本不用区分这个，因为没有什么意义，只不过类似孔乙己先生知道茴香豆的茴字有多少种写法罢了。

在本教程中，把那个所谓实参，就称之为值（或者数据、或者对象），形参就笼统称之为参数（似乎不很合理，但是接近数学概念）。随着你敲代码的实践越多，或许会对各种参数概念有深入理解。

比较参数和变量

在不同的参数名称面前，糊涂也罢、明白也罢，对写程序的干扰不大。不过，对于变量和参数，这两个就不能算糊涂账了。不过它们的确容易让把人搞糊涂了。

在数学的函数中y = 3x + 2,那个x叫做参数，也可以叫做变量。但是，在编程语言的函数中，与此有异。

先参考一段来自微软网站的比较高度抽象，而且意义涵盖深远的说明。我摘抄过来，看官读一读，是否理解，虽然是针对VB而言的，一样有启发。

参数和变量之间的差异 (Visual Basic)

多数情况下，过程必须包含有关调用环境的一些信息。执行重复或共享任务的过程对每次调用使用不同的信息。此信息包含每次调用过程时传递给它的变量、常量和表达式。

若要将此信息传递给过程，过程先要定义一个形参，然后调用代码将一个实参传递给所定义的形参。 您可以将形参当作一个停车位，而将实参当作一辆汽车。 就像一个停车位可以在不同时间停放不同的汽车一样，调用代码在每次调用过程时可以将不同的实参传递给同一个形参。

形参表示一个值，过程希望您在调用它时传递该值。

当您定义 Function 或 Sub 过程时，需要在紧跟过程名称的括号内指定形参列表。对于每个形参，您可以指定名称、数据类型和传入机制（ByVal (Visual Basic) 或 ByRef (Visual Basic)）。您还可以指示某个形参是可选的。这意味着调用代码不必传递它的值。

每个形参的名称均可作为过程内的局部变量。形参名称的使用方法与其他任何变量的使用方法相同。

实参表示在您调用过程时传递给过程形参的值。调用代码在调用过程时提供参数。

调用 Function 或 Sub 过程时，需要在紧跟过程名称的括号内包括实参列表。每个实参均与此列表中位于相同位置的那个形参相对应。

与形参定义不同，实参没有名称。每个实参就是一个表达式，它包含零或多个变量、常数和文本。求值的表达式的数据类型通常应与为相应形参定义的数据类型相匹配，并且在任何情况下，该表达式值都必须可转换为此形参类型。

看官如果硬着头皮看完这段引文，发现里面有几个关键词：参数、变量、形参、实参。本来想弄清楚参数和变量，结果又冒出另外两个东东，更混乱了。请稍安勿躁，本来这段引文就是有点多余，但是，之所以引用，就是让列位开阔一下眼界，在编程业界，类似的东西有很多名词。下次听到有人说这些，不用害怕啦，反正自己听过了。

在Python中，没有这么复杂。

看完上面让人晕头转向的引文之后，再看下面的代码，就会豁然开朗了。

>>> def add(x): #x是参数，准确说是形参 ... a = 10 #a是变量 ... return a+x #x就是那个形参作为变量，其本质是要传递赋给这个函数的值 ... >>> x = 3 #x是变量，只不过在函数之外 >>> add(x) #这里的x是参数，但是它由前面的变量x传递对象3 13 >>> add(3) #把上面的过程合并了 13 

至此，是否清楚了一点点。当然，我所表述不正确之处或者理解错误之处，请不吝赐教，小可作揖感谢。

其实没有那么复杂。关键要理解函数名括号后面的东东（管它什么参呢）的作用是传递值。所以，那个参数的作用本质上就是一个“占位符”，当调用一个函数的时候，并不是赋值了一份参数的值来替换占位符，比如add(x)，并没有用3来替换原来的占位符，而是把占位符指向了变量，进而指向了对象。换个角度说，就是通过一连串的接力动作，把对象传给了函数。这样说来，你就可以在函数内部改变那个对象了。

>>> def foo(lst): ... lst.append(99) ... return lst ... >>> x = [1, 3, 5] >>> y = foo(x) >>> y [1, 3, 5, 99] >>> x [1, 3, 5, 99] >>> id(x) 3075464588L >>> id(y) 3075464588L 

结合前面学习过的列表能够被原地修改知识，加上刚才说的参数特点，你是不是能理解上面的操作呢？

函数的有三中不同的参数：

• 普通参数
• 默认参数
• 动态参数

普通参数：

# ######### 定义函数 ######### 

# name 叫做函数func的形式参数，简称：形参
def func(name):
    print name

# ######### 执行函数 ######### 
#  'wupeiqi' 叫做函数func的实际参数，简称：实参
func('wupeiqi')

普通参数

 默认参数： 

def func(name, age = 18):
    
    print "%s:%s" %(name,age)

# 指定参数
func('wupeiqi', 19)
# 使用默认参数
func('alex')

注：默认参数需要放在参数列表最后

默认参数

 

动态参数：

def func(*args):

    print args


# 执行方式一
func(11,33,4,4454,5)

# 执行方式二
li = [11,2,2,3,3,4,54]
func(*li)

动态参数

 

def func(*args):

    print args


# 执行方式一
func(11,33,4,4454,5)

# 执行方式二
li = [11,2,2,3,3,4,54]
func(*li)

动态参数

 

def func(*args, **kwargs):

    print args
    print kwargs

 

按值传递参数和按引用传递参数

定义函数的时候，我们把参数的名字和位置确定下来，函数的接口定义就完成了。对于函数的调用者来说，只需要知道如何传递正确的参数，以及函数将返回什么样的值就够了，函数内部的复杂逻辑被封装起来，调用者无需了解。

Python的函数定义非常简单，但灵活度却非常大。除了正常定义的必选参数外，还可以使用默认参数、可变参数和关键字参数，使得函数定义出来的接口，不但能处理复杂的参数，还可以简化调用者的代码。

所有参数（自变量）在Python里都是按引用传递。如果你在函数里修改了参数，那么在调用这个函数的函数里，原始的参数也被改变了。例如：

#!/usr/bin/python
# -*- coding: UTF-8 -*-
 
# 可写函数说明
def changeme( mylist ):
   "修改传入的列表"
   mylist.append([1,2,3,4]);
   print "函数内取值: ", mylist
   return
 
# 调用changeme函数
mylist = [10,20,30];
changeme( mylist );
print "函数外取值: ", mylist

 传入函数的和在末尾添加新内容的对象用的是同一个引用。故输出结果如下：

函数内取值:  [10, 20, 30, [1, 2, 3, 4]]
函数外取值:  [10, 20, 30, [1, 2, 3, 4]]

 

参数

以下是调用函数时可使用的正式参数类型：

• 必备参数
• 关键字参数
• 默认参数
• 不定长参数

设置默认参数时，有几点要注意：

一是必选参数在前，默认参数在后，否则Python的解释器会报错（思考一下为什么默认参数不能放在必选参数前面）；

二是如何设置默认参数。

当函数有多个参数时，把变化大的参数放前面，变化小的参数放后面。变化小的参数就可以作为默认参数。

使用默认参数有什么好处？最大的好处是能降低调用函数的难度

必备参数

必备参数须以正确的顺序传入函数。调用时的数量必须和声明时的一样。

调用printme()函数，你必须传入一个参数，不然会出现语法错误：

#!/usr/bin/python
# -*- coding: UTF-8 -*-
 
#可写函数说明
def printme( str ):
   "打印任何传入的字符串"
   print str;
   return;
 
#调用printme函数
printme();

 以上实例输出结果：

Traceback (most recent call last):
  File "test.py", line 11, in <module>
    printme();
TypeError: printme() takes exactly 1 argument (0 given)

 

关键字参数

可变参数允许你传入0个或任意个参数，这些可变参数在函数调用时自动组装为一个tuple。而关键字参数允许你传入0个或任意个含参数名的参数，这些关键字参数在函数内部自动组装为一个dict。

关键字参数和函数调用关系紧密，函数调用使用关键字参数来确定传入的参数值。

使用关键字参数允许函数调用时参数的顺序与声明时不一致，因为 Python 解释器能够用参数名匹配参数值。

以下实例在函数 printme() 调用时使用参数名：

#!/usr/bin/python
# -*- coding: UTF-8 -*-
 
#可写函数说明
def printme( str ):
   "打印任何传入的字符串"
   print str;
   return;
 
#调用printme函数
printme( str = "My string");

 以上实例输出结果：

My string

 下例能将关键字参数顺序不重要展示得更清楚：

#!/usr/bin/python
# -*- coding: UTF-8 -*-
 
#可写函数说明
def printinfo( name, age ):
   "打印任何传入的字符串"
   print "Name: ", name;
   print "Age ", age;
   return;
 
#调用printinfo函数
printinfo( age=50, name="miki" );

 以上实例输出结果：

Name:  miki
Age  50

 对于关键字参数，函数的调用者可以传入任意不受限制的关键字参数。

使用命名关键字参数时，要特别注意，如果没有可变参数，就必须加一个*作为特殊分隔符。如果缺少*，Python解释器将无法识别位置参数和命名关键字参数

缺省参数

调用函数时，缺省参数的值如果没有传入，则被认为是默认值。下例会打印默认的age，如果age没有被传入：

 1 #!/usr/bin/python
 2 # -*- coding: UTF-8 -*-
 3  
 4 #可写函数说明
 5 def printinfo( name, age = 35 ):
 6    "打印任何传入的字符串"
 7    print "Name: ", name;
 8    print "Age ", age;
 9    return;
10  
11 #调用printinfo函数
12 printinfo( age=50, name="miki" );
13 printinfo( name="miki" );

以上实例输出结果：

Name:  miki
Age  50
Name:  miki
Age  35

 

不定长参数

你可能需要一个函数能处理比当初声明时更多的参数。这些参数叫做不定长参数，和上述2种参数不同，声明时不会命名。基本语法如下：

1 def functionname([formal_args,] *var_args_tuple ):
2    "函数_文档字符串"
3    function_suite
4    return [expression]

加了星号（*）的变量名会存放所有未命名的变量参数。选择不多传参数也可。如下实例：

#!/usr/bin/python
# -*- coding: UTF-8 -*-
 
# 可写函数说明
def printinfo( arg1, *vartuple ):
   "打印任何传入的参数"
   print "输出: "
   print arg1
   for var in vartuple:
      print var
   return;
 
# 调用printinfo 函数
printinfo( 10 );
printinfo( 70, 60, 50 );

 以上实例输出结果：

输出:
10
输出:
70
60
50

递归函数

在函数内部，可以调用其他函数。如果一个函数在内部调用自身本身，这个函数就是递归函数。

举个例子，我们来计算阶乘n! = 1 x 2 x 3 x ... x n，用函数fact(n)表示，可以看出：

fact(n) = n! = 1 x 2 x 3 x ... x (n-1) x n = (n-1)! x n = fact(n-1) x n

所以，fact(n)可以表示为n x fact(n-1)，只有n=1时需要特殊处理。

于是，fact(n)用递归的方式写出来就是：

def fact(n):
    if n==1:
        return 1
    return n * fact(n - 1)

 上面就是一个递归函数。可以试试：

>>> fact(1)
1
>>> fact(5)
120
>>> fact(100)
93326215443944152681699238856266700490715968264381621468592963895217599993229915608941463976156518286253697920827223758251185210916864000000000000000000000000

 如果我们计算fact(5)，可以根据函数定义看到计算过程如下：

===> fact(5)
===> 5 * fact(4)
===> 5 * (4 * fact(3))
===> 5 * (4 * (3 * fact(2)))
===> 5 * (4 * (3 * (2 * fact(1))))
===> 5 * (4 * (3 * (2 * 1)))
===> 5 * (4 * (3 * 2))
===> 5 * (4 * 6)
===> 5 * 24
===> 120

 

递归函数的优点是定义简单，逻辑清晰。理论上，所有的递归函数都可以写成循环的方式，但循环的逻辑不如递归清晰。

使用递归函数需要注意防止栈溢出。在计算机中，函数调用是通过栈（stack）这种数据结构实现的，每当进入一个函数调用，栈就会加一层栈帧，每当函数返回，栈就会减一层栈帧。由于栈的大小不是无限的，所以，递归调用的次数过多，会导致栈溢出。

解决递归调用栈溢出的方法是通过尾递归优化，事实上尾递归和循环的效果是一样的，所以，把循环看成是一种特殊的尾递归函数也是可以的。

尾递归是指，在函数返回的时候，调用自身本身，并且，return语句不能包含表达式。这样，编译器或者解释器就可以把尾递归做优化，使递归本身无论调用多少次，都只占用一个栈帧，不会出现栈溢出的情况。

尾递归调用时，如果做了优化，栈不会增长，因此，无论多少次调用也不会导致栈溢出。

遗憾的是，大多数编程语言没有针对尾递归做优化，Python解释器也没有做优化，所以，即使把上面的fact(n)函数改成尾递归方式，也会导致栈溢出。

小结

使用递归函数的优点是逻辑简单清晰，缺点是过深的调用会导致栈溢出。

针对尾递归优化的语言可以通过尾递归防止栈溢出。尾递归事实上和循环是等价的，没有循环语句的编程语言只能通过尾递归实现循环。

Python标准的解释器没有针对尾递归做优化，任何递归函数都存在栈溢出的问题。

 

匿名函数

python 使用 lambda 来创建匿名函数。

• lambda只是一个表达式，函数体比def简单很多。
• lambda的主体是一个表达式，而不是一个代码块。仅仅能在lambda表达式中封装有限的逻辑进去。
• lambda函数拥有自己的命名空间，且不能访问自有参数列表之外或全局命名空间里的参数。
• 虽然lambda函数看起来只能写一行，却不等同于C或C++的内联函数，后者的目的是调用小函数时不占用栈内存从而增加运行效率。

语法

lambda函数的语法只包含一个语句，如下：

lambda [arg1 [,arg2,.....argn]]:expression

 

如下实例：

#!/usr/bin/python
# -*- coding: UTF-8 -*-
 
# 可写函数说明
sum = lambda arg1, arg2: arg1 + arg2;
 
# 调用sum函数
print "相加后的值为 : ", sum( 10, 20 )
print "相加后的值为 : ", sum( 20, 20 )

 以上实例输出结果：

return 语句

return语句[表达式]退出函数，选择性地向调用方返回一个表达式。不带参数值的return语句返回None。之前的例子都没有示范如何返回数值，下例便告诉你怎么做：

#!/usr/bin/python
# -*- coding: UTF-8 -*-
 
# 可写函数说明
def sum( arg1, arg2 ):
   # 返回2个参数的和."
   total = arg1 + arg2
   print "函数内 : ", total
   return total;
 
# 调用sum函数
total = sum( 10, 20 );

 以上实例输出结果：

函数内 :  30

 

小结

Python的函数具有非常灵活的参数形态，既可以实现简单的调用，又可以传入非常复杂的参数。

默认参数一定要用不可变对象，如果是可变对象，程序运行时会有逻辑错误！

要注意定义可变参数和关键字参数的语法：

*args是可变参数，args接收的是一个tuple；

**kw是关键字参数，kw接收的是一个dict。

以及调用函数时如何传入可变参数和关键字参数的语法：

可变参数既可以直接传入：func(1, 2, 3)，又可以先组装list或tuple，再通过*args传入：func(*(1, 2, 3))；

关键字参数既可以直接传入：func(a=1, b=2)，又可以先组装dict，再通过**kw传入：func(**{'a': 1, 'b': 2})。

使用*args和**kw是Python的习惯写法，当然也可以用其他参数名，但最好使用习惯用法。

命名的关键字参数是为了限制调用者可以传入的参数名，同时可以提供默认值。

定义命名的关键字参数在没有可变参数的情况下不要忘了写分隔符*，否则定义的将是位置参数。

变量作用域

一个程序的所有的变量并不是在哪个位置都可以访问的。访问权限决定于这个变量是在哪里赋值的。

变量的作用域决定了在哪一部分程序你可以访问哪个特定的变量名称。两种最基本的变量作用域如下：

• 全局变量
• 局部变量

---

全局变量和局部变量

定义在函数内部的变量拥有一个局部作用域，定义在函数外的拥有全局作用域。

局部变量只能在其被声明的函数内部访问，而全局变量可以在整个程序范围内访问。调用函数时，所有在函数内声明的变量名称都将被加入到作用域中。如下实例：

#!/usr/bin/python
# -*- coding: UTF-8 -*-

total = 0; # 这是一个全局变量
# 可写函数说明
def sum( arg1, arg2 ):
   #返回2个参数的和."
   total = arg1 + arg2; # total在这里是局部变量.
   print "函数内是局部变量 : ", total
   return total;
 
#调用sum函数
sum( 10, 20 );
print "函数外是全局变量 : ", total 

 以上实例输出结果：

函数内是局部变量 :  30
函数外是全局变量 :  0

 

内置函数

Python3版本所有的内置函数：

The Python interpreter has a number of functions and types built into it that are always available. They are listed here in alphabetical order.

		Built-in Functions
abs()	dict()	help()	min()	setattr()
all()	dir()	hex()	next()	slice()
any()	divmod()	id()	object()	sorted()
ascii()	enumerate()	input()	oct()	staticmethod()
bin()	eval()	int()	open()	str()
bool()	exec()	isinstance()	ord()	sum()
bytearray()	filter()	issubclass()	pow()	super()
bytes()	float()	iter()	print()	tuple()
callable()	format()	len()	property()	type()
chr()	frozenset()	list()	range()	vars()
classmethod()	getattr()	locals()	repr()	zip()
compile()	globals()	map()	reversed()	__import__()
complex()	hasattr()	max()	round()
delattr()	hash()	memoryview()	set()

注: 查看3.0版本详细猛击这里      查看2.0版本详细猛击这里

1. abs()　　获取绝对值

1 2 3 4 5 6 7 8 9

>>> abs ( - 10 ) 10 >>> abs ( 10 ) 10 >>> abs ( 0 ) 0 >>> a = - 10 >>> a.__abs__() 10

2. all()　　接受一个迭代器，如果迭代器的所有元素都为真，那么返回True，否则返回False

1 2 3 4 5 6 7 8 9

>>> tmp_1 = [ 'python' , 123 ] >>> all (tmp_1) True >>> tmp_2 = [] >>> all (tmp_2) True >>> tmp_3 = [ 0 ] >>> all (tmp_3) False

3. any()　　接受一个迭代器，如果迭代器里有一个元素为真，那么返回True,否则返回False

4. ascii()　　调用对象的__repr__()方法，获得该方法的返回值.

5. bin(),　6. oct(),  7. hex()  　　三个函数功能为：将十进制数分别转换为2/8/16进制。

8. bool()　　测试一个对象是True还是False.

9. bytes()　　将一个字符串转换成字节类型

1 2 3 4 5 6 7 8

>>> s = 'python' >>> x = bytes(s, encoding = 'utf-8' ) >>> x b 'python' >>> a = '王' >>> s = bytes(a, encoding = 'utf-8' ) >>> s b '\xe7\x8e\x8b'

10. str()　　将字符类型/数值类型等转换为字符串类型

1 2 3 4

>>> str (b '\xe7\x8e\x8b' , encoding = 'utf-8' )  # 字节转换为字符串 '王' >>> str ( 1 )   # 整数转换为字符串 '1'

11. challable()　　判断对象是否可以被调用，能被调用的对象就是一个callables对象，比如函数和带有__call__()的实例。

1 2 3 4 5 6 7 8

>>> callable ( max ) True >>> callable ([ 1 , 2 , 3 ]) False >>> callable ( None ) False >>> callable ( 'str' ) False

12. char()，13. ord()　　查看十进制数对应的ASCII字符/查看某个ASCII对应的十进制数。

1 2 3 4 5 6 7 8 9 10 11

>>> chr ( - 1 ) Traceback (most recent call last):    File "<pyshell#26>" , line 1 , in <module>      chr ( - 1 ) ValueError: chr () arg not in range ( 0x110000 ) >>> chr ( 0 ) '\x00' >>> ord ( '\x00' ) 0 >>> ord ( '7' ) 55

14. classmethod()　　用来指定一个方法为类的方法，由类直接调用执行，只有一个cls参数,执行雷的方法时，自动将调用该方法的类赋值给cls.没有此参数指定的类的方法为实例方法。

1 2 3 4 5 6 7 8 9 10 11 12

class Province:      country = "中国"             def __init__( self , name):          self .name = name             @classmethod      def show( cls ):  # 类方法，由类调用，最少要有一个参数cls，调用的时候这个参数不用传值，自动将类名赋值给cls          print ( cls )        # 调用方法 Province.show()

15. complie()　　将字符串编译成python能识别或可以执行的代码，也可以将文字读成字符串再编译。

1 2 3 4 5 6

compile (source, filename, mode, flags = 0 , dont_inherit = False , optimize = - 1 ) 将source编译为代码或者AST对象。代码对象能过通过 exec 语句来执行或者 eval ()进行求值。 参数source：字符串或者AST（abstract syntax trees）对象。 参数filename：代码文件名称，如果不是从文件读取代码则传递一些可辨认的值。 参数model：指定编译代码的种类。可以指定 'exec' , 'eval' , 'single' 。 参数flag和dont_inherit：这两个参数为可选参数。

1 2 3 4

>>> s  = "print('helloworld')" >>> r = compile (s, "<string>" , "exec" ) >>> r <code object <module> at 0x000001C648038390 , file "<string>" , line 1 >

16. complex()

1 2 3

创建一个值为real + imag * j的复数或者转化一个字符串或数为复数。如果第一个参数是字符串，则不需要指定第二个参数。 参数real： int ， long ， float 或字符串。 参数imag： int ， long ， float 。

17. delattr()　　删除对象的属性

具体查看：python面向对象类的成员中属性的详细介绍

18. dict()　　创建数据字典

1 2 3 4 5 6 7 8 9

>>> a = dict ()  空字典 >>> a {} >>> b = dict (one = 1 , two = 2 ) >>> b { 'one' : 1 , 'two' : 2 } >>> c = dict ({ 'one' : 1 , 'two' : 2 }) >>> c { 'one' : 1 , 'two' : 2 }

19. dir()　　不带参数时返回当前范围内的变量，方法和定义的类型列表，带参数时返回参数的属性，方法列表。

1 2 3 4

>>> dir () [ '__builtins__' , '__doc__' , '__loader__' , '__name__' , '__package__' , '__spec__' , 'li' , 'li1' , 'li2' , 'li_1' ] >>> dir ( list ) [ '__add__' , '__class__' , '__contains__' , '__delattr__' , '__delitem__' , '__dir__' , '__doc__' , '__eq__' , '__format__' , '__ge__' , '__getattribute__' , '__getitem__' , '__gt__' , '__hash__' , '__iadd__' , '__imul__' , '__init__' , '__iter__' , '__le__' , '__len__' , '__lt__' , '__mul__' , '__ne__' , '__new__' , '__reduce__' , '__reduce_ex__' , '__repr__' , '__reversed__' , '__rmul__' , '__setattr__' , '__setitem__' , '__sizeof__' , '__str__' , '__subclasshook__' , 'append' , 'clear' , 'copy' , 'count' , 'extend' , 'index' , 'insert' , 'pop' , 'remove' , 'reverse' , 'sort' ]

20. divmod()　　分别取商和余数

1 2	>>> divmod ( 20 , 6 ) ( 3 , 2 )

21. enumerate()　　返回一个可以枚举的对象，该对象的next()方法将返回一个元组。

1 2 3 4 5 6 7 8

>>> test = [ 'a' , 'b' , 'c' ] >>> for k,v in enumerate (test):      print (k,v)   # 输出结果： 0 a 1 b 2 c

22. eval()　　将字符串str当成有效的表达式来求值并返回计算结果

1 2 3 4 5

>>> s = "1+2*3" >>> type (s) < class 'str' > >>> eval (s) 7

23. exec()　　执行字符串或complie方法编译过的字符串，没有返回值

24. filter()　　过滤器，构造一个序列，等价于[ item for item in iterables if function(item)]，在函数中设定过滤条件，逐一循环迭代器中的元素，将返回值为True时的元素留下，形成一个filter类型数据。

1 2 3 4 5 6 7

filter (function, iterable) 参数function：返回值为 True 或 False 的函数，可以为 None 。 参数iterable：序列或可迭代对象。 >>> def bigerthan5(x): ...     return x > 5 >>> filter (bigerthan5, [ 3 , 4 , 5 , 6 , 7 , 8 ]) [ 6 , 7 , 8 ]

25. float()　　讲一个字符串或整数转换为浮点数。

1 2 3 4 5 6 7 8 9 10 11

>>> float () 0.0 >>> float ( '123' ) 123.0 >>> float ( 1 ) 1.0 >>> float ( 'a' ) Traceback (most recent call last):    File "<pyshell#45>" , line 1 , in <module>      float ( 'a' ) ValueError: could not convert string to float : 'a'

26. format()　　格式化输出字符串，format(value, format_spec)实质上是调用了value的__format__(format_spec)方法。

1 2	>>> "I am {0}, I like {1}!" . format ( "wang" , "moon" )     'I am wang, I like moon!'

27. frozenset()　　创建一个不可修改的集合。

1 2 3 4

frozenset ([iterable]) set 和 frozenset 最本质的区别是前者是可变的，后者是不可变的。当集合对象会被改变时（例如删除，添加元素），只能使用 set ， 一般来说使用fronzet的地方都可以使用 set 。 参数iterable：可迭代对象。

28. getattr()　　获取对象的属性

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20

getattr ( object , name [, defalut]) 获取对象 object 名为name的特性，如果 object 不包含名为name的特性，将会抛出AttributeError异常；如果不包含名为name的特性 且提供default参数，将返回default。 参数 object ：对象 参数name：对象的特性名 参数default：缺省返回值 >>> append = getattr ( list , 'append' ) >>> append <method 'append' of 'list' objects> >>> mylist = [ 3 , 4 , 5 ] >>> append(mylist, 6 ) >>> mylist [ 3 , 4 , 5 , 6 ] >>> method = getattr ( list , 'add' ) Traceback (most recent call last):    File "<stdin>" , line 1 , in <module> AttributeError: type object 'list' has no attribute 'add' >>> method = getattr ( list , 'add' , 'NoMethod' ) >>> method 'NoMethod'

29. globals()　　返回一个描述当前全局变量的字典

1 2 3

>>> a = 1 >>> globals () { '__loader__' : < class '_frozen_importlib.BuiltinImporter' >, 'a' : 1 , '__builtins__' : <module 'builtins' (built - in )>, '__doc__' : None , '__name__' : '__main__' , '__package__' : None , '__spec__' : None }

30. hasattr()

1 2 3 4 5 6 7 8

hasattr ( object ，name) 判断对象 object 是否包含名为name的特性（ hasattr 是通过调用 getattr ( object ，name)）是否抛出异常来实现的。 参数 object ：对象 参数name：特性名称 >>> hasattr ( list , 'append' ) True >>> hasattr ( list , 'add' ) False

31. hash()　　哈希值

1 2 3

hash ( object ) 如果对象 object 为哈希表类型，返回对象 object 的哈希值。哈希值为整数，在字典查找中，哈希值用于快递比价字典的键。 两个数值如果相等，则哈希值也相等。

32. help()　　返回对象的帮助文档

1	调用内建的帮助系统，如果不包含参数，交互式帮助系统将在控制台启动。如果参数为字串，则可以是模块，类，方法等名称，并且帮助页面将会在控制台打印。参数也可以为任意对象

33. id()　　返回对象的内存地址

1 2 3

>>> a = 1 >>> id (a) 1588522800

34. input()　　获取用户输入内容

1 2 3 4 5

num = input ( "请输入一个数字：" ) # 用户输入3 print (num) # 输出结果 3

35. int()　　将一个字符串或数值转换为一个普通整数

1 2 3 4 5 6 7

int ([x[,radix]]) 如果参数是字符串，那么它可能包含符号和小数点。参数radix表示转换的基数（默认是 10 进制）。 它可以是[ 2 , 36 ]范围内的值，或者 0 。如果是 0 ，系统将根据字符串内容来解析。 如果提供了参数radix，但参数x并不是一个字符串，将抛出TypeError异常； 否则，参数x必须是数值（普通整数，长整数，浮点数）。通过舍去小数点来转换浮点数。 如果超出了普通整数的表示范围，一个长整数被返回。 如果没有提供参数，函数返回 0 。

36. isinstance()　　检查对象是否是类的对象，返回True或False

1 2 3 4 5 6

isinstance (obj, cls ) 检查obj是否是类 cls 的对象, 返回 True 或 False class Foo( object ):      pass obj = Foo() isinstance (obj, Foo)

37. issubclass()　　检查一个类是否是另一个类的子类。返回True或False

1 2 3 4 5 6 7 8 9 10

issubclass (sub, super ) 检查sub类是否是 super 类的派生类（子类）。返回 True 或 False   class Foo( object ):      pass     class Bar(Foo):      pass     issubclass (Bar, Foo)

38. iter()　

iter (o[, sentinel]) 返回一个iterator对象。该函数对于第一个参数的解析依赖于第二个参数。 如果没有提供第二个参数，参数o必须是一个集合对象，支持遍历功能（__iter__()方法）或支持序列功能（__getitem__()方法）， 参数为整数，从零开始。如果不支持这两种功能，将处罚TypeError异常。 如果提供了第二个参数，参数o必须是一个可调用对象。在这种情况下创建一个iterator对象，每次调用iterator的 next ()方法来无 参数的调用o，如果返回值等于参数sentinel，触发StopIteration异常，否则将返回该值。

39. len()　　返回对象长度，参数可以是序列类型（字符串，元组或列表）或映射类型（如字典）

40. list()　　列表构造函数。

1 2 3 4

list ([iterable]) list 的构造函数。参数iterable是可选的，它可以是序列，支持编译的容器对象，或iterator对象。 该函数创建一个元素值，顺序与参数iterable一致的列表。如果参数iterable是一个列表，将创建 列表的一个拷贝并返回，就像语句iterables[:]。

41. locals()　　打印当前可用的局部变量的字典

不要修改 locals ()返回的字典中的内容；改变可能不会影响解析器对局部变量的使用。 在函数体内调用 locals ()，返回的是自由变量。修改自由变量不会影响解析器对变量的使用。 不能在类区域内返回自由变量。

42. map()

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17

map (function, iterable,...) 对于参数iterable中的每个元素都应用fuction函数，并将结果作为列表返回。 如果有多个iterable参数，那么fuction函数必须接收多个参数，这些iterable中相同索引处的元素将并行的作为function函数的参数。 如果一个iterable中元素的个数比其他少，那么将用 None 来扩展改iterable使元素个数一致。 如果有多个iterable且function为 None ， map ()将返回由元组组成的列表，每个元组包含所有iterable中对应索引处值。 参数iterable必须是一个序列或任何可遍历对象，函数返回的往往是一个列表( list )。   li = [ 1 , 2 , 3 ] data = map ( lambda x :x * 100 ,li) print ( type (data)) data = list (data) print (data)   运行结果：   < class 'map' > [ 100 , 200 , 300 ]

43. max()　　返回给定元素里最大值

max (iterable [,args...][, key]) 如果只提供iterable参数，函数返回可遍历对象（如：字符串，元组或列表）中最大的非空元素。 如果提供多个参数，那么返回值最大的那个参数。 可选参数key是单参数的排序函数。 如果提供key参数，必须是以命名的形式，如： max (a, b, c, key = fun)

44. meoryview()

45. min()　　返回给定元素里最小值

min (iterable [,args...][, key]) 如果只提供iterable参数，函数返回可遍历对象（如：字符串，元组或列表）中最小的非空元素。 如果提供多个参数，那么返回值最小的那个参数。 可选参数key是单参数的排序函数。 如果提供key参数，必须是以命名的形式，如： max (a, b, c, key = fun)

46. next()　　返回一个可迭代数据结构（如列表）中的下一项

47. object()

1 2	获取一个新的，无特性(geatureless)对象。 Object 是所有类的基类。它提供的方法将在所有的类型实例中共享。 该函数时 2.2 .版本新增， 2.3 版本之后，该函数不接受任何参数。

48. open()　　打开文件

open (filename [, mode [, bufsize]]) 打开一个文件，返回一个 file 对象。 如果文件无法打开，将处罚IOError异常。 应该使用 open ()来代替直接使用 file 类型的构造函数打开文件。 参数filename表示将要被打开的文件的路径字符串； 参数mode表示打开的模式，最常用的模式有： 'r' 表示读文本， 'w' 表示写文本文件， 'a' 表示在文件中追加。 Mode的默认值是 'r' 。 当操作的是二进制文件时，只要在模式值上添加 'b' 。这样提高了程序的可移植性。 可选参数bufsize定义了文件缓冲区的大小。 0 表示不缓冲； 1 表示行缓冲；任何其他正数表示使用该大小的缓冲区； 负数表示使用系统默认缓冲区大小，对于tty设备它往往是行缓冲，而对于其他文件往往完全缓冲。如果参数值被省却。 使用系统默认值。

49. pow()　　幂函数

1 2 3 4 5

r = pow ( 2 , 10 )  # 2的10次方 print (r)                # 输出 1024

50. print()　　输出函数

1 2 3 4

python2中的 print 语句被python3中的 print ()函数取代。 如何限制 print 的默认换行： 1. python2版本下，在 print 输出的最后加一个逗号 ',' 2. python3. 4 以后， print (value, ...,sep = ' ',end=' \n', file = sys.stdout,flush = False ),将end设为空即可。

51. property()

52. range()　　根据需要生成一个指定范围的数字，可以提供你需要的控制来迭代指定的次数

用于创建包含连续算术值的列表( list )。常用于 for 循环。参数必须是普通整数。 参数step默认值为 1 ，参数start的默认值为 0 。 全参数调用该函数将返回一个普通整数列表。 step 可以是正整数或者负整数。不可以为 0 ，否则将处罚ValueError异常。 range ( 3 )代表 0 , 1 , 2. 等价于 range ( 0 , 3 ) >>> range ( 0 , 10 , 2 )  #第一个参数是起始数，第二个是终止数(不包含这个)，第三个数步数 >>>[ 0 , 2 , 4 , 6 , 8 ]

53. repr()　　将任意值转换为字符串，供计时器读取的形式

repr ( object ) 返回一个对象的字符串表示。有时可以使用这个函数来访问操作。 对于许多类型来说， repr ()尝试返回一个字符串， eval ()方法可以使用该字符串产生对象； 否则用尖括号括起来的，包含类名称和其他二外信息的字符串被返回。

54. reversed()　　　反转，逆序对象

1 2 3

reversed (seq) 返回一个逆序的iterator对象。参数seq必须是一个包含__reversed__()方法的对象或支持序列操作(__len__()和__getitem__()) 该函数是 2.4 中新增的

55. round()　　四舍五入

1 2 3 4 5 6 7

round (x [, n]) 对参数x的第n + 1 位小数进行四舍五入，返回一个小数位数为n的浮点数。 参数n的默认值是 0 。结果是一个浮点数。如 round ( 0.5 )结果为 1.0 >>> round ( 4 , 6 ) 4 >>> round ( 5 , 6 ) 5

56. set()

57. setattr()　　与getattr()相对应

58. slice()　　切片功能

59. sorted()　　排序

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16

>>> sorted ([ 36 , 6 , - 12 , 9 , - 22 ])  列表排序 [ - 22 , - 12 , 6 , 9 , 36 ] >>> sorted ([ 36 , 6 , - 12 , 9 , - 22 ],key = abs ) 高阶函数，以绝对值大小排序 [ 6 , 9 , - 12 , - 22 , 36 ] >>> sorted ([ 'bob' , 'about' , 'Zoo' , 'Credit' ])  字符串排序，按照ASCII的大小排序 [ 'Credit' , 'Zoo' , 'about' , 'bob' ] 如果需要排序的是一个元组，则需要使用参数key，也就是关键字。 >>> a = [( 'b' , 2 ), ( 'a' , 1 ), ( 'c' , 0 )] >>> list ( sorted (a,key = lambda x:x[ 1 ]))   按照元组第二个元素排序 [( 'c' , 0 ), ( 'a' , 1 ), ( 'b' , 2 )] >>> list ( sorted (a,key = lambda x:x[ 0 ]))   按照元组第一个元素排序 [( 'a' , 1 ), ( 'b' , 2 ), ( 'c' , 0 )] >>> sorted ([ 'bob' , 'about' , 'Zoo' , 'Credit' ],key = str .lower) 忽略大小写排序 [ 'about' , 'bob' , 'Credit' , 'Zoo' ]  >>> sorted ([ 'bob' , 'about' , 'Zoo' , 'Credit' ],key = str .lower,reverse = True ) 反向排序 [ 'Zoo' , 'Credit' , 'bob' , 'about' ]

60. staticmethod()

61. str()　　字符串构造函数

62. sum()　　求和

63. super()　　调用父类的方法

64. tuple()　　元组构造函数

65. type()　　显示对象所属的类型

66. vars()　　

67. zip()　　将对象逐一配对

1 2 3 4 5 6 7 8

list_1 = [ 1 , 2 , 3 ] list_2 = [ 'a' , 'b' , 'c' ] s = zip (list_1,list_2) print ( list (s))   运行结果：   [( 1 , 'a' ), ( 2 , 'b' ), ( 3 , 'c' )]

68. __import__()

 

 分类

一、数学运算类

abs(x)	求绝对值 1、参数可以是整型，也可以是复数 2、若参数是复数，则返回复数的模
complex([real[, imag]])	创建一个复数
divmod(a, b)	分别取商和余数 注意：整型、浮点型都可以
float([x])	将一个字符串或数转换为浮点数。如果无参数将返回0.0
int([x[, base]])	将一个字符转换为int类型，base表示进制
long([x[, base]])	将一个字符转换为long类型
pow(x, y[, z])	返回x的y次幂
range([start], stop[, step])	产生一个序列，默认从0开始
round(x[, n])	四舍五入
sum(iterable[, start])	对集合求和
oct(x)	将一个数字转化为8进制
hex(x)	将整数x转换为16进制字符串
chr(i)	返回整数i对应的ASCII字符
bin(x)	将整数x转换为二进制字符串
bool([x])	将x转换为Boolean类型

 

二、集合类操作

basestring()	str和unicode的超类 不能直接调用，可以用作isinstance判断
format(value [, format_spec])	格式化输出字符串 格式化的参数顺序从0开始，如“I am {0},I like {1}”
unichr(i)	返回给定int类型的unicode
enumerate(sequence [, start = 0])	返回一个可枚举的对象,该对象的next()方法将返回一个tuple
iter(o[, sentinel])	生成一个对象的迭代器，第二个参数表示分隔符
max(iterable[, args...][key])	返回集合中的最大值
min(iterable[, args...][key])	返回集合中的最小值
dict([arg])	创建数据字典
list([iterable])	将一个集合类转换为另外一个集合类
set()	set对象实例化
frozenset([iterable])	产生一个不可变的set
str([object])	转换为string类型
sorted(iterable[, cmp[, key[, reverse]]])	队集合排序
tuple([iterable])	生成一个tuple类型
xrange([start], stop[, step])	xrange()函数与range()类似，但xrnage()并不创建列表，而是返回一个xrange对象，它的行为与列表相似，但是只在需要时才计算列表值，当列表很大时，这个特性能为我们节省内存

 

三、逻辑判断

all(iterable)	1、集合中的元素都为真的时候为真 2、特别的，若为空串返回为True
any(iterable)	1、集合中的元素有一个为真的时候为真 2、特别的，若为空串返回为False
cmp(x, y)	如果x < y ,返回负数；x == y, 返回0；x > y,返回正数

 

四、反射

callable(object)	检查对象object是否可调用 1、类是可以被调用的 2、实例是不可以被调用的，除非类中声明了__call__方法
classmethod()	1、注解，用来说明这个方式是个类方法 2、类方法即可被类调用，也可以被实例调用 3、类方法类似于Java中的static方法 4、类方法中不需要有self参数
compile(source, filename, mode[, flags[, dont_inherit]])	将source编译为代码或者AST对象。代码对象能够通过exec语句来执行或者eval()进行求值。 1、参数source：字符串或者AST（Abstract Syntax Trees）对象。 2、参数 filename：代码文件名称，如果不是从文件读取代码则传递一些可辨认的值。 3、参数model：指定编译代码的种类。可以指定为 ‘exec’,’eval’,’single’。 4、参数flag和dont_inherit：这两个参数暂不介绍
dir([object])	1、不带参数时，返回当前范围内的变量、方法和定义的类型列表； 2、带参数时，返回参数的属性、方法列表。 3、如果参数包含方法__dir__()，该方法将被调用。当参数为实例时。 4、如果参数不包含__dir__()，该方法将最大限度地收集参数信息
delattr(object, name)	删除object对象名为name的属性
eval(expression [, globals [, locals]])	计算表达式expression的值
execfile(filename [, globals [, locals]])	用法类似exec()，不同的是execfile的参数filename为文件名，而exec的参数为字符串。
filter(function, iterable)	构造一个序列，等价于[ item for item in iterable if function(item)] 1、参数function：返回值为True或False的函数，可以为None 2、参数iterable：序列或可迭代对象
getattr(object, name [, defalut])	获取一个类的属性
globals()	返回一个描述当前全局符号表的字典
hasattr(object, name)	判断对象object是否包含名为name的特性
hash(object)	如果对象object为哈希表类型，返回对象object的哈希值
id(object)	返回对象的唯一标识
isinstance(object, classinfo)	判断object是否是class的实例
issubclass(class, classinfo)	判断是否是子类
len(s)	返回集合长度
locals()	返回当前的变量列表
map(function, iterable, ...)	遍历每个元素，执行function操作
memoryview(obj)	返回一个内存镜像类型的对象
next(iterator[, default])	类似于iterator.next()
object()	基类
property([fget[, fset[, fdel[, doc]]]])	属性访问的包装类，设置后可以通过c.x=value等来访问setter和getter
reduce(function, iterable[, initializer])	合并操作，从第一个开始是前两个参数，然后是前两个的结果与第三个合并进行处理，以此类推
reload(module)	重新加载模块
setattr(object, name, value)	设置属性值
repr(object)	将一个对象变幻为可打印的格式
slice（）
staticmethod	声明静态方法，是个注解
super(type[, object-or-type])	引用父类
type(object)	返回该object的类型
vars([object])	返回对象的变量，若无参数与dict()方法类似
bytearray([source [, encoding [, errors]]])	返回一个byte数组 1、如果source为整数，则返回一个长度为source的初始化数组； 2、如果source为字符串，则按照指定的encoding将字符串转换为字节序列； 3、如果source为可迭代类型，则元素必须为[0 ,255]中的整数； 4、如果source为与buffer接口一致的对象，则此对象也可以被用于初始化bytearray.
zip([iterable, ...])	实在是没有看懂，只是看到了矩阵的变幻方面

 

五、IO操作

file(filename [, mode [, bufsize]])	file类型的构造函数，作用为打开一个文件，如果文件不存在且mode为写或追加时，文件将被创建。添加‘b’到mode参数中，将对文件以二进制形式操作。添加‘+’到mode参数中，将允许对文件同时进行读写操作 1、参数filename：文件名称。 2、参数mode：'r'（读）、'w'（写）、'a'（追加）。 3、参数bufsize：如果为0表示不进行缓冲，如果为1表示进行行缓冲，如果是一个大于1的数表示缓冲区的大小 。
input([prompt])	获取用户输入 推荐使用raw_input，因为该函数将不会捕获用户的错误输入
open(name[, mode[, buffering]])	打开文件 与file有什么不同？推荐使用open
print	打印函数
raw_input([prompt])	设置输入，输入都是作为字符串处理

 

其他

help()--帮助信息

 

 补充：最常见的内置函数

 

常见编写代码的注意事项：

1. 别忘了冒号。一定要记住符合语句首行末尾输入“：”（if,while,for等的第一行）
2. 从第一行开始。要确定顶层（无嵌套）程序代码从第一行开始。
3. 空白行在交互模式提示符下很重要。模块文件中符合语句内的空白行常被忽视。但是，当你在交互模式提示符下输入代码时，空白行则是会结束语句。
4. 缩进要一致。避免在块缩进中混合制表符和空格。
5. 使用简洁的for循环，而不是while or range.相比，for循环更易写，运行起来也更快
6. 要注意赋值语句中的可变对象。
7. 不要期待在原处修改的函数会返回结果,比如list.append()，这在可修改的对象中特别注意
8. 调用函数是，函数名后面一定要跟随着括号，有时候括号里面就是空空的，有时候里面放参数。
9. 不要在导入和重载中使用扩展名或路径。

以上各点如果有不理解的，也不要紧，在以后编程中，时不时地回来复习一下，能不断领悟其内涵。

 

后记

内置函数，一般都是因为使用频率比较频繁或是是元操作，所以通过内置函数的形式提供出来，通过对python的内置函数分类分析可以看出来：基本的数据操作基本都是一些数学运算（当然除了加减乘除）、逻辑操作、集合操作、基本IO操作，然后就是对于语言自身的反射操作，还有就是字符串操作，也是比较常用的，尤其需要注意的是反射操作。

 

转载于:https://www.cnblogs.com/zhangyux/p/6014234.html