4.python函数入门

一、函数参数
二、*的用法
三、名称空间，作用域
四、关键字global、nonlocal
五、函数名
六、匿名函数
七、内置函数
- - 内置函数一
  - 内置函数二

一、函数参数

1、位置参数

位置参数就是从左至右，实参和形参一一对应

# a,b就是位置参数
def func(a,b):
  return a+b

2、关键字参数

不要记住参数的位置，只需知道名字即可。

def func(name,age,sex):
  print('姓名：%s，年龄：%s，性别：%s'%(name,age,sex))
 
func(name='an',age=11,sex='男')

3、混合传参

将位置参数和关键字参数混合使用，调用时可以给出位置参数，也可指定关键字参数。

def func(name,age,sex):
  print('姓名：%s，年龄：%s，性别：%s'%(name,age,sex))
 
func('an',age=11,sex='男')

注意：关键字参数一定要在位置参数后面

4、默认值参数

函数声明时就给出函数参数的默认值。

def func(name,age,sex='男'):
  print('姓名：%s，年龄：%s，性别：%s'%(name,age,sex))
 
func('an',age=11,'女')

默认参数的坑

# 默认参数的坑
def func(a, list=[]):
    list.append(a)
    return list
print(func(10,))  # [10,]
print(func(20,[]))  # [20,]  传入空列表，此次lsit为空
print(func(100))  # [10,100]  没有传入第二个参数，沿用list=[10]

5、动态参数

动态参数可分为两种：动态接受位置参数*args,动态接受关键字参数**kwargs

动态接受位置参数：*args

def func(*args):
    print(args)
func('语文','数学','英语')

def func(*args):
    sum = 0
    for i in args:
        sum+=i
    return sum
print(func(1,2,3,4,5,6))	# -->21

*args可将接收到的参数，形参会将实参所有的位置参数接收，放置在一个元组中，并将这个元组赋值给args这个形参。

动态接受关键字参数：**kwargs

接受所有的关键字参数，然后将其转换成一个字典赋值给kwargs这个形参。

def func(**kwargs):
    print(kwargs)
func(name='an',sex='男')	# -->{'name': 'an', 'sex': '男'}

接受所有的位置参数和关键字参数，提高了函数拓展性。

def func(*args,**kwargs):
    print(args)
    print(kwargs)
func('an',sex='男',age=11)

6、仅限关键字参数

与默认值参数的位置无所谓，但是要放在*args和*kwargs之间，它只接受关键字参数且必须传值。

def foo(a,b,*args,c,sex=None,**kwargs):
print(a,b)
print(c)
print(sex)
print(args)
print(kwargs)
# foo(1,2,3,4,c=6)
# foo(1,2,sex='男',name='alex',hobby='old_woman')		# 报错，因为没有给c传值
# foo(1,2,3,4,name='alex',sex='男')		# 报错，因为没有给c传值
# foo(1,2,c=18)		# 此时args是空元组，kwargs是空字典
# foo(2, 3, [1, 2, 3],c=13,hobby='喝茶')
# foo(*[1, 2, 3, 4],**{'name':'an','c':12,'sex':'女'})

形参角度的所有形参的最终顺序为：位置参数，*args，默认值参数，仅限关键字参数，**kwargs。

二、*的用法

2.1 单个*作为形参的作用

函数定义时，位于*parameter或单独的一个星号后面的所有参数都只能以关键字参数的形式传入，不接受其他形式的传参。

def func(a,b,*,c)		# c必须以关键字参数传入

2.2 单个 / 做参数的作用

在python中和单个星号作用相反的是斜杠（/），表示这个函数只接受位置参数，不允许以关键字的形式进行传值，如sum函数，通过help(sum)的结果是sum(iterable, start=0, /)

2.3 函数中的作用

函数中分为打散和聚合。

函数中的打散和聚合

1. 聚合

如果不加*，args表示一个位置参数，下面的这种传参会报错，加*号会将所有位置参数聚合成一个元组。

kwargs同理，将所有的关键字参数聚合成一个字典。

def func(args):
    print(args)
func('语文','数学','英语')

2. 打散

如果不使用*，args应该是一个元组，包含一个列表和一个字典。

l1 =[1,2,3,4]
tu = ('an','bn','cn')
def func(*args):
    print(args)
func(*l1,*tu)		# -->(1, 2, 3, 4, 'an', 'bn', 'cn')

3.单独一个星号作为函数的参数

