python基础之数据类型

一、数据类型之字符串类型及方法

---

　　注：字符串与数值：都是不可变类型，对象创建不会删，只会改指向位置

1.1 字符串的定义

　　1.用" "/' '引起来的数据为字符串，可用做字符串转换'string'

　　2.repr()---表示返回规范的字符串

　　　　b=repr("he is happy Yes")，方便电脑阅读，打印出会带有''

　　3.创建字符串：a='123'--a="123"

　　4.字符串操作：

　　　　字符串切片：str[start:end:step]---开始:结束：步骤

　　　　　　print('helloworld'[2:])--第二个索引之后的所有字母，从第三个l开始

　　　　判断是否包含：in

　　　　　　print('el2' in 'hello')---false/true

　　　　格式化了符串：以一定格式输出 

　　　　　　print('alex is a good teacher')=print('%s is a gool teacher '%'alex')

　　　　　　占位符：%s(字符占位) %d(数值占位) %f(浮点数。约为小数)
　　　　　　msg ='''--多行
　　　　　　　　---info of %s---
　　　　　　　　name:%s
　　　　　　　　age:%s
　　　　　　　　job:%s
　　　　　　　　----end---
　　　　　　　　'''
　　　　　　%(name,age,job)

　　　　　　print(msg)
　　　　　　结果：每个输入后最后会打印msg这个字符串的值

　　　　字符串拼接：

　　　　　　方式一：

　　　　　　　　　　a=123    b=abc   c=a+b print(c)---123abc

　　　　　   方式二：join：列表或元组里的每个元素拼接用' '里的符串拼接起来

　　　　　　　　　　c=''.join([a,b]) ---这个是空字符串用的join方法，print(c)---123abc

　　　　　　　　　　d='---'.join([a,b])-------print(c)   123---abc

　　　　　　

1.2 字符串对象的方法

　　1.count()    st.count('t')---t出现的次数，统计元素个数

　　2.capitalize() st.capitalize()---字符串首字符大写

　　3.center()       st.center(50,'-')--字符串放中间除字符串之外的都用-补充到50，居中-----hello kitty--------

　　4.encode():编码

　　　　二进制-->ASCII(只能存英文与拉丁字符，数字也是ASCII,一个字符占一个字节为8位)-->其它各国出现不同中国GB2312(只能存6700个中文)

　　　　-->gbk1.0（存2万多字符，1995）---gb18020(存2万七千多中文，2000)---国标出现万国码unicode标准(存所有的都占四个字节)[开始实现utf-32一个字符占4个字

　　　　节，后有utf-16:一个字符占2个字符或2个以上，存65535，最后出现utf-8:

　　　　一个英文用ASCII码来存，一个中文占3个字节，其它国用不同字节]---对中国来说程序必须支持gb18030与utf-8,主用uts-8

　　　　　　例：中国开发的支持GBK编码的程序，发行到日本，那日本的JPK识别不了GBK的所以都是乱码，如何解决？

　　　　　　　　中间编码，所有的国家都支持万国码unicode默认为utf-16，程序都可以各国使用，各国把自己的语言转为unicode称为解码decode,

                            其它国把unicode转为本国语言为编码encode,注其它unicode的编码也要转为utf-16,
　　　　
　　　　python2: 默认编码为ASCII，想写中文，要申明中文
　　　　　　s="特点" print(s)会报错，所以要申明，# -*-coding:utf-8 -*- 这时写的就是utf8，这里的utf8要转为utf16，所以要告诉16自己是哪个，不然会认为是Pythonl默认的ASCII

　　　　　　解码：s_to_unicode=s.decode("utf-8"):参数是自己是哪个编码，decode方法是把自己变为unicode这个过程，所以这个结果是unicode的字符了
　　　　　　unicode_to_gbk=s_to_unicode.encode("gbk")----参数是要编码成哪个编码，这二个结果相同不解码也能看到中文，因Unicode会兼容各种语言，所以到unicode想看到的语言都能看到
　　　　python3:默认编码unicode,如何查字符编码
　　　　　　import sys
　　　　　　print(sys.getdefaultencoding())--查看默认编码

