python定义匿名函数关键字_Python（11）：Python函数基础（定义函数、函数参数、匿名函数）...

函数先定义函数，后调用

一、定义函数：

1、简单的规则：

函数代码块以 def 关键词开头，后接函数标识符名称和圆括号 ()。

任何传入参数和自变量必须放在圆括号中间，圆括号之间可以用于定义参数。

函数的第一行语句可以选择性地使用文档字符串—用于存放函数说明。

函数内容以冒号起始，并且缩进。

return [表达式] 结束函数，选择性地返回一个值给调用方。不带表达式的return相当于返回 None。

2、语法

Python 定义函数使用 def 关键字

默认情况下，参数值和参数名称是按函数声明中定义的顺序匹配起来的。

def函数名(param1,param2……):"""函数功能的描述信息

:param1：描述

:param2：描述

:return：返回值"""code

...return 返回值

3、无参函数

defregister():"""注册功能"""username= input('username:').strip()

pwd= input('password:').strip()

with open('32.txt', 'a', encoding='utf8') as fa:

fa.write(f"{username}:{pwd}\n")

fa.flush()

4、有参函数

defsum_self(x, y):"""求和"""res= x+yprint(res)

sum_self(1,2) #3

5、空函数

你只知道你需要实现某个功能，但不知道该如何用代码实现时，你可以暂时写个空函数

deffunc():pass

二、调用函数及返回值

定义一个函数：给了函数一个名称，指定了函数里包含的参数，和代码块结构。

这个函数的基本结构完成以后，你可以通过另一个函数调用执行，也可以直接从 Python 命令提示符执行。

函数名(param1、param2……)

如：

1、函数运行完毕所有代码，如果函数体不写return，则会返回None。

deffoo():pass

print(foo()) #None

2、函数可以返回一个或多个值(元组类型)

deffunc():

name= 'nick'age= 19hobby_list= ['read', 'run']returnname, age, hobby_list

name, age, hobby_list=func()print(name,age,hobby_list) #('nick', 19, ['read', 'run'])

三、函数的参数

1、普通参数，位置必需参数

在函数定义阶段，按照从左到右的顺序依次定义的形参，称之为位置形参。

特点：按照位置定义的形参，都必须被传值，多一个不行，少一个也不行。

deffunc(x, y):print(x)print(y)

在函数调用阶段，按照从左到右的顺序依次定义的实参，称之为位置实参。

特点：按照位置为对应的形参依次传值。

func(1, 2)

2、关键字参数

在调用函数时，按照key=value的形式为指定的参数传值，称为关键字实参。

特点：可以打破位置的限制，但仍能为指定的形参赋值。

func(y=2, x=1)

可以混用位置实参和关键字实参，但是位置实参必须在关键字实参的左边。

可以混用位置实参和关键字实参，但不能对一个形参重复赋值。

func(x, y=2)

func(y=2, x) #SyntaxError: positional argument follows keyword argument

func(x, x=1) #NameError: name 'x' is not defined

3、默认参数

在定义阶段，就已经被赋值。意味着在调用时可以不用为其赋值。位置形参必须放在默认形参的左边。

def func(x, y=10):print(x)print(y)

func(2)

默认形参的值只在定义阶段赋值一次，也就是说默认参数的值在函数定义阶段就已经固定了。

m = 10

def foo(x=m):print(x)

m= 111foo()#10

默认参数的值通常应该是不可变类型。

def register(name, hobby, hobby_list=None):

hobby_list=[hobby]print(f"{name} prefer {hobby_list}")

#演示形参是可变类型,（列表是可变类型）

def register(name, hobby, hobby_list=None):

hobby_list=[hobby]print(f"{name} prefer {hobby_list}")

4、不定长参数之*

形参中的*会将溢出的位置实参全部接收，然后存储元组的形式，然后把元组赋值给*后的参数。需要注意的是：*后的参数名约定俗成为args。

def sum_self(*args):

res=0for num inargs:

res+=numreturnres

res= sum_self(1, 2, 3, 4)print(res) #10

注意：实参之*

实参中的*，*会将*后参数的值循环取出，打散成位置实参。以后但凡碰到实参中带*的，它就是位置实参，应该马上打散成位置实参去看。

def func(x, y, z, *args):print(x, y, z, args)

func(1, *(1, 2) , 3, 4) #1 1 2 (3, 4)

5、不定长参数之**

形参中的**会将溢出的关键字实参全部接收，然后存储字典的形式，然后把字典赋值给**后的参数。需要注意的是：**后的参数名约定俗成为kwargs。

def func(**kwargw):print(kwargw)

func(a=5,b=3) #{'a': 5, 'b': 3}

