day10函数与模块

Posted 2021-06-10 橘子皮卡丘

今日内容概要

• 指针移动seek()方法

• 文件修改的两种方法

• 函数

  定义函数
  调用函数
  函数的参数：形参与实参
  函数的返回值
  

• 模块

  import
  from...import...
  常用模块
  

今日内容详细

指针移动seek()方法

# 之前文件内指针的移动都是由读/写操作而被动触发的，若想读取文件某一特定位置的数据，则则需要用f.seek方法主动控制文件内指针的移动，详细用法如下：
# f.seek(指针移动的字节数,模式控制): 
# 模式控制:
# 0: 默认的模式,该模式代表指针移动的字节数是以文件开头为参照的
# 1: 该模式代表指针移动的字节数是以当前所在的位置为参照的
# 2: 该模式代表指针移动的字节数是以文件末尾的位置为参照的
# 强调:其中0模式可以在t或者b模式使用,而1跟2模式只能在b模式下用
f.seek(字节个数,0)
f.seek(字节个数,1)
f.seek(字节个数,2)

文件修改的两种方法

# 文件修改的原理：
# 把硬盘数据读入内存，在内存修改完毕后，再覆盖回硬盘
方式一：将硬盘存放的该文件的内容全部加载到内存，在内存中是可以修改的，修改完毕后，再由内存覆盖到硬盘（word，vim，nodpad++等编辑器）
import os

