总结

字符串

s1.stript()去留白
s1.count('xxx')计数
s1.isdigit()是否是数字

列表

删除:ls.remove()删除某一个
增加:ls.extend()将某个集合整体增加
排序：ls.sort()默认正向排序
ls.sort(reverse=ture)反向排序
反转:ls.resverse()

深浅拷贝

不可变类型：数字，字符串，元组
可变类型：列表，字典，集合

值拷贝

只会拷贝目标的内存拷贝过来，目标发生任何变化，拷贝过来的数据都会发生变化

浅拷贝

1.对于不可变类型，浅复制仅仅是地址指向，不会开辟新空间
2.对于可变类型，浅复制会开辟新的空间地址，并将目标的内存地址拷贝过来，目标内部的可变类型值发生改变时，拷贝过去的数据也会发生改变

深拷贝

1.对于不可变数据类型，深拷贝仍然是地址的指向，并不会开辟新的地址空间。
2.对于可变数据类型,深拷贝会开辟新的地址空间,拷贝的目标对象内部所有的数据类型发生改变，拷贝得到的数据对象都不会改变

元组

1.值可以为任意类型
2.可以存放多个值 - 可以进行成员运算
3.可以存放重复的值 - 可以计算成员出现的次数
4.有序存储 - 可以通过索引取值，可以切片

元组和列表的区别

1.元组与列表相同，也是容器对象，可以存储不同类型的内容
2.元组的声明使用小括号，而列表使用方括号，当声明只有一个元素的元组时，需要在这个元素的后面添加英文逗号
3.元组声明和赋值后，不能像列表一样添加、删除和修改元素，也就是说元组在程序运行过程中不能被修改。(即元组属于不可变类型)

小知识（常识）

1.单列容器有：list(字典)和tuple(元组)和集合set
2.双列容器只有字典
3.字典和集合都是无序的，而列表/元组/字符串为有序的

字典

1.字典的删除pop，pop(k)删除指定key的value并返还删除的value
2.循环字典的key：dic.keys()
3.循环字典的values：dic.values()
4.同时循环字典的k,v：dic.items()

集合

1.s = set()
2.set为可变类型
3.set为去重存储 - set中不能存放重复数据
4.增（add）删（clear）改（update）

读写

基本读写

wf = open('target.txt', 'w', encoding='utf-8')
wf.read()或者wf.write()
必须要有wf.flush()刷新到内存

游标

1.游标操作的是字节，所有只能在b模式下进行操作
2.seek(offset, whence):
offset:往后偏移多少个字节
whence：0代表将游标置为开头，1代表从当前位置，2代表将游标置为末尾

垃圾回收机制

1.引用计数，会导致循环引用
2.标记清除，解决循环引用
3.分代回收：1.刚产生的变量值放在新生代中高频率检查，如果引用计数为0，就是采用引用计数机制回收，长期存活的变量值经过多次检查后会提高分代
2.分带又高，检查频率越低，且还能继续提高一直存活的变量值的分带，从而来提高整体垃圾回收的效率

函数

函数的优点

1.避免代码冗余
2.让程序代码结构更加清晰
3.让代码具有复用性，便于维护

global和nonlocal

global：将局部变量变为全局变量
nonlocal：将局部变量变为嵌套局部变量

开放封闭原则

开放封闭原则：在不修改源代码与掉用方式的情况下为函数添加新功能

装饰器

装饰器：满足开放封闭原则的闭包应用
def outer(func):
# 不能确定被装饰的函数的参数：来者不拒，用可边长来接受
def inner(args, **kwargs):
pass # 新功能位
res = func(args, **kwargs) # 解压带给原功能
pass # 新功能位
return res
return inner

迭代器对象和可迭代对象

迭代器对象：有__next__()方法的对象是迭代器对象，迭代器对象依赖__next__()方法进行取值
可迭代对象：有__iter__()方法的对象是可迭代对象，可迭代对象调用__iter__()得到迭代器对象

递归

函数直接或间接调用本身，都称之为递归
递归掉用的案例：1.获取第几个人的年纪
def get_age(count):
if count == 1:
return 58
# 第 九...一 个人 - 2
age = get_age(count - 1) - 2
return age

age = get_age(3)
print(age)
2.求n的阶乘

匿名函数

1.匿名函数没有函数名
2.有关键字lambda
3.关键字lambda与函数功能体：之间一定是参数，所以省略
4.匿名还是没有函数体，只有返回值，所以函数体和返回值的return关键字都省略了
eg：lambda *args, **kwargs: '返回值'
eg：lambda *args, **kwargs: ('返回值1', '返回值2')

os与sys的区别

os:提供了一种方便的使用操作系统函数的方法。
os.mkdir/makedirs('dirname')创建目录/多层目录
os.path.join(path1[,path2[,...]]) 将分离的各部分组合成一个路径名
os.path.exists() 是否存在
os.path.isdir() 是否为目录
os.path.isfile() 是否为文件
sys:由解释器使用或维护的变量和与解释器进行交互的函数
sys.path 返回模块的搜索路径，初始化时使用PYTHONPATH环境变量的值
BASE_DIR = os.path.dirname(os.path.dirname(file))
sys.path.append(BASE_DIR)

验证码

def random_code0(num):
    code = ""
    for i in range(num):
        d = random.randint(65, 90)
        x = random.randint(97, 122)
        n = random.randint(0, 9)
        code += random.choice([chr(d), chr(x), str(n)])
    return code

subprocess

