Python入门之 函数

1、初识函数

1.1 什么是函数?

<1> 将某个功能封装到一个空间中就是一个函数

<2> 减少重复代码

1.2 定义函数

def -- python中的关键字

()-- 必须要写 格式规定

: -- 语句结束

def len():
函数体
def my_len():
n = 0
for i in dic:
n += 1
print(n)

1.3 函数的调用

函数名 + () 就是在调用函数

def yue():
print("掏出手机")
print("打开微信")
rint("摇一摇")
print("聊一聊")
print("约吗?")
print("....")
yue()
yue()

面向过程:

print("掏出手机")
print("打开微信")
print("摇一摇")
print("聊一聊")
print("约吗?")
print("....")
print("上班")
print("掏出手机")
print("打开微信")
print("摇一摇")
print("聊一聊")
print("约吗?")
print("....")
print("检查一下")

面向函数编程:

def work():
print("打开电脑")
print("查看邮件")
print("打开找到微信")
print("进行群聊")
print("开始撸代码")
print("撸完")
print("下班")
def yue():
print("掏出手机")
print("打开微信")
print("摇一摇")
print("聊一聊")
print("约吗?")
print("....")
yue()
work()
yue()
print("检查一下")
yue()
print("6块钱的麻辣烫")
yue()
print("歇会,上个班")

1.4 函数的返回值

def yue():
print("打开手机")
print("打开微信")
print("打开附近的人")
print("聊一聊")
print("见一见")
print("......")
return 1,2,3,4,5
print(1111)
girl = yue()
print(girl)

(1)函数的返回值,返回给函数的调用者

return 值 (返回值)

(2)return:

<1> 可以返回任意类型数据
<2> return返回多个内容时是元组的形式
<3> return下方不执行,并且会终止当前这个函数
<4> return不写或者写了return后面不写值都返回None

函数名+()

启动函数

接受返回值

1.5 函数的参数

def yue(app1,app2,app3,app4):      # 形参
print("打开手机")
print(f"打开{app1} {app2}")
print("聊一聊")
print("见一见")
print("......")
yue("微信","探探","陌陌","soul") # 实参
def yue(a,b,c,app1="微信"):     # 形参
print("打开手机")
print(f"打开{a} {app1}")
print("聊一聊")
print("见一见")
print("......")
yue("探探","陌陌","微信") # 实参
def yue(a,b,c,a1="微信"):     # 形参
print("打开手机")
print(f"打开{a} {b} {c} {a1}")
print("聊一聊")
print("见一见")
print("......")
yue(11,c=5,b=1) # 实参

三元运算符*(三目运算符):(只支持if else)

条件成立的结果 条件 条件不成立的结果

def func(a,b):
return a if a > b else b
print(func(6,9))
def info(name,age,job,moeny,sex="男"):
print(f"姓名:{name} 年龄:{age} 性别:{sex} 岗位:{job} 薪资:{moeny}")
while True:
name = input("name:") # rimo
age = input("age:") # 89
sex = input("sex(男性回车):") # 女
job = input("job:") # wc
money = input("moeny:") # 10
if sex == "女":
info(name,age,job,money,sex)
else:
info(name, age, job, money)

(1)形参:

<1> 位置参数:

​ 一一对应

<2> 默认参数: 函数定义的时括号中写好的就是默认参数

​ 不进行传参使用默认参数,进行传参时使用传递的参数

(2)实参:

<1>位置参数:

​ 一一对应

<2> 关键字参数:

​ 按照名字进行传参

(3)混合参数:

​ 位置参数和关键字参数一起使用

​ 位置参数 > 默认参数(关键字参数)

形参: 函数定义阶段括号中的参数叫做形参

实参: 函数调用阶段括号中的参数叫做实参

传参: 将实参传递给形参的过程叫传参

2、函数进阶:

def eat(a,b,c,d,e,f):
print(a,b,c,d,e,f)
eat("麻辣烫","大烧饼","大煎饼","大腰子","韭菜","羊蝎子")

如何解决参数数量太多?

2.1 动态位置参数:

