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)

　　

 

python基础之day2的更多相关文章

  1. Python基础篇-day2

    主要内容: for循环 while循环 格式化输出(2) 数据统计及记录 ############################################################# 1 ...

  2. python基础1 day2

    一.上节课回顾1. 编译型: 将源码一次性全部编译成二进制. C 优点:执行效率高. 缺点:开发效率慢,不可跨平台使用. 解释型: 当程序执行时,代码一行一行的去解释成二进制. python 优点:开 ...

  3. Python基础学习Day2

    一.格式化输出 需求格式化输出:姓名.年龄.工作.爱好 # 格式化输出 name = input('请输入用户名:') age = input('请输入年龄:') job = input('请输入你的 ...

  4. Python基础，day2

    程序练习 程序:购物车程序 需求: 启动程序后,让用户输入工资,然后打印商品列表 允许用户根据商品编号购买商品 用户选择商品后,检测余额是否够,够就直接扣款,不够就提醒 可随时退出,退出时,打印已购买 ...

  5. Python基础知识-day2

    格式化输出 %占位符,s字符串,d 数字, 表示%  用%% name = input("请输入姓名: ") age = input("请输入年龄: ") he ...

  6. python基础一 day2 字符串操作

    s.capitalize()  s.upper()  s.lower() s.swapcase()   s.title()  s.center(20,"#")   s.expand ...

  7. python基础一 day2 数据类型

    int:        bool: 类型转换: str到int有条件,str必须是数字, "123e"是错误的 bool转换为int类型,需要int(x)  结果:  结果: 空字 ...

  8. python基础一 day2

    内容:   3%%s   输出:3%s       后面的全部转义 结果: 如果是因为执行break语句导致循环提前结束,就不会执行else. 单位换算: 编码方式: ascii  unicode u ...

  9. Day2 - Python基础2 列表、字典、集合

    Python之路,Day2 - Python基础2   本节内容 列表.元组操作 字符串操作 字典操作 集合操作 文件操作 字符编码与转码 1. 列表.元组操作 列表是我们最以后最常用的数据类型之一, ...

随机推荐

  1. JS Date.parse() 函数详解

    Date.parse()函数用于分析一个包含日期的字符串,并返回该日期与 1970 年 1 月 1 日午夜之间相差的毫秒数. 该函数属于Date对象,所有主流浏览器均支持该函数. 语法 Date.pa ...

  2. yii小细节

    1.main.php增加导航栏严格区分大小写,否则会出现404错误 2.增加'分页'功能---前后台的models里面的search.php 添加 public function search($pa ...

  3. 导出（Excel格式）

    poi导出,需要的poi jar包: 步骤一.两个工具类: 1.ExcelUtil.java package util; import java.awt.Color; import java.io.F ...

  4. html常用标签介绍

    常用标签介绍 文本 最常用的标签可能是<font>了,它用于改变字体,字号,文字颜色. 点击查看效果 <font size="6">6</font&g ...

  5. ble示例代码

    ble代码下载: https://github.com/sutogan4ik/Android-BLE-GATT-Master-Slave

  6. 【Java EE 学习 76 上】【数据采集系统第八天】【角色授权】【用户授权】【权限的粗粒度控制】【权限的细粒度控制】

    一.角色管理 单击导航栏上的"角色管理"超链接,跳转到角色管理界面,在该界面上显示所有角色,并提供角色的增加和删除.修改超链接. 1.增加新角色(角色授权) 流程:单击增加新角色超 ...

  7. EF不能很好的支持DDD？估计是我们搞错了！

    (此文章同时发表在本人微信公众号"dotNET每日精华文章",欢迎右边二维码来关注.) 题记:最近在ABP项目中尝试纯粹的DDD,然后遇到EF实现的Repository似乎不能很好 ...

  8. 虚拟机下CentOS 配置IP地址的三种方法

    1.自动获取IP地址(我不是用的这种方法,不做过多介绍) 虚拟机使用桥接模式,相当于连接到物理机的网络里,物理机网络有DHCP服务器自动分配IP地址. #dhclient 自动获取ip地址命令 #if ...

  9. 关于在django框架里取已登录用户名字的问题

    在 views里取值是这样的 request.user.username而在模板页面取值是这样的:{{request.user}} 判断是否通过验证是这样的 {% if request.user.is ...

  10. iOS应用九宫格算法

      1.框框横向间隔为:( "界面的总宽度"-"界面每行的控件的宽度" * "每行要现实的列数(这里是3)") / ("列数 + ...