版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
列表推导式
#可变类型：可以在原有的数据基础上对数据进行修改，修改后内存地址不变
#不可变类型：不可以在原有的数据基础上对数据进行修改，直接复制一个新值，那么内存地址发生改变
#可变类型列表，集合，字典
#不可变类型：字符串，数字，元组
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 = 装饰器（函数）