Python旅途——函数(1)

2019/06/20 21:24
阅读数 9

函数

简介

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

函数式编程

  • 函数本质:将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:找到上一级的变量,并对它进行修改
  • 以后全局变量都要大写,局部可以小写

总结

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

展开阅读全文
打赏
0
0 收藏
分享
加载中
更多评论
打赏
0 评论
0 收藏
0
分享
返回顶部
顶部