Python 基础部分-4

文件的基本操作

open()

用于文件处理

操作文件时，一般需要经历如下步骤：

• 打开文件
• 操作文件
• 关闭文件

基本操作文件方式

open(文件名/路径，模式，编码)，默认模式为“只读”

f = open('test.log', "r")
data = f.read()
f.close()
print(data)

>>>
testlog

打开文件时，需要指定文件路径和以何等方式打开文件，打开后，即可获取该文件句柄，日后通过此文件句柄对该文件操作。

打开文件的模式：　

• r ，只读模式【默认】

f = open('test.log')
data = f.read()
f.close()
 print(data)

>>>
abc123

• w，只写模式【不可读；文件不存在则创建；文件存在则清空内容；】

f = open('test.log', 'w')
data = f.write('defg123456') #以写方式覆盖文件
f.close()
print(data)

>>>
10  #写入10个字符

f = open('test.log', 'w')
data = f.read()
f.close()
print(data)

>>>
data = f.read()
io.UnsupportedOperation: not readable#只写方式不能读取文件内同

• x， 只写模式【不可读；文件不存在则创建；文件存在则报错】

f = open('test2.log', 'x')#文件不存在，创建一个新的文件
f.write("qwe456") 
f.close()

f = open('test2.log', 'x')
f.write("zxcv123456") 
f.close()

>>>
    f = open('test2.log', 'x')
FileExistsError: [Errno 17] File exists: 'test2.log'#文件已经存在，不能创建同名文件

• a， 追加模式【不可读；文件不存在则创建；文件存在则只追加内容；】

f = open('test2.log', 'a')
data = f.write("9876543210")
f.close()
print(data)

>>>
10 #写入10个字符

"+" 表示可以同时读写某个文件

• r+， 读写【可读，可写】

　　　　先读取文档，在文档末尾追加写入，指针移到最后

f = open("test.log", 'r+', encoding = "utf-8")
print(f.tell()) #显示指针位置，指针从开始向后读取
f.write("123456")

data = f.read()

print(data)
print(f.tell()) #读取文件后指针位置

f.close()

>>>
0
123456
6

• w+，写读【可读，可写】

　　　　先把文件内容清空，从开始向后读取文件；重新写入内容后，指针移到最后，读取文件。

f = open("test.log", 'w+', encoding = "utf-8")
f.write("123456")#写入完成后，文档指针位置在文件末尾
f.seek(0)#设定指针在文档开始
data = f.read()
print(data)

• x+ ，写读【可读，可写】

　　　　若文件存在，系统报错，建新文件，再写入内容后，指针移到最后，读取文件。

• a+， 写读【可读，可写】

　　　　文件打开同时，文档指针已经设定在最后， 写入文件后，指针留在文件的最后。

f = open("test.log", 'a+', encodig"utf-8")
f.write("987654")
print(f.tell()) #显示指针位置
f.seek(0)　　　　#设定指针为文档最开始
data = f.read()
print(data) 

>>>
6 
987654

r+ w+ x+ a+都以指针位置读取或写入数据。

 "b"表示以字节（bytes）的方式操作

• rb  或 r+b

f = open('test2.log', 'wb')
f.write(bytes("中国", encoding='utf-8'))
f.close()


f = open('test2.log', "rb")
data = f.read()
f.close()
print(data)
str_data = str(data, encoding='utf - 8')
print(str_data)

>>>
b'xe4xb8xadxe5x9bxbd'
中国

• wb 或 w+b

f = open('test2.log', 'wb')
str_data = "中国"
bytes_data = bytes(str_data, encoding = 'utf-8')#指定写如的编码
f.write(bytes_data)
f.close()

f = open('test2.log', 'wb')
f.write("中国")
f.close()

>>>
    f.write("中国")
TypeError: a bytes-like object is required, not 'str'

• xb 或 x+b
• ab 或 a+b

 注：以b方式打开时，读取到的内容是字节类型，写入时也需要提供字节类型

普通打开方式

python内部将底层010101010的字节 转换成 字符串

二进制打开方式

python将读取将底层010101010的字节 再按照程序员设定的编码，转换成字符串。

