内容回顾：
- bytes
- str 和bytes
- int
- str
- list
- tuple

- 深拷贝和浅拷贝

今日内容：
数据类型
- bytes
- int
- str
- bool
- list
- tuple
- dict (字典)
dic = {'k1':'v1'}
- values
- keys
- items
- get
- setdefault
- fromkeys dict.fromkeys
- update
- pop
- popitem
- copy
- clear

#dict.fromkeys 的3个示例原理：

val = dict.fromkeys(['k1','k2','k3'],666) #列表内容为键值对的key，后面数值为所有键值对的值
print(val)
val['k1'] = 999
print(val)

#fromkeys 指向的是同一个列表---value,所以3个可以vlaue相同都为追加后的列表
val = dict.fromkeys(['k1','k2','k3'],[])
val['k1'].append(678)
val['k2'].append(999)
print(val)

val = dict.fromkeys(['k1','k2','k3'],[])
val['k1'].append(666) #修改内部值
val['k1'] = [1,2,3] #将原k1的vlaue由666，修改为[1,2,3]---重新赋值
print(val)

- set (集合)
di = {"k1","k2"}#set

"""
names = {'龙哥','海角','老狗','成绩','小江','小高'}
names.add('龙哥') #集合添加元素，如果已经存在，则不再重复添加
print(names)
"""

#difference ---差集
"""
names = {'龙哥','海角','老狗','成绩','小江','小高'}
boys = {'小高','海娇','小狗'}
val = names.difference(boys) #names 中存在，boys中不存在的数据---name必须是集合，boys可以是列表或元组
print(val)
"""

"""
names = {'龙哥','海角','老狗','成绩','小江','小高'}
boys = {'小高','海娇','小狗'}
val = boys.difference(names) #boys 中存在，names中不存在的数据
print(val) #创建了一个新就集合---差集部分
"""

#difference_update
"""
names = {'龙哥','海角','老狗','成绩','小江','小高'}
boys = {'小高','海娇','小狗'}
boys.difference_update(names) #先找到差集，然后再重新将差集赋值给boys
print(boys)
"""

"""
names = {'龙哥','海角','老狗','成绩','小江','小高'}
boys = {'小高','海娇','小狗'}
names.difference_update(boys) #先找到差集，然后再重新将差集赋值给names
print(names)
"""

"""
#symmetric_difference ----对称差集
names = {'龙哥','海角','老狗','成绩','小江','小高'}
boys = {'小高','海娇','小狗'}
val = names.symmetric_difference(boys) #将两个集合分别求差集后，将这些差集和在一起，形成一个新的集合
print(val)
"""

"""
#symmetric_difference_update----对称差集重新赋值个某个集合
names = {'龙哥','海角','老狗','成绩','小江','小高'}
boys = {'小高','海娇','小狗'}
names.symmetric_difference_update(boys) #将两个集合分别求差集后，再将这些差集和在一起，重新赋值个names
print(names)
"""

"""
#discard 集合中删除指定的值
names = {'龙哥','海角','老狗','成绩','小江','小高'}
names.discard('龙哥')
print(names)
"""

"""
#intersection ---求交集
names = {'龙哥','海角','老狗','成绩','小江','小高'}
boys = {'小高','海娇','小狗'}
val = names.intersection(boys) #将names和boys求交集
print(val)
"""

"""
names = {'龙哥','海角','老狗','成绩','小江','小高'}
boys = {'小高','海娇','小狗'}
names.intersection_update(boys) #将names和boys求交集，并将交集重新赋值个names
print(names)
"""

"""
#union --求并集
names = {'龙哥','海角','老狗','成绩','小江','小高'}
boys = {'小高','海娇','小狗'}
val = names.union(boys)
print(val)
"""

"""
#isdisjoint 判断是否无交集
#有交集：False
#无交集：True
names = {'龙哥','海角','老狗','成绩','小江','小高'}
boys = {'小高','海娇','小狗'}
val = names.isdisjoint(boys)
print(val)

"""

