函数
""""""
"""
函数——等价于小封装
将一段公式/逻辑 定义在一个特定名称的代码块里面
如： S=3.14 * r(平方) 计算圆的面积 R(参数)
就相当于 我们可以把公式先写出来，然后需要调用（使用）这个公式的人来进行参数的传递，从而完成整个逻辑/公式的运行和计算
定义函数：def 函数名 ([])
——调用方式，直接写上函数名 + 具体的参数就能直接调用
"""
def aa(str): #定义函数
print(str) #函数的代码块，执行逻辑
# 以上就是一个简单的函数
aa("新年好") #调用函数
#升级
def add(m,n):
print(m+n) #=====>6
add(3,3) #调用 传入参数
"""
某些函数执行时，需要将计算/逻辑执行的结果传递出来（返回出来）
这个时候，可以用关键字 return 来返回结果
一旦有return关键字返回结果时，调用函数的地方，需要有变量来获取返回的结果，这样就能直接使用
函数内的变量 有对应的作用域
函数内定义的变量 不能与函数外进行传递
同意，也不能与其他函数进行传递
不是同名函数就可以直接共有值
reture:关键字
特性：1、可以把值传递出来
2、赋值给外部定义的变量
3、return 标志一段代码的结束，如果在函数内，表示函数执行完毕
4、不管在任何情况下，我们遇到return 就代表运行结束
"""
s=0
def add(m,l):
s= m+l
return s
add(1,2)
print(s)
#升级：4、不管在任何情况下，我们遇到return 就代表运行结束
def aaa():
s=0
while s<3:
print("执行111")
s+=1
return 3 #reture 已经结束了运行，所以只打印了一遍 执行111
# break # 只是结束当前循环，后续代码会继续执行
# print("代码才结束，打印")
aaa()
""""""
"""
如果函数没有rreturn 或者return湖没有值，返回则为None
"""
def aaa1():
s=0 #遍历我们的列表，找到s这个字符
#满足条件1 直接结束程序 if username==0 return
# 满足添加2 需要遍历列表 elif username =xx while
while s<3:
print("执行111")
s+=1
return 3
print("循环结束")
aaa1()
"""
函数的参数：
定义函数的时候，可以有参数，也可以没有参数，也可以有默认参数
"""
def bbb():
print("你好呀")
bbb()
"""
有参数的函数：默认参数
"""
def cc (a=0,b=8): #这里相当于默认给了a b一个值
return a+b
print(cc())
"""
有参数 且不是默认参数的
参数的形式有三种情况
1、位置参数，传递的参数是根据你调用的位置来一一对应
2、指定参数，写参数名=值，顺序可以任意输入
3、指定+位置 也可以用 但是第一个参数一点要对应好
4、不定长参数—— * 和 **表示
*aa 传入一个元祖
**aa 传入一个字典
"""
#-----位置参数的示例------
def add(m,n,k):
print("传人的参数m是{}".format(m))
print("传入的参数n是{}".format(n))
print("传入的参数k是{}".format(k))
# add(1,2,3) #默认指定参数
add(1,k=2,n=3)
def funl(*args):#*表示变量有多个元素
print(args) #====>(1, 2, 3, 4)
print(type(args)) #====><class 'tuple'>
print(args[0]) #====>1
funl(1,2,3,4)
def fun2(**aa):
print(aa) #====>{'name': 'liaoxinyi', 'age': '18'}
print(type(aa)) #====><class 'dict'>
print(aa["name"]) #===>liaoxinyi
fun2(name="liaoxinyi",age="18")
""""""
"""
函数的注释——和普通的注释有点区别，
：param 表示要传入的参数，我们可以描述这个参数是什么？
name : 用户姓名
：return 关键字表示返回结果是什么
返回的是xx公式的计算结果 ， 返回的是xx对象
"""
def fun1(name,age):
"""
函数中注释：'''敲回车'''
:param name: 要求输入用户姓名
:param age: 要求输入用户年龄
:return: 返回检验的结果
"""
if name =="小明" and age>18:
return "刷个"
else:
return "拜拜"
print(fun1("狗子",24))
print(fun1.__doc__) # 返回函数和注释
""""""
"""
一个函数里面可以直接去调用另外的一个函数
测试得知识面广 溢出
模式——思维——知识度的广度
"""
def fun1():
print("Liaoliao")
def fun2():
print("富婆是谁")
fun1()
fun2()
#升级
def fun1():
print("Liaoliao")
return 3
def fun2(x):
print("富婆是谁")
r=fun1()
print(x+r)
fun2(3)
"""
python 跟Java C++不一样的地方：
函数内可以直接定义函数，还可以直接调用函数
"""
def fun3():
print ("廖廖同学能赚大钱")
def fun4():
print("廖廖同学是优秀的")
return #这个return 只作用域在fun4 不打印111
print("111")
fun4()
print("我们大家都是棒棒的")
fun3()
#fun3 与fun4 是两个独立的线程
""""""
"""
数学函数比较多:计算用到的函数比较多，会用就行
abs() 绝对值
round() 四舍五入
divmod() 返回商和余数
pow 次方
sum 求和
min () 最小值
max () 最大值
"""
res =abs (-100)
print(res)
x=int(input("请输入一个数:"))
a,b=divmod(x,2) #前面是除数后面是被除数
print(a) #商
print(b) #余数
print(round(2.5)) #特殊情况：偶数在round中 .5会被舍去 2
print(round(3.5)) #===》4
lst = [1,2,4,5,6,8]
print(sum(lst))
print(max(lst))
print(min(lst))
""""""
"""
作用域：
变量：
全局变量与局部变量
全局变量——在当前文件的任何位置可以被调用如s1
局部变量——在有效范围内可以被调用，出了范围就不能用了
例如：函数中声明的变量
循环里声明的变量
类中循环的变量
局部变量 可以通过关键字 global 变成全局变量
"""
s1=10
def fun1():
global s2 #s2=5 不能直接声明且赋值
s2=5
fun1()
print(s1)
print(s2) #得在s2前面加global 才能变为全局变量
匿名函数
""""""
"""
匿名函数 结合内置函数使用
"""
# lst = [10,20,30]
# res1 = lambda a: sum(a) #可换成 min max 等等来求值
# print(res1(lst)) #得传参 lst
"""
内置函数 filter
filter 是一个过滤器，规则定义 根据规则返回true 或者False
"""
lst1 =[1,2,3,4,5,6,7,8,9,10]
#取列表中的所以偶数
def fun1 ():
for i in lst1:
if i % 2==0:
print(i)
# 语法规则filter（function，可迭代的对象）
#filter 的使用特性：第一个参数为规则，这个规则可以用函数表示
#第二个参数为 遵循filter规则的值或者是数据传递进来
#filter 返回的是一个列表 转成列表
def fun2(num): #作为filter的判断函数
if num % 2==0:
return num
print(list(filter(fun2,lst1)))
print(list(filter(lambda num: num%2==0,lst1)))
""""""
"""
匿名函数 就是没有名字的函数
python 通过lambda 表达式来实现匿名函数
lambda 参数：表达式
结果就是表达式的返回值 不要return
lambda 是函数名
"""
#计算面积
PI=3.14
def fun(r):
return r*r*PI
print("当前圆的面积是：{}".format(fun(5)))
#匿名函数 —— 简单的计算可以用匿名函数
res= lambda r:r*r*PI #传递了一个参数
print("匿名函数当前圆的面积是：{}".format(res(5)))
res2=lambda r1,r2 :r1*r2*PI #传递了2个参数
print("匿名函数当前圆的面积是：{}".format(res2(5,5)))
装饰器
""""""
"""
python 可以把函数当遍历传递，
一旦我们执行了这个操作，当作参数的函数会自动执行
"""
import logging
"""
loggin 是一个日志模块，在自动化过程中，我们会经常通过日志模块
来帮助我们进行代码执行流程的记录
在某些代码执行时，我们可以给代码定好级别，来记录到对应日志中
这样我们在定位问题的时候，可以直接通过确定问题发生的点在哪里
"""
## 在工作中，日志需要定义级别
logging.basicConfig(level=logging.INFO) #DEBUG
def fun1():
print("执行函数")
logging.info("这里是info级别的日志")
logging.debug("这里是debug级别的日志")
logging.warning("警告，这里是警告级别的日志")
logging.error("错误，这里是错误级别的日志")
def fun2(fun1_a):
fun1_a()
print("执行fun2")
# fun2(fun1)
"""
范围：
debug :展示所有级别的错误日志——info debug warning error
info:只展示除了debug之外的所有错误日志——info warning error
warning: 展示包含error的错误日志——warning error
error ：只展示本身error 的日志
根据工作需求选择
"""
"""
优化：
"""
def loginfo (fun_name):
logging.info("记录日志")
fun_name()
logging.info("日志记录完毕")
def fun3():
print("代码执行")
def fun4():
print("4函数代码执行了")
loginfo(fun3)
loginfo(fun4)
"""
在 python 中，我们可以把函数名，用不带括号的方式
进行参数化传递 其中，这个函数名叫做
函数名——<引用>
"""
""""""
"""
装饰器：这是一种语法结构
定义一个方法/函数 通过 @ + 函数名 的这种方式来简化
我们的函数间相互引用的问题
"""
import logging
def log(fun_name):
def warpper(): #当调用了log方法时里面的这个warpper方法不会执行，因为并么有人调用，调用才能执行
print("你好我是装饰器")
logging.warning("{}正在执行".format(fun_name))
return fun_name()
return warpper
@log #装饰器 python 它有编译器——cpu (先找到方法名为log的方法并执行)
#相当于告诉编译器，要用特殊的方式去翻译，翻译给cpu去执行代码
def fun1():
print("执行函数")
fun1() #当有装饰器时可以直接调用
print(fun1.__name__)
print(fun1.__doc__)
# fun = log(fun1) --这里返回的是warpper 因为只执行了第一个def log(fun_name):方法，def warpper(): 不会被执行因为没有被调用
# 这个两行代码与@log 为等价的 cpu 在翻译的过程中会把@log 翻译成这个两行代码
# fun() #这里加了（）表示调用也就是调用了 wrapper 函数，也就是执行了warpper函数,调用才会执行
""""""
import logging
from functools import wraps #引入warps
def log(fun_name):
"""
wraps 本身就是装饰器，作用是吧原有的函数拷贝进来
"""
@wraps(fun_name) #固定写法 要加这一行
def warpper(): #当调用了log方法时里面的这个warpper方法不会执行，因为并么有人调用，调用才能执行
print("你好我是装饰器")
logging.warning("{}正在执行".format(fun_name))
return fun_name()
return warpper
@log #装饰器 python 它有编译器——cpu (先找到方法名为log的方法并执行)
#相当于告诉编译器，要用特殊的方式去翻译，翻译给cpu去执行代码
def fun1():
"""
这是一个装饰器
:return:
"""
print("执行函数")
fun1() #当有装饰器时可以直接调用
print(fun1.__name__)
print(fun1.__doc__)
#相当于wraps 替换掉了fun1
# fun = log(fun1) --这里返回的是warpper 因为只执行了第一个def log(fun_name):方法，def warpper(): 不会被执行因为没有被调用
# 这个两行代码与@log 为等价的 cpu 在翻译的过程中会把@log 翻译成这个两行代码
# fun() #这里加了（）表示调用也就是调用了 wrapper 函数，也就是执行了warpper函数,调用才会执行
文件操作
""""""
"""
覆盖写 w
追加写 a
"""
# w 是覆盖 执行后 再打开文档会原有的数据被覆盖掉
# file=open(r"D:\ppt模板软件\1.txt",mode="w",encoding="UTF-8")
# a 是追加 再次点开文档会追加一条
file=open(r"D:\ppt模板软件\1.txt",mode="a",encoding="UTF-8")
file.write("\n廖廖是老大")
file.close()
""""""
"""
pytho能够直接读取计算机的文件——txt
动态的把一些代码中的信息写入/读取到文件中去
针对于拿到的内容进行修改
使用的函数
open
1、打开文件 open("文件路径"，mode<读取方式>)
mode : r 只读 我覆盖性（删除原有文字，覆盖新的内容）
rb wb ab-二进制（图片）
r+ w+ a+ 读写
2、文件操作——读 写
"""
#读文件的时候需要注意编码问题 ，默认情况下 它英语解析的——IOS-8859
#修改编码格式，来确定中文格式encoding="UTF-8
file=open(r"D:\ppt模板软件\1.txt",mode="r",encoding="UTF-8") #路径前面加r 表示不转义直接读取路径
# msg = file.read() #一个字一个字的读
#readline()一行一行的读,一次只能读文本的一行
# msg=file.readline()
# print(msg)
'''
.readlines() 会将txt文本返回一个列表回来所以我们要通过for 循环将里面的元素一个个显示出来
replace 替换 将/n转换成空格
'''
content=file.readlines()
for txt in content:
print(txt.replace("/n"," "))
#读完要不要关闭——文件会被占用
file.close()
模块
""""""
"""
模块，指的就是针对于某个包下的python文件
py 文件里面，包含我们的python的对象，以及函数，以及定义变量，装饰器
一旦我们需要再其他的py文件中使用 这时候我们就就可以直接导入这个模块来进行使用
"""
'''
import 关键字，用来导入已经存在的模块
如果说要用到模块里面已经写好的函数
模块名.函数名 来表示
from(py 文件名).import (函数名) 关键字 仅仅只导入这个函数
'''
import time
print(time.time()) #打印出导入的当前时间
from time import time
print(time())
|