python基础知识--6函数
1.函数的特点
print pow input sorted 等等
# 1.功能强⼤；
# 2.调⽤⽅便；
# 3.灵活⾼效。
# 1.功能强⼤
# 内置函数，或⾃定义函数内部，可以根据不同需求，实现相应的功能。
print('lemon','pear',sep=',',end='*')
运⾏结果：
lemon,pear*
# 2.调⽤⽅便
# 函数内部具体细节的定义可能很复杂，但有时我们不需了解具体细节，只需传⼊相关参数，就能⽅便调⽤函数，实现相应功能。
2 ** 3
运⾏结果：8
pow(2,3)
运⾏结果：8
# 3.灵活⾼效
# Python声明⼀个函数，不需声明函数返回值类型，也不需说明参数类型。这也符合，Python⼀切皆对象的特点。
# 写⼀段程序的时候，可以将相同功能的代码块封装在⼀个函数⾥，减少很多重复代码，以提⾼效率
2.函数的基本形式
def <；函数名> (参数):
<；函数语句>
return <；返回值>
其中注意的地⽅有：
1.def 声明⼀个函数；
2.函数名，可⾃定义，为了避免不必要的⿇烦，不建议与 Python关键字，Python内置函数同名；
3.函数参数，不是必须的，可以不填；
4.即使函数不传⼊任何参数，()是不能省的；
5.默认两个空格缩进的函数语句，表⽰属于该函数；
help('keywords')
运⾏结果：
Here is a list of the Python keywords.  Enter any keyword to get more help.
False              def                if                  raise
None                del                import              return
True                elif                in                  try
and                else                is                  while
as                  except              lambda              with
assert              finally            nonlocal            yield
break              for                not
class              from                or
continue            global              pass
dir(__builtins__)
# 创建简单函数
# 需求1：创建⼀个函数, 调⽤该函数的时候打印 hello lemon
def hello():
print('hello lemon')
hello()
运⾏结果：
hello lemon
# 需求2：创建⼀个函数, 传⼊两个值，返回两个值的和
def add(x,y):
result = x + y
return result
add(2,3)
运⾏结果：5
add(4,6)
运⾏结果：10
3.函数参数类型
# ⽆参函数
def hello():
print('hello lemon')
# 有参函数
def add(x,y):
result = x + y
return result
#%%
add(3,2)
#%%
# x,y 形式参数，形参
# 3,2 实际参数，实参
def func_name(param1,*args,param2=0,**kwargs):
pass
声明函数时，可以不定义任何形式参数。
声明函数时，如果需要定义形式参数。形式参数类型有必须参数、可变参数、默认值参数、可变关键字参数这四种。# 定义函数的时候，⼀般有以下常见形参：
param1      必须参数（定义了多少个参数，就必须得传递多少个参数）
*args        可变参数（可以传递任意个参数）
param2      默认值参数（给参数赋默认值）
python新手函数**kwargs    可变关键字参数（可以传递任意个关键字参数）
这4种参数都可以⼀起使⽤，或者只⽤其中某些。
如果要⼀起使⽤的话，请注意，参数定义的顺序最好是：
必须参数、可变参数、默认参数和关键字可变参数。
如只需其中某些参数，这些参数的顺序，也应相对固定
4.必须函数
# 必须参数
# 声明⼀个函数的时候，定义了多少个必须参数，调⽤函数的时候就必须的传递多少个实参。
# 实参赋值的顺序，对应必须参数定义时的顺序。
def add(x,y):
result = x + y
return result
add(3,2)
运⾏结果：5
# 个⼈建议：
# 不建议⼤家定义过多必须参数。
# 如果⼤家真的需要定义多个必须参数，建议⼤家，可将多个必须参数封装成⼀个对象，把对象传⼊到函数中。
# 需求：创建⼀个函数，录⼊苹果，柠檬两种⽔果数量，并打印详情
def detail(apple,lemon):
print('apple的数量为:' + str(apple))
print('lemon的数量为:' + str(lemon))
detail(4)
运⾏结果：
TypeError Traceback (most recent call last)
<ipython-input-4-50154db873ac> in <module>() ----> 1 detail(4)
TypeError: detail() missing 1 required positional argument: 'lemon'
detail(4,5)
运⾏结果：
apple的数量为:4
lemon的数量为:5
# 疑问：假如我调⽤函数的时候，记不住参数的顺序，那该怎么办？
# 关键字参数，可以在调⽤函数的时候，告诉Python，我们赋值的实参，到底是传递给哪个参数。
detail(apple=10,lemon=8)
运⾏结果：
apple的数量为:10
lemon的数量为:8
# 使⽤关键字参数，特点：
# 1.没有改变函数⾏为，增强代码的可读性。
# 2.不需强制记忆参数的顺序，可任意调换参数传递的顺序。
5.默认参数值
def func_name(param1 = 'default1',param2 = 'default2'):
pass
# 默认值参数，指的是，参数在定义时，设置的默认值。
# 调⽤函数的时候，如果需要修改默认值参数，建议使⽤关键字参数，对默认值参数进⾏重新赋值。关键字参数，可以不遵循默认值参数顺序。
def message(name,age,sex='male',nationality='China'):
print('我叫：' + str(name) )
print('今年：' + str(age) + ' 岁' )
print('性别：：' + str(sex) )
print('国籍为：：' + str(nationality) )
message('lemon',8)
运⾏结果：
我叫：lemon
今年：8 岁
性别：：male
国籍为：：China
message('Alice',24,sex='female',nationality='USA')
我叫：Alice
今年：24 岁
性别：：female
国籍为：：USA
message('Alice',24,nationality='USA',sex='female')
我叫：Alice
今年：24 岁
性别：：female
国籍为：：USA
6.可变参数
# 序列解包
# 序列解包就是，将序列中的元素平铺出来，按照顺序分别赋值给多个变量。
# 序列：字符串、列表、元组
# 序列解包-字符串
s = '123'
a,b,c = s
print('a的值为：' + str(a) + ' 类型为：' + str(type(a)))
print('b的值为：' + str(b) + ' 类型为：' + str(type(b)))
print('c的值为：' + str(c) + ' 类型为：' + str(type(c)))
运⾏结果：
a的值为：1 类型为：<class 'str'>
b的值为：2 类型为：<class 'str'>
c的值为：3 类型为：<class 'str'>
# 赋值的变量数量，需要与序列中的元素数量⼀致
a,b,c = s
# 序列解包-列表
l = [1,2,3]
a,b,c = l
print('a的值为：' + str(a) + ' 类型为：' + str(type(a)))
print('b的值为：' + str(b) + ' 类型为：' + str(type(b)))
print('c的值为：' + str(c) + ' 类型为：' + str(type(c)))
运⾏结果：
a的值为：1 类型为：<class 'int'>
b的值为：2 类型为：<class 'int'>
c的值为：3 类型为：<class 'int'>
# 序列解包-元组
tu = (1,2,3)
a,b,c = tu
print('a的值为：' + str(a) + ' 类型为：' + str(type(a)))
print('b的值为：' + str(b) + ' 类型为：' + str(type(b)))
print('c的值为：' + str(c) + ' 类型为：' + str(type(c)))
运⾏结果：
a的值为：1 类型为：<class 'int'>
b的值为：2 类型为：<class 'int'>
c的值为：3 类型为：<class 'int'>
def func_args(*args):
print(args)
print(type(args))
# 对于可变参数，我们可传递任意个参数，这些参数在函数调⽤时⾃动组装为⼀个tuple。# 传⼊0个参数
func_args()
()
<class 'tuple'>
# 传⼊2个参数
func_args(1,2)
(1, 2)
<class 'tuple'>
# 疑问：可否传⼊⼀个元祖
a = (1,2)
func_args(a)
运⾏结果：
((1, 2),)
<class 'tuple'>
func_args(*a)
运⾏结果：
(1, 2)
<class 'tuple'>
# * 星号的作⽤是将元祖⾥⾯的元素平铺出来，传递到可变参数的函数⾥⾯；
# 如果你想将⼀个序列内的元素平铺出来，传递到可变参数的函数⾥⾯，可使⽤序列解包操作。
# 此外，⼤家也可以传递⼀个字符串、列表到可变参数函数⾥⾯，⼤家下去可以去尝试⼀下。
# 总结
def func_args(*args):
print(args)
print(type(args))
func_args(1,N)
func_args(*seq)
# 1.对于可变参数，我们可以传递任意个参数，
# 2.我们也可以传递⼀个序列，不过序列前⾯需要加上⼀个*
# 需求：创建⼀个函数，⽤户可传⼊任意值，并返回任意值相加后的值
def add_all(*args):
sum = 0
for i in args:
sum += i
return sum
add_all(1,2,3,4)
运⾏结果：10
a = (1,2,3,4)
add_all(*a)
运⾏结果：10
7.可变关键字参数
def func_kwargs(**kwargs):
print(kwargs)
print(type(kwargs))
# 可变关键字参数，可传递任意个关键字参数，这些关键字参数在函数调⽤的时候会⾃动组装为⼀个dict。# 传⼊0个关键字参数
func_kwargs()

版权声明：本站内容均来自互联网，仅供演示用，请勿用于商业和其他非法用途。如果侵犯了您的权益请与我们联系QQ:729038198，我们将在24小时内删除。