#issubset 判断是否是子集

"""
names = {'龙哥','海角','老狗','成绩','小江','小高'}
boys = {'海娇','王老师'}
val = names.issubset(boys) #names集合不包含在boys集合里，为False
print(val)
"""
"""
names = {'龙哥','海角','老狗','成绩','小江','小高'}
boys = {'龙哥','老狗'}
val = names.issubset(boys) #names集合不包含在boys集合里，为False
print(val)
"""

"""
names = {'龙哥','海角','老狗','成绩','小江','小高'}
boys = {'龙哥','老狗'}
val = boys.issubset(names) #boys 子集包含在names集合里，为True
print(val)
"""

"""
#issuperset 判断是否是父集
names = {'龙哥','海角','老狗','成绩','小江','小高'}
boys = {'龙哥','老狗'}
val = names.issuperset(boys) #names是boys的父集，结果为True
print(val)
"""

"""
#pop --随机删除集合的一个元素
names = {'龙哥','海角','老狗','成绩','小江','小高'}
v = names.pop()
print(v)
"""

"""
#remove - 删除集合里指定的元素，当指定的元素不存在时，会报错
names = {'龙哥','海角','老狗','成绩','小江','小高'}
#names.remove('老狗')
names.remove('老狗1') #删除指定的元素不存在时，会报错
print(names)
"""

#update --更新
"""
names = {'龙哥','海角','老狗','成绩','小江','小高'}
boys = ['龙哥1','老狗1']
names.update(boys) #names必须是个集合，而boys可以是集合或列表等
print(names)
"""

"""
names = {'龙哥','海角','老狗','成绩','小江','小高'}
boys = {'龙哥1','老狗1'}
names.update(boys) #names必须是个集合，而boys可以是集合或列表、元组
print(names)
"""

"""
#集合可以通过for循环，也可以取长度
names = {'龙哥','海角','老狗','成绩','小江','小高'}
for item in names:
print(item)
print(len(names))
"""

#集合的应用：
#列表元素去掉重复项
names = ['龙哥','老狗','海角','老狗','成绩','小江','小高','小江']
val = set(names)
print(val)

names2 = list(val)
names = names2
print(names2)
print(names)

#集合：
- 元素，不可变

文件操作
美女模特空姐护士联系方式.txt

1. 路径：D:\美女模特空姐护士联系方式.txt
2. 编码：utf-8
3. 模式：只读 r, 只写，读写...
- rb
- r
- r+ #常用，能读也能写 *****
- r+b
- wb
- w
- w+ #写读，先清空，再写了之后才能读，读的是新写的数据
- w+b
- ab
- a #追加，尾部写入
- a+ #读写，只能在最后面追加写入，通过指针指定也无效
- a+b

功能：
obj = open (文件路径,mode='r+')
obj.read()
obj.write()
obj.seek()
obj.tell()
obj.close()
obj.flush()
#obj.readline() #等价与py2的obj.xreadlines()
for line in obj:
print(line)

obj.readlines() #不好，逐行读取，放在内容，分割成列表
obj.xreadlines() #py2中存在

PS ：打开文件后，记得关闭文件
obj = open(文件路径,mode='r+')
xxxx
obj.close()

自动关闭：

with open(文件路径,mode='r+') as obj:
obj.read()
#代码执行完毕后，自动关闭文件

只读：
#读取文件
#读取utf-8编码的数据，【转换】成unicode(str)编码的数据
obj = open('D:\美女模特空姐护士联系方式.txt',encoding='utf-8',mode='r')
content = obj.read()
obj.close()
print(content) #打印出来的conten为str类型-----unicode编码

打印出来的conten为str类型

window--cli示例：
Microsoft Windows [版本 6.1.7601]
版权所有 (c) 2009 Microsoft Corporation。保留所有权利。

C:\Users\ZH>python D:\Install-File\python-work\auto-chapter7\4-file-operate.py
test---1500

C:\Users\ZH>

