多测师拱墅校区肖sir_高级金牌讲师_python之函数

python之函数

======================
一、函数的介绍
（1）定义：函数是组织好的，可重复使用的，用实现单一或相关联功能的代码段。
（2）python中的结构:

(3)函数的特点：
1.降低代码冗余
2、增加代码的复用性，提高开发效率
3.提高程序拓展性
4、函数有两个阶段：定义阶段，调用阶段
定义时：只检查函数体内代码语法，不执行函数体内代码
调用阶段：调用方便
5、封装：就是把代码片段放在函数当中

======================
二、函数的使用
（一）函数类型
a、自定义函数
b、内置函数
1、自定义函数：
自定义函数：自己根据业务需求自己封装的函数
2、如何定义一个函数（自定义函数）
使用def关键字来创建pyhton自定义函数
基本格式：
def 函数名 （参数列表）
函数体

函数名（） 调用函数

案例：
def gs():
print(‘我是一个函数’)
print(‘我是二个函数’)
print(‘我是三个函数’)
gs() #调用函数
备注：def 函数名（） ： 英文的括号
tab键 就是空格4格 函数体

函数名（） #调用函数

3、调用函数有三种类型:
(1)直接调用
a.函数名 （）

（2）利用main方法调用 if name == ‘main’:
主函数：
解释： if name == ‘main’: 是函数的入口，也称为主函数 name 是当前模块名，当模块被直接运行时模块名为 main ，这句话的 意思就是，当模块被直接运行时，以下代码块将被运行，当模块是被导入时， 代码块不被运行。
main函数和其他模块函数调用
案例：

（3）跨模块调用
案例：
aa文件

bb文件

===========================
三、函数中的参数

（1）函数无参数
案例：
def gs():
print(‘我是一个函数’)
def yh():
print(‘我是二个函数’)
def xh():
print(‘我是三个函数’)
gs()
（2）函数中有单个参数
案例：
def gs(name):
print(“我是”+name+‘来自叙利亚,扛着ak47’)
gs(“大哥”)
（3）函数中有多个参数
def gs(name,z):
print(“我是”+name+‘来自叙利亚,扛着ak47’+‘坐着’+z)
gs(“大哥”,‘拖拉机’)

（4）函数定义时带上默认参数（缺省参数）
案例：
def gs(name,z=“直升机”):
print(“我是”+name+‘来自叙利亚,扛着ak47’+‘坐着’+z)
gs(“大哥”)

（5）可变长元组
a.单独使用可变长元组
def gs(*name):
print(“我是”+str(name))
gs(‘大哥’,“二哥”,“三弟”)

b.可变长元组和普通参数同时使用
def gs(z,*name):
print(“我是”+str(name)+z+‘上北京’)
gs(‘拖拉机’,‘大哥’,“二哥”,“三弟”)

(5) 可变长字典 **
a.单独传入字典
def gs(**name):
print(“我是”+str(name)+‘上北京’)
gs(name=‘zs’,age=18,sex=‘男’)
b.可变长元组和可变长字典同时传参
def gs(*s,**name):
print(str(s)+“我是+”+str(name)+‘上北京’)
gs(1,2,3,name=‘zs’,age=18,sex=‘男’)

c、普通参数，可变长元组，可变长字典同时传参
def gs(c,*s,**name):
print(c+str(s)+“我是+”+str(name)+‘上北京’)
gs(‘cc’,1,2,3,name=‘zs’,age=18,sex=‘男’)

=============================================
四、函数的变量和作用域
(1)全局变量：函数的变量和作用域
(2)局部变量：在函数中可以定义变量，在函数中定义的变量被称之为局部变量，变量只在定义它的函数内部有效
案例1:
z=100 #全局变量
def s():
z=50 #局部变量
print(z)
def c():
print(z)
s()
c()
(3) global 将局部变量设置成全局变量，
global全局变量优先级要高于直接定义的全局变量
案例：
z=100 #全局变量
def s():
global z #通glibal 设置成全局变量
z=50 #局部变量
print(z)
def c():
print(z)
s()
c()

=================================
函数的返回值 return
（1）定义
Python中，用 def 语句创建函数时，可以用 return 语句指定应该返回的值， 该返回值可以是任意类型。需要注意的是，return 语句在同一函数中可以出 现多次，但只要有一个得到执行，就会直接结束函数的执行。 函数中，使用 return 语句的语法格式如下： return [返回值] 其中，返回值参数可以指定，也可以省略不写（将返回空值 None）。
（2）返回值的作用
1、在程序开发中，有时候会希望一个函数执行程序结束后，告诉 调用者一个结果，以便调用者针对具体的结果做后续的处理。
2、返回值是函数完成工作后，最后给到调用者的一个结果。
3、在函数中使用return关键字可以返回结果。
4、调用函数的一方可以使用变量来接收函数的返回结果

案例1：return 返回值，接收返回值
def s():
global z
z=50/5 #局部变量
return z
def c():
sum=s()
k=sum/2
print(k)
c()

案例2： 讲解retuen后的语句不执行

def s():
global z
z=50/5 #局部变量
return z
z=*2
def c():
sum=s()
k=sum/2
print(k)
c()

返回值实战练习
需求：登录银行系统并显示余额，
有两个功能第一个是登录，
第二个是登录 后显示余额，
先登录然后根据登录是否成功然后是否显示余额。
分析思路：如果想查询到余额，前提必须登录，所以现在我们用两个函数来 处理，第一个函数实现登录，第二个函数实现余额查询，调用第一个函数得 到的结果给第二个函数，然后第二个函数根据结果进行代码处理。

案例：

