Python函数

Python函数

1、定义：
函数是一种仅在调用时运行的代码块。
您可以将数据（称为参数）传递到函数中。
函数可以把数据作为结果返回。

2、函数的命名规则
和变量的命名规则一样
函数名不推荐下划线命名法，尽量做到见名知意

①参数的定义：
在函数名后面的括号中可以定义参数
②参数的传递：
定义在函数括号后面的参数，需要再调用函数的时候传递进行
③形参和实参：
形参：定义的参数
实参：调用是传用的参数

创建函数
在 Python 中，使用 def 关键字定义函数：

def my_function():
  print("Hello from a function")

调用函数
如需调用函数，请使用函数名称后跟括号：

def my_function():
  print("Hello from a function")

my_function()

参数
信息可以作为参数传递给函数。
参数在函数名后的括号内指定。您可以根据需要添加任意数量的参数，只需用逗号分隔即可。
下面的例子有一个带参数（fname）的函数。当调用此函数时，我们传递一个名字，在函数内部使用它来打印全名：

def my_function(fname):
  print(fname + " Gates")

my_function("Rory John")
my_function("Jennifer Katharine")
my_function("Phoebe Adele")

默认参数值
下面的例子展示如何使用默认参数值。
如果我们调用了不带参数的函数，则使用默认值：

def my_function(country = "China"):
  print("I am from " + country)

my_function("Sweden")
my_function("India")
my_function()
my_function("Brazil")

以 List 传参
您发送到函数的参数可以是任何数据类型（字符串、数字、列表、字典等），并且在函数内其将被视为相同数据类型。

例如，如果您将 List 作为参数发送，它到达函数时仍将是 List（列表）：

def my_function(food):
  for x in food:
    print(x)

fruits = ["apple", "banana", "cherry"]

my_function(fruits)

返回值
如需使函数返回值，请使用 return 语句：
① return 空或者没有return时，打印函数执行者时，为None

def func1():
    print (888)
    return
 
def func2():
    print(9)
    
print(func1())
print(func2())

②return 加一个值，返回给函数这个值，这个值是什么类型就返回什么类型
③return 加多个值是，返回给函数一个由这些值组成的元组
④当函数执行到return之后，就会终止函数运行

def func1():
    a = 8
    return a
def func2():
    a = 9 
    b = 20
    return a, b
 
print(func1())
print(func2())

位置参数
例如：add（110，100）

关键字参数
您还可以使用 key = value 语法发送参数。

参数的顺序无关紧要。

def my_function(child3, child2, child1):
  print("The youngest child is " + child3)

my_function(child1 = "Phoebe", child2 = "Jennifer", child3 = "Rory")

任意参数
如果您不知道将传递给您的函数多少个参数，请在函数定义的参数名称前添加 *。

这样，函数将接收一个参数元组，并可以相应地访问各项：

实例
如果参数数目未知，请在参数名称前添加 *：

def my_function(*kids):
  print("The youngest child is " + kids[2])

my_function("Phoebe", "Jennifer", "Rory")

注意点：两种传参方式混合使用是，位置参数在前，关键字参数在后
例如：add(11,22,m=33,n=44)

函数定义的方式

1、必备参数（必须参数）：定义了必须要传
2、默认参数（缺省参数）：定义可以传，也可以不传，不传就是默认值
**3、不定长参数（可变参数）：调用是可以传0个或多个值
*args：只能使用位置传参的形传值，以元组返回
kwargs：只能使用关键字传，返回为字典形式

#以元组形式返回
def func(*args):
    print(args)

func(11,22,33)

#以字典形式返回
def func(**kwargs):
    print(kwargs)

func(a=11,b=22)

需求：定义一个可以接受任意个参数的函数，同时支持位置传参和关键字传参

def func(*args,**kwargs):
    print(args)
    print(kwargs)

func(11,22)
func(11,22,a=33)

函数参数的拆包

*可以对列表、元组进行拆包
**可以对字典进行拆包处理

#对列表进行拆包
def func(a, b, c=99):
    print(a)
    print(b)
    print(c)

li = [11, 22, 33]
func(*li)

#对字典进行拆包
def func(a, b, c=99):
    print(a)
    print(b)
    print(c)

dic = {'a':111, 'b':222, 'c':333}
func(**dic)

lambda 函数是一种小的匿名函数。

lambda 函数可接受任意数量的参数，但只能有一个表达式。
一个 lambda 函数，它把作为参数传入的数字加 10，然后打印结果：

x = lambda a : a + 10
print(x(7))

