[python]未整理(持续更新中)

neillien

已于 2022-02-21 19:17:06 修改

阅读量254

点赞数

文章标签： python

于 2022-02-21 09:57:29 首次发布

本文链接：https://blog.csdn.net/neillien/article/details/123032403

版权

Ctrl+f搜关键词，搜不到找其他博客，下面肯定没有

知识补充

1.Python 中新式类和经典类的区别是什么?

经典类：不继承自object

2.Python 3 中的类型注解有什么好处?如何使用?

传入的参数类型

在声明变量时，变量的后面可以加一个冒号，后面再写上变量的类型，如 int、list 等等。

在声明方法返回值的时候，可以在方法的后面加一个箭头，后面加上返回值的类型，如 int、list 等等。

3.大文件只需读取部分内容，或者避免读取时候内存不足的解决方法?

当以a模式打开时，只能写文件，而且是在文件末尾添加内容。

当以a+模式打开时，可以写文件，也可读文件，可是在读文件的时候，会发现读出来的数据为空，是因为 a+模式是在文件末尾添加内容，所以其指针已经指到了文件末尾，所以读出来的数据就是空的。

当以w模式打开时，只能写文件，而且会直接将之前的数据给丢失。当以w+模式，可读可写，但是如果想读取的内容的话，只能在写内容的时候，同时读取其中的内容，相当于只能读取出你刚刚写入的内容，没有意义

当以r模式打开文件时，只能读取文件。

当以r+模式打开文件时，可读可写文件。如果是读取文件，会从首个字符开始读取数据，如果是以该模式打开文件，就写数据，则会从首个字符开始写，并一个一个字符的向后面覆盖。如果想从末尾添加内容，则可先read()然后在向其中添加数据。

4.什么是全缓冲、行缓冲和无缓冲?

全缓冲：我们缓存在缓冲区的东西在缓冲区满的时候，才写入磁盘或者我们调用fflush刷新缓冲区才能写入到磁盘。对于全缓冲，如果我们缓冲区没满，或者我们没有手动刷新缓存，那么缓存区的内容是不能写入到磁盘的。

行缓冲：我们标准输入、标准输出都是采用的行缓存，也就是遇到换行符的时候，才会将缓存区的东西写入到磁盘。

无缓存：有的时候，我们希望一些内容在第一时间写入磁盘或者显示出来，比如我们显示错误信息的时候，这时候典型的例子比如标准出错，它就是直接显示出错信息，而不会先放入缓存。

5.什么是序列化和反序列化?JSON 序列化时常用的四个函数是什么?

将对象转换为可通过网络传输或可以存储到本地磁盘的数据格式（如：XML、JSON或特定格式的字节串）的过程称为序列化；反之，则称为反序列化。

json.dump()：将json格式字符串写到文件中

json.dumps()：将 Python对象转换编码成JSON字符串

json.load()：从文件中读取json字符串

json.loads()：用于解码 JSON 数据，返回 Python 字段的数据类型

6.JSON 中 dumps 转换数据时候如何保持中文编码?

Python 3中的json在做dumps操作时，会将中文转换成unicode编码，并以16进制方式存储，再做逆向操作时，会将unicode编码转换回中文

ensure_ascii=False（因为json.dumps 序列化时对中文默认使用的ascii编码.想输出真正的中文需要指定 ensure_ascii=False）

7.is 和 == 有什么区别?

is 用于判断两个变量引用对象是否为同一个，就是所引用的对象的内存地址是否一致

== 用于判断引用变量的值是否相等。只判断值和数据类型

8.字符串，列表，元组如何反转?反转函数 reverse 和 reversed 的区别?

都可使用切片进行反转

reverse只适用于列表，reversed()是python内置的一个函数，但它返回的是一个反转的迭代器

9.列表合并的常用方法?

使用append()方法、使用“+”完成操作、使用切片方法（a[0:0]=b）

10.字典中元素的如何排序?sorted 排序函数的使用详解?

dict1 = sorted(dict.items())

