python学习之路-3 初始python数据类型以及文件操作

时间：2021-12-31 11:48:24

本篇涉及内容



set集合

set是一个无序的且不重复的元素集合

1、创建set集合的方法

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
# 第一种方法
s = set()
print(type(s))
            
# 输出
<class 'set'>
           
           
# 第二种方法
s = {1, 2}
print(type(s))
           
# 输出
<class 'set'>
           
           
# 第三种方法
# 将一个可迭代的序列转换成为集合
l1 = [11, 22, 33, 44, 22, 44]
s = set(l1)
print(type(s))
print(s)
           
           
# 输出
<class 'set'>
{33, 11, 44, 22}
           
# 注：可以看到输出的set集合里面每一个值都是唯一的，这也体现出了set集合是一个不重复的序列

2、set集合的一些方法

  • add()  向set集合中添加一个元素
    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
    12
    13
    # add()  向set集合中添加一个元素
    s = {1, 2}
    print(s)
    s.add(3)
    s.add(3)
    s.add(2)
    print(s)
              
    # 输出
    {1, 2}
    {1, 2, 3}
              
    # 注：set的add方法一次只能够添加一个元素，由于set集合有去重的机制，所以多次添加相同的值，最后输出set集合的时候也只会显示一次

  • clear() 清空set集合中的所有元素

    1
    2
    3
    4
    5
    6
    7
    8
    s = {1, 2, "a", "b", "c"}
    print(s)
    s.clear()
    print(s)
               
    # 输出
    {'b', 1, 2, 'a', 'c'}
    set()

  • copy() 浅拷贝

    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
    12
    13
    14
    15
    16
    17
    x = [11, 22, 33, 11, 44, 22, 55]
    s = set(x)
    print(s)
    print(id(s))    # 输出内存地址
               
    # 对s进行浅拷贝
    s2 = s.copy()
    print(s2)
    print(id(s2))  # 输出内存地址
               
               
    # 输出
    {33, 11, 44, 22, 55}
    5882152   # 内存地址
    {33, 11, 44, 22, 55}
    6091272   # 内存地址
    # 注：可以看到s和s2的内存地址已经发生变化了

  • difference()  将前者存在，后者不存在的值取出来赋值给一个新的变量

    1
    2
    3
    4
    5
    6
    7
    8
    9
    s1 = {11, 22, 33, 44}
    s2 = {22, 33, 44, 55}
    s3 = s1.difference(s2)
    print(s3)
                
    #　输出
    {11}
                
    # 注：将s1中存在,s2中不存在的元素放到一个新的set集合中，然后返回给s3

  • difference_update()   将前者存在，后者不存在的元素放到一个新的set集合中，然后将前者直接覆盖掉

    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
    s1 = {11, 22, 33, 44}
    s2 = {22, 33, 44, 55}
    s3 = s1.difference_update(s2)
    print(s1)
    print(s3)
               
    #　输出
    {11}
    None
               
    # 注：将s1中存在的元素，s2中不存在的元素放到一个新的set集合中，然后将前者直接覆盖掉，不返回值

  • discard()  删除set集合中的一个元素

    1
    2
    3
    4
    5
    6
    7
    8
    9
    s1 = {11, 22, 33, 44}
    s1.discard(11)
    s1.discard(111)
    print(s1)
               
    # 输出
    {33, 44, 22}
               
    # 注：如果删除的值不存在，也不会出现报错信息

  • intersection()   前者和后者都有的

    1
    2
    3
    4
    5
    6
    7
    8
    9
    s1 = {11, 22, 33, 44}
    s2 = {22, 33, 44, 55}
    s3 = s1.intersection(s2)
    print(s3)
               
    # 输出
    {33, 44, 22}
               
    # 注：可以理解为两个集合的并集吧

  • intersection_update()   前者和后者都有的，赋值给前者   没有返回值

    1
    2
    3
    4
    5
    6
    7
    8
    9
    s1 = {11, 22, 33, 44}
    s2 = {22, 33, 44, 55}
    s1.intersection_update(s2)
    print(s1)
               
    # 输出
    {33, 44, 22}
               
    # 注：将s1清空,把s1和s2中都存在的元素赋值给s1

  • isdisjoint()  判断两个集合是否有相同的元素，如果有，则返回False 否则返回True

    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
    12
    13
    14
    15
    16
    s1 = {11, 22, 33, 44}
    s2 = {55}
    s3 = s1.isdisjoint(s2)
    print(s3)
               
    # 输出
    True
               
               
    s1 = {11, 22, 33, 44}
    s2 = {22, 33, 44, 55}
    s3 = s1.isdisjoint(s2)
    print(s3)
               
    # 输出
    False

  • issubset() 判断前者是否是后者的子集,返回一个布尔值

    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
    12
    13
    14
    15
    16
    17
    18
    s1 = {11, 22, 33, 44}
    s2 = {44}
    s3 = s1.issubset(s2)
    print(s3)
                 
    # 输出
    False
                 
                 
    s1 = {44}
    s2 = {11, 22, 33, 44}
    s3 = s1.issubset(s2)
    print(s3)
                 
    # 输出
    True
                
    # 注：就是判断前者中的所有元素在后者中是否都存在，返回一个布尔值

  • issuperset() 判断前者是否是后者的父集，返回一个布尔值

    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
    12
    13
    14
    15
    16
    17
    18
    s1 = {11, 22, 33, 44}
    s2 = {44}
    s3 = s1.issuperset(s2)
    print(s3)
                
    # 输出
    True
                
                
    s1 = {44}
    s2 = {11, 22, 33, 44}
    s3 = s1.issuperset(s2)
    print(s3)
                
    # 输出
    False
                
    # 同issubset()方法正好相反

  • pop() 随机删除一个set集合中的元素，并返回该元素, 如果该集合为空，则报错

    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
    12
    13
    14
    15
    16
    17
    18
    s1 = {11, 22, 33, 44}
    s2 = s1.pop()
    print(s1)
    print(s2)
                
    # 输出
    {11, 44, 22}
    33
                
    # 如果从空集合中执行pop方法，则会报错
    s1 = set()
    s2 = s1.pop()
                
    # 错误信息
    Traceback (most recent call last):
      File "D:/SVN/learning/s13/day3/class_code/set集合.py", line 218, in <module>
        s2 = s1.pop()
    KeyError: 'pop from an empty set'

  • remove() # 从集合中删除一个指定的元素，如果该元素不存在，则报错，可以直接忽略该方法，直接用上面介绍的discard方法，删除元素不会报错，没有返回值

    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
    12
    13
    14
    15
    16
    17
    18
    s1 = {11, 22, 33, 44}
    s1.remove(11)
    print(s1)
               
    # 输出
    {33, 44, 22}
               
               
    # 使用remove删除一个不存在的元素
    s1 = {11, 22, 33, 44}
    s1.remove(111)
    print(s1)
               
    # 输出
    Traceback (most recent call last):
      File "D:/SVN/learning/s13/day3/class_code/set集合.py", line 222, in <module>
        s1.remove(111)
    KeyError: 111

  • symmetric_difference  # 前者有后者没有  和后者有，前者没有的  都取出来放到一个新的集合中并返回

    1
    2
    3
    4
    5
    6
    7
    s1 = {11, 22, 33, 44}
    s2 = {22, 33, 44, 55}
    s3 = s1.symmetric_difference(s2)
    print(s3)
              
    # 输出
    set([11, 55])

  • symmetric_difference_update 前者有后者没有  和后者有，前者没有的  都取出来放到一个新的集合中覆盖前者, 没有返回值

    1
    2
    3
    4
    5
    6
    7
    s1 = {11, 22, 33, 44}
    s2 = {22, 33, 44, 55}
    s1.symmetric_difference_update(s2)
    print(s1)
              
    # 输出
    set([11, 55])

  • union() 返回一个新的集合，返回一个集合，包含前者和后者所有的元素

    1
    2
    3
    4
    5
    6
    7
    s1 = {11, 22, 33, 44}
    s2 = {22, 33, 44, 55}
    s3 = s1.union(s2)
    print(s3)
              
    # 输出
    set([33, 11, 44, 22, 55])

  • update()   将后者的元素全部添加到前者中， 没有返回值

    1
    2
    3
    4
    5
    6
    7
    s1 = {11, 22, 33, 44}
    s2 = {22, 33, 44, 55, 1, 2, 3, 4}
    s3 = s1.update(s2)    # update中接受一个可以迭代的对象,可以是字典、元组、字符串、set集合
    print(s1)
               
    # 输出
    set([33, 2, 3, 4, 1, 11, 44, 22, 55])

