Python 全栈之路系列之函数

神奇的命令行
1,137 阅读11分钟
原文链接： blog.ansheng.me

函数

函数是Python为了代码最大程度的重用和最小化代码冗余而提供的最基本的程序结构。

  1. 函数式：将某功能代码封装到函数中，日后便无需重复编写，仅调用函数即可
  2. 面向对象：对函数进行分类和封装，让开发“更快更好更强…”

函数式编程最重要的是增强代码的重用性和可读性

创建的函数语法

  1. def 函数名(参数):
  2.     ...
  3.     函数体
  4.     ...
  5.     返回值

简单的实例

  1. # x为函数的参数
  2. >>> def num(x):
  3. ...  print(x)
  4. ...
  5. # 123456等于x
  6. >>> num("123456")
  7. 123456

函数的返回值

函数的返回值需要使用到return这个关键字，返回值主要是用来接受函数的执行结果

  1. >>> def re():
  2. ...   if 1==1:
  3. ...     return True
  4. ...   else:
  5. ...     return False
  6. ...
  7. >>> re()
  8. True

函数return后面是什么值，re就返回什么值，如果没有指定return返回值，那么会返回一个默认的参数None

在函数中，当return执行完成之后，return后面的代码是不会被执行的

  1. >>> def ret():
  2. ...  print("123")
  3. ...  return True
  4. ...  print("abc")
  5. ...
  6. >>> ret()
  7. 123
  8. True

位置参数

传入参数的值是按照顺序依次赋值过去的。

代码

  1. # x==形式参数，形式参数有几个，那么实际参数就要传几个，默认参数除外
  2. def ret(x):
  3.     print(x)
  4. # "Hello Word"实际参数
  5. print(ret("Hello Word"))

执行结果

  1. Hello Word

如图所示:
Python-Day04-04

ret小括号内的值会被传入到函数ret里面都能做x的值，结果差不多就是print("Hello Word")

函数的普通参数实例：发送邮件

  1. def email(mail):
  2.     import smtplib
  3.     from email.mime.text import MIMEText
  4.     from email.utils import formataddr
  6.     msg = MIMEText('邮件内容', 'plain', 'utf-8')
  7.     msg['From'] = formataddr(["测试",'asdasd@126.com'])
  8.     msg['To'] = formataddr(["走人",'asdasdasd@163.com'])
  9.     msg['Subject'] = "主题"
  11.     server = smtplib.SMTP("smtp.126.com", 25)
  12.     server.login("wdfgfghfgh@126.com", "123456")
  13.     server.sendmail('asdasdas@126.com', [mail,], msg.as_string())
  14.     server.quit()
  16. email("6087414@qq.com")

当执行这个脚本的时候会给邮箱6087414@qq.com发送邮件。

注：上面的邮箱地址等都是随便写的，请自行更改

指定参数

  1. >>> def ret(a,b,c):
  2. ...  print(a,"a")
  3. ...  print(b,"b")
  4. ...  print(c,"c")
  5. ...
  6. >>> ret(b="bbb",a="aaa",c="ccc")
  7. aaa a
  8. bbb b
  9. ccc c

默认情况在再函数ret括号内如果要输入函数参数的值，是要按照顺序来的，但是如果在ret括号内制定的参数的值，那么就不需要按照顺序来了。

默认参数

如果我们在创建函数的时候给函数定义了值，那么在调用函数的时候如果不填写值程序就会报错：

  1. >>> def ret(x):
  2. ...  print(x)
  3. ...
  4. >>> ret()
  5. Traceback (most recent call last):
  6.   File "<stdin>", line 1, in <module>
  7. TypeError: ret() missing 1 required positional argument: 'x'

如果要解决这个问题就可以给函数的值指定一个默认值，指定函数的默认值需要在def这一行指定，制定之后，当调用这个函数的时候就不需要输入函数值了。

  1. >>> def ret(x="Hello Word"):
  2. ...  print(x)
  3. ...
  4. >>> ret()
  5. Hello Word
  6. # 如果值指定默认值，那么实际参数替换掉形式参数
  7. >>> ret("Pythoner")
  8. Pythoner

