美文网首页
python+AI第五课

python+AI第五课

作者: M_小七 | 来源:发表于2019-11-09 16:08 被阅读0次
函数 function
def 函数名():
    # 函数实现
    pass # pass空语句
# 函数执行的顺序,调用的时候才会被执行
num = 100
print(num)
# 100
def say_hello():
    print('hello1')
    print('hello2')

    print('hello3')
print('haha')
# # 调用函数
say_hello()
'''
haha
hello1
hello2
hello3
'''

\color{blue}{为什么使用函数}
1 代码重用 2 便与修改,易扩展

# 7个长度的字符串,替换第三个字符
str1 = 'abcdefg'
str1 = str1[:2] + 'z' + str1[3:]
print(str1)
#abzdefg
str1 = '1234567'
str1 = str1[:2] + '8' + str1[3:]
print(str1)
#1284567

改进封装成函数

def set_str(msg,index,char):
    """
    将目标字符串的指定位置进行替换
    :param msg: 目标字符串
    :param index: 替换字符串的索引位置
    :param char: 要替换的字符
    :return: 返回替换完成的字符串
    """
    res = msg[:index] + char + msg[index+1:]
    return res
    # 对给定的char进行判断  isinstance(char, type) 判断两个变量是否属于某种类型
    if isinstance(char, int):
        char = str(char)
    return msg[:index] + char + msg[index + 1:]
    res = set_str('1234567',2, '9')
    set_str('abcdefddd',1, 9)
    res = set_str('abcdefddd',1, 9)

    print(res)
  • 函数的形参和实参
    形式参数、实际调动的参数
    区别: 形参式虚拟的,不占内存空间,形参变量只有在被调用的时候才分配内存空间; 实参是一个变量,占用内存空间,数据是单向传送的 实参传给形参,
# 求矩形面积
def area(width, length):
    return width*length
w = 4
l = 6
print(area(width=4,length=6))
print(area(4,6))
#24
  • 函数参数
    1、必须参数:以正确的顺序传入函数,调用的时候必须和声明的时候保持一致
def f(name, age):
    print('我叫%s,我今年%d岁'%(name, age))
f('张三',18)
#我叫张三,我今年18岁
f(18, '李四') #错误的
#%d format: a number is required, not str

2、关键字参数, 关键字参数允许函数调用时参数的顺序与声明不一致,因为Python解释器能够用参数名匹配参数值

f(age=19, name='李四')

3、默认参数(缺省参数)
在调用函数时,缺省的参数如果没有被传入,则会使用默认值

def f(name, age, sex = 'male'):
    print('我叫%s,我今年%d岁'%(name, age))
    print('性别%s'%(sex))
# f(age=19, name='李四')
f(age=19, name='李四',sex='female')
# 我叫李四,我今年19岁
# 性别female

4、不定长参数
有时候可能需要一个函数能处理比当初声明时更多的参数,这些参数叫不定长参数

def funcname([formal_args,]*args,**kwargs):
    """文档字符串"""
    pass

加了星号的变量args会存放所有未命名的变量参数,args为元组
加了星星号的变量kwargs会存放命名参数,即形如 ket=value形式的参数, kwargs为字典

例1func(1, 2, c, d) 注意不加星号的传入方式

def func(a, b, *args, **kwargs):
    """
    可变参数演示示例
    :param a: formal_args
    :param b: formal_args
    :param args: 未命名的变量参数 args为元组
    :param kwargs: 命名参数 kwargs为字典
    :return: 无
    """
    print('a = ', a)
    print('b = ', b)
    print('args=', args)
    print('kwargs = ')
    for k, v in kwargs.items():
        print(k, '----->',v)

c = (3, 4, 5)
d = {"m":6,"n":7,"p":8}
func(1, 2, c, d) # 注意不加星号的传入方式
# a =  1
# b =  2
# args= ((3, 4, 5), {'m': 6, 'n': 7, 'p': 8})
# kwargs = 

例1func(1, 2, *c, **d) 加星号的传入方式

def func(a, b, *args, **kwargs):
    """
    可变参数演示示例
    :param a: formal_args
    :param b: formal_args
    :param args: 未命名的变量参数 args为元组
    :param kwargs: 命名参数 kwargs为字典
    :return: 无
    """
    print('a = ', a)
    print('b = ', b)
    print('args=', args)
    print('kwargs = ')
    for k, v in kwargs.items():
        print(k, '----->',v)
c = (3, 4, 5)
d = {"m":6,"n":7,"p":8}
func(1, 2, *c,**d)
func(1, 2, 3, 4, 5, m=6, n=7, p=8)#结果相同
# a =  1
# b =  2
# args= (3, 4, 5)
# kwargs = 
# m -----> 6
# n -----> 7
# p -----> 8
def f(*args):
    print(args)

f(*[1,2,5])
#(1, 2, 5)
def f1(**kargs):
    print(kargs)

f1(**{'name':'alex'})
# {'name': 'alex'}
  • 函数的返回值
    如果想要获取函数的执行结果,我们一般要编写函数的返回值,使用return可以把结果返回
    return 作用: return停止这个函数的执行,返回指定的结果
    Python中的return可以返回多个对象, 解释器会将其组装成一个元组作为一个整体结果输出
    如果未指定return,那么这个函数的返回值是 None
    例:
给定一个list 将列表中所有数字进行累加,并且返回他们的累加和以及平均数
def sum_and_ave(list):
    """
    :param list: 给定一个列表
    :return: 返回他们的累加和以及平均数
    """
    count = 0
    sum = 0
    for x in list:
        if isinstance(x, int) or isinstance(x, float):
            # 进行累加
            sum += x
            # 计数
            count +=1
    ave = sum/count
    return sum, ave