函数

一、函数的定义

函数就是为了避免重复造*，避免造成代码量的冗余以及让代码的维护更简单

简单来说，比如我有一个功能需要应用在10个地方，如果不用函数来实现的话，我就需要在10个地方将这个功能的代码都写一遍，这个时候你的老板说这个功能要加一个小的功能进去，这个时候你就崩溃了，在这10个地方写的代码都需要修改，如果使用函数的话，就只需要修改这个用函数封装起来的代码就可以了

二、函数的语法和创建

  • 语法

    1
    2
    3
    4
    5
    6
    7
    def 函数名(参数):
        ...
        函数体
        ...
        返回值
              
    # 返回值不是必须的，如果没有return语句，则默认返回值None

  • 创建一个函数

    1
    2
    3
    4
    def test():  # 创建一个名为test的函数
        print("hello")   # 函数体输入"hello"
              
    test()  # 调用函数，会执行test函数的函数体

三、参数

1
2
3
4
5
6
python中函数的参数主要分为以下几种：
1、普通参数
2、默认参数
3、指定参数
4、动态参数
5、万能参数

  • 普通参数

    1
    2
    3
    4
    5
    6
    7
    8
    def send(name, content):    # name 和 content是形式参数，简称形参
        print(name, content) return True
            
    send("zhangsan", "DaShaX") # 调用函数  "zhangsan" 和 "DaShaX" 是实际参数，简称实参
            
            
    # 输出
    zhangsan DaShaX

  • 默认参数

    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
    # 默认参数只能在形式参数的最后出现，否则会报错
    def send(name, content="DaShaX"):
        print(name, content)
        return True
           
    # 调用函数
    send("zhangsan")
           
           
    # 输出
    zhangsan DaShaX

  • 指定参数

    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
    12
    13
    def send(name, content):
        print(name, content)
        return True
           
    # 调用函数
    send(content="DaShaX", name="zhangsan")
           
           
    # 输出
    zhangsan DaShaX
           
           
    # 注：在调用函数时，指定形参对应的实参，可以不按照函数形参的顺序进行调用

  • 动态参数

    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
    12
    13
    14
    15
    16
    17
    18
    19
    20
    21
    22
    23
    24
    25
    26
    27
    28
    29
    30
    动态参数主要包括两种：
        *args     # 接收一个可迭代的数据类型
        **kwargs    # 接收一个含有键值对的数据类型
            
    使用动态参数的好处主要是不需要指定参数的个数
             
             
    ### *args 对传进来的可迭代参数将其进行迭代，将迭代后的值组成一个元组
    def f1(*args):
        print(args, type(args))
             
    li = [1, 2, 3, 4]
    f1(*li)
             
    # 输出
    (1, 2, 3, 4) <class 'tuple'>
             
             
            
    ### **kwargs将传进来的字典或者键值对，保存到一个字典中
    def f1(**kwargs):
        print(kwargs, type(kwargs))
             
    dic = {'k1': 'v1', 'k2': 'v2'}
    f1(**dic)
    # 或者通过下面这种形式调用
    # f1(k1='v1', k2='v2') 得到的输出结果是一样的
             
    # 输出
    {'k1': 'v1', 'k2': 'v2'} <class 'dict'>

  • 万能参数

    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
    12
    13
    14
    15
    16
    17
    # 万能参数是由动态参数的两种形式组合而成，*args在前，**kwargs在后
           
    def f1(*args, **kwargs):
        print(args, type(args))
        print(kwargs, type(kwargs))
           
    f1(11, 22, 33, 44, k1="v1", k2="v2")  # 调用函数
           
    # 或者使用下面的方式进行调用，效果是一样的
    # l1 = [11, 22, 33, 44]
    # d1 = {"k1": "v1", "k2": "v2"}
    # f1(*l1, **d1)
           
           
    # 输出
    (11, 22, 33, 44) <class 'tuple'>
    {'k2': 'v2', 'k1': 'v1'} <class 'dict'>

  • 动态参数的应用

    1
    2
    3
    4
    5
    6
    7
    8
    9
    # 对字符串的format()方法进行传参的时候可以使用动态参数来完成，下面两种传参得到的结果都是一样的
    s1 = "i am {0}, age {1}".format("zhangsan", 20)
    print(s1)
    s2 = "i am {0}, age {1}".format(*["zhangsan", 20])
    print(s2)
           
    # 输出
    i am zhangsan, age 20
    i am zhangsan, age 20