#读文件rb模式
obj = open('D:\美女模特空姐护士联系方式.txt', mode='rb') #rb模式读取的数据为原始编码，不做转换
content = obj.read()
obj.close()
print(content)
print(content,type(content))

# b'\xba\xa3\xbd\xbf--test---1500'
# b'\xba\xa3\xbd\xbf--test---1500' <class 'bytes'>

只写：
- obj = open('美女',mode='wb')
- obj = open('美女',mode='w',encoding='utf-8')

示例：
obj = open('美女',mode='w',encoding='utf-8')
obj.write("海娇-贾敏")
obj.close()
print(data)

obj = open('美女',mode='wb')
obj.write("海娇-贾敏22222".encode('utf-8'))
obj.close()

只追加： a

- obj = open('美女',mode='ab')
- obj = open('美女',mode='a',encoding='utf-8')

示例：
obj = open('美女',mode='a',encoding='utf-8')
obj.write("小红")
obj.close()
print(obj)

obj = open('美女',mode='ab')
obj.write("龙哥22".encode('utf-8'))
obj.close()

r+ 能读写 示例：
obj = open('美女',mode='r+',encoding='utf-8')
data = obj.read()
obj.write("66666")
obj.close()
print(data)

=============================脚本=========================

字典补充知识相关脚本：

  1.  #dic = {'k1':'v1'}
  2.  
  3.  #1.字典的key都能是什么？
  4.  #布尔值：True = 1 ; False = 0
  5.  ###!!!不可变：str,int bool,tuple    -----可以作为key的值
  6.  ##可变：list,dict,set  ----不可以作为key的值
  7.  
  8.  #2.字典查找速度快，给予哈希索引
  9.  #字典的key在内存中是哈希表，哈希索引
  10.  
  11.  #True 的值为1，所以True 不能与1同时做为key的值；同理False与0不能同时做为key的值
  12.  """
  13.  dic = {
  14.      'k1':'v1',
  15.      2:'v1',
  16.      True:'v1',
  17.      #1:'vvvv1'
  18.      (11,22,33):'v3',
  19.      #[11,22,33]:'v4'    #list 列表不能作为key的值
  20.  }
  21.  print(dic)
  22.  
  23.  """
  24.  
  25.  #pop    删除对应的key及其value，同时获取删除key对应的值
  26.  """
  27.  dic = {'k1':'v1','k2':'v2'}
  28.  v = dic.pop('k2')
  29.  print(dic)
  30.  print(v)
  31.  """
  32.  
  33.  """
  34.  #若果key不存在，则不删除key，但同时可以获取不存在key的默认值-----存在默认值的情况，如果没有指定默认值，值报错
  35.  dic = {'k1':'v1','k2':'v2'}
  36.  v = dic.pop('k22','默认值')
  37.  print(dic)
  38.  print(v)
  39.  """
  40.  
  41.  #popitem
  42.  #删除键值对
  43.  
  44.  """
  45.  dic = {'k1':'v1','k2':'v2'}
  46.  v = dic.popitem()
  47.  print(dic)
  48.  print(v)
  49.  """
  50.  
  51.  """
  52.  #分别赋值模式---改进
  53.  dic = {'k1':'v1','k2':'v2'}
  54.  v1,v2 = dic.popitem()
  55.  print(dic)
  56.  print(v1,v2)
  57.  """
  58.  
  59.  ### 字典里的设置：添加，修改
  60.  
  61.  #字典里的---设置---setdefault
  62.  #setdefault ----添加---，没有就添加，有就不变
  63.  """
  64.  dic = {'k1':'v1','k2':'v2'}
  65.  dic.setdefault('k3','999')
  66.  print(dic)
  67.  """
  68.  
  69.  """
  70.  dic = {'k1':'v1','k2':'v2'}
  71.  dic.setdefault('k2','999')  #k2的value不发生变化
  72.  #dic['k2'] = 999    #将k2的value修改为999
  73.  print(dic)
  74.  """
  75.  
  76.  #update
  77.  #key不存在----即没有重复出现时
  78.  """
  79.  dic = {'k1':'v1','k2':'v2'}
  80.  dic.update({'k3':'v4','k5':'v5'})
  81.  print(dic)
  82.  """
  83.  
  84.  """
  85.  #key存在----将原key的value更新为新的value
  86.  dic = {'k1':'v1','k2':'v2'}
  87.  dic.update({'k3':'v4','k2':'v5'})
  88.  print(dic)
  89.  """
  90.  
  91.  ####----以上都是通过对象（类的对象）得出的功能
  92.  
  93.  #fromkeys   ----通过类表示出的功能
  94.  
  95.  """
  96.  val = dict.fromkeys(['k1','k2','k3'],666)   #列表内容为键值对的key，后面数值为所有键值对的值
  97.  print(val)
  98.  val['k1'] = 999
  99.  print(val)
  100.  
  101.  """
  102.  
  103.  """
  104.  #fromkeys   指向的是同一个列表---value,所以3个可以vlaue相同都为追加后的列表
  105.  val = dict.fromkeys(['k1','k2','k3'],[])
  106.  val['k1'].append(678)
  107.  val['k2'].append(999)
  108.  print(val)
  109.  """
  110.  
  111.  """
  112.  #追加与修改
  113.  val = dict.fromkeys(['k1','k2','k3'],[])
  114.  val['k1'].append(666)   #修改内部值
  115.  val['k1'] = [1,2,3] #将原k1的vlaue由666，修改为[1,2,3]---重新赋值
  116.  print(val)
  117.  """

