python 基础之数据类型

谁借莪１个温暖的怀抱￠ 2023-10-09 10:37 26阅读 0赞

一、python中的数据类型之列表
    　　1、列表
    　　　　列表是我们最以后最常用的数据类型之一，通过列表可以对数据实现最方便的存储、修改等操作

**二、列表常用操作**

**>切片  
>追加  
>插入  
>修改  
>删除  
>扩展  
>拷贝  
>统计**

**>排序**

**>翻转**

>>> names = ["admin","abc","jack","lily"]    #定义列表
    >>> names            #查表中的元素
    ['admin', 'abc', 'jack', 'lily']
    
    通过下标访问列表中的元素，下标从0开始计数 >>> names[0]
    'admin'
    >>> names[1]
    'abc'
    >>> names[2]
     'jack' 取最后一个元素： >>> names[-1]
    'lily' 取倒数第二个元素： >>> names[-2]
    'jack'

2.1.1、切片：取多个元素

![ContractedBlock.gif][] ![ExpandedBlockStart.gif][]

>>> names 
    ['admin', 'abc', 'jack', 'lily']
    >>> names[0:3]         #取下标0到下标3之间的数字，包括0，不包括3
    ['admin', 'abc', 'jack']
    
    >>> names[:3]           #从头开始取，0可以忽略，跟上问效果一样
    ['admin', 'abc', 'jack']
    
    >>> names[0:-1]        #取下标0到-1之前的数字，包括0，不包括-1.也就是最后一个
    ['admin', 'abc', 'jack']
    
    >>> names[1:]           #如果想取到最后一个，只能这么写，不能写-1
    ['abc', 'jack', 'lily']
    
    >>> names[1:-1]        #如果写成-1,此时不包括-1
    ['abc', 'jack']
    
    >>> names[0::2]        #后面的2代表每隔一个元素取一个
    ['admin', 'jack']
            
    >>> names[::2]          #跟上句效果一样
    ['admin', 'jack']

切片

2.1.2、追加

![ContractedBlock.gif][] ![ExpandedBlockStart.gif][]

>>> names   
    ['admin', 'abc', 'jack', 'lily']
    >>> names.append("追加第一个")                #追加函数 append，默认追加到最后一个
    >>> names
    ['admin', 'abc', 'jack', 'lily', '追加第一个']
    
    >>> names.append("追加第二个")
    >>> names
    ['admin', 'abc', 'jack', 'lily', '追加第一个', '追加第二个']

追加

2.1.3、插入

![ContractedBlock.gif][] ![ExpandedBlockStart.gif][]

>>> names
    ['admin', 'abc', 'jack', 'lily', '追加第一个', '追加第二个']
    >>> names.insert(1,"我是新来的")                         #在下标1的前面插入一个元素
    >>> names
    ['admin', '我是新来的', 'abc', 'jack', 'lily', '追加第一个', '追加第二个']
    
    >>> names.insert(-1,"我也是新来的")                  #在倒数第一个前面插入一个元素
    >>> names
    ['admin', '我是新来的', 'abc', 'jack', 'lily', '追加第一个', '我也是新来的', '追加第二个']

插入

2.1.4、修改

![ContractedBlock.gif][] ![ExpandedBlockStart.gif][]

>>> names
    ['admin', '我是新来的', 'abc', 'jack', 'lily', '追加第一个', '我也是新来的', '追加第二个']
    
    >>> names[6] = "boy"                  #将下标6的元素改为boy
    >>> names 
    ['admin', '我是新来的', 'abc', 'jack', 'lily', '追加第一个', 'boy', '追加第二个']

修改

2.1.5、删除

![ContractedBlock.gif][] ![ExpandedBlockStart.gif][]

