python的爬虫都有什么内置函数

python的爬虫都有什么内置函数？

函数

一.引言

a) 概念：函数是完成指定或者特定任务的一组代码。在面向对象编程的类中函数通常被称为方法。不同的函数在程序中会扮演不同的角色完成不同的功能。

b) 作用：

i. 函数的使用可以提高代码的复用性，省去重复代码的编写，提升程序代码重复利用率。

ii. 函数能封装内部的实现，保护内部的数据。通常，我们可以将函数看做成一个“黑盒子”。往往函数的使用者并不是函数的编写者，函数的使用者并不需要对函数内部实现和行为进行考虑，可以将精力更多投入到自身业务逻辑的设计中。只有函数的编写者才需要考虑函数内部的实现细节，如何暴露对外的接口，返回什么样的数据值，也就是API的设计。

iii. 提高程序的可读性。使得程序模块化。从一盘散散沙变成整齐队列。

iv. 提高程序的可维护性。案例：打印一个不同字符组成的分隔符。

二.函数基础

a) 可以将函数抽象成现实生活中的工具。工具需要先制作出来才可以使用。函数也是一样的需要先进行函数的定义，然后方可进行函数调用。

b) 函数定义语法结构：

def 函数名(参数):

# 内部代码

return 表达式

c) Return：return不是必须要写的，如果需要则写，不需要可不写。Return后面什么都不跟表示return None。一旦函数执行过程中遇到了return语句，那么函数中return后面的所有语句将不会执行，函数执行结束。

d) 函数调用：

i. 语法结构：函数名(参数值)

ii. 注意事项：

1. 参数之前使用逗号隔开

2. 由于python动态语言的特点，函数调用时填写的参数，python不会对参数类型进行检查，如果函数调用中的参数不符合函数内部运行机制的话，会报错。

e) 参数：现实函数和调用者之间的交互

i. 函数-》工具：使用ATM取钱时需要传入密码数据。

ii. 实参和形参的概念。

iii. 函数调用时，实参会传值给形参

1. 注意：

a) Python的函数参数传递实际上传递的是实参的地址

b) Python中的参数类型分为可变数据类型和不可变数据类型。

2. Test：使用可变数据类型和不可变数据类型的数据作为参数

a = 1

def func(a):

print("在函数内部修改之前,变量a的内存地址为： %s" % id(a))

a = 2

print("在函数内部修改之后,变量a的内存地址为： %s" % id(a))

print("函数内部的a为： %s" % a)

print("调用函数之前,变量a的内存地址为： %s" % id(a))

func(a)

print("函数外部的a为：%s" % a)

打印结果为：

调用函数之前,变量a的内存地址为： 1401140288

在函数内部修改之前,变量a的内存地址为： 1401140288

在函数内部修改之后,变量a的内存地址为： 1401140320

函数内部的a为： 2

函数外部的a为：1

解释：作为参数，a被传入函数时，将数字对象1的地址传递给了函数内部的a。执行第一句内部代码时，此时内部的a和外面的a其实是一个东西，因此打印出了同样的内存地址。而当a=2被执行后，由于整数是不可变的数据类型，所以创建了一个新的内部变量a，并赋值2，将数字对象2的内存地址赋给变量a。我们知道，首先，赋值语句具有创建新变量的功能。

刚才说的是不可变类型参数，如果是可变类型的，比如列表呢?

a = [1, 2, 3]

def func(b):

print("在函数内部修改之前,变量b的内存地址为： %s" % id(b))

b.append(4)

print("在函数内部修改之后,变量b的内存地址为： %s" % id(b))

print("函数内部的b为： %s" % b)

print("调用函数之前,变量a的内存地址为： %s" % id(a))

func(a)

print("函数外部的a为：%s" % a)

执行结果是：

调用函数之前,变量a的内存地址为： 34875720

在函数内部修改之前,变量b的内存地址为： 34875720

在函数内部修改之后,变量b的内存地址为： 34875720

函数内部的b为： [1, 2, 3, 4]

函数外部的a为：[1, 2, 3, 4]

三.参数类型：python函数的参数定义灵活度很大，可以定义位置参数，默认参数，动态参数，关键字参数等。

a) 位置参数

i. 概念：也叫做必传参数，在函数调用时必须明确提供的参数，切参数顺序个数必须和形参保持一致。但是如果在函数调用的时候给实参指定参数名，那么位置参数的顺序可以不同。

b) 默认参数：如果给某个参数提供一个默认值，该参数就是默认参数。在函数调用时，可以给默认参数传递一个值，也可以使用默认值。

i. Test：

def power(x, n = 2):

return x**n

ret1 = power(10) # 使用默认的参数值n=2

