python函数
python函数
目录
定义
函数是组织好的，可重复使用的，用来实现单一，或相关联功能的代码段。
函数能提高应用的模块性，和代码的重复利用率。
自定义函数
#格式
def 函数名(参数列表)
'''
注释说明这个函数的作用
:param xxx: 说明这个参数可以传什么
:param xxx:
:return: 说明这个函数的返回值
'''
函数体
#调用
函数名(参数列表)
函数的调用
-
直接调用
fun()def func() func() #最好不要这样用,否则在别的模块引用这个模块的时候,这个函数也会被调用到. a.py def func(): func() -
调试
python 层级结构
project-->包-->目录
包和目录的区别:
- 包里面是包含一个_init_.py的文件,它是用来初始化里面的py文件(模块)，使这些模块(py文件)可以被其它模块调用
''' __name__:当前模块的名称 __main__:当前被运行的模块名称 ''' def func() if __name__ == '__main__': func() 作用: 写在main函数上面的代码,就是为了防止避免被其它模块调用. 最主要的作用是调试 -
跨模块调用
from xx包 import xx模块
参数
参数为空， 单个参数，多个参数，默认参数，可变长参数
无参数
#无参数
def func():
print('aaa')
func()
单个参数
#单个参数
def func1(name): #name是形参
print(name+'被输出')
if __name__=='__main__':
func1('user') #调用时要传入一个实参
多个参数
# 多个参数
def func2(name,where) :
"""
可以说明这个函数的作用
:param name: 说明这个参数可以传什么
:param where:
:return: 说明这个函数的返回值
"""
print(name+'在'+where+'努力学习')
if __name__=='__main__':
func2('小明','中国') #调用的时候,要一一对应传入
默认参数
定义函数时,如果有多种参数,则要把默认参数放在不带默认值参数的后面
# 默认值参数
# 传入默认参数时,要把默认参数放在不带默认值参数的后面
def func3(name,where,do='玩游戏') :
print(name+'在'+where+do)
if __name__=='__main__':
func3('小明','中国') #调用函数时未给默认参数传新值，则函数使用默认值
func3('小明','中国','努力学习') ##调试函数给默认参数传新值，则函数使用新值
可变长元组参数
使用可变长元组参数时,必须在变量名前面加 '*'
可变长元组参数,传入的时一个元组
#可变长元组参数 *变量名
# type(name) --><class 'tuple'>
def func4(*name) :#*name表示的就是可变长元组参数,作用:可以接收多个实际传入的参数
print(type(name)) #<class 'tuple'>
print(name[0]+'1')
print(name[1]+'2')
print(name[2]+'3')
if __name__=='__main__':
func4('小明','小红','小黄')
可变长字典参数
使用可变长字典参数时,必须在前面加 '**'
当可变长元组和可变长字典同时出现时，默认将可变长字典放后面
#可变长字典参数 **变量名
# type(dict1) --><class 'tuple'>
def func5(**dict1) :#**dict1表示的就是可变长字典参数,作用:可以接收字典格式的参数
print(type(dict1)) #<class 'dict'>
print(dict_param)
for
# 传入可变长参数,并调用函数
# 方法1:
dict_param={'name':'小明','age':18,'sex':'nan'}
func5(**dict_param)
# 简化调用
func5(**{'name':'小明','age':18,'sex':'nan'})
可变长元组和可变长字典混合使用
- 先定义可变长元组,再定义可变长字典
- 调用这个函数的时候,传入可变长字典参数的时候前面要加**
# 普通参数,可变长元组和可变长字典混合使用
def func6(a,*t,**d):
print(a)
print(t)
print(d)
if __name__=='__main__':
func6('aa',('小明','小红','小黄'),**{'name':'小明','age':18,'sex':'nan'}
全局变量&局部变量
局部变量:函数中定义的变量
全局变量 : 函数外部的变量
global:可以把函数内部的的局部变量变成优先级最高的全局变量 , 同时把这个局部变量改成全局变量
num = 100
def fun2():
sum=num+100
print(sum) #200
def fun1():
global num
num=50 #同时会修改全局的num变量,此时会把局部变量提升为全局变量
sum=num+100
print(sum) #150
print(sum) #50
函数返回值
格式: return xxx
注意点:
- 如果没有return , 默认返回值为 'None'
- 函数执行时, return 语句后面的所有语句都不会被执行
作用:
- 在程序开发中，有时候会希望一个函数执行程序结束后，告诉调用者一个结果，以便调用者针对具体的结果做后续的处理。 返回值是函数完成工作后，最后给到调用者的一个结果。
- 调用函数的一方可以使用变量来接收函数的返回结果。
实战练习:
#需求：登录银行系统并显示余额，有两个功能第一个是登录，第二个是登录后显示余额，先登录然后根据登录是否成功然后是否显示余额。
#分析思路：如果想查询到余额，前提必须登录，所以现在我们用两个函数来处理，第一个函数实现登录，第二个函数实现余额查询，调用第一个函数得到的结果给第二个函数，然后第二个函数根据结果进行代码处理。
def login():
name=input('请输入:')
if name == 'admin' :
print('输入正确,登录成功')
return 'success'
else:
print('输入错误,登录失败')
return 'error'
def check_account():
status=login()
if status=='success':
print('显示余额')
return '余额'
else:
print('不能查余额')
return '登录失败,不能查余额'
if __name__=='__main__':
check()
内置函数
format()函数
# 不使用format()函数格式化输出
print('%s is number %d' %('xiaoming',1))
# 使用format()函数 :格式化输出
#不指定顺序进行格式化输出
print('{} is {} one'.format('xiaoming','number'))
#根据索引位进行指定顺序
print('{1} is {1} one'.format('xiaoming','number'))
# 对参数设置参数名格式化输出
print('姓名:{name},年龄:{age}'.format(name='xiaoming',age=18))
# 对列表进行格式化
list1=['xiaoming','18','男']
hobby='打球'
print('姓名:{0[0]},年龄:{0[1]},性别:{0[2]},爱好:{1}'.format(list1,hobby))
#对字典进行格式化
dict1={'name':'xiaoming','age':30,'rich':50,'sex':'man'}
print('姓名:{name},年龄:{age}'.format(**dict1))
print('姓名:{0[name]},年龄:{0[age]}'.format(dict1))
zip()打包函数
- zip() 函数用于将可迭代的对象作为参数，将对象中对应的元素打包成 一个个元组，然后返回由这些元组组成的列表
- 可迭代对象:字符串,列表,字典,元组,集合
- 不可迭代对象: 整型
- 对于1个打包对象只能解压1次,再次解压会返回空列表[ ]
# zip打包函数: 通常对可迭代数据进行处理:
# 可迭代:string,list,tuple,set,dict
# 不可迭代:int
list1=['小明','小红','小黄','小绿']
list2=['aa','bb','cc','dd']
l=zip(list1,list2) #压缩
print(l) #结果为: <zip object at 0x0000029FD8929DC0>
print(list(l)) # 解压并转为列表 结果为: [('小明', 'aa'), ('小红', 'bb'), ('小黄', 'cc'), ('小绿', 'dd')]
print(list(l)) # 解压 结果为:[] 一个zip对象,只能处理解压1次;再次解压会返回空列表[ ]
# 利用字典的方法转换成字典
list1=['小明','小红','小黄','小绿']
list2=['aa','bb','cc','dd']
l=zip(list1,list2) #压缩
print(dict(l)) #解压并转字典 结果为: {'小明': 'aa', '小红': 'bb', '小黄': 'cc', '小绿': 'dd'}
#由于zip解压的结果为 [('小明', 'aa'), ('小红', 'bb'), ('小黄', 'cc'), ('小绿', 'dd')]
#可以转成字典 {'小明': 'aa', '小红': 'bb', '小黄': 'cc', '小绿': 'dd'}
如果各个迭代器的元素个数不一致，则返回列表长度与最短的对象相同
# 如果各个迭代对象的元素不一致,则返回列表长度与最短对象长度相同
list1=['小明','小红','小黄']
list2=['aa','bb','cc','dd']
l=zip(list1,list2)
print(l)
list1=list(l)
print(list1) #[('小明', 'aa'), ('小红', 'bb'), ('小黄', 'cc')]
dict1=dict(l)
print(dict1) #{} 只能解压1次
open打开函数
用于打开一个文件,创建一个file对象
语法:
open(file路径, mode,encoding='utf-8')
# 模式有r(只读),w(写入覆盖),a(写入追加)
# 在python里面读取计算机本地文件时,尽量加上encoding='utf-8'
#file路径防止转义方式:
# 1.路径前面加r,r---对文件路径中遇到的转义,不起作用
# 2.对单个'\'变成'\\'
读模式
只能对内容读1次,再次读会显示空
# 第一个r的作用: 把需要打开的文件路径进行防止转义的处理
# 第二个r的作用:mode='r' 表示打开的方式为r,也就是只读
o=open(r'./aa.text',mode='r',encoding='utf-8')
a=o.read() #使用read方法读取文件的全部内容,并以字符串的类型赋值给a
print(type(a)) #<class 'str'>
b=o.readline() #读取文件的第一行,以字符串的形式赋值给b,换行符是看不见的,但是起作用
c=o.readlines() #使用readlines方法读取文件剩下的全部内容,以列表的方式进行赋值,每一行就是列表的元素
o.close() #关闭文件;对文件写入后,一般都是使用close函数关闭文件,释放资源
写模式
写完返回的是写入的字符串长度
# 写模式
o=open(r'./aa.txt',mode='w',encoding='utf-8')
# a=o.read() #写模式,不能读
# print(a)
a=o.write('welcome') #返回写入的字符串的长度
a=o.write('\naa')
o.close() #关闭文件;对文件写入后,一般都是使用close函数关闭文件,释放资源
追加模式
o=open(r'./aa.txt',mode='a',encoding='utf-8')
o.write('\n追加的内容')
open函数优化写法
用with语句的好处，就是到达语句末尾时，会自动关闭文件，即便出现异常
with open(file路径, mode) as f:
...
浙公网安备 33010602011771号