删除可以有三种方法实现
    >>> names
    ['admin', '我是新来的', 'abc', 'jack', 'lily', '追加第一个', 'boy', '追加第二个']
    >>> del names[3]               #删除下标为第3个的元素 ‘蜡jack'
    >>> names
    ['admin', '我是新来的', 'abc', 'lily', '追加第一个', 'boy', '追加第二个']
    
    >>> names
    ['admin', '我是新来的', 'abc', 'lily', '追加第一个', 'boy', '追加第二个']
    >>> names.remove("abc")    #删除指定元素
    >>> names
    ['admin', '我是新来的', 'lily', '追加第一个', 'boy', '追加第二个']
    
    >>> names.pop()                  #删除最后一个元素并将删除元素显示出来
    '追加第二个'
    >>> names
    ['admin', '我是新来的', 'lily', '追加第一个', 'boy']

删除

2.1.6、扩展

![ContractedBlock.gif][] ![ExpandedBlockStart.gif][]

>>> names
    ['admin', '我是新来的', 'lily', '追加第一个', 'boy']
    >>> a = ["123","abc","321"]
    >>> names.extend(a)           #将两个列表扩展成一个列表
    >>> names
    ['admin', '我是新来的', 'lily', '追加第一个', 'boy', '123', 'abc', '321']
    >>> a                                  #列表不会改变
    ['123', 'abc', '321']

扩展

2.1.7、拷贝

![ContractedBlock.gif][] ![ExpandedBlockStart.gif][]

>>> names
    ['admin', '我是新来的', 'lily', '追加第一个', 'boy']
    >>> names_copy = names.copy() 
    >>> names_copy
    ['admin', '我是新来的', 'lily', '追加第一个', 'boy']

拷贝

2.1.8、统计

![ContractedBlock.gif][] ![ExpandedBlockStart.gif][]

>>> names
    ['admin', '我是新来的', 'lily', '追加第一个', 'boy', 'admin', 'admin']
    >>> names.count("admin")     #统计列表中相同元素的个数
    3

统计

2.1.9、排序

![ContractedBlock.gif][] ![ExpandedBlockStart.gif][]

>>> names
    ['admin', '我是新来的', 'lily', '追加第一个', 'boy', 'admin', 'admin', '123', 'abc', '321']
    >>> names.sort()                        #排序
    >>> names
    ['123', '321', 'abc', 'admin', 'admin', 'admin', 'boy', 'lily', '我是新来的', '追加第一个']

排序

2.2.1、翻转

![ContractedBlock.gif][] ![ExpandedBlockStart.gif][]

>>> names
    ['123', '321', 'abc', 'admin', 'admin', 'admin', 'boy', 'lily', '我是新来的', '追加第一个']
    >>> names.reverse()
    >>> names
    ['追加第一个', '我是新来的', 'lily', 'boy', 'admin', 'admin', 'admin', 'abc', '321', '123']

翻转

2.2.2、获取下标

![ContractedBlock.gif][] ![ExpandedBlockStart.gif][]

>>> names
    ['追加第一个', '我是新来的', 'lily', 'boy', 'admin', 'admin', 'admin', 'abc', '321', '123']
    >>> names.index("admin")     #只返回找到的第一个下标
    4

获取下标

**　　**2.2.3、长度获取

![ContractedBlock.gif][] ![ExpandedBlockStart.gif][]

>>> names     
    ['追加第一个', '我是新来的', 'lily', 'boy', 'admin', 'admin', 'admin', 'abc', '321', '123']
    >>> len(names)            #列表中元素的个娄
    10

长度获取

**三、python 字符串函数**

**　　**Python内置的字符串处理函数整理,收集常用的Python 内置的各种字符串处理 函数的使用方法

>>> abc = "Python String Function"           #生成字符串变量
    >>> abc
    'Python String Function'
    >>> len(abc)                 #字符串长度获取，从0开始，包括空格在内
    22
    >>> abc[0]
    'P'
    >>> abc[21]   
    'n'

3.1、字母处理

![ContractedBlock.gif][] ![ExpandedBlockStart.gif][]

