qq_39106949的博客

#author F username = "123" password = "321" def login(cate): def outerwraped(func): def wrapped(*args, **kwargs): user = input("Username").strip() passw = input("P

#author F import sys,time f = open("file", "r", encoding="utf-8") print(f.tell()) print(f.readline().rstrip()) print(f.read(5)) print(f.tell()) print(f.read()) print("分割线".center(50, "-")) print(f

# http # smtp # dns # ftp:下载上传文件 # ssh # snmp # dhcp # icmp ping :网络层 (其他都是在传输层之上 都是应用层 ) # 数据的交换: 收/发两个步骤 # OSI七层模型: # 物理层 # 数据链路 mac(十六进制) 计算机只认识mac地址 # 网络 IP 双方互相识别 # TCP/IP:三次

#author F #文件的修改: 必须把东西扔到版内存里 (vim) # test # 不是除了你，我就没人要了。只是除了你，我谁都不想要。 # # 晓看天色暮看云，行也思君，坐也思君。 # # 螃蟹在剥我的壳，笔记本在写我。 # 漫天的我落在枫叶上雪花上。 # 而你在想我。 # # 夜澜卧听风吹雨，铁马是你，冰河也是你。 # # 对不起，情话是我学的，但爱你是真心的。 # # 用我一生换你十

# socket_client import socket client = socket.socket() #申明socket类型 同时生成socket链接对象 client.connect(('localhost', 6969)) client.send(b"hello world") #所有的数据传输接受都需要使用bytes类型 中文 encode("utf-8") data = c

#author F #字符编码 import sys print(sys.getdefaultencoding()) #打印默认编码 ''' #python2中编码转换 s = "你好" s_to_unicode = s.decode("utf-8") print(s_to_unicode) s_to_gbk = s_to_unicode.encode("gbk") print(s_to_gb

#author F import time #面向对象 : 类 --->class #面向过程 : 过程-->def #函数式编程 : 函数-->def #定义函数 def func1(): """testing""" print("in the func1") return 0 #定义过程 def func2(): """testing""" p

# 类 # 包含属性和方法 # 属性包括实例变量和类变量 # 什么时候用到类变量: 中国人->国籍 # 私有属性: __name # 方法: # 构造方法 # 析构方法: 析构函数不管写不写都会执行 写相当于重构 不写:本身就有一个析构方法 # 对象 # 实例化一个类之后得到的对象 # 封装 #

#author F #递归 : 自己调用自己 #必须有一个明确的结束条件 #每次进入更深一层递归时 问题规模要比上一层小 #递归效率不高, 递归层次过多会导致栈溢出 函数的调用是通过栈来实现的 def calc(n): print(n) return calc(n+1) # calc(0) def mul(n): print(n) if int(n/2) >

#author F #模块的定义:用来从逻辑上组织python代码(变量/函数/类/逻辑),本质就是实现一个功能(以py结尾的python文件 module.py, 使用模块->import module) #包:本质就是一个文件夹(目录),必须带有一个__init.py__文件, 是从逻辑上组织模块的 name = "Aux Air conditioner" def sayHello():

# 异步IO\数据库\队列\缓存 # 1.协程:线程上下文切换会保存到cpu的寄存器里 协程是由用户自己实现的 # 2.函数中有yield时候会变成生成器 最简单的协程 # 3.send有两个作用: 唤醒生成器并传递数据 (交互) # 4.遇到IO操作就切换 协程处理并发的原理就是避开IO操作 # IO操作完成切回去 IO操作系统负责操作系统的控制 # 5.greenlet 手动切换 # 6.

# 1 动态导入模块 # import importlib # # __import__("import_lib.metaclass") #这是解释器自己调用的 到lib为止 # # import_lib.metaclass #不建议使用 # importlib.import_module("lib.metaclass") #直接到lib.metaclass 写

#author F #装饰器: 本质是函数 为其他函数添加功能 文章发表过程->前后添加->运营添加->... #已经上线 100个函数用到 需要修改 #装饰器原则: 1.不能修改被装饰函数的代码 # 2.不能修改被装饰的函数的调用方式 #也即: 装饰器对被装饰函数是透明的 对被装饰函数完全不影响 import time ''' def timmer(func):

#author F import time def timer(func): def deco(*args, **kwargs): #保证传递所有参数都能使用 start_time = time.time() func(*args, **kwargs) stop_time = time.time() print("cost

# 1.线程和进程的区别? # 进程 -> 资源的集合 # 线程 -> 操作cpu的最小调度单位 # 进程和线程谁快? 无法比 # 进程至少包含一个线程,进程需要靠线程启动 # 线程之间内存是共享的,线程同时修改同一份数据时需要加锁 互斥锁 # 递归锁->锁中有锁 # 2.join等待线程执行结束 启动线程的语法 # def run(): # ... # t_joins =

