python2筑基—（装饰器/函数/匿名函数/文件操作/模块导入）

函数

• 函数的定义

""""""
"""
函数——等价于小封装
将一段公式/逻辑 定义在一个特定名称的代码块里面
如： 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())