四、return语句

return是函数执行的返回值，在函数执行的过程中，遇到return的时候，函数就结束了，并且返回对应的值，如果return没有定义返回值，则为None

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
# 创建两个函数，一个有返回值，一个没有返回值
def f1(a1 , a2):
    return
       
       
def f2(a1, a2):
    return a1 + a2
       
a1 = 5
a2 = 10
ret1 = f1(a1, a2)   # 接收到的是None
ret2 = f2(a1, a2)   # 接收到的是15
print(ret1)
print(ret2)
       
# 输出
None
15

五、变量作用域

  • 全局变量

    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
    12
    13
    14
    15
    16
    17
    18
    19
    20
    21
    22
    23
    24
    25
    26
    27
    28
    29
    30
    31
    32
    33
    34
    35
    36
    37
    38
    39
    40
    41
    42
    43
    44
    45
    46
    47
    48
    49
    50
    51
    52
    53
    54
    55
    56
    57
    58
    59
    60
    61
    62
    63
    64
    65
    66
    67
    68
    69
    70
    71
    72
    73
    74
    75
    76
    77
    78
    79
    80
    ###定义在函数外面的变量为全局变量，全局变量使用大写来表示，例如：
    NAME = "zhangshan"
           
           
    ### 在函数中可以直接调用全局变量来使用，但是不能对其进行重新赋值
    NAME = "zhangshan"
    def f1():
        age = 18
        print(age, NAME)
           
    f1()
           
    # 输出
    18 zhangshan
           
           
           
    ### 如果全局变量为列表，字典或集合，在函数中可以对其进行修改，但是不能对其进行重新赋值，字符串不能进行任何操作
    # 全局变量为列表，在函数中对其进行append操作
    NAMES = ["zhangshan", "lisi", "wangwu"]  # 全局变量
    def f1():
        age = 18
        NAMES.append("dasha")   # 在函数中对全局变量进行操作
        print(age, NAMES)
           
    f1()   # 调用函数
    print(NAMES)  # 输出在函数内被操作的全局变量
           
    # 输出
    18 ['zhangshan', 'lisi', 'wangwu', 'dasha']
    ['zhangshan', 'lisi', 'wangwu', 'dasha']
           
           
    # 当全局变量为字典时，在函数中对其添加一对键值对
    NAMES = {"zhangshan": 18, "lisi": 20, "wangwu":100}
    def f1():
        age = 18
        NAMES["DaShanPao"] = 200
        print(age, NAMES)
           
    f1()
    print(NAMES)
           
    # 输出
    18 {'lisi': 20, 'DaShanPao': 200, 'wangwu': 100, 'zhangshan': 18}
    {'lisi': 20, 'DaShanPao': 200, 'wangwu': 100, 'zhangshan': 18}
           
           
    # 当全局变量为set集合时候，在函数中对其进行add操作
    NAMES = set(["zhangshan", "lisi", "wangwu"])
    def f1():
        age = 18
        NAMES.add("sss")
        print(age, NAMES)
           
    f1()
    print(NAMES)
           
    # 输出
    18 {'lisi', 'wangwu', 'sss', 'zhangshan'}
    {'lisi', 'wangwu', 'sss', 'zhangshan'}
           
           
    # 如果希望在函数内对全局变量进行重新赋值时，就需要在函数内使用global关键字对变量进行声明
    NAMES = ["zhangshan", "lisi", "wangwu"]
    def f1():
        global NAMES
        NAMES = "DaShanPao"
        print(age, NAMES)
           
    f1()
    print(NAMES)
           
    # 输出
    ['zhangshan', 'lisi', 'wangwu']
    DaShanPao
    DaShanPao
           
    # 注：可以看到在函数中对全局变量NAMES使用global关键字进行声明，
    #     然后对该变量进行修改，在函数外进行输出时输出的是修改过的值

  • 局部变量

    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
    12
    13
    14
    15
    16
    17
    18
    19
    20
    21
    22
    23
    24
    25
    26
    27
    28
    29
    ### 定义在函数内的变量为局部变量，局部变量使用大写来表示，例如：
    def f1():
        NAME = "zhangshan"
        print(NAME)
    f1()
    print(NAME)
           
    # 输出
    Traceback (most recent call last):
      File "D:/SVN/learning/s13/day3/class_code/函数.py", line 142, in <module>
        print(NAME)
    NameError: name 'NAME' is not defined
    zhangshan
           
    # 注：在函数内定义的变量为局部变量，在函数外使用函数内的变量是会报错的
           
           
           
    ### 要想让函数内的变量在函数外使用需要用global进行声明
    def f1():
        global NAME
        NAME = "zhangshan"
        print(NAME)
    f1()
    print(NAME)
           
    # 输出
    zhangshan
    zhangshan

