day03-课堂笔记

# 数据类型
"""
# int
# py2存放长整型：long
# py3环境，所以整型均由int存储
num1 = -10
num2 = 100000000000000000000000000000000000000000888
print(num1, type(num1))
print(num2, type(num2))

# complex
cp = complex(4, 5)
print(cp, type(cp))

# float
f = float(3)
print(f, type(f))

# bool: 在内存中就是存储0、1
print(True, type(True))  # True 'bool'

# isinstance(obj, type)  # 判断某对象是否是某类型
print(isinstance(3.14, int))
print(isinstance(True, bool))  # True
print(isinstance(True, int))  # True

res = True
print(type(res) == int)  # False

"""

# 字符串
# '' ""  """ """
print('good "boy"')

s = 'hello world!!!'
# 索引取字符 *****
print(s[1])  # 正向索引从0开始
print(s[-4])  # 反向索引从-1开始

# 切片 *****
res = s[6:-3:]  # 顾头不顾尾
print(res)

# 列表与字符串相互转换 *****
res = s.split(' ')
print(res)  # 按空格拆分为list
res = '-'.join(res)
print(res)

# 替换 ****
ns = s.replace('!', '.')
print(ns)
print(s)
ns = s.replace('!', '.', 1)
print(ns)
ns = s.replace('!!!', '.')
print(ns)

# 查找子字符串的出现次数 ***
ct = s.count('o', 0, 6)  # sub starIndex endIndex
print(ct, )

# 字符串的长度 *****
print(len(s))

# 判断是否能转换为int *****
print('12'.isdigit())

# 大小写切换
print('abc'.upper())
print('ABC'.lower())

# list: 可变
# 自身指向的内存空间(地址)不发生改变时，可以改变地址指向的内存空间中的内容
ls = []
print(id(ls))
# 增删改查
ls.append(1)
ls.append(2)
ls.append(3)
print(ls)
print(id(ls))
# 插入
ls.insert(len(ls), 4)
print(ls)
ls.insert(0, 0)
print(ls)
# 删
del ls[2]
print(ls)
ls = [0, 1, 3, 4, 0, 0]
ls.remove(0)
print(ls)
res = ls.pop(4)
print(ls, res)

# 翻转
ls.reverse()
print(ls)

# 排序
ls.sort(reverse=True)
print(ls)

# 多值添加
ls = [0, 1, 2]
ls.extend('abc')
print(ls)
ls.extend([1, 10, 20, 30])
print(ls)

# 可以被for循环的类型就叫可迭代类型
for v in 'abc':
    print(v)

for o in [10, 20, 30]:
    print(o)

# 嵌套
ls = [
    [1, 2, 3],
    [4, 5, 6, [10]],
    'xyz'
]
print(ls)
# 取[1, 2, 3]子list
print(ls[0])
# 取数字5
print(ls[1][1])
print(ls[1][3][0])
# 取字母z
print(ls[2][2])

# 元组：不可变的list
# 元组(不可变)与列表(可变)的转化
print(tuple([1, 2, 3]))
print(list((1, 2, 3)))

# 字典: 没有索引(无序存储)，按key取值
dic = {}
print(dic, type(dic))

# 增删改查
dic['name'] = 'Bob'
print(dic)
dic['name'] = 'Jerry'
print(dic)
del dic['name']
print(dic)
# 按[key]查
# print(dic['name'])  # key不存在就抛异常
# 带默认值取值 *****
dic['name'] = 'Bob'
print(dic.get('name', 'key不存在'))

# 删除
dic = {
    'name': 'Owen',
    'age': 18,
    'gender': 'God'
}
res = dic.pop('age')
print(res)
print(dic)

# 从最后删除，返回(k, v)
k, v = dic.popitem()
print(k, v)

dic = {'name': 'Owen', 'salary': '66666', 'height': 180}
# 设置默认值：没有该key添加并设置默认值，如果有，不做操作
dic.setdefault('salary', '88888')
print(dic)
dic['height'] = 185
print(dic)

# 通过keys初始化字典
dic = dic.fromkeys(('name', 'age', 'gender'), None)  # 通过默认值给None一般省略
print(dic)

---

# 多值更新
dic = {'name': 'Engo', 'salary': 100}
dic.update({'name': "Egon", 'age': 58, 'gender': '未知'})
print(dic)