单独一个星号作为函数的参数表示该星号后面的参数都必须以关键字参数的形式传入。

def func(a, * ,b=None)

2.4 函数外的作用

函数外可以处理剩余的元素。

处理剩余的元素

上面说的都是函数内的聚合和打散，在函数外可以这样用。

# 分别赋值
a,*b = (1, 2, 3, 4,)
print(a, b) # 1 [2, 3, 4]
*rest,a,b = range(5)
print(rest, a, b) # [0, 1, 2] 3 4
print([1, 2, *[3, 4, 5]]) # [1, 2, 3, 4, 5]

三、名称空间，作用域

# 名称空间：命名空间
# 内置名称空间：python源码提供的内置函数，print
# python分为三个空间：
	# 内置名称空间（builtins.py）
    # 全局名称空间（当前py文件），存放py文件除去函数，类内部的变量，函数名与函数内存地址的关系
    # 局部名称空间：(函数，函数执行时才开辟空间)

# 加载顺序：内置名称空间，全局名称空间，局部名称空间
# 取值顺序：就近原则
# 下列报错：局部作用域不能改变全局作用域的变量，当python解释器读取到局部作用域时，发现你对一个变量进行修改操作
# 解释器会认为你已经定义过这个变量了，他就会从局部找这个变量，报错了
# count = 1
# def func():
#    count+=1
#    print(count)
# func()

四、关键字global、nonlocal

print(globals()) # 返回字典：字典里的键值对：全局作用域的所有内容

print(locals()) # 返回字典，字典里的键值对：局部作用域

# global
# 1, 在局部作用域声明一个全局变量。
name = 'an'
def func():
    global name
    name = 'bn'
# print(name)
print(globals())
func()
# print(name)
print(globals())

# 2. 修改一个全局变量
count = 1
def func():
    # print(count)
    global count
    count += 1
print(count)
func()
print(count)

# nonlocal
# 1. 不能够操作全局变量。
# count = 1
# def func():
#     nonlocal count
#     count += 1
# func()
# 2. 局部作用域：内层函数对外层函数的局部变量进行修改。
#
# def wrapper():
#     count = 1
#     def inner():
#         nonlocal count
#         count += 1
#     print(count)
#     inner()
#     print(count)
# wrapper()

五、函数名

函数的内存地址地址

def func():
  	pass
print(func)		# 打印的是函数的地址

函数名可以赋值给其他变量

def func():        
    pass  
print(func) 
f = func  # 把函数当成一个变量赋值给另一个变量
f() # 函数调用 func()

函数名可以成为容器类的元素

def func1():
    pass
def func2():
    pass
def func3():
    pass
def func4():
    pass
lst = [func1, func2, func3, func4]
for i in lst:
    i()

函数名可以当作函数的参数

这点和变量类似。

def func1():
    print('func1')

def func2(f):
    print('func2')
    f()

func2(func1)

函数名可以作为函数的返回值

def func1():
    print('func1')

def func2(f):
    print('func2')
    return f

func2(func1)

六、匿名函数

匿名函数lambda，也叫一句话函数。

语法：

函数名 = lambda 参数: 返回值

此函数不是没有名字，他是有名字的，他的名字就是你给其设置的变量，比如func.
lambda 是定义匿名函数的关键字，相当于函数的def.
lambda 后面直接加形参，形参加多少都可以，只要用逗号隔开就行，但是一般只加位置参数。
返回值在冒号之后设置，返回值和正常的函数一样,可以是任意数据类型。
匿名函数不管多复杂。只能写一行.且逻辑结束后直接返回数据

七、内置函数

内置函数一

all() any() bytes() callable() chr() complex() divmod() eval() exec() format() frozenset() globals() hash() help() id() input() int() iter() locals() next() oct() ord() pow() repr() round()

eval：执行字符串类型的代码，并返回最终结果。

eval('1+1')
eval('print('an')')

exec:执行字符串类型的代码。

s = '''
for i in [1,2,3,4,5]:
    print(i)
'''
exec(s)

hash：获取一个对象（可哈希对象：int，str，Bool，tuple）的哈希值。

print(hash(12322))
print(hash('123'))
print(hash('an'))
print(hash(True))

help：函数用于查看函数或模块用途的详细说明。

print(help(list))
print(help(print()))

callable：函数用于检查一个对象是否是可调用的。如果返回True，object仍然可能调用失败；但如果返回False，调用对象绝对不会成功。

s = 'an'
def func():
    pass
print(callable(s))  # False
print(callable(func))  # True