lambda 函数可接受任意数量的参数：
一个 lambda 函数，它把参数 a 与参数 b 相乘并打印结果：

x = lambda a, b : a * b
print(x(5, 2))

一个 lambda 函数，它把参数 a、b 和 c 相加并打印结果：

x = lambda a, b, c : a + b + c
print(x(7, 6, 2))

为何使用 Lambda 函数？
当您把 lambda 用作另一个函数内的匿名函数时，会更好地展现 lambda 的强大能力。
假设您有一个带一个参数的函数定义，并且该参数将乘以未知数字：

def myfunc(n):
  return lambda a : a * n

使用该函数定义来创建一个总是使所发送数字加倍的函数：

def myfunc(n):
  return lambda a : a * n

mydoubler = myfunc(2)

print(mydoubler(11))

或者，使用相同的函数定义来创建一个总是使您发送的数字增加三倍的函数：

def myfunc(n):
  return lambda a : a * n

mytripler = myfunc(3)

print(mytripler(11))

或者，在同一程序中使用相同的函数定义来生成两个函数：

def myfunc(n):
  return lambda a : a * n

mydoubler = myfunc(2)
mytripler = myfunc(3)

print(mydoubler(11)) 
print(mytripler(11))

python之全局变量与局部变量

全局变量和局部变量的区别在于作用域，全局变量在整个py文件中声明，全局范围内可以使用；局部变量是在某个函数内部声明的，只能在函数内部使用，如果超出使用范围（函数外部），则会报错。

A = 100 # 全局变量一般用大写字母表示

def func():
	a = 50 # 局部变量一般用小写字母表示
	print(a+A) 
func()
	print(A)
print(a) # 报错信息NameError: name 'a' is not defined

在函数内部，如果局部变量与全局变量变量名一样，则优先调用局部变量。

A = 100
def func():
	A=250
	print(A)

print(A)    # 打印全部变量
func()      # 局部变量

如果想在函数内部改变全局变量，需要在前面加上global关键字，在执行函数之后，全局变量值也会改变。

A = 100
def func():
	global  A
	A = 200
	print(A)

print(A)    # 打印全局变量
func()      # 局部变量
print(A)   # 改变后的全局变量

如果全局变量是列表类型，可以通过list的列表方法去对列表进行修改，并且可以不用global来声明。

list_1 = [1,2,56,"list"]

def changeList():
    list_1.append("over")
    print(list_1)

changeList()
print(list_1)

常用内置函数

min（）：获取最小值
max（）：获取最大值
sum（）：求和

li = [11, 2, 343, 5, 2, 5, 33, 55]
res1 = min(li)
res2 = max(li)
res3 = sum(li)
print(res1)
print(res2)
print(res3)

可迭代对象（iterable）：能够使用for进行遍历的数据都是可迭代对象（字符串，列表，字典，元组，集合）

高级的内置函数

①eval（）：识别字符串中有效的python表达式

print(eval("11+22"))

②enumerate：获取列表中的数据及索引

li = ["name", "python", "Java", "php"]
res = list(enumerate(li))
print(res)

li = ["name", "python", "Java", "php"]

for i in li:
    print(li.index(i),i)

li = ["name", "python", "Java", "php"]

for i in enumerate(li):
    print(i)

#拆包后，同index
li = ["name", "python", "Java", "php"]

for i, v in enumerate(li):
    print(i, v)

③zip（）：数据的聚合打包

li = ["name", "python", "Java", "php"]
li2 = ["tony", "good", "good2", "good3"]
print(list(zip(li, li2)))

li = ["name", "python", "Java", "php"]
li2 = ["tony", "good", "good2", "good3"]
print(dict(zip(li, li2)))

扩展：若长度不相等，以最短的为标准

li = ["name", "python", "Java", "php"]
li2 = ["tony", "good", "good2"]
print(dict(zip(li, li2)))

**④filter（）：**过滤器
作用：批量的过滤数据
参数1：过滤的规则（函数）
参数2：需要过滤的数据

#过滤80分以上
stu = [45, 66, 88, 99, 100, 89, 97, 96]
new_list = []
for i in stu:
    if i >80:
        new_list.append(i)
print(new_list)

stu = [45, 66, 88, 99, 100, 89, 97, 96]
def func(x):
    return x>80

print(func(100))

stu = [45, 66, 88, 99, 100, 89, 97, 96]
def func(x):
    return x>80

print(list(filter(func, stu)))

stu = [45, 66, 88, 99, 100, 89, 97, 96]

print(list(filter(lambda x:x>80, stu)))