# 反射: # hasattr() 判断一个对象里是否有对应的 name_str 字符串的方法 # getattr() 根据字符串获得对象里的对应的方法的内存地址 后面+()可调用 # setattr(obj, 'name', value) 通过字符串设置一个值 # delattr(obj, "str") def eat(self): print("eat") class Dog(ob

# 类的特殊成员方法 import sys class Cat(object): '''这个类是描述喵这个对象的''' def __init__(self, name, age): self.name = name self.age = age def __call__(self, *args, **kwargs): pr

#author F #迭代器 #列表生成式 list_build = [2*i for i in range(0, 24)] #2*i可以改成某函数 print(list_build) # 相当于三行代码 list_man_made = [] for i in range(0, 24): list_man_made.append(2*i) print(list_man_made)

#author F #单线程下的并行效果 (生成器) #协程 import time def consumer(name): print("%s 准备吃包子啦" %name) while True: baozi = yield print("包子%s来啦 被%s吃啦!" %(baozi, name)) c = consumer("WW") #

#author F #迭代器 #可直接作用于for循环的数据结构有: str,list,dict,set,tuple(元组),generate #这些可直接作用于for循环的对象统称为可迭代对象Iterable #判断一个对象是否是可迭代 可循环的 : isinstance() from collections import Iterable print(isinstance([], Iter

#author F #模块的定义:用来从逻辑上组织python代码(变量/函数/类/逻辑),本质就是实现一个功能(以py结尾的python文件 module.py, 使用模块->import module) #包:本质就是一个文件夹(目录),必须带有一个__init.py__文件, 是从逻辑上组织模块的 name = "Aux Air conditioner" def sayHello():

#author F #内置函数 print(abs(-5)) #绝对值 print(all([0, -5, 13])) #如果可迭代对象都为真 返回true 如果有不为真 返回false print(any([0, -5, 13])) #如果有一个对象为真 返回true 如果都不为真 返回false print(any([])) #false a = ascii([1,2,3,"大苏打

#json序列化和反序列化 ''' info = { 'name': 'AxiBa', 'sex': 'male' } f = open('test.txt', 'a', encoding="utf-8") f.write(str(info)) f.close() ''' import json info = { 'name': 'AxiBa', 'sex': 'm

import pickle def say(): print("hello One") info = { "test1":"111111", "test2":"222222", "test3":say #pickle可以dump函数(内存地址) } f = open("test.txt", "wb") pickle.dump(info, f)# f.write(pi

#author F import os import sys print(__file__) #相对路径 print(os.path.abspath(__file__)) #绝对路径 print(os.path.dirname(os.path.abspath(__file__))) print(os.path.dirname(os.path.dirname(os.path.abspath(__f

# 面向对象 # # 特性 # class 类 :对一类拥有相同属性的对象的抽象,蓝图,原型 定义对象的共同方法 # object 对象:类的实例化后的实体 一个类可以实例化多个对象 每个对象亦有不同的属性 # # 封装: 内部调用对外部是透明的 里面包含类的数据和方法 (内脏= =) # 继承: 一个类派生出子类 父亲的属性,方法自动被子类继承 (财产,基因) # 多态: 一个接口多种实现,

#author F datas = { "实务": { "主体": { "政府": { "利益": { "政治利益", "物质利益", "精神利益(文化)", "民生利益(保障)", "生态利益" }, "思想":

#author F list_1 = [1, 4, 6, 8, 6, 34, 77] list_1 = set(list_1) #列表转集合 集合和字典一样 都是无序的 print(list_1, type(list_1)) list_2 = set([4, 5, 6, 98, 2, 5]) print(list_1, list_2) #交集 print(list_1.intersectio

import threading,queue import time # 最简单的线程并发 # def run(*args): # print("threading", args) # time.sleep(2) # # run("t1") # run("t2") # # t3 = threading.Thread(target=run, args=("t3",)) #必须使用

# 面向对象 # # 特性 # class 类 :对一类拥有相同属性的对象的抽象,蓝图,原型 定义对象的共同方法 # object 对象:类的实例化后的实体 一个类可以实例化多个对象 每个对象亦有不同的属性 # # 封装: 内部调用对外部是透明的 里面包含类的数据和方法 (内脏= =) # 继承: 一个类派生出子类 父亲的属性,方法自动被子类继承 (财产,基因) # 多态: 一个接口多种实现,

# 进程/线程/协程 # IO:同步/异步/阻塞/非阻塞 # greenlet gevent # 事件驱动与异步IO # Select\Poll\Epoll异步IO 以及selectors模块 # Python队列/RabbitMQ队列　　 #############################################################################