0006-20180422-自动化第七章-python基础学习笔记

内容回顾：
- 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:UsersH>python D:Install-Filepython-workauto-chapter74-file-operate.py
test---1500

C:UsersH>

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

# b'xbaxa3xbdxbf--test---1500'
# b'xbaxa3xbdxbf--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)

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

字典补充知识相关脚本：

#dic = {'k1':'v1'}

#1.字典的key都能是什么？
#布尔值：True = 1 ; False = 0
###!!!不可变：str,int bool,tuple    -----可以作为key的值
##可变：list,dict,set  ----不可以作为key的值

#2.字典查找速度快，给予哈希索引
#字典的key在内存中是哈希表，哈希索引




#True 的值为1，所以True 不能与1同时做为key的值；同理False与0不能同时做为key的值
"""
dic = {
    'k1':'v1',
    2:'v1',
    True:'v1',
    #1:'vvvv1'
    (11,22,33):'v3',
    #[11,22,33]:'v4'    #list 列表不能作为key的值
}
print(dic)

"""

#pop    删除对应的key及其value，同时获取删除key对应的值
"""
dic = {'k1':'v1','k2':'v2'}
v = dic.pop('k2')
print(dic)
print(v)
"""

"""
#若果key不存在，则不删除key，但同时可以获取不存在key的默认值-----存在默认值的情况，如果没有指定默认值，值报错
dic = {'k1':'v1','k2':'v2'}
v = dic.pop('k22','默认值')
print(dic)
print(v)
"""

#popitem
#删除键值对

"""
dic = {'k1':'v1','k2':'v2'}
v = dic.popitem()
print(dic)
print(v)
"""

"""
#分别赋值模式---改进
dic = {'k1':'v1','k2':'v2'}
v1,v2 = dic.popitem()
print(dic)
print(v1,v2)
"""

### 字典里的设置：添加，修改

#字典里的---设置---setdefault
#setdefault ----添加---，没有就添加，有就不变
"""
dic = {'k1':'v1','k2':'v2'}
dic.setdefault('k3','999')
print(dic)
"""

"""
dic = {'k1':'v1','k2':'v2'}
dic.setdefault('k2','999')  #k2的value不发生变化
#dic['k2'] = 999    #将k2的value修改为999
print(dic)
"""


#update
#key不存在----即没有重复出现时
"""
dic = {'k1':'v1','k2':'v2'}
dic.update({'k3':'v4','k5':'v5'})
print(dic)
"""

"""
#key存在----将原key的value更新为新的value
dic = {'k1':'v1','k2':'v2'}
dic.update({'k3':'v4','k2':'v5'})
print(dic)
"""

####----以上都是通过对象（类的对象）得出的功能

#fromkeys   ----通过类表示出的功能

"""
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相关脚本：

#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)

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

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

文件操作相关脚本：

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

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

# b'xbaxa3xbdxbf--test---1500'
# b'xbaxa3xbdxbf--test---1500' <class 'bytes'>
"""

#1.文件在硬盘时时，一定是:utf-8,gbk...(以一定编码保存的)
#2.rb, bytes    读取的是原生文件编码，当模式为，rb模式时，不用指定编码方式
#3 r, 转换encoding=utf-8  当模式为r模式时，需要指定读取文件的转换编码方式


#在当前目录下打开文件
"""
obj = open('log.txt',mode='rb')
data = obj.read()
obj.close()
print(data)
#b'adadfdfefedfxc4xe3xbaxc3xa3xa1'
"""

"""
obj = open('log.txt',mode='r',encoding='utf-8')
data = obj.read()
obj.close()
print(data)
print(type(data))
# dadfdfd-您好！
# <class 'str'>
"""

"""
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()
"""

"""
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()

"""

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

"""

"""
#不读只写时，写入的数据覆盖了开始的数据
obj = open('美女',mode='r+',encoding='utf-8')
#data = obj.read()
obj.write("66666")
obj.close()
#print(data)

"""

"""
#读和追加写入
#写入情况1
obj = open('美女',mode='r+',encoding='utf-8')
data = obj.read(1)  #读的光标，但不影响写的光标，仍然追加写入
obj.write("6")
obj.close()
print(data)
"""

"""
#写入情况2
obj = open('美女',mode='r+',encoding='utf-8')
data = obj.read(1)
obj.seek(1) #通过光标定位，将要写入的数据指定到当前光标位置，新写入的数据会覆盖当前光标位置的数据
obj.write("6")
obj.close()
print(data)
"""


"""
obj = open('美女',mode='w',encoding='utf-8')
obj.write("海角海角")
obj.close()
"""


"""
#默认读取全部数据
obj = open('美女',mode='r+',encoding='utf-8')
data = obj.read()   #默认读取所有文件内容
obj.close()
print(data)

"""

"""
#指定读取位置，通过r+读取的是字符
obj = open('美女',mode='r+',encoding='utf-8')
data = obj.read(2)   #读取指定文件内容----读取的是字符
#obj.write()    #r+模式下写入的是字符
obj.close()
print(data)
"""

"""
#指定读取位置，通过r+b读取的是字节
obj = open('美女',mode='r+b')
data = obj.read(2)   #读取指定文件内容----读取的是字节
#obj.write()    #r+b模式下写入的是字节
obj.close()
print(data)
#b'xe6xb5'

"""

"""
#通过seek指定读取指针的位置
obj = open('美女',mode='r+',encoding='utf-8')
obj.seek(3)     #光标位置永远是字节位置----读取第3个字节后面的数据
data = obj.read()   
obj.close()
print(data)
"""

obj = open('美女',mode='r+',encoding='utf-8')
#obj.seek(3)     #光标位置永远是字节位置----读取第3个字节后面的数据
#data = obj.read()
#obj.close()
#obj.tell()      #读取当前指针的位置
#print(data)
num = int(input('请输入要读取的字符个数：'))
data = obj.read(num)
inp = input('从当前位置开始向后覆盖的内容：')
#obj.seek((obj.tell()))
#obj.writable()  #是否可写
#obj.readable()  #是否可读
#obj.flush()     #强刷入硬盘---不关闭文件强制写入硬盘#默认关闭文件时会写入硬盘，flush指令可强制在不关闭文件的同时将内存中的内容强制写入硬盘
#obj.readline()  #默认只读取1行，再写一个readline则接着上次的指针，继续读取下面一行
#obj.truncate()  #截取，如通过seek将指针指向3，后面使用truncate指令，则只保留指针之前的数据，后面的数据删除了

#通过for循环读取每一行，直到读取所有数据
for line in obj:
    print(line)


obj.close()