　　　　　　如果要用gdk写就申明用gdk # -*-coding:gdk -*-

　　　　　　注：在Python3里在进行编码的同时也会把数据再转成bytes数据类型,解码同时会把byte类型转为字符串

　　5.endswith()：以某内容为结尾，print(st.endswith('tty'))---true,字符串以tty结尾　

　　6*.startswith():以某内容开头，print(st.startswith('he'))---true

　　7.expandtabs():在 之间设几个空格 print(st.expandtabs(tabsize=10))-he lly world

　　8*.find():查找会返回索引值，查找第一个元素，并将索引值返回 print(st.find('t'))---结果为8，

　　9*.format(): print(st.format(name='alex',age=18))---hello kitty alex is 18

　　10.format_map():同format,参数写法不同print(st.format_map({name:'alex',age:18})
　　　　注：格式化二种方式 %：%s----%alex 
　　　　　　方式2 {}

　　11.index():查索引值 print(st.index('z'))----查索引值，没有的会报错，find不会报错

　　12.isalnum():判断字符串是否包含数字或字母 print('abc'.isalnum())--true

　　13.isdecimal():判断是否为一个十进制数

　　14.isdigit():判断字符串是否是一个数字，必须是整型，print('111'.isdigit())

          if salary.isdigit():---salary是不是数值
             salar=int(salary)
          else:
             print("must input digit")

　　15.isidentifier():判断是不是非法变量 print('123abc'.isidentifier())--false变量不能以数字开头

　　16*.islower():判断字符是否为全小写

　　17*.isupper():判断字符是否为全大写

　　18.isspace():判断字符是否是一个空格

　　19.istitle():判断每个单词的首字母是大写 print('My Title'.istitle())--true

　　20.join()

　　21.lower():所有大写变小写，print('My name'.lower())---my name

　　22.upper():所有小写变大写

　　23.swapcase():反转，所有小写变为大，所有大变为小

　　24.ljust()：这个字符只占最左边，其它全为其它，rjust():这个字符只占最右边，center左右都占，print('my name'.ljust(10,'*'))--my name***

　　25.lstrip():将左边的空格与换行符去掉，rstrip():将右边的空格与换行符去掉

　　26**.strip():将开头与结尾的空格及换行符去掉，注处理文件里的文本的每行时用的多，要反正换行符去掉才能会处理print(' my '.strip())--my 光标在本行了，不在下一行，如果不加光标会在下一行

　　27*.replace():替换， print('My title title'.replace('title','lesson',1))---反title替换成lesson一次，如果不写1是全部替换

　　28.rfind():从右向左找的索引，索引还是唯一的那个索引

　　29*.split():以某内容分成列表，字符串转成列表的方式print('my title title'.split('i'))--['my t', 'tle t', 'tle']

　　30.rsplit(' ',#):以某内容分成几次从右开始

　　31.title():按单词首字母为大写的格式写print('my title title'.title())--My Title Title

二、数据类型之数值、布尔型　

---

1.数值

　　int()：整数据

　　float():浮点数

2.布尔型

　　下列值表示false:

　　　　none

　　　　false

　　　　任何表示0的数据类型：0     0.0等

　　　　任何空序列：' '  ()   []----空字符串    空元组   空列表

　　　　任何空映射：{}  # -----空字典   空集合

　　其它为真：True

三、数据类型之列表

---

 3.1 列表定义

　　1.创建列表

　　　　方式一：A=['张三'，'李四']

　　　　方式二：工厂函数A=list([1,2,3])==A=list((1,2,3))--相当于转化所以不管是列表还是元组的格式都转化为列表---list类有如下方法

　　2.查

　　　　print (A[1])       print (A[1:3])

　　3.增：insert与append

　　　　A.append('alex')

　　　　A.insert(2,'alvin')

　　4.改：用赋值操作

　　　　A[1]='test'

　　5.删 remove del pop

　　　　A.remove('alex')

　　　　del A[1]

　　　　del A

　　　　A.pop()--pop有一个返回值，根据索引删除的，不加默认删最后一个

3.2 列表对象的方法　

　　1.count统计某个元素在列表中出现的次数

　　　　A.count('test')--记录哪个值的次数

　　2. extend方法可以在列表的末尾一次性追加另一个序列中的多个值

　　　　a=[1,2]    b=[3,4]   

　　　　a.extend(b)----a被修改

　　3.index:用于从列表中找出某个值第一个匹配项的索引位置

　　　　A.index('张三')--查元素的索引

　　4.reverse将列表中的元素反向存放

　　5.sort:用于在原位置对列表进行排序

　　　　x=[1,3,5,4,2]

　　　　x.sort()---数字排或ACCSI码排

　　6.嵌套：列表里元素能放列表与元组

　　　　c=[[1,2],[3,4]]

　　7.len()--列表个数长度

　　8.判断：In

　　　　 print (123 in [23,45,123])

四、数据类型之元组

---

　　　概述：相当于只读列表，不能修改

　　1.创建：

　　　　方式一：B=(1,3,4)

　　　　方式二：B=tuple([1,2,3])

　　2.对象的方法同列表相同除了修改的方法

　　3.只有二个内建方法 count  index

五、数据类型之字典

---

　　概述：实际是通过第一个值做哈希算法算出内存位置，把第二个值放这个位置，而对列表来说是用索引来定位置，这些位置是有序的，而字典是算出来的是无序的值，所以是无序的

　　特点

　　　　1.无序

　　　　2.键是唯一的，不可修改，因位置是唯一的

1. 创建字典：

　　方式一：

　　　　C={'name':'alex','age':'3','hobby':'girl'}

　　　　print(C)---展示出来的位置不一样了  {'age':'3','name':'alex','hobby':'girl'}

　　方式二：

　　　　用工厂函数创建dict(())

　　　　D=dict((('name','alex'),('age',35)))

　　方式三：

　　　　dic4=dict.fromkeys(['host1','host2','host3'],'test')

　　　　print(dic4)--{'host1':'test','host2':'test','host3':'test'} 

　　注：键必须是不可变类型，所以列表不能做键，但字典本身是可变类型，所以值是可变类型，所以字典里的值可以是列表与字典,键只能是整型字符串等类型而值则可以是字典列表等可变类型　

2.增

　　方式一：给键赋值

　　　　dic1={'name':'alex'}

　　　　dic1['age']=18

　　方式二：setdefault--有就不改保留原值，没有就加这个值，这个方法有返回值的，返回键对应的真实的值

　　　　dic1.setdefault('age',34)

　　　　ret=dic1.setdefault('age',34)

　　　　print(ret)--18

　　　　ret2=dic2.setdefault('hobby','girl')

　　　　print(ret2)---girl

3.查

　　方式一：根据键名去查值

　　　　print(dic1['name'])

　　方式二：查有哪些键

　　　　print(dic1.key())---拿出所有键,是另一个类型，可以用list(dic1.key())转换成列表

　　方式三：查哪些值

　　　　print(list(dic1.values()))

　　方式四：拿键值元素为元组的列表---元组键值对--字典变为列表

　　　　print(list(dic1.items()))---[('name','alex'),('age',34)]

4.改

　　方式一：

　　　  dic1['age']=16

　　方式二

　　　　dic2={'name':'alex'}

　　　　dic3={'hobby','girl'}

　　　　dic2.update(dic3)-把3的合到2里如果有重复更新新的值

5.删

　　方式一：

　　　　del=del dic2['name']---删了一个键值对

　　　　del dic2----删除字典

　　方式二：

　　　　dic2.clear()---清空

　　方式三：pop---给个变量有返回值

　　　　print(dic2.pop('age'))---返回的是删掉的这个值返回回来

　　　　print(dic2.popitem())--随机删除一个键值对

6.其它操作及涉及方法

　　（1）字典嵌套：

　　　　　　E={'欧美'：{'www':['很多','质量']}}

　　　　　　E[欧美]['www'][1]=很好

　　（2）字典排序：默认根据键来排序的

　　　　　　F={5:'444',2:'333'}

　　　　　　print(sorted(F))----[2,5]--或ASCII码排序

　　　　　　print(sorted(F.values()))---根据值排序

　　　　　　print(sorted(F.items()))----把字典变为元组列表

　　（3）字典遍历

　　　　方式一：

　　　　　　for i in dic1:--遍历的是键，键是有序的但值是无序的

　　　　　　　　print(i，dic1[i])---默认打印的是键

　　　　方式二：效率低

　　　　　　for i,v in dic1.items():--变成列表是有序的，这时i,v分别是元组里的二个值

　　　　　　　　print(i,v)

　　　　方式三：get方法

　　　　　　F={5:'444',2:'333'}

　　　　　　data=F.get('5')

　　　　　　print(data)--取对应键的值

7.实例，购物车及三级登录 

     （2）实例1：购物车 test.py
        # __author__-"dandan"--作者
        #date - 2016/08/22 10:10--时间
        //购物车实例：
        //1.商品列表（价格 产品） 2.购买哪个商品input() 3.比较存钱与价格大小
       //列表多属性可用嵌套eg:a=[[1,2],'test',(3,4)]
          
          product_list=[('mac',9000),('kindle',800),('tesla',900000),('python book',105),('bike',2000)]
                  //字符串，输入本金
          saving=input('please input your money:')
                 //购物车
          shoping_car=[]
          if saving.isdigit():  ---saving是数值时才返回true
             saving=int(saving) ---字符串变为整型
             while true:
                             //方式1：
                 for i in product_list:
                      print(product_list.index(i),i)
                       (0,('mac',9000))
                       (1,('kindle',800) )
                       (2,('tesla',900000))
                       (3,('python book',105))
                       (4,('bike',2000))
                 
                  //方法2： 给序列加序号,从1开始
              for i in enumrate(product_list,1):
                   print(i)
                                '''结果：
                (1,('mac',9000))
                    (2,('kindle',800))
                (3,('tesla',900000))
                (4,('python book',105))
                (5,('bike',2000))'''    
                        //方法3：不以元组展示，用二个变量再接受这个元组的值，enumerate(product_list,1)是一个元组(1,('mac',9000))
                      for i,v enumerate(product_list,1):
                print(i,v)
                      ''' 结果
            1 ('mac',9000)---i是1  v是('mac',9000)
                2 ('kindle',800) 
                        3 ('tesla',900000)               
                4 ('python book',105)
                5 ('bike',2000) '''
            a,b=[2,3]二个变量，a=2  b=3---元组 列表 字典都可以
              choice=input('选择购买商品编号[退出：q]：')
              if choice.isdigit():
                  choice=int(choice)
                  if choice>0 and choice<len(product_list);--len列表长度
                     p_item=product_list[choice-1]
                     if p_item[1]<saving:
                        saving-=p_item[1]
                        shoping_car.append(p_item)//新增列表
                     else:
                        print('余额不足，还少%s'%saving)//在少后是saving的值
                     print(p_item)
                     
                  else:
                     print('编码不存在')
                     
              elif choice=='q':
                  print('您已购买如下商品')
                  for i in shopping_car:
                     print (i)
                   print('您还余%s元钱'%saving)
                   break
                  
              else:
                  print('输入错误')
      （3）实例3.三级登录
            用户名密码可以用变量或字典存储，再于用户输入进行比对
             menu={'北京'：{'朝阳'：{'国贸'：{'CCTV':{},'HP':{}},
                                    '望京'：{'陌陌'：{},'360':{}}},
                           '昌平'：{'沙河'：{'老男孩'：{}}，
                                    '天通苑'：{'HB':{}}}}，
            '上海'：{}，
            '山东'：{}}
            实现：一层进一层到所有层:三层循环，break会跳出一个循环，一个个跳
                  可以每层返回上一层
                  可以任意层退出
                  
            back_flay=False---标记位  
            exit_flay=False      
            while not back_flay and not exit_flay：
                for key in menu:
                    print(key)
                choice = input(">>:").strip()
                if choice == "q"
                   exit_flay= True
                if choice in menu:
                  while not back_flay and not exit_flay://#让程序停在第二层
                     for key2 in menu[choice]:
                        print (key2)
                     choice2 = input(">>:").strip()
                     
                     if choice2 == "b"
                         back_flay=True
                     if choice2 == "q"
                        exit_flay= True
                       if key3 in menu[choice]:
                          while not back_flay and not exit_flay:
                             for key3 in menu[choice][choice2]                           
                                 print(key3)
                             choice3 = input(">>:").strip()
                             if choice3 == "b"
                                back_flay=True
                            if choice3 == "q"
                                exit_flay= True
                               if key4 in menu[choice][choice2]
                                  while not back_flay and not exit_flay:
                                    for key4 in menu[choice][choice2][choice3]
                                       print(key4)
                                     choice4 = input(">>:").strip()
                                     if choice4 == "b":
                                        back_flay=True--后若不写back_flay为真，所有循环结束，结束程序了
                                     if choice4 == "q"
                                        exit_flay= True
                                  else:
                                     back_flag=False
                          else:
                            back_flag=False
                   else:
                        back_flag=False
               else:
                back_flag=False    

      方法2：  
         current_layer=menu
         
         parent_list = []:保存所有父级，最后一个元素永远都是父亲级
         while True:
            for key in current_layer:
                print(key)
            choice = input(">>>":).strip()
            if len(choice) == 0:
                continue            
            if choice in current_layer:
               parent_list.append(current_layer)
               current_layer = current_layer[choice]--变为子层
            elif choice == "b"
               current_layer=parent_list.pop()
            
            else:
               print("无此项")                                        

六、数据类型之字节类型

---

1.b = byte = 字节类型 = [0-255]---不同文件数据传输只能是这个数据类型　　

总结：
　　对象：一切都是对象，当对象创建好后，对象有不同类型，不同类型有不同方法，对象类型如下：
　　　　　　如何查看对象内存地址：id(A)---内存地址，print(id(A))
　　　　　　如何查对象是什么类型：type(A)
　　对象的方法是处理对象本身还id type 表示对象自身属性

　　不可变类型：整型 字符串 元组
　　可变类型：列表（指向列表本身的指向没变但指向的这个内存可做为变量分为指向别的地方[0] [1]--指向不同位置，当这些小的内存变了但实际上原指针没变了） 字典

java基本数据类型：

　　boolean:布尔型,表一位信息，只有二个值，true和false boolean one=turn

　　byte:字节型，是8位有符号以二进制补码表整数，范围-128~127,默认值是0，占空间只有int的四分之一，byte a=100,在内存里用二进制表这个数据，用8位来表示-2^7~2^7-1

　　char:字符型,是单一的16位Unicode字符，每16位表一个字符，范围：u0000(0)~uffff(65、535),可存任何字符，char letter='A'

　　double:双精度浮点,64位符合IEEE754标准的浮点数默认0.0d double d1=123.4

　　float：单精度浮点，32位符合IEEE754标准的浮点数默认0.0f float f1=123.5f

　　int：整型，是32位有符号的以二进制补码表整数

　　long：长整型，64位

　　short：短整型,数据类型是16位，有符号的以二进制补码表整数，范围-32768~32767(-2^15~2^15-1),它占int型变量的二分之一，默认为0
申请一个以上的变量时，若不给值打印时会默认上面的默认值

七、数据类型之集合set，深浅拷贝

---

7.1 深浅拷贝,复制列表

　　1.普通拷贝

　　　　s=[1,'alex']

　　　　s2=s.copy()  --这时s与s2是一样的

　　　　s2[0]=3---这时s没变，但s2变了

　　2.浅拷贝

　　　　y=[[1,2],'dan','alvin']

　　　　y3=y.copy()

　　　　print(y3)

　　　　print(y)----y与y3都没变

　　　　y3[0][1]=3

　　　　print(y3)

　　　　print(y)---y与y3都变了y变为[[1,3],'dan','alvin']，原因：y与y3是有关系的这是浅拷贝

　　　　　　y指向

　　　　　　　　内存为88 - [1,2]列表为可变类型又分为二个内存为102[0] 107[1] 

　　　　　　　　内存为89 - dan  

　　　　　　　　内存为90 - alvin

　　　　　　 y3实际指的是

　　　　　　　　 内存为88 - [1,2]所以当[1]变了是88这个内存指向变了，但88本身没变，所以y看到的88，88看到的就变为新的了 

　　　　　　　　内存为89 - dan  

　　　　　　　　内存为90 - alvin

　　3.浅拷贝

　　　　a=[1,2,3]

　　　　b=a

　　　　这时a=[2,2,3]

　　　　b=[2,2,3]---一样的原因，b指向a的全部，所以a里面变了之后b也会变，b的指一个整的

　　　　总结：修改字符等不会变，但修改列表与字典二个都会变

　　4.一个专门的copy模块用于拷贝

　　　　import copy

　　　　c=['dan',123,[10,19]]

　　　　d=copy.copy(c)---同上copy,浅拷贝

　　　　e=copy.deepcopy(c)--深拷贝

　　　　c[0]='xiong'

　　　　c[1]=666

7.2  集合set　

　　概述：也是一种数据类型--用于去重，但是无序的。必须是一组可哈希的里面是不可变类型，里面的元素不可以是列表与字典，可哈希的是不可变的类型

　　1.创建集合:只有一种

　　　　S=set('序列')---可以是'' ()  []

　　　　eg:S=set('it is') print(s)--{'i','t',' ','s'}---有重复的就不显示，去重

　　　　　　S1=set(['alvin','ee','alvin'])---结果：S2={'alvin','ee'}

　　　　　　print(type(S2))---结果：set ，做成列表  S3=list(S1)

　　　　注：set()--里必须是不可变的，列表与字典就不可以里面可以是列表，但第二层不可是列表与字典
　　　　li=([1,2],4,5)

　　　　li2=set(li)---会报错，因第一个是可变的列表，不可哈希

　　2.取值：由于集合是无序的并无重复的，不能为集合创建索引与切片，所以如果取值只有二种办法用for循环遍历或迭代器循环或in not in来访问或判断集合元素

　　　　print(2 in li)---返回true/flase

　　　　for i in li:

　　3.分类

　　　  可变集合（set常用）：可添加和删除元素，非可哈希的不能用作字典的键，也不能做其他集合的元素

　　　　　　set('t')---t是可哈希的但set('t')本身是不可哈希的，元素是不可变类型但集合本身是可变类型

　　　　　　li=([1,2],4,5)

　　　　　　li2=set(li)

　　　　　　A={li2:'123'}---会报错，字典的键必须是可哈希的不可变的，所以列表 字典与集合都不能做字典的键

　　　　不可变集合(frozenset())：与可变集合正好相反

　　4.对象方法

　　　　新增：

　　　　　　li.add('uu') 加一个uu,加了一个整体

　　　　更新：

　　　　　　S2.update('ops')--{'alvin','o','ee','s','p'}---当一个序列更新进去

　　　　删除值：

　　　　　　S2.remove('alvin')

　　　　　　S2.pop()---随机删除一个

　　　　删除集合

　　　　　　S2.clear()

　　　　　　del S2

　　5.集合操作符

　　　　1. in   not in

　　　　2.等价与不等价 ==   !=

　　　　　　　print(set('alex')==set('aalelexx'))---true  最终都是a l e x

　　　　　　　是否包含>  <  <=  >=

　　　　　　　print(set('alex')<set('alexww'))--true　

　　　　3.联合union()：与集合的or操作是等价的

　　　　　　a=set([1,2,3,4,5])

　　　　　　b=set([4,5,6,7,8])

　　　　　　a.interserction(b)=a & b---交集 and--4,5//相等的

　　　　　　a.union(b)=a | b---并集 |--1 2 3 4 5 6  7 8//合起来去重

　　　　　　a.difference(b)=a - b---差集--a里有但b里没有的，1,2,3    b.difference(a)=b-a---差集---6,7,8

　　　　　　

　　　　　　a.symmetric_differnce(b)=a ^ b---对称差集，除了相同的全取出来1，2，3，6，7，8

　　　　　　a.issuperset(b)=a > b---父集--a是否包含b  false

　　　　　　a.issubset(b)=a < b---子集--是否是子集  false

　　总结：列表去重变为集合就行，字符串去重也是变为集合就行

八、文件操作（增 删 查 改）

---

8.1 文件处理

　　概述：文件打开后就会有一个光标指向第一个位置，打开后的操作是引起光标变化的，上一个操作完下一个操作就从上个光标的位置开始。查看光标的位置文件对象f   print(f.tell())--不同操作后可以用它来查光标的位置。文件本身也是对象，也有很多内建方法。

　　1.读文件及关闭对象

　　　　拿出这个文件的对象来调用方法操作：open('文本路径'，读写模式等，编码)

　　　　打开文件方法open('文本路径'，读写模式等，编码):data=open('/mnt/小重山','r',encoding='utf8').read()---open是拿出对象，才可调用方法

　　　　　　print(data)--打印这个文件的内容

　　　　f=open('/mnt/小重山','r',encoding='utf8')--对象

　　　　f.read()---读出对象，read有参数

　　　　f.read(5)--一个字符，Python3一个字符一个中文，所以是打出5个字

　　　　f.write()---报错不能写

　　　　f.close()---关闭对象，找开后一定要关掉　

　　2. 操作文件对象，变为写模式　

　　　　g=open('/mnt/小重山','w',encoding='utf8')--是不可读的

　　　　g.read()---报错

　　　　g.write('hello world')---把文件里的内空清掉再写

　　　　g.write()----也会把文件清掉，如果没有这个文件就创建这个文件

　　　　g.write('alex')---这时会写成hello worldalex,这个不会覆盖，写一个存一个

　　　　　　工作原理：在内存里的页会一个一个去写不会有空格与换行符，写一个指针会向下移一下，下次写从指针的位置开始

　　　　g.write('hello world ')

　　　　g.write('alex')-----hello world    alex

　　3.文件描述符

　　　　print(f.fileno())---一个文件对象都有一个不同的文件描述符

　　4.文件里添加内容，加模式

　　　　r=open('/mnt/小重山','a',encoding='uft8')--追加内容,append模式

　　　　pring(r.write(' hello world '))

　　5.读写模式

　　　　r+:读写模式，在文档最后开始写

　　　　　　f=open('小重山'，'r+',encoding='utf8')

　　　　　　f.write('test')---结果：写到文件最后的位置，读的光标与写的光标指的位置是不同的

　　　　w+:写读模式

　　　　　　f=open('小重山'，'w+',encoding='utf8')--先清空，写了再读还是没有只能看到最后一次写的

　　　　a+:加读模式

　　　　　　f=open('小重山'，'w+',encoding='utf8')

　　6.修改某处文件，改原文件

　　　　1.给第二行后加个字符串

　　　　　　f=open('小重山'，'r+',encoding='utf8')-可读可写

　　　　　　number=0

　　　　　　for line in f:

　　　　　　　　number+=1

　　　　　　　　if number=6:---光标在第六行了，read时的位置，但这时要写不能用write,它会自动跑到最后去写

　　　　　　　　所以直接修改不了文件

　　　　2.只能把数据一行一行取出来存到另一个文件来替换

　　　　　　f=open('小重山'，'r',encoding='utf8')

　　　　　　g=open('小重山1'，'w',encoding='utf8')

　　　　　　number=0

　　　　　　for i in f:

　　　　　　　　number+=1

　　　　　　　　if number==5:

　　　　　　　　　　i='hello wrodle ' 

　　　　　　　　g.write(i)--不满足条件要做的,严格用对齐的方法来执行的

　　7.with语句可同时管理多个文件对象（若忘关了文件就引入with）---主用这个就不用关闭文件了

　　　　with open('log','r') as f:

　　　　f.read()----缩进的是属于with代码块的与它一平的是不属于的---with完后会自动反正文件关掉

　　　　eg: with open('小重山'，'r',encoding='utf8') as f, open('小重山1'，'w',encoding='utf8') as g：

　　　　　　for i in f:

　　　　　　　f.write(i)

8.2 文件对象的方法

　　1.按行拿readline(),从1行取，默认取一行

　　　　f=open('/mnt/小重山','r',encoding='utf8' )

　　　　print(f.readline())--展示第一行，光标到第一行后面

　　　　print(f.readline())--只展示第二行

　　
　　2.多行打印readlines()---默认所有行，打印出来结果是每行及换行符组成的列表
　　　　['昨夜蛩不住鸣。 ','回千里梦，已三更。 ']

　　　　for i in f.readlines():

　　　　　print(i)--结果每行之间有空格，print默认会换行，i里有 会识别再换一行

　　　　　print(i.strip())---行之间没有空格了　
                 eg:第二行后加个字符串
                     number=0------变量里记录循环次数，i是列表里的值
                     for i in f.readlines():
                     number+=1
                     if number=2:
                          print(i.strip()+'ikeit')--字符串相加
                     else:
                          print(i.strip())
                          f.close()
               法2：
                      number=0
                      for i in f.readlines():
                      number+=1
                     if number==6:
                     i=''.join((i.strip(),'ikeit'))---里面是元组或列表里的元素都可以拼接起来
                     print(i.strip())
                       注：以上的readlines把文件的所有行都读到内存里，如果文件很大有10G，那内存都占完了不实用，用如下的方式
　　3.迭代器（内存里只存迭代器，用一个拿一个）

　　　　for i in f:---文本做成了迭代器，迭代器占用了内存但，文本内容还是磁盘上，i用一个就从磁盘加载一个，不用全部内部加载内存

　　　　（for循环内部把对象做成了迭代器把磁盘里的f通过对应该关系做成迭代器放在内存，以行为单位用一行让迭代器对应取一个，用一个取一个）f是对象不是序列
print(i.strip())---打印所有的文件，第一行打印完后就没有了，第一行就不再内存里了,一般用这个方法来处理文件

　　4.光标位置tell()---一个英语占一个字符，一个中文占三个字符，所以tell()--它的个数与read读的数是不一样的
　　　　f.tell()
　　5.调光标的方法seek()---比如光标在第三个位置，又想从头看
　　　　f.seek(0)---光标到0了
　　6.同步磁盘flush()--把内存与缓存里的数据立刻存到磁盘里
　　　　f=open('hello','w','encoding'='utf8')
　　　　f.write('alex is 35')----写进去后没写到磁盘文件里
　　　　f.flush()---再对应的目录里的这个文件及数据就有了
　　　　例：做进度条
　　　　　　终端输出用到模块sys里的方法stdout的write(注sys.stdout这个终端也是个文件对象)
　　　　　　import sys,time
　　　　　　for i in range(10):
　　　　　　　　sys.stdout.write(*)--直接终端上写内容调用的模块，结果打印出10个*,这时i相当于循环10次打印10次
　　　　　　　　sys.stdout.flush()---把终端进行每次flush()操作
　　　　　　　　time.sleep(0.2)---0.2*10=2s看到10个*一起出来，它是一个一个都存完了才写到磁盘上的，要想0.2看一次就要之前加个flush
　　　　　　　　　　　　　　　　这时就会放在缓存区同步完就会打印，一点点显示，这就可以做成进度条

　　7.清空truncate() --打开格式是a时才能用

　　　　f.truncate()---默认很光标最开始的位置向后截断，光标之前的留下

　　　　f.truncate(5)---从第5个字符向后全删了只留前四个

　　8.文件描述符 fileno()--唯一表示一个对象

　　9.isatty()--判断是否是一个终端设备，返回true/flase

　　10.readable()--判断是否可读