python基础之day2

python基本数据类型

1、数字

• int(整型)

     在32位机器上，整数的位数为32位，取值范围为-2**31～2**31-1，即-2147483648～2147483647
　  在64位系统上，整数的位数为64位，取值范围为-2**63～2**63-1，即-9223372036854775808～9223372036854775807

• float(浮点型)

    浮点数也就是小数,按照科学记数法表示时，一个浮点数的小数点位置是可变的，比如，1.23x109和12.3x108是完全相等的,对于很大或很小的浮点数,用10用e替代，1.23x109 就是1.23e9，或者12.3e8，               0.000012可以写成1.2e-5，等

2、布尔型

布尔值和布尔代数的表示完全一致，一个布尔值只有True、False两种值，也可以用0和1来表示。

布尔值可以用and、or和not运算。

 1）and运算是与运算，只有所有都为True，and运算结果才是True：

 >>> True and True
 True
 >>> True and False
 False
 >>> False and False
 False
 >>> 5 > 3 and 3 > 1
 True

and 运算 

 2）or运算是或运算，只要其中有一个为True，or运算结果就是True：

Or 运算

 

 3）not运算是非运算，它是一个单目运算符，把True变成False，False变成True：

 >>> not True
 False
 >>> not False
 True
 >>> not 1 > 2
 True

not 运算

布尔值经常用在条件判断中，比如：

 if age >= 18:
     print('adult')
 else:
     print('teenager')

boolean

 

3、空值

    空值是Python里一个特殊的值，用None表示。None不能理解为0，因为0是有意义的，而None是一个特殊的空值。

4、字符串

字符串是以单引号'或双引号"括起来的任意文本，比如'abc'，"xyz"等等

由于Python的字符串类型是str，在内存中以Unicode表示，一个字符对应若干个字节。如果要在网络上传输，或者保存到磁盘上，就需要把str变为以字节为单位的bytes。

Python对bytes类型的数据用带b前缀的单引号或双引号表示： x = b'ABC'

要注意区分'ABC'和b'ABC'，前者是str，后者虽然内容显示得和前者一样，但bytes的每个字符都只占用一个字节。以Unicode表示的str通过encode()方法可以编码为指定的bytes，例如：

>>> 'ABC'.encode('ascii')
b'ABC'
>>> '中文'.encode('utf-8')
b'\xe4\xb8\xad\xe6\x96\x87'
>>> '中文'.encode('ascii')
Traceback (most recent call last):
  File "<stdin>", line 1, in <module>
UnicodeEncodeError: 'ascii' codec can't encode characters in position 0-1: ordinal not in range(128)

纯英文的str可以用ASCII编码为bytes，内容是一样的，含有中文的str可以用UTF-8编码为bytes。含有中文的str无法用ASCII编码，因为中文编码的范围超过了ASCII编码的范围，Python会报错。

在bytes中，无法显示为ASCII字符的字节，用\x##显示。

反过来，如果我们从网络或磁盘上读取了字节流，那么读到的数据就是bytes。要把bytes变为str，就需要用decode()方法：

>>> b'ABC'.decode('ascii')
'ABC'
>>> b'\xe4\xb8\xad\xe6\x96\x87'.decode('utf-8')
'中文'

　　

对字符串的操作 

  字符串常用功能：

• 移除空白
• 分割
• 长度
• 索引
• 切片

字符串格式化

Python的字符串格式化有两种方式: 百分号方式、format方式

1.百分号方式

  %[(name)][flags][width].[precision]typecode 

• (name)      可选，用于选择指定的key
• flags          可选，可供选择的值有:
  • +       右对齐；正数前加正好，负数前加负号；
  • -        左对齐；正数前无符号，负数前加负号；
  • 空格    右对齐；正数前加空格，负数前加负号；
  • 0        右对齐；正数前无符号，负数前加负号；用0填充空白处