集合---set相关脚本：

  1.  #set
  2.  
  3.  """
  4.  names = {'龙哥','海角','老狗','成绩','小江','小高'}
  5.  names.add('龙哥') #集合添加元素，如果已经存在，则不再重复添加
  6.  print(names)
  7.  """
  8.  
  9.  #difference ---差集
  10.  """
  11.  names = {'龙哥','海角','老狗','成绩','小江','小高'}
  12.  boys = {'小高','海娇','小狗'}
  13.  val = names.difference(boys)    #names 中存在，boys中不存在的数据---name必须是集合，boys可以是列表或元组
  14.  print(val)
  15.  """
  16.  
  17.  """
  18.  names = {'龙哥','海角','老狗','成绩','小江','小高'}
  19.  boys = {'小高','海娇','小狗'}
  20.  val = boys.difference(names)    #boys 中存在，names中不存在的数据
  21.  print(val)  #创建了一个新就集合---差集部分
  22.  """
  23.  
  24.  #difference_update
  25.  """
  26.  names = {'龙哥','海角','老狗','成绩','小江','小高'}
  27.  boys = {'小高','海娇','小狗'}
  28.  boys.difference_update(names)   #先找到差集，然后再重新将差集赋值给boys
  29.  print(boys)
  30.  """
  31.  
  32.  """
  33.  names = {'龙哥','海角','老狗','成绩','小江','小高'}
  34.  boys = {'小高','海娇','小狗'}
  35.  names.difference_update(boys)   #先找到差集，然后再重新将差集赋值给names
  36.  print(names)
  37.  """
  38.  
  39.  """
  40.  #symmetric_difference   ----对称差集
  41.  names = {'龙哥','海角','老狗','成绩','小江','小高'}
  42.  boys = {'小高','海娇','小狗'}
  43.  val = names.symmetric_difference(boys)  #将两个集合分别求差集后，将这些差集和在一起，形成一个新的集合
  44.  print(val)
  45.  """
  46.  
  47.  """
  48.  #symmetric_difference_update----对称差集重新赋值个某个集合
  49.  names = {'龙哥','海角','老狗','成绩','小江','小高'}
  50.  boys = {'小高','海娇','小狗'}
  51.  names.symmetric_difference_update(boys) #将两个集合分别求差集后，再将这些差集和在一起，重新赋值个names
  52.  print(names)
  53.  """
  54.  
  55.  """
  56.  #discard    集合中删除指定的值
  57.  names = {'龙哥','海角','老狗','成绩','小江','小高'}
  58.  names.discard('龙哥')
  59.  print(names)
  60.  """
  61.  
  62.  """
  63.  #intersection   ---求交集
  64.  names = {'龙哥','海角','老狗','成绩','小江','小高'}
  65.  boys = {'小高','海娇','小狗'}
  66.  val = names.intersection(boys)  #将names和boys求交集
  67.  print(val)
  68.  """
  69.  
  70.  """
  71.  names = {'龙哥','海角','老狗','成绩','小江','小高'}
  72.  boys = {'小高','海娇','小狗'}
  73.  names.intersection_update(boys) #将names和boys求交集，并将交集重新赋值个names
  74.  print(names)
  75.  """
  76.  
  77.  """
  78.  #union  --求并集
  79.  names = {'龙哥','海角','老狗','成绩','小江','小高'}
  80.  boys = {'小高','海娇','小狗'}
  81.  val = names.union(boys)
  82.  print(val)
  83.  """
  84.  
  85.  """
  86.  #isdisjoint     判断是否无交集
  87.  #有交集：False
  88.  #无交集：True
  89.  names = {'龙哥','海角','老狗','成绩','小江','小高'}
  90.  boys = {'小高','海娇','小狗'}
  91.  val = names.isdisjoint(boys)
  92.  print(val)
  93.  
  94.  """
  95.  
  96.  #issubset   判断是否是子集
  97.  
  98.  """
  99.  names = {'龙哥','海角','老狗','成绩','小江','小高'}
  100.  boys = {'海娇','王老师'}
  101.  val = names.issubset(boys)  #names集合不包含在boys集合里，为False
  102.  print(val)
  103.  """
  104.  """
  105.  names = {'龙哥','海角','老狗','成绩','小江','小高'}
  106.  boys = {'龙哥','老狗'}
  107.  val = names.issubset(boys)  #names集合不包含在boys集合里，为False
  108.  print(val)
  109.  """
  110.  
  111.  """
  112.  names = {'龙哥','海角','老狗','成绩','小江','小高'}
  113.  boys = {'龙哥','老狗'}
  114.  val = boys.issubset(names)  #boys 子集包含在names集合里，为True
  115.  print(val)
  116.  """
  117.  
  118.  """
  119.  #issuperset 判断是否是父集
  120.  names = {'龙哥','海角','老狗','成绩','小江','小高'}
  121.  boys = {'龙哥','老狗'}
  122.  val = names.issuperset(boys)    #names是boys的父集，结果为True
  123.  print(val)
  124.  """
  125.  
  126.  """
  127.  #pop    --随机删除集合的一个元素
  128.  names = {'龙哥','海角','老狗','成绩','小江','小高'}
  129.  v = names.pop()
  130.  print(v)
  131.  """
  132.  
  133.  """
  134.  #remove - 删除集合里指定的元素，当指定的元素不存在时，会报错
  135.  names = {'龙哥','海角','老狗','成绩','小江','小高'}
  136.  #names.remove('老狗')
  137.  names.remove('老狗1') #删除指定的元素不存在时，会报错
  138.  print(names)
  139.  """
  140.  
  141.  #update --更新
  142.  """
  143.  names = {'龙哥','海角','老狗','成绩','小江','小高'}
  144.  boys = ['龙哥1','老狗1']
  145.  names.update(boys)  #names必须是个集合，而boys可以是集合或列表等
  146.  print(names)
  147.  """
  148.  
  149.  """
  150.  names = {'龙哥','海角','老狗','成绩','小江','小高'}
  151.  boys = {'龙哥1','老狗1'}
  152.  names.update(boys)  #names必须是个集合，而boys可以是集合或列表、元组
  153.  print(names)
  154.  """
  155.  
  156.  """
  157.  #集合可以通过for循环，也可以取长度
  158.  names = {'龙哥','海角','老狗','成绩','小江','小高'}
  159.  for item in names:
  160.      print(item)
  161.      print(len(names))
  162.  """
  163.  
  164.  #集合的应用：
  165.  #列表元素去掉重复项
  166.  names = ['龙哥','老狗','海角','老狗','成绩','小江','小高','小江']
  167.  val = set(names)
  168.  print(val)
  169.  
  170.  names2 = list(val)
  171.  names = names2
  172.  print(names2)
  173.  print(names)