六、自定义函数及函数规范

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
def login(username, password):
    """
    用于用户登录
    :param username: 用户输入的用户名
    :param password:  用户输入的密码
    :return: True：表示登录成功   False：表示登录失败
    """
    f = open("db", "r")
    for line in f:
        line_list = line.split("|")
        if line_list[0] == username and line_list[1] == password:
            return True
       
    return False
       
       
def register(username, password):
    """
    用户用户注册
    :param username: 用户输入的用户名
    :param password: 用户输入的密码
    :return: None
    """
    f = open("db", 'a')
    temp = "\n" + username + "|" + password
    f.write(temp)
    f.close()
       
       
def main():
    t = input("1：登录   2：注册")
    if t == "1":
        user = input("请输入用户名：")
        pwd = input("请输入密码：")
        r = login(user, pwd)
        if r:
            print("登录成功")
        else:
            print("登录失败")
    elif t == "2":
        user = input("请输入用户名：")
        pwd = input("请输入密码：")
        register(user, pwd)

七、lambda表达式

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
# lambda表达式就是简单函数的缩写
# 例如
def f1(a1):
    return a1 + 100
       
# 使用lambda表达式可以简写为：
f2 = lambda a1: a1 + 100
       
# 也可以有两个参数,还可以有默认参数
# f2 = lambda a1, a2=0: a1 + a2 + 100
       
