函数
一、什么是函数
1、定义：函数是组织好的，可重复使用的，用来实现单一，或相关联功能的代码段
2、函数能提高应用的模块性，和代码的重复利用率。
3、函数的类型： 自定义函数 ，内建函数
4、python中结构：
5、自定义函数分为两个阶段：函数定义阶段和函数调用阶段
（1）格式：def 函数名（）
函数体
函数名（）
案例：
def gs(): #定义阶段
print('a')
print("b")
gs() #调用阶段
6、调用方法有三种
（1）第一种：直接通过函数名（）
gs() #调用阶段
（2）第二种：通过main方法调用
主函数的解释：
解释：
if __name__ == '__main__': 是函数的入口，也称为主函数
__name__ 是当前模块名，当模块被直接运行时模块名为 __main__ ，这句话的
意思就是，当模块被直接运行时，以下代码块将被运行，当模块是被导入时，
代码块不被运行
案例：
def gs():
print('a')
print("b")
def ss():
print("c")
if __name__ == '__main__':
ss()
# gs()
（3）第三种跨模块调用
aa ：文件定义函数
案例：
def x():
print('a')
def y():
print("b")
def z():
print("c")
bb文件：
# from gsml.gsbao.aa import * #*代表调用所用
from gsml.gsbao.aa import * #调用指定的函数
x()
y()
z()
================================
函数：
（1）无参数函数
格式：
def 函数名(无参数):
执行语句块
函数名（）
案例
def gs():
print('a')
gs()
（2）函数中有单个参数
格式：
def 函数名(变量名1):
执行语句块
函数名（参数）
案例：
def gs(a):
print(a+2)
gs(3)
（3）函数中有多个参数
格式：
def 函数名(变量名1，变量名2):
执行语句块
函数名（参数1，参数2）
案例：
def gs(a,b):
print(a+b)
gs(5,6)
（4）函数定义时带上默认参数（缺省参数）
def 函数名(变量名1，变量名2=默认值):
执行语句块
函数名（参数1，参数2可写可不写）
案例：
传参的优先级高于默认值
案例:
def gs(a,b=5):
print(a+b)
gs(3,6)
（5）可变长元组
符号*表示
场景1：单独使用可变长元组
def gs(*a):
print(a)
gs(3,4,5,6,7,8)
场景2：当可变长元组和普通参数同时使用，普通参数在前，可变长元组在后
（6）可变长字典 **（两个*号））
场景1：单独传入字典
（1）def gs(**a):
print(a)
gs(name='zs',age='18')
（2）
d={'name':'zs','age':'18'}
def gs(**a):
print(a)
gs(**d)
场景2：单独传入可变长字典和普通参数和可变元组
普通参数最前，可变元组第二，可变长字典第三
d={'name':'zs','age':'18'}
def gs(x,*y ,**z):
print(x)
print(y)
print(z)
gs(1,2,3,4,5,6,**d)
案例3：普通参数和可变长字典
普通参数在前和可变长字典在后
d={'name':'zs','age':'18'}
def gs(x,**z ):
print(x)
# print(y)
print(z)
gs(1,**d)
案例4：可变长元组和可变长字典
可变长元组在前和可变长字典在后
d={'name':'zs','age':'18'}
def gs(*y,**z):
print(y)
print(z)
gs(1,2,3,3,**d)
==========================
函数的变量和作用域
1、变量：全局变量，局部变量
（1）在函数中也可以定义变量，在函数中定义的变量被称之为局部变量，局部变量
只在定义它的函数内部有效
（2）在函数体之外定义的变量，我们称之为全局变量
2、实战
注意点：
（1）当局部变量和全局变量都存在时，局部变量优先级高于全局变量
（2）全局可以被所有的函数引用
（3）将局部变量转换成全局变量 global
（4）函数外的局部变量优先级要低于 global 设置的全局变量
案例1：
a=20 #全局变量
def gs():
a=10 #局部变量
print(a)
def gs2():
print(a)
gs()
gs2()
案例2：
a=20 #全局变量===============================
def gs():
global a #局部变量
a = 10
print(a)
def gs2():
print(a)
gs()
gs2()
return返回值
（1）定义：python中，用 def 语句创建函数时，可以用 return 语句指定应该返回的值，
该返回值可以是任意类型
（2）return 语句的语法格式如下：
return [返回值]
（3）返回值参数可以指定，也可以省略不写（将返回空值 None）
（4）返回值的作用：
1、在程序开发中，有时候会希望一个函数执行程序结束后，告诉调用者一个结果，以便调用者针对具体的结果做后续的处理。
2、返回值是函数完成工作后，最后给到调用者的一个结果。
3、在函数中使用return关键字可以返回结果。
4、调用函数的一方可以使用变量来接收函数的返回结果。
案例：
def gs():
global a #局部变量
a = 10
return a #在函数中使用return关键字可以返回结果。
# print(a) #return后面的代码都不执行
def gs2():
sum=gs() #调用函数的一方可以使用变量来接收函数的返回结果。
m=100
c=sum+m
print(c)
gs2()
作业:
需求：登录银行系统并显示余额，有两个功能第一个是登录，第二个是登录
后显示余额，先登录然后根据登录是否成功然后是否显示余额。
分析思路：如果想查询到余额，前提必须登录，所以现在我们用两个函数来
处理，第一个函数实现登录，第二个函数实现余额查询，调用第一个函数得
到的结果给第二个函数，然后第二个函数根据结果进行代码处理。
案例：
def x():
user=input("用户名：")
if user=='aa' :
passwd=input("密码：")
if passwd=="123456":
return "登录成功"
else:
print("密码错误")
else:
print("用户名错误")
def y():
f=x()
if f=="登录成功":
print("1 个亿")
y()
===============================================
内置函数
python自带的函数
===============================================
1、format()函数是一种格式化字符串的函数 ，该函数增强了字符串格式化的功能。
基本语法：是通过 {} 来代替以前的 %
场景1、不设置指定位置，按默认顺序
a="{}{}".format("hello","duoceshi")
print(a)
场景2、设置指定索引位置输出
a="{1}{0}".format("hello","duoceshi")
print(a) #duoceshihello
场景3：
a='姓名：{name},年龄：{age}'.format(name="duoceshi",age=18)
print(a) #姓名：duoceshi,年龄：18
场景4：对列表进行格式化
大括号里面的0代表的是列表、中括号里面的0和1是列表元素对应的索引位
a=['多测师','www.duoceshi.com']
b=[1,2,3]
c="网站名:{0[0]}, 地址 {0[1]}".format(a,b)
d="网站名:{1[0]}, 地址 {0[1]}".format(a,b)
print(c)
print(d)
5、对字典进行格式化 "**"表示可变长字典
a={"name":"多测师","url":"www.duoceshi.com"}
b="网站名:{name}, 地址:{url}".format(**a)
print(b)
===============================================
zip()函数
（1）zip() 函数用于将可迭代的对象作为参数，将对象中对应的元素打包成
一个个元组，然后返回由这些元组组成的列表，如果各个迭代器的元素个
数不一致，则返回列表长度与最短的对象相同。
（2）案例：
x=["a","b","c"]
y=["1","2","3","4"]
s=zip(x,y)
# print(type(s)) #<class 'zip'>
# print(list(s))
m=dict(s)
print(m)
===============================================
open()函数
（1）open() 函数用于打开一个文件，创建一个 file 对象
（2）语法:open(file, mode),模式有r(只读),w(写入覆盖),a(写入追加)
（3）读取路径：
第一种方法：加r
第二种方法：双斜杠
（4）如果中文路径，在路径后加上
encoding='utf-8'
（5）打开文件后要用，close关闭文件，释放资源
o.close() #关闭文件
复制路径：
1、读的模式： r(只读)
a=o.read() #读取文件中所有内容返回字符串
b=o.readline() #读取文件中第一行内容
c=o.readlines() #读取文件中所有内容返回列表
案例：
f=open(r"C:\Users\Administrator\PycharmProjects\gs2\gsml\gsbao\aa.py"，'r')
print(f.read())
print(f.readline())
print(f.readlines())
2.写的模式：w(写入覆盖)
o.write(）
o.writelines
案例1：
f=open(r"C:\Users\Administrator\PycharmProjects\gs2\gsml\gsbao\aa.py",'w',encoding='utf-8')
f.write('123')
f.close()
3、
3、追加的模式：a(写入追加)
f=open(r"C:\Users\Administrator\PycharmProjects\gs2\gsml\gsbao\aa.py",'a',encoding='utf-8')
f.write('abc')
f.close()
4、open读取本地内容
wj=r"D:\f\sj.txt"
f=open(wj,'r')
print(f.read())
=================
with open
（1）用with语句的好处，就是到大语句末尾时，会自动关闭文件，以便出现异常
案例：
wj=r"D:\f\sj.txt"
with open(wj,'r') as f:
print(f.read())
=================
拓展知识：
（1）len函数
定义：返回一个内容的长度
语法：len（内容）
字符串，列表，字典，元组等
案例1:
a='abc'
print(len(a))
（2）abs函数
案例：
s=-1
print(abs(s)) #1
（3）max函数
定义：返回一个内容的最大值
a=[1,2,3,5]
（4）min函数
定义：返回一个内容的最最小值
a=[1,2,3,5]
print(min(a))
print(min(a))
（5）sum 函数
a=[1,2,3,5]
print(sum(a))
（6）id函数
定义：内存对象地址
案例：
s=-1
a=[1,2,3,5]
print(id(a)) 2332459950728
print(id(s)) 140703619572304
（7）long函数在python3中已经删除
===========================================
深浅拷贝：
浅拷贝是将原始对象中的数据型字段拷贝到新对象中去，将引用型字段的“引用”复制到新对象中去，不把“引用的对象”复制进去，所以原始对象和新对象引用同一对象，新对象中的引用型字段发生变化会导致原始对象中的对应字段也发生变化。
深拷贝是在引用方面不同，深拷贝就是创建一个新的和原始字段的内容相同的字段，是两个一样大的数据段，所以两者的引用是不同的，之后的新对象中的引用型字段发生改变，不会引起原始对象中的字段发生改变。
s=-1
a=[1,2,3,5]
b=a
c=a.copy()
# b.remove(2)
c.remove(3)
print(id(a))
# print(id(b))
print(id(c))
print(c)
print(a)
print(b)
===========================================