如果给函数创建了默认值，那么有默认值的这个参数必须在最后面定义，不能够在没有默认参数的值的前面。

动态参数

动态参数把接收过来的实际参数当作一个元组，每一个参数都是元组中的一个元素。

第一种动态参数

定义第一种动态参数需要在参数前面加上一个*号

  1. >>> def ret(*args):
  2. ...  print(args,type(args))
  3. ...
  4. >>> ret(11,22,33)
  5. (11, 22, 33) <class 'tuple'>

第二种动态参数

定义第二种动态参数需要在参数前面加上两个*号，给参数传参的时候是一个key对应一个value的，相当于一个字典的键值对，而且返回的类型就是字典类型。

使用两个星号可以将参数收集到一个字典中，参数的名字是字典的键，对应参数的值是字典的值。

  1. >>> def ret(**kwargs):
  2. ...  print(kwargs,type(kwargs))
  3. ...
  4. >>> ret(k1=123,k2=456)
  5. {'k1': 123, 'k2': 456} <class 'dict'>

第三种动态参数

第三种又称为万能的动态参数，如下实例：

  1. >>> def ret(*args,**kwargs):
  2. ...  print(args,type(args))
  3. ...  print(kwargs,type(kwargs))
  4. ...
  5. >>> ret(11,222,333,k1=111,k2=222)
  6. (11, 222, 333) <class 'tuple'>
  7. {'k1': 111, 'k2': 222} <class 'dict'>

字典小例子：

  1. >>> def arg(**kwargs):
  2. ...  print(kwargs,type(kwargs))
  3. ...
  4. >>> dic = {"k1":123,"k2":456}
  5. >>> arg(k1=dic)
  6. {'k1': {'k1': 123, 'k2': 456}} <class 'dict'>
  7. >>> arg(**dic)
  8. {'k1': 123, 'k2': 456} <class 'dict'>

避免可变参数的修改

如果不想在函数内部修改参数值而影响到外部对象的值，我们可以使用切片的方式进行参数的传递：

  1. #!/use/bin/env python
  3. L = ['a', 'b']
  4. def changer(L):
  5.     L[0] = 0
  6. print(L)
  7. changer(L)
  8. """
  9. ['a', 'b']
  10. [0, 'b']
  11. """
  12. # changer(L[:])
  13. """
  14. ['a', 'b']
  15. ['a', 'b']
  16. """
  17. print(L)

参数解包

  1. In [2]: def f(a, b, c, d): print(a, b, c, d)
  3. In [3]: args = (1, 2)
  5. In [4]: args += (3, 4)
  7. In [5]: f(*args)
  8. 1 2 3 4

又或者使用

  1. def f(a, b, c, d): print(a, b, c, d)
  2. args = {'a': 1, 'b': 2, 'c': 3, 'd': 4}
  3. f(**args)

参数书写位置

在函数调用中： 位置参数 –》 关键字参数 –》元组形式–》字典形式
在函数头部： 一般参数–》默认参数–》元组形式–》字典形式

  1. def func(name, age=None, *args, **kwargs):
  2.     print(name, age, args, kwargs)
  4. func('ansheng', 18, *(1, 2, 3), **{'blog': 'blog.ansheng.me'})

全局变量和局部变量

简单的理解全局变量和变量，全局变量可以理解为在当前这个文件内定义的变量，局部变量则是在函数内定义的变量，如下例：

  1. # qa
  2. # 全局变量
  3. n1 = 1
  4. def num():
  5.     # 局部变量
  6.     n2 = 2
  7.     print(n1)
  8.     print(n2)
  9. num()

输出的结果

  1. C:\Python35\python.exe F:/Python_code/sublime/Day05/def.py
  2. 1
  3. 2