# 对函数的调用
ret = f1(10)
print(ret)
       
ret2 = f2(9)
print(ret2)
       
# 输出
110
110

八、python内置函数

python中有许多内置的函数 --> 点我查看python3内置函数官方文档

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
### abs(x)  取绝对值
print(abs(-10))
# 输出
10
      
      
### all(iterable)  返回一个bool值，传入一个可迭代的值，该值内的每一个元素都为真，才为真
n = all([1, 2, 3])
print(n)
# 输出
True
      
n = all([1, 2, 3, 0])
print(n)
# 输出
False
      
      
### any(iterable)  返回一个bool值，传入一个可迭代的值，该值内只要有一个元素都为真，就为真
n = any([1, 0, False])
print(n)
# 输出
True
      
n = any([False, 0])
print(n)
# 输出
False
      
      
### bool([x])   返回一个布尔值  True 或 False  x为可选，x为空时候，返回False
x = 1
x2 = 0
ret = bool(x)
ret2 = bool(x2)
print(ret)
print(ret2)
      
# 输出
True
False
      
      
### bin(number)   # 将十进制转换成二进制
number = 10
ret = bin(number)
print(ret)
      
# 输出
0b1010
      
      
### oct(number)   将十进制转换成为八进制
number = 9
ret = oct(number)
print(ret)
      
# 输出
0o11
      
      
### hex()     # 将十进制转为十六进制
number = 15
ret = hex(number)
print(ret)
      
