开发者笔记
目录
- 1.叠加装饰器的装饰顺序与执行顺序
- 2.什么是无参装饰器与有参装饰器
- 3.简述可迭代对象，迭代器对象及迭代取值方式，及for循环内部原理
- 4.迭代器对象的优缺点是什么？
- 5.请实现一个装饰器,限制该函数被调用的频率,如10秒一次
- 6.什么是序列化？什么是反序列化？为什么要这么做？
- 7.什么是json与picjle的区别是什么？
- 8.ATM的登录与注册功能，用户数据用json数据保存。
- 9.写一个扑克牌随机发牌游戏
- 10.爬虫正则
- 11.面向对象编程的优缺点是什么？
- 12.对象的属性查找顺序是什么？
- 13.什么是继承？继承的目的？
- 14.python与期他语言的继承区别是什么？
- 15.如何寻找继承关系？
- 16.继承背景下对象属性的查找顺序是什么？
- 17.什么是派生？如何重用父类的属性并派生？两种方式
- 18.什么是新式类与经典类？
- 19.钻石继承下，经典类与新式类属性的查找顺序是什么？
- 20.下面这段代码的输出结果将是什么？请解释。
- 21.下述代码新式类与新式类的查找顺序是什么？
- 22.什么是组合？为什么要使用组合？
- 23.什么是封装？
- 24.什么是访问限制机制？
- 25.访问限制机制的优点？
- 26.什么是property？为什么要使用property？
- 27.输入半径，计算圆的面积、周长
- 29 上传下载电影
- 30.二进制转其他字符类型：
- 31.decode、endoce
1.叠加装饰器的装饰顺序与执行顺序
装饰顺序：从下往上（被装饰函数）
执行顺序：从上往上（python代码的执行顺序）
1.1无参装饰器模板：
def outter(func):
@wraps(func)
def inner(*args, **kwargs):
# 装饰前做的事
return func(*args, **kwargs)
# 装饰后做的事
retur inner给函数添加测试运行时间的功能：
import time
from functools import wraps
def outter(func):
@wraps(func)
def inner(*args, **kwargs):
start_time = time.time()
res = func(*args, **kwargs)
end_time = time.time()
print(end_time-start_time)
return res
return inner
@outter
def time_func():
time.sleep(1)
time_func()1.2有参装饰器
from functools import wraps
def wrappers(params1,params2,params3):
def outter(func):
@wraps(func)
def inner(*args, **kwargs):
# 装饰前做的事
return func(*args, **kwargs)
# 装饰后做的事
return inner
return outter2.什么是无参装饰器与有参装饰器
无参装饰器：被装饰的函数不需要参数，两层
有参装饰器：被装饰的函数需要参数，三层
说白了，有参装饰器就是再无参装饰器的基础上又添加了一层包装，目的：添加一个参数。那么有没有可能四层、五层？答案是没必要。因为四层、五层就意味着传递了更多的参数，那么我们用三层就能达到效果。所有装饰器最多三层3.简述可迭代对象，迭代器对象及迭代取值方式，及for循环内部原理
3.1迭代器
迭代器：迭代取值的工具 ——（用__iter__生成迭代器对象）
优点：1.不依赖与索引取值
2.内存中只占一份空间，不会内存溢出，节约空间，运行效率更高*（执行一次__next__取值一次，而不是一次全部取值）*
缺点：1.不能获取指定的元素
2.只能依次往后取值3.2 迭代协议
class MyIter:
"""num传入 用来指定迭代次数 """
def __init__(self, num):
self.num = num
self.c = 0
# 迭代
def __iter__(self):
return self
# 取值
def __next__(self):
self.c += 1
if self.c <= self.num:
return "jeff"
else:
raise StopIteration
# 循环取值
for i in MyIter(10):
print(i)3.2 for 循环内部原理
1、在遍历Foo的实例对象时，执行for...in...时，首先会先执行__iter__()方法，将此对象变为迭代器。
2、__iter__方法返回了一个迭代器对象，而后调用next()方法进行循环4.迭代器对象的优缺点是什么？
优点：1.不依赖与索引取值
2.内存中只占一份空间，不会内存溢出，节约空间，运行效率更高*（执行一次__next__取值一次，而不是一次全部取值）*
缺点：1.不能获取指定的元素
2.只能依次往后取值5.请实现一个装饰器,限制该函数被调用的频率,如10秒一次
import time
def outter(func):
def inner(*args, **kwargs):
print('开始调用函数。。。')
res = func(*args, **kwargs)
time.sleep(10)
print('函数调用结束。。。')
return res
return inner
@outter
def index():
print('函数正在执行中。。。')
index()6.什么是序列化？什么是反序列化？为什么要这么做？
序列化：
序列：字符串
序列化：其他数据类型转成字符串的过程
序列化：其他数据类型转成字符串的过程
反序列化：字符串转成其他数据类型
注意：
写入文件的数据必须是字符串（二进制）
基于网络传输的数据必须是二进制7.什么是json与picjle的区别是什么？
json:可以和其他语言玩
pickle:只能和自己（python）玩8.ATM的登录与注册功能，用户数据用json数据保存。
with open(user_path, 'w', encoding='utf-8') as f:
json.dump(user_dic, f, ensure_ascii=False)
f.flush()9.写一个扑克牌随机发牌游戏
飘三叶：
有bug，可取到重复的牌
import random
def fried_golden_flower():
for i in range(0, 3):
color = random.choice(['♥', '♠', '♦', '♣'])
number = random.choice(['A', '2', '3', '4', '5', '6', '7', '8', '9', '10', 'J', 'Q', 'K'])
a = color
b = number
point = namedtuple('扑克牌', ['color', 'number'])
p = point(color, number)
print(p, a+b)
fried_golden_flower()斗地主：
from collections import namedtuple
import random
def fight_against_landlords():
list = ['大鬼', '小鬼']
color = ['♥', '♠', '♦', '♣']
number = ['A', '2', '3', '4', '5', '6', '7', '8', '9', '10', 'J', 'Q', 'K']
for i in color:
for n in number:
list.append(i+n)
# 打乱顺序
random.shuffle(list)
# 生成迭代器，避免取到重复的牌
a = list.__iter__()
for i in range(0,3):
list_s = [] # 将发的17张牌放在此列表中
for num in range(0, 17):
list_s.append(a.__next__())
print("玩家%s：%s" % (i+1, list_s))
dizhupai = []
for i in range(0, 3):
dizhupai.append(a.__next__())
print('地主牌：%s' % dizhupai)
fight_against_landlords()10.爬虫正则
# 注意: 先敲课堂上的代码，理解并记录博客，再写作业！
'''
1.subprocess模块的作用？
subprocess 子进程模块
2.什么是包？包的作用是什么？
包是一个带有__init__.py的文件夹，包也可以被导入，并且可以一并导入包下的所有模块。
3.如何防止模块被导入时自动执行测试功能。
伪代码：
if __name__ == '__main__':
调用执行的函数（）
4.请写出logging模块的使用步骤:
# logging配置字典
LOGGING_DICT = {...}
1.配置日志的路径，项目的路径
2.配置日志的文件（名字，创建日志文件）
3.配置日志字典数据
4.调用日志模块，并把字典数据当参数参数
5.请写出爬虫原理的4个过程？
整个流程：
1.发送请求：requests
2.获取响应数据：对方机器直接返回
3.解析并提取想要的数据：re
4.保存提取后的数据：with open()保存
我们需要做的：
1.发送请求
2.解析数据
3.保存数据
6.什么是正则表达式与re模块？
正则表达式：一种筛选匹配字符串的独立技术
re模块：pycharm利用re模块，匹配字符串
7.使用正则表达式匹配出str1中的地址。
source = '''
<html><h1>www.baidu.com</h1></html>
<html><h1>www.taobao.com</h1></html>
<html><h1>www.jd.com</h1></html>
<html><h1>www.oldboyedu.com</h1></html>
'''
答案1：print(re.findall('www.(?:baidu|taobao|jd|oldboyedu).com', source))
结果：['www.baidu.com', 'www.taobao.com', 'www.jd.com', 'www.oldboyedu.com']
答案2：print(re.findall('www\..*com', source))
8.用正则过滤掉str3中的英文和数字，最终输出"张全蛋 广州"
str3 = "not 404 found 张全蛋 99 广州"
不标准答案：print(re.findall('(?:张全蛋|广州)', str3))
结果：['张全蛋', '广州']
答案:print(re.findall('[^a-z:0-9:A-Z ]{2}', str3))
结果：['张全蛋', '广州']
9.复习今日之前的所有知识点!!!
'''11.面向对象编程的优缺点是什么？
优点：可扩展性高
缺点：相对于面向过程复杂度高12.对象的属性查找顺序是什么？
自己——类——报错class Student:
name = '张全蛋'
def __init__(self, name):
self.name = name
def learn(self):
print('learning...')
stu1 = Student('赵铁柱')
print(stu1.name)
# 结果：赵铁柱 优先查找自己13.什么是继承？继承的目的？
继承是一种创建新类的方式，在python中，新建的类可以继承一个或多个父类，父类又可称为基类或超类（super），新建的类称为派生类或子类14.python与期他语言的继承区别是什么？
python可以多继承，其他语言只能单继承15.如何寻找继承关系？
mro(): 会把当前类的继承关系列出来16.继承背景下对象属性的查找顺序是什么？
自己–>类->报错
17.什么是派生？如何重用父类的属性并派生？两种方式
第一种：super().__init方法
class Animal():
def __init__(self, name, eat, run):
self.name = name
self.eat = eat
self.run = run
print(f'{self.name}会{self.eat}')
print(f'{self.name}会{self.run}')
class Sunwukong(Animal):
def __init__(self, name, eat, run, aa):
super().__init__(name, eat, run)
self.aa = aa
第二种：父类.__init__方法
class Animal():
def __init__(self, name, eat, run):
self.name = name
self.eat = eat
self.run = run
print(f'{self.name}会{self.eat}')
print(f'{self.name}会{self.run}')
class Sunwukong(Animal):
def __init__(self, name, eat, run, aa):
Animal.__init__(self,name, eat, run)
self.aa = aa18.什么是新式类与经典类？
- 新式类:
1.凡是继承object的类或子孙类都是新式类。
2.在python3中所有的类都默认继承object，都是新式类。
- 经典类:
1.在python2中才会有经典类与新式类之分。
2.在python2中，凡是没有继承object的类，都是经典类。19.钻石继承下，经典类与新式类属性的查找顺序是什么？
20.下面这段代码的输出结果将是什么？请解释。
class Parent(object):
x = 1
class Child1(Parent):
pass
class Child2(Parent):
pass
print(Parent.x, Child1.x, Child2.x) # 1 1 1
Child1.x = 2
print(Parent.x, Child1.x, Child2.x) # 1 2 1
Parent.x = 3
print(Parent.x, Child1.x, Child2.x) # 3 2 3
# 结果：
1 1 1
1 2 1
3 2 321.下述代码新式类与新式类的查找顺序是什么？
class A(object):
def test(self):
print('from A')
class B(A):
def test(self):
print('from B')
class C(A):
def test(self):
print('from C')
class D(B):
def test(self):
print('from D')
class E(C):
def test(self):
print('from E')
class F(D, E):
def test(self):
print('from F')
pass
# python3中校验:
FD->DB->FE->EC->CA
# python2中校验:
FD->DB->BA->FE->EC22.什么是组合？为什么要使用组合？
组合指的是一个对象中，包含另一个或多个对象。23.什么是封装？
隐藏对象的属性和实现细节，仅对外提供公共访问方式24.什么是访问限制机制？
在内部在属性前加'__'，使属性私有化。实际上是内部替换了变量名称 方法名 替换为：_类名__方法名25.访问限制机制的优点？
1.让一些关键的数据，变成私有更加的安全
2.不是随意可以更改的
3.在属性，和方法前面加’__‘,变成私有，那么外界就不可以直接调用修改。
4.但是：在类的内部可以定义一个函数，方法调用修改。使用者直接调用这个函数就可以了。这个函数就是接口
5.可以在这个函数、方法加条件限制，而不是任意的改动26.什么是property？为什么要使用property？
让使用者调用方式一致，是一个内置的装饰器。
使用了property内置装饰器之后，使用者调用方法时少了一个括号，导致看起来像获取某个方法，而不是加括号执行某个函数27.输入半径，计算圆的面积、周长
第一种方式：类绑定
import math
class Circular():
# 计算面积
@classmethod
def area(self,randius):
res = math.pi * math.pow(randius, 2)
print(f'面积为：{res}')
#计算周长
@classmethod
def perimeter(self, randius):
res = 2 * math.pi * randius
print(f'周长为：{res}')
Circular.area(10)
Circular.perimeter(10)
# 结果：
面积为：314.1592653589793
周长为：62.83185307179586第二种方式：对象绑定
import math
class Circular():
def __init__(self, randius):
self.randius = randius
# 计算面积
@property
def area(self):
res = math.pi * math.pow(self.randius, 2)
print(f'面积为：{res}')
# 计算周长
@property
def perimeter(self):
res = 2 * math.pi * self.randius
print(f'周长为：{res}')
# 生成对象
A = Circular(10)
# 执行
A.area
A.perimeter
# 结果：
面积为：314.1592653589793
周长为：62.8318530717958628、使用abc模块定义一个Phone手机抽象类，让所有子类都继承手机抽象类，让不同牌子的手机都必须遵循抽象类手机打电话的步骤。
# @abc.abstractmethod子类必须按照父类的方法编写
import abc
class Phone():
@abc.abstractmethod
def call(self):
pass
class Xiaomi(Phone):
def call(self):
print('小米手机正在打电话！')
class Iphone(Phone):
def call(self):
print('我是闪亮苹果BB机，正在打电话！')
# 产生对象
iphone = Iphone()
xiaomi = Xiaomi()
# 执行
iphone.call()
xiaomi.call()
# 结果：
我是闪亮苹果BB机，正在打电话！
小米手机正在打电话！29 上传下载电影
服务端：
import socket
import json
import struct
import os
server = socket.socket()
server.bind(('127.0.0.1', 8080))
server.listen(5)
conn, addr = server.accept()
def unload():
while True:
try:
hand_dict = conn.recv(4)
len_dict = struct.unpack('i', hand_dict)[0]
dict_json = conn.recv(len_dict)
dict = json.loads(dict_json.decode('utf-8'))
move_size = dict['move_size']
accept_size = 0
with open(dict['move_name'], 'wb')as f:
while accept_size < move_size:
accept = conn.recv(1024)
f.write(accept)
accept_size += len(accept)
print('上传成功！')
except StopIteration as f:
print(f)
break
def load():
while True:
try:
DATA_PATH = os.path.dirname(__file__)
MOVE_PATH = os.path.join(DATA_PATH)
# 把电影列表打包传给客户端
move_list = os.listdir(MOVE_PATH)
move_list_json = json.dumps(move_list).encode('utf-8')
hand_dict = struct.pack('i', len(move_list_json))
# 发送报头
conn.send(hand_dict)
# 发送json格式真实电影列表
conn.send(move_list_json)
# 接收客户选择要下载的电影编号 4个字节接受编号，足够
choice = conn.recv(4)
choice = int(choice.decode('utf-8'))
# 根根选择，拿到电影名
move_name = move_list[choice]
# 拼接选择的电影路径
move_name_path = os.path.join(MOVE_PATH, move_name)
# 电影大小
move_size = os.path.getsize(move_name_path)
# 做成字典
move_dict = {'move_name': move_name, 'move_size': move_size}
# 序列化
move_json = json.dumps(move_dict).encode('utf-8')
hand_dict = struct.pack('i', len(move_json))
# 发送报头，和json格式字典
conn.send(hand_dict)
conn.send(move_json)
with open(move_name_path, 'rb')as f:
for i in f:
conn.send(i)
print('下载成功！')
except StopIteration as f:
print(f)
break
def run():
res = conn.recv(4)
res = res.decode('utf-8')
if res == '1':
unload()
elif res == '2':
load()
run()
server.close()
客户端：
import socket
import json
import os
import struct
client = socket.socket()
client.connect(('127.0.0.1', 8080))
# 上传电影
def unload():
while True:
print('---下载电影---')
# 拼接路径
MOVE_PATH = os.path.join('D:\PS素材')
move_list = os.listdir(MOVE_PATH)
for index, move_name in enumerate(move_list):
print(index, move_name)
choice = input('请选择电影编号(q.退出):').strip()
if choice == 'q':
break
if not choice.isdigit():
print('输入数字！')
continue
choice = int(choice)
if choice not in range(len(move_list)):
print('不在范围！')
continue
move_name = move_list[choice]
move_name_path = os.path.join(MOVE_PATH, move_name)
move_size = os.path.getsize(move_name_path)
move_dict = {'move_name': move_name, 'move_size': move_size}
move_json = json.dumps(move_dict).encode('utf-8')
hand_dict = struct.pack('i', len(move_json))
client.send(hand_dict)
client.send(move_json)
with open(move_name_path, 'rb')as f:
for i in f:
client.send(i)
print('上传成功！')
# 下载电影
def load():
while True:
print('---下载电影---')
hand_dict = client.recv(4)
len_dict = struct.unpack('i', hand_dict)[0]
# 接收了json格式的列表
dict_json = client.recv(len_dict)
# 解码电影列表
move_list = json.loads(dict_json.decode('utf-8'))
# 打印列表，展示
for index, move_name in enumerate(move_list):
print(index, move_name)
while True:
choice = input('选择你要下载的电影编号 (q.退出):').strip()
if choice == 'q':
run()
if not choice.isdigit():
print('输入数字！')
continue
choice = int(choice)
if choice not in range(len(move_list)):
print('输入不规范！')
continue
# 如果输入规范，把用户选择的编号传给客户端
choice = str(choice).encode('utf-8')
client.send(choice)
hand_dict = client.recv(4)
len_dict = struct.unpack('i', hand_dict)[0]
dict_json = client.recv(len_dict)
dict = json.loads(dict_json.decode('utf-8'))
move_size = dict['move_size']
accept_size = 0
with open(dict['move_name'], 'wb')as f:
while accept_size < move_size:
accept = client.recv(1024)
f.write(accept)
accept_size += len(accept)
print('下载成功！')
continue
def run():
while True:
print('''
1:【上传电影】
2:【下载电影】
q:退出
''')
choice = input('请选择功能：').strip()
if choice == '1':
client.send(choice.encode('utf-8'))
unload()
elif choice == '2':
client.send(choice.encode('utf-8'))
load()
elif choice == 'q':
break
else:
print('输入不规范！')
continue
if __name__ == '__main__':
run()
30.二进制转其他字符类型：
int 其他进制转十进制
a = int('0b1010011010', 2)
b = int('0o1232', 8)
c = int('0x29a', 16)
print(a,b,c)
# 结果： 666 666 666
bin 十进制转二进制
aa = bin(666)
print(aa)
# 结果 ：0b1010011010
oct 十进制转八进制
bb = oct(666)
print(bb)
# 结果 ：0o1232
oct 十进制转八进制
bb = oct(666)
print(bb)
# 结果 ：0o123231.decode、endoce
第一种：
res = a.encode('utf-8') # 编码
print(res.decode('utf-8')) # 解码
第二种：
res1 = bytes(a, encoding='utf-8') # 编码二进制
res2 = str(res1, encoding='utf-8') # 解码二进制
版权声明：本文为guyouyin123原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。