视觉差 网站网络营销渠道可分为

一、函数的返回值

return 语句：

        1、给函数返回值(表达式)

        2、用于终止函数的运行

return 语法：

        1、如果不写return 或者 写了return 但是后面不写值或者变量，默认返回None

        2、reutrn返回一个数据时，返回的数据类型为返回值本身的数据类型object

        3、return返回多个数据是，元素之间用逗号隔开，返回的数据类型为元组tuple

        4、函数中不同分值可以有多个return语句

        5、return是函数运行结束的标识符

# 1、不写return 或者 写了return 但是后面不写值或者变量，默认返回None
def add_func(a,b):total = a + breturn
res = add_func(11, 22)
print("--------------------------------------")
print("add_func返回的值为：{}".format(res))
'''
运行结果：
--------------------------------------
add_func返回的值为：None
'''# 2、return返回一个值
def add_func(a,b):total = a + breturn total
res = add_func(11, 22)
print("--------------------------------------")
print("add_func返回的值为：{},其数据类型为{}".format(res,type(res)))
'''
运行结果：
--------------------------------------
add_func返回的值为：33,其数据类型为<class 'int'>
'''# 3、return返回多个值
def add_func(a,b):total1 = a + btotal2 = a - btotal3 = a * btotal4 = a / breturn total1,total2,total3,total4
res = add_func(11, 22)
print("--------------------------------------")
print("add_func返回的值为：{},其数据类型为{}".format(res,type(res)))
'''
运行结果：
--------------------------------------
add_func返回的值为：(33, -11, 242, 0.5),其数据类型为<class 'tuple'>
'''# 4、多分支，return
def add_func(a,b,method):if method == "+":print("{} + {} ,运算结果为：{}".format(a,b,a+b))return a + belif method == "-":print("{} - {} ,运算结果为：{}".format(a, b, a - b))return a - belif method == "*":print("{} * {} ,运算结果为：{}".format(a, b, a * b))return a * belif method == "/":print("{} / {} ,运算结果为：{}".format(a, b, a / b))return a / b
print("--------------------------------------")
res = add_func(11, 22,"+")
print("add_func多分支返回的值为：{},其数据类型为{}".format(res,type(res)))
res = add_func(11, 22,"-")
print("add_func多分支返回的值为：{},其数据类型为{}".format(res,type(res)))
res = add_func(11, 22,"*")
print("add_func多分支返回的值为：{},其数据类型为{}".format(res,type(res)))
res = add_func(11, 22,"/")
print("add_func多分支返回的值为：{},其数据类型为{}".format(res,type(res)))
print("--------------------------------------")
'''
--------------------------------------
11 + 22 ,运算结果为：33
add_func多分支返回的值为：33,其数据类型为<class 'int'>
11 - 22 ,运算结果为：-11
add_func多分支返回的值为：-11,其数据类型为<class 'int'>
11 * 22 ,运算结果为：242
add_func多分支返回的值为：242,其数据类型为<class 'int'>
11 / 22 ,运算结果为：0.5
add_func多分支返回的值为：0.5,其数据类型为<class 'float'>
--------------------------------------
'''

二、函数的全局变量和局部变量

局部变量：

        1、在函数内部定义的变量

        2、其作用域仅为函数内部

        3、函数的形参是局部变量

        4、局部变量在函数调用时被创建，调用结束后被销毁

全局变量：

        1、定义在函数体外，python模块中的变量

        2、其作用域为整个python文件

        3、全局变量不能在函数体内修改其绑定关系

全局变量的修改：

        1、任何一个子函数，直接去使用全局变量，不对它进行修改，则只是引用共享全局变量

        2、某个子函数，对全局变量进行修改，全局变量是不可变数据类型，相当于重新创建一个全局变量

        3、某个子函数，对全局变量进行修改，全局变量是可变数据类型，确实是修改了全局变量

global 关键字：

        1、声明函数内部操作的一个或多个变量是全局变量

        2、不能先声明局部变量，再用global声明为全局变量

        3、global变量列表里的变量名不能出现在次作用域内的形参列表

函数变量引用的优先级：

        1、语句执行检查语法是从右到左

        2、先在局部变量，再找全局变量

        3、当局部变量和全局变量同名时，函数会优先使用局部变量

        4、函数内部定义局部变量时，尽量不和全局变量同名

