【python知识点总结】第二章 函数

第二节 函数

​ 将一段具有独立功能的代码块整合到一个整体并命名，在需要的位置调用名称，更高效的实现代码重用

一 调用函数

​ 函数调用通过栈进行，防止栈溢出

​ 绝对值函数 abs()

help(abs)			# 不知道函数意思就调用帮助文档，help(函数名)
print(abs(-20))		# 20

​ 最大值函数 max()

print(max(2,3,56,34))	# 56

​ 类型转换函数

print(int(12.23))	# 12
print(bool(1))		# True
print(str(123))		# 123

​ 十六进制转换函数 hex()

print(hex(255))		# 0xff
print(hex(1000))	# 0x3e8

​ 随机数函数模块random

import random
a=random.randint(1,10)		# randint随机整数，(开始,结束)要包含该数字
print(a)

二 定义函数

​ 格式： def 函数名(参数) ：

​ 代码块

​ return(参数)

def my_abs(x):
    if not isinstance(x,(int,float)):		# 类型检查，x必须是int和float类型才行
        raise TypeError('bad type')
    if x>=0:
        return x
    else:
        return -x
        
def move(x,y,step,angle=0):			# 也可返回多个参数
    nx=x+step*math.cos(angle)
    ny=y-step*math.sin(angle)
    return nx,ny

# 定义函数说明文档
def sum_fc(a,b):
    """						# 在函数第一行使用多行注释可以定义说明文档
        说明文档定义处：
        求和函数
    """
    result=a+b
    return result

help(sum_fc)				#sum_fc(a, b)    说明文档定义处：    求和函数

def sum_fc(a,b):
    """						# 打了""""""后直接换行会出现参数提示
    求和函数
    :param a: ——参数1
    :param b: ——参数2
    :return: ——返回值
    """
    result=a+b
    return result
    
# 一个函数多个返回值
def testA():
    return 1,2		# 用,隔开
res=testA()
print(res)			# (1, 2) —— 返回多个数据时默认元组类型

# return还可以返回列表、字典、元组
def testA():
    return [1,2]
res=testA()
print(res)			# [1,2]

​ 空函数

def nop():
    pass		# 先用pass占位，使程序不报错

三 函数的参数

1、位置参数

​ 传入的值按照位置顺序依次赋值给参数，传入和定义参数的顺序及个数必须一致；真实数据3,3是实参（真实数据），接收x,n是形参（非真实数据）

def power(x,n):
    s=1
    while n>0:
        n=n-1
        s=s*x
    return s
    
print(power(3,3))		# 27

2、默认参数(缺省参数)—要给参数赋值

​ 可以直接用参数的赋值或传入新值，若提供单个默认参数，则要写明为哪个参数赋值

​ 必须选择参数在前，默认参数在后，位置参数都在默认参数前；

​ 当有多个参数时，将变化大的参数放前，变化小的放后；

​ 默认参数必须指向不变对象（str、None）

def power(x,n=2):
    s=1
    while n>0:
        n=n-1
        s=s*x
    return s

print(power(3))		# 直接用n=2，得9
print(power(3,4))	# 81


def enroll(name,gender,age=18,city='beijing'):
    print(name)
    print(gender)
    print(age)
    print(city)

enroll('zhangsan','女')					# zhangsan	女	18	beijing
enroll('lisi','男',city='shanghai')		# 写明为city赋值——lisi	男	18	shanghai

3、可变参数(不定长参数)—*参数

​ 允许传入0个或任意个参数，在函数调用时自动组装为一个tuple元组，*参数也叫做包裹位置传递

def calc(*number):
    sum=0
    for n in number:
        sum=sum+n*n
    return sum

print(calc(1,2))		# 5
print(calc())			# 0

# 将List或tuple的元素变成可变参数传入
nums=[1,2,3]
print(calc(*nums))		# 14

4、关键字参数—**参数

​ 允许传入0个或任意个含参数名称的参数，在函数内部自动组装为一个dict字典，即通过“键=值”形式指定，**参数也叫做包裹关键字传递

# 加**接收关键字参数
def person(name,age,**kw):
    print('name:',name,'age:',age,'other:',kw)
# 接收任意个关键字参数
person('mich',30)	
	# name: mich age: 30 other: {}