sorted不改变原数据

11.字典如何合并?字典解包是什么?

1）dict(d1.items() + d2.items())

2）d3.update(d1) d3.update(d2) 或d3 = d1.copy() d3.update(d2)

3)dict(d1, **d2)

4)for循环添加（不推荐）

解包：**dict_info

12.字典推导式使用方法?

name = [“张三”, “李四”, “王五”, “李六”] # 保存名字列表 sign = [“白羊座”, “双鱼座”, “狮子座”, “处女座”] #保存星座列表 dict1 = {i : j for i, j in zip(name, sign)} # 字典推导式 print(dict1)

{‘张三’: ‘白羊座’, ‘李四’: ‘双鱼座’, ‘王五’: ‘狮子座’, ‘李六’: ‘处女座’}

13.字典的键可以是哪些类型的数据?

标量类型（整数、浮点数、字符串）或元组（且元组内对象也必须是不可变对象）。

这里要使用到一个术语叫作哈希化，通过hash函数可以检查一个对象是否可以哈希化（即是否可以用作字典的键）

14.类实例化时候，init 和 new 方法有什么作用?

__new__至少要有一个参数cls，代表要实例化的类，此参数在实例化时由Python解释器自动提供。 __new__必须要有返回值，返回实例化出来的实例，这点在自己实现__new__时要特别注意，可以return父类__new__出来的实例，或者直接是object的__new__出来的实例。 __init__有一个参数self，就是这个__new__返回的实例，__init__在__new__的基础上可以完成一些其它初始化的动作，__init__不需要返回值。

15.实例方法、类方法和静态方法有什么不同?

实例方法：第一个参数必须是实例对象，该参数名一般为“self”，通过它来传递实例的属性和方法（也可以传类的属性和方法）；调用：只能由实例对象调用。

类方法：使用装饰器@classmethod。第一个参数必须是当前类对象，该参数名一般为“cls”，通过它来传递类的属性和方法（不能传实例的属性和方法）；调用：实例对象和类对象都可以调用。

静态方法：使用装饰器@staticmethod。参数随意，没有“self”和“cls”参数，但是方法体中不能使用类或实例的任何属性和方法；调用：实例对象和类对象都可以调用

16.*args 和 **kwargs 的区别?

*args 用来将参数打包成tuple给函数体调用

**kwargs 打包关键字参数成dict给函数体调用

17.通用装饰器和类装饰器

@property

@属性名.setter or @属性名来设置或得到属性

通用装饰器：

	def add(func):
		def fun(*args, **kwargs):
			print("装饰器的功能代码：登录")
			func(*args,**kwargs)
		return fun

类装饰器本质上和函数装饰器原理、作用相同,都是为其它函数增加额外的功能。但是相比于函数装饰器, 类装饰器具有灵活度大、高内聚、封装性等优点。使用类装饰器可以直接依靠类内部的__call__方法来实现,当使用 @ 形式将类装饰器附加到函数上时,就会调用类装饰器的__call__方法。而不需要向函数装饰器那样,在装饰器函数中定义嵌套函数,来实现装饰功能。”

class MyDecorator(object):
    def __init__(self, func):
        # 定义为私有属性
        self.__func = func
    # 实现__call__方法，让对象变成可以调用的对象，可调用的对象可以想函数那样使用
    def __call__(self, *args, **kwargs):
        # 对已有函数进行封装
        print("装饰器开始执行...")
        self.__func()
@MyDecorator  
def show():
    print("正在执行被装饰的函数...")
show()

18.可迭代对象和迭代器对象有什么区别?

可迭代对象不一定是迭代器，迭代器一定是可迭代对象。因为迭代器一定会实现 __ iter __ 方法，而可迭代对象尽管实现了 __ iter __ 也不一定实现 __ next __方法。

19.迭代器就是生成器，生成器一定是迭代器，这句话对吗?

不对，生成器是一类特殊的迭代器

20.yield 关键字有什么好处?