# Demo实例1：----全局和局部作用域区分
name = 'james' # 全局变量
print("-----------------------------")def test():name = 'xiaowang'print("局部变量只在函数体内有效：",name)return nameres = test()   # 局部变量通过return返回
print("局部变量可以通过函数返回：",res)# 全局变量不能在函数体内修改其绑定关系
print("全局变量不能在函数体内修改其绑定关系:",name)
print("-----------------------------")
'''
运行结果：
-----------------------------
局部变量只在函数体内有效： xiaowang
局部变量可以通过函数返回： xiaowang
全局变量不能在函数体内修改其绑定关系: james
-----------------------------
'''

# Demo实例2：----函数内使用全局变量，报错情况一
# 未进行全局声明前，如下代码会报错
number1 = 100def func1():number1 = number1 + 100 # 会报错，原因如下："""这行会报错，函数找number1的定义时，从右到左，先执行number1+100，发现number1在该语句之前没定义，因其定义的语句：number1 = number1 + 100还未生效"""print("number1的值为：{}".format(number1))func1()
print("----------------------------------------------------------")
'''
执行结果：（报错提示：在赋值之前不能先使用，得先声明再使用）
UnboundLocalError: local variable 'number1' referenced before assignment
'''# Demo实例3：----针对上述报错方案的优化
number2 = 100def func2():# 修改为如下，则OK, global声明的必须先声明再使用global number2number2 = number2+ 100print("局部定义global number2后的值为：{}".format(number2))func2()
"""
运行结果：
局部定义global number2后的值为：200
"""

# Demo4--global关键字的使用
test_list1 = [1,2,3] # 全局变量，作用域（整个当前的py文件）
def test01():global test_list  # 声明为全局变量test_list = [1,2,3] # 局部变量print("打印函数内部的局部变量的内存地址：",id(test_list))def test02():test01()print("global声明 打印全局变量的内存地址",id(test_list))print("打印全局变量的内存地址",id(test_list1))test02()
'''
运行结果：
-----------------------------
打印函数内部的局部变量的内存地址： 2585025008712
global声明 打印全局变量的内存地址 2585025008712
打印全局变量的内存地址 2585025008200
-----------------------------
'''

# 某个子函数，对全局变量进行修改，全局变量是可变数据类型，确实是修改了全局变量
test_list1 = [1, 2, 3] # 全局变量，作用域（整个当前py文件内使用）def test01():print("打印全局变量test_list1的内存地址t", test_list1, id(test_list1))def test02():test_list1.append(4)print("打印全局变量test_list1的内存地址t", test_list1, id(test_list1))
test01()
test02()
'''
-----------------------------
打印全局变量test_list1的内存地址t [1, 2, 3] 2021704487496
打印全局变量test_list1的内存地址t [1, 2, 3, 4] 2021704487496
-----------------------------
'''# 某个子函数，对全局变量进行修改，全局变量是不可变数据类型，相当于重新创建一个全局变量
test_list1 = 3 # 全局变量，作用域（整个当前py文件内使用）def test01():print("打印全局变量test_list1的内存地址t", test_list1, id(test_list1))def test02():test_list1 = 5print("打印全局变量test_list1的内存地址t", test_list1, id(test_list1))
test01()
test02()
'''
-----------------------------
打印全局变量test_list1的内存地址t 3 140735760920896
打印全局变量test_list1的内存地址t 5 140735760920960
-----------------------------
'''

三、内置函数

4.1 匿名函数

lambda关键字：

python 使用 lambda关键字来创建匿名函数

lambda基本语法：

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

arg1...argn: 是参数列表，可以1个或者多个

expression: 是该匿名函数的返回值，或者返回逻辑，最多只能支持三元运算

lambda注意事项：

1）lambda只是一个表达式，函数体比def简单很多，无函数名称

2）lambda的主体是一个表达式，而不是一个代码块。仅仅能在lambda表达式中封装有限的逻辑

3）lambda函数拥有自己的命名空间，且不能访问自己参数列表之外或全局参数

4）最多支持三元运算符

三元运算符（条件为真时的结果 if 判段的条件 else 条件为假时的结果 ）

# demo1——简单的匿名函数
a = lambda x : x*x # x 为参数，x*x为返回的结果，a接受函数的返回值
print("两数相乘的匿名函数返回的结果：",a(10)) # 输出  100add_func = lambda a,b: a+b
print("两数相加的匿名函数返回的结果：",add_func(10,20)) # 输出 30# demo2——三元运算匿名函数
func = lambda x,y: x+y if x>y else x-y
print("若x>y，则相加,输入{},{}，结果为{}".format(5,3,func(5,3)))
print("若x<y，则相加,输入{},{}，结果为{}".format(3,5,func(3,5)))
'''
输出结果：
若x>y，则相加,输入5,3，结果为8
若x<y，则相加,输入3,5，结果为-2
'''

 4.2 常用内置函数