def eat(*args):    # 函数的定义阶段 *聚合(打包)
print(args) # tuple
print(*args) # 函数体中的 * 打散(解包)
eat("麻辣烫","大烧饼","大煎饼","大腰子","韭菜","羊蝎子")
def eat(a,b,*c):       #位置参数 > 动态位置参数
print(a)
print(b)
print(c) # tuple
eat("面条","米饭","馒头","大饼")
def eat(a,b,*args,d=2,**c):  # 位置参数 > 动态位置参数 > 默认参数 > 动态默认参数
print(a)
print(b)
print(d)
print(args) # tuple
print(c) # dict
eat("面条","米饭","大烧饼","大煎饼",a1=1,b1=2) # 位置 > 关键字
def eat(*args,**kwargs):  # (万能传参)
print(args) # tulpe
print(kwargs) #
lst = [1,23,4,6,7]
dic = {"key1":1,"key2":3}
应用场景
eat(lst,dic) eat(*lst,**dic) # eat(1,23,4,6,7,"key1"=1,"key2"=2)

总结:

<1> *args (聚合位置参数) 大家伙都用的名字,可以进行修改但是不建议修改

<2> **kwargs (聚合关键字参数) 大家伙都用的名字,可以进行修改但是不建议修改

函数的定义阶段 * 和 ** 都是聚合

函数体中 * 就是打散,* args将元组中的元素进行打散,* kwargs将字典的键获取

2.2 形参:

<1> 位置参数

动态位置参数:先执行位置参数,位置参数接受后额外的参数由动态位置参数进行接受 ,获取的是一个元组

<2> 默认参数

动态关键字参数(默认):先执行默认参数,默认参数接受后额外的由默认参数进行接受,获取的是一个字典

实参和函数体:

  • *打撒
  • **实参时能够使用

2.3 函数的注释:

def a(a:int,b:int):
"""
求和
:param a: int
:param b: int
:return: int
"""
return a + b def b(a:int,b:int):
"""
求差
:param a: int
:param b: int
:return: int
"""
return a - b

(1)函数名._ doc _ #查看函数的注释

(2)函数名._ name _ #查看函数的名字

2.4 名称空间

(1)内置空间:Python解释器自带的空间

(2)全局空间:py文件中顶格写的就是全局空间

(3)局部空间:函数体中就是局部空间

<1> 加载顺序:

​ 内置空间

​ 全局空间

​ 局部空间

def func():
a = 1
print(a)
func()
<2> 取值顺序:

​ 局部空间

​ 全局空间

​ 内置空间

a = 10
def func():
print(a)
func()

(4)作用域:

全局作用域:全局 + 内置

局部作用域: 局部

作用域的作用就是保护数据的安全性

2.5 函数的嵌套:

不管在什么位置,只要是函数名() 就是在调用一个函数

混合嵌套:

def f1():
print(11)
def f2():
print(22)
f1()
def f3():
print(33)
f1()
def run():
f3()
f2()
f1()
run()
def foo(a):
a = 10
def f1(b):
c = b
def foo(c):
print(c)
print(foo.__doc__)
foo(c)
print(b)
f1(a)
print(a)
foo(25)

2.6 global :只修改全局,没有时就创建一个

a = 10
def func():
global a
a = a - 6
print(a)
print(a)
func()
print(a)

2.7 nonlocal :只修改局部,修改离nonlocal最近的一层,上一层没有继续向上上层查找,只限在局部,没有就报错

a = 100
def func():
b = 10
def foo():
b = a
def f1():
nonlocal b
b = b + 5
print(b) # 105
f1()
print(b) # 105
foo()
print(b) # 10
func()
print(a) # 100

​ enumerate() #枚举 默认从0开始数 第一个参数是可迭代对象 第二个对象是起始值

3 、 函数的第一类对象及使用

(1)函数名可以当做值,赋值给变量 :

def func():
print(1)
print(func) # 函数的内存地址
a = func
print(a)
a()

(2)函数名可以当做容器中的元素:

def login():
print("这是登录")
def register():
print("这是注册")
def index():
print("这是博客园的主页")
msg = """
1 登录
2 注册
3 主页
"""
choose = input(msg) # 1
if choose.isdecimal():
if choose == "1":
login()
elif choose == "2":
register()
elif choose == "3":
index()

​ 改良:

def login():
print("这是登录")
def register():
print("这是注册")
def index():
print("这是博客园的主页")
dic = {"1":login,"2":register,"3":index}
msg = """
1 登录
2 注册
3 主页
"""
choose = input(msg) # 1
if choose.isdecimal():
if dic.get(choose):
dic[choose]()
else:
print("请正确输入!")

(3)函数名可以当做函数的参数:

def func(a):
print(111)
a()
def foo():
print(222)
func(foo)

(4)函数名可以当做函数的返回值:

def func():
def foo():
print(111)
return foo
a = func()
a()
func()() # foo()

练习:

def f1(c):
def a():
def f3():
print(3333)
return [f3,a,f1]
print(11)
return f3()
ret = a()
return c(ret) def aa(b):
print(111)
return b
print(f1(aa))

4、匿名函数 == 一句话函数(一行函数)

匿名函数是有名字的 叫做 lambda

(1)lambda x:x

<1> lambda 关键字

<2> x 是普通函数的形参(位置,关键字·····)可以不接收参数,可以不写

<3> :x 冒号后边的x是普通函数的函数值 (只能返回一个数据类型),必须要有返回值

print((lambda x:x+6)(5))

f = lambda x:x+6
print(f.__name__) f = lambda x,y,z,b=1:x,y,z,b
print(f(1,2,3)) print([lambda :5][0]())
print((lambda :5)())
a = lambda :5
a() lst = [lambda :i for i in range(5)]
print(lst[0]())
lst = [lambda :i for i in range(5)]
print(lst[0]()) 面试题拆解:
lst = []
for i in range(5):
def func():
return i
lst.append(func)
lst = [] # [lambda x:x+1,lambda x:x+1]
for i in range(2):
lst.append(lambda x:x+1)
print(lst[-1](5)) lst = [lambda x:x+1 for i in range(5)]
print(lst[0](5)) tu = (lambda :i for i in range(3))
print(next(tu)())
print(next(tu)())
print(next(tu)()) def func():
for i in range(3): # i = 0 1 2
def foo(): # foo1 foo2 foo3
return i
yield foo # foo1 foo2 foo3
g = func()
print(next(g)()) # foo1
print(next(g)) # foo2
print(next(g)) # foo3 lst = [lambda :i for i in range(3)]
print(lst[0]()) tu = (lambda :i for i in range(3))
print(next(tu)())
lst = [lambda x:x+5 for i in range(2)]
print([i(2) for i in lst]) lst = [] # [lambda x:x+5,lambda x:x+5]
for i in range(2):
lst.append(lambda x:x+5)
new_lst = []
for i in lst:
new_lst.append(i(2))
print(new_lst)
lst = (lambda x:x+5 for i in range(2))
print([i(2) for i in lst]) def func():
for i in range(2):
f = lambda x: x + 5
yield f
g = func()
lst = []
for i in g:
lst.append(i(2))
print(lst)
lst = [lambda x:x*i for i in range(2)]
print([i(2) for i in lst]) #[2,2] lst = [] # [lambda x:x*i,lambda x:x*i]
for i in range(2):
lst.append(lambda x:x*i)
# print(i)
new_lst = []
for em in lst:
new_lst.append(em(2))
print(new_lst)
lst = (lambda x:x*i for i in range(2))
print([i(2) for i in lst]) #[0,2] def func():
for i in range(2):
f = lambda x:x*i
yield f
g = func()
lst = []
for i in g:
lst.append(i(2))
print(lst)