# 输出
0xf
      
      
### bytes()    将字符串转换成为对应编码格式的字节类型
name = "张三"
ret = bytes(name, encoding="utf-8")
print(ret)
print(str(ret, encoding="utf-8"))   # 使用str()   将字节类型转换为字符串类型，编码格式需要对应
      
ret = bytes(name, encoding="gbk")
print(ret)
print(str(ret, encoding="gbk"))     # 使用str()   将字节类型转换为字符串类型，编码格式需要对应
      
# 输出
b'\xe5\xbc\xa0\xe4\xb8\x89'
张三
b'\xd5\xc5\xc8\xfd'
张三

三元运算

1
2
3
4
5
6
7
8
9
# 三元运算就是对 if else的简写
# 例如：
if i == 1:
    name = "zhangshan"
else:
    name = "SB"
      
# 使用三元运算简写如下
name = "zhangsan" if 1 == 1 else "SB"

文件处理

  • 打开文件

    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
    12
    13
    14
    15
    16
    17
    18
    19
    20
    21
    # 打开文件
    # 第一种方法
    f = open("文件名(绝对路径或相对路径)", "方法", encoding="utf-8")    # 打开文件的时候一定要指定字符集
    # 第二种方法
    with open("文件名(绝对路径或相对路径)", "方法", encoding="utf-8") as f:    # with下面的代码块执行完毕，自动关闭文件
        
    # 方法主要包括以下几种：
    "r"   # 只读，文件必须存在，如果不存在，则报错
    "w"   # 只写，如果文件存在，则清空，如果不在，则创建
    "x"   # 如果文件存在，则报错，如果不存在，创建文件并只写
    "a"   # 追加，如果文件存在，在文件末尾写，如果不存在，则先创建文件
        
    "rb"  # 二进制读，以字节码方式表示，文件必须存在，如果不存在，则报错
    "wb"  # 二进制写，以字节码方式表示，如果文件存在，则清空，如果不在，则创建
    "xb"  # 二进制打开文件，以字节码方式表示，如果文件存在，则报错，如果不存在，创建文件并只写
    "ab"  # 二进制打开文件，以字节码方式表示，追加，如果文件存在，在文件末尾写，如果不存在，则先创建文件
        
    "r+"  # 读写  可读，可写    # 一般都用这个   先读在写，可以调整指针位置，然后在写入
    "w+"  # 写读  可读，可写    # 先清空文件，在可读可写
    "x+"  # 写读  可读，可写
    "a+"  # 写读  可读，可写    # 不管指针在哪里，永远写到最后面

  • 操作文件

    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
    12
    f.read([number,])    # 无参数，读全部，看参数number是否有值，有b  读字节， 无b，读字符
    f.write()   # 写数据，当前指针位置写入文件    有b  写字节， 无b，写字符
    f.seek()    # 调整当前指针的位置(字节)
    f.tell()    # 获取当前指针的位置(字节)
    f.fileno()  # 检测文件是否发生变化
    f.flush()   # f.write会将内容写入到内存中，f.flush 会强制将内存中的内容写入到文件中
    f.readable() # 判断文件句柄是否可读   返回一个布尔值
    f.seekable() # 判断指针是否可以移动   返回一个布尔值
    f.writeable()  # 判断文件句柄是否可写   返回一个布尔值
    f.readline() # 每次读取一行
    f.readlines() # 将文件中的内容存放到一个列表中，每一行为一个元素
    f.truncate()  # 将文件进行截断，将指针后面的内容清空

  • 关闭文件

    1
    2
    f.close()
    如果使用with打开文件，with下面的代码块执行完毕，文件会自动关闭

  • 练习代码

    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
    # 循环文件每一行
    f = open("文件名", "r+", encoding="utf-8")
    for line in f:   # 循环文件句柄，可以得到每一行的内容
        print(line)
        
        
            
    # 通过with同时打开两个文件，从第一个文件将内容读出，写入到第二个文件
    with open("文件1", "r", encoding="utf-8) as f1, open("文件2", "w", encoding="utf-8") as f2:
        for line in f1:
            f2.write(line)

相关文章