'''
 类型转换

 1.数字类型：int() | bool() | float()

    2.str与int： int('10') | int('-10') | int('0') | float('-.5') | float('3.14') | str(数字)

    3.重点 - str与list：


   　　 'abc' => ['a', 'b', 'c']: list('abc') | ''.join(['a', 'b', 'c'])

   　　 'abc|def|xyz' => ['abc', 'def', 'xyz']: s.split('|') | '|'.join(ls)

    4.list、set、tuple：类型()

    5.list与dict：


    　　a=1&b=2&c=3 <=> [('a', 1), ('b', 2), ('c', 3)] <=> {'a': 1, 'b': 2, 'c': 3}

    　　dic = {}

   　　 for k, v in [('a', 1), ('b', 2), ('c', 3)]:

        　　dic[k] = v

   　　 ls = []

    　　for k, v in {'a': 1, 'b': 2, 'c': 3}.items():

        　　ls.appen((k, v))

    6.可以通过字典构建任意数据的映射关系：


   　　 type_map = {

       　　 1: '壹',

        　　'壹': 1,

       　　 'owen'：(1, 88888),

       　　 'add': add  # add是功能(函数)

   　　 }

字符编码：

    编码表：人能识别的符号与机器能识别的符号(01组成的二进制码)映射关系

    py2：ASCII，常用ASCII表只有英文、数字、英文符号与与机器能识别的符号的对应关系

    py3：utf-8，是unicode编码表的一种实现方式，采用变长存储数据，字母数字简单符号1个字节，中文3~6字节

    utf-8: 变长，在英文数字较多时，更节省空间，用于传输，cpu与硬盘中采用的编码格式

    utf-16: 定长，英文数字汉字都是采用2个字节，读存效率高，内存中采用的编码格式

    gbk => utf-8: 转码

    　　普通字符串 => 二进制字符串：编码，目的是用于传输数据  'abc'.encode('utf-8')

   　　 二进制字符串 => 普通字符串：解码，目的是用于显示数据  b'abc'.decode('utf-8')

　例子：

# ascii与字符的相互转换
print(10)
print(0B1010)  　　# 二进制 0b
print(0o12) ·　　  # 八进制 0o
print(0xa)  　　　　# 十六进制 0x

# 将数字转化为字符  chr
print(0b01000001)　　　　  #65
print(chr(0b01000001))　　#A
print(chr(65))　　　　　　　#A

# 将字符转化为数字  ord
print(ord('A'))　　　　 #65

print(chr(9326))　　　　　
print(ord('①'))　　　　#9312

# -128 ~127: 一个字节占8个二进制位，首位为符号位
# -32768~32767
# 11111111 ~ 01111111 => -127 ~ 127 | 10000000(-128), 00000000 => -128 ~127
# 原码 补码

print('abc呵呵'.encode('utf-8'))　　　　#b'abc\xe5\x91\xb5\xe5\x91\xb5'

print(b'abc\xe5\x91\xb5\xe5\x91\xb5'.decode('utf-8'))　　#abc呵呵

# 二进制流
print(126187 * 16 + 7)    #字节大小计算

'''

# 普通字符串：u'以字符作为输出单位'

print(u'abc')  # 用于显示  abc

# 二进制字符串：b'' 二进制字符串以字节作为输出单位

print(b'abc')  # 用于传输  b'abc'

  # 原义字符串：r'以字符作为输出单位，所有在普通字符串中能被转义的符号在这都原样输出' print(u'a\tb\nc') print(r'a\tb\nc') # 取消转义 print(r'F:\python8期\课堂内容\day08\代码\1.三种字符串.py')

'''
1.打开文件: 硬盘空间被操作系统持有，文件对象被应用程序持有


　　f = open('source.txt', 'r', encoding='utf-8')

2.操作文件


　　data = f.read()


3.释放文件：释放操作系统对硬盘空间的持有

　　f.close()

'''

f = open('source.txt', 'r', encoding='utf-8')

f.read()  # 将所有内容一次性读完

f.read(10)  # 读取指定字符数

f.readline()  # 一次读取一行(文件的换行标识就是结束本次读取的依据)

f.readlines()  # 将所有内容读存，按换行标识作为读取一次的依据，存放为列表

f.close()

wf = open('target.txt', 'w', encoding='utf-8')

wf.write('123\n')  # 一次写一条，行必须用\n标识

wf.write('456\n')

wf.flush()  # 向操作系统发送一条将内存中写入的数据刷新到硬盘

wf.write('789\n')

wf.writelines(['abc\n', 'def\n', 'xyz\n'])  # 一次写多行，行必须用\n标识

wf.close()  # 1.将内存中写入的数据刷新到硬盘 2.释放硬盘空间

# 优化整合了文件资源的打开与释放

#        -- 在with的缩进内可以操作文件对象，一旦取消缩进，资源就被释放了

# part1

# as起别名，rf持有文件资源的变量

with open('target.txt', 'r', encoding='utf-8') as rf:

    # 文件操作的具体代码

# 缩进一旦取消缩进，资源就被释放了

# part2

