模块化编程
定义：把程序进行封装
- 函数封装
- 面向对象
- 面向文件
函数：封装完不会执行，调用来使用。
函数是什么：一个具有特定功能的代码块
函数的作用：封装代码，提高代码的重用性；提高开发效率；降低后期维护成本。
函数的定义：
def func([参数列表])： 当前函数的具体功能代码 当前函数的具体功能代码 。。。函数的调用：
func( )
函数的特征：
1，先定义再调用
2，不调用不执行
3，调用次数不限
4，命名遵守命名规范：字母，数字，下划线；不能以数字开头；严格区分大小写；不使用关键字，中文；有意义。
5，函数名不能重复，否则会覆盖
函数的参数：
1)实参：普通实参在前，关键字参数在后
2)形参：关键字收集参数一定在最后；收集参数推荐在普通参数的后面
3)推荐顺序：普通 形参，收集参数，关键字收集参数
定义函数时：可以在参数列表的位置定义行参
如果函数有行参，在调用时必须传递参数（实参）
实参传递给行参的过程，本质上就是变量的赋值操作
a普通参数：
#定义带有参数的函数 #在小括号内可以定义行参（形式上的参数） def func1(w): print(f'hello{w}') #调用得带参数，不然报错 func1('kris')#调用带有行参的函数时，需要传递参数（实参） func1()#TyprError func1(w='kris')#调用时可以指定 #函数里带有多个参数的 def func2(x,y): print(f'hello: {x},hi: {y}') #调用普通函数 #方法一：定义了几个参数，调用时必须按顺序进行参数传递 func2('kris','sehun')#本质上x='kris',y='sehun' #方法二：可以把普通参数按照关键字参数进行传递 func2(y='sehun',x='kris')b默认参数：含有默认值的
c收集参数：在形参的位置加一个默认星号* args
d命名关键字参数：定义在在*args后面，调用的时候必须以形参的名字调用
def func3(a,b,c=3,*args,name): #name就是命名关键字参数，调用的时候必须给定name的值 print(a,b,c)#a,b形参，c默认参数， print(*args)#收集参数 print(name)#命名关键字参数 func3(1,2,4,5,6,7,8,9,name='sehun') #1 2 4 #(5,6,7,8,9) #sehun func3(1,2,name='sehun') #1 2 3 c默认参数，没有就默认为3 #sehun func3(1,2,5，name='sehun') #1 2 5 c默认参数，有就默认为5 #sehune关键字参数收集：**kwargs
# Tips:注意行参声明的位置： #func4(普通参数，默认参数，收集参数，关键字参数，关键字收集参数)——极少出现 #一般情况：普通参数，收集参数，关键字收集参数 def func4(a,b,c=3,*args,name,age,**kwargs): print(a,b,c) print(args)#普通收集参数，把多余参数收集成——元祖 print(name,age) print(kwargs)#关键字收集参数，把多余关键字收集成——字典 func4(1,2,5,112,114,name='sehun',age=26,gender='男',height=184) #1 2 5 #(112, 114) #sehun 26 #{'gender': '男', 'height': 184}
函数返回值：按照需要返回一些内容，可返或可不返
使用return关键字来指定返回数据
可以返回任意类型的数据
会把数据返回到调用处，可以使用变量结束或其他处理
return——意味着函数的结束，return之后的代码不再执行
#没有返回值的函数 or 没有指定返回内容，默认返回None def func5(a,b): print(f'{a} lalla {b}') func5('kris','sehun') #需要在函数中指定返回内容，可以在函数体内用关键字return返回任意内容 def func5(a,b): res = f'{a} lalla {b}' return res func5('kris','sehun')#无结果：定义一个字符串 #改进： print(func5('kris','sehun'))#这里调用，这里输出
函数的分类：
1，执行过程函数：函数体内完成一定的功能即可，没有返回值。
2，具有返回值的函数：函数体内完成一定的功能，并且返回一个结果到函数调用处。
#需求1:定义一个函数，完成两个数相加，并把结果输出
def jia(n1,n2):
res = n1 + n2
print(res)
jia(3,5)
#需求2:定义一个函数，完成两个结果的运算，并把结果返回
def jia(n1,n2):
re = n1 + n2
return re #把运算的结果返回
r = jia(n1,n2)
print(r)
变量的作用域：当前起作用，可用的范围区域。
即变量的有效范围
分：
全局变量：1）在函数内使用global定义的，函数内外都可以使用
2）在函数外定义的变量，在函数内使用global关键字进行声明
globals()—— 在任何位置都获取全局数据
局部变量：1）在函数内定义，在函数外不可以使用；
locals()—— 获取当前作用域的数据
- 函数外定义的变量，函数可以访问，但不能更改
num = 10 def func6(): print(num)#10# 在函数内部可以直接获取函数外部的变量 func6()num = 10 #可获取但不可改变 def func6(): num += 20#但是不可以更改或者使用函数外部的变量 print(num)#报错# 在函数内部可以直接获取函数外部的变量 func6()def func6(): a = 20#函数内定义的变量 a += 20 func6() print(a)#报错#在函数外不可以使用def func6(): a = 20#函数内定义的变量 a += 20 print(a)#在函数内可以使用 func6()#40数据类型的分类：
可变数据类型：在函数外定义的变量，在函数内可以使用
list ，dict
不可变数据类型：在函数外定义的变量，在函数内只能访问，不能使用其他操作
__name__:__main__
#__name__表示当前脚本的名字；如果当前脚本作为主程序，那么值是__main__；如果当作一个模块，在另外一个脚本中引用去使用
#__main__表示指定当前脚本运行
__doc__#表示当前脚本的文档说明'''注释'''
不光变量有作用域，函数一样也有相同的作用域
def outer():
'''
文档说明
'''
print('outer function')
def inner():#局部函数，在函数外无法使用
print('inner function')
outer()#outer function
inner()#报错
print(outer.__doc__)
改进：
def outer():
print('outer function')
def inner():#局部函数，在函数外无法使用
print('inner function')
inner()#inner function
outer()#outer function
区分：
def outer():
print('outer function')
abc = 123#外部普通全局变量
def inner():#局部函数，在函数外无法使用
print('inner function')
abc += 1#内部改变
print(abc)#报错
inner()#inner function
outer()#outer function
def outer():
print('outer function')
abc = 123#外部普通全局变量
def inner():#局部函数，在函数外无法使用
print('inner function')
print(abc)#123
inner()#inner function
outer()#outer function
nonlocal关键字——用于在内函数中使用外层函数的变量
def outer(): print('outer function') abc = 123#外部普通全局变量 def inner():#局部函数，在函数外无法使用 print('inner function') nonlocal abc#可以引用上一层函数中定义的局部变量，但依然不能提升为全局变量 abc += 1#内部改变 print(abc)#124 inner()#inner function outer()#outer function
函数的封装
#定义函数，打印九九乘法表
def jiujiu(n=0):
'''
当前函数的功能就是 打印 九九乘法表
n=0; 控制 正向输出 和 反向输出 九九乘法表 ，0为正向 默认，1为反向
'''
if n == 0:
rs = range(1,10)
else:
rs = range(9,0,-1)
for x in rs:
for y in range(1,x+1):
print(f'{x}x{y}={x*y}',end=" ")
print()
jiujiu(1)
# 封装打印矩形的函数 juxing(x=10,y=10)
def juxing(n,x,y):
for i in range(x):
for j in range(y):
if n ==1:
if i == 0 or i == x-1 or j == 0 or j == y-1:
print('*',end = ' ')
else:
print(' ',end = ' ')
else:
print('*',end = ' ')
print()
一：递归函数
1.定义一个函数，在函数内自己调用自己
例题：斐波那契数列：1，1，2，3，5，8，21，，，，
实现一个阶乘：1 * 2 * 3 * 4* 5
#实现一个递归：3，2，1，0
def func1(n):
print(n)
#检测当前的值是否到0
if n > 0:
func1(n-1)#调用自己
func1(3)
2.递归函数内必须要有结束，不然就会一直调用下去，直到调用的层数越来越多，栈溢出
3.递归函数是一层一层的进入，再一层一层的返回
#实现斐波那契数列
def func1(n):
if n == 1 or n == 2:
return 1
else:
#print(n-1,n-2)
return func1(n-1) + func1(n-2)
#实现阶乘
def func2(n):
if n == 1:
return 1
else:
return n * func2(n-1)
4.递归函数的效率不高，尽量不要用
5.一个函数如果调用后没有结束，那么在栈空间就一直存在，知道这个函数运算结束在销毁。
二：回调函数—把一个函数作为行参
定义：在一个函数中 要求传递的参数是一个函数作为参数，并且在函数中使用了传递进来的函数
#带有回调参数的函数
def func3(f):
#print(f,type(f))
#在函数中调用了传递进来的函数
f()
#回调函数
def func4():
print('exo')
func3(func4)#exo
def func5(x,y,f):
'''
当这个函数接受两个数值，并把两个数值传递给第三个参数进行计算
x,y,int
f function
return
'''
print(f(x,y))
def func5(x,y,pow):
print(pow(x,y))
func5(2,3,pow)
#都要求传递一个函数进去
map(),sorted(),filter(),reduce()
三：闭包函数—在一个函数中返回一个函数
定义：在一个函数内返回一个内函数，并且这个返回的内函数还使用了外函数中的局部变量
def person():
money = 0#在外函数中定义了局部变量，并且在内部函数中使用了这个局部变量
#工作：在外函数中定义的内函数
def work():
nonlocal money#在内函数中使用了外函数的临时变量
money += 100
print(money)
#加班
def overtime():
nonlocal money
money += 200
#购物
def buy():
nonlocal money
money -= 50
#在外函数中返回内函数，这个内函数就是闭包函数
return work
res = person()#接收一下,res = work
res()#res() == work()
#检测一个函数是否为闭包函数
print(res.__closure__)#(<cell at 0x11083bf48: int object at 0x10b94b790>,)
#此时不能在全局中对money 这个局部变量进行任何操作
闭包的作用：
保护了函数中的变量不受外部的影响，但是又能够不影响使用
闭包的特点：
1，在外函数中定义了局部变量，并且在内部函数中使用了这个局部变量
2，在外函数中返回了内函数，返回的内函数就是闭包函数
3，主要在于保护了外函数中的局部变量，既可以被使用，又不会被破坏
如何检测一个函数是否为闭包函数
函数名.closure 如果是闭包函数返回 cell
四：匿名函数 lambda 表达式：称为一行代码函数
定义：可以不使用def定义，并且这个函数也没有名字
在python中可以使用lambda表达式来定义匿名函数
Tips：
lambda仅仅是一个表达式，即一行代码；不是一个代码块；
lambda表达式也有行参，并且不能访问除了自己行参之外的任何数据包括全局变量
#lambda [参数列表]:返回值
res = lambda x,y:x+y#拿一个变量接受
print(res(2,3))
lambda是一个表达式，因为不能写太复杂的逻辑，功能相对单一
lambda可以使用分支结构
#带有分支结构
#lambda参数列表：真区间 if 表达式判断 else 假区间
res = lambda sex:'man' if sex == '男' else 'woman'
print(res('女'))
五：迭代器
特点
是python中最具特色的功能之一；
是访问集合元素的一种方式；
是一个可以记住访问遍历的位置的对象；
从集合的第一个元素开始访问，知道集合中的所有元素被访问完毕；
只能从前往后一个一个遍历，不能后退；
能被next()函数调用，并不断返回下一个值的对象 称为迭代器（iterator迭代对象）
# 定义一个列表，是一个可迭代的对象
f4 = ['赵','刘','小','海']
#提取数据出来
#可迭代对象：可以用for循环
# 可以使用for循环来遍历数据
for i in f4:
print(i)
# 可以把可迭代对象转为迭代器使用
res = iter(f4)
print(res,type(res)) # <list_iterator object at 0x109063810> <class 'list_iterator'>
iter()
功能：把可迭代的对象，转为一个迭代器对象
参数：可迭代的对象 （str，list，tuple，dict，set，range。。。）
return： 迭代器对象
Tips ：迭代器一定是一个可以迭代的对象，但是可迭代对象不一定是迭代器
迭代器取值的方案
next() 调用一次获取一次，直到数据被取完
list() 使用list函数直接取出迭代器中的所有数据
使用for循环遍历迭代器的数据
迭代器取值的特点：取出一个少一个，直到都取完，最后再获取就会报错
#1.使用next()函数去调用迭代器对象
print(next(res))
#print(next(res))
#2.使用list取值
r = list(res)
print(r)
#3.使用for循环
for i in res:
print(i)
# print(next(res)) #当调用次数用完，超出可迭代的范围，报错；StopIteration
检测迭代器和可迭代对象的方法
from collections.abc import Iterator,Iterable
str1 = '123456'
res = iter(str1)
# 1 type() 函数返回当前数据的类型，
# 2 isinstance() 检测一个数据是不是一个指定的类型
r1 = isinstance(str1,Iterable) # True 可迭代对象
r2 = isinstance(str1,Iterator) # False 不是一个迭代器
r3 = isinstance(res,Iterable) # True 可迭代对象
r4 = isinstance(res,Iterator) # True 是一个迭代器
print(r1,r2)
print(r3,r4)
# 迭代器一定是一个可迭代的对象，可迭代对象不一定是迭代器
# next(varstr) # TypeError: 'str' object is not an iterator
#Iterable:检测是不是一个可迭代对象
#Iterator:检测是不是一个迭代器
内置函数:python解释器自带的
-
range()函数
1.功能：能够生成一个指定的数字序列,方便循环
2.参数：range(start, stop,[,step])
start : 开始的值 ，默认值为0
stop ： 结束的值
[, step]： 可选步进值,默认值为1
3.return： 可迭代的对象，数字序列
# 获取range函数返回的数字序列的方法
res = range(10,0,-2)#10,8,6,4,2
res = range(4,10,2)#4,6,8
res = range(6,10)#6,7,8,9
res = range(-10)#[ ]
res = range(10)#0,1,2,3,4,5,6,7,8,9
# 1.转为list列表数据
print(list(res))
# 2.通过 for循环 进行遍历
for i in res:
print(i)
# 3.转为迭代器，使用next函数调用
res = iter(res)
print(next(res))
-
zip()函数
功能：
可以接受多个可迭代的对象，然后把每个可迭代对象中的第i个元素组合在一起，形成一个新的迭代器
参数：zip(*iterables)
*iterables，任意个的 可迭代对象
return： 返回一个元组的迭代器
var1 = '1234'
var2 = ['a','b','c']
var3 = ('A','B','C','D')
# 调用zip函数，组成新的元组迭代器
res = zip(var1,var2,var3)
print(res,type(res))#<zip object at 0x10d30b848> <class 'zip'>
# 提取迭代器数据的方法， next(),list(),for i in ...
print(list(res))
[
('1', 'a', 'A'),
('2', 'b', 'B'),
('3', 'c', 'C'),
]
for i in res:
print(i)
('1', 'a', 'A')
('2', 'b', 'B')
('3', 'c', 'C')
v1 = [1,2,3,4]
v2 = [22,33,44,55]
res = zip(v1,v2)
print(list(res))
[
(1, 22),
(2, 33),
(3, 44),
(4, 55)
]
- #### zip() 与 * 运算符相结合可以用来拆解一个列表:
x = [1, 2, 3]
y = [4, 5, 6]
zipped = zip(x, y)
print(list(zipped))#[(1, 4), (2, 5), (3, 6)]
print(zipped) # 迭代器对象
# 组合好的多个元组数据
print(*zip(x, y))#(1,4)(2,5)(3,6)
x2, y2 = zip(*zip(x, y))
print(x2,y2)# (1, 2, 3) (4, 5, 6)
-
数据类型相关函数
- int() 将其它类型数据转为整型
- float() 转为浮点类型
- bool() 转为布尔类型
- complex() 转为复数
- str() 转为字符串类型
- list 转为列表类型
- tuple 转为元组类型
- dict 转为字典类型
- set 转为集合类型
-
变量相关函数
- id() 获取当前数据的ID标识
- type() 获取当前数据的类型字符串
- print() 数据的打印
- input() 获取输入的数据
- isinstance() 检测是否为指定的数据类型
-
和数学相关的函数
#获取一个数的绝对值
print(abs(-99.99))
#求和——从 start 开始自左向右对 iterable 中的项求和并返回总计值
print(sum([1,2,3]))
#获取——最大值
print(max([1,2,3]))
print(max(99,12,45))
#获取——最小值
print(min([2,1,6,-9]))
print(min(6,7,1,0,-2))
#幂运算——返回 x 的 y 次幂
print(pow(2,3))#2**3=8
#四舍五入
r = round(3.1415926)#3
# 小数点保留几位
r = round(3.1415926,2) #3.14
#奇进偶退
r = round(4.5) # 1.5 = 2 2.5=2,3.5=4,4.5=4
print(r)
-
进制相关的函数和字符串
A - Z 65-90
a - z 97-122
0 - 9 48-57
Ascii 共计 128个字符，更新于 1986年 ，主要用于显示现代英语和其他西欧语言。
GB2312-80 是 1980 年制定的中国汉字编码国家标准，共收录 7445 个字符，其中汉字 6763 个。
GBK 于1995年制定 收录了 21003 个汉字，与 GB 2312 编码兼容，
GBK18030 2001年的1月正式强制执行，是我国制订的以汉字为主并包含多种我国少数民族文字（如藏、蒙古、傣、彝、朝鲜、维吾尔文等）的超大型中文编码字符集强制性标准，其中收入汉字7万余个
Unicode（统一码、万国码、单一码）是计算机科学领域里的一项业界标准，包括字符集、编码方案等。为每种语言中的每个字符设定了统一并且唯一的二进制编码，以满足跨语言、跨平台进行文本转换、处理的要求。1990年开始研发，1994年正式公布。
UTF-8以字节为单位对Unicode进行编码的一种方案。
bin() #将数值类型转为二进制
print(bin(123)) # 0b1111011
int() #将二进制转为整型
print(int(0b1111011)) #123
oct() #转为八进制数 01234567
print(oct(123)) # 0o173
hex() #转为十六进制数,用于颜色 0123456789abcdef
print(hex(123)) # 0x7b
print(int(0x7b))#123
# 将字符转为 ascii
r = ord('a')
print(r)
# 将ascii转为字符
r = chr(65)
print(r)
-
sorted( )
原理：
把可迭代数据里面的元素，一个一个的取出来，放到key这个函数中进行处理，
并按照函数中return的结果进行排序，返回一个新的列表
功能： 排序
参数：
iterable 可迭代的数据 （容器类型数据，range数据序列，迭代器）
reverse 可选，是否反转，默认为False，不反转； True反转
key 可选， 函数，可以是自定义函数，也可以是内置函数
return： 排序后的结果
arr = [3,7,1,-9,20,10]
# 默认按照从小到大的方式进行排序
res1 = sorted(arr) # [-9, 1, 3, 7, 10, 20]
print(res1)#[-9, 1, 3, 7, 10, 20]
# 可以按照从大到小的方式进行排序
res2 = sorted(arr,reverse=True) # [20, 10, 7, 3, 1, -9]
print(res2)#[20, 10, 7, 3, 1, -9]
# 使用abs这个函数(求绝对值）作为sorted的key关键字参数使用
res3 = sorted(arr,key=abs)#按照出处理结果排序
print(res3)#[1, 3, 7, -9, 10, 20]
#使用自定义函数对数据进行处理
def func(num):
#print(num,num % 2)
return num % 2
arr = [3,2,4,6,5,7,9]
# 在sorted函数中使用自定义函数对数据进行处理
res = sorted(arr,key=func)
print(res)
# 优化版
arr = [3,2,4,6,5,7,9]
res = sorted(arr,key=lambda x:x%2)
print(res)
-
map( )
map(func, *iterables)
功能：
对传入的可迭代数据中的每个元素放入到函数中进行处理，返回一个新的迭代器
参数：
func 函数 自定义函数|内置函数
iterables：可迭代的数据
return：迭代器
#1.字符串数字的列表转为整型的数字列表
#['1','2','3','4'] 转为 [1, 2, 3, 4]
#普通方法
varlist = ['1','2','3','4']
newlist = []
for i in varlist:
newlist.append(int(i))
print(newlist)
# 使用map函数处理这个数据
varlist = ['1','2','3','4']
res = map(int,varlist)
print(list(res))
#2.[1, 2, 3, 4] 转为 [1, 4, 9, 16]
#普通方法
varlist = [1,2,3,4]
newlist = []
for i in varlist:
j = i ** 2
newlist.append(j)
print(newlist)
# 使用map函数处理这个数据
varlist = [1,2,3,4]
def func(x):
return x **2
res = map(func,varlist)
print(list(res))
#优化版
res = map(lambda x:x**2,varlist)
print(list(res))
#3.['a','b','c','d'] 转为 [65,66,67,68]
list1 = ['a','b','c','d']
res = map(lambda x:ord(x.upper()),list1)
print(list(res))
-
reduce( )
需要导入 from functools import reduce
reduce(func,*iterable)
功能：
每一次从 iterable 拿出两个元素，放入到func函数中进行处理，得出一个计算结果，
然后把这个计算结果和iterable中的第三个元素，放入到func函数中继续运算，
得出的结果和之后的第四个元素，加入到func函数中进行处理，以此类推，直到最后的元素都参与了运算
参数：
func： 内置函数或自定义函数
iterable： 可迭代的数据(逻辑类型，range类型，可迭代对象)
return：最终的运算处理结果
from functools import reduce
# 1. [5,2,1,1] 转为 5211
#方法一：普通方法
varlist = [5,2,1,1]
res = ''
for i in varlist:
res += str(i)
res = int(res)
print(res,type(res))
#方法二
'''
5 2 1 1
5 * 10 + 2 == 52
52 * 10 + 1 == 521
521 * 10 + 1 == 5211
'''
def myfunc(x,y):
return x*10+y
varlist = [5,2,1,1]
# 调用函数
res = reduce(myfunc,varlist)
print(res,type(res))
#2.字符串 '456' 转为 int的 456
# 不能使用int方法进行类型的转换时，如何解决上面的问题？
# 定义函数，给定一个字符串的数字，返回一个整型的数字
def myfunc(s):
vardict = {'0':0,'1':1,'2':2,'3':3,'4':4,'5':5,'6':6,'7':7,'8':8,'9':9}
return vardict[s]
print(myfunc('4'))#4
print(myfunc('5'))#5
print(myfunc('6'))#6
# 1.先使用 map函数，把数字字符串，转为整型的数字
iter1 = map(myfunc,'456')
# 调用一下：print(list(iter1))#[4,5,6]
# 2. 把数字列表中的值，使用lambda进行二次处理
iter2 = reduce(lambda x,y:x*10+y,iter1)
print(iter2)#456
-
filter( )—过滤器
filter(func,iterable)
功能： 过滤数据，把 iterable 中的每个元素拿到 func 函数中进行处理，
如果函数返回True则保留这个数据，返回False则丢弃这个数据
参数：
func 自定义函数
itereble： 可迭代的数据
return：保留下来的数据组成的 迭代器
varlist = [1,2,3,4,5,6,7,8,9]
# 保留所有的偶数，丢弃所有的奇数
#普通方法
newlist = []
for i in varlist:
if i % 2 == 0:
newlist.append(i)
print(newlist)
# 使用 filter 进行处理
#定义一个函数，判断当前这个函数是否为偶数，偶数返回True，奇数返回False
def myfunc(n):
if n % 2 == 0:
return True
else:
return False
# 调用 过滤器 函数进行处理
it = filter(myfunc,varlist)
print(it,list(it))#<filter object at 0x10d2c1400> [2, 4, 6, 8]
# 优化版
it = filter(lambda n:True if n % 2 == 0 else False,varlist)
print(it,list(it))
