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

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)

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

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

总结

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

巴特西

Python旅途——函数(1)

函数

简介

函数式编程

面向对象编程

函数基本结构：

参数

1.参数的使用

2.强制转换

3.位置传参(调用函数，并传入参数)

4. 关键字传参

5. 默认参数

6. 万能参数

7. 参数相关知识重点

返回值：

1.数据类型中的方法到底有没有返回值？

2.一般常用的需要记住的：

作用域

总结

最新文章

热门文章