数据类型补充相关知识脚本：

  1. v1 = [] #空列表    等价于:    list()
  2. v1 = () #空元组     等价于:   tuple()
  3. v3 = {} #空字典----默认为字典    等价于:   dict()
  4. v4 = set()
  5. print(type(v4))
  6. print(type(v3))

文件操作相关脚本：

  1.  """
  2.  #读文件 utf-8模式
  3.  #读取utf-8编码的数据，【转换】成unicode(str)编码的数据
  4.  obj = open('D:\美女模特空姐护士联系方式2.txt', encoding='utf-8', mode='r')
  5.  content = obj.read()
  6.  obj.close()
  7.  print(content)
  8.  print(content,type(content))
  9.  # 海娇--test---1500
  10.  # 海娇--test---1500 <class 'str'>
  11.  #打印出来的conten为str类型-----unicode编码
  12.  """
  13.  
  14.  """
  15.  #读文件rb模式
  16.  obj = open('D:\美女模特空姐护士联系方式.txt', mode='rb')    #rb模式读取的数据为原始编码，不做转换
  17.  content = obj.read()
  18.  obj.close()
  19.  print(content)
  20.  print(content,type(content))
  21.  
  22.  # b'\xba\xa3\xbd\xbf--test---1500'
  23.  # b'\xba\xa3\xbd\xbf--test---1500' <class 'bytes'>
  24.  """
  25.  
  26.  #1.文件在硬盘时时，一定是:utf-8,gbk...(以一定编码保存的)
  27.  #2.rb, bytes    读取的是原生文件编码，当模式为，rb模式时，不用指定编码方式
  28.  #3 r, 转换encoding=utf-8  当模式为r模式时，需要指定读取文件的转换编码方式
  29.  
  30.  #在当前目录下打开文件
  31.  """
  32.  obj = open('log.txt',mode='rb')
  33.  data = obj.read()
  34.  obj.close()
  35.  print(data)
  36.  #b'adadfdfefedf\xc4\xe3\xba\xc3\xa3\xa1'
  37.  """
  38.  
  39.  """
  40.  obj = open('log.txt',mode='r',encoding='utf-8')
  41.  data = obj.read()
  42.  obj.close()
  43.  print(data)
  44.  print(type(data))
  45.  # dadfdfd-您好！
  46.  # <class 'str'>
  47.  """
  48.  
  49.  """
  50.  obj = open('美女',mode='w',encoding='utf-8')
  51.  obj.write("海娇-贾敏")
  52.  obj.close()
  53.  print(data)
  54.  """
  55.  
  56.  """
  57.  obj = open('美女',mode='wb')
  58.  obj.write("海娇-贾敏22222".encode('utf-8'))
  59.  obj.close()
  60.  """
  61.  
  62.  """
  63.  obj = open('美女',mode='a',encoding='utf-8')
  64.  obj.write("小红")
  65.  obj.close()
  66.  print(obj)
  67.  """
  68.  
  69.  """
  70.  obj = open('美女',mode='ab')
  71.  obj.write("龙哥22".encode('utf-8'))
  72.  obj.close()
  73.  
  74.  """
  75.  
  76.  """
  77.  obj = open('美女',mode='r+',encoding='utf-8')
  78.  data = obj.read()
  79.  obj.write("66666")
  80.  obj.close()
  81.  print(data)
  82.  
  83.  """
  84.  
  85.  """
  86.  #不读只写时，写入的数据覆盖了开始的数据
  87.  obj = open('美女',mode='r+',encoding='utf-8')
  88.  #data = obj.read()
  89.  obj.write("66666")
  90.  obj.close()
  91.  #print(data)
  92.  
  93.  """
  94.  
  95.  """
  96.  #读和追加写入
  97.  #写入情况1
  98.  obj = open('美女',mode='r+',encoding='utf-8')
  99.  data = obj.read(1)  #读的光标，但不影响写的光标，仍然追加写入
  100.  obj.write("6")
  101.  obj.close()
  102.  print(data)
  103.  """
  104.  
  105.  """
  106.  #写入情况2
  107.  obj = open('美女',mode='r+',encoding='utf-8')
  108.  data = obj.read(1)
  109.  obj.seek(1) #通过光标定位，将要写入的数据指定到当前光标位置，新写入的数据会覆盖当前光标位置的数据
  110.  obj.write("6")
  111.  obj.close()
  112.  print(data)
  113.  """
  114.  
  115.  """
  116.  obj = open('美女',mode='w',encoding='utf-8')
  117.  obj.write("海角海角")
  118.  obj.close()
  119.  """
  120.  
  121.  """
  122.  #默认读取全部数据
  123.  obj = open('美女',mode='r+',encoding='utf-8')
  124.  data = obj.read()   #默认读取所有文件内容
  125.  obj.close()
  126.  print(data)
  127.  
  128.  """
  129.  
  130.  """
  131.  #指定读取位置，通过r+读取的是字符
  132.  obj = open('美女',mode='r+',encoding='utf-8')
  133.  data = obj.read(2)   #读取指定文件内容----读取的是字符
  134.  #obj.write()    #r+模式下写入的是字符
  135.  obj.close()
  136.  print(data)
  137.  """
  138.  
  139.  """
  140.  #指定读取位置，通过r+b读取的是字节
  141.  obj = open('美女',mode='r+b')
  142.  data = obj.read(2)   #读取指定文件内容----读取的是字节
  143.  #obj.write()    #r+b模式下写入的是字节
  144.  obj.close()
  145.  print(data)
  146.  #b'\xe6\xb5'
  147.  
  148.  """
  149.  
  150.  """
  151.  #通过seek指定读取指针的位置
  152.  obj = open('美女',mode='r+',encoding='utf-8')
  153.  obj.seek(3)     #光标位置永远是字节位置----读取第3个字节后面的数据
  154.  data = obj.read()
  155.  obj.close()
  156.  print(data)
  157.  """
  158.  
  159.  obj = open('美女',mode='r+',encoding='utf-8')
  160.  #obj.seek(3)     #光标位置永远是字节位置----读取第3个字节后面的数据
  161.  #data = obj.read()
  162.  #obj.close()
  163.  #obj.tell()      #读取当前指针的位置
  164.  #print(data)
  165.  num = int(input('请输入要读取的字符个数：'))
  166.  data = obj.read(num)
  167.  inp = input('从当前位置开始向后覆盖的内容：')
  168.  #obj.seek((obj.tell()))
  169.  #obj.writable()  #是否可写
  170.  #obj.readable()  #是否可读
  171.  #obj.flush()     #强刷入硬盘---不关闭文件强制写入硬盘#默认关闭文件时会写入硬盘，flush指令可强制在不关闭文件的同时将内存中的内容强制写入硬盘
  172.  #obj.readline()  #默认只读取1行，再写一个readline则接着上次的指针，继续读取下面一行
  173.  #obj.truncate()  #截取，如通过seek将指针指向3，后面使用truncate指令，则只保留指针之前的数据，后面的数据删除了
  174.  
  175.  #通过for循环读取每一行，直到读取所有数据
  176.  for line in obj:
  177.      print(line)
  178.  
  179.  obj.close()

