python基础篇【第三篇】：函数、文件操作

一、函数

什么是函数？

函数是可以实现一些特定功能的小方法或是小程序。在Python中有很多内建函数如：（print（）），当然随着学习的深入，也可以学会创建对自己有用的函数。简单的理解下函数的概念，就是你编写了一些语句，为了方便使用这些语句，把这些语句组合在一起，给它起一个名字。使用的时候只要调用这个名字，就可以实现语句组的功能了，自己创建的函数就叫做自定义函数。

函数的特点：可重复使用的，用来实现单一，增强代码的重用性和可读性

定义函数

你可以定义一个由自己想要功能的函数，以下是简单的规则：

• 函数代码块以 def 关键词开头，后接函数标识符名称和圆括号()。
• 任何传入参数和自变量必须放在圆括号中间。圆括号之间可以用于定义参数。
• 函数的第一行语句可以选择性地使用文档字符串—用于存放函数说明。
• 函数内容以冒号起始，并且缩进。
• return [表达式] 结束函数，选择性地返回一个值给调用方。不带表达式的return相当于返回 None。
• 在函数中只要运行了return 下面的代码就不在执行直接返回！

语法：　

def name():  #（）里面内容称为形式参数  name为函数的名字
    print()　#中间的称为函数体
                #没有return  默认返回值为None

调用函数：

前面定义函数的时候，都给函数取了个名字，调用函数格式就是 函数名字后面加个括号如：name()

实例：

#定义函数
def name():
    print("hello world")

#调用函数
name()
name()#第二次调用函数

#执行结果：
C:PythonPython35python.exe E:/Python课程/s13/day3/函数（返回值2）.py
hello world
hello world

返回值实例：

1 def test():
2     print("a")
3     if 1 == 1:  # 如果1等于2 才会执行下面的return
4         return True # 在函数里只要执行了return 下面的将不再执行 中断函数操作
5     return False    #前面的条件不成立就会return False
6 
7 
8 name=test()     #把函数的返回值赋予一个变量，这样就可以显示出来返回的结果
9 print(name)

给函数传递参数：

再说这个之前先说一下变量还在函数里面的使用；

首先定义全局变量的潜规则写法是全部大写与常亮一样。

所有参数（自变量）在Python里都是按引用传递。如果你在函数里修改了参数，那么在调用这个函数的函数里，原始的参数也被改变了。

如以下实例：

#执行
def name(li):          #li就是给函数name传递一个参数，名为形参
    li.append("a")　　　　#修改参数的里的内容，注意是修改，而不是重新赋值
    print(li,type(li))

lists=[1,2,3,"q"]      #原始参数，定义成的变量
name(lists)         　　 #这里的lists 就是实际参数，统称实参
print(lists)

#返回结果：             #反馈的结果就是把原始参数也改变了，下面的再有函数调用lists变量时，调的就是新生成的变量
C:PythonPython35python.exe E:/Python课程/s13/day3/函数（返回值2）.py
[1, 2, 3, 'q', 'a'] <class 'list'>
[1, 2, 3, 'q', 'a']     

Process finished with exit code 0

global用法：

　　在函数里，要想给全局变量重新赋值，就用global如下：

 1  #执行代码
 2  name="tianjie"
 3  def  show():
 4     global name
 5     name='alex'
 6     print(name,type(name))
 7  show()
 8  print(name)
 9  
10 #返回结果
11 C:PythonPython35python.exe E:/Python课程/s13/day3/函数（返回值2）.py
12 alex <class 'str'>
13 alex
14  
15  Process finished with exit code 0
16 
17 #如果不加global name 只在函数作用域内生效
18 C:PythonPython35python.exe E:/Python课程/s13/day3/函数（返回值2）.py
19 alex <class 'str'>
20 tianjie
21 
22 Process finished with exit code 0

lambda表达式：

lambda 表达式，简单函数的表达方式
例如：

#例如定义一个函数:

# def test(a):
#     b=a+1
#     return b
# name=test(2)
# print(name)

#用lambda表达式写法
test=lambda a: a+1
#创建了形式参数a，
#函数内容，a+1 并把结果return
name=test(22)
print(name)


#结果就是：23

三元运算：

三元运算（三目运算），是简单的条件的语句缩写。

Python没有三目运算符但是可以用if else语句实现相同的功能:

#!/usr/bin/env python3

#三元运算格式
#test = 值1 if 条件 else 值2
#如果条件成立,那么值1赋值给变量test,否则将值2赋给test变量

#实例:
test = True if 1 > 0 else False
print(test)

#运行结果
True

函数指定参数：

就是给函数传递多个参数，不用按照顺序形参对应实参，可以在实参里直接指定，要把实参赋值给哪个形参！

如下实例：

def show(name,name1):
    print(name,name1)
show(name1=123,name=456)

默认参数：

默认形参等于一个值，如果调用函数是，没有给形参赋值，那么形参就用默认值；

如下实例：

# def show(name,name1=999):
#     #默认参数没有给name1赋值默认为999，默认参数必须放在后面
#     print(name,name1)
#
# show("a1","a2") #如果赋值了就会把默认参数替换掉