bin：将十进制转换成二进制并返回。

oct：将十进制转化成八进制字符串并返回。

hex：将十进制转化成十六进制字符串并返回。

divmod：计算除数与被除数的结果，返回一个包含商和余数的元组(a / b, a % b)。

round：保留浮点数的小数位数，默认保留整数。

pow：求xy次幂。（三个参数为xy的结果对z取余）

bytes：用于不同编码之间的转化。

# s = '你好'
# s1 = s.encode('utf-8')
# print(s1)
# s2 = s1.decode('utf-8')
# print(s2)
# s3 = bytes(s,encoding='utf-8')
# print(s3)
# s4 = '你好'.encode('gbk')
# s5 = s4.decode('gbk')
# print(s5.encode('utf-8'))

repr:返回一个对象的string形式。

内置函数二

abs() enumerate() filter() map() max() min() open() range() print() len() list() dict() str() float() reversed() set() sorted() sum() tuple() type() zip() dir()

max()方法返回给定参数的最大值，参数可以为序列。

**reversed() 将一个序列翻转, 返回翻转序列的迭代器 **

d = reversed('你好')  # d 获取到的是一个生成器
print(list(d))  # -->['好', '你']
ret = reversed([1, 4, 3, 7, 9])
print(list(ret))  # -->[9, 7, 3, 4, 1]

zip() 拉链方法。函数用于将可迭代的对象作为参数,将对象中对应的元素打包成一个个元组,然后返回由这些元祖组成的内容,如果各个迭代器的元素个数不一致,则按照长度最短的返回，

li1 = [1,2,3]
li2 = ['a','b','c','d']
li3 = (11,12,13,14,15)
for i in zip(lst1,lst2,lst3):
    print(i)
结果:
(1, 'a', 11)
(2, 'b', 12)
(3, 'c', 13)

sorted排序函数

语法:sorted(iterable,key=None,reverse=False)

iterable : 可迭代对象

key: 排序规则(排序函数),在sorted内部会将可迭代对象中的每一个元素传递给这个函数的参数.根据函数运算的结果进行排序

reverse :是否是倒叙,True 倒叙 False 正序

lst = [1,3,2,5,4]
lst2 = sorted(lst)
print(lst)    #原列表不会改变
print(lst2)   #返回的新列表是经过排序的
lst3 = sorted(lst,reverse=True)
print(lst3)   #倒叙
结果:
[1, 3, 2, 5, 4]
[1, 2, 3, 4, 5]
[5, 4, 3, 2, 1]

# 字典使用sorted排序
dic = {1:'a',3:'c',2:'b'}
print(sorted(dic))   # 字典排序返回的就是排序后的key

filter筛选过滤函数

语法: filter(function,iterable)

function: 用来筛选的函数,在filter中会自动的把iterable中的元素传递给function,然后根据function返回的True或者False来判断是否保留此项数据

iterable:可迭代对象

lst = [{'id':1,'name':'alex','age':18},
        {'id':1,'name':'wusir','age':17},
        {'id':1,'name':'taibai','age':16},]
ls = filter(lambda e:e['age'] > 16,lst)
print(list(ls))
结果:
[{'id': 1, 'name': 'alex', 'age': 18},
 {'id': 1, 'name': 'wusir', 'age': 17}]

map函数

映射函数

语法: map(function,iterable) 可以对可迭代对象中的每一个元素进行映射,分别去执行function

# 计算列表中每个元素的平方,返回新列表
lst = [1,2,3,4,5]
def func(s):
    return  s*s
mp = map(func,lst)
print(mp)
print(list(mp))


改写成lambda
lst = [1,2,3,4,5]
print(list(map(lambda s:s*s,lst)))

posted @ 2020-07-03 15:41 journeyerxxx 阅读(135) 评论(0) 编辑收藏举报

刷新页面返回顶部

登录后才能查看或发表评论，立即登录或者逛逛博客园首页

阅读排行：
· 25岁的心里话
· 闲置电脑爆改个人服务器（超详细） #公网映射 #Vmware虚拟网络编辑器
· 零经验选手，Compose 一天开发一款小游戏！
· 通过 API 将Deepseek响应流式内容输出到前端
· AI Agent开发，如何调用三方的API Function，是通过提示词来发起调用的吗

公告

昵称： journeyerxxx
园龄： 4年8个月
粉丝： 2
关注： 4

+加关注

2025年3月

日

一

二

三

四

五

六

journeyer_xsh