f = open('test2.log', 'wb')
f.write(bytes("中国", encoding='utf-8'))
f.close()

f = open('test2.log', "rb")
data = f.read()
f.close()
print(data)
str_data = str(data, encoding='utf - 8')
print(str_data)

>>>
b'xe4xb8xadxe5x9bxbd'
中国

文件操作内部函数

f.flush()

主动把内容刷新到硬盘内

f = open("test.log", "r+", encoding="utf-8")
f.write("123456789")#内容写入到内存中
f.flush()#把内容刷新到硬盘内
i = input(">>>") 

f.readline()

仅读取一行内容

f1 = open("test.log", 'r+', encoding = 'utf-8')
d = f1.realline()
f.close()
print(d)

f.tell()

显示指针位置

f.seek()

设定指针位置

f.trucate()

截取数据，仅保留指针前的数据

f = open("test.log", "r+", encoding = "utf-8")
print(f.tell())
print(f.seek(6))

f.truncate()
f1.close()

f.close()

关闭文件，把文件保存在硬盘中

使用for循环读取文件

f = open("xxx", "r")
for line in f:
    print(line)

with 循环打开文件

with open("xxx", 'r') as f:
    f.read()

f = open("xxx", 'r') 
f.read()
#不需要f.close()关闭文件

with支持同时打开两个文件,从源文件中逐行拷贝到目标文件中

with open("test.log", 'r') as obj1, open ("test2.log", 'w') as obj2:
    for line in obj1:
        obj2.write(line)

class file(object)
    def close(self): # real signature unknown; restored from __doc__
        关闭文件
        """
        close() -> None or (perhaps) an integer.  Close the file.
         
        Sets data attribute .closed to True.  A closed file cannot be used for
        further I/O operations.  close() may be called more than once without
        error.  Some kinds of file objects (for example, opened by popen())
        may return an exit status upon closing.
        """
 
    def fileno(self): # real signature unknown; restored from __doc__
        文件描述符  
         """
        fileno() -> integer "file descriptor".
         
        This is needed for lower-level file interfaces, such os.read().
        """
        return 0    
 
    def flush(self): # real signature unknown; restored from __doc__
        刷新文件内部缓冲区
        """ flush() -> None.  Flush the internal I/O buffer. """
        pass
 
 
    def isatty(self): # real signature unknown; restored from __doc__
        判断文件是否是同意tty设备
        """ isatty() -> true or false.  True if the file is connected to a tty device. """
        return False
 
 
    def next(self): # real signature unknown; restored from __doc__
        获取下一行数据，不存在，则报错
        """ x.next() -> the next value, or raise StopIteration """
        pass
 
    def read(self, size=None): # real signature unknown; restored from __doc__
        读取指定字节数据
        """
        read([size]) -> read at most size bytes, returned as a string.
         
        If the size argument is negative or omitted, read until EOF is reached.
        Notice that when in non-blocking mode, less data than what was requested
        may be returned, even if no size parameter was given.
        """
        pass
 
    def readinto(self): # real signature unknown; restored from __doc__
        读取到缓冲区，不要用，将被遗弃
        """ readinto() -> Undocumented.  Don't use this; it may go away. """
        pass
 
    def readline(self, size=None): # real signature unknown; restored from __doc__
        仅读取一行数据
        """
        readline([size]) -> next line from the file, as a string.
         
        Retain newline.  A non-negative size argument limits the maximum
        number of bytes to return (an incomplete line may be returned then).
        Return an empty string at EOF.
        """
        pass
 
    def readlines(self, size=None): # real signature unknown; restored from __doc__
        读取所有数据，并根据换行保存值列表
        """
        readlines([size]) -> list of strings, each a line from the file.
         
        Call readline() repeatedly and return a list of the lines so read.
        The optional size argument, if given, is an approximate bound on the
        total number of bytes in the lines returned.
        """
        return []
 
    def seek(self, offset, whence=None): # real signature unknown; restored from __doc__
        指定文件中指针位置
        """
        seek(offset[, whence]) -> None.  Move to new file position.
         
        Argument offset is a byte count.  Optional argument whence defaults to
(offset from start of file, offset should be >= 0); other values are 1
        (move relative to current position, positive or negative), and 2 (move
        relative to end of file, usually negative, although many platforms allow
        seeking beyond the end of a file).  If the file is opened in text mode,
        only offsets returned by tell() are legal.  Use of other offsets causes
        undefined behavior.
        Note that not all file objects are seekable.
        """
        pass
 
    def tell(self): # real signature unknown; restored from __doc__
        获取当前指针位置
        """ tell() -> current file position, an integer (may be a long integer). """
        pass
 
    def truncate(self, size=None): # real signature unknown; restored from __doc__
        截断数据，仅保留指定之前数据
        """
        truncate([size]) -> None.  Truncate the file to at most size bytes.
         
        Size defaults to the current file position, as returned by tell().
        """
        pass
 
    def write(self, p_str): # real signature unknown; restored from __doc__
        写内容
        """
        write(str) -> None.  Write string str to file.
         
        Note that due to buffering, flush() or close() may be needed before
        the file on disk reflects the data written.
        """
        pass
 
    def writelines(self, sequence_of_strings): # real signature unknown; restored from __doc__
        将一个字符串列表写入文件
        """
        writelines(sequence_of_strings) -> None.  Write the strings to the file.
         
        Note that newlines are not added.  The sequence can be any iterable object
        producing strings. This is equivalent to calling write() for each string.
        """
        pass
 
    def xreadlines(self): # real signature unknown; restored from __doc__
        可用于逐行读取文件，非全部
        """
        xreadlines() -> returns self.
         
        For backward compatibility. File objects now include the performance
        optimizations previously implemented in the xreadlines module.
        """
        pass