你的函数将返回一组你只需要使用一次的大量值时使用yield

21.上下文管理器

上下文管理器有__enter__和__exit__两个方法，执行开启关闭动作，最常见的是文件操作with open

21.uvloop提升asyncio性能

pip install uvloop

import uvloop
asyncio.set_event_loop_policy(uvloop.EventLoopPolicy())

22.单例模式

基于_new__实现

import threading
class Singleton(object):
    _instance_lock = threading.Lock()
    def __init__(self):
        pass
    def __new__(cls, *args, **kwargs):
        if not hasattr(Singleton, "_instance"):
            with Singleton._instance_lock:
                if not hasattr(Singleton, "_instance"):
                    Singleton._instance = object.__new__(cls)  
        return Singleton._instance
obj1 = Singleton()
obj2 = Singleton()
print(obj1,obj2)
def task(arg):
    obj = Singleton()
    print(obj)
for i in range(10):
    t = threading.Thread(target=task,args=[i,])
    t.start()

@property和@classmethod和@staticmethod

https://blog.csdn.net/weixin_34029680/article/details/93250110

23.pycharm设置

plugins

material theme ui #界面样式

rainbow brackets

settings:

设置选中添加标点不会被替代

File --> Settings --> Editor --> General --> Smart Keys，勾选 Surround selection on typing quote or brace

24.mobaxterm

crtl+shift+u ,创建相同选项卡

25.Linux Centos7.4下安装mongodb4.4.1

#mongodb数据库安装
vim /etc/yum.repos.d/mongodb-org-4.4.repo
[mongodb-org-4.4]
name=MongoDB Repository
baseurl=https://repo.mongodb.org/yum/redhat/$releasever/mongodb-org/4.4/x86_64/
gpgcheck=1
enabled=1
gpgkey=https://www.mongodb.org/static/pgp/server-4.4.asc
sudo yum install -y mongodb-org-4.4.1 mongodb-org-server-4.4.1 mongodb-org-shell-4.4.1 mongodb-org-mongos-4.4.1 mongodb-org-tools-4.4.1
#启动mongodb
sudo systemctl start mongod
#系统重启后mongodb自动启动
sudo systemctl enable mongod              
#停止mongodb
sudo systemctl stop mongod
#重启mongodb
sudo systemctl restart mongod

26.*args和**args

*args个数可变的位置参数，**args个数可变的关键字参数

27.os.path

splitext() #分离文件名和拓展名

basename(path) #从目录中提取中文

28.enumerate

enumerate() 函数用于将一个可遍历的数据对象(如列表、元组或字符串)组合为一个索引序列，同时列出数据和数据下标

enumerate(sequence, [start=0])

29.生成器

g = (x for x in rang(10))
next(g)  # 值为0
for i in g:
print(i)   #i为1，2，3....
#多次调用next(g)超出后会报错

30.迭代器

isinstance(object, classinfo)  #isinstance(age,int)
object -- 实例对象。
classinfo -- 可以是直接或间接类名、基本类型或者由它们组成的元组。

31.map函数通过lambda重新生成迭代器

map(str,[1,2,3,4,5])是一个迭代器
print(reduce(getMax,list1))    #打印list1通过getMax得到的结果
filter(lambda x:x['age']>19,emps)  #留下年龄大于19的
max(emps,key=lambda x:x['salary'])   #留下工资最高的，min同理

32.闭包

必须有一个内嵌函数，且内嵌函数必须引用在外部函数的变量，外部函数必须返回内部函数

闭包中内嵌函数想调用外部函数生成的变量，必须在内嵌函数中的这个变量前加nonlocal

闭包的陷阱

def test3():
    fun_list = []
    for i in range(1,4):
        def test4():      #解决办法  def test4(_i=i):,让确定的_i取代i
            return i**2     #return _i**2    
        fun_list.append(test4)
    return fun_list
f1,f2,f3 = test3()
print(f1(),f2(),f3())   
结果为 9，9，9     解决后为1，4，9

33.偏函数