# 类列表类型，不能直接通过index取值，但可以被for循环迭代取值
print(dic.keys())
print(dic.values())
print(dic.items())

for k in dic.keys():
    print(k, ":", dic[k])
print('------------------------------------')
for v in dic.values():
    print(v)

print('------------------------------------')
for k, v in dic.items():  # *****
    print(k, v)

a, b, c = [1, 2, 3]
print(c)
a, b, _ = (1, 2, 3)
print(a)

# 嵌套: JSON
dic = {
    'students': [
        {
            'name': 'Bob',
            'id': 1,
            'gender': '男'
        },
        {
            'name': 'Tom',
            'id': 2,
            'gender': '女'
        }
    ],
    'teachers': []
}

stus = dic['students']  # list
tom_stu = stus[1]  # dic
name = tom_stu['name']
print(name)
print(dic['students'][1]['name'])
print('======================')
for k, v in dic.items():
    # 只遍历学生
    if k == 'students':
        for stu in v:
            for s_k, s_v in stu.items():
                print(s_k, ":", s_v)
            print('--------------')
    if k == 'teachers':
        pass

---

# 无序、无key、无索引集合

# set特定：存放数据具有唯一性:去重
# 应用场景：处理大量有重复信息的数据，对其去重，如果需要取值，将其转化为list
s = set()
print(type(s), s)

# 增
s.add('a')
s.add('b')
s.add('a')
s.add('b')
s.add('c')
print(s)
# 取值, 遍历(set也提供了自身遍历)
ls = list(s)
print(ls)
# 遍历
for v in s:
    print(v)

# 多个关系set完成关系运算
py = {'a', 'b', 'c', 'egon'}
ln = {'x', 'y', 'z', 'egon'}
# 只报python, 反过来Linux
res = py - ln
print(res)
res = ln.difference(py)
print(res)

# 两个都报了的
res = py & ln
res = py.intersection(ln)
print(res)

# 只报一门
res = py ^ ln
res = py.symmetric_difference(ln)
print(res)

# 报名的学生
res = py | ln
res = py.union(ln)
print(res)

---

# 乱码：存和取所采用的编码不一致

# 编码：ascii，unicode, gbk, gb2312, utf-8

# 电脑组成：硬盘 - 内存 -(二级缓存、一级缓存、cpu寄存器)- cpu

# cpu交互的是用户能识别的数据：字符
# 硬盘中最终存储的数据：0,1的二进制数据(可以直接转化为电脑能识别的高低电频)

# 什么是字符编码：将人识别的字符转换计算机能识别的01，转换的规则就是字符编码表
''' 编码表 对应关系
你好 <=> 000010001001010101
好的 <=> 001010001001010000
'''

# 最早期对应关系：ascii编码表 - 存放的是英文数字与机器二进制的对应关系
# 数字70对应ascii表，指向的是字母'F'
print(chr(70))  # 'F'
print(ord('f'))  # 102

# 字符所占字节数
# 1字节 = 8个二进制位 00000000 ~ 11111111 256个数字 -128 ~ 127

# ascii中一个字母或数字占一个字节

# 中文
# GBK： 16个二进制位 15个0到15个1
# 兼容ascii，一个字母或数字占一个字节
# 2w多汉字，用两个字节进行存储

'''
你好 <=> 00000101010101001011 <=> 콱봤
'''
# 日文/韩文：Shift_JIS、Euc-kr

# 国际上交流：
# 一条信息中，可能同时出现英文/中文/日文/韩文，将所有信息存储，且不乱码
# 万国编码表：unicode
# unicode采用两个字节存放数据：utf-8，utf-16
# utf-8采用变长存储：1字节存放数字与英文，3字节存放汉字
# utf-16采用定长存储：均以2字节存放数字，英文，汉字

# 内存中用utf-16存取数据：定长存取效率高（变长需要计算后才存取）
# cpu中与硬盘中，采用utf-8存放数据（utf-8传输更快）

---

# 操作文件的三步骤
# 1、打开文件
# f被程序持有，文件被操作系统持有
# f = open('file.txt', 'r', encoding='utf-8')  # r读文件，文件一定要提前存在
# del f
# f.close()