定义的全局变量都可以在函数内调用，但是不能再函数内修改，局部变量在也不能够直接调用，如果要在函数内修改全局变量，那么就需要用到关键字``

  1. n1 = 1
  2. def num():
  3.     n2 = 2
  4.     global n1
  5.     n1 = 3
  6.     print(n1)
  7.     print(n2)
  8. num()

执行结果

  1. C:\Python35\python.exe F:/Python_code/sublime/Day05/def.py
  2. 3
  3. 2

nonlocal语句

nonlocal是用来修改嵌套作用域中的变量，类似于global一样，只需要在嵌套函数中声明变量名即可，但是这个变量名是必须已经存在的否则就会报错，如果要修改的变量在作用域中查找不到，那么不会继续到全局或内置作用域中查找。

  1. In [1]: def func1(arg1):
  2.    ...:     n = arg1
  3.    ...:     print(n)
  4.    ...:     def func2():
  5.    ...:         nonlocal n
  6.    ...:         n += 1
  7.    ...:     func2()
  8.    ...:     print(n)
  9.    ...:     
  11. In [2]: func1(10)
  12. 10
  13. 11

Lambda表达式

Lambda（Lambda expressions）表达式是用lambda关键字创建的匿名函数，Lambda函数可以用于任何需要函数对象的地方，在语法上，它们被局限于只能有一个单独的表达式。

使用Lambda表达式创建函数

  1. >>> f = lambda x,y : x + y
  2. >>> f(1,2)
  3. 3

使用def创建函数

  1. >>> def f(x,y):
  2. ...  return x + y
  3. ...
  4. >>> f(1,2)
  5. 3

对于比较简单的函数我们就可以通过lambda来创建，它的的好处是缩短行数。

lambda创建的函数和def创建的函数对应关系如图所示：

Python-Day05-01

嵌套lambda和作用域

  1. def action(x):
  2.     return (lambda y: x + y)
  4. act = action(99)
  5. print(act)
  6. result = act(2)
  7. print(result)

输出为：

  1. <function action.<locals>.<lambda> at 0x1021e6400>
  2. 101

lambda也能够获取到任意上层lambda中的变量名：

  1. action = lambda x: (lambda y: x + y)
  2. act = action(99)
  3. print(act)
  4. result = act(3)
  5. print(result)

输出为：

  1. <function <lambda>.<locals>.<lambda> at 0x1029e6400>
  2. 102

测试题

第一题

简述普通参数、指定参数、默认参数、动态参数的区别

普通参数即是用户在调用函数是填入的参数，且参数位置必须与参数保持一致。

指定参数即在用户调用函数的时候不需要按照函数中参数的位置中所填写，指定参数是需要制定参数对应的值。

默认参数可以写在定义参数的后面，如果用户调用函数是没有制定参数，那么就会用默认参数，如果用户指定了参数，那么用户指定的参数就会代替默认参数。

动态参数可以接受用户输入的任何参数，包括字典、列表、元组等数据类型。

第二题

计算传入字符串中数字、字母、空格以及其他的个数

  1. def var(s):
  2.     all_num = 0
  3.     spance_num = 0
  4.     digit_num = 0
  5.     others_num = 0
  6.     for i in s:
  7.         # 检测数字
  8.         if i.isdigit():
  9.             digit_num += 1
  10.         # 检测空格
  11.         elif i.isspace():
  12.             spance_num += 1
  13.         # 检测字母
  14.         elif i.isalpha():
  15.             all_num += 1
  16.         else:
  17.             # 其他
  18.             others_num += 1
  19.     return ("字母：",all_num,"空格：",spance_num,"数字",digit_num,"其他字符",others_num)
  20. num = var("21323 asd*%^*^% &*213asdasdasda sdasdasd")
  21. print(num)

执行结果

  1. C:\Python35\python.exe F:/Python_code/sublime/operation/Day05/c.py
  2. ('字母：', 21, '空格：', 3, '数字', 8, '其他字符', 8)

第三题

