文章目录
- 1.函数定义和调用
- 1.1定义函数
- 1.2 函数的文档注释使用
- 1.3 关于函数返回值的一些细节
- 1.4 关于全局变量(global)
- 1.5 函数同时返回多个值(多个值可以包装成一个元组,返回一个元组对象)
- 1.6 练习Demo(正确定义一个函数、实现多个参数返回值)
- 1.7 默认参数 func(a, b, c=20)
- 1.8 关键字参数 func(c=1,b=2)
- 1.9 可变参数(一个*)
- 1.10关键字参数的可变参数(两个*)
- 1.11 参数的混合使用
- 1.12 在实参前面加*
- 1.13 自动组包、拆包
- 1.14 利用自动解包交换两个变量的值
- 1.15 小数字和短字符串的对象池
- 1.16 可变类型与不可变类型
- 1.17 参数的引用传递
- 1.18 +=与=+的区别
- 1.19 模块的基本使用
1.函数定义和调用
1.1定义函数
定义函数的格式如下:
def 函数名():
代码
demo:
# 注意python中习惯于使用下划线 _ 作为方法名的不同单词间的间隔
def print_my_python():
i = 0;
while i < 10:
print(f"第{i}遍输出我的Python")
i += 1
print("开始打印测试。。。")
print_my_python()
print("测试结束。。。")
# 无参数的方法定义
def sum1():
print(f"{3+5}")
sum1()
# 带参数的方法定义
def sum2(a, b):
return a + b
print(sum2(1, 1))
1.2 函数的文档注释使用
"""
函数的注释:
对函数进行解释说明的文字.
函数的文档注释:
在函数定义的那一行的下面添加的多行注释.
文档注释的作用:
对函数进行解释说明,提高了函数的可读性.
"""
def hello_python():
'''
函数的注释:
打印十次python
:return: 空值
'''
i = 1
while i <= 10:
print(f"hello python {i}")
i += 1
hello_python()
print()
1.3 关于函数返回值的一些细节
retur语句不写返回值,表示直接结束当前的操作,同一个文件中的函数不能够重名,重名了后边的方法会覆盖前边的方法。
"""
函数的5个细节(重点):
1.保存函数的返回值
2.直接打印函数的返回值
3.函数的返回值作为参数传递给另一个函数
4.函数中写多个return语句
5.同一个文件中函数不能重名
"""
def func1(x):
print(x)
# 1.保存函数的返回值
def sum1(a,b):
return a+b
res = sum1(2,3)
print(res) # 5
# 2.直接打印函数的返回值
print(sum1(2,3)) # 5
# 3.函数的返回值作为参数传递给另一个函数
func1(sum1(2,3)) # 5
# 4.函数中写多个return语句
# 只执行最上面的return语句.在执行函数时,只要执行了return语句,函数的执行到此结束,不再向下执行了.
print("========多个return==========")
def sum2(a,b,c):
return a
return b
return c + b
print(sum2(2,3,4)) # 2
# return语句后面可以不写返回值,这样表示函数执行到return语句到此结束,函数没有返回值.
def func2():
print("测试return方法")
return
print("测试返回后的return")
func2() # 测试return方法
def func4():
print("this is first")
def func4(a, b):
return a+b
'''
必须要注意,在python中同一个类中没有java的重写的这回事,后边的函数会直接覆盖前边的
# 5.同一个文件中函数不能重名
# 会使用后面定义的函数覆盖前面同名的函数
'''
# func4()
print(func4(1,2)) # 3
1.4 关于全局变量(global)
# 定义全局变量
a = 10
def func1():
# 如果在函数外面没有定义变量a,这里就是在定义全局变量a
global a # 注意需要使用global关键字声明后的a才是全局的变量,否则就不是
a = 100
# 打印全局变量
print(a) # 100
def func2():
# 打印全局变量
print(a) # 100
func1() #100
func2() #100,可以注意到全局变量的改变
1.5 函数同时返回多个值(多个值可以包装成一个元组,返回一个元组对象)
"""
函数同时返回多个值
"""
def func1(a, b):
res_sum = a + b
res_avg = res_sum / 2
res_multiply = a * b
# 在返回之前,python解释器会自动对return后面的数据进行组包成一个元组.
return res_sum,res_avg,res_multiply # return (s, avg, multip)
result = func1(10,20)
print(result)
print(type(result))
def func2(a, b):
res_sum = a + b
res_avg = res_sum / 2
res_multiply = a * b
return res_sum
print("测试单个值的会不会也包装成元组类型,结果不是。。。")
result2 = func2(10,20)
print(result2)
print(type(result2))
def func3(a, b):
res_sum = a + b
res_avg = res_sum / 2
res_multiply = a * b
return res_sum,res_sum #返回两个相同的变量也是可以的
result3 = func3(10,20)
print(result3)
print(type(result3))
1.6 练习Demo(正确定义一个函数、实现多个参数返回值)
def test_num(str):
upper_count = 0
lower_count = 0
dig_count = 0
other_count = 0
for e in str:
if e.isupper():
upper_count += 1
elif e.islower():
lower_count += 1
elif e.isdigit():
dig_count += 1
else:
other_count += 1
return upper_count, lower_count, dig_count, other_count
while True:
str = input("请录入一个字符串:")
if str.__eq__("no"):
break
res = test_num(str)
print(res)
1.7 默认参数 func(a, b, c=20)
"""
默认参数:
在定义函数时,给形参指定了默认的值,这个参数叫默认参数(缺省参数).
特点:
在调用函数时,可以给它传值也可以不给它传值.
如果传了,在执行函数时就会使用传递过去的值,如果没传就是用默认的值.
"""
def default_fun_test(a, b, c=20):
print(a + b + c)
default_fun_test(10,20,30)
default_fun_test(10,20)
1.8 关键字参数 func(c=1,b=2)
"""
关键字参数:
在调用函数时,根据形参的名称传递的实参叫做关键字参数.
特点:
是根据形参的名称给形参传值的.
关键字参数只能写在实参列表的最后.
"""
def test_keyword_num(a, b, c):
print(a + b + c)
test_keyword_num(a=10, b=20, c=30) # 60
test_keyword_num(10,20,c=30) # 60
test_keyword_num(b=20,a=10,c=30) # 60
test_keyword_num(10,20,30) # 60
'''
指定了关键字参数之后可以交换位置,指定形参对应的的值,灵活好多
'''
1.9 可变参数(一个*)
def func1():
print("空参方法")
def func2(a):
print(a)
def func3(a,b):
print(a)
print(b)
def func4(a,b,c):
print(a)
print(b)
print(c)
# 像上边的的这种参数可变的方法,多次定义,浪费资源
"""
可变参数:
在形参前面加了 一个 *,这个参数就叫可变参数(不定长参数).
表示0个或者任意多个形参.
特点:
1. 前面 有一个 *
2. 表示0个或者任意多个形参
好处:
1.可以扩展函数的功能,更加通用.
"""
def func5(* a):
print(* a)
print(a)
print(type(a))
print("======================")
for e in a:
print(e,end=" ")
print()
func5()
'''
()
<class 'tuple'>
======================
'''
print("========第一个===========")
func5(1)
'''
1
(1,)
<class 'tuple'>
======================
1
'''
print("==========第二个==============")
func5(1,2)
'''
1 2
(1, 2)
<class 'tuple'>
======================
1 2
'''
1.10关键字参数的可变参数(两个*)
"""
关键字参数的 可变参数:
在参数前面加 ** ,这个参数叫做 关键字参数的 可变参数.
"""
def print_arguments(a, ** kwargs):
print(kwargs)
print(type(kwargs))
# 如果以关键参数的形式 传递实参,而且 执行的形参名称又不存在.
# python解释器会自动把 关键参数打包成一个 字典, 然后把字典传递给带**的可变参数.
'''
特别注意:这里和前边的可变参数的区别在于这个**,打包的是一个字典,前边的*打包的是一个元组
'''
print_arguments(1,b=10,c=20)
'''
{'b': 10, 'c': 20}
<class 'dict'>
'''
print_arguments(a=1,b=10,c=20)
'''
{'b': 10, 'c': 20}
<class 'dict'>
'''
1.11 参数的混合使用
def test_mix_func(a,*args,b=20,c=30,**kwargs):
print(a)
print(args)
print(b)
print(c)
print(kwargs)
test_mix_func(10,20,30,40,50,b=2,c=3,mm=110,nn=120)
1.12 在实参前面加*
def func1(* a, ** b):
print(a) # ((10, 20), {'m': 10, 'n': 20})
print(b) # {}
def func2(*args,**kwargs):
print(args) #(10, 20)
print(kwargs) #{'m': 10, 'n': 20}
# 调用func1函数
# func1(args, kwargs)
# args是一个元组, kwargs是一个字典
# * 元组: 对元组解包,解成 元素1 元素2
# ** 字典: 对字典解包,解成 m=30, n=40形式的
func1(args,kwargs) # ((10, 20), {'m': 10, 'n': 20})
'''
(10, 20)
{'m': 10, 'n': 20}
((10, 20), {'m': 10, 'n': 20})
{}
'''
func2(10,20,m=10,n=20)
1.13 自动组包、拆包
# 拆包操作
a,b=(10,20)
print(a)
print(b)
print("======================")
#
a,b = [10,20]
print(a)
print(b)
print("========================")
# 组包操作
tuple1 = 10,20
print(tuple1)
cc = 10,20
print(cc)
1.14 利用自动解包交换两个变量的值
a = 10
b = 20
# 交换两个值的常用方法1:使用一个临时变量
temp = a
a = b
b = temp
print(a) # 20
print(b) # 10
print("======================")
# 交换两个值的常用方法1:借助两个变量的和
c = a + b
a = c - a
b = c - a
print(a) # 10
print(b) # 20
print("======================")
# 利用自动拆包
a, b = b, a # a,b -> 20,10 -> a,b = (20,10) -> a=20,b=10
print(a) # 20
print(b) # 10
1.15 小数字和短字符串的对象池
"""
小数字:
-5-256
短字符串:
长度不超过20的字符串
在python解释器一启动的时候,就会把小数字和短字符串放到 缓冲区(小数字对象池和短字符串对象池).
"""
a = 10
b = 10
print("========小数字的对象池==========")
# 获得数据的地址: 调用id(数据)
print(id(10)) # 2071815488
print(id(a)) # 2071815488
print(id(b)) # 2071815488
print("========大数字的对象池==========")
c = 100000
d = 100000
print(id(100000)) # 17096000
print(id(c)) # 17096000
print(id(d)) # 17096000
print("=========短字符串的对象池===============")
e = "aa"
f = "aa"
print(id("aa")) # 20385472
print(id(e)) # 20385472
print(id(f)) # 20385472
print("长字符串的对象池")
h = "hellohellohellohellohellohellohellohellohellohello"
i = "hellohellohellohellohellohellohellohellohellohello"
print(id("hellohellohellohellohellohellohellohellohellohello")) # 59737056
print(id(h)) # 59737056
print(id(i)) # 59737056
1.16 可变类型与不可变类型
"""
不可变类型:
如果改变了该类型的数据的值,地址 也发生了变化, 这种类型的数据,是不可变类型的数据.
常见类型:
int, float,bool, str, tuple
可变类型:
如果改变了该类型的数据的值,地址 没有 发生了变化, 这种类型的数据,是可变类型的数据.
常见类型:
列表,字典,set集合
"""
print("=========测试数字的可变性============") #属于不可变类型
a = 10
print(id(a)) # 2071815488
a = 20
print(id(a)) # 2071815648
print("=========测试字符串的可变性==============") #属于不可变类型
str1 = "helloWorld"
print(id(str1)) # 12797056
str1 = "newWorld"
print(id(str1)) # 12797136
print("=========测试字典类型的可变性============") #属于可变类型
list1 = [10,20]
print(id(list1)) # 21841400
list1.append(30)
print(list1)
print(id(list1)) # 21841400
print("=============")
1.17 参数的引用传递
"""
python中只有引用传递没有值传递.
也就是说在调用函数传递实参时,给形参传递的是实参的地址,而不是具体的数据值.
"""
def print_list(list2=[]):
list2.append(10)
print(id(list2))
print(list2)
list1 = [10,20]
print(list1) # [10, 20]
print(id(list1)) # 12601984
print("=======list2-test========")
print_list(list1)
'''
12601984
[10, 20, 10]
'''
1.18 +=与=+的区别
"""
a += 1
a = a + 1
这两种写法对应 不可变类型的 数据,是没有区别的.
"""
print("========测试不可变类型中的数字=========")
a = 10
print(id(a)) # 2071815488
a += 20
print(id(a)) # 2071815808
print("=======测试不可变类型类型中的字符串========")
str1 = "hello"
print(id(str1)) # 13111008
str1 += "python"
print(id(str1)) # 13321664
print("============测试可变类型的list字典==================") # 地址变了
# 只是把第二个列表中的元素放到第一个列表中,第一个列表的地址没有变,没有产生第三个列表
print("========测试list的 =+ ===========")
list1 = [10,20]
print(id(list1)) # 28526072
list1 = list1 + [30,40]
print(list1)
print(id(list1)) # 57130360
print("=============测试list的 += =======================") # 地址不变
# 是把两个列表中的元素都放到第三个列表中,产生了第三个列表,把第三个列表赋值给了list1
list2 = [10,20]
print(id(list2)) # 56511104
list2 += [30,40]
print(list2)
print(id(list2)) # 56511104
1.19 模块的基本使用
首先定义一个模块:
a = 100
def func1(a, b):
return a + b
在另一个类中使用:
"""
模块的基本使用:
模块: 一个.py文件就是一个模块.可以在这个模块文件中定义全局变量,函数和类.
可以把这个模块文件导入到另外一个程序文件中,然后在另外一个文件中调用模块文件中定义的
全局变量,函数和类
导入模块:
1.使用import关键字 导入模块
import 模块名
这里的模块名是指 .py文件的模块,不包含.py.
2.通过模块名访问模块文件中内容
模块名.全局变量
模块名.函数名(实参1,实参2,...)
"""
# 1.使用import关键字 导入模块
import module01
# 2.通过模块名访问模块文件中内容
print(module01.a) # 100
sum = module01.func1(10, 20)
print(sum) # 30