2.x

class TextIOWrapper(_TextIOBase):
    """
    Character and line based layer over a BufferedIOBase object, buffer.
    
    encoding gives the name of the encoding that the stream will be
    decoded or encoded with. It defaults to locale.getpreferredencoding(False).
    
    errors determines the strictness of encoding and decoding (see
    help(codecs.Codec) or the documentation for codecs.register) and
    defaults to "strict".
    
    newline controls how line endings are handled. It can be None, '',
    '
', '
', and '
'.  It works as follows:
    
    * On input, if newline is None, universal newlines mode is
      enabled. Lines in the input can end in '
', '
', or '
', and
      these are translated into '
' before being returned to the
      caller. If it is '', universal newline mode is enabled, but line
      endings are returned to the caller untranslated. If it has any of
      the other legal values, input lines are only terminated by the given
      string, and the line ending is returned to the caller untranslated.
    
    * On output, if newline is None, any '
' characters written are
      translated to the system default line separator, os.linesep. If
      newline is '' or '
', no translation takes place. If newline is any
      of the other legal values, any '
' characters written are translated
      to the given string.
    
    If line_buffering is True, a call to flush is implied when a call to
    write contains a newline character.
    """
    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

    def __getstate__(self, *args, **kwargs): # real signature unknown
        pass

    def __init__(self, *args, **kwargs): # real signature unknown
        pass

    @staticmethod # known case of __new__
    def __new__(*args, **kwargs): # real signature unknown
        """ Create and return a new object.  See help(type) for accurate signature. """
        pass

    def __next__(self, *args, **kwargs): # real signature unknown
        """ Implement next(self). """
        pass

    def __repr__(self, *args, **kwargs): # real signature unknown
        """ Return repr(self). """
        pass

    buffer = property(lambda self: object(), lambda self, v: None, lambda self: None)  # default

    closed = property(lambda self: object(), lambda self, v: None, lambda self: None)  # default

    encoding = property(lambda self: object(), lambda self, v: None, lambda self: None)  # default

    errors = property(lambda self: object(), lambda self, v: None, lambda self: None)  # default

    line_buffering = property(lambda self: object(), lambda self, v: None, lambda self: None)  # default

    name = property(lambda self: object(), lambda self, v: None, lambda self: None)  # default

    newlines = property(lambda self: object(), lambda self, v: None, lambda self: None)  # default

    _CHUNK_SIZE = property(lambda self: object(), lambda self, v: None, lambda self: None)  # default

    _finalizing = property(lambda self: object(), lambda self, v: None, lambda self: None)  # default