with open(\'a.txt\') as read_f,open(\'.a.txt.swap\',\'w\') as write_f:
    data=read_f.read() #全部读入内存,如果文件很大,会很卡
    data=data.replace(\'alex\',\'SB\') #在内存中完成修改

    write_f.write(data) #一次性写入新文件

os.remove(\'a.txt\')
os.rename(\'.a.txt.swap\',\'a.txt\') 

方式二：将硬盘存放的该文件的内容一行一行地读入内存，修改完毕就写入新文件，最后用新文件覆盖源文件
import os

with open(\'a.txt\') as read_f,open(\'.a.txt.swap\',\'w\') as write_f:
    for line in read_f:
        line=line.replace(\'alex\',\'SB\')
        write_f.write(line)

os.remove(\'a.txt\')
os.rename(\'.a.txt.swap\',\'a.txt\') 

函数

什么是函数

函数就是盛放功能(一系列代码)的容器
定义函数就是造出了一个工具

事先准备工具的过程->函数的定义
遇到应用场景拿来就用->函数的调用

为何要用函数

不用函数写出的代码问题是:
    1、代码的组织结构不清晰，可读性差
    2、遇到重复的功能只能重复编写实现代码，代码冗余
    3、功能需要扩展时，需要找出所有实现该功能的地方修改之，无法统一管理且维护难度极大   

如何用函数

函数使用原则:
    函数即“变量”，“变量”必须先定义后引用。未定义而直接引用函数，就相当于在引用一个不存在的变量名
    先定义
    后调用

定义函数的语法:
def 函数名(参数1,参数2,参数3,...):
    代码1
    代码2
    代码3
    return 值

调用函数语法:
res = 函数名(值1,值2,值3)

函数分类

#1、内置函数
为了方便我们的开发，针对一些简单的功能，python解释器已经为我们定义好了的函数即内置函数。对于内置函数，我们可以拿来就用而无需事先定义，如len(),sum(),max()
ps：我们将会在最后详细介绍常用的内置函数。

#2、自定义函数
很明显内置函数所能提供的功能是有限的，这就需要我们自己根据需求，事先定制好我们自己的函数来实现某种功能，以后，在遇到应用场景时，调用自定义的函数即可。
#语法
def 函数名(参数1,参数2,参数3,...):
    \'\'\'注释\'\'\'
    函数体
    return 返回的值

#函数名要能反映其意义

定义函数

函数在定义阶段都干了哪些事？
#申请内存空间,把函数体代码放进去,然后把内存地址绑定给函数名
#只检测语法，不执行代码
也就说，语法错误在函数定义阶段就会检测出来，而代码的逻辑错误只有在执行时才会知道
def func():
    print(1)
    print(2
    print(3)
          
#1、定义时无参，意味着调用时也无需传入参数
#2、定义时有参，意味着调用时则必须传入参数          

调用函数

函数的调用：函数名加括号
1 先找到名字
2 根据名字调用代码

函数调用的三种形式
1 语句形式：foo()
2 表达式形式：3*len(\'hello\')
3 当中另外一个函数的参数：range(len(\'hello\'))

函数在调用阶段都干了哪些事？
执行函数体代码
def func():
    print(1)
    print(2)
    asdf
    print(3)

func()

函数的参数：形参与实参

#形参即变量名，实参即变量值，函数调用时，将值绑定到变量名上，函数调用结束，解除绑定
具体应用：
#1、位置参数：按照从左到右的顺序定义的参数
    位置形参：必选参数
    位置实参：按照位置给形参传值

#2、关键字参数：按照key=value的形式定义的实参
    无需按照位置为形参传值
    注意的问题：
        1. 关键字实参必须在位置实参右面
        2. 对同一个形参不能重复传值

#3、默认参数：形参在定义时就已经为其赋值
    可以传值也可以不传值，经常需要变得参数定义成位置形参，变化较小的参数定义成默认参数（形参）
    注意的问题：
        1. 只在定义时赋值一次
        2. 默认参数的定义应该在位置形参右面
        3. 默认参数通常应该定义成不可变类型


#4、可变长参数：
    可变长指的是实参值的个数不固定
    而实参有按位置和按关键字两种形式定义，针对这两种形式的可变长，形参对应有两种解决方案来完整地存放它们，分别是*args，**kwargs
        ===========*args===========
        def foo(x,y,*args):
            print(x,y)
            print(args)
        foo(1,2,3,4,5)

        def foo(x,y,*args):
            print(x,y)
            print(args)
        foo(1,2,*[3,4,5])


        def foo(x,y,z):
            print(x,y,z)
        foo(*[1,2,3])

        ===========**kwargs===========
        def foo(x,y,**kwargs):
            print(x,y)
            print(kwargs)
        foo(1,y=2,a=1,b=2,c=3)

        def foo(x,y,**kwargs):
            print(x,y)
            print(kwargs)
        foo(1,y=2,**{\'a\':1,\'b\':2,\'c\':3})


        def foo(x,y,z):
            print(x,y,z)
        foo(**{\'z\':1,\'x\':2,\'y\':3})

        ===========*args+**kwargs===========

        def foo(x,y):
            print(x,y)

        def wrapper(*args,**kwargs):
            print(\'====>\')
            foo(*args,**kwargs)

#5、命名关键字参数：*后定义的参数，必须被传值（有默认值的除外），且必须按照关键字实参的形式传递
可以保证，传入的参数中一定包含某些关键字
def foo(x,y,*args,a=1,b,**kwargs):
    print(x,y)
    print(args)
    print(a)
    print(b)
    print(kwargs)

foo(1,2,3,4,5,b=3,c=4,d=5)
结果：
1
2
(3, 4, 5)
1
3
{\'c\': 4, \'d\': 5}

函数的返回值

函数的返回值有三种形式:
1.无return->None:没有return或者return无值或者return None:返回的都是None
2.return 1个值->返回1个值:return 值: 返回的就是改值本身/-
3.return 逗号分隔多个值->元组:return 值1,值2,值3:返回的是小元组

# return返回值的语法:
# 函数内可以有多个return,但只要执行一次,整个函数就立即结束,并且将return后的值当作本次调用的产品返回

什么时候该有返回值？
    调用函数，经过一系列的操作，最后要拿到一个明确的结果，则必须要有返回值
    通常有参函数需要有返回值，输入参数，经过计算，得到一个最终的结果
什么时候不需要有返回值？
    调用函数，仅仅只是执行一系列的操作，最后不需要得到什么结果，则无需有返回值
    通常无参函数不需要有返回值

模块

什么是模块

模块就是一组功能的集合体，我们的程序可以导入模块来复用模块里的功能。

#常见的场景：一个模块就是一个包含了一组功能的python文件,比如spam.py，模块名为spam，可以通过import spam使用。

#在python中，模块的使用方式都是一样的，但其实细说的话，模块可以分为四个通用类别：　
　　1 使用python编写的.py文件
　　2 已被编译为共享库或DLL的C或C++扩展
　　3 把一系列模块组织到一起的文件夹（注：文件夹下有一个__init__.py文件，该文件夹称之为包）
　　4 使用C编写并链接到python解释器的内置模块

模块有三种来源:
    1 python自带的模块/库
    内置模块
    标准库
    2 第三方的库
    3 自定义库

为何要用模块

#1、从文件级别组织程序，更方便管理
随着程序的发展，功能越来越多，为了方便管理，我们通常将程序分成一个个的文件，这样做程序的结构更清晰，方便管理。这时我们不仅仅可以把这些文件当做脚本去执行，还可以把他们当做模块来导入到其他的模块中，实现了功能的重复利用

#2、拿来主义，提升开发效率
同样的原理，我们也可以下载别人写好的模块然后导入到自己的项目中使用，这种拿来主义，可以极大地提升我们的开发效率

#ps：
如果你退出python解释器然后重新进入，那么你之前定义的函数或者变量都将丢失，因此我们通常将程序写到文件中以便永久保存下来，需要时就通过python test.py方式去执行，此时test.py被称为脚本script。

如何用模块

import

#模块可以包含可执行的语句和函数的定义，这些语句的目的是初始化模块，它们只在模块名第一次遇到导入import语句时才执行（import语句是可以在程序中的任意位置使用的,且针对同一个模块很import多次,为了防止你重复导入，python的优化手段是：第一次导入后就将模块名加载到内存了，后续的import语句仅是对已经加载到内存中的模块对象增加了一次引用，不会重新执行模块内的语句），如下 

#test.py
import spam #只在第一次导入时才执行spam.py内代码,此处的显式效果是只打印一次\'from the spam.py\',当然其他的顶级代码也都被执行了,只不过没有显示效果.
import spam
import spam
import spam

\'\'\'
执行结果：
from the spam.py
\'\'\'
import spam

print(spam.x)
print(spam.f1)
print(spam.f2)

def f1():
    print(\'xxxxxxxx\')

spam.f1()
spam.f2()

from ... import...

1.使用
from spam import read1,read2

2.from...import 与import的对比
#唯一的区别就是：使用from...import...则是将spam中的名字直接导入到当前的名称空间中，所以在当前名称空间中，直接使用名字就可以了、无需加前缀：spam.

#from...import...的方式有好处也有坏处
    好处：使用起来方便了
    坏处：容易与当前执行文件中的名字冲突
    
from spam import x,f1,f2
# def f1():
#     print(\'xxxxx\')
f1()    

常用模块

time模块

三种方式表示时间:
1.时间戳(timestamp)：通常来说，时间戳表示的是从1970年1月1日00:00:00开始按秒计算的偏移量。我们运行“type(time.time())”，返回的是float类型。
2.格式化的时间字符串(Format String)
3.结构化的时间(struct_time)：struct_time元组共有9个元素共九个元素:(年，月，日，时，分，秒，一年中第几周，一年中第几天，夏令时)
import time

# 时间戳
print(time.time())

# 格式化的字符
print(time.strftime(\'%Y-%m-%d %H:%M:%S\'))

# 结构化的时间
obj = time.localtime()  # 本地时区的struct_time
print(obj.tm_year)
print(obj.tm_yday)
print(obj)

obj2 = time.gmtime()  # utc时区的struct_time
print(obj2)

# sleep(secs)
# 线程推迟指定的时间运行，单位为秒。

#时间加减
import datetime

print(datetime.datetime.now()) #返回 2016-08-19 12:47:03.941925
print(datetime.date.fromtimestamp(time.time()) )  # 时间戳直接转成日期格式 2016-08-19
print(datetime.datetime.now() )
print(datetime.datetime.now() + datetime.timedelta(3)) #当前时间+3天
print(datetime.datetime.now() + datetime.timedelta(-3)) #当前时间-3天
print(datetime.datetime.now() + datetime.timedelta(hours=3)) #当前时间+3小时
print(datetime.datetime.now() + datetime.timedelta(minutes=30)) #当前时间+30分

c_time  = datetime.datetime.now()
print(c_time.replace(minute=3,hour=2)) #时间替换

random模块

import random

print(random.random())  #(0,1)----float    大于0且小于1之间的小数
print(random.randint(1,3))  #[1,3]    大于等于1且小于等于3之间的整数
print(random.randrange(1,3))  #[1,3)    大于等于1且小于3之间的整数
print(random.choice([11,"aaa",333]))  #11或者aaa或者333
print(random.sample([11,"aaa",333,444],2))  #列表元素任意2个组合

print(random.uniform(1, 3))  #大于1小于3的小数，如1.927109612082716 

item=[1,3,5,7,9]
random.shuffle(item)  #打乱item的顺序,相当于"洗牌"
print(item)

# 储备知识
print(chr(65))
print(chr(90))

print(ord(\'A\'))
print(ord(\'Z\'))

#生成随机验证码
import random

def make_code(size):
    res = \'\'
    for i in range(size):
        num = str(random.randint(0,9))
        s = chr(random.randint(65,90))
        res += random.choice([num,s])
    return res

print(make_code(6))