注意：实参之**

实参中的**，**会将**后参数的值循环取出，打散成关键字实参。以后但凡碰到实参中带**的，它就是关键字实参，应该马上打散成关键字实参去看。

def func(x, y, z, **kwargs):print(x, y, z, kwargs)

func(1, 3, 4, **{'a': 1, 'b': 2} ) #1 3 4 {'a': 1, 'b': 2}

可变长参数应用

defindex(name, age, sex):print(f"name: {name}, age: {age}, sex: {sex}") #name: nick, age: 19, sex: male

def wrapper(*args, **kwargs):print(f"args: {args}") #args: ()

print(f"kwargs: {kwargs}") #kwargs: {'name': 'nick', 'sex': 'male', 'age': 19}

index( *args, **kwargs)

wrapper(name='nick', sex='male', age=19)

6、命名关键字参数

命名关键字则是在「位置参数」和「命名关键字参数」中使用,*,隔开，后面的即为命名关键字。* 后的参数必须用关键字传入。

def student(name, age, *, city, gender):print(name, age, city, gender)

student('xiaoming', 6, city='beijing', gender='male') #xiaoming 6 beijing male

student('xiaoming', 6, 'beijing', 'male') #TypeError: student() takes 2 positional arguments but 4 were given

特点：在传值时，必须按照key=value的方式传值，并且key必须命名关键字参数的指定的参数名。

def register(x, y, *, name, gender='male', age):print(x)print(name)print(age)

Python3.8 新增了一个函数形参语法， “/” 用来指明函数形参必须使用指定位置参数，不能使用关键字参数的形式。

在以下的例子中，形参 a 和 b 必须使用指定位置参数，c 或 d 可以是位置形参或关键字形参，而 e 或 f 要求为关键字形参:

def f(a, b, /, c, d, *, e, f):print(a, b, c, d, e, f)

以下使用方法是正确的:

f(10, 20, 30, d=40, e=50, f=60)

四、函数对象

函数是第一类对象，即函数可以被当做数据处理。

deffunc():print('from func')print(func) #

1、函数当作参数传给一个另一函数

deffunc():print('from func')deffoo(m):

m()

foo(func)#from func

2、函数当作另一函数的返回值

deffunc():print('from func')deffoo(x):returnx

res=foo(func)print(res) #

3、函数可以当作容器类型的元素

deffunc():print('from func')

function_list=[func]

function_list[0]()#from func

五、函数递归

递归的精髓在于通过不断地重复逼近一个最终的结果。

age(1)=26,age(n)=age(n-1)+2 ，求age(5)的值：

'''...

age(5) = age(4) + 2

age(4) = age(3) + 2

age(3) = age(2) + 2

age(2) = age(1) + 2

age(1) = 26

age(n) = age(n-1) +2

age(1) = 26 # n=1'''

defage(n):if n == 1:return 26res= age(n-1) + 2

returnresprint(f"age(5): {age(5)}")

递归的本质就是干重复的活。

lis = [1, [2, [3, [4, [5, [6, ]]]]]]deftell(lis):for i inlis:if type(i) islist:

tell(i)else:print(i)

tell(lis)

二分法的思想实现查找数字。

from random importrandint

nums= [randint(1, 100) for i in range(100)]

nums=sorted(nums)defsearch(search_num, nums):print(nums)

mid_index= len(nums) // 2

if notnums:print('not exists')return

if search_num >nums[mid_index]:#in the right

nums = nums[mid_index + 1:]

search(search_num, nums)elif search_num

nums =nums[:mid_index]

search(search_num, nums)else:print('find it')

search(7, nums)

六、匿名函数:

python 使用 lambda 来创建匿名函数。

所谓匿名，意即不再使用 def 语句这样标准的形式定义一个函数。

lambda 只是一个表达式，函数体比 def 简单很多。

lambda的主体是一个表达式，而不是一个代码块。仅仅能在lambda表达式中封装有限的逻辑进去。

lambda 函数拥有自己的命名空间，且不能访问自己参数列表之外或全局命名空间里的参数。

虽然lambda函数看起来只能写一行，却不等同于C或C++的内联函数，后者的目的是调用小函数时不占用栈内存从而增加运行效率。

1、语法

lamdbda 参数 : 逻辑代码

#可写函数说明

sum = lambda arg1, arg2: arg1 +arg2#调用sum函数

print ("相加后的值为 :", sum( 10, 20))print ("相加后的值为 :", sum( 20, 20 ))

匿名函数，他没有绑定名字，使用一次即被收回，加括号既可以运行。

print(lambda x, y: x + y ) #(x, y)>

res = (lambda x, y: x + y)(1, 2)print(res) #3

