函数
简介
到目前为止，我们一直所接触的都是属于面向过程编程，这样的代码会降低代码的可读性，因此引入了函数式编程，在后面我们还会学到面向对象编程。
函数式编程
函数本质：将N行代码拿到别处，并给他起个名字，以后通过名字就可以找到这段代码并执行。
应用场景：代码重复执行，代码量特别多超过一屏，可以选择函数进行代码的分割
面向对象编程
- 对函数进行分类和封装，让开发“更快更好更强...”
函数基本结构：
def 函数名():
# 函数内容
函数名() #执行函数
注：如果函数没被调用，则内部代码永不执行参数
1.参数的使用
- 参数调用可以是任意的类型，同样的return返回值也可以是任意类型
2.强制转换
v1 = [1,2,3,4]
v2 = tuple(v1)
v1 = (1,2,3,4)
v2 = list(v1)3.位置传参(调用函数，并传入参数)
def func(a,b,c):
pass
func(1,2,3)4. 关键字传参
def func(a,b,c):
pass
func(k1 = 1,k2 = 2,k3 = 3)- 位置参数和关键字参数可以混合使用，位置参数一定在前面，关键字参数一定在后面。
5. 默认参数
def func(a,b = 3):
pass
func(11) # 可以只写一个值，则另外一个默认就是3
func(2,3) # 也可以写两个值，这样就是把2赋值给a，把3赋值给b，b不在取默认值6. 万能参数
*args :不支持关键字传参，只能传位置参数，可以接收n个位置参数，并且将参数转化为元组
调用函数无 *：
def func(*args):
print(args)
func(1,2,3...) # 不支持关键字传参，只能传位置参数，可以接收n个位置参数，并且将参数转化为元组 调用函数有 *：
def func(*args):
print(args)
func(*(1,2,3,4))
func(*[1,2,3,4])**kwargs :不支持位置传参，只能关键字传参，可以接收n个关键字参数，并且转化为字典
调用函数无**：
def func(**kwargs):
print(kwargs)
func(k1=1,k2=2,k3=3...) # 不支持位置传参，只能关键字传参，可以接收n个关键字参数，并且转化为字典
调用函数有**：
def func(**kwargs):
print(kwargs)
func(**{'k1':'alex','k2':'eric'}) # kwargs={'k1':'v2','k2':'v2'}
- 综合应用 ：*args + **kwargs = 无敌
def func(*args,**kwargs):
print(*args,**kwargs)
func(1,2,3,k1=1,k2=3,k3=5)
func(*[1,2,3],k1=2,k5=9,k19=999)
func(*[1,2,3],**{'k1':1,'k2':3})
func(111,222,*[1,2,3],k11='alex',**{'k1':1,'k2':3})7. 参数相关知识重点
定义函数：
# 第一种 def func(a,b): pass func(1,2) # 第二种 def func(a,b=None): pass func(1) # 第三种 def func(*args,**kwargs): pass func(1,k1=1)调用函数
- 位置参数在前
- 关键参数在后
def get_list_first_data(aaa): # aaa叫形式参数(形参)
v = [11,22,33,44]
print(v[aaa])
get_list_first_data(1) # 2/2/1调用函数时传递叫：实际参数（实参） 练习：
# 1. 请写一个函数，函数计算列表 info = [11,22,33,44,55] 中所有元素的和。
def value(x):
var = 0
for i in x:
var += i
print(var)
v1 = value([11,22,33,44,55])# 2. 请写一个函数，函数将两个列表拼接起来。
def value(x,y):
list1 = []
list1.extend(x)
list1.extend(y)
print(list1)
value([1,2,3],['alex','eric'])# 3. 计算一个列表的长度
def length(x):
var = 0
for i in x:
var += 1
print(var)
length([1,2,3,4,5])返回值：
- 函数是一个功能块，该功能到底执行成功与否，需要通过返回值来告知调用者。
1.数据类型中的方法到底有没有返回值？
- 有返回值
- 无返回值
- 有返回+修改数据
2.一般常用的需要记住的：
- str
- strip 返回str
- split 返回str
- replace 返回str
- upper 返回str
- lower 返回str
- join 返回str
- list
- append 无返回值
- insert 无返回值
- pop 返回要删除的数据
- remove 无返回值
- find/index 返回索引位置
- dict
- get 有返回值
- keys 有返回值
- values 有返回值
- items 有返回值
- 基本格式
def func(arg):
# ....
return 9 # 返回值为9 默认：return None
val = func('adsfadsf')- 下面是一些简单的练习题来深入理解返回值的概念
# 练习
1.写函数，计算一个列表中有多少个数字，打印： 列表中有%s个数字。 提示：type('x') == int 判断是否是数字。
def num(list):
var = 0
for i in list:
if type(i) == int:
var += 1
return var
v1 = num(['sdf',1,2,3,'sdf'])
print(v1)# 2. 写函数，计算一个列表中偶数索引位置的数据构造成另外一个列表，并返回。
def double(list):
var = []
for i in range(0,len(list)) :
if i%2 == 0:
var.append(list[i])
return var
v1 = double([1,2,3,4,5,6])
print(v1)# 3. 读取文件，将文件的内容构造成指定格式的数据，并返回。
"""
a.log文件
alex|123|18
eric|uiuf|19
...
目标结构：
a. ["alex|123|18","eric|uiuf|19"] 并返回。
b. [['alex','123','18'],['eric','uiuf','19']]
c. [
{'name':'alex','pwd':'123','age':'18'},
{'name':'eric','pwd':'uiuf','age':'19'},
]
"""
a:
def var():
list = []
with open('a.log',mode='r',encoding='utf-8') as f:
for line in f:
list.append(line)
return list
v1 = var()
print(v1)
b:
def var():
list = []
with open('a.log',mode='r',encoding='utf-8') as f:
for line in f:
line = line.strip()
new_line = line.split("|")
list.append(new_line)
return list
v1 = var()
print(v1)
c:
def var():
list = []
with open('a.log',mode='r',encoding='utf-8') as f:
for line in f:
line = line.strip()
new_line = line.split("|")
a,b,c = new_line
info = {}
info['name'] = a
info['pwd'] = b
info['age'] = c
list.append(info)
return list
v1 = var()
print(v1)
作用域
Python中：
- py文件 为全局作用域
- 函数为局部作用域
a = 1
def s1():
x1 = 666
print(x1)
print(a)
print(b)
b = 2
print(a)
s1()
a = 88888
def s2():
print(a,b)
s1()
s2() #打印结果 1,666,1,2，8888,2,666,8888,2总结：
- 一个函数是一个作用域
- 作用域中查找数据规则：优先在自己的作用域中寻找，自己的作用域没有的话，就去父级的作用域里面找，直到找完全局作用域
练习题 !/usr/bin/env python -*- coding:utf-8 -*- x = 10 def func(): x = 9 print(x) def x1(): x = 999 print(x) func() x = 10 def func(): x = 9 print(x) def x1(): x = 999 print(x) x1() func() # 9,999 x = 10 def func(): x = 9 print(x) def x1(): x = 999 print(x) print(x) x1() func() #9,9,999 x = 10 def func(): x = 8 print(x) def x1(): x = 999 print(x) x1() print(x) func() #8,999,8 x = 10 def func(): x = 8 print(x) def x1(): print(x) x1() print(x) func() # 8,8,8 x = 10 def func(): x = 8 print(x) def x1(): print(x) x = 9 x1() x = 10 print(x) func() # 8,9,10 x = 10 def func(): x = 8 print(x) def x1(): print(x) x1() x = 9 x1() x = 10 print(x) func() # 8,8,9,10-- 子作用域中只能找到父级中的值，默认无法重新为父级的变量重新赋值
name = 'dali' def func(): name = 'alex' # 在自己作用域再创建一个这样的值。 print(name) func() print(name) # ##################### name = [1,2,43] def func(): name.append(999) print(name) func() print(name) # ###################### 如果非要对全局的变量进行赋值 # 示例一 name = ["大栗",'alex'] def func(): global name name = '我' func() print(name) # 示例一 name = "大栗" def func(): name = 'alex' def inner(): global name name = 999 inner() print(name) func() print(name) # ##################### name = "大栗" def func(): name = 'alex' def inner(): global name name = 999 inner() print(name) func() print(name) # ##################### name = "大栗" def func(): name = 'alex' def inner(): nonlocal name # 找到上一级的name name = 999 inner() print(name) func() print(name)- 重新赋值
- global：找到全局变量并可以对它进行重新赋值
- nonlocal：找到上一级的变量，并对它进行修改
以后全局变量都要大写，局部可以小写
总结
主要对于函数的参数、返回值、以及函数的作用域做了简单的介绍和分享。