>>> abc
    'Python String Function'
    >>> abc.upper()                     #全部大写
    'PYTHON STRING FUNCTION'
    
    >>> abc.lower()                      #全部小写
    'python string function'
           
    >>> abc.swapcase()                #大小写互换
    'pYTHON sTRING fUNCTION'
            
    >>> abc.capitalize()                #首字母大写，其他小写
    'Python string function'
    
    >>> abc.title()                         #首字母大写
    'Python String Function'

字母处理

3.2、格式化相关

![ContractedBlock.gif][] ![ExpandedBlockStart.gif][]

>>> abc
    'Python String Function'
    >>> abc.ljust(30，"*")    #获取固定长度，左对齐，右边不够*补齐,不加*会以空格补齐
    'Python String Function********'
    
    >>> abc.rjust(30)           #获取固定长度，右对齐，左边不够*补齐
    '********Python String Function'
    
    >>> abc.center(30,"*")   #获取固定长度，中间对齐，两边不够用*补齐
    '****Python String Function****'

格式化

3.3、搜索相关

![ContractedBlock.gif][] ![ExpandedBlockStart.gif][]

>>> abc
    'Python String Function'
    >>> abc.find("b")            #搜索指定字符串，没有返回-1
    -1
    
    >>> abc.find("t",3)           #指定起始位置搜索，返回的是第二个t的下标
    8
    
    >>> abc.find("t",1,13)       #指定开始及结束位置搜索，如果找到多个，只返回第一个的下标
    2
    
    >>> abc.rfind("t")             #从右边开始找
    18
    
    >>> abc.count("t")            #指定字符串的个数
    3
    上面所有方法都可用index代替，不同的是使用index查找不到会抛异常，而find返回-1

搜索相关

3.4、替换相关

![ContractedBlock.gif][] ![ExpandedBlockStart.gif][]

>>> abc
    'Python String Function'
    >>> abc.replace("tion","TION")        #将指定字符串替换为大写
    'Python String FuncTION'
    
    >>> abc.replace("t","*",1)               #替换字符串中的第一个t为*
    'Py*hon String Function'

替换

3.5、去空格及去指定字符

![ContractedBlock.gif][] ![ExpandedBlockStart.gif][]

>>> abc.strip()                   #去两边空格    
    'Python String Function'
    
    >>> abc.lstrip()                  #去左边空格
    'Python String Function'
    
    >>> abc.rstrip()                  #去右边空格
    'Python String Function'
    
    >>> abc.strip("n")              #去两边字符串，也有lstrip和rsrtip
    'Python String Functio'

去空格及指定字符串

3.6、判断相关

![ContractedBlock.gif][] ![ExpandedBlockStart.gif][]

>>> abc
    'Python String Function'
    
    >>> abc.startswith("P")        #是否以P开头，是则为True，不是则为False
    True
    
    >>> abc.endswith("n")         #是否以n结尾，是则为True,不是则为False
    True
    
    >>> abc.isalnum()              #是否全为字母或数字，是则为True
    False
    
    >>> abc.isalpha()               #是否全为字母，不是则为False,因为还有空格
    False
    
    >>> abc.isdigit()                #是否全为数字，不是则False
    False
    
    >>> abc.islower()               #是否全小写
    False
    
    >>> abc.isupper()              #是否全大写
    False

判断

**四、元组**

定义：与列表类似，只不过［］改成（）

**特性：**

1.可存放多个值
    2.不可变
    3.按照从左到右的顺序定义元组元素，下标从0开始顺序访问，有序

>>> ages = ("10","20","30","40")
    >>> ages
    ('10', '20', '30', '40')

**注：只有2个方法，一个是count,一个是index**

**五、字典**

定义：｛key1:value1,key2:value2｝,key-value结构，key必须可hash
    字典一种key - value 的数据类型
    语法：

>>> info = {
    ... "stu1":{
        "lily":{
        "age":18,"job":"IT"}},
    ... "stu2":{
        "jack":{
        "age":20,"job":"IT"}},
    ... "stu3":{
        "admin":{
        "age":30,"job":"Driver"}}
    ... }
    >>> info
    {
         'stu2': {
        'jack': {
        'age': 20, 'job': 'IT'}}, 'stu1': {
        'lily': {
        'age': 18, 'job': 'IT'}}, 'stu3': {
        'admin': {
        'age': 30, 'job': 'Driver'}}}