数据统计相关：如下三个函数的参数必须为可迭代对象iterable

1、min()： 获取最小值

2、max()： 获取最大值

3、sum()： 求和

可迭代对象：数据只能用一次

list1 = [1,2,3,4]
print("min的最小值为：",min(list1))
print("max的最大值为：",max(list1))
print("sum求和：",sum(list1))
'''
min的最小值为： 1
max的最大值为： 4
sum求和： 10
'''

高级内置函数：

1、eval：

    识别字符串中的有效的python表达式并执行表达式====去引号+执行表达式 

print("eval函数去引号，执行表达式结果为{}".format(eval('3*2')))
print("未用eval函数去引号，执行表达式结果为{}".format('3*2'))
'''
eval函数去引号，执行表达式结果为6
未用eval函数去引号，执行表达式结果为3*2
'''

2、enumerate：

    用于将一个可遍历的数据对象(如列表、元组或字符串)组合为一个索引序列，

    同时列出数据和数据下标，一般用在 for 循环当中。

    返回的是元组数据的格式(索引， 值)

list_test = ["james","study","python","good"]
for data in enumerate(list_test):print("enumerate函数打印序列的索引和值，结果为元组：{}".format(data))for index,item in enumerate(list_test):print("enumerate函数打印序列的索引和值，元组拆包结果为：{}，{}".format(index,item))
'''
enumerate函数打印序列的索引和值，结果为元组：(0, 'james')
enumerate函数打印序列的索引和值，结果为元组：(1, 'study')
enumerate函数打印序列的索引和值，结果为元组：(2, 'python')
enumerate函数打印序列的索引和值，结果为元组：(3, 'good')
enumerate函数打印序列的索引和值，元组拆包结果为：0，james
enumerate函数打印序列的索引和值，元组拆包结果为：1，study
enumerate函数打印序列的索引和值，元组拆包结果为：2，python
enumerate函数打印序列的索引和值，元组拆包结果为：3，good
'''

 3、zip：

    用于将可迭代的对象作为参数，将对象中对应的元素打包成一个个元组，

    然后返回由这些元组组成的对象，这样做的好处是节约了不少的内存

    也叫做数据的聚合打包，聚合后的数据只能使用一次

    如果各个迭代器的元素个数不一致，则返回列表长度与最短的对象相同

    利用 * 号操作符，可以将元组解压为列表。

# zip--两个list聚合以后才能转换成字典
list1 = ["a","b","c"]
list2= [1,2,3]
res = zip(list1,list2)
# print("zip函数打包两个list时，结果为字典：{}".format(dict(res)))
print("zip函数打包两个list时，结果为列表：{}".format(list(res)))
'''
zip函数打包两个list时，结果为字典：{'a': 1, 'b': 2, 'c': 3}
zip函数打包两个list时，结果为列表：[('a', 1), ('b', 2), ('c', 3)]
'''list1 = [1, 2, 3, 4, 5]
list2 = [11, 22, 33, 44, 55]
list3 = [111, 222, 333, 444, 555]
list4 = [1111, 2222, 3333, 4444, 5555]
list5 = [11111, 22222, 33333, 44444, 55555]ret = zip(list1, list2, list3, list4, list5)
print("zip函数打包多个list时，结果为列表，列表的每个元素为相同索引对应的值组成的子列表：\n{}".format(numpy.array(list(ret))))
'''
zip函数打包多个list时，结果为列表，列表的每个元素为相同索引对应的值组成的子列表：
[[    1    11   111  1111 11111][    2    22   222  2222 22222][    3    33   333  3333 33333][    4    44   444  4444 44444][    5    55   555  5555 55555]]
'''

4、filter：

    函数用于过滤序列，过滤掉不符合条件的元素，返回一个迭代器对象，

    如果要转换为列表，可以使用 list() 来转换。接收两个参数，第一个为函数，第二个为序列，

    序列的每个元素作为参数传递给函数进行判，

    然后返回 True 或 False，最后将返回 True 的元素放到新列表中。

stu = [90, 100, 25, 425, 32, 77]ret = filter(lambda x: x > 80, stu)
print("filter函数过滤大于80的元素", list(ret))
'''
filter函数过滤大于80的元素 [90, 100, 425]
'''