import functools
a = functools.partial(int,base=2)

34.给一个类一个没有在类中定义的方法

import types
class Person(object):
....
if __name__ == '__main__':
    def run():
    ....
    p=Person(...)
    p.run=types.MethodType(run,p)
    p.run(...)

35.魔术方法

__slots__

class Students(object):
__slots__ = ('name','age')  #只允许添加name和age属性

__str__

def __str__(self): 
    return 'Student object (name: %s)' % self.name  
#使用print会显示Student object (name: Michael)

__iter__和__next__

def __iter__(self): 
    return self # 实例本身就是迭代对象，故返回自己 
def __next__(self): 
    self.a, self.b = self.b, self.a + self.b # 计算下一个值 
    if self.a > 100000: # 退出循环的条件 
        raise StopIteration() 
    return self.a # 返回下一个值

__getitem__

class Fib(object):
    def __getitem__(self, n): 
        a, b = 1, 1 
        for x in range(n): 
            a, b = b, a + b 
        return a  
f = Fib() 
f[0]   #可以向列表一样使用

切片小陷阱：
def __getitem__(self, item): # item 可能是一个下标，还有可能是一个切片（范围）
        if isinstance(item,int): # item是一个下标
            a,b =1,1
            for x in range(item):
                a ,b = b,a+b
            return a
        elif isinstance(item,slice): # item是一个范围
            start = item.start
            stop = item.stop
            if start is None:
                start = 0 # start默认值
            a,b =1,1
            L = []
            for x in range(stop):
                if x>=start:
                    L.append(a)
                a,b =b,a+b
            return L

__getattr__

def __getattr__(self, item):
        if item =='age':
            return 18
        elif item == 'eat':
            return lambda : print('eat函数执行')       
#可能是p.age or p.eat()   

__call__

def __call__(self, *args, **kwargs):
        print('person 对象可以调用') 
#把对象当作函数使用       
callable(p)  #判断p是不是一个函数

36.多继承

顺序：在子类中，谁在前面谁的优先级高，最高为子类本身

37.枚举类

实例化对象个数固定的类，可以用枚举类来定义
from enum import Enum
class Color(Enum):
    # 为序列值指定value值
    red = 1
    green = 2
    blue = 3
print(Color.red.value)   #1
print(Color.red.name)    #red
Color.__members__.items  #遍历枚举类中所有成员

38.元类

class PersonMetaclass(type):
	def __new__(cls,name,bases,attrs):  name:类名，bases：父类名,attrs:属性及方法
		def ....
	return type(name,bases,attrs)
class Person(object,metaclass = PersonMetaclass):
	...

39.正则

(?P<name>\w)(?P=name)  #用于对称的匹配

40.对象池

小整数池 [-5, 256]的整数使用同一内存空间，大整数池则不同，创建一个就会往池中存储一个

41.intern机制

每个单词(字符串)，不夹杂空格或者其他符号，默认开启intern机制，共享内存，靠引用计数决定是否销毁

42.垃圾回收

当使用某个引用作为参数，传递给getrefcount()时，参数实际上创建了一个临时的引用。因此，

getrefcount()所得到的结果，会比期望的多1。

1、引用计数增加

a、对象被创建b、另外变量也指向当前对象

c、作为容器对象的一个元素

d、作为参数提供给函数：test(x)

2、引用计数减少

a、变量被显式的销毁

b、对象的另外一个变量重新赋值

c、从容器中移除

d、函数被执行完毕

43.回调函数

定义一个函数，然后将这个函数的函数名传递给另一个函数做参数，以这个参数命名的函数就是回调函数。

44.反射

getattr 获取指定字符串名称的对象属性
setattr 为对象设置一个对象
hasattr 判断对象是否有对应的对象（字符串）
delattr 删除指定属性

neillien

关注

0
点赞
踩
0

收藏

觉得还不错? 一键收藏
0
评论
[python]未整理(持续更新中)

[python]未整理(持续更新中)
复制链接

扫一扫