python基础知识-函数

python基础知识-函数

一.函数

1.1 认识函数

函数就是实现某一特定功能的代码的封装（函数是组织好的，可重复使用的，用来实现特定，或相关联功能的代码段）–函数就是实现某个特定功能的代码达成一个包，以后再需要这个功能的时候，直接使用函数就行了

1.2 函数作用

函数能提高应用的模块性，和代码的重复利用率

1.3定义函数

函数分类：

系统函数（由系统创建好的函数，只需要在使用他们功能时直接调用）

自定义函数（由程序员自己创建的函数）

（1）语法结构：

def 函数名（形参列表）：

​ 函数说明文档（可有可无）

​ 函数体

（功能说明区）
：param str1：（参数说明）需要统计的字符串
：return：（返回值说明）None

（2） 说明

def ————关键字：固定写法

函数名————程序员自己命名

• 两个要求：是标识符，不是关键字
• 三个规范：见名知义（看到函数名就大概直到函数的功能），不使用习题函数类名或者模块名；所有的字母都小写，多个单词之间下划线隔开

（）————固定写法

形参列表————以变量名1，变量名2，变量名3…的形式存在。每一个变量都是一个形参，形参的个数可以是任意个。形参可以将函数外部的数据传递到函数里面

函数说明文档————函数本质就是多行注释

函数体————函数体就是和def保持一个缩进的一条或者多条语句（至少一条），逻辑上，函数体就是实现函数功能的代码

（3）初学者定义函数的步骤：

• 第一步：确定函数功能
• 第二步：确定函数名
• 第三步：确定形参（看函数体需要几个形参）
• 第四步：确定函数体实现的功能（这个时候直接将形参作为对应的数据来使用）
• 第五步：确定函数返回值
• 第六步：写函数说明文档

#案例1：定义一个函数求任意两个数的和
def sum_1(num1, num2):
    print(num1 + num2)

sum_1(9, 10)

#案例2：
# 定义一个函数，求一个字符串中中文的个数
def count_chinese(str1):
    count = 0
    for i in str1:
        if '\u4e00' <= i <= '\u9fa5':
            count += 1
    print(count)


count_chinese("asdf啊打发")

#案例3
# 提取两个字符串公共的字符
def public_char(str1, str2):
    print(''.join(set(str1) & set(str2)))


public_char('asddf', 'asdofhjf')

#案例4
# 求10！
def cheng(num):
    count = 1
    for i in range(1, num + 1):
        count *= i
    print(count)


cheng(10)

1.4 调用函数（使用函数）

（1）语法

函数名（实参列表）————实参个数和形参个数要一致

（2）说明

函数名————必须是已经定义好的函数的函数名（需要哪个函数的功能就调用哪个函数，就写哪个函数的函数名）

（）————固定写法

实参列表————实参即使通过形参从函数外部传递到函数内部的数据，以’数据1，数据2，数据3…',这儿的每个数据就是一个实参

重要结论：定义函数的时候不会执行函数体，调用函数的时候才会执行，调用多少次，函数体就会执行多少次。

调用函数的过程：每次调用函数的时候’

（1）回到函数定义的位置

（2）传参（用实参给形参赋值）

（3）执行函数体

（4）确认返回值

（5）回到函数调用的位置接着往后执行

二.参数

1.1 位置参数和关键字参数

根据调用函数的时候提供的方式不同，可以将参数分为位置参数和关键字参数

（1）位置参数——直接将多个数据用逗号隔开，让实参和形参在位置上一一对应

（2）关键字参数——以“形参名1=实参1，形参名2=实参2…”形式存在的参数。参数的顺序无关紧要。

idef my_function(child3, child2, child1):
  print("The youngest child is " + child3)
my_function(child1 = "Phoebe", child2 = "Jennifer", child3 = "Rory")

注意：

• 不管赋值多少个，都必须保证每个实参都有值

• 如果位置参数和关键字参数一起使用，那么位置参数必须在关键字参数的前面一起使用

def my_function(child3, child2, child1):
  print("The youngest child is " + child3)
my_function( "Phoebe", child2 = "Jennifer", child3 = "Rory")

#my_function(child2 = "Jennifer", "Phoebe",  child3 = "Rory")————会报错（位置参数必须在关键字参数前）
#my_function( "Phoebe", child1 = "Jennifer", child3 = "Rory")——会报错————child1赋值了两次，child2没有赋值

1.2参数默认值

定义函数的时候可以以“形参名=值”的方式给形参赋默认值，有默认值的参数在调用的时候可以不用传参，在有默认值的情况下再次赋值就表示重新赋值。