lambda 匿名函数也是可以使用"关键字参数"进行参数传递,也可以设定默认值。

g = lambda x=0, y=0: x ** 2 + y ** 2

print(g(2, 3))#13

print(g(2))#4

print(g(y=3))#9

2、与内置函数联用

匿名函数通常与max()、sorted()、filter()、sorted()方法联用。

1.max()

如果我们想从上述字典中取出薪资最高的人，我们可以使用max()方法，但是max()默认比较的是字典的key。

首先将可迭代对象变成迭代器对象

res=next(迭代器对象)，将res当做参数传给key指定的函数，然后将该函数的返回值当做判断依据

salary_dict ={'nick': 3000,'jason': 100000,'tank': 5000,'sean': 2000}print(max(salary_dict)) #tank

deffunc(k):returnsalary_dict[k]print(max(salary_dict, key=func)) #jason

print(max(salary_dict, key=lambda name: salary_dict[name] ) ) #jason 匿名函数

2.sorted()

如果我们想对上述字典中的人，按照薪资从大到小排序，可以使用sorted()方法。

首先将可迭代对象变成迭代器对象

res=next(迭代器对象)，将res当做参数传给第一个参数指定的函数，然后将该函数的返回值当做判断依据。

lis = [1, 3, 2, 5, 8, 6]

sorted(lis)print(lis) #[1, 3, 2, 5, 8, 6]

print(sorted(lis, reverse=True)) #[8, 6, 5, 3, 2, 1]

salary_dict={'nick': 3000,'jason': 100000,'tank': 5000,'sean': 2000}print(sorted(salary_dict, key=lambda name: salary_dict[name] )) #['sean', 'nick', 'tank', 'jason']

3.map()

如果我们想对一个列表中的某个人名做处理，可以使用map()方法。

首先将可迭代对象变成迭代器对象

res=next(迭代器对象)，将res当做参数传给第一个参数指定的函数，然后将该函数的返回值作为map()方法的结果之一。

name_list = ['jason', 'tank', 'sean']

res= map(lambda name: f"{name} sb", name_list)print(list(res)) #['jason sb', 'tank sb', 'sean sb']

4.filter()

如果我们想筛选除名字中含有'sb'的名字，我们可以使用filter()方法。

首先将可迭代对象变成迭代器对象

res=next(迭代器对象)，将res当做参数传给第一个参数指定的函数，然后filter会判断函数的返回值的真假，如果为真则留下。

name_list = ['nick', 'jason sb', 'tank sb', 'sean sb']

filter_res= filter(lambda name: name.endswith('sb'), name_list)print(list(filter_res)) #['jason sb', 'tank sb', 'sean sb']

七、内置函数

共68个：

abs()、 all()、 any()、 ascii()、 bin()、 bool()、 bytearray()、 bytes()、 callable()、 chr()、 classmethod()、 compile()、 complex()、 delattr()、

dict()、 dir()、 divmod()、 enumerate()、 eval()、 exec()、 filter()、 float()、 format()、 frozenset()、 getattr()、 globals()、 hasattr()、 hash()、

help()、 hex()、 id()、 input()、 int()、 isinstance()、 issubclass()、 iter()、 len()、 list()、 locals()、 map()、 max()、 memoryview()、

min()、 next()、 object()、 oct()、 open()、 ord()、 pow()、 print()、 property()、 range()、 repr()、 reversed()、 round()、 set()、

setattr()、 slice()、 sorted()、 staticmethod()、 str()、 sum()、 super()、 tuple()、 type()、 vars()、 zip()、 __import__()、

1.bytes()：解码字符。

res = '你好'.encode('utf8')print(res) #b'\xe4\xbd\xa0\xe5\xa5\xbd'

res = bytes('你好', encoding='utf8')print(res) #b'\xe4\xbd\xa0\xe5\xa5\xbd'

2.chr()/ord()：chr()参考ASCII码表将数字转成对应字符；ord()将字符转换成对应的数字。

print(chr(65)) #A

print(ord('A')) #65

3.divmod()：分栏。

print(divmod(10, 3)) #(3, 1)

4.enumerate()：带有索引的迭代。

l = ['a', 'b', 'c']for i inenumerate(l):print(i)#(0, 'a')#(1, 'b')#(2, 'c')

5.eval()：把字符串翻译成数据类型。

lis = '[1,2,3]'lis_eval=eval(lis)print(lis_eval) #[1, 2, 3]

6.hash()：是否可哈希。

print(hash(1)) #1

7.abs()：求绝对值。

print(abs(-13)) #13

8.all()：可迭代对象内元素全为真，则返回真。

print(all([1, 2, 3, 0])) #False