3.x

冒泡排序

#利用新变量互换值
a1 = 123
a2 = 456

temp = a1
a1 = a2
a2 = temp

a1 = 456
a2 = 123

#实现列表元组互换
li = [11,33,22,44,55]

temp = li[1]
li[1] = li[2]
li[2]=temp

print(li)

>>>
[11,22,33,44,55]

#把列表里面的所有值进行比较
li = [33,22,10,1]

for i in range(len(li)-1): #循环列表次数
    # i = 0              1   2   3
    #current:      li[0] 1   2   3
    #next_value:   li[1] 2   3   4 #列表li里面没有li[4]，因此需要减少一次循环次数
    current = li[i]
    next_value = li[i+1]
    print(i, current, next_value)

>>>
0 33 2 #第一次循环
1 2 10 #第二次循环
2 10 1 #第三次循环

#循环一次列表，仅把一个最大的元素排在最右方
li = [33,2,10,1]

for i in range(len(li)-1): #循环列表元素
    if li[i] > li[i+1]: #元素互换的条件
        temp = li[i]
        li[i] = li[i+1]
        li[i + 1] = temp
print(li)

>>>
[2, 10, 1, 33]

li = [33,2,10,1]

for i in range(len(li)-1): #元素内部从左往右循环比较三次，等于列表长度减1那么多次，如列表4个元素，两两比较，需要比较三次1-(33, 2), 2-(2,10), 3-(10, 1)

    if li[i] > li[i+1]:
        temp = li[i]
        li[i] = li[i+1]
        li[i + 1] = temp

print(li)

>>>
[2,10,1,33]
    

li = [33,2,10,1]
for j in range(1, len(li)): #由于i循环每完成一次，下一次i循环排序的元素就减少一次， j的数值应为1,2,3 到数列的长度为止。
    #j: 1 ,2 ,3, i循环中两两比较的次数
    for i in range(len(li)-j): #元素内部循环比较完成一次，得到最右边的一个最大元素，下一次循环比较的元素就减少一个，j代表每次完成循环减少的排序的元素。
        if li[i] > li[i+1]:
            temp = li[i]
            li[i] = li[i+1]
            li[i + 1] = temp

print(li)

>>>
[1, 2, 10, 33]

递归

递归指的是这样一个数列：1、1、2、3、5、8、13、21、……

递归满足2个条件：

1）有反复执行的过程（调用自身）

2）有跳出反复执行过程的条件（递归出口）

递归执行过程中参数传递过程

def f1():
    return "f1" #8. 执行f1()，返回"f1"， f1返回给函数调用者f1()="f1"=>f2()=>f3()=>f4(),最后有ret接受返回值“f1”

def f2():
    r = f1() #6. 执行f2(),得到 r = f1()
    return r #7. r = f1()， 返回r，即返回执行f1()

def f3(): 
    r = f2() #4. 执行f3(),得到 r = f2()
    return r #5. r = f2()， 返回r，即返回执行f2()

def f4():     
　　 r = f3() #2.执行f4(),得到 r = f3()
    return r #3.r = f3()， 返回r，即返回执行f3()

ret = f4() # 1.解释器读取函数，把f1,f2,f3,f4的函数存入内存，执行函数f4(), ret接受f4返回值r
print(ret)

def f4(a1, a2):
    print(a1, a2)

    #a1 = 0, a2 = 1,a3 = 1
    #a1 = 1, a2 = 1, a3 = 2
    #a1 = 1, a2 = 2, a3 = 3

    a3 = a1 + a2 #
    f4(a2, a3) #嵌套上面的参数循环执行函数

f4(0, 1)

>>> 
0 1
1 1
1 2
2 3
3 5
5 8
8 13
13 21
21 34
34 55
55 89
...

 练习:利用递归获取斐波那契数列中的第 10 个数，并将该值返回给调用者。

def f5(depth, a1, a2): #depth数列的第n个数
　　if depth == 10:
        return a1 #数列第十个数的返回值，最终有启始的函数'ret'接受
    a3 = a1 + a2
    r = f5(depth +1, a2, a3)
    return r
    
