自己动手写爬虫二

列表推导式

#可变类型：可以在原有的数据基础上对数据进行修改，修改后内存地址不变
#不可变类型：不可以在原有的数据基础上对数据进行修改，直接复制一个新值，那么内存地址发生改变

#可变类型列表，集合，字典
#不可变类型：字符串，数字，元组

my_list = [1,5,6]
print(my_list,id(my_list))
my_list[0] = 7
print(my_list,id(my_list))
my_list.append(6)
print(my_list,id(my_list))
del my_list[1]
print(my_list,id(my_list))

my_dict = {"name" : "ls","age" :20}
print(my_dict,id(my_dict))
my_dict["age"] = 10
print(my_dict,id(my_dict))

my_set  = {5,10}
print(my_set,id(my_set))
my_set.add("77")
print(my_set,id(my_set))

#内存地址发生了改变，这局势不可变类型
my_str = "hello"
print(my_str,id(my_str))
my_str = "world"
print(my_str,id(my_st


E:\anaconda\python.exe F:/python_2/13-可变与不可变类型.py
[1, 5, 6] 1463890633224
[7, 5, 6] 1463890633224
[7, 5, 6, 6] 1463890633224
[7, 6, 6] 1463890633224
{'name': 'ls', 'age': 20} 1463891097856
{'name': 'ls', 'age': 10} 1463891097856
{10, 5} 1463893704264
{10, 5, '77'} 1463893704264
hello 1463895441000
world 1463895441112

其他同理，不在演示
总结：
#可变类型允许在原有数据上修改，内存地址不变
#不可变类型不允许在原有数据上修改，修改内存地址改变

global的使用

#定义全局变量
#这是不可变得全局变量
g_num = 10
def modify():
    #什么药修改全局变量
    global g_num
    g_num = 1
    print("modify: ",g_num)

modify()
print(g_num)

#可变的全局变量
g_list = [5,10]
def modify():
    #什么药修改全局变量
    # global g_list，加上global表示内存地址要发生改变
    #如果只是修改数据，那么这里可以不加上global
    g_list.append(1)
    print("modify: ",g_list)

modify()
print(g_list)

#可变的全局变量
g_list = [5,10]
def modify():
    #什么药修改全局变量
    # global g_list，加上global表示内存地址要发生改变,因为这里发生了改，从新复制药开辟新空间，因此加上
    global g_list
    g_list = [1,2]
    print("modify: ",g_list)

modify()
print(g_list) 

公共运算符

my_list = [12,45,12]
my_tuple = (5,6)
my_set = {1,2}

#把列表转成集合,要什么类型接写什么类型,集合会把相同的过滤掉
result = set(my_list)
print(result,type(result))
result = set(my_tuple)
print(result,type(result))

result = list(my_tuple)
print(result,type(result))
result = list(my_set)
print(result,type(result))

result = tuple(my_set)
print(result,type(result))
result = tuple(my_list)
print(result,type(result))

函数的文档说明

def sum_num(num1,num2):
    '''

    :param num1:第一个值
    :param num2:第二个值
    :return:返回值
    '''
    result = num1 +num2
    return result

sum = sum_num(1,2)
print(sum)

help(sum_num)

#给第三方人看到



E:\anaconda\python.exe F:/python_2/17-函数的文档说明.py
3
Help on function sum_num in module __main__:

sum_num(num1, num2)
    :param num1:第一个值
    :param num2:第二个值
    :return:返回值

偏函数

#就是指明函数偏爱某个值，就是偏函数
import functools
def show(num1,num2,num3=1):
    result = num1+num2+num3
    return result

result = show(1,2)
print(result)

#定义偏函数,同时包含了上面的1
def show2(num1,num2,num3 = 2):
    result = show(num1,num2,num3)
    return result

result = show2(1,2)
print(result)

#指明函数的设置为某个值
new_func = functools.partial(show2,num2 = 2)#返回的函数就是偏函数
result = new_func(1)
print(result)

#指明某个内置函数偏爱某个值，生成一个函数
result = int("123")
new_func=functools.partial(int, base = 2)#让他偏爱二进制的数
result = new_func("11")
print(result)

返回函数

#函数的嵌套

#返回函数：在函数内返回函数
def show():
    def inner():
        print("hahaha")
    #返回一个函数
    return inner()
#获得返回函数
new_func = show()
#执行返回函数
new_func

高阶函数

#当一个函数的参数可以接受另一个函数或返回一个函数，那么就叫高阶函数
#高阶函数针对的是接受的是函数或返回的是函数，就叫高阶函数

def sum_num(num1,num2):
    result = num2+num1
    return result

#这个就是高阶函数，因为接受的是一个函数
def calc_num(num1,num2,new_func):
    value = new_func(num1,num2)
    return value

result = calc_num(1,2,sum_num)

print(result)

#高阶函数，返回一个函数
def test(new_func):
    new_func()
    def inner():
        print("hasjdhia")
    return inner

def show_msg():
    print("天天")

new_fuc=test(show_msg)
new_fuc()

闭包

在函数嵌套的情况下，内部函数使用了外部的参数后变量，并把这个内部函数返回，那么这个内部函数就叫闭包

#在函数嵌套的情况下，内部函数使用了外部的参数后变量，并把这个内部函数返回，那么这个内部函数就叫闭包
def show():
    num = 10
    def inner():
        print(num)
    return inner

new_func = show()
print(new_func)
new_func()
#闭包的引用场景，可以根据参数生成不同的返回函数
#通关闭包可以生成不同的函数
#好处，可以根据不同条件，生成不同函数

def show(masg,number):
    def inner():
        result = masg*number
        print(result)
    return inner

new_func1 = show("A",5)
new_func1()
new_func2 = show("B",5)
new_func2()

装饰器

装饰器本质上也是一个函数，可以给原函数的功能进行扩展,好处，不改变与函数的定义与功能

# #装饰器本质上也是一个函数，可以给原函数的功能进行扩展,好处，不改变与函数的定义与功能
#
# def show():
#     print("你好")
# #装饰器是通过闭包完成的
# def decorator(new_func):
#     def inner():
#         print("*"*10)
#         new_func()
#         print("*"*10)
#     # 返回为闭包
#     return inner
#
# show = decorator(show)
# show()


def decorator(new_func):
    def inner():
        print("*"*10)
        new_func()
        print("*"*10)
    # 返回为闭包
    return inner
#在使用的时候，装饰器的的代码就会执行
@decorator
#上面的等于show = decorator(show),语法糖，快速使用装饰器
#使用装饰器装饰以下函数
def show():
    print("你好")

show()

装饰器的与参数的函数

#定义一个装饰器函数
def decorator(new_func):
    def inner(num1,num2):
        print("计算结果如下")
        new_func(num1,num2)
    return inner
@decorator
def sum_num(num1,num2):
    result = num1+num2
    print(result)

result = sum_num(1,2)
print(result)#我们可以看到这个返回值为空，因为inner内部没有返回函数

通用的装饰器

def getdecorator(char):
    #定义装饰器函数
    def decorator(func):
        def inner():
            print(char*10)
            func()
        return inner
    return decorator
    #把@相当于执行了一个函数，返回来一个装饰器
@getdecorator("a")#有参数的装饰器
def show():
    print("11111")

show()

函数使用多个装饰器

def decorator1(func):
    def inner():#inner其实是你封装后的代码】
        print("-"*10)
        func()
    return inner
def decorator2(func):
    def inner():#inner其实是你封装后的代码】
        print("*"*10)
        func()
    return inner

@decorator1#因为他把下面那一个东东看出一个函数进行传递
@decorator2#
def show():
    print("AAAAa")

show()
#show = 装饰器（函数）