一些概念总结

太过爱你忘了你带给我的痛 2023-08-17 16:53 27阅读 0赞

**is 与 == 的区别**

Python中万物皆对象，每个对象都包含3个属性：id,type,value. 1.id就是对象地址，可以通过内置函数id()查看对象引用的地址。 2.type就是对象类型，可以通过内置函数type()查看对象的类型. 3.value就是对象的值。 is也被叫做同一性运算符，这个运算符比较判断的是对象间的唯一身份标识，也就是id是否相同； ==比较操作符：用来比较两个对象是否相等，value做为判断因素

类中的@classmethod、@staticmethod和@property的用法和效果。

@classmethod、@staticmethod 介绍
    python中，一般方法的调用，是用类的实例对象来调用，但是使用@classmethod ,@staticmethod 时，直接用类名来调用。
    用处：把一些功能与某个类相近的函数处理，可以写在类中，用这两个方法装饰，以便达到组织代码，使得代码相关性清晰的效果。

两者的区别：
    @staticmethod 就跟使用函数一样，不需要表示自身对象的self和自身类的cls参数；
    @classmethod也不需要self参数，但第一个参数需要是表示自身类的cls参数。
    因为@classmethod 传入了cls参数，代指当前的这个类，就可以调用当前类的属性，方法，实例化对象等，个人觉得这个与类的关系更加紧密一些。

@property 的用法 @@property 即是python内置的一个装饰器，用于把一个方法变成属性方式调用， property() 方法的语法: class property([fget[, fset[, fdel[, doc]]]]) - fget -- 获取属性值的函数 - fset -- 设置属性值的函数 - fdel -- 删除属性值函数 - doc -- 属性描述信息

**python的反射**

> 利用字符串的形式去对象（模块）中操作（寻找/检查/删除/设置）

**函数中的\*args，\*\*kwargs**

> 用于函数的形式参数，当我们定义函数的时候，不确定参数的个数时用，
> 
> \*args.可以传递任意数量的位置参数        --   以元组形式存储
> 
> \*\*kwargs可以传递任意数量的关键字参数       --  以字典形式存储
> 
> \*args和\*\*kwargs可以同时在函数的定义中，但是\*args必须在\*\*kwargs前面。

**单例模式**

> 为什么要用单例模式
> 
> 性能方面：当每个实例都会占用资源，而且实例初始化会影响性能，这个时候就可以考虑使用单例模式，它给我们带来的好处是只有一个实例占用资源，并且只需初始化一次。
> 
> 数据的同步。在一个对急中封装要使用的数据，在各个地方调用数据时，数据不会出现错乱的情况，以达到数据同步的效果。
> 
> 单例实现的四种方法
> 
> \- 模块方式
> 
>  
> 
>  
> 
>

**lambda函数**

> 通常是在需要一个函数，但是又不想费神去命名一个函数的场合下使用，也就是指匿名函数。
> 
> 与filter，map，reduce函数的连用

li = [2, 18, 9, 22, 17, 24, 8, 12, 27] filter(lambda x: x % 3 == 0, li)  # 返回值[18, 9, 24, 12, 27]
    map(lambda x: x * 2 + 10, li)    # 返回值[14, 46, 28, 54, 44, 58, 26, 34, 64]
    reduce(lambda x, y: x + y, foo)  # 返回值139

**可变对象和不可变对象（看内存地址，id（变量））**

> 在python中，可变对象指对象创建之后，值发生改变时，内存地址不会发生改变:dict，list
> 
> 不可变对象指，当值发生改变时，内存地址也发生改变。str，int，tuple，float

**去除一个列表中重复的内容，原顺序不变**

a = ['a','b','b','c','c','d'] b = list(set(a)) b.sort(key=a.index)    # 按照index索引来
    或者 c = sorted(set(a),key=a.index)

**一个列表里套着字典，以字典的某个k的值排序**

l=[{
         "a":1","b":2},{ "a":1","b":8},{
         "a":1","b":5},{ "a":1","b":3}] 以"a"的值排序 sorted(l,key=lamdba k:k["a"])

**List=\[-2，1，3，-6\]，如何实现以绝对值大小从小到大将 List中内容排序。**

li.sort(key=abs,reverse=False)  #按照内置函数abs,是否降序：False
     li = [1, -2, 3, -6]  # 改变了原来的li

**列表的sort方法和sorted的区别是什么？**