ret = f5(1,0,1)#数值0为第一个斐波那契的数值
print(ret)
>>>
34

 装饰器

装饰器用于装饰某个函数或者方法或者类，在调用者调用方式不变的情况下，可以在函数执行前或执行后做其他操作。

装饰器本质，将 原函数 封装到 新的函数里面（），使执行新函数时，既可以实现新函数的功能，有可以执行就函数的功能。

def outer(func):#参数func = 以原来的f1函数作为参数
    def inner():#inner函数作为新的f1函数执行
        print("hello")
        r = func()#由于outer(func)的参数为f1，此处执行原来的f1函数
        print("end")
        return r
    return inner #@outer inner = f1
　　　　　                                                                       
@outer #f1 = outer(f1)  1.执行outer函数，并且将其下面的函数名f1当做参数，func = f1；
　　　　　　　　　　　　　　2.将outer的返回值inner重新赋值给f1，f1=(outer的返回值)=inner, 执行f1() = 执行inner()
def f1():
    print("F1")
　　return ooo

def f2():
    print("F2")

def f3():
    print("F3")
"""
.
.
.
"""

def f100():
    print("F100")
　　

f1()

>>>
hello
F1
end
ooo

 只要函数应用装饰器，那么函数就被重新定义为：装饰器的内层函数。

装饰器装饰含两个参数的函数

def outer(func):
    def inner(a1, a2):
        print("123")
        ret = func(a1, a2)
        print("456")
        return ret
    return inner

@outer  #inner = index(a1, a2)，index函数被装饰到inner函数里面，
        #执行index函数是需要两个参数，因此装饰器函数也需要两个参数inner(a1,a2)。
        #装饰器内部执行func() = 执行index(),因此也需要在func函数中加入两个参数。func(a1, a2)
def index(a1, a2):
    print("执行函数")
    return a1 + a2

ret = index(1, 2)
print(ret)

装饰器装饰含N个参数的函数

def f1(*args,**kwargs):#多参数函数
    print(args)
    print(kwargs)

f1(11, 22, 33, 44, 55, 66, 77, 88, k1=123, k2=321)

>>>

　　(11, 22, 33, 44, 55, 66, 77, 88)
　　{'k2': 321, 'k1': 123}

def outer(func):
    def inner(*args, **kwargs):#
        print(args)
        ret = func(*args, **kwargs)#
        print(kwargs)
        return ret
    return inner


@outer
def index(a1, a2, k1=123, k2=456):
    print("执行函数")
    return a1 + a2

ret = index(10, 20, k1=123, k2=456)
print(ret)

>>>
(10, 20)
执行函数
{'k1': 123, 'k2': 456}
30

多个装饰器装饰同一个函数 

def outer_0(func):
    def inner(*args, **kwargs):
        print("python 3.5")
        ret = func(*args, **kwargs)
        return ret
    return inner

def outer(func):
    def inner(*args, **kwargs):
        print(args)
        ret = func(*args, **kwargs)
        print(kwargs)
        return ret
    return inner

@outer_0
@outer
def index(a1, a2, k1=123, k2=456):
    print("执行函数")
    return a1 + a2

>>>
python 3.5
(10, 20)
执行函数
{'k1': 123, 'k2': 456}
30

多装饰器嵌套原理

# @outer：  inner = index, outer(func) = outer(index)
# inner = 新的 index 函数 
# index(*args, **kwargs):
#   print(args)
#   ret = index(*args, **kwargs)
#       print("执行函数")
#       return a1 + a2
#   print(kwargs)
#   return ret

#@outer0：inner = 新的 index 函数 + 新的 inner， outer0(func) = outer0(inner(index))
#inner =out0 + index(*args, **kwargs) 函数 +
#index(*args, **kwargs):
#   print("python 3.5")
#   print(args)
#   print("执行函数")
#   return a1 + a2
#   print(kwargs)
#   return ret

装饰器总结 @ 

把index函数作为outer的参数去执行outer函数

index的整体放入内存 当内层函数inner中对index进行调用它作为一个新的函数

@outer

1. 执行outer函数，将index作为参数传递

2. 将outer的返回值，重新赋值给index