def denglu(user,password):
global a
a=0
if user ==‘admin’ and password == 123456:
a=1
print(‘登录成功’)
else:
print(‘登录失败’)
return a
def yue():
if a == 1:
print(‘余额为：100000000’)
if name == ‘main’:
a=str(input(‘请输入账号’))
b=int(input(‘请输入密码’))
denglu(a,b)
yue()
案例2：

def x():
a=input(‘银行账号’)
if a==‘nzw’:
b=input(‘密码’)
if b==‘123456’:
return ‘登录成功’

x()

def y():
c=x()
if c==‘登录成功’:
print(‘余额:10000’)
else:
print(‘登录失败’)
y()

案例3：

======================================
python内置函数：

1、format函数：
（1）定义format()函数是一种格式化字符串的函数 ，该函数增强了字符串格式化的功能。
（2）基本语法：是通过 {} 来代替以前的 %
（3）案例：
a、不设置指定位置，按默认顺序
案例1
h=‘{}’.format(‘gsdcs’,‘bjdcs’)
print(h)
z=‘{}{}’.format(‘gsdcs’,‘bjdcs’)
print(z)

b、设置指定索引位置输出 不足：索引从0开始
案例：
z=‘{1}+{0}’.format(‘gsdcs’,‘bjdcs’)
print(z)

c、设置参数输出
案例
h=‘{name}，{name1}’.format(name=‘gsdcs’,name1=‘bjdcs’)
print(h)

d、对列表进行格式化
(1)
list=[‘hz’,‘dcs’]
list1=[1,2]
print(‘地点:{0[0]},校区:{0[1]}’.format(list)) 第一个表示的是表的索引， 第二个0表示的是索引中的0,1
(2)
list=[‘hz’,‘dcs’]
list1=[1,2]
list2=[3,4]
print(‘地点:{0[0]},校区:{0[0]}’.format(list)) #0表
print(‘地点:{0[0]},校区:{1[0]}’.format(list,list1)) #表0，表1
print(‘地点:{0[0]},校区:{2[1]}’.format(list,list1,list2)) #表0，表1，表2

e、对字典进行格式化
案例：
s={‘gs’:‘hz’,‘mc’:‘dcs’}
c=(‘城市：{gs},名称:{mc}’.format(**s))
print©

========================================================================
zip()函数
1、zip() 函数用于将可迭代的对象作为参数，将对象中对应的元素打包成 一个个元组，然后返回由这些元组组成的列表，如果各个迭代器的元素个 数不一致，则返回列表长度与最短的对象相同。
2、实例讲解
案例1：m=[1,2,3,4]
n=[1,2]
v=zip(m,n)
print(list(v))
print(type(v))
案例2：解压

========================================================================
open函数

（1）open函数用于打开一个文件创建一个file对象
（2）语法： open（file ，摸得）
（3）r （读） w （写入） a （追加）
（4）r+ （读写文件） ，w+ (读写文件),a+ 追加）
(5)注意点：
a、路径：r 开头
b、路径：加上双反斜杠
c.路径：单斜杠
案例：

查看函数用法：

（6）读取文件内容三种方法：
1、read()) #读取文件中所有的内容
2、readline())#读取文件中第一行
3、readlines() #读取文件中所有的内容，返回的结果是列表格式

path=r’C:\Users\Administrator\PycharmProjects\gs1\bao\bb.py’
f=open(path,‘r’,encoding=‘utf-8’)
#print(f.read()) #读取文件中所有的内容
print(f.readline())#读取文件中第一行
print(f.readlines()) ##读取文件中所有的内容，返回的结果是列表格式

（7）读取本地文件
lj=r"E:\ls\aa.txt"
f=open(lj,‘r’)
print(f.read())

=========================================
写：w模式
（1） （写入覆盖）
lj=“E:/ls/aa.txt”
f=open(lj,‘w’)
f.write(‘jjjjj’)
f.close()

=========================================
（2）追加 a
lj=“E:/ls/aa.txt”
f=open(lj,‘a’)
f.write(‘kkkkk’)
f.close()

=========================================
with open
（1）用with语句的好处，就是到达语句末尾时，会自动关闭文件，即便出现异常。
（2）案例：
lj=“E:/ls/aa.txt”
with open(lj,“r”) as f:
a=f.read()
print(a)
========================================
拓展知识
（1）long函数; 在python3中已经删除
l（2）en函数：
返回一个内容的长度
语法：len(内容)
内筒：字符串，列表，字典，元组扥等
a、计算字符串
s=‘abcdefg’
print(len(s)) #7
b、计算列表
c=[1,2,3,4]
print(len©) #4
c.计算字典
d={‘name’:‘zs’,‘age’:‘10’}
print(len(d)) #2
d、计算元组
e=(1,2,3,4,5)
print(len(e))

（3）abs函数:
a=-1
print(abs(a)) #1

（4）sum函数
print(sum(range(1,101))) #5050
（5）max函数
e=(6,1,2,3,4,5)
print(max(e)) #6
（6）min函数
e=(6,1,2,3,4,5)
print(min(e)) #1

（7）id函数
a=1
b=2
print(id(a)) #140704141435536
print(id(b))#140704141435568

深浅拷贝

浅拷贝：数据共享（复制其数据独立内存存放，但是只拷贝成功第一层）
a=[1,2,3]
b=a
b.append(‘s’)
print(a)
print(b)
print(id(a))
print(id(b))
深拷贝：数据完全不共享（复制其数据完完全全放独立的一个内存，完全拷贝，数据不共享）
a=[1,2,3]
b=a.copy()
b.append(‘s’)
print(a)
print(b)
print(id(a))
print(id(b))

============================