# 2、操作文件
# data = f.read()  # 读所有内容
# print(data)

# data = f.read(2)  # 读指定字节数或字符数
# print(data)
# d1 = f.read(1)  # 在当前位置接着再读1个字节或字符
# print(d1)

# line = f.readline()  # 读取一行
# print(line)

# lines = f.readlines()  # 按行，将所有行一次一次读出到list中
# print(lines)

# 3、关闭文件
# f.close()  # 操作系统对文件的持有权一定要在文件操作完毕后释放
# del f

w = open(r'file.txt', 'w', encoding='utf-8')
w.write('123\n')
w.flush()  # 数据量过大时，可以手动将内存中的数据刷新到硬盘中
w.write('456\n')
w.writelines(['000\n', '111\n', '222\n'])

# 是否可读可写
print(w.readable())
print(w.writable())

w.close()

print('end')

---

'''
主模式：
r:  文件必须存在的读
w:  文件无需存在的写，无创建，有清空再写
a:  文件无需存在的写，无创建，有在文件最后追加写

从模式：
t:  按文本字符操作数据（默认模式）
b:  按文本字节操作数据
+:  可读可写

了解：
x：新建文件写，如果文件已存在，抛异常
'''

# with open语法
# with open('file.txt', 'x', encoding='utf-8') as f:  # 不需要明文书写f.close()
#     # data = f.read()
#     # print(data)
#     print(f.readable())
#     print(f.writable())

# 追加模式
# with open('file.txt', 'a', encoding='utf-8') as f:
#     f.write('123\n')
#     print(123)
#     print(123)
#     f.write('456\n')
#     f.flush()
#     f.write('789\n')

# 字节方式操作文件
"""
你好
好的
123
"""
# 注：b操作模式下不需要指定encoding，
# 原因，因为b可以对所有类型数据进行操作，包含文本/视频/音频等各种文件
# 而utf-8只是文本文件的编码方式
# 数据在硬盘中本就以二进制进行存储的，所有b默认操作就是对数据从硬盘到内存的拷贝
# with open('file.txt', 'rb') as f:
#     data = f.read()
#     print(data)
#     # 但如果数据要展现给用户，文本文件就要涉及解码，其他文件需要通过专业工具打开
#     print(data.decode('utf-8'))

# with open('file.txt', 'ab') as f:
#     f.write(b'\n\xe5\x91\xb5\xe5\x91\xb5')

# r+: 从头开始写， a+：从尾开始写， w+：清空写
with open('file.txt', 'rb+') as f:
    print(f.readable())
    print(f.writable())
    # print(f.read())
    f.write(b'999')

---

'''
123
你好
456
'''
with open('file.txt', 'w', encoding='utf-8') as f:
    f.write('123\n你好\n456\n')

# 大前提: 游标操作一定要在b模式下进行操作，因为游标一定按字节进行偏移
# seek(偏移量, 操作位置)
#  操作位置：0,从头开始 1,从当前位置开始 2,从最后开始
# with open('file.txt', 'rt', encoding='utf-8') as f:
#     d1 = f.read(7)
#     print(d1)
#     f.seek(1, 0)
#     d2 = f.read(1)
#     print(d2)
# seek()在操作位置为0时，可以兼容t模式，但任然按字节进行偏移

with open('file.txt', 'rb') as f:
    d1 = f.read(14)
    print(d1)
    # f.seek(1, 1)  # 在当前位置往后偏移1个字节
    # f.seek(-1, 1)  # 在当前位置往前偏移1个字节

    f.seek(-3, 2)  # 将鼠标移至到文件末尾，往前偏移3个字节

    d2 = f.read(1)
    print(d2)

---

# 文件的修改
# rb+:在当前位置进行覆盖书写
with open('change.txt', 'rb+') as f:
    f.seek(14, 0)
    print(f.read(2))
    f.seek(-2, 1)
    f.write(b'16')

# ab+:可以操作游标，但只对读起作用，写任然是最后追加
# with open('change.txt', 'ab+') as f:
#     f.seek(14, 0)
#     print(f.read(2))
#     f.seek(-2, 1)
#     print(f.read(2))
#     f.write(b'18')

with open('change.txt', 'rb+') as f:
    data = f.read()
    newData = data.decode('utf-8').replace('16', '016')

    f.seek(0, 0)
    f.write(newData.encode('utf-8'))