（1）导入模块
import subprocess

内存中 每个进程的内存区域是相互隔离的不能直接访问 所以需要管道来通讯

stdout=subprocess.PIPE就是指定了一个输出管道

（2）# 通过管道来获取命令
p = subprocess.Popen("dir",shell=True,stdout=subprocess.PIPE)
（3）# 从管道中读取出执行结果
reuslt = p.stdout.read().decode("GBK")

面向对象

封装：隐藏对象的属性和实现细节，仅对外公开接口，控制程序的访问权限
封装的目的：保护数据的安全和隔离复杂度

封装的方法

1.属性的封装：
需要在属性前加双下'__'线，在外部事不可以通过直接点得到的，也不能在外部修改，如果想要修改，需要在内部定义函数修改，外部掉用这个公有的函数方法传参修改
2.函数方法的封装：
与属性的封装同样道理，但如果想要访问到需要将名字变为_类名__x的形式

封装之property

property：将一个方法伪装成一个普通属性，对象可以通过点的方式来访问该方法会在修改属性值时自动执行
setter装饰的方法会在修改属性值时自动执行
deleter装饰的方法会在删除属性值自动执行

class Foo:
    def __init__(self,val):
        self.__NAME=val #将所有的数据属性都隐藏起来

    @property
    def name(self):
        return self.__NAME #obj.name访问的是self.__NAME(这也是真实值的存放位置)

    @name.setter
    def name(self,value):
        if not isinstance(value,str):  #在设定值之前进行类型检查
            raise TypeError('%s must be str' %value)
        self.__NAME=value #通过类型检查后,将值value存放到真实的位置self.__NAME

    @name.deleter
    def name(self):
        raise TypeError('Can not delete')

f=Foo('Jack') 

print(f.name) # 访问property属性
#输出 Jack
f.name="Rose" # 修改property属性 抛出异常'TypeError: 10 must be str'

del f.name # 删除property属性 抛出异常'TypeError: Can not delete'

继承

继承：是一种关系，通过这种关系，一个对象可以直接使用另一个类中已定义的方法和属性

优点：1.减少代码冗余2.为多态提供支持
派生：父类提供的属性无法完全满足子类的需求时,子类可以增加自己的属性或非法,或者覆盖父类已经存在的属性,此时子类称之为父类的派生类;
覆盖：子类中如果出现于父类相同的属性名称时,根据查找顺序,优先使用子类中的属性,这种行为也称为覆盖
重用：使用super()
小知识：查询继承关系表：类名.mro()
组合：在一个类中以另外一个类的对象作为数据属性

多态

多态指的是一类事物有多种形态

内置函数

构造 指的是从无到有(init)
析构 值从有到无(del)

反射

hasattr 判断是否存在某个属性

getattr	获取某个属性的值

setattr	新增或修改某个属性 

delattr 删除某个属性 

元类

元类：是由type实例化产生的
type(类名,父类元组,名称空间字典) #返回一个新的类
type(对象) #将会返回这个对象的类型
自定义元类：
1.定义一个类继承type
2.再定义一个新类（metaclass=MyMetaclass）

网络

TCP：传输控制协议，可靠的、面向连接的协议，传输效率低
UDP：用户数据报协议，不可靠的、无连接的服务，传输效率高，属于传输层的协议,数据量较小的简单传输

socket

socket:是应用层与TCP/IP协议族通讯的中间软件抽象层，它是一组接口

粘包问题

粘包问题只出现在TCP协议中,因为TCP是流式协议,数据之间没有明显分隔
之所以出现粘包
1. 把时间间隔短的 数据量小的数据 一次性发送
2. 数据已经到达 接收多了或少了 都会粘包
之所以粘包本质原因就是接收方不清楚数据长度
解决方案就是提前告诉接收方数据长度

进程/线程/协程/GIL/IO多道技术/守护进程

进程：一个正在运行中的程序，不能被执行，他是一个资源单位，包含了运行程序所需要的所有资源
线程：操作系统最小的运算调度单位，被包含在进程中，一个线程就是一个固定的执行流程
异步回调：在发起一个异步任务的同时指定一个函数，在异步任务完成时会自动调用这个函数
协程：单线程实现并发
线程的特点：
1.创建开销小
2.同一个进程中的多线程数据是共享的
3.多个线程之间，是平等的没有父子关系，所有线程的PID都是相同的

线程进程的关系

1.线程不能单独存在
2.线程是一个资源单位，包含了运行程序所需的所有资源
3.线程是真正的执行单位
4.没有线程，进程中的资源无法被利用起来，所以一个进程至少包含一个线程

协程

协程是一种用户态的轻量级线程，即协程是由用户程序自己控制调度的。
通过gevent模块实现并发
优点：1.协程的切换开销更小，属于程序级别的切换，操作系统完全感知不到，因而更加轻量级
2.单线程内就可以实现开发的效果，最大限度的利用cup

sql

Innodb和MyIsam的区别

Innodb：1.支持事务2.不支持全文索引3.索引和数据都在同一个文件中.ibd,表结构在.frm中4.5.5以上版本
MyIsam：1.5.5版本以下2.不支持事务3.支持全文索引4..frm表结构 .MYD表数据 .MYI表索引

慢查询日志

记录执行速度特别慢的SQL语句

1. show variables like '%query%';
2. set global long_query_time = 1; 设置慢查询的时间
3. slow_q uery_log = ON
4. slow_query_log_file = E:programmysql-5.6.44-winx64dataoldboy-slow.log