#执行结果：
a1 a2

函数发送邮件练习：

import smtplib
from email.mime.text import MIMEText
from email.utils import formataddr

#给不同人发邮件

def mail(user):  #user 称为形式参数
    test=True
    try:
        msg = MIMEText('邮件内容', 'plain', 'utf-8')
        msg['From'] = formataddr(["tianjie",'zjht0709@sina.com'])
        msg['To'] = formataddr(["gogo","451587411@qq.com"])
        msg['Subject'] = "主题"

        server = smtplib.SMTP("smtp.sina.com", 25)
        server.login("zjht0709@sina.com", "zjht0709")
        server.sendmail('zjht0709@sina.com', [user,], msg.as_string())
        server.quit()
    except Exception:
        test=False
    return test
test = mail("451587411@qq.com") #称为实际参数
test = mail("tianjie0522@163.com")  #称为实际参数

if test:
    print("发送成功")
else:
    print("发送失败")

动态参数：

　　你可能需要一个函数能处理比当初声明时更多的参数。这些参数叫做动态参数（*args，**kwargs）

形参一个*表示传递的是一个列表或者元组，两个**的表示字典，两个**的必须放在一个*后面，否则会报错，python默认的！

如下实例：

def show(*name):# 一个* 为元组
    print(name,type(name))
show(1,2,3,4,5,)

def show(**name): #两个*为字典
    print(name,type(name))
show(k="v1",k2="v2")

def show(*name,**name1):
    print(name,type(name))
    print(name1,type(name1))
show("w1","w2",k="v1",k2="v2")  #实参一个*的必须放在两个*的前面

#执行结果如下：
C:PythonPython35python.exe E:/Python课程/s13/day3/函数（动态参数）.py
(1, 2, 3, 4, 5) <class 'tuple'>
{'k2': 'v2', 'k': 'v1'} <class 'dict'>
('w1', 'w2') <class 'tuple'>
{'k2': 'v2', 'k': 'v1'} <class 'dict'>

#传递变量形式

# def show(*name,**name1):
#     print(name)
#     print(name1)
# n=["a1","a2","a3"]
# w={"k1":"v1","k2":"v2"}
# show(*n,**w)   #也可以传递列表或字典，意思是n前面加一个*，把n列表传递给*name
#                 #w前加两个*，把w字典传递给**name1

内置函数：

对于一些python中常用的函数，python自身就已经定义了一些函数用于调用，我们就叫它内置函数！

一些常用的内置函数具体用法：

1.abs()；取绝对值

n=abs(-2)
print(n)

结果：
2

2.all();传入可迭代的对象中，都为真才为真;

Fasle： 0,None,"",[],{} ,()都为假
True: 1,-1,True," " 

n=all([1,2,3," ",1,-1,True])
print(n)
#结果
True

3.any() 传入可迭代的对象中，任意一个为真，返回真

n=any([0,None,"",[],{} ,()]) #都为假
print(n)

#结果
False

4.bin()  把传入的十进制转换为二进制

n=bin(10)
print(n)

#执行结果
0b1010

5.oct()  把传入的十进制转换为八进制

n=oct(10)
print(n)

执行结果
0o12

6.hex() 把传入的十进制转换为十六进制

n=hex(10)
print(n)

执行结果
0xa

7.bytes() 把字符串转换成字节类型，需要指定编码  

其中： gbk编码：一个汉字占2个字节；

　　　 utf8编码：一个汉字占3个字节

n=bytes("hello",encoding="utf-8")
print(n)

执行结果：
b'hello'

 8.open()打开文件

f=open("db","r")    # db是文件名，r 是文件模式  

 

二、文件操作

上面已经说到了open这个python內键函数，就是为了打开文件，然后操作，最后关闭，这三步！

下面我们来看看，文件在python中有哪些操作方法；

打开文件：

　　f=open("db","r",encoding="utf-8") 
#db:文件的路径加文件名字，r:文件模式，encoding ：指定用什么字符编码打开

1、文件打开的模式：

　　　　r：只读模式，这个是默认的

　　　　w:只写模式，不可读 ，  写之前会把原有的文件内容都给清空然后在写；慎用！慎用！

　　　　a:追加模式，可读，文件内有内容就在文件最后添加，没有就创建

　　　　x:Python3新增，如果文件存在，就报错，文件不存在创建并写文件；

　“+”表示可同时读写文件

　　　　r+: 可读，可写，可追加

　　　　w+:写读

　　　　a+：同a

　“b”表示处理二进制文件

　　在Python内部打开文件的时候，python自己是把文件内容以二进制文件打开的，然后通过python解释器再转换成字符编码，写入文件的时候也是一样，需要通过python解释器做翻译成二进制方式给电脑

　　　　rb：以二进制方式读取

　　　　wb：以二进制方式写，不用再通过python解释器作解释了，读的时候也必须是以二进制方式读取

　　　　ab：以二进制方式追加

文件的操作方法：