写函数，判断用户传入的对象（字符串、列表、元组）长度是否大于5，如果大于5就返回True，如果小于5就返回False

  1. # 定义一个函数num
  2. def num(x):
  3.     # 判断函数的值如果长度大于5就返回True
  4.     if len(x) > 5:
  5.         return True
  6.     # 否则就返回False
  7.     else:
  8.         return False
  10. ret = num(["asd","asdasd","asdasd","asdasd"])
  11. print(ret)
  12. ret = num("asdasdasd")
  13. print(ret)

第四题

写函数，检查用户传入的对象（字符串、列表、元组）的每一个元素是否含有空内容，如果有空就返回False

  1. # 定义一个函数num
  2. def num(x):
  3.     # 循环输出num内的所有内容
  4.     for n in x:
  5.         # 数据类型转换为字符串
  6.         n = str(n)
  7.         # 如果有空格就返回False
  8.         if n.isspace():
  9.             return False
  11. ret = num(" ")
  12. print(ret)
  14. ret = num("asdasd")
  15. print(ret)
  17. ret = num(["asd","312",123," "])
  18. print(ret)

第五题

写函数，检查传入列表的长度，如果大于2，那么仅保留前两个长度的内容，并将新内容返回给调用者。

  1. def num(x):
  2.     # 如果列表中的长度大于2,那么就输出列表前两个内容，否则就返回一个空
  3.     if len(x) > 2:
  4.         return x[:2]
  5.     else:
  6.         return ""
  7. print(num(["11","22","33"]))
  9. print(num(["33"]))

第六题

写函数，检查获取传入列表或元组对象的所有奇数位索引对应的元素，并将其作为新列表返回给调用者。

  1. def num(x):
  2.     # 定义一个空列表用于接收奇数位的元素
  3.     resule = []
  4.     # 循环输出列表中的所有元素值
  5.     for n in range(len(x)):
  6.         # 如果列表中的位置为奇数就把值添加到resule列表中
  7.         if n % 2 == 1:
  8.             resule.append(x[n])
  9.     # 然会resule列表中的内容
  10.     return resule
  12. ret = num([11,22,33,44,55,66])
  13. print(ret)

第七题

写函数，检查传入字典的每一个value的长度,如果大于2，那么仅保留前两个长度的内容，并将新内容返回给调用者。

  1. dic = {"k1": "v1v1", "k2": [1111,22,33,44]}

PS:字典中的value只能是字符串或列表

代码

  1. def dictt(x):
  2.     # 循环字典中所有的key
  3.     for k in x.keys():
  4.         # 如果字典中k对应的元素是字符串类型就下面的判断
  5.         if type(x[k]) == str:
  6.             # 如果元素的长度大于2
  7.             if len(x[k]) > 2:
  8.                 # 那么就让这个元素重新赋值，新的值只保留原来值的前两个
  9.                 x[k]=x[k][0:2]
  10.         # 如果字典中k对应的元素类型是列表，就进入下面的判断
  11.         elif type(x[k]) == list:
  12.             # 先把列表中的值全部for循环
  13.             for i in x[k]:
  14.                 # 把元素转换为字符串
  15.                 string = str(i)
  16.                 # 如果元素的长度大于2
  17.                 if len(string) > 2:
  18.                     # 获取元素的索引值
  19.                     num = x[k].index(i)
  20.                     # 先把这个元素给删除
  21.                     x[k].pop(x[k].index(i))
  22.                     # 然后再添加一个新的元素，新元素的只保留原来元素的前两个
  23.                     x[k].insert(num,string[:2])
  24.     # 把结果return出来
  25.     return dic
  26. ret = dictt(dic)
  27. print(ret)
  • 执行结果
  1. C:\Python35\python.exe F:/Python_code/sublime/operation/Day05/h.py
  2. {'k1': 'v1', 'k2': ['11', 22, 33, 44]}

当前文章非永久URL：https://blog.ansheng.me/article/python-full-stack-way-function/

创建时间：Dec. 29, 2016, 9:08 p.m.

更新时间：Feb. 1, 2017, 4:10 p.m.

mode_edit
avatar
文章
阅读
粉丝