0006-20180422-自动化第七章-python基础学习笔记的更多相关文章

  1. 0003.5-20180422-自动化第四章-python基础学习笔记--脚本

    0003.5-20180422-自动化第四章-python基础学习笔记--脚本 1-shopping """ v = [ {"name": " ...

  2. 0001-20180421-自动化第一章-python基础学习笔记

    ======================学习python==================介绍: python种类: cpython(*),jpython,ironpython,rubypyth ...

  3. 0005-20180422-自动化第六章-python基础学习笔记

    day6 内容回顾: 1. 变量 2. 条件 3. while循环 4. 数据类型 - int - bit_length - bool - True/False - str - upper - low ...

  4. 0004-20180422-自动化第五章-python基础学习笔记

    内容回顾:1.数据类型 2.for和while循环 continue break #如下循环将怎么打印结果? for i in range(1,10): print(i) for i in range ...

  5. 0003-20180422-自动化第三章-python基础学习笔记

    3章 内容回顾: 1. 计算机组成 2. 程序编译器 3. 变量 4. 条件 5. 循环 6. py2与py3区别 - 默认编码, - 除法, - input ,raw_input 7. 位,字节关系 ...

  6. Python基础学习笔记（七）常用元组内置函数

    参考资料: 1. <Python基础教程> 2. http://www.runoob.com/python/python-tuples.html 3. http://www.liaoxue ...

  7. python 基础学习笔记（1）

    声明:  本人是在校学生,自学python,也是刚刚开始学习,写博客纯属为了让自己整理知识点和关键内容,当然也希望可以通过我都博客来提醒一些零基础学习python的人们.若有什么不对,请大家及时指出, ...

  8. 第一课、python基础学习笔记

    自动化非自动化的区别 自动化测试就是让机器按照人的想法把功能全部跑一遍 自动化测试的过程,让我们写一段程序去测试另一段程序是否正常的过程 Java 编译型语言,   编码-->编译-->解 ...

  9. Python基础学习笔记（十三）异常

    参考资料: 1. <Python基础教程> 2. http://www.runoob.com/python/python-exceptions.html Python用异常对象(excep ...

随机推荐

  1. C#高阶与初心：（一）List.Add添加的到底是什么？

    前几日与同事讨论一个相对复杂的场景,需要先将中间过程存储在List中,稍后再用.同时程序类的许多线程共用了一个全局变量. 具体来说就是如下代码 ... _order = order1; _list.A ...

  2. 运营商挂时长神器,批量导入账号,导出账号状态,随机修改MAC地址

    话不多说,直接上图 可批量导入账号,同时修改广域网口MAC地址 导出账号状态,包括在线时长,MAC,IP地址等等

  3. springboot-multisource

    项目中经常会出现需要同时连接两个数据源的情况,这里基于MyBatis来配置两个数据源,并演示如何切换不同的数据源. 通过自定义注解+AOP的方式,来简化这种数据源的切换操作. <properti ...

  4. redis在php中的基本使用

    //使用autoload加载相关库,这边重点就是为了require $file; spl_autoload_register(function($class) { $file = __DIR__.’/ ...

  5. 转：The Difference Between a LayoutTransform and a RenderTransform

    来自:http://www.tuicool.com/articles/fIfm22 #770 – The Difference Between a LayoutTransform and a Rend ...

  6. Linux系统挂载windows共享目录报错mount error(121):remote error I/O error

    经查,这是由于NFS(Network File System)即网络文件系统服务器有多个版本,V2.V3.V4.而且各版本同时运行,因此挂载时需要说明版本号 mount -o username='pk ...

  7. Q - Girls and Boys

    来源poj1068 In the second year of the university somebody started a study on the romantic relations be ...

  8. filter滤镜效果(css3属性)

    <!DOCTYPE html> <html> <head> <style> img { width: 33%; height: auto; float: ...

  9. 微信小程序时间戳的转换及调用

    13位 的时间戳,如下图: 效果图: 1.(utils.js里面的代码): function formatTime(timestamp, format) { const formateArr = [' ...

  10. 范进中Nature——儒林外史新义

    范进中Nature——儒林外史新义 范进发了文章回办公室,实验室一块儿搬砖的挂名作者俱各欢喜.正待烧锅煮方便面,只见他老板胡副教授,手里拿着一包外卖和一瓶红星二锅头,走了进来.范进向他作揖,坐下.胡副 ...