person('Bob',30,city='BEIJINHG')								
	# name: Bob age: 30 other: {'city': 'BEIJINHG'}
person('Rose',30,city='shanghai',gender='M')					
	# name: Rose age: 30 other: {'city': 'shanghai', 'gender': 'M'}
# 自己组装dict然后转进去
extra={'city':'CHENGDU','hobby':'football','job':'teecher'}		
person('Jack',24,**extra)										
	# name: Jack age: 24 other: {'city': 'CHENGDU', 'hobby': 'football', 'job': 'teecher'}


# 还可以不加**，只要传进去是键值对形式就为关键字参数
def testA(name,age,gender):
    print(name,age,gender)
testA('ch',age=12,gender='男')		# ch 12 男 —— 直接利用键=值作为关键字参数
testA('ch',gender='男',age=12)		# 关键字参数没有顺序之分，必须写在位置参数后面

5、命名关键字参数—参数 ,*，参数

​ 会限制关键字参数的名字，即*分隔符之后为命名关键字参数

def people1(name,age,*,city,job):
    print(name,age,city,job)			

people1('jessi',12,city='suzhou',job='engineer')	# jessi 12 suzhou engineer

# 可加入默认参数
def people3(name,age,*,city='guangdong',job):
    print(name,age,city,job)			

people3('Gray',16,job='worker')						# Gray 16 guangdong worker

​ 若函数定义中有可变参数，则不需要分隔符*

def people2(name,age,*args,city,job):
    print(name,age,args,city,job)

people2('jessi',22,city='hangzhou',job='student')

参数组合顺序：必选参数、默认参数、可变参数、命名关键字参数、关键字参数

def f1(a,b,c=0,*args,**kw):
    print('a=',a,'b=',b,'c=',c,'args=',args,'kw=',kw)

f1(1,2,3,'a','b',x=99,y=88)			# a= 1 b= 2 c= 3 args= ('a', 'b') kw= {'x': 99, 'y': 88}

四 递归函数

​ def：一个函数在内部调用自身

def fun(n):
    if n==1:
        return 1
    return n*fun(n-1)

print(fun(1))		# 1
print(fun(5))		# 120

​ 防止栈溢出采用尾递归法，即在函数返回时调用自身，且return语句不能包含表达式

def fact_iter(num,product):
    if num==1:
        return product
    return fact_iter(num-1,num*product)

print(fact(5))		# 120

五 函数嵌套调用

​ 一个函数里面又调用了另外一个函数

def testA():
    print("---")
    testB()
    print("===")

def testB():
    print("testb")

testA()			# ---	testb	===

六 变量作用域

​ 即变量生效的范围，分为局部变量和全局变量

​ 局部变量：定义在函数体内部的变量，只在函数体内部生效，在函数内部临时保存数据，函数调用完则销毁

​ 全局变量：在整个代码域都能生效

b=200
def testA():
    a=100
    print(a)	# a是局部变量
testA()
print(b)		# b是全局变量

# 在函数内部修改全局变量
b=200
def testA():
    global b	# 加global声明b是全局变量
    b=100
    print(b)	# 100
testA()
print(b)		# 100

七 拆包和交换变量的值

1、拆包

​ 组包为将零散的数据整合到一个整体；拆包为将一个整体的数据单独拆开

拆包：元组

def test_num():
    return 100,200

num1,num2=test_num()
print(num1)		# 100
print(num2)		# 200

拆包：字典

dict1={'name':'lisa','age':23}
a,b=dict1
# 对字典进行拆包，取出来的是key
print(a)			# name
print(b)			# age
# 按key查找数据
print(dict1[a])		# lisa
print(dict1[b])		# 23

2、交换变量值

借助第三方变量存储数据

a=10
b=20
c=0
c=a
a=b
b=c
print('a=',a)	# a=20
print('b=',b)	# b=10

直接交换

a=10
b=20			# 还可以a,b=10,20
a,b=b,a			# b赋值到a,a赋值到b
print('a=',a)	# a=20
print('b=',b)	# b=10

八 可变和不可变类型

​ 可变类型：数据能直接进行修改；不可变类型：数据不能直接修改

可变类型	不可变类型
列表	整形
字典	浮点型
集合	字符串
	元组

本文根据廖雪峰老师python课程和黑马程序员python课程进行记录