with open('target.txt', 'r', encoding='utf-8') as rf1, open('target1.txt', 'r', encoding='utf-8') as rf2:

    print(rf1.read())

    print(rf2.read())

# print(rf1.read())  # 报错

# print(rf2.read())  # 报错

# part3

with open('target.txt', 'r', encoding='utf-8') as rf1:

    with open('target1.txt', 'r', encoding='utf-8') as rf2:

        print(rf1.read())

        print(rf2.read())

    # print(rf1.read())  # 可以操作

    # print(rf2.read())  # 不可以操作

'''


主模式：r | w | a | x

    -- 主模式只能选取一个，规定着主要的操作方式
从模式：t | b | +

    -- 从模式也必须出现，但个数不一定是一个，为主模式额外添加功能

r: 读，文件必须有，没有则报错

w: 清空写，文件可有可无，有则情况写，没有创建写

a: 追加写，文件可有可无，有则追加写，没有创建写

x：创建写，文件必须无，文件有则报错

t：默认，按字符操作

b：按字节操作

+：可读可写

#按照字符形式：

# rt: 文件必须提前存在，不存在报错，文件操作采用字符形式 - 简写为 r

# wt: 文件可以存在，也可以不存在，存在则清空后写入，不存在新建后写入，文件操作采用字符形式 - 简写为 w

# at: 文件可以存在，也可以不存在，存在在之前内容的末尾追加写入，不存在新建后写入，文件操作采用字符形式 - 简写为 a

#按照字节形式：

# rb: 文件必须提前存在，不存在报错，文件操作采用字节形式

# wb: 文件可以存在，也可以不存在，存在则清空后写入，不存在新建后写入，文件操作采用字节形式

# ab: 文件可以存在，也可以不存在，存在在之前内容的末尾追加写入，不存在新建后写入，文件操作采用字节形式

# r+t：文件必须存在的可读可写，默认从头开始替换写，按字符操作

# w+t：文件存在清空不存在创建的可读可写，按字符操作

# a+t：文件存在追加不存在创建的可读可写，按字符操作

# r+b：文件必须存在的可读可写，默认从头开始替换写，按字节操作

# w+b：文件存在清空不存在创建的可读可写，按字节操作

# a+b：文件存在追加不存在创建的可读可写，按字节操作

'''

'''

t模式下：原文件采用什么编码，你就选取什么编码操作，如果不选取，默认跟操作系统保持一致

    -- t模式下一定要指定编码

b模式下：硬盘的数据就是二进制，且能根据内容识别出编码，写入时的数据也是通过某种编码提前处理好的，所有在操作时，没有必要再去规定编码

'''

# 文本文件的复制：可以t也可以b

with open('target.txt', 'r', encoding='utf-8') as rf:

    with open('target2.txt', 'w', encoding='utf-8') as wf:

        for line in rf:

            wf.write(line)

with open('target.txt', 'rb') as rf:

    with open('target3.txt', 'wb') as wf:

        for line in rf:

            wf.write(line)

# 非文本文件只能采用b模式操作，不需要指定编码 - 因为根本不涉及编码解码过程

with open('001.mp4', 'rb') as rf:

    with open('002.mp4', 'wb') as wf:

        for line in rf:

            wf.write(line)

# 1.游标操作的是字节，所有只能在b模式下进行操作

# 2.游标操作可以改变操作位置，r模式下可以改变位置进行操作，所有主模式选择r模式

# 3.seek(offset, whence):

#       -- offset为整数就是往后偏移多少个字节，负数就是往前偏移多少个字节

#       -- whence：代表将游标置为开头，代表从当前位置，代表将游标置为末尾

# 你是日本人

with open('target.txt', 'rb') as f:

    # 先读6个字节

    data = f.read(6)

    print(data.decode('utf-8'))  # 你是

    # 将游标从头开始往后偏移3个字节

    f.seek(3, 0)

    data = f.read(6)

    print(data.decode('utf-8'))  # 是日

    # 从当前游标位置往前偏移3个字节

    f.seek(-3, 1)

    data = f.read(3)

    print(data.decode('utf-8'))  # 日

    f.seek(-3, 2)

    data = f.read(3)

    print(data.decode('utf-8'))  # 人

'''

#秒传案例

id_str = b''

with open('001.mp4', 'rb') as f:

    data = f.read()

    length = len(data)

    print(length)

    f.seek(0, 0)   　　　　　　

    id_str += f.read(10)    　#读10个字节

    f.seek(length // 2, 0)

    id_str += f.read(10)

    f.seek(-10, 2)　　　　　　　#从当前游标位置往前偏移10个字节

    id_str += f.read(10)

print(id_str)

new_id_str = b''

with open('002.mp4', 'rb') as f:

    data = f.read()

    length = len(data)

    print(length)

    f.seek(0, 0)

    new_id_str += f.read(10)

    f.seek(length // 2, 0)

    new_id_str += f.read(10)

    f.seek(-10, 2)

    new_id_str += f.read(10)

if new_id_str == id_str:

    print('秒传成功')

else:

    print('慢传')

'''