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)
所有的问题都是最后一刻解决，如果没有解决，说明你还没有到最后