li = [20, 15, 2.8, 'a', 35, 5.9, -1.8]
print(sum_and_ave(li))
print('累加和',sum_and_ave(li)[0])
print('平均数',sum_and_ave(li)[1])
# (76.9, 12.816666666666668)
# 累加和 76.9
# 平均数 12.816666666666668
  • 高阶函数
    满足,输入:接受一个或多个函数, 输出:一个函数
def add(x, y, f):
    return f(x) + f(y)
# 传入的是函数名
res = add(3, -6, abs)#abs绝对值
#9

def method():
    x = 2
    def double(n):
        return n*x
    return double
d = method()
res2 = d(40)
print(res2)
#80
  • Python系统高阶函数
    1.map()
    map(func, iterable)
    函数接收两个参数,一个是函数,一个是Iterable,map将传入的函数依次作用到序列的每个元素,最后把处理的结果作为新的可迭代对象返回
# 举例: [1, 2, 3, 4, 5] -> [1, 4, 9, 16, 25]
def power(x):
    return x*x
result = map(power, [1, 2, 3, 4, 5])
print(list(result))
# [1, 4, 9, 16, 25]

# 使用map函数: [1, 2, 3, 4, 5, 6, 7, 8, 9] -> ['1', '2', '3', '4', '5', '6', '7', '8', '9']

res2 = map(str,[1, 2, 3, 4, 5, 6, 7, 8, 9])
print(list(res2))
# ['1', '2', '3', '4', '5', '6', '7', '8', '9']

2.reduce()
reduce(func, sequence) 函数,累积操作。
func函数必须接受两个参数, reduce会把func的运行结果继续和序列的下一个元素做累积计算,reduce(func, [1,2,3]) 等同于 func(func(1,2), 3)

引入
from functools import reduce
def mul(x, y):
    return x*y
li = [1, 2, 3, 4, 5]
res = reduce(mul, li)
print(res)
#120
#理解为mul(mul(mul(mul(1*2)*3)*4)*5)

3.lambda匿名函数
表达式: 不需要显示指定名字的函数

格式
函数名 = lambda 参数1,参数2,。。。n :返回表达式

lambda 的参数可以是无限个,但是返回表达式只能有一个
优点: 1、用担心函数名冲突 2、减少代码量 3、优雅
lambda主要目的是联合其他函数使用

print(reduce(lambda x, y: x * y, li))
#120

4.filter()
filter(func,iterable) 和map相似接收一个函数和一个序列
与map()不同的是,filter()把传入的函数依次作用于每个元素,然后根据返回值是True还是False决定保留还是丢弃该元素。

# 如果函数返回True,则保留该数据,否则就不保留
li = [i for i in range(1, 15)]
# 将li 中所有的奇数筛选出来
print(list(filter(lambda x: x % 2 == 1, li)))
# [1, 3, 5, 7, 9, 11, 13]

5.sorted()
对数据进行排序,并且返回一个新的对象,原对象不变

from random import randint
li2 = [randint(-10,10) for _ in range(5)]
#li2 = [10, 2, 7, -5, 3]
print('排序前',li2)
res = li2.sort() # None
res = sorted(li2)
print('排序后',li2)
print('返回值',res)
# 排序前 [-4, -10, 10, 3, 7]
# 排序后 [-10, -4, 3, 7, 10]
# 返回值 [-10, -4, 3, 7, 10]

key参数可以用来指定排序的规则,key接受的值是一个函数

li2 = [-4, -10, 10, 3, 7]
res = sorted(li2, key=abs)
print(res)
#[3, -4, 7, -10, 10]
#按照绝对值排序

reverse参数是指定排序的顺序(升序还是降序),默认是升序

chars = ['lee', 'james', 'kobe', 'Antetokounmpo', 'jordan', ]
# 对chars进行排序 按照字母的长度 降序
chars = sorted(chars, key=len, reverse=True)
print(chars)
# ['Antetokounmpo', 'jordan', 'james', 'kobe', 'lee']
chars = sorted(chars, key=lambda x:len(x), reverse=True)
print(chars)
# ['Antetokounmpo', 'jordan', 'james', 'kobe', 'lee']

复合列表结构的列表排序

grade_list = [
    {'name':'张三', 'grade':90},
    {'name':'李四', 'grade':30},
    {'name':'王五', 'grade':70},
    {'name':'赵六', 'grade':52},
]
print(grade_list)
# 按照成绩进行排序
grade_list = sorted(grade_list, key=lambda d:d['grade'])
print(grade_list)

stu_info = [
    ('wunan',22),('yangjiulin',39),('hanlei',17),('chenzhenqi', 90)
]
# 按照年龄降序排序
stu_info = sorted(stu_info, key=lambda x:x[1], reverse=True)
print(stu_info)

回顾三目运算符

store = ['']
print(len(store))
if len(store) == 0:
    store = '当当自营'
else:
    store = store[0]
print(store)
# 改成三目运算符
print('当当自营' if len(store) == 0 else store[0])
# 满足条件时返回的值 if 满足的条件 else 不满足条件时返回的值

# 将 x, y   如果 x>y  返回 x*y  else x <= y x /y需求使用lambda表达式进行编写
res = lambda x, y:x*y if x > y else x/y
print(res(2, 5))
print(res(5, 2))

相关文章

网友评论

      本文标题:python+AI第五课

      本文链接:https://www.haomeiwen.com/subject/uhwwbctx.html