def close(self, *args, **kwargs): # real signature unknown
        '''关闭文件'''
        pass


    def fileno(self, *args, **kwargs): # real signature unknown
        '''文件描述'''
        pass

    def flush(self, *args, **kwargs): # real signature unknown
        '''刷新文件内部缓冲区'''
        pass

    def isatty(self, *args, **kwargs): # real signature unknown
        '''判断文件是否是同意tty设备?'''
        pass

    def read(self, *args, **kwargs): # real signature unknown
        '''读文件,指定字节数据'''
        pass

    def readable(self, *args, **kwargs): # real signature unknown
        '''是否可读'''
        pass

    def readline(self, *args, **kwargs): # real signature unknown
        '''仅读取一行'''
        pass

    def seek(self, *args, **kwargs): # real signature unknown
        '''指定文件中指针的位置'''
        pass

    def seekable(self, *args, **kwargs): # real signature unknown
        '''指针是否可操作'''
        pass

    def tell(self, *args, **kwargs): # real signature unknown
        '''获取指针位置'''
        pass

    def truncate(self, *args, **kwargs): # real signature unknown
        '''截断数据,仅保留指定之前的数据'''
        pass

    def writable(self, *args, **kwargs): # real signature unknown
        '''是否可写'''
        pass

    def write(self, *args, **kwargs): # real signature unknown
        '''写内容'''
        pass

f.read([size])                #size为读取的长度，打开模式有b 就按byte为单位，无b就以字符为单位

f.readline([size])            #读第一行
f.readlines([size])          #把文件每一行作为一个list的一个成员，并返回这个list。其实它的内部是通过循环调用readline()来实现的。如果提供size参数，size是表示读取内容的总长，也就是说可能只读到文件的一部分。

f.write(str)                 #把str写到文件中，write()并不会在str后加上一个换行符

f.writelines(seq)            #把seq的内容全部写到文件中(多行一次性写入)。这个函数也只是忠实地写入，不会在每行后面加上任何东西。

f.close()                    #关闭文件。

f.flush()                    #把缓冲区的内容写入硬盘
f.tell()                     #返回文件操作标记的当前位置，以文件的开头为原点
f.next()                     #返回下一行，并将文件操作标记位移到下一行。把一个file用于for … in file这样的语句时，就是调用next()函数来实现遍历的。

f.seek(offset[,whence])              #将文件打操作标记移到offset的位置。这个offset一般是相对于文件的开头来计算的，一般为正数。但如果提供了whence参数就不一定了，whence可以为0表示从头开始计算，1表示以当前位置为原点计算。2表示以文件末尾为原点进行计算。需要注意，如果文件以a或a+的模式打开，每次进行写操作时，文件操作标记会自动返回到文件末尾。

f.truncate([size])                  #把文件裁成规定的大小，默认的是裁到当前文件操作标记的位置。如果size比文件的大小还要大，依据系统的不同可能是不改变文件，也可能是用0把文件补到相应的大小，也可能是以一些随机的内容加上去。

具体用法如下：

f=open('db','r')
data=f.read(1)   #读取文件如果读取模式无b，按一个字符读取，不指定，默认是全部
print(data,type(data))
f.close()

f=open("db","w")  #写文件，写之前会把“db”文件中的内容清空然后再写
f.write("hello")
f.close()

f=open("db","a")  #追加在文件后面
f.write("tianjie")
f.close()

f=open("db1","x")  #如果文件存在就会报错，不存在创建且写入
f.write("hi")
f.close()

#字节方式打开

f=open('db','rb') #读取模式有b，则read，按照字节读取
data=f.read()
print(data,type(data))
f.close()

f=open("db","ab")   #以二进制方式追加且指定字符加，因为有b 是以字节方式追加的，所以需要把字符转化成字节
f.write(bytes("田杰",encoding='utf-8'))
f.close()

f = open('db','wb')   #字符需要转换成字节
test = "人民的力量"
bytes_data = bytes(test,encoding='utf-8')
# f.write(bytes("人民的力量",encoding='utf-8'))
f.write(bytes_data)
f.close()

#+号
f=open("db","r+")  #读、写 这个通常用的较多
f.read(1)         #堆取第一个字符
print(f.tell())     #查看当前指针所在的位置（字节）
f.seek(f.tell())    #调整当前指针位置
f.write("333")      #在调整后的指针位置后面添加
print(f.tell())

f=open("db","w+")   #写读，先清空，然后再写，再写之后的就可以读了
f.write("tianjie")
n=f.tell()
print(n)
f.seek(0)              #从头开始读，把指针调到最开始位置（0），从指针第0个位置开始读
data=f.read()
print(data)

for line in f.readlines() :   #读取每一行内容，
        print(line)
　　　　line.startswith("xxxx") #以xxxx字符串开头的行
f.readline(): #读取第一行内容

with .... as .....:
　　文件打开方式还有一种就是用with as 的方式，这种方式的好处就是，你不用自己手动再去关闭文件了，这种方式自动就会关闭文件。
具体用法：

with open("db","r+") as f: #打开模式都是一样的写法，（注意缩进）
    for i in f.readlines():
        print(i)

同时打开多个文件：

#同时打开两个文件，把一个文件中的内容，写到另一个文件中
with open("db","r") as f,open("db2","w") as k:
    for line in f.readlines():
        k.write(line)