> sort 是应用在 list 上的方法，sorted 可以对所有可迭代的对象进行排序操作。
> 
> list 的 sort 方法返回的是对已经存在的列表进行操作，而内建函数 sorted 方法**返回的是一个新的 list**，而不是在原来的基础上进行的操作。

**python是如何进行内存管理的？**

python的内存管理，主要涉及到以下的3个方面： 1.python内部使用引用计数，来保持追踪内存中的对象，Python内部记录了对象有多少个引用，即引用计数，当对象被创建时就创建了一个引用计数，当对象不再需要时，这个对象的引用计数为0时，它被垃圾回收。 2.那什么是垃圾回收机制呢？ 1、当内存中有不再使用的部分时，垃圾收集器就会把他们清理掉。它会去检查那些引用计数为0的对象，然后清除其在内存的空间。 　　当然除了引用计数为0的会被清除，还有一种情况也会被垃圾收集器清掉：当两个对象相互引用时，他们本身其他的引用已经为0了。 3.Python提供了对内存的垃圾收集机制，但是它将不用的内存放到内存池而不是返回给操作系统。 Python中所有小于256个字节的对象都使用pymalloc实现的分配器，而大的对象则使用系统的 malloc。 另外Python对象，如整数，浮点数和List，都有其独立的私有内存池，对象间不共享他们的内存池。也就是说如果你分配又释放了大量的整数，用于缓存这些整数的内存就不能再分配给浮点数。

**解释python脚本程序\_name\_\_变量及其作用**

我们编写模块的时候，是为了给自己或者别人在适当的时候进行调用的，但是我们在编写模块时，也是需要测试的，会写一些测试代码，但是我们想在别人调用时，测试代码不起作用。 为了解决这一问题，python提供了一个系统变量：__name__
    
    __name__有2个取值：当模块是被调用执行的，取值为模块的名字。当模块是直接执行的，则该变量取值为：__main__ 一般的用法： def addFunc(a,b): return a+b if __name__ == '__main__': print('结果:',addFunc(1,1))

**mysql表中的数据越来越大，请给出优化的简易的优化方案**

我们一般的步骤是找问题，再优化： 优化sql的一般步骤（找问题） 1.通过show status了解各种sql的执行频率 2.定位执行效率低的sql语句 3.通过explain分析效率低的sql 4.通过show profile分析sql 5.通过trace分析优化器如何选择执行计划 6.确定问题，采取措施优化 问题优化： 1.优化你的sql和索引； 2.加缓存，memcached,redis； 3.就做主从复制或主主复制，读写分离，可以在应用层做，效率高，也可以用三方工具，第三方工具推荐360的atlas,其它的要么效率不高，要么没人维护； 4.mysql自带分区表，对你的应用是透明的，无需更改代码,但是sql语句是需要针对分区表做优化的， 　　　　sql条件中要带上分区条件的列，从而使查询定位到少量的分区上，否则就会扫描全部分区，另外分区表还有一些坑，在这里就不多说了； 5.先做垂直拆分，其实就是根据你模块的耦合度，将一个大的系统分为多个小的系统，也就是分布式系统； 6.水平切分，针对数据量大的表，这一步最麻烦，最能考验技术水平，要选择一个合理的sharding key,为了有好的查询效率，表结构也要改动，做一定的冗余，应用也要改， 　　　　sql中尽量带sharding key，将数据定位到限定的表上去查，而不是扫描全部的表

**简述python的GIL锁**

python代码的执行由解释器主循环来控制(虚拟机)，python在设计之初，就决定每次在解释器主循环中，同一时刻，只有一个线程。 对python解释器的访问，就是有GIL(全局解释器锁)来控制，正是这把锁，控制了同一时刻，只有一个线程在解释器中。 在多线程环境中，Python 解释器按以下方式执行： 1. 设置GIL 2. 切换到一个线程去运行 3. 运行： a. 指定数量的字节码指令，或者 b. 线程主动让出控制（可以调用time.sleep(0)） 4. 把线程设置为睡眠状态 5. 解锁GIL 6. 再次重复以上所有步骤 锁住全局解释器使得比较容易的实现对多线程的支持，但也损失了多处理器主机的并行计算能力。 但是，不论标准的，还是第三方的扩展模块，都被设计成在进行密集计算任务时，释放GIL。 还有，就是在做I/O操作时，GIL总是会被释放。对所有面向I/O 的程序来说，GIL 会在这个I/O 调用之前被释放，以允许其它的线程在这个线程等待I/O 的时候运行。 如果是纯计算的程序，没有 I/O 操作，解释器会每隔一定时间就释放这把锁，让别的线程有机会执行（这个次数可以通过 sys.setcheckinterval 来调整）。 I/O 密集型的Python 程序比计算密集型的程序更能充分利用多线程环境的好处。

