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。

函数调用

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

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

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

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

# 定义函数
def printme( str ):
   "打印任何传入的字符串"
   print str;
   return;

# 调用函数
printme("我要调用用户自定义函数!");
printme("再次调用同一函数");

以上实例输出结果：

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

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

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

普通参数：

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

# 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()--帮助信息

补充：最常见的内置函数

后记

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

时间： 2024-10-12 13:59:36

python基础之函数的相关文章

python基础——sorted()函数

python基础——sorted()函数 排序算法 排序也是在程序中经常用到的算法.无论使用冒泡排序还是快速排序,排序的核心是比较两个元素的大小.如果是数字,我们可以直接比较,但如果是字符串或者两个dict呢?直接比较数学上的大小是没有意义的,因此,比较的过程必须通过函数抽象出来. Python内置的sorted()函数就可以对list进行排序: >>> sorted([36, 5, -12, 9, -21]) [-21, -12, 5, 9, 36] 此外,sorted()函数也是一个

Python基础07 函数

Python基础07 函数 作者:Vamei 出处:http://www.cnblogs.com/vamei 欢迎转载,也请保留这段声明.谢谢! 函数最重要的目的是方便我们重复使用相同的一段程序. 将一些操作隶属于一个函数,以后你想实现相同的操作的时候,只用调用函数名就可以,而不需要重复敲所有的语句. 函数的定义 首先,我们要定义一个函数, 以说明这个函数的功能. def square_sum(a,b): c = a**2 + b**2 return c 这个函数的功能是求两个数的平方和. 首先

python基础——匿名函数及递归函数

python基础--匿名函数及递归函数 1 匿名函数语法 匿名函数lambda x: x * x实际上就是: def f(x): return x * x 关键字lambda表示匿名函数,冒号前面的x表示函数参数. 匿名函数有个限制,就是只能有一个表达式,不用写return,返回值就是该表达式的结果. 2 匿名函数举例 用匿名函数有个好处,因为函数没有名字,不必担心函数名冲突.此外,匿名函数也是一个函数对象,也可以把匿名函数赋值给一个变量,再利用变量来调用该函数: >>> f = lam

python基础教程函数参数

python里有很多的内置函数给我们的工作带来了很多发便利,在我们实现某些功能或者优化代码的时候,可以自己定义一个函数,同时我们在定义一个类的时候也会用到函数的一些知识去构造一个方法,这里就涉及到一些关于函数的基础知识和函数传参的知识. 一.函数的相关介绍 1.函数定义:函数是指将一组语句的集合通过一个名字(函数名)封装起来,要想执行这个函数,只需调用其函数名即可. 函数特性: 减少重复代码 使程序变的可扩展 使程序变得易维护 2.函数的定义示例 定义一个函数要使用def语句,依次写出函数名.括

Python学习笔记（一）python基础与函数

1.python基础 1.1输入与输出 输出 用print加上字符串,就可以打印指定的文字或数字 >>> print 'hello, world' hello, world >>> print 300 300 >>> print 100+200 300 print语句也可以跟上多个字符串,用逗号","隔开,就可以连成一串输出: >>> print 'The quick brown fox', 'jumps over

python基础及函数1

Python的程序执行方式:Python的程序编辑窗口.Python的解释器提示符. python常量:整形.实型(浮点型).字符串型. Python数据类型:数值类型.字符串类型.布尔类型.复合数据类型 数值类型:整型(0b/0B.0o/0O.0x/0X).浮点型(e/E).复数型 字符串类型:Python标准字符.转义字符.基本字符串函数 布尔类型:true.false 复合数据类型:列表.元组.字典.集合 Python3提供的有效数字精度:17位 字符串分片: >>>str1=&q

python基础_函数

函数基础 目标 函数的快速体验 函数的基本使用 函数的参数 函数的返回值 函数的嵌套调用 在模块中定义函数 01. 函数的快速体验 所谓函数,就是把 具有独立功能的代码块 组织为一个小模块,在需要的时候 调用 函数的使用包含两个步骤:1.定义函数 -- 封装 独立的功能2.调用函数 -- 享受 封装 的成果 函数的作用,在开发程序时,使用函数可以提高编写的效率以及代码的 重用 02. 函数基本使用 2.1 函数的定义 定义函数的格式如下: def 函数名(): 函数封装的代码 -- def 是英

第七篇 python基础之函数，递归，内置函数

阅读目录 一 数学定义的函数与python中的函数 二 为何使用函数 背景提要 三 函数和过程 四 函数参数 五 局部变量和全局变量 六 前向引用之'函数即变量' 七 嵌套函数和作用域 八 递归 九 匿名函数 十 函数式编程 十一 内置函数 十二 本节作业 一 数学定义的函数与python中的函数 初中数学函数定义:一般的,在一个变化过程中,如果有两个变量x和y,并且对于x的每一个确定的值,y都有唯一确定的值与其对应,那么我们就把x称为自变量,把y称为因变量,y是x的函数.自变量x的取值范围叫做

python基础之函数，递归，内置函数

一 数学定义的函数与Python中的函数 初中数学函数定义:一般的,在一个变化过程中,如果有两个变量x和y,并且对于x的每一个确定的值,y都有唯一确定的值与其对应,那么我们就把x称为自变量,把y称为因变量,y是x的函数.自变量x的取值范围叫做这个函数的定义域 例如y=2*x python中函数定义:函数是逻辑结构化和过程化的一种编程方法. python中函数定义方法: def test(x): "The function definitions" x+=1 return x def:定

Python基础之函数，递归。

一.数学定义的函数与python中的函数 - 初中数学函数定义:一般的,在一个变化过程中,如果有两个变量x和y,并且对于x的每一个确定的值,y都有唯一确定的值与其对应,那么我们就把x称为自变量,把y称为因变量,y是x的函数.自变量x的取值范围叫做这个函数的定义域 - python中函数定义:函数是逻辑结构化和过程化的一种编程方法. 二. 为何使用函数 1.解决代码重用 2.保持一致性,易维护 3.可扩展性 三. 函数参数 1.形参:形参变量只有在被调用时才分配内存单元,在调用结束时,即刻释放所分