• width         可选，占有宽度
• .precision   可选，小数点后保留的位数
• typecode    必选
  • s，获取传入对象的__str__方法的返回值，并将其格式化到指定位置
  • r，获取传入对象的__repr__方法的返回值，并将其格式化到指定位置
  • c，整数：将数字转换成其unicode对应的值，10进制范围为 0 <= i <= 1114111（py27则只支持0-255）；字符：将字符添加到指定位置
  • o，将整数转换成 八  进制表示，并将其格式化到指定位置
  • x，将整数转换成十六进制表示，并将其格式化到指定位置
  • d，将整数、浮点数转换成 十 进制表示，并将其格式化到指定位置
  • e，将整数、浮点数转换成科学计数法，并将其格式化到指定位置（小写e）
  • E，将整数、浮点数转换成科学计数法，并将其格式化到指定位置（大写E）
  • f， 将整数、浮点数转换成浮点数表示，并将其格式化到指定位置（默认保留小数点后6位）
  • F，同上
  • g，自动调整将整数、浮点数转换成 浮点型或科学计数法表示（超过6位数用科学计数法），并将其格式化到指定位置（如果是科学计数则是e；）
  • G，自动调整将整数、浮点数转换成 浮点型或科学计数法表示（超过6位数用科学计数法），并将其格式化到指定位置（如果是科学计数则是E；）
  • %，当字符串中存在格式化标志时，需要用 %%表示一个百分号

注：Python中百分号格式化是不存在自动将整数转换成二进制表示的方式

常见的用法

s = 'dbb %'
print (s)
 
s1 = 'dbb %s %%'%('derby')
print(s1)
 
s3 = 'name:%s age:%d'%('dbb',18)
print(s3)
 
>>> dbb %
>>> dbb derby %
>>> name:dbb age:18

>>>s = 'Info: %(name)-10s %(age)d salary:%(p).2f'%{'name':'dbb','age':18,'p':1.237334}
 