字典的特性：

*  dict是无序的
 *  key必须是唯一的,天生去重

5.1、增加

![ContractedBlock.gif][] ![ExpandedBlockStart.gif][]

>>> info["abc"] = {
         "age":22,"job":"IT"}
    >>> info
    {
          'stu2': {
         'jack': {
         'age': 20, 'job': 'IT'}}, 'stu1': {
         'lily': {
         'age': 18, 'job': 'IT'}}, 'abc': {
         'age': 22, 'job': 'IT'}, 'stu3': {
         'admin': {
         'age': 30, 'job': 'Driver'}}}

增加

5.2、修改

![ContractedBlock.gif][] ![ExpandedBlockStart.gif][]

>>> info["abc"] = "xiaoming"
    >>> info
    {
          'stu2': {
         'jack': {
         'age': 20, 'job': 'IT'}}, 'stu1': {
         'lily': {
         'age': 18, 'job': 'IT'}}, 'abc': 'xiaoming', 'stu3': {
         'admin': {
         'age': 30, 'job': 'Driver'}}}

修改

5.3、删除

![ContractedBlock.gif][] ![ExpandedBlockStart.gif][]

>>> info
    {
          'stu2': {
         'jack': {
         'age': 20, 'job': 'IT'}}, 'stu1': {
         'lily': {
         'age': 18, 'job': 'IT'}}, 'abc': 'xiaoming', 'stu3': {
         'admin': {
         'age': 30, 'job': 'Driver'}}}
    >>> del info["abc"]   
    >>> info
    {
          'stu2': {
         'jack': {
         'age': 20, 'job': 'IT'}}, 'stu1': {
         'lily': {
         'age': 18, 'job': 'IT'}}, 'stu3': {
         'admin': {
         'age': 30, 'job': 'Driver'}}}
    >>> 
    
    
    #另一种方法
    >>> info.pop("stu3")
    {
          'admin': {
         'age': 30, 'job': 'Driver'}}
    >>> info 
    {
          'stu2': {
         'jack': {
         'age': 20, 'job': 'IT'}}, 'stu1': {
         'lily': {
         'age': 18, 'job': 'IT'}}}

删除

5.4、查找

![ContractedBlock.gif][] ![ExpandedBlockStart.gif][]

>>> info
 {
 'stu2': {
 'admin': {
 'age': 30, 'job': 'Driver'}}, 'stu1': {
 'lily': {
 'age': 18, 'job': 'IT'}}, 'stu3': {
 'jack': {
 'age': 20, 'job': 'IT'}}}
 >>> "stu3" in info #显示返回值
 True
 
 >>> info["stu3"] #第二种方法
 {
 'jack': {
 'age': 20, 'job': 'IT'}}
 >>> info["stu4"] #如果没找到会报错
 Traceback (most recent call last):
 File "<stdin>", line 1, in <module>
 KeyError: 'stu4'
 
 >>> info.get("stu3") #第三种方法
 {
 'jack': {
 'age': 20, 'job': 'IT'}}
 >>> info.get("stu4") #没找到不会报错
 >>>

查找

其他方法：

![ContractedBlock.gif][] ![ExpandedBlockStart.gif][]