• 如果要跳过前面有默认值的参数，直接给后面的参数传参，必须使用关键字参数
• 定义函数的时候可以有的参数有默认值，有的参数没有默认值，但没有默认值参数必须在有默认值参数前面

def my_function(country = "China"):
  print("I am from " + country)

my_function("Sweden")
my_function("India")
my_function()
my_function("Brazil")
#结果
I am from Sweden
I am from India
I am from China
I am from Brazil

#
def my_function(a,b,c=10):
    print(a,b,c)
    
my_function(a,b,c=20)

1.3参数类型说明

定义参数的时候可以对参数类型进行说明

• 没有默认值的参数：形参名:类型

  def fuc(str1:list):
      pass
  

• 有默认值的参数：默认值的数据类型就是参数类型

def func(str1:list,str2=''):
	pass

三.返回值

1.1 认识返回值

返回值就是从函数内部传递到函数外部的数据

定义函数的时候，需不需要添加返回值的建议：

• 实现函数的功能有没有产生新的数据，如果有新的数据，将新的数据作为返回值返回

1.2 怎么确定返回值

返回值就是return关键字后面的表达式的值（函数内部产生的数据，如果不用返回值返回时无法在函数外使用）

return 表达式————一遇到return函数就结束了

注意：print不等于return ，print只是在函数内部打印了一次返回值，return相当于从函数内部传了一个数据到函数外，在函数外可以使用这个数据————注意在循环中如果满足条件就要结束循环，否则会输出多个不一样的值，用break跳出循环，或者用continue跳过本次循环，看情况使用。

def sum_1(num1, num2):
    s1=num1+num2
    avg=s1/2
    return s1,avg#多个返回值写在一行，写在多行只会返回一个

sum_1(9, 10)

1.3如何使用函数返回值

函数调用表达式的值就是函数的返回值（python中每个函数调用都是有结果，这个结果就是这个函数在调用的时候得到的返回值）

函数调用表达式——调用函数的语句

def func():
    return 'abc'
func()
print(func)
print(func[-1])


def sum_1():
    return 100
sum_1()
print(sum_1)
print(sum_1+100)

#案例
#方法1：定义一个新列表（此时已经产生了新的数据，需要返回）
def del_minus(nums:list):
    new_nums=[]
    for i in nums:
        if i >0:
            new_nums.append(i)
    return new_nums
list1=[10,20,-7,-8,62]
result=del_minus(list1)
print(result)


#方法2：直接在原列表上修改
def del_minus(nums:list):
    for i in nums:
        if i<0:
            nums.remove(i)
list1=[10,20,-7,-8,62]
print(del_minus(list))#此时是在原列表上进行删除，没有新的数据进行返回，在执行完函数功能之后它本身就是想要的的数据，此时不需要return

1.4 return的作用

注意return只能在函数体中使用，（也可以直接写return，表示函数结束）

• 将数据作为函数的返回值返回
• 结束函数（执行函数体的时候如果遇到return，函数直接结束）

def funcz():
    print('+++++++++')
    print("__________")
    print("==========")

funcz()

#+++++++++
__________
==========

def funcz():
    print('+++++++++')
    return 100#遇到return函数就结束了，
    print("__________")
    print("==========")

funcz()

#+++++++++

def func3(n):
    for x in range(1, n):
        if n % 2 == 0:
            return x
        print(f':{x}')


print(func3(5))

#:1
:2
:3
:4
None

def func3(n):
    for x in range(1, n):
        if x % 3 == 0:
            return x
        print(f':{x}')


print(func3(5))

#:1
:2
3

四.变量作用域

1.1 变量作用域

变量作用域治的是变量定义完成后可以使用的有效范围

根据变量作用域的不同，可以将变量分为全局变量和局部变量

1.2 全局变量和局部变量

（1）全局变量

python没有定义在函数中或者类中的变量默认都是全局变量

作用域：从定义开始到程序结束

#a是全局变量
a=100
#i和b都是全局变量，只要是没有在类中或者是函数中的都是全局变量
for i in range(5):
    b=200

（2）局部变量

定义在函数中的变量就是局部变量

作用域：从定义开始到函数结束

（3）全局变量和局部变量的存储原理

1）全局变量默认保存在全局栈区间，全局栈区间会在程序结束后自动释放

2）调用函数的时候系统会自动为这个函数创建一个临时栈区间，用来保存在函数中产生的数据（局部变量就是保存在函数对应的临时栈区间中的），函数对应的临时栈区间会在函数调用结束的时候自动释放。

3）在函数中可以通过修改global修改局部变量的保存方式

