Python旅途——函数(1)

函数

简介

到目前为止，我们一直所接触的都是属于面向过程编程，这样的代码会降低代码的可读性，因此引入了函数式编程，在后面我们还会学到面向对象编程。

函数式编程

• 函数本质：将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)
  

• 调用函数

  1. 位置参数在前
  2. 关键参数在后

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.一般常用的需要记住的：

1. str
   • strip 返回str
   • split 返回str
   • replace 返回str
   • upper 返回str
   • lower 返回str
   • join 返回str
2. list
   • append 无返回值
   • insert 无返回值
   • pop 返回要删除的数据
   • remove 无返回值
   • find/index 返回索引位置
3. 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中：

1. py文件 为全局作用域
2. 函数为局部作用域

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)
  
  

  • 重新赋值
    1. global：找到全局变量并可以对它进行重新赋值
    2. nonlocal：找到上一级的变量，并对它进行修改

• 以后全局变量都要大写，局部可以小写

总结

主要对于函数的参数、返回值、以及函数的作用域做了简单的介绍和分享。