>>> info.values()
    dict_values([{
          'admin': {
         'age': 30, 'job': 'Driver'}}, {
         'lily': {
         'age': 18, 'job': 'IT'}}, {
         'jack': {
         'age': 20, 'job': 'IT'}}])
    
    
    >>> info.keys()
    dict_keys(['stu2', 'stu1', 'stu3'])
    
    >>> a = {1:2,2:3,"a":"b"}
    >>> info.update(a)
    >>> info    
    {
          'stu1': {
         'lily': {
         'job': 'IT', 'age': 18}}, 1: 2, 2: 3, 'stu2': {
         'jack': {
         'job': 'IT', 'age': 20}}, 'stu3': {
         'admin': {
         'job': 'Driver', 'age': 30}}, 'a': 'b'}
    
    >>> info.items()
    dict_items([('stu1', {
         'lily': {
         'job': 'IT', 'age': 18}}), (1, 2), (2, 3), ('stu2', {
         'jack': {
         'job': 'IT', 'age': 20}}), ('stu3', {
         'admin': {
         'job': 'Driver', 'age': 30}}), ('a', 'b')])

其他方法

循环、、、

![ContractedBlock.gif][] ![ExpandedBlockStart.gif][]

info = {
        "name1":"lily",
        "name2":"admin",
        "name3":"jack",
        "name4":"abc"
    }
    
    for key in info:
        print(key,info[key])
    
     
        name3 jack
        name1 lily
        name2 admin
        name4 abc

循环

**六、集合**

集合是一个无序的，不重复的数据组合，它的主要作用如下：

*  去重，把一个列表变成集合，就自动去重了
 *  关系测试，测试两组数据之前的交集、差集、并集等关系

#### 　　集合常用操作：关系运算 ####

in 
　　not in 
　　＝＝ 
　　 ！＝ 不等于 
　　 <,<= 
　　 >,>= 
　　 |,|=:合集 
　　 &.&=:交集 
　　 －,－=:差集 
　　 ^,^=:对称差分

**　set 的创建：　**

**　　**

>>> L = [1,1,2,4,3]
 >>> t = (2,3,4,6,6,6,7)
 >>> s = {
 1}
 >>> type(s)
 <class 'set'>
 >>> s= set(L)
 >>> s
 {
 1, 2, 3, 4} #从列表到集合
 
 >>> s = set(t) 
 >>> s
 {
 2, 3, 4, 6, 7} #从元组到集合

set 基本函数与操作：

s.add( x ) 将元素 x 添加到集合s中，若重复则不进行任何操作

![ContractedBlock.gif][] ![ExpandedBlockStart.gif][]

>>> s = {1,2,"a"}
    >>> s.add("b")
    >>> s
    {
          1, 2, 'b', 'a'}
    >>> s.add(1)
    >>> s
    {
          1, 2, 'b', 'a'}

add

s.update( x ) 将集合 x 并入原集合s中，x 还可以是列表，元组，字典等，x 可以有多个，用逗号分开

![ContractedBlock.gif][] ![ExpandedBlockStart.gif][]

>>> s
    {
          1, 2, 'b', 'a'}
    >>> s.update({1,3})
    >>> s
    {
          1, 2, 'b', 3, 'a'}
    >>> s.update([1,4])
    >>> s
    {
          1, 2, 'b', 3, 4, 'a'}

update