在函数内部定义全局变量用global；在函数内部修改全局变量的值用global

name="小明"
def fun2():
    global num
    num=100
    
    global name#将函数内部的name变为全局变量，可以修改name的值，原本的name的值小明，修改后为小花
    name="小花"#局部变量，只能作用于函数内部，经过global修改为全局变量之后可以在函数外部使用

五.匿名函数

1.1 匿名函数

• 匿名函数-没有名字的函数

• 语法：函数名 lambda 形参列表:返回值（一般函数名不写）

  注意：

  （1） 匿名函数的形参至少一个

  （2）匿名函数的调用和普通函数一样

  （3）无默认值的类型说明在函数中不能使用（即str1：str）

  （4）匿名函数同样可以使用默认值的形式

#案例：定义一个匿名啊含糊，求任意两个函数的和
sum_1=lambda num1,num2:num1+num2

print(sum_1(100,200)
#result=sum_1(100,200)
#print(result)
      
      
sum_2=lambda num1=100,num2=200:num+num2
sum_2()#表示默认num1的和num2值为100，200然后做加法运算
      
      
#判断是否是闰年
year = lambda x: x % 4 == 0 and x % 100 != 0 or x % 400 == 0
print(year(2022))

六.实参高阶函数

函数参数就是函数的函数就是实参高阶函数

给参数是函数的参数传参：使用普通函数函数名；使用匿名函数

重点：掌握系统或者第三档库提供法提供的实参高阶函数用法

常见的实参高阶：max,min,sorted,列表.sort,map,reduce

def fun7():
    x()
def t():
    print("这是t函数")
    
fun7(t)#这里的t的是一个函数

#案例
def fun7(x):
    print(x(10,20)+30)#有参数，必须传两个参数


def t(a,b):
    return a*b

fun7(t)#这里要传函数名就行，不用跟（）
fun7(lambda a,b:a+b)

1.1.常见的高阶函数

可以在其中使用列表推导式（在任何地方都可以使用列表推导式，注意将之前学习过的知识联系起来））

（1）max（序列）——直接比较序列中元素的大小求最大值–普通用法

​ max（序列，key=函数）——按照函数制定的规则比较序列中元素的大小获取最大值–高级用法

• 函数要求
• 有且只有只一个参数**（这个参数代表序列中的每个元素）**
• 有一个返回值（返回值就是比较对象）

#求各位数最大的元素
num=[13,67,79,88,98,55]
result=[max(num,key=lambda x:x%10)]
print(result)


student = [
    {'name': 'stu1', "age": 20, "score": 88 },
    {"name": 'stu2', "age": 25, "score": 90},
    {"name": 'stu3', "age": 24, "score": 53}
]
result=max(student,key=lambda x:x["score"])
print(result)


#案例


# 求list1中长度最长的字符串
list1 = ["你好", "hiw are you", "thank you!and you ", "好好学习，天天向上"]
result=[max(list1,key=lambda x:len(x))]
print(result)

# 求num中十位数最小的数

num=[92,129,37,99,150,501]
result=min(num,key=lambda x:x%100//10)
print(result)

# 将所有的学生按照年龄从很小到大排序
student = [
    {'name': 'stu1', "age": 20, "score": 88},
    {"name": 'stu2', "age": 25, "score": 90},
    {"name": 'stu3', "age": 24, "score": 53}
]
result = sorted(student, key=lambda x: x["age"])
print(result)

# 求各个位之和最大的元素
nums = [123, 78, 90, 201, 192, 330]  # 将num中的的那个元素转换为str类型拆开，然后转换为整型做sum运算
result = max(nums, key=lambda a: sum([int(i) for i in str(a)]))
print(result)  # 可以在任何地方运用列表表达式
##方法2：
result=max(nums,key=lambda item:eval('+'.jooin(str(item))))
print(result)
#123->'123'->'+'.join(str(item))->eval('1+2+3')

（2）map————基于原序列中的元素创建一个新的序列

• map(函数，序列)————通过函数买哦书的规则基于序列中的元素创建一个新的序列，map的结果是一个迭代器（<map object at 0x000001CA3553EFA0>），并不是我们熟悉的数据，需要转换为序列。
  • 函数要求：有且只有一个参数（代表后面的这个序列中的每个元素）
  • 有一个返回值（返回值就是新序列中的元素）
• map(函数，序列1，序列2…)
  • 函数要求：
  • 有且只有两个参数（分别代表后面两个序列中的每个元素）
  • 有一个返回值（返回值就是新序列中的元素）

# 将num中所有元素乘10
num = [19, 20, 30, 40]
result = map(lambda x: x * 10, num)
print(list(result))#print（result）的结果是一个迭代器。并不是我们熟悉的数据，将其转换为序列

# 获取个位数
num = [20, 60, 45, 85, 66]
result = map(lambda item: item % 10, num)
print(list(result))

# 将num和num2中相同位置上的元素相乘，得到一个新的序列

num = [20, 60, 45, 85, 66]
num2 = [19, 20, 30, 40, 20]  # 注意位置要一一对应
result = map(lambda a, b: a * b, num, num2)
print(list(result))

names = ["张三", "里斯", "王二", "黄武", "李俊"]

result = map(lambda x: x[0], names)
print(list(result))

# 电子信息-stu1的形式
student = [
    {'name': 'stu1', "age": 20, "score": 88},
    {"name": 'stu2', "age": 25, "score": 90},
    {"name": 'stu3', "age": 24, "score": 53},
    {"name": 'stu4', "age": 26, "score": 80},
    {"name": 'stu5', "age": 24, "score": 66}
]

subject = ["电子信息", "金融", "会计", "计算机", "物联网"]

#方法1：初始化
result = map(lambda a, b: f'{b}-{a["name"]}', student, subject)
print(list(result))

#方法2：join。注意只需要一个参数（如果有多个参数，将其放入到一个序列中
result = map(lambda a, b: '-'.join([b,a["name"]]), student, subject)
print(list(result))
#方法3字符串连接
result = map(lambda a, b: b+'-'+a["name"], student, subject)
print(list(result))


#['张', '里', '王', '黄', '李']
['电子信息-stu1', '金融-stu2', '会计-stu3', '计算机-stu4', '物联网-stu5']

（3）reduce——将序列中的元素合并成一个数据（基于原序列中所有的元素得到一个数据）

• 一般形式：reduce(函数，序列，初始值)——按照函数制定的规则将序列中的元素合并成一个数据

• 函数要求：

  • 有且只有两个函数（第一个参数指向初始值，第二个参数代表序列中的每个元素）–（即初始值和元素本身之间有怎样的关系）
  • 需要一个返回值（返回值就是合并规则）

  初始值：

• 累积求数值和，初始值是0

• 累积求数值乘积，初始值为1

• 字符串合并，初始值是空串

from functools import reduce
num = [20, 60, 45, 85, 66]

result=redcue(lambda x,item:x+item,num,0)
print(result)

#求2060458566：'20'+60+...

num = [20, 60, 45, 85, 66]
result = reduce(lambda x, item:   x+str(item), num, '')
print(result)
#注意x和item的顺序，顺序不一样，结果也会不一样（最好是初始值加上元素）


from functools import reduce
nums = [12, 301, 40, 55, 112]
result = reduce(lambda x, item: x + item % 10, nums, 0)
print(result)

七.迭代器

迭代器类似于扑克，一个压着一个，只有当上一个取了之后才能取下一个；迭代器只出不进

1.1 认识迭代器（iter）

（1）迭代器是容器型数据类型（可以遍历，可以转换成列表），五大直接提供一个迭代器，只能将其他序列转换成迭代器。
（2）特点：

• 打印迭代器的时候无法查看到迭代器有安歇元素
• 无法通过len获取迭代器中元素的个数（会报错）
• 如果要使用迭代器中的元素必须将元素从迭代器中取出，取走的元素会从迭代器中永远消失（用一个少一个）

（3）任何数据都可以作为迭代器的元素

1.2创建迭代器（转换）

i1=iter('anc')
i2=iter([10,20,30])

i3=iter((10,1.23,'abc',True,[10,20]))
print(i1,i2)#无法查看元素

print(len(i1))#会报错

1.3获取迭代器中的元素

无论以任何方式获取到迭代器中的某个元素，那么这个元素一定会从迭代器中消失

（1）获取单个元素：

next(迭代器)——获取迭代器最前面的元素

i1=iter('anc')
print(next(i1))#'a'
print(next(i1))#'n'
print(next(i1))'c'
print(next(i1))#迭代器的取一个少一个，当取完之后迭代器没有元素会报错


i2=iter([10,20,30,40])
print(next(i2))#10
print(list(i2))#[20,30,40],迭代器取了一个元素，则迭代器中少了一个元素
print(next(i2))#此时会报错，因为迭代器没有元素，上一步就已经将元素取完

（2）遍历迭代器

for i in 迭代器：

​ 循环体

for i in i3:
  	print(i)
    
print(list(i3))#空列表，因为迭代器遍历取元素已经将元素取完，再转换为列表，成为一个空列表