>>>print (s)
>>>Info: dbb        18 salary:1.24

 2.format 方式

  [[fill]align][sign][#][0][width][,][.precision][type] 

• fill           【可选】空白处填充的字符
• align        【可选】对齐方式（需配合width使用）
• <，内容左对齐
• >，内容右对齐(默认)
• ＝，内容右对齐，将符号放置在填充字符的左侧，且只对数字类型有效。 即使：符号+填充物+数字
• ^，内容居中
• sign         【可选】有无符号数字
  • +，正号加正，负号加负；
  •  -，正号不变，负号加负；
  • 空格 ，正号空格，负号加负；
• #            【可选】对于二进制、八进制、十六进制，如果加上#，会显示 0b/0o/0x，否则不显示
• ，            【可选】为数字添加分隔符，如：1,000,000
• width       【可选】格式化位所占宽度
• .precision 【可选】小数位保留精度
• type         【可选】格式化类型
  • 传入” 字符串类型 “的参数
    • s，格式化字符串类型数据
    • 空白，未指定类型，则默认是None，同s
  • 传入“ 整数类型 ”的参数
    
    • b，将10进制整数自动转换成2进制表示然后格式化
    • c，将10进制整数自动转换为其对应的unicode字符
    • d，十进制整数
    • o，将10进制整数自动转换成8进制表示然后格式化；
    • x，将10进制整数自动转换成16进制表示然后格式化（小写x）
    • X，将10进制整数自动转换成16进制表示然后格式化（大写X）
  • 传入“ 浮点型或小数类型 ”的参数
    • e， 转换为科学计数法（小写e）表示，然后格式化；
    • E， 转换为科学计数法（大写E）表示，然后格式化;
    • f ， 转换为浮点型（默认小数点后保留6位）表示，然后格式化；
    • F， 转换为浮点型（默认小数点后保留6位）表示，然后格式化；
    • g， 自动在e和f中切换
    • G， 自动在E和F中切换
    • %，显示百分比（默认显示小数点后6位）

常见用法 

s1 = 'dengbinbin-{0}-a234-{0}-3-{1}'.format('derby',18)
s2 = '---{name:s}===={age:d}----{name:s}'.format(name='derby',age=18)
print(s1)
print(s2)
 
>>> dengbinbin-derby-a234-derby-3-18
 
>>> ---derby====18----derby

s1 = "-----{:2^20}-----{:+d}==={:#b}".format('derby',123,10)
print (s1)
 
s2 = 'adsd {:%}'.format(1.2323343)
s3 = 'adsd {:.3%}'.format(1.2323343)
print(s2)
print(s3)
 
>>>-----2222222derby22222222-----+123===0b1010
>>>adsd 123.233430%
>>>adsd 123.233%

 >>> tpl = "i am {}, age {}, {}".format("seven", 18, 'alex')
 >>> print(tpl)
 i am seven, age 18, alex
 
 >>> tpl = "i am {}, age {}, {}".format(*["seven", 18, 'alex'])
 >>> print(tpl)
 i am seven, age 18, alex
 
 >>> tpl = "i am {0}, age {1}, really {0}".format("seven", 18)
 >>> print(tpl)
 i am seven, age 18, really seven
 
 >>> tpl = "i am {0}, age {1}, really {0}".format(*["seven", 18])
 >>> print(tpl)
 i am seven, age 18, really seven
 
 >>> tpl =  'i am {name},age{age},really{name}'.format(**{'name':'derby','age':18})
 >>> print(tpl)
 i am derby,age18,reallyderby
 >>>
 >>> tpl = "numbers: {:b},{:o},{:d},{:x},{:X}, {:%}".format(15, 15, 15, 15, 15, 15.87623, 2)
 >>> print(tpl)
 numbers: 1111,17,15,f,F, 1587.623000%
 >>> tpl = "numbers: {0:b},{0:o},{0:d},{0:x},{0:X}, {0:%}".format(15)
 >>> print(tpl)
 numbers: 1111,17,15,f,F, 1500.000000%
 >>> tpl = "numbers: {num:b},{num:o},{num:d},{num:x},{num:X}, {num:%}".format(num=15)
 >>> print(tpl)
 numbers: 1111,17,15,f,F, 1500.000000%
 >>> 

更多用法

　

5.列表　

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

# 定义列表
name=["zhangshan","lisi","wangwu","Derby"]
 
#通过下标访问列表中的元素，下标从0开始计数
 
>>> names[0]
'zhangshan'
 
>>> names[-1]     #还可以倒着取
'Derby'

　对列表的操作

 >>> name = ["zhangshan",'lisi','lily','derby']
 >>> name[1:3]  #取下标1至下标3之间的数字，包括1，不包括3
 ['lisi', 'lily']
 >>> name[1:-1]  #取下标1至-1的值，不包括-1
 ['lisi', 'lily']
 >>> name[:2]     #如果是从头开始取，0可以忽略，跟上句效果一样
 ['zhangshan', 'lisi']
 >>> name[1:]     #如果想取最后一个，必须不能写-1，只能这么写
 ['lisi', 'lily', 'derby']
 >>> name[::2]    #后面的2是代表步长，每隔2个元素，就一个
 ['zhangshan', 'lily']

切片:取多个元素　

 >>> name
 ['zhangshan', 'lisi', 'lily', 'derby']
 >>> name.append('newcomer')   #默认都是追加到最后
 >>> name
 ['zhangshan', 'lisi', 'lily', 'derby', 'newcomer']
 >>> name.insert(3,'wangwu')     #在第三个元素前面插入wangwu
 >>> name
 ['zhangshan', 'lisi', 'lily', 'wangwu', 'derby', 'newcomer']

追加和插入

 >>> name
 ['zhangshan', 'lisi', 'lily', 'wangwu', 'derby', 'newcomer']
 >>> name[1]="李四"      #lisi改成中文
 >>> name
 ['zhangshan', '李四', 'lily', 'wangwu', 'derby', 'newcomer']
 >>> del name[1]          #常用的删除方法
 >>> name
 ['zhangshan', 'lily', 'wangwu', 'derby', 'newcomer']
 >>> name.remove("lily")     #删除指定的元素
 >>> name
 ['zhangshan', 'wangwu', 'derby', 'newcomer']
 >>> name.pop()              #删除最后一个元素
 'newcomer'
 >>> name
 ['zhangshan', 'wangwu', 'derby']

修改和删除

 >>> name
 ['zhangshan', 'wangwu', 'derby']
 >>>
 >>> b = [1,2,3]
 >>> name.extend(b)
 >>> name
 ['zhangshan', 'wangwu', 'derby', 1, 2, 3]
 >>> name1=name.copy()
 >>> name1
 ['zhangshan', 'wangwu', 'derby', 1, 2, 3]
 >>> 

扩展和拷

 >>> name
 ['zhangshan', 'wangwu', 'derby', 1, 2, 3]
 >>> name.sort()             #Python3已经不支持不同数据类型排序2 OK
 Traceback (most recent call last):
   File "<pyshell#48>", line 1, in <module>
     name.sort()
 TypeError: unorderable types: int() < str()
 >>> name.reverse()       #反转
 >>> name
 [3, 2, 1, 'derby', 'wangwu', 'zhangshan']
 >>> name.append("derby")
 >>> name
 [3, 2, 1, 'derby', 'wangwu', 'zhangshan', 'derby']
 >>> name.index('derby')   #只返回找到的第一个下标
 3

排序，反转和获取下标

6.元组

元组其实跟列表差不多，也是存一组数，只不是它一旦创建，便不能再修改，所以又叫只读列表

语法

>>> name = ("zhangshan","derby","wangwu")
>>> name
('zhangshan', 'derby', 'wangwu')

只用2个方法，一个是count,一个是index。

7.字典

字典一种key - value 的数据类型，使用就像我们上学用的字典，通过笔划、字母来查对应页的详细内容。

创建字典：

person = {"name": "cangjingkong", 'age': 18}

字典的特性：

• 字典是无序的
• key必须唯一，因此天生去重

  字典的操作

#字典之基本操作
 
#增加
>>> nameinfo
{'age': 18, 'name': 'cangjingkong'}
>>> nameinfo["name1"]="wutenglan"
>>> nameinfo
{'age': 18, 'name': 'cangjingkong', 'name1': 'wutenglan'}
 
#修改
>>> nameinfo["name"]="苍井空"
>>> nameinfo
{'age': 18, 'name': '苍井空', 'name1': 'wutenglan'}
 
#删除
>>> nameinfo
{'age': 18, 'name': '苍井空', 'name1': 'wutenglan'}
>>> nameinfo.pop("age")     #标准删除
18
>>> nameinfo
{'name': '苍井空', 'name1': 'wutenglan'}
>>> del nameinfo["name"]   #其他方法删除
>>> nameinfo
{'name1': 'wutenglan'}
>>> nameinfo["name3"]="mariya"
>>> nameinfo
{'name3': 'mariya', 'name1': 'wutenglan'}
>>> nameinfo.popitem()       #随机删除
('name3', 'mariya')
 
#查找
>>> nameinfo
{'age': 18, 'name': 'cangjingkong', 'name1': 'wutenglan'}
>>> "age" in nameinfo           #标准用法
True
>>> nameinfo.get("name")    #get方法，不存在返回None
'cangjingkong' 
 
>>> nameinfo['name']       #同上但是，不存在会报错
'cangjingkong'

　

 #  update 功能覆盖之前字典里的key-value, 即之前字典没有key的会添加，之前字典有的key
 
 >>> CityDict
 {'上海': {'徐汇区': ['复旦大学'], '杨浦区': ['魔都科技', '外滩小酒馆', '大上海歌舞厅'], '闵行区': ['东方明珠塔']}, '北京': {'海定区': ['百度科技', '京东商城'], '昌平区': ['老男孩教育', '其他培训机构'], '东城区': ['天朝天安门', '天朝北站']}, '广东': {'广州': ['天河区', '越秀区', '海珠区'], '深圳': ['罗湖', '南山', '福田']}}
 
 >>> dict2 = {'name':'国家','上海':{'徐汇区':['同济大学']}}
 >>> dict2
 {'name': '国家', '上海': {'徐汇区': ['同济大学']}}
 >>> CityDict.update(dict2)
 >>> print(CityDict)
 {'name': '国家', '上海': {'徐汇区': ['同济大学']}, '北京': {'海定区': ['百度科技', '京东商城'], '昌平区': ['老男孩教育', '其他培训机构'], '东城区': ['天朝天安门', '天朝北站']}, '广东': {'广州': ['天河区', '越秀区', '海珠区'], '深圳': ['罗湖', '南山', '福田']}}
 
 >>> dictw= {'北京': {'东城区': ['只有帝都天朝']}}
 >>> CityDict.update(dictw)
 >>> CityDict
 {'name': '国家', '上海': {'徐汇区': ['同济大学']}, '北京': {'东城区': ['只有帝都天朝']}, '广东': {'广州': ['天河区', '越秀区', '海珠区'], '深圳': ['罗湖', '南山', '福田']}}
 
 #获取 key 和 values
 
 >>> CityDict.values()  #获取values
 dict_values(['国家', {'徐汇区': ['同济大学']}, {'东城区': ['只有帝都天朝']}, {'广州': ['天河区', '越秀区', '海珠区'], '深圳': ['罗湖', '南山', '福田']}])
 >>> CityDict.keys()    #获取keys
 dict_keys(['name', '上海', '北京', '广东'])
 
 #判断 字典里是否存在相应的key
 
 >>> '上海'  in  CityDict
 True
 
 # 添加默认值
 >>> CityDict.setdefault('江西',{'南昌':['九江','新余']})
 {'南昌': ['九江', '新余']}
 >>> CityDict
 {'name': '国家', '江西': {'南昌': ['九江', '新余']}, '上海': {'徐汇区': ['同济大学']}, '北京': {'东城区': ['只有帝都天朝']}, '广东': {'广州': ['天河区', '越秀区', '海珠区'], '深圳': ['罗湖', '南山', '福田']}}

字典之更多操作

　嵌套字典

 av_catalog = {
     "欧美":{
         "www.youporn.com": ["很多免费的,世界最大的","质量一般"],
         "www.pornhub.com": ["很多免费的,也很大","质量比yourporn高点"],
         "letmedothistoyou.com": ["多是自拍,高质量图片很多","资源不多,更新慢"],
         "x-art.com":["质量很高,真的很高","全部收费,屌比请绕过"]
     },
     "日韩":{
         "tokyo-hot":["质量怎样不清楚,个人已经不喜欢日韩范了","听说是收费的"]
     },
     "大陆":{
         "":["全部免费,真好,好人一生平安","服务器在国外,慢"]
     }
 }
 
 av_catalog["大陆"][""][1] += ",可以用爬虫爬下来"
 print(av_catalog["大陆"][""])
 #ouput
 ['全部免费,真好,好人一生平安', '服务器在国外,慢,可以用爬虫爬下来']

字典嵌套

    其他方式

 #values
 >>> info.values()
 dict_values(['LongZe Luola', 'XiaoZe Maliya'])
 
 #keys
 >>> info.keys()
 dict_keys(['stu1102', 'stu1103'])
 
 #setdefault
 >>> info.setdefault("stu1106","Alex")
 'Alex'
 >>> info
 {'stu1102': 'LongZe Luola', 'stu1103': 'XiaoZe Maliya', 'stu1106': 'Alex'}
 >>> info.setdefault("stu1102","龙泽萝拉")
 'LongZe Luola'
 >>> info
 {'stu1102': 'LongZe Luola', 'stu1103': 'XiaoZe Maliya', 'stu1106': 'Alex'}
 
 #update
 >>> info
 {'stu1102': 'LongZe Luola', 'stu1103': 'XiaoZe Maliya', 'stu1106': 'Alex'}
 >>> b = {1:2,3:4, "stu1102":"龙泽萝拉"}
 >>> info.update(b)
 >>> info
 {'stu1102': '龙泽萝拉', 1: 2, 3: 4, 'stu1103': 'XiaoZe Maliya', 'stu1106': 'Alex'}
 
 #items
 info.items()
 dict_items([('stu1102', '龙泽萝拉'), (1, 2), (3, 4), ('stu1103', 'XiaoZe Maliya'), ('stu1106', 'Alex')])
 
 #通过一个列表生成默认dict,有个没办法解释的坑，少用吧这个
 >>> dict.fromkeys([1,2,3],'testd')
 {1: 'testd', 2: 'testd', 3: 'testd'}

其他的用法

dict循环

 #方法1
 for key in info:
     print(key,info[key])
 
 #方法2
 for k,v in info.items(): #会先把dict转成list,数据里大时莫用
     print(k,v)

8.set (集合)

set和dict类似，也是一组key的集合，但不存储value。由于key不能重复，所以，在set中，没有重复的key。

要创建一个set，需要提供一个list作为输入集合：

#创建方式
 
>>> s = set([1, 2, 3])
>>> s
{1, 2, 3}

综合练习　

Python统计列表中的重复项出现的次数

# 方法一： 使用set
mylist = [1,2,2,2,2,3,3,3,4,4,4,4]
myset = set(mylist)  #myset是另外一个列表，里面的内容是mylist里面的无重复 项
for item in myset:
  print("the %d has found %d" %(item,mylist.count(item)))

 List=[1,2,2,2,2,3,3,3,4,4,4,4]
 a = {}
 for i in List:
   if List.count(i)>1:
     a[i] = List.count(i)
 print (a)

方法二：for循环判断

 >>> from collections import Counter
 >>> Counter([1,2,2,2,2,3,3,3,4,4,4,4])
 Counter({1: 5, 2: 3, 3: 2})

方法三：利用字典的特性

 l=[1,4,2,4,2,2,5,2,6,3,3,6,3,6,6,3,3,3,7,8,9,8,7,0,7,1,2,4,7,8,9]
 
 count_times = []
 for i in l :
   count_times.append(l.count(i))
 
 m = max(count_times)
 n = l.index(m)
 
 print (l[n])

方法四：只用列表实现

Python对文件的操作

对文件操作流程

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

基本操作　

python中对文件、文件夹（文件操作函数）的操作需要涉及到os模块和shutil模块。

>>> import os
>>> os.getcwd()     #获取当前Python工作目录
'C:\\python'
>>> os.listdir('C:/')       #返回指定目录下的所有文件和目录名
['$GetCurrent', '$Recycle.Bin', 'Boot', 'bootmgr', 'BOOTSECT.BAK', 'dbbtest.txt', 'Documents and Settings', 'PerfLogs', 'Program Files', 'Program Files (x86)', 'ProgramData', 'python', 'Python27', 'Recovery', 'System Volume Information', 'TDDownload', 'unintall.log', 'Users', 'Windows']
 
>>> os.remove('C:/dbbtest.txt')  #删除指定文件
>>> os.removedirs(r'C:/test')      #删除指定目录
>>> os.path.isfile("c:/unintall.log")   #判断是否是个文件
True
>>> os.path.isdir("c:/unintall.log")    #判断是否是个目录
False
>>> os.path.exits("C:/")              #判断路径是否存在
True
>>> os.system("ipconfig")          #运行shell 命令
0
>>> os.path.splitext("c:/unintall.log")  #分离扩展名
('c:/unintall', '.log')
 
>>> os.path.basename("c:/unintall.log")   #获取文件名
'unintall.log'
>>> os.rename("C:/unintall.log",'c:/unintall_new.log.') #文件重命名
>>> os.mkdir("c:/dbbtest")  #创建目录
>>> os.path.getsize("c:/unintall_new.log")  #获取文件大小
1690

文件操作

#创建文件
fp = open("test.txt",'w')     #直接打开一个文件，如果文件不存在则创建文件

打开模式有以下几种：

• r ，只读模式【默认】
• w，只写模式【不可读；不存在则创建；存在则清空内容；】
• x， 只写模式【不可读；不存在则创建，存在则报错】
• a， 追加模式【可读；   不存在则创建；存在则只追加内容；】

"+" 表示可以同时读写某个文件

• r+， 读写【可读，可写】
• w+，写读【可读，可写】
• x+ ，写读【可读，可写】
• a+， 写读【可读，可写】

"b"表示以字节的方式操作

• rb  或 r+b
• wb 或 w+b
• xb 或 w+b
• ab 或 a+b

注：以b方式打开时，读取到的内容是字节类型，写入时也需要提供字节类型

操作实例之读写文件

 #代码示例
 with open('read.txt','r+') as f :
     f.write('name dbb\n')
     f.write('user 123456\n')
     f.write('age 18\n')
 
 ##默认read将文件一次性读到内存,放在一个字符串变量中，生成的内容是一个字符串类型
 
     a=f.read()
         print("a read is :\n",a)
         print (type(a))
 结果：
  name dbb
 user 123456
 age 18
 <class 'str'>
 
 #readline()每只读取文件的一行，通常也是读取到的一行内容放到一个字符串变量中，返回str类型
 
     b=f.readline()
         print ("b readline is :\n",b)
         print (type(b))
 结果：
 b readline is :
  name dbb
 <class 'str'>
 
 #.readlines()每次按行读取整个文件内容，将读取到的内容放到一个列表中，返回list类型，一般配合for循环
     c=f.readlines()
         print('c readlines is :\n',c)
         print(type(c))
 结果：
 a readlines is :
  ['name dbb\n', 'user 123456\n', 'age 18']
 <class 'list'>

Python读文件

 with open('test.txt','r+') as f:
     # 如果打开模式无b,则read,按照字符读取
     # 有b 则会将字符根据编码拆解成字节
     data = f.read(1)
     print (f.tell())  #tell获取当前指针所在的位置（按字节）
     f.seek(f.tell())  #跳转到当前指针的位置（按字节）
     f.write('derby')  #当前指针开始向后覆盖（有b 写字节，无b 写字符）
     

python 读写文件

 class TextIOWrapper(_TextIOBase):
     """
     Character and line based layer over a BufferedIOBase object, buffer.
 
     encoding gives the name of the encoding that the stream will be
     decoded or encoded with. It defaults to locale.getpreferredencoding(False).
 
     errors determines the strictness of encoding and decoding (see
     help(codecs.Codec) or the documentation for codecs.register) and
     defaults to "strict".
 
     newline controls how line endings are handled. It can be None, '',
     '\n', '\r', and '\r\n'.  It works as follows:
 
     * On input, if newline is None, universal newlines mode is
       enabled. Lines in the input can end in '\n', '\r', or '\r\n', and
       these are translated into '\n' before being returned to the
       caller. If it is '', universal newline mode is enabled, but line
       endings are returned to the caller untranslated. If it has any of
       the other legal values, input lines are only terminated by the given
       string, and the line ending is returned to the caller untranslated.
 
     * On output, if newline is None, any '\n' characters written are
       translated to the system default line separator, os.linesep. If
       newline is '' or '\n', no translation takes place. If newline is any
       of the other legal values, any '\n' characters written are translated
       to the given string.
 
     If line_buffering is True, a call to flush is implied when a call to
     write contains a newline character.
     """
     def close(self, *args, **kwargs): # real signature unknown
         关闭文件
         pass
 
     def fileno(self, *args, **kwargs): # real signature unknown
         文件描述符
         pass
 
     def flush(self, *args, **kwargs): # real signature unknown
         刷新文件内部缓冲区
         pass
 
     def isatty(self, *args, **kwargs): # real signature unknown
         判断文件是否是同意tty设备
         pass
 
     def read(self, *args, **kwargs): # real signature unknown
         读取指定字节数据
         pass
 
     def readable(self, *args, **kwargs): # real signature unknown
         是否可读
         pass
 
     def readline(self, *args, **kwargs): # real signature unknown
         仅读取一行数据
         pass
 
     def seek(self, *args, **kwargs): # real signature unknown
         指定文件中指针位置
         pass
 
     def seekable(self, *args, **kwargs): # real signature unknown
         指针是否可操作
         pass
 
     def tell(self, *args, **kwargs): # real signature unknown
         获取指针位置
         pass
 
     def truncate(self, *args, **kwargs): # real signature unknown
         截断数据，仅保留指定之前数据
         pass
 
     def writable(self, *args, **kwargs): # real signature unknown
         是否可写
         pass
 
     def write(self, *args, **kwargs): # real signature unknown
         写内容
         pass
 
     def __getstate__(self, *args, **kwargs): # real signature unknown
         pass
 
     def __init__(self, *args, **kwargs): # real signature unknown
         pass
 
     @staticmethod # known case of __new__
     def __new__(*args, **kwargs): # real signature unknown
         """ Create and return a new object.  See help(type) for accurate signature. """
         pass
 
     def __next__(self, *args, **kwargs): # real signature unknown
         """ Implement next(self). """
         pass
 
     def __repr__(self, *args, **kwargs): # real signature unknown
         """ Return repr(self). """
         pass
 
     buffer = property(lambda self: object(), lambda self, v: None, lambda self: None)  # default
 
     closed = property(lambda self: object(), lambda self, v: None, lambda self: None)  # default
 
     encoding = property(lambda self: object(), lambda self, v: None, lambda self: None)  # default
 
     errors = property(lambda self: object(), lambda self, v: None, lambda self: None)  # default
 
     line_buffering = property(lambda self: object(), lambda self, v: None, lambda self: None)  # default
 
     name = property(lambda self: object(), lambda self, v: None, lambda self: None)  # default
 
     newlines = property(lambda self: object(), lambda self, v: None, lambda self: None)  # default
 
     _CHUNK_SIZE = property(lambda self: object(), lambda self, v: None, lambda self: None)  # default
 
     _finalizing = property(lambda self: object(), lambda self, v: None, lambda self: None)  # default
 
 3.x

python3.x 文件所有操作

文件使用完毕后必须关闭，因为文件对象会占用操作系统的资源，并且操作系统同一时间能打开的文件数量也是有限的

由于文件读写时都有可能产生IOError，一旦出错，后面的f.close()就不会调用。所以，为了保证无论是否出错都能正确地关闭文件，我们可以使用try ... finally来实现：

 try:
     f = open('C:/dbbtest.txt, 'r')
     print(f.read())
 finally:
     if f:
         f.close()

try..finally

但是每次都这么写实在太繁琐，所以，Python引入了with语句来自动帮我们调用close()方法：

 

#写文件
 
with open('C:/dbb.txt', 'r') as f:
    print(f.read())
 
#读文件
with open('c:/dbb.txt', 'w') as f:
    f.write('Hello, world!')

with 读写文件

 python read,readline,readlines 区别

 #read() 每次读取整个文件，它通常将读取到底文件内容放到一个字符串变量中，也就是说 .read() 生成文件内容是一个字符串类型
 
 with open('test.txt','r+') as f:
     data = f.read()
     print (data,type(data))
 
 结果：
 The line of first(1)
 The line of second(2)
 The line of third(3)
  <class 'str'>
 
 #readline()每只读取文件的一行，通常也是读取到的一行内容放到一个字符串变量中，返回str类型
 with open('test.txt','r+') as f:
     data = f.readline()
     print(data,type(data))
 
 结果：
 The line of first(1)
  <class 'str'>
 
 #readlines()每次按行读取整个文件内容，将读取到的内容放到一个列表中，返回list类型
 
 with open('test.txt','r+') as f:
     data = f.readlines()
     print(data,type(data))
 
 结果：
 ['The line of first(1)\n', 'The line of second(2)\n', 'The line of third(3)\n'] <class 'list'>

 #
 with open('test.txt','r+') as f:
     for line in f:
         print (line)
 
 结果：
 The line of first(1)
 
 The line of second(2)
 
 The line of third(3)

python 迭代文件行

 文件编码和位置调整：

#文件以什么编码存储，就应该以什么编码打开，很多时候乱码就是打开的编码不对
 
#打开文件如果不加b,折默认都是以字符的方式打开
 
f = open('testfile','r+',encoding='utf-8')  #以utf-8方式自动转化字符串，
data = f.read()
print (data,type(data))
print(f.tell())      #tell 当前指针所在的位置(字节)
 
#调整到当前指针的位置，
#f.seek(f.tell())
f.seek(5)   # seek 文件指针，以字节的方式去找位置，并且是以覆盖后文的字节的方式写入，如果找的是中文(三个字节)则乱码
f.write('add  something')
f.close()

Python 操作多个文件　　

#python 2.4后的版本支持同时操作2个以上的文件
#将文件1 的前五行 复制到文件2
with open('testfile','r',encoding='utf-8') as f1 , open('file2','w',encoding='utf-8') as f2:
    count = 0
    for line in f1:
        count += 1
        if count < 5:
            f2.write(line)
        else：
            break

替换文件1字符串，写入到文件2

with open('testfile','r',encoding='utf-8') as f1 , open('file2','w',encoding='utf-8') as f2:
    for line in f1:
        newLine = line.replace('5000','6000')
        f2.write(newLine)