码迷，mamicode.com
首页 > 编程语言 > 详细

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

时间：2016-05-27 00:35:25      阅读：249      评论：0      收藏：0      [点我收藏+]

标签：

本篇所涉及的内容



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)







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

标签：

原文地址：http://www.cnblogs.com/CongZhang/p/5533109.html
踩
(0)
赞
(0)
   
举报
评论 一句话评论（0）
登录后才能评论！
分享档案
更多>
2021年07月29日 (22)
2021年07月28日 (40)
2021年07月27日 (32)
2021年07月26日 (79)
2021年07月23日 (29)
2021年07月22日 (30)
2021年07月21日 (42)
2021年07月20日 (16)
2021年07月19日 (90)
2021年07月16日 (35)
周排行
mamicode.com排行更多图片
更多
友情链接
兰亭集智   国之画   百度统计   站长统计   阿里云   chrome插件   新版天听网
关于我们 - 联系我们 - 留言反馈
© 2014 mamicode.com 版权所有  联系我们:gaon5@hotmail.com
迷上了代码！