函数的介绍
# python中的函数
# 函数的定义
# 打印一个佛祖镇楼 -> 一个功能点的解释
def print_info():
print(
"测试")
print(
" _ooOoo_ ")
print(
" o8888888o ")
print(
" 88 . 88 ")
print(
" (| -_- |) ")
print(
" O\\ = /O ")
print(
" ____/`---'\\____ ")
print(
" . ' \\| |// `. ")
print(
" / \\||| : |||// \\ ")
print(
" / _||||| -:- |||||- \\ ")
print(
" | | \\\\\\ - /// | | ")
print(
" | \\_| ''\\---/'' | | ")
print(
" \\ .-\\__ `-` ___/-. / ")
print(
" ___`. .' /--.--\\ `. . __ ")
print(
" ."" '< `.___\\_<|>_/___.' >'"". ")
print(
" | | : `- \\`.;`\\ _ /`;.`/ - ` : | | ")
print(
" \\ \\ `-. \\_ __\\ /__ _/ .-` / / ")
print(
" ======`-.____`-.___\\_____/___.-`____.-'====== ")
print(
" `=---=' ")
print(
" ")
print(
" ............................................. ")
print(
" 佛祖镇楼 BUG辟易 ")
print(
" 佛曰: ")
print(
" 写字楼里写字间，写字间里程序员； ")
print(
" 程序人员写程序，又拿程序换酒钱。 ")
print(
" 酒醒只在网上坐，酒醉还来网下眠； ")
print(
" 酒醉酒醒日复日，网上网下年复年。 ")
print(
" 但愿老死电脑间，不愿鞠躬老板前； ")
print(
" 奔驰宝马贵者趣，公交自行程序员。 ")
print(
" 别人笑我忒疯癫，我笑自己命太贱； ")
print(
" 不见满街漂亮妹，哪个归得程序员？")
a = 10
if a == 10
:
# print_info()
pass # 占位符，防止语法错误
# num = 1
# if num == 1:
# print_info()
# my_str = "hello"
# if my_str == "hello":
# print_info()
# 函数 - > python
函数的定义和调用
# 使用函数分为两步
'''第一步：定义函数'''
# def -> define 定义
# 格式：def 函数名():
# 执行的代码01
# 执行的代码02
# 执行的代码03...
def my_func():
print(
"hello python")
'''第二步：函数的调用(执行)'''
# 格式：函数名()
my_func()
函数的参数(一)
# 利用函数来完成
# 函数的定义
def my_func1():
num1 = 1
num2 = 2
# 定义两个变量
ret = num1 +
num2
print(ret)
# 打印
my_func1()
# 函数调用
def my_func2():
num1 = 90
num2 = 9
# 定义两个变量
ret = num1 +
num2
print(ret)
# 打印
my_func2()
# 合二为一
# 定义一个有参数的函数
# 形参：形式参数
# 格式：def 函数名(形参1,形参2,...)
def my_func3(a, b):
ret = a + b
# 求和
print(ret)
# 打印
# 执行一个有参数的函数
# 实参：实际参数
# 格式： 函数名(实参1,实参2,...)
my_func3(15, 6)
# 执行一个有参数的函数
num1 = 15
num2 = 6
# 在执行函数的时候就好比是a=num1,b=num2
my_func3(num1, num2)
# 通过一个函数 打印一句话 无论输入什么字符串，最终格式：你好xx
def my_func(name):
print(
"你好%s" %
name)
print(
"你好%s" %
name)
print(
"你好%s" %
name)
my_func("小红")
函数的返回值
# 等号右侧的值返回给了a
# 叫a 记录这个20的值
# a = 10 + 10
# print(a)
# python中学习了一个内置函数len(object)
# 内含子函数如何实现
my_str =
"hello" # 定义一个字符串
def my_len(object):
ret =
0
for i
in object:
# 猜测
ret += 1
# 如果有一个return数值，成为这个函数的返回值
return ret
my_1 =
my_len(my_str)
print(
"自定义的:", my_1)
# 输出：None ->返回值 空值类型
# my_len(my_str) # 输出：5
l =
len(my_str)
print(l)
# 输出：1
# 定义一个函数
def add2num(a,b):
ret = a +
b
return ret
num = add2num(10,11
)
print(num)
# 定义一个变量，记录圆周率
pi = 3.1415926
# 我想在执行一个函数的时候,给我圆周率
def my_pi():
return 3.1415926
ret =
my_pi()
print(ret)
函数的类型(4种)
'''
函数根据有没有参数，有没有返回值，可以相互组合，一共有4种
1、无参数，无返回值
2、无参数，有返回值
3、有参数，无返回值
4、有参数，有返回值'''
# 1、无参数，无返回值
def my_print():
print(
"你好")
print(
"python")
# 执行函数
my_print()
# 2、无参数，有返回值
def my_pi():
return 3.1415926
print(my_pi())
# 3、有参数，无返回值
def print_info(name):
print(
"你好%s" %
name)
print_info("马老师")
# 输出：你好马老师
def print_info(name):
print(
"你好%s" %
name)
name_list = [
'高老师',
'小明',
'小红',
'张三']
for new_name
in name_list:
# print(new_name)
print_info(new_name)
# 4、有参数，有返回值
def my_finc(a,b):
# ret = a + b
# return ret
return a + b
# 优化简写
result = my_finc(10,5
)
print(result)
函数的嵌套和使用
# def my_func1():
# print("my_func1开始")
# print("my_func1结束")
# print("开始测试")
# my_func1()
# print("测试")
''' 《输出》
开始测试
my_func1开始
my_func1结束
测试'''
def my_func1():
print(
"my_func1开始")
print(
"my_func1结束")
def my_func2():
print(
"my_func2开始")
my_func1()
print(
"my_func2结束")
my_func2()
print(
"测试")
'''《输出》
my_func2开始
my_func1开始
my_func1结束
my_func2结束
测试
'''
函数的应用：打印图形和数字计算
# 1、写一个函数打印一条横线
def print_one_line():
print(
"-"*10
)
# print_one_line() # 调用函数
# 2、打印自定义行数的横线
def print_lines(num):
for i
in range(num):
# for 循环
print_one_line()
# 执行函数pring_one_line
print_lines(5)
# 最终执行print_lines
# 3、写一个函数求三个数的和
def add3num(a, b, c):
return a + b +
c
# ret = add3num(10, 20, 30)
# print(ret)
# 4、写一个函数求三个数的平均值
def average3num(num1, num2, num3):
# 求num1+num2+num3
# ret = num1 + num2 + num3
# 通过求和函数完成
ret =
add3num(num1, num2, num3)
# 把和除以3
return ret / 3
result = average3num(10, 20, 30
)
print(result)
调用函数：位置参数
# 定义一个函数
def my_func(a, b):
print(a +
b)
# 函数调用 -> 位置参数调用函数
# 使用当前位置参数调用函数需要注意当前实参的位置
# 实参的位置和当前形参的位置要一一对应
# 如果实参传入的少一个，会报错
# TypeError: my_func() missing 1 required positional argument: 'b'
my_func(10, 11)
调用函数：关键字函数
# 定义一个函数
# python是一个弱类型
def my_print(name, age):
print(
"我的名字:%s" %
name)
print(
"我的年龄:%d" %
age)
# 调用 ->位置参数
my_print(
"小明", 20
)
# 关键字参数
# 调用函数的时候使用的是函数的形参名
my_print(name=
"老王", age=32
)
# my_print(age=32, name="老王") #不在乎顺序
# 调用函数的时候使用了位置和关键字参数混合
my_print(
"小马", age=30
)
# 如果混合使用，需要让位置参数在前，关键字参数在后面
# my_print(age=30, "小马" ) # 会报错
# 如果某个参数使用了关键字参数，后面的都需要使用关键字参数
函数参数(二)：缺省参数
# 定义一个函数 （名字 学号 年龄）
def my_print(name, no, age):
print(
"名字:%s" %
name)
print(
"学号:%s" %
no)
print(
"年龄:%d" %
age)
print(
"="*10
)
# 小明 001 20
# 小红 002 20
# 小张 003 20
my_print(
"小明",
"001", 20
)
my_print("小红",
"002", 20
)
my_print("小张",
"003", 20
)
# 或者下面写法
# 定义一个有缺省参数的函数
#缺省函数：给形参设置了一个默认值
def my_print(name, no, age=20
):
print(
"名字:%s" %
name)
print(
"学号:%s" %
no)
print(
"年龄:%d" %
age)
print(
"="*10
)
# 在调用函数的时候，如果有默认值，可以根据业务需求不传递
my_print(
"小明",
"001")
my_print("小红",
"002")
my_print("小张",
"003")
# 假如这个my_print的函数打印全班人的信息，有80%是20岁，但是20%年龄是25-30岁之间
# 如果执行函数时提供实参那么函数的形参使用实参
# 如果执行函数的时候没有提供实参那么形参讲使用默认值(缺省参数)
my_print(
"老王",
"010" ,30
)
# 在定义函数的时候，某个形参使用了缺省参数，那么后面的形参都需要用缺省参数
def my_print(name, age=20, no=
"001"):
print(
"名字:%s" %
name)
print(
"学号:%s" %
no)
print(
"年龄:%d" %
age)
print(
"="*10)
函数的返回值：多个return
# 定义一个函数，当执行函数的时候，传入一个分数，可以返回一个字符串(优 良 中 差)
# 包含多个return
def my_func(score):
# 对分数进行判断
if score >= 90
:
return "优"
elif score >= 80
:
return "良"
elif score >= 60
:
return "中"
elif score >=
0:
return "差"
print(
"测试")
# 它不会执行，因为在第11行已经执行了return
ret = my_func(89
)
print(ret)
# 输出：良
def my_func1():
print(
"开始")
# 只要函数中执行了return就提前结束函数的执行，而且return后面的代码将不再执行
return "3.14"
print(
"开始1")
return "20"
print(
"结束")
# my_func1()
ret =
my_func1()
print(ret)
print(
"测试")
'''《输出》
开始
3.14
测试
'''
python中return使用总结
# return总结
# <1>作为函数的返回值
# <2>执行的额函数提前结束(为了提高性能)
# 包含多个return
def my_func(score):
if score <
0:
print(
"您传入的分数有误!!!")
return # 函数的执行提前结束
print(
"测试")
# 对分数进行判断
if score >= 90
:
return "优"
elif score >= 80
:
return "良"
elif score >= 60
:
return "中"
elif score >=
0:
return "差"
# 需求：如果调用函数的人传入的分数为0，那么就认为传入的错误，告知函数的调用着
my_func(-10)
# 您传入的分数有误!!!
函数的返回值：函数返回多个数据
# 需求：传入一个名字 年龄
# 例如 小明 22
# 通过调用函数后，得到两个字符串 姓名：小明 年龄：22
def deal_name_age(name, age):
# 处理后 姓名:小明 年龄:22
new_name =
"姓名:%s" %
name
new_age =
"年龄:%d" %
age
print(new_name)
print(new_age)
return
deal_name_age("小明", 22
)
# 假如是列表
def deal_name_age(name, age):
# 处理后 姓名:小红 年龄:23
new_name =
"姓名:%s" %
name
new_age =
"年龄:%d" %
age
# print(new_name)
# print(new_age)
return[new_name, new_age]
# 变量为列表
ret = deal_name_age(
"小红", 23
)
print(type(ret))
print(ret[0])
print(ret[1
])
# 假如字典
def deal_name_age(name, age):
# 处理后 姓名:小章 年龄:24
new_name =
"姓名:%s" %
name
new_age =
"年龄:%d" %
age
return{
"name": new_name,
"age": new_age}
my_dict = deal_name_age(
"小章",24
)
print(my_dict[
"name"])
print(my_dict[
"age"])
# 假如元祖
def deal_name_age(name, age):
# 处理后 姓名:小章 年龄:24
new_name =
"姓名:%s" %
name
new_age =
"年龄:%d" %
age
# 如果在函数内部使用return，返回值1 返回值2，...默认就是元祖类型
return new_name, new_age
my_tuple = deal_name_age(
"小李",25
)
print(type(my_tuple))
print(my_tuple[0])
print(my_tuple[1])
拆包
# 拆包
# 定义一个列表
# my_list = [1, 3.14, "hello", True]
# 可以获取列表中元素的值，但是读性不强
# print(my_list[1])
# print(my_list[2])
# 拆包
# num, pi, my_str, my_bool = my_list
# print(pi)
# print(my_bool)
# num, pi, my_str, my_bool = [1, 3.14, "hello", True]
# 定义一个元祖
my_tuple = (1, 3.14,
"hello", True)
# um, pi, my_str, my_bool = my_tuple
# print(pi)
# 定义一个字典
my_dict = {
"name":
"老王",
"age":19
}
ret1, ret2 =
my_dict
# 得到的是key 字典是无序的
print(ret1, ret2)
# 一次定义多个变量
num1 = 10
num2 = 20
num3 = 30
num4 = 40
# 称之为比较python自夸
# 变量名和值是一一对应的
num1, num2, num3, num4 = 10, 20, 30, 40
print(num1)
# 思考：下面这个可以拆包吗？
def deal_name_age(name, age):
# 处理后 姓名:小章 年龄:24
new_name =
"姓名:%s" %
name
new_age =
"年龄:%d" %
age
# 如果在函数内部使用return，返回值1 返回值2，...默认就是元祖类型
return new_name, new_age
# 拆包：
my_name, my_age = deal_name_age(
"小明",20
)
print(my_name, my_age)
交换变量的值
# 第1种方式
a = 4
b = 5
c =
0
c = a
# c = 4
a = b
# a = 5
b = c
# b = 4
# 结果
print(a)
print(b)
# 第2种方式
a = 4
b = 5
a = a+b
# a=9, b=5
b = a-b
# a=9, b=4
a = a-b
# a=5, b=4
print(a)
print(b)
# # 第3种方式
a, b = 4, 5
# a = 4,b = 5
# 在执行27行时，看的是滴22行的代码
# a = b
# b = a
# 不是等价的
a, b = b, a
# a = 5,b = 4
print(a)
print(b)
函数的文档说明
# 假设使用len函数
help(len)
# 函数文档说明->加的文档说明是python
# len(obj, /)
# Return the number of items in a container.
# 很多的时候需要程序员自己创建
# 自定义一个函数
# def add2num(num1, num2):
# return num1 + num2
# # 如果一个自定义函数没有我问的那个说明，默认是help会打印函数上面的注释
# help(add2num) # 输出： # 自定义一个函数
# 自定义一个函数
def add2num(num1, num2):
""" # 6个双引号，按回车键，自动生成函数的文档说明
# 这个函数是用来计算两个数的和的
:param num1: # 数字1
:param num2: # 数字2
:return: # 返回值是两个数字相加
"""
return num1 +
num2
help(add2num)
# 错误的
# add2num([1, 2], (1, 3))
'''
01- 可以快速读懂自己的代码
02- 便于工作的交接
习惯和公司的要求
'''
局部变量
# 定义一个函数
def my_func1():
# 定义一个局部变量
# 局部变量：定义在函数内部的变量
# 局部的作用域(使用范围)在函数的内部，函数的外部无法使用
num = 10
print(num)
# 调用函数
my_func1()
# 再定义一个函数
def my_func2():
# 定义一个局部变量
num = 10
print(num)
# 在函数内部定义的局部变量名可以和其他函数的局部变量名相同，是不冲突的
my_func2()
全局变量
# 全局变量：定义在函数的外部的变量
# 全局变量 或者变量(作用域实在整个模块内使用)
# num1 = 10
# 分别在两个函数内部使用了全局变量
# def my_func1():
# print("my_func1", num1)
#
# def my_func2():
# print("my_func2", num1)
#
# print("函数外面", num1)
# my_func1()
# my_func2()
# 全局变量
# num2 = 10
# 分别在两个函数内部使用了全局变量
# def my_func3():
# # 其实是定义了一个和全局变量名相同的局部变量
# # 在函数内部如果使用变量，它先从函数内部找，如果有直接使用
# # 如果函数内部没有找到，会到函数外面找(全局变量)
# # 如果还是没有找到，就报错
# num2 = 20
# print("my_func3", num2)
#
# my_func3()
# print("外面", num2)
# 全局变量
num3 = 10
# 分别在两个函数内部使用了全局变量
def my_func3():
# 标识这两个函数内部不是定义一个局部变量，其实是对全局变量的进行修改
global num3
# 对全局变量进行修改
num3 = 20
print(
"my_func3", num3)
my_func3()
print(
"外面", num3)
匿名函数
# 匿名函数(藏名字的函数)
# 对函数的简写
# 无参数无返回值的函数
# def my_print():
# print("hello python")
# my_print()
# 表达式的定义
# f = lambda : print("hello python")
# 执行
# f()
# 等价于
# (lambda : print("hello python"))()
# 无参数有返回值的函数
# def my_pi():
# return 3.14
# print(my_pi())
# f = lambda : 3.14
# print(f())
# 有参数的无返回值的函数
# def my_prnt(name):
# print("你好%s" % name)
# print("姜子牙")
# f = lambda name:print("你好%s"%name)
# # 执行
# f("姜子牙")
# 有参数有返回值的函数
def add2num(a, b):
return a +
b
f =
lambda a, b :a +
b
ret = f(10, 20
)
print(f(10, 20))
列表推导式
# 定义一个列表
# my_list = {1, 2, 3, 4, 5}
# 定义一而空列表
# my_list = []
# for i in range(1, 101):
# my_list.append(i)
# print(my_list)
# 列表推导式
# 使用列表推导式快速创建一个列表
my_list = [i
for i
in range(1, 30
)]
print(my_list)
# 思考：得到一个有30个哈哈的列表
my_list = [
"哈哈" for i
in range(30
)]
print(my_list)
# 定义一个列表，保存数据[1,50]之间的偶数
my_list =
[]
for i
in range(1,51
):
if i % 2 ==
0:
my_list.append(i)
print(my_list)
# 列表推导式
my_list = [i
for i
in range(1,51)
if i % 2 ==
0]
print(my_list)
# def my_func1():# print("my_func1开始")# print("my_func1结束")# print("开始测试")# my_func1()# print("测试")''' 《输出》开始测试my_func1开始my_func1结束测试'''def my_func1():
print(
"my_func1开始")
print(
"my_func1结束")
def my_func2():
print(
"my_func2开始") my_func1()
print(
"my_func2结束")my_func2()
print(
"测试")
'''《输出》my_func2开始my_func1开始my_func1结束my_func2结束测试'''
转载于:https://www.cnblogs.com/yaoteng/p/10920608.html