**多进程开发中，join和daemon的区别**

一个程序至少有一个主线程，主线程启动子线程后，它们之间并没有隶属关系。主线程和子线程执行是并行的，相互独立。
    　主线程执行完毕后默认不等子线程执行结束就接着往下走了，如果有其他程序就会运行另外的程序，如果没有就等待子线程执行完成后结束程序。
    
    主线程创建一个子线程后，如果子线程调用join()方法，主线程会在调用的地方等待，直到该子线程运行完成才会接着往下执行。
    
    setDaemon()方法：在主线程中创建子线程，该子线程调用setDaemon方法后成为主线程的守护线程。这种情况下如果主线程执行结束，那么不管子线程是否完成，一并和主线程退出。
    这里基本和join()方法相反。此外，还有个要特别注意的：必须在start() 方法调用之前设置，如果不设置为守护线程，程序会被无限挂起。

**迭代器与生成器的理解。**

讨论迭代器与生成器 1.在python中一切皆对象，如果一个对象，含有__iter__方法，则这个对象就是可迭代对象； 2.如果一个对象拥有__next__方法，其是迭代器。 3.定义可迭代对象，必须实现__iter__方法；定义迭代器，必须实现__iter__和next方法。 4.具有yield关键字的函数都是生成器，yield可以理解为return，返回后面的值给调用者。 　　不同的是return返回后，函数会释放，而生成器则不会。在直接调用next方法或用for语句进行下一次迭代时，生成器会从yield下一句开始执行，直至遇到下一个yield。

**mysql有哪些存储引擎，优化mysql数据库的方式有哪些？**

MySQL5.5以后默认使用InnoDB存储引擎，其中InnoDB和BDB提供事务安全表，其它存储引擎都是非事务安全表。 1.MyISAM 它不支持事务，也不支持外键，尤其是访问速度快，对事务完整性没有要求或者以SELECT、INSERT为主的应用基本都可以使用这个引擎来创建表。 2.InnoDB InnoDB存储引擎提供了具有提交、回滚和崩溃恢复能力的事务安全。但是对比MyISAM的存储引擎，InnoDB写的处理效率差一些并且会占用更多的磁盘空间以保留数据和索引。 3.MEMORY memory使用存在内存中的内容来创建表。每个MEMORY表实际对应一个磁盘文件，格式是.frm。MEMORY类型的表访问非常快，因为它到数据是放在内存中的， 并且默认使用HASH索引，但是一旦服务器关闭，表中的数据就会丢失，但表还会继续存在。 4.MERGE 　　merge存储引擎是一组MyISAM表的组合，这些MyISAM表结构必须完全相同，MERGE表中并没有数据，对MERGE类型的表可以进行查询、更新、删除的操作，这些操作实际上是对内部的MyISAM表进行操作

**python中如何动态的获取和设置对象的属性**

其实就是Python的自省 dir([obj]): 调用这个方法将返回包含obj大多数属性名的列表（会有一些特殊的属性不包含在内）。obj的默认值是当前的模块对象。 hasattr(obj, attr): 这个方法用于检查obj是否有一个名为attr的值的属性，返回一个布尔值。 getattr(obj, attr): 调用这个方法将返回obj中名为attr值的属性的值，例如如果attr为’bar’，则返回obj.bar。 setattr(obj, attr, val): 调用这个方法将给obj的名为attr的值的属性赋值为val。例如如果attr为’bar’，则相当于obj.bar = val。

**python中如何拷贝一个对象**

在Python中,无论是对象赋值，作为为参数传递,作为函数返回值,都是引用传递的.如果需要拷贝对象，需要使用标准库中的copy模块（import copy）。 1.浅拷贝 ： 使用copy.copy,它可以进行对象的浅拷贝(shallow copy),它复制了对象,但对于对象中的元素,依然使用引用（换句话说修改拷贝对象元素，则被拷贝对象元素也被修改） 2.深拷贝 ： 使用copy.deepcopy，它可以进行深拷贝，不仅拷贝了对象，同时也拷贝了对象中的元素，获得了全新的对象，与被拷贝对象完全独立，但这需要牺牲一定的时间和空间。

转载于:https://www.cnblogs.com/biao-wu/articles/11366323.html