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

最新推荐文章于 2018-06-25 11:33:02 发布
最新推荐文章于 2018-06-25 11:33:02 发布
阅读量123 收藏 1
点赞数
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/crazy_zhangcong/article/details/88374386
版权

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

本篇涉及内容



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)







posted on 2016-05-26 23:22 奋斗中的码农 阅读(...) 评论(...) 编辑 收藏

crazy_zhangcong
关注
  • 0
    点赞
  • 踩
  • 1
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
Python 分布式缓存之Reids数据类型操作详解
09-16
在本文中，我们将深入探讨Python中使用Redis作为分布式缓存的数据类型操作。Redis是一个开源的内存数据结构存储系统，可作为数据库、缓存和消息代理使用。它支持多种数据结构，包括字符串(Strings)、哈希(Hashes)、...
蓝桥杯python第三期模拟赛 python题解
风信子的猫Redamancy的快乐星球
04-08 6188
蓝桥杯python第三期模拟赛 python题解 文章目录蓝桥杯python第三期模拟赛 python题解题目1题目2题目3题目4题目5题目6题目7题目8题目9题目10 想着在考前模拟测试一下，就写了这个 题目1 请问十六进制数 2021ABCD 对应的十进制是多少？ print(int('2021ABCD',16)) 思路：python一行搞定 答案：539077581 题目2 如果一个整数 M 同时是整数 A 和 B 的倍数，则称 M 是 A 和 B 的公倍数，公倍数中最小的一个正整数称为最小公
安全编码实践二：NXCOMPAT选项和数据执行保护DEP
04-26 5598
《程序员》3月文章申明。文章仅代表个人观点，与所在公司无任何联系。 概述    在安全编码实践一中我们谈到GS编译选项和缓存溢出。缓存溢出的直接后果就是可能导致恶意代码的远程执行。GS选项存在自身的局限，例如，有若干方法可以绕过GS选项的保护。   在这篇文章里，我们会介绍另外一个非常重要的安全特性：数据执行保护，即DEP-Data Execution Prevent
python 读取txt出现\xef\xbb\xbf…的问题
热门推荐
qq_16583687的博客
05-23 2万+
用python读取txt文件，文件的内容是一列数如下：1883 1886 1900 1900 1897 1897 1897 1897 1906 1917 1910 1910但是读取的时候第一个元素为‘\xef\xbb\xbf1883’，上网看了一些资料，原来在python的file对象的readline以及readlines程序中，针对一些UTF-8编码的文件，开头会加入BOM来表明编码方式。 解
Python数据类型运算符
05-03
Python 数据类型运算符 Python 中的数据类型可以分为数值类型、布尔类型、字符串类型、列表类型、元组类型、字典类型和集合类型等。每种数据类型都有其特点和应用场景。 数值类型包括整型 int、浮点型 float 和...
Python数据类型之Tuple元组实例详解
12-31
本文实例讲述了Python数据类型之Tuple元组。分享给大家供大家参考，具体如下： tuple元组 1.概述 本质上是一种有序的集合，和列表非常的相似，列表使用[]表示，元组使用()表示. 特点：一旦初始化，就不能发生改变 2....
python3实现将json对象存入Redis以及数据的导入导出
09-08
总的来说，Python3 实现将 JSON 对象存入 Redis 主要涉及 JSON 序列化、Redis 连接初始化、选择合适的数据类型和命令进行存储，以及了解 Redis 的持久化机制来保证数据的安全性。在实际应用中，还需要考虑如何有效地...
Python Numpy 数组的初始化和基本操作
12-23
Numpy的主要数据类型是ndarray，即多维数组。它有以下几个属性： ndarray.ndim：数组的维数 ndarray.shape：数组每一维的大小 ndarray.size：数组中全部元素的数量 ndarray.dtype：数组中元素的类型（numpy.int32...
简单谈谈python基本数据类型
12-24
int（整型） 在32位机器上，整数的位数为32位，取值范围为-2**31～2**31-1，即-2147483648～...注意，自从Python2.2起，如果整数发生溢出，Python会自动将整数数据转换为长整数，所以如今在长整数数据后面不加字母L也
Python-内置数据类型.zip
最新发布
05-27
==================内置数据类型========================= 第二章 009.程序的构成 010.对象的基本组成和内存示意图 011.引用的本质_栈内存和堆内存_内存示意图 012.标识符_帮助系统的简单使用_命名规则 013....
Python实现初始化不同的变量类型为空值
09-16
除了上述基本类型外，Python还有一个特殊的数据类型——`NoneType`，对应的值就是`None`。`None`是一个常量，表示空或者缺失值，它有自己的类型`NoneType`，与任何其他类型都不相同。 在Python中，`None`、空字符串...
Python变量及数据类型用法原理汇总
09-16
在Python中，变量和数据类型是编程的基础，它们对于理解和操作程序中的数据至关重要。以下是关于Python变量及数据类型用法原理的详细说明： 1. **变量（Variable）**： - 变量可以被视为存储数据的容器，它们的值...
python学习-numpy
01-23
在Python数据分析领域，NumPy库扮演着至关重要的角色。它提供了高效的多维数组对象和用于处理数组的数学函数。在上述代码中，我们看到了一系列关于NumPy的基本操作，包括创建数组、获取数组属性以及对数组进行操作。...
Python校内实训第二天--列表之水仙花数
chhandsome的博客
06-25 458
#生成1-10等十个数的列表# list2=range(1,11)# print(list(list2))#取得水仙花数      “[]”为列表，“()”为生成器list4=("%d%d%d" %(i,j,k) for i in range(1,10) for j in range(0,10) for k in range(0,10) if (i*i*i+j*j*j+k*k*k)==i*100+...
Dive Into Python学习日志
学习日记
10-09 1358
 def main (argv):    try:    opts,args = getopt.getopt (argv, "hg:d", ["help","grammar="])    except getopt.GetoptError:    usage()    sys.exit(2)    for opt, arg in opts:    if opt in (-h,--he
Python学习笔记（五）数据类型
psyche_knight的博客
11-16 403
Python数据类型
Spring AOP是什么?你都拿它做什么?
weixin_33853794的博客
07-18 1095
2019独角兽企业重金招聘Python工程师标准>>> ...

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值