Python入门之 函数的更多相关文章

  1. Python入门篇-函数、参数及参数解构

    Python入门篇-函数.参数及参数解构 作者:尹正杰 版权声明:原创作品,谢绝转载!否则将追究法律责任. 一.函数概述 1>.函数的作用即分类 函数 数学定义:y=f(x) ,y是x的函数,x ...

  2. Python入门-初始函数

    今天让我们来初步认识一个在python中非常重要的组成部分:函数 首先,让我们来幻想这样一个场景: 比如说我们现在想要通过社交软件约一个妹子,步骤都有什么? print('打开手机 ') print( ...

  3. python入门15 函数

    函数的主要作用是实现代码复用 1 python内置函数 2 匿名函数lambda 3 自定义函数 def functionname(arg):... #coding:utf-8 #/usr/bin/p ...

  4. python入门总结-函数

    函数形式: def functionname(paramlist): function body 局部变量不改变实参的值,如果需要改变,声明global.比如,global x 可以给函数默认值,注意 ...

  5. python入门之函数

    为什么要用函数 python的函数是由一个新的语句编写,即def ,def是可执行的语句--函数并不存在,知道python运行了def后才存在. 函数是通过赋值函数传递的,参数通过赋值传递给函数. d ...

  6. Python入门之函数的装饰器

    本章目录: 装饰器: 一.为什么要用装饰器 二.什么是装饰器 三.无参装饰器 四.装饰器语法糖 五.认证装饰器实现 六.叠加多个装饰器 七.带参装饰器 ======================== ...

  7. Python入门之函数的嵌套/名称空间/作用域/函数对象/闭包函数

    本篇目录: 一.函数嵌套 二.函数名称空间与作用域 三.函数对象 四.闭包函数 ============================================================ ...

  8. Python入门day04_函数与装饰器

    一.函数入门 什么是函数: # 函数:函数是一系列代码的集,用来完成特定功能的代码块,类似于工具,可以重复不但的去使用 为什么要有函数: # 优点:# 1. 避免代码的冗余 # 2. 让程序代码结构更 ...

  9. python入门之函数对象

    目录 函数是第一类对象 1.函数名可以被引用 2.函数名可以当做参数传递 3.函数名可以当做返回值使用 4.函数名可以被当做容器类型的元素 函数是第一类对象 First-Class Object : ...

随机推荐

  1. GO语言学习笔记1-输入带空格的字符串

    最近开始学习GO语言,并做了一些编程练习.有道题要输入带空格的字符串,这在C/C++中很容易实现,但GO中好像并不那么容易.学过C/C++的可能都知道,在C中可以使用gets()函数,在C++可以使用 ...

  2. Set数据结构

    1.生成Set数据结构 const s = new Set(); const set = new Set([1, 2, 3, 4, 4]); 以上如果打印set值: 2.特性 它类似于数组,但是成员的 ...

  3. Linux培训教程 linux下修改用户权限的方法

    一般我们日常碰到要修改用户权限的,往往是要么修改一下用户的gorupid,通过上面命令可以改;要么是把普通用户改成具有超级权限的用户,这个一般自己不能直接改,只能是root或有root权限的用户才能帮 ...

  4. Linux入门培训教程 linux网络编程socket介绍

    一.概念介绍 网络程序分为服务端程序和客户端程序.服务端即提供服务的一方,客户端为请求服务的一方.但实际情况是有些程序的客户端.服务器端角色不是这么明显,即互为Linux培训 客户端和服务端. 我们编 ...

  5. XML 文档包含 XML 元素。

    XML 文档包含 XML 元素. 什么是 XML 元素? XML 元素指的是从(且包括)开始标签直到(且包括)结束标签的部分. 元素可包含其他元素.文本或者两者的混合物.元素也可以拥有属性. < ...

  6. Python3学习笔记(八):集合

    集合(set)是一种可变的无序的不重复的数据类型 要创建集合,需要将所有项(元素)放在花括号({})内,以逗号(,)分隔. >>> s = {'p','y','t','h','o', ...

  7. splice()、slice()、split()函数的区分

    1.slice(数组) 用法:array.slice(start,end) 解释:该方法是对数组进行部分截取,并返回一个数组副本:参数start是截取的开始数组索引,end参数等于你要取的最后一个字符 ...

  8. 测试常用linux命令之sed篇

    一.sed命令 可以放在单独的脚本文件中执行:sed -f script1 data1 多条命令也可以用{}括起来 sed可以进行文本的替换,删除,行添加,打印等.采用 sed [address]{c ...

  9. 几种常见的CSS布局

    本文概要 本文将介绍如下几种常见的布局: 其中实现三栏布局有多种方式,本文着重介绍圣杯布局和双飞翼布局.另外几种可以猛戳实现三栏布局的几种方法 一.单列布局 常见的单列布局有两种: header,co ...

  10. ros the public key is not available

    W: An error occurred during the signature verification. The repository is not updated and the previo ...