ret2 = power(10, 4) # 将4传给n，实际计算10**4的值

ii. 使用默认参数的注意事项：

1. 默认参数必须在顺序参数后面

2. 默认参数尽量指向不变的对象

a) Test：

下面是国内某上市互联网公司Python面试真题：

def func(a=[]):

a.append("A")

return a

print(func())

print(func())

print(func())

不要上机测试，仅凭代码，你能说出打印的结果吗?

很多同学可能会说，这还不简单，肯定是下面的结果啊：

['A']

['A']

['A']

真的是这样吗?错了!真正的结果是：

['A']

['A', 'A']

['A', 'A', 'A']

Why?为什么会这样?

因为Python函数体在被读入内存的时候，默认参数a指向的空列表对象就会被创建，并放在内存里了。因为默认参数a本身也是一个变量，保存了指向对象[]的地址。每次调用该函数，往a指向的列表里添加一个A。a没有变，始终保存的是指向列表的地址，变的是列表内的数据!我们可以测试一下：

def func(a=[]):

print("函数内部a的地址为：%s" % id(a))

a.append("A")

return a

b = func()

print('此时b的值为：%s' % b)

print("函数外部b的地址为：%s" % id(b))

print("-------------")

c = func()

print('此时c的值为：%s' % c)

print("函数外部c的地址为：%s" % id(c))

print("-------------")

d = func()

print('此时d的值为：%s' % d)

print("函数外部d的地址为：%s" % id(d))

打印结果是：

函数内部a的地址为：39287880

此时b的值为：['A']

函数外部b的地址为：39287880

-------------

函数内部a的地址为：39287880

此时c的值为：['A', 'A']

函数外部c的地址为：39287880

-------------

函数内部a的地址为：39287880

此时d的值为：['A', 'A', 'A']

函数外部d的地址为：39287880

那么如何避免这个问题呢?

使用不可变的数据类型作为默认值!

def func(a=None):

# 注意下面的if语句

if a is None:

a = []

a.append("A")

return a

print(func())

print(func())

print(func())

将默认参数a设置为一个类似None，数字或字符串之类的不可变对象。在函数内部，将它转换为可变的类型，比如空列表。这样一来，不管调用多少次，运行结果都是['A']了。

iii. 动态参数

1. 概念：函数调用时传入的参数可以是动态数量的，可以为任意个，甚至是0个。

2. 分类：重点是*的个数，*后的名字任意。动态参数必须放在所有位置参数和动态参数后面。

a) *args：可以接受任意个参数。调用时，会将实参打包成一个元组传给形参。如果参数是一个列表，则会将整个列表当做一个参数传入。

i. Test

def func(*args):

for arg in args:

print(arg)

func('a', 'b', 'c')

li = [1, 2, 3]

func(li)

ii. 上述案例中，我们本意是将li这个列表中的元素作为参数进行传值，但是实际却是将列表本身作为一个整体进行了传递。如果想要将一个序列类型的对象(元组，列表，字符串，字典)的元素依次作为参数进行传递，则可以在序列对象前加一个*即可。如果参数是字典，则会将字典所有的key逐一传递进去。

1. Test：

def func(*args):

for arg in args:

print(arg)

li = [1, 2, 3]

func(*li)

b) **kwargs：表示接受键值对的动态参数，数量任意。调用时，会将参数打包成一个字典。

i. Test：

def func(**kwargs):

for kwg in kwargs:

print(kwg, kwargs[kwg])

print(type(kwg))

func(k1='v1', k2=[0, 1, 2])

运行结果是：

k1 v1

k2 [0, 1, 2]

ii. 而如果我们这样传递一个字典dic呢?我们希望字典内的键值对能够像上面一样被逐一传入。

1. Test:

def func(**kwargs):

for kwg in kwargs:

print(kwg, kwargs[kwg])

dic = {

'k1': 'v1',

'k2': 'v2'

}

func(**dic)

iv. 关键字参数：关键字参数前面需要一个特殊分隔符*和位置参数及默认参数分隔开来。*后面的参数被视为关键字参数。在函数调用时，关键字参数必须传入参数名。

1. Test：

def student(name, age, *, sex):

pass

student(name="jack", age=18, sex='male')

Test2：如果函数定义中已经有了一个*args参数，后面跟着的命名关键字参数就不再需要一个特殊分隔符*了。

def student(name, age=10, *args, sex, classroom, **kwargs):

pass

student(name="jack", age=18, sex='male', classroom="202", k1="v1")

总结：参数定义顺序：位置参数，动态参数，关键字参数，动态参数

声明：本文内容由网友自发贡献，本站不承担相应法律责任。对本内容有异议或投诉，请联系2913721942#qq.com核实处理，我们将尽快回复您，谢谢合作！