print(all([])) #True

9.any()：可迭代对象中有一元素为真，则为真。

print(any([1, 2, 3, 0])) #True

print(any([])) #False

10.bin()/oct()/hex()：二进制、八进制、十六进制转换。

print(bin(17)) #0b10001

print(oct(17)) #0o21

print(hex(17)) #0x11

11.dir()：列举出所有time的功能。

importtimeprint(dir(time))#['_STRUCT_TM_ITEMS', '__doc__', '__loader__', '__name__', '__package__', '__spec__', 'altzone', 'asctime', 'clock', 'ctime', 'daylight', 'get_clock_info', 'gmtime', 'localtime', 'mktime', 'monotonic', 'perf_counter', 'process_time', 'sleep', 'strftime', 'strptime', 'struct_time', 'time', 'timezone', 'tzname', 'tzset']

12.frozenset()：不可变集合。

s = frozenset({1, 2, 3})print(s) #({1, 2, 3})

13.globals()/loacals()：查看全局名字；查看局部名字。

#print(globals())

deffunc():

a= 1

#print(globals())

print(locals())

func()#{'a': 1}

14.pow()：

print(pow(3, 2, 3)) #(3**2)%3 =0

15.round()：

print(round(3.5)) #4

16.slice()：

lis = ['a', 'b', 'c']

s= slice(1, 4, 1)print(lis[s]) #['b', 'c']#print(lis[1:4:1])

17.sum()：

print(sum(range(100))) #4950

18.__import__()：通过字符串导入模块。

m = __import__('time')print(m.time()) #1556607502.334777

19. 面向对象知识点

classmethod

staticmethod

property

delattr

hasattr

getattr

setattr

isinstance()

issubclass()

object()

super()

python定义匿名函数关键字_Python（11）：Python函数基础（定义函数、函数参数、匿名函数）...相关推荐

Python编程学习：让函数更加灵活的*args和**kwargs(设计不同数量参数的函数)的简介、使用方法、经典案例之详细攻略
Python编程学习:让函数更加灵活的*args和**kwargs(设计不同数量参数的函数)的简介.使用方法.经典案例之详细攻略目录 *args和**kwargs(设计不同数量的参数函数)的简介 1 ...
python定义匿名函数关键字_python语言的匿名函数、7种可调用对象以及用户定义的可调用类型...
匿名函数在python表达式中,用来创建匿名函数的是lambda关键字. lambda函数在python语言中只能使用纯表达式,也就是说,在lambda函数体中不能使用while和try,当然也不能 ...
python中主函数循环_python入门（三）：分支、循环、函数详解
1.分支 if循环格式: if condition_1: statement_block_1 elif condition_2: statement_block_2 else: statement_b ...
python内建函数测试对象身份_python 学习笔记day03-python基础、python对象、数字、函数...
python基础语句和语法注释及续行首要说明的是:尽管python可读性最好的语言之一,这并不意味者程序员在代码中就可以不写注释和很多UNIX脚本类似,python注释语句从#字符开始注释可 ...
python顺序结构的关键字_Python相关数据结构的排序
作者|Luay Matalka 编译|VK 来源|Towards Datas Science 在本教程中,我们将了解如何根据不同的标准对可迭代的容器(如列表.元组.字符串和字典)进行排序. 对列表排序 ...
[转载] python不允许使用关键字_Python中关键字global与nonlocal的区别
参考链接: Python全局关键字版权声明:本文为博主原创文章,未经博主允许不得转载. https://blog.csdn.net/xCyansun/article/details/79672634 ...
python 2x可以打么_Python打基础一定要吃透这68个内置函数
内置函数就是Python给你提供的,拿来直接用的函数,比如print.,input等. 截止到python版本3.6.2 ,python一共提供了68个内置函数,具体如下 abs() dict() h ...
python打开网址搜索关键字_Python实验:百度搜索关键字自动打开相关URL
#! python # coding: utf-8 # python实现百度搜索关键字,并依次用浏览器打开前五个搜索结果 ## ##Beautiful Soup 是一个模块,用于从HTML 页面中提取 ...
python将输入值转化为元组_Python实现将元组中的元素作为参数传入函数的操作
本文由Markdown语法编辑器编辑完成. 1. 需求: 现在有一个Python的需求需要实现: 就是实现连接一次数据库,就能够执行多条SQL语句,而且这个SQL语句是需要通过调用者将每一次执行的参数 ...

python定义匿名函数关键字_Python（11）：Python函数基础（定义函数、函数参数、匿名函数）...

python定义匿名函数关键字_Python（11）：Python函数基础（定义函数、函数参数、匿名函数）...相关推荐

最新文章

热门文章