s.discard( x ）将 x 从集合s中移除，若x不存在，不会引发错误

![ContractedBlock.gif][] ![ExpandedBlockStart.gif][]

>>> s
    {
          1, 2, 'b', 3, 4, 'a'}
    >>> s.discard(1)
    >>> s
    {
          2, 'b', 3, 4, 'a'}
    >>> s.discard(1)
    >>> s
    {
          2, 'b', 3, 4, 'a'}

discard

s.remove( x ) 将 x 从集合s中移除，若x不存在，会引发错误

![ContractedBlock.gif][] ![ExpandedBlockStart.gif][]

>>> s
 {
 2, 'b', 3, 4, 'a'}
 >>> s.remove("a")
 >>> s
 {
 2, 'b', 3, 4}
 >>> s.remove("a")
 Traceback (most recent call last):
 File "<input>", line 1, in <module>
 KeyError: 'a'

remove

s.pop() 随机删除并返回集合s中某个值，注意，因为set是无序的，不支持下标操作，没有所谓的最后一个，pop()移除随机一个元素，这和其他数据结构不同

![ContractedBlock.gif][] ![ExpandedBlockStart.gif][]

>>> s
    {
          2, 'b', 3, 4}
    >>> s.pop()
    2
    >>> s
    {
          'b', 3, 4}

pop

s.clear() 清空

len(s) set支持len操作

>>> s
    {
         'b', 3, 4}
    >>> len(s)
    3

x in s  set同样支持in操作

>>> s
    {
         'b', 3, 4}
    >>> 1 in s
    False
    >>> 3 in s 
    True

s.union( x ) 返回s与集合x的交集，不改变原集合s，x 也可以是列表，元组，字典。

![ContractedBlock.gif][] ![ExpandedBlockStart.gif][]

>>> s1 = {1,2,3}
    >>> s2 = {
         "a","b"}
    >>> s1.union(s2)
    {
          1, 2, 3, 'b', 'a'}
    >>> s1
    {
          1, 2, 3}
    >>> s2
    {
          'b', 'a'}

s.intersection( x ) 返回s与集合x的并集，不改变s， x 也可以是列表，元组，字典。

![ContractedBlock.gif][] ![ExpandedBlockStart.gif][]

>>> s1 = {1,2,3}
    >>> s2 = {2,3,4}
    >>> s1.intersection(s2)
    {
          2, 3}
    >>> s1
    {
          1, 2, 3}

intersection

s.symmetric\_difference( x ) 返回s和集合x的对称差集，即只在其中一个集合中出现的元素，不改变集合s， x 也可以是列表，元组，字典。

![ContractedBlock.gif][] ![ExpandedBlockStart.gif][]

>>> s1
    {
          1, 2, 3}
    >>> s2
    {
          2, 3, 4}
    >>> s1.symmetric_difference(s2)
    {
          1, 4}
    >>> s1
    {
          1, 2, 3}

s.issubset( x ) 判断 集合s 是否是 集合x 子集

s.issuperset( x ） 判断 集合x 是否是集合s的子集

![ContractedBlock.gif][] ![ExpandedBlockStart.gif][]

>>> s1 = {1,2,3}
    >>> s2 = {1,3}
    >>> s2.issubset(s1)
    True
    >>> s1.issubset(s2)
    False
    >>> s1.issuperset(s2)
    True

求交集，并集，差集，对称差集的另一种方法：

![ContractedBlock.gif][] ![ExpandedBlockStart.gif][]

>>> s1 = {1,2,3,"a"}
    >>> s2 = {3,4,"b"}
    >>> s1 & s2          #交集
    {3}
    >>> s1 | s2           #并集
    {1, 2, 3, 'b', 4, 'a'}
    >>> s1 - s2           #差集
    {1, 2, 'a'}
    >>> s1 ^ s2          #对称差集
    {1, 'b', 2, 4, 'a'}

\{ \} 在布尔运算中表示 False，其他均为 True

**七、文件操作**

**对文件操作流程**

1.  打开文件，得到文件句柄并赋值给一个变量
2.  通过句柄对文件进行操作
3.  关闭文件

<table> 
 <tbody> 
 <tr> 
 <th style="border:1px solid #999999;">模式&nbsp;</th> 
 <th style="border:1px solid #999999;">描述</th> 
 </tr> 
 <tr> 
 <td style="border:1px solid #999999;">r</td> 
 <td style="border:1px solid #999999;">打开一个文件为只读。文件指针被放置在文件的开头。这是默认模式。 </td> 
 </tr> 
 <tr> 
 <td style="border:1px solid #999999;">rb</td> 
 <td style="border:1px solid #999999;">打开一个文件只能以二进制格式读取。文件指针被放置在文件的开头。这是默认模式。 </td> 
 </tr> 
 <tr> 
 <td style="border:1px solid #999999;">r+</td> 
 <td style="border:1px solid #999999;">打开用于读和写文件。文件指针置于该文件的开头。 </td> 
 </tr> 
 <tr> 
 <td style="border:1px solid #999999;">rb+</td> 
 <td style="border:1px solid #999999;">打开用于读取和写入二进制格式的文件。文件指针置于该文件的开头。 </td> 
 </tr> 
 <tr> 
 <td style="border:1px solid #999999;">w</td> 
 <td style="border:1px solid #999999;">打开一个文件只写。如果文件存在覆盖该文件。如果该文件不存在，则创建写入新文件。 </td> 
 </tr> 
 <tr> 
 <td style="border:1px solid #999999;">wb</td> 
 <td style="border:1px solid #999999;">打开一个文件只能以二进制格式写入。如果文件存在覆盖该文件。如果该文件不存在，则创建写入新文件。 </td> 
 </tr> 
 <tr> 
 <td style="border:1px solid #999999;">w+</td> 
 <td style="border:1px solid #999999;">打开文件为写入和读取模式。如果文件存在覆盖现有文件。如果该文件不存在，创建用于读写操作的新文件。 </td> 
 </tr> 
 <tr> 
 <td style="border:1px solid #999999;">wb+</td> 
 <td style="border:1px solid #999999;">打开用于以二进制格式写入和读出文件。如果文件存在覆盖现有文件。如果该文件不存在，创建用于读写操作的新文件。 </td> 
 </tr> 
 <tr> 
 <td style="border:1px solid #999999;">a</td> 
 <td style="border:1px solid #999999;">打开用于追加的文件。文件指针是在文件是否存在该文件的末尾。也就是说，该文件是在追加模式。如果该文件不存在，它会创建一个用于写入的新文件。 </td> 
 </tr> 
 <tr> 
 <td style="border:1px solid #999999;">ab</td> 
 <td style="border:1px solid #999999;">打开文件用于二进制格式追加。文件指针是在文件是否存在该文件的末尾。也就是说，文件是在追加模式。&nbsp;如果该文件不存在，它会创建一个用于写入的新文件。 </td> 
 </tr> 
 <tr> 
 <td style="border:1px solid #999999;">a+</td> 
 <td style="border:1px solid #999999;">打开文件为追加和读取方式。文件指针是在文件是否存在该文件的末尾。该文件以追加模式打开。如果该文件不存在，它将创建用于读写操作的新文件。 </td> 
 </tr> 
 <tr> 
 <td style="border:1px solid #999999;">ab+</td> 
 <td style="border:1px solid #999999;">打开一个文件以附加和二进制格式读取模式。如果该文件存在文件指针在该文件的末尾。该文件以追加模式打开。如果该文件不存在，它将创建读写操作的新文件。</td> 
 </tr> 
 </tbody> 
</table>

## 　　file 对象属性 ##

一旦文件被打开，则就会有一个文件对象，你就可以得到有关该文件的各种信息。

这里是一个文件对象相关的所有属性的列表：

属性:

<table style="width:388px;"> 
 <tbody> 
 <tr> 
 <th style="border:1px solid #999999;">&nbsp;</th> 
 <th style="border:1px solid #999999;">描述</th> 
 </tr> 
 <tr> 
 <td style="border:1px solid #999999;text-align:left;">file.closed</td> 
 <td style="border:1px solid #999999;"> 
 <div> 
 如果文件被关闭返回true，否则为false 
 </div> </td> 
 </tr> 
 <tr> 
 <td style="border:1px solid #999999;">file.mode</td> 
 <td style="border:1px solid #999999;"> 
 <div> 
 返回文件打开访问模式 
 </div> </td> 
 </tr> 
 <tr> 
 <td style="border:1px solid #999999;">file.name</td> 
 <td style="border:1px solid #999999;"> 
 <div> 
 返回文件名 
 </div> </td> 
 </tr> 
 </tbody> 
</table>

示例：

1 fo = open("foo.txt","wb")
    2 print("Name of the file:",fo.name)
    3 print("Closed or not :",fo.closed)
    4 print("Opening mode:",fo.mode)
    5 fo.close()

结果：

Name of the file: foo.txt
    Closed or not : False
    Opening mode: wb

## *close()*方法 ##

文件对象的close()方法用于刷新任何未写入的信息，并关闭文件对象， 之后就没有更多的写入东西了。

Python自动关闭文件当参考文件对象分配给另一个文件。使用 close()方法关闭文件一个很好的做法。

fileObject.close();

示例：

fo = open("foo.txt","wb")
    print("Name of the file:",fo.name)
    fo.close()

结果：

Name of the file: foo.txt

读写文件

文件对象提供了一组访问方法。 我们将看到如何使用 read()和write()方法来读取和写入文件。

## write() 方法 ##

write()方法将字符串写入一个打开的文件。要注意，Python的字符串可以是二进制数据，而不仅仅只是文字。

write()方法不添加换行符('\\n')到字符串的结尾-

语法：

fileObject.write(string);

这里，传递的参数是要写入到打开的文件的内容。

### 示例： ###

fo = open("foo.txt","w")
    fo.write("Python is a great language.\n Yeah its great!\n")
    fo.close()

上面的方法将创建 foo.txt 文件，并给出的内容写入文件，最后将关闭该文件。如果打开这个文件，会看到它有以下内容。

Python is a great language.
     Yeah its great!

** read() 方法**

read()方法从一个打开的文件读取字符串。要注意，Python字符串可以是二进制数据。而并非只是文本数据。

### 语法 ###

fileObject.read([count]);

这里，传递的参数是从打开的文件读取的字节数。该方法开始从文件的开始读取，并且如果 *count* 丢失，那么它会尝试尽可能读，也许直到文件的末尾。

### 示例 ###

让我们使用一个文件 foo.txt，这是我们在上面所创建的。

# Open a file
    fo = open("foo.txt", "r+")
    str = fo.read(10)
    print ("Read String is : ", str)
    # Close opened file
    fo.close()

这将产生以下结果 -

Read String is :  Python is

文件位置

tell() 方法告诉你该文件中的当前位置；换句话说，下一个读或写将发生在从该文件的开头之后多个字节。

*seek(offset\[, from\])* 方法改变当前文件的位置。 offset 参数指示要移动字节数。from 参数指定字节从哪移动的参考位置。

如果 from 被设置为0，这意味着使用该文件的开头作为基准位置，以及如果设置为1，则使用当前位置作为基准位置，如果它被设置为2，则该文件的结束将被作为基准位置。

### 示例 ###

让我们使用一个文件foo.txt，这是我们在上面创建的。

# Open a file
    fo = open("foo.txt", "r+")
    str = fo.read(10)
    print ("Read String is : ", str)
    
    # Check current position
    position = fo.tell()
    print ("Current file position : ", position)
    
    # Reposition pointer at the beginning once again
    position = fo.seek(0, 0)
    str = fo.read(10)
    print ("Again read String is : ", str)
    # Close opened file
    fo.close()

这将产生以下结果 -

Read String is :  Python is
    Current file position :  10
    Again read String is :  Python is

重命名和删除文件

Python的os模块提供了执行文件处理操作，如重命名和删除文件的方法。

要使用这个模块，需要先导入它，然后就可以调用任何相关的功能了。

### 八. 字符编码与转码 ###

详细文章:

http://www.cnblogs.com/yuanchenqi/articles/5956943.html

http://www.diveintopython3.net/strings.html

> 需知:
> 
> 1.在python2默认编码是ASCII, python3里默认是utf-8
> 
> 2.unicode 分为 utf-32(占4个字节),utf-16(占两个字节)，utf-8(占1-4个字节)， so utf-8就是unicode
> 
> 3.在py3中encode,在转码的同时还会把string 变成bytes类型，decode在解码的同时还会把bytes变回string
> 
>

转载于:https://www.cnblogs.com/Lily-P/p/5981340.html

[ContractedBlock.gif]: https://images.cnblogs.com/OutliningIndicators/ContractedBlock.gif
[ExpandedBlockStart.gif]: https://images.cnblogs.com/OutliningIndicators/ExpandedBlockStart.gif