---

# 复制文件
with open('old.txt', 'r', encoding='utf-8') as f1, open('new.txt', 'w', encoding='utf-8') as f2:
    # 文件的循环
    for line in f1:  # 对可读文件对象直接遍历循环，得到的是一行行内容
        print(line)
        f2.write(line)

import os
with open('001.png', 'rb') as f1, open('002.png', 'wb') as f2:
    for line in f1:
        f2.write(line)
# 按指定路径将文件删除
os.remove(r'D:\python周末四期\day03\代码\001.png')

---

mk = b""
# 计算得到秒传依据
with open('002.png', 'rb') as f:
    data = f.read()
    # print(data)
    length = len(data)
    print(length)
    # 设置秒传算法：1.截取的部分字节，2.加密字节的算法

    # 1.从头开始读10个字节，中间读10个字节，末尾读10个字节
    # 2.将所有数据进行拼接
    f.seek(0, 0)
    d1 = f.read(10)
    f.seek(length // 2, 0)
    d2 = f.read(10)
    f.seek(-10, 2)
    d3 = f.read(10)
    mk = d1 + d2 + d3

print(mk)

# 实现秒传
with open('200.png', 'rb') as f:
    new_mk = b''
    f.seek(0, 0)
    new_mk += f.read(10)
    f.seek(length // 2, 0)
    new_mk += f.read(10)
    f.seek(-10, 2)
    new_mk += f.read(10)
    if new_mk == mk:
        print('秒传')
    else:
        print('调用上传方法，进行龟速上传')

# with open('200.png', 'rb+') as f:
#     f.seek(-7, 2)
#     f.write(b'12')

---

# 什么是函数：用来完成特定功能的代码块，类似于工具，可以重复不但的去使用

# 为什么要有函数
# 1. 避免代码的冗余
# 2. 让程序代码结构更加清晰
# 3. 让代码具有复用性，便于维护

# while True:
#     print('老男孩万岁')

# print('egon:给我买水')
# print('owen:给你哇哈哈')
#
# print('egon:我想和哇哈哈')
# print('egon:给我买水')
# print('owen:给你哇哈哈')
#
# print('egon:我口渴了')
# print('egon:给我买水')
# print('owen:给你哇哈哈')
#
# print('egon:我失恋了')
# print('egon:给我买水')
# print('owen:给你哇哈哈')

# 函数的语法
def get_water(money):
    print('egon:给我买水,给你%s' % money)
    print('owen:给你哇哈哈')
    return '哇哈哈'

res = get_water(2.5)
print(res)
'''
def：定义函数的关键词  *****

def 函数名(参数列表):
    函数体
    return 返回值

get_water：函数名（工具名，使用工具的依据）
(money)：参数
print()...：函数体（功能实体）
return：函数的返回值
'''

---

# 函数四部分
'''
1. 函数名：使用该函数的依据, 没有函数名就无法正常使用函数
2. 函数体：完成功能的代码块，没有函数体事都做不了
3. 返回值：功能完成的反馈结果，函数做完事一定要有结果，且要告诉外界
4. 参数：完成功能需要的条件信息，函数内部要使用一些外部数据
'''

# 参数可有可无
# return一定有，但存在方式多种
def fn(a, b):
    return

# 参数范畴
# 生产零件: 不需要参数
def make_flag():
    print('立个flag')
make_flag()
make_flag()

# 购物：需要参数
def shopping(money, goods):
    print('花了%s钱买了个%s' % (money, goods))
shopping(10000, '表')

# 返回值

# 没有写return，默认返回None
def fn():
    pass
res = fn()
print(res)

# 主动书写return，返回None
def fn2():
    return
res = fn2()
print(res)

def fn1(info):
    if info == 123:
        return  # 主动结束函数，如果不写return，默认只能在函数最后结束函数
    print(info)
fn1(123)

# 结束函数且带出一个值
def fn3():
    return 1
res = fn3()
print(res)

# 结束函数且带出多个值: 本质就是带出一个元组
def fn3():
    # return 1, 2, 3, 4, 5
    return (1, 2, 3, 4, 5)
# res = fn3()
# print(res)
a, b, c, d, e = fn3()
print(a, b, c, d, e)