长沙网站优化seo,产品推广策略,邯郸网站设计怎么开发,做网站最基础需要什么条件目录 1.概念理解题python内置数据结构#xff0c;哪些是不可变的python新式类和经典类的区别is和有什么区别Python中变量查找顺序python函数的参数是值传递还是引用传递python垃圾回收机制什么是闭包什么是装饰器#xff0c;开发中用到举例如何实现只读属性Python中类方法、实… 目录 1.概念理解题python内置数据结构哪些是不可变的python新式类和经典类的区别is和有什么区别Python中变量查找顺序python函数的参数是值传递还是引用传递python垃圾回收机制什么是闭包什么是装饰器开发中用到举例如何实现只读属性Python中类方法、实例方法、静态方法有何区别new和init的区别什么时候使用到如何查一个对象的所有属性Python中如何动态获取和设置对象的属性GIL锁的理解有GIL锁一定可以保证线程安全吗为什么还要设计GIL锁常用的魔法方法isinstance 的作用以及与 type()的区别如何实现一个上下文管理类字典内部如何实现python实现单例模式单例模式的应用场景有哪些Python 中的反射元类是什么有什么作用python中为什么类都继承了object类python实现一个抽象基类什么时候使用抽象基类 2.常考语法求集合交集和并集求字典value最大值对应的key给字典按值排序字符串反转alist中元素的age由大到小排序产生一个公差为11的等差数列列表里放可变参数时下面代码输出结果遍历列表时删除元素统计一个文本中单词频次最高的10个单词输入日期 判断这一天是这一年的第几天排列奇数在偶数前且奇数升序排列偶数降序排序以下代码他们的输出结果多装饰器代码打印顺序 1.概念理解题
python内置数据结构哪些是不可变的
a. 整型 int、 长整型 long、浮点型 float、 复数 complex
b. 字符串 str、 列表 list、 元祖 tuple
c. 字典 dict 、 集合 set
d. Python3 中没有 long只有无限精度的 int
不可变数值类型int、float、bool、string字符串、tuple元组
可变list列表、dict字典)、集合 set
python新式类和经典类的区别
a. 在python里凡是继承了object的类都是新式类
b. Python3里只有新式类
c. Python2里面继承object的是新式类没有写父类的是经典类
d. 经典类目前在Python里基本没有应用
e. 保持class与type的统一对新式类的实例执行a.class与type(a)的结果是一致的对于旧式类来说就不
一样了。
f.对于多重继承的属性搜索顺序不一样新式类是采用广度优先搜索旧式类采用深度优先搜索。
is和有什么区别
is比较的是两个对象的id值是否相等也就是比较俩对象是否为同一个实例对象。是否指向同一个内
存地址 比较的两个对象的内容/值是否相等默认会调用对象的eq()方法。
Python中变量查找顺序
函数作用域的LEGB顺序
1.什么是LEGB?
L local 函数内部作用域
E: enclosing 函数内部与内嵌函数之间
G: global 全局作用域
B build-in 内置作用
python在函数里面的查找分为4种称之为LEGB也正是按照这是顺序来查找的
python函数的参数是值传递还是引用传递
在Python中其实是引用传递。也就是函数外和函数内的变量都指向同一个对象。
但是当在函数里修改变量或重新赋值时就需要区分 当参数是可变对象时函数里变量都引用了同一个对象那么在函数里改变变量会影响其他引用的变量 当参数是不可变对象时函数里的变量被拷贝了一份赋值给了函数内自己的变量在函数内改变不会影响原来的值。
python垃圾回收机制
循环引用会怎么样
参考记一次面试问题——Python 垃圾回收机制 · TesterHome
python 采用的是引用计数机制为主标记 - 清除和分代收集两种机制为辅的策略。
**引用计数**当一个对象被创建或者被引用时,该对象的引用计数就会加1,当对象被销毁时相应的引用计数就会减1,一旦引用计数减为0时,表示该对象已经没有被使用.可以将其所占用的内存资源释放掉。
引用计数无法解决循环引用问题。
**分代回收**以空间换时间的操作方式Python 将内存根据对象的存活时间划分为不同的集合每个集合称为一个代Python 将内存分为了 3“代”分别为年轻代第 0 代、中年代第 1 代、老年代第 2 代他们对应的是 3 个链表它们的垃圾收集频率与对象的存活时间的增大而减小。新创建的对象都会分配在年轻代年轻代链表的总数达到上限时Python 垃圾收集机制就会被触发把那些可以被回收的对象回收掉而那些不会回收的对象就会被移到中年代去依此类推老年代中的对象是存活时间最久的对象甚至是存活于整个系统的生命周期内。分代回收是建立在标记清除技术基础之上。分代回收同样作为 Python 的辅助垃圾收集技术处理那些容器对象。
标记清除Mark—Sweep是一种基于追踪回收tracing GC技术实现的垃圾回收算法。它分为两个阶段第一阶段是标记阶段GC 会把所有的『活动对象』打上标记第二阶段是把那些没有标记的对象『非活动对象』进行回收。那么 GC 又是如何判断哪些是活动对象哪些是非活动对象的呢
对象之间通过引用指针连在一起构成一个有向图对象构成这个有向图的节点而引用关系构成这个有向图的边。从根对象root object出发沿着有向边遍历对象可达的reachable对象标记为活动对象不可达的对象就是要被清除的非活动对象。根对象就是全局变量、调用栈、寄存器。 mark-sweepg 在上图中我们把小黑圈视为全局变量也就是把它作为 root object从小黑圈出发对象 1 可直达那么它将被标记对象 2、3 可间接到达也会被标记而 4 和 5 不可达那么 1、2、3 就是活动对象4 和 5 是非活动对象会被 GC 回收。
标记清除算法作为 Python 的辅助垃圾收集技术主要处理的是一些容器对象比如 list、dict、tupleinstance 等因为对于字符串、数值对象是不可能造成循环引用问题。Python 使用一个双向链表将这些容器对象组织起来。不过这种简单粗暴的标记清除算法也有明显的缺点清除非活动的对象前它必须顺序扫描整个堆内存哪怕只剩下小部分活动对象也要扫描所有对象。
什么是闭包
在函数嵌套的前提下内部函数使用了外部函数的变量并且外部函数返回了内部函数我们把这个使用外部函数变量的内部函数称为闭包。
构成条件 在函数嵌套函数里面在定义函数的前提下 内部函数使用了外部函数的变量还包括外部函数的参数 外部函数返回了内部函数
实现
除了使用嵌套函数外还可以使用类实现闭包
class Out:def __init__(self, x):self.x xdef __call__(self, y):return x yout Out(3)
out(4)定义类使用__call__实现对象可被调用。
什么是装饰器开发中用到举例
装饰器就是一个特殊的闭包把一个函数当作外部函数的参数在内部函数中使用这个函数。使用装饰器则是使用语法糖来装饰函数。
开发中使用的比较多比如
1.flask钩子函数、Django中间件
2.flask路由函数route
3.自定义接口返回格式的时候的装饰器
4.日志记录装饰器
如何实现只读属性
class Computer:def __init__(self, name, mem, cpu):self.__name namepropertydef name(self): # 只读 getter方法return self.__namepc2 Computer(admin, 8G, 8)
print(pc2.name )
# pc2.name aa # 修改会报错AttributeError: cant set attributePython中类方法、实例方法、静态方法有何区别
类方法: 是类对象的方法在定义时需要在上方使用 classmethod 进行装饰,形参为cls表示类对象类对象和实例对象都可调用
类实例方法: 是类实例化对象的方法,只有实例对象可以调用形参为self,指代对象本身;
静态方法: 是一个任意函数在其上方使用 staticmethod 进行装饰可以用对象直接调用静态方法实际上跟该类没有太大关系
new和init的区别什么时候使用到
new是在实例创建之前被调用的任务是创建实例然后返回该实例对象是个静态方法至少要有一个参数cls代表当前类必须有返回值即该实例对象。
init是在实例创建完成后被调用的设置对象属性的一些初始值通常用在初始化一个类实例的时候是一个实例方法至少有一个参数self(代表当前的实例)无需返回值。
init在new之后被调用new的返回值实例传递给init的第一个参数然后由init设置一些实例的参数。
如何查一个对象的所有属性
可以使用dir()和__dict__查询对象属性。
dir()是python提供的API函数利用对象的继承关系来查询该对象的所有有效属性查询顺序为从对象本身向上级查询下级的属性查询不到。
__dict__本身作为对象的一种属性查询范围区别于dir()利用继承关系查询__dict__仅限于对象本身属性。但是并不是所有对象都有__dict__属性。如果类的属性中有__slots__属性则该类的实例没有__dict__属性。
Python中如何动态获取和设置对象的属性
hasattr和setattr
if hasattr(Parent, x): print(getattr(Parent, x)) setattr(Parent, x,3) print(getattr(Parent,x))GIL锁的理解
GIL是python的全局解释器锁同一进程中假如有多个线程运行一个线程在运行python程序的时候会霸占python解释器(加了一把锁即GIL),使该进程内的其他线程无法运行等该线程运行完后其他线程才能运行。如果线程运行过程中遇到耗时操作则解释器锁解开使其他线程运行。所以在多线程中,线程的的运行仍是有先后顺序的,并不是同时进行。 多进程中因为每个进程都能被系统分配资源相当于每个进程有了一个python解释器所以多进程可以实现多个进程的同时运行缺点是进程系统资源开销大。
有GIL锁一定可以保证线程安全吗
不能。
python中一个线程有两种情况释放GIL一种情况是在该线程进入IO操作之前会主动释放GIL另一种情况是解释器不间断运行了1000字节码Py2或运行15毫秒Py3后该线程也会放弃GIL。既然一个线程可能随时会失去GIL那么就涉及到线程安全。GIL设计的出发点是考虑到线程安全但是这种线程安全是粗粒度不需要程序员自己对线程加锁语言层面本身维护着一个全局的锁机制用来保证线程安全。
为什么还要设计GIL锁
不能完全保证线程安全为什么还要设计GIL锁
这和 CPython 的底层内存管理有关。
CPython 使用引用计数来管理内容所有 Python 脚本中创建的实例都会配备一个引用计数来记录有多少个指针来指向它。当实例的引用计数的值为 0 时会自动释放其所占的内存。
假设有两个 Python 线程同时引用 a那么双方就都会尝试操作该数据很有可能造成引用计数的条件竞争导致引用计数只增加 1实际应增加 2这造成的后果是当第一个线程结束时会把引用计数减少 1此时可能已经达到释放内存的条件引用计数为 0当第 2 个线程再次视图访问 a 时就无法找到有效的内存了。
所以CPython 引进 GIL可以最大程度上规避类似内存管理这样复杂的竞争风险问题。
常用的魔法方法
__repr__
__str__
__iter__
__call__
__new__
__init__
__getattr__
__setattr__
__dir__
__lt__
__le__isinstance 的作用以及与 type()的区别
在python中isinstance的意思是“判断类型”isinstance()是一个内置函数用于判断一个对象是否是一个已知的类型类似type()。
isinstance() 与 type() 区别
type() 不会认为子类是一种父类类型不考虑继承关系。isinstance() 会认为子类是一种父类类型考虑继承关系。
如果要判断两个类型是否相同推荐使用 isinstance()。
如何实现一个上下文管理类
1.实现enter和exist方法
class File:def __init__(self, filename, mode):self.filename filenameself.mode modedef __enter__(self):print(进入)self.f open(self.filename, self.mode)return self.fdef __exit__(self, exc_typeNone, exc_valNone, exc_tbsNone):print(退出)self.f.close()2.使用contextmanager装饰器
该装饰器将生成器中的代码通过yield语句分成两部分yield之前的代码为__enter__方法yield之后的代码为__exit__方法yield的返回值即__enter__方法的返回值用于赋给as后的变量。
from contextlib import contextmanagercontextmanager
def open_file(filename, mode):print(进入)f open(filename, mode)try:yield ffinally:print(退出)f.close()字典内部如何实现
https://blog.csdn.net/YZL40514131/article/details/125349175
python字典的底层实现的是哈希表。调用python内置的哈希函数将键key作为参数进行转换哈希运算取余运算得到一个唯一的地址地址的索引然后将值value存放到对应的地址中给相同的键赋值会直接覆盖原值因为相同的键转换后的地址时一样的。
哈希表使用顺序表存储数据存储键值对时通过哈希函数计算出键对应的索引将值存到索引对应的数据区中 获取数据时通过哈希函数计算出键对应的索引将该索引对应的数据取出来。
所以键Key必须是可哈希的即通过哈希函数可为此键计算出唯一地址。
对于 Python 来说变量列表、字典、集合这些都是可变的所以都不能做为键Key来使用。因为元组里边可以存放列表这类可变元素所以如果实在想拿元组当字典的键Key那必须对元组做限制元组中只包括像数字和字符串这样的不可变元素时才可以作为字典中有效的键Key。另外还需要注意的一点是Python 的哈希算法对相同的值计算得到的结果是一样的也就是说 12315 和 12315.0 的值相同他们被认为是相同的键Key。
python实现单例模式
第一种方法:使用装饰器
def singleton(cls):instances {}def wrapper(*args, **kwargs):if cls not in instances:instances[cls] cls(*args, **kwargs)return instances[cls]return wrappersingleton
class Foo(object):passif __name__ __main__:foo1 Foo()foo2 Foo()print(foo1 is foo2)第二种方法使用基类
class Singleton(object):_instance Nonedef __new__(cls, *args, **kwargs):if not hasattr(cls, _instance):cls._instance super(Singleton, cls).__new__(cls, *args, **kwargs)return cls._instanceclass Foo(Singleton):passif __name__ __main__:foo1 Foo()foo2 Foo()print(foo1 is foo2)第三种方法使用元类
元类元类是用于创建类对象的类类对象创建实例对象时一定要调用call方法因此在调用call时候保证始终只创建一个实例即可type是python的元类。
class Singleton(type):# 元类必须继承typedef __call__(cls, *args, **kwargs):if not hasattr(cls, _instance):cls._instance super(Singleton, cls).__call__(*args, **kwargs)return cls._instanceclass Foo(metaclassSingleton):passif __name__ __main__:foo1 Foo()foo2 Foo()print(foo1 is foo2)单例模式的应用场景有哪些
单例模式应用的场景一般发现在以下条件下
资源共享的情况下避免由于资源操作时导致的性能或损耗等如日志文件应用配置。
控制资源的情况下方便资源之间的互相通信。如线程池等1,网站的计数器 2,应用配置 3.多线程池 4.数据库配置 数据库连接池 5.应用程序的日志应用…
Python 中的反射
反射的定义主要是应用于类的对象上在运行时将对象中的属性和方法反射出来。
使用场景可以动态的向对象中添加属性和方法。也可以动态的调用对象中的方法或者属性。
反射的常用方法 1.hasaattr(obj,str) 判断输入的str字符串在对象obj中是否存在(属性或方法)存在返回True否则返回False
2.getattr(obj,str) 将按照输入的str字符串在对象obj中查找。如找到同名属性则返回该属性如找到同名方法则返回方法的引用想要调用此方法得使用 getattr(obj,str)()进行调用。 如果未能找到同名的属性或者方法则抛出异常AttributeError。
3.setattr(obj,name,value) name为属性名或者方法名value为属性值或者方法的引用动态添加属性。如上首先定义一个方法。再使用setattr(对象名,想要定义的方法名,所定义方法的方法名)
4.delattr(obj,str) 将你输入的字符串str在对象obj中查找如找到同名属性或者方法就进行删除
元类是什么有什么作用
python 里一些皆对象包括类也是一个对象。元类及创建类的类。
一般自己写元类主要作用是对创建类或类的对象做一些限制和验证等。
python中为什么类都继承了object类
新式类以 object 为基类父类的类经典类不以 object 为基类的类。
新式类和经典类在多继承中会影响 MRO方法搜索顺序经典类会按照深度优先的方法去搜索 新式类会按照广度优先的方法去搜索。
在 Python 2.x 中如果没有指定父类也不会把 object 作为基类。
而在 Python 3.x 中如果未指定父类则默认将 object 作为该类的基类所以 Python 3.x 中定义的都是新式类。
主要是为了兼容经典类所以都统一默认为新式类了。不理解。。。
python实现一个抽象基类什么时候使用抽象基类
2.常考语法
求集合交集和并集
交集
s1 {2, 3.6, True, 2 3j}
s2 {1, 3.6, False, 2 3j}print(s1 s2)
# {1, 3.6, (23j)}
print(s2 s1)
# {True, 3.6, (23j)}交集时布尔类型和0、1比较时返回结果参考的是后一个数据
但是把s2的False去掉又不一样了还不知道原因
s1 {2, 3.6, True, 2 3j}
s2 {1, 3.6, 2 3j}print(s1 s2)
# {1, 3.6, (23j)}
print(s2 s1)
# {1, 3.6, (23j)}并集
s1 {2, 3.6, True, 2 3j}
s2 {1, 3.6, False, 2 3j}print(s1 | s2)
# {False, True, 2, 3.6, (23j)}
print(s2 | s1)
# {False, 1, 2, 3.6, (23j)}并集时布尔类型和0、1比较时返回结果参考的是第一个数据
把s2的False去掉求并集时没有出现上面那种现象。
求字典value最大值对应的key
d1 {a: 2,b: 3,c: 1
}print(max(d1, keylambda x: d1[x]))max默认比较的是字典的key可以指定key来制定比较规则。
给字典按值排序
sorted(d.items(),keylambda x:x[1])字符串反转
s aStr[::-1]alist中元素的age由大到小排序
sorted函数的使用
alist [{name:a,age:20},{name:b,age:30},{name:c,age:25}]
def sort_by_age(list1):return sorted(alist,keylambda x:x[age], reverseTrue)print(sort_by_age(alist))产生一个公差为11的等差数列
print([x*11 for x in range(10)])列表里放可变参数时下面代码输出结果
list1 []
dict1 {}for i in range(3):dict1[num] ilist1.append(dict1)print(list1)
# [{num: 2}, {num: 2}, {num: 2}]因为dict1是可变变量所以每次把dict1加到列表里其实列表里存的都是dict1的引用当dict1倍改变列表里引用的dict1都一起跟着改变。
遍历列表时删除元素
1.使用一个新列表把不需要删除的元素拷贝到新列表
2.如果不使用新列表可以使用倒序遍历这样遍历时删除元素不会导致前面的索引变化
a[1,2,3,4,5,6,7,8]
print(id(a))
for i in range(len(a)-1,-1,-1): if a[i]5: pass else:a.remove(a[i]) print(id(a)) print(-----------) print(a)统计一个文本中单词频次最高的10个单词
import re
from collections import Counterdef test2(filepath):with open(filepath) as f:return list(map(lambda c: c[0], Counter(re.sub(\W, , f.read()).split()).most_common(10)))输入日期 判断这一天是这一年的第几天
考察datetime模块使用
import datetime
def dayofyear(): year input(请输入年份: ) month input(请输入月份: ) day input(请输入天: ) date1 datetime.date(yearint(year),monthint(month),dayint(day)) date2 datetime.date(yearint(year),month1,day1) return (date1-date2).days1排列奇数在偶数前且奇数升序排列偶数降序排序
方法1
def func1(l):if isinstance(l, str):l [int(i) for i in l]l.sort(reverseTrue)for i in range(len(l)):if l[i] % 2 0:l.insert(0, l.pop(i))print(.join(str(e) for e in l))方法2
def func2(l):print(.join(sorted(l, keylambda x: int(x) % 2 0 and 20 - int(x) or int(x))))以下代码他们的输出结果
def multi(): return [lambda x : i*x for i in range(4)]
print([m(3) for m in multi()])正确答案是[9,9,9,9]而不是[0,3,6,9]。产生的原因是Python的闭包的后期绑定导致的这意味着在闭包中的变量是在内部函数被调用的时候被查找的因为最后函数被调用的时候for循环已经完成, i 的值最后是3,因此每一个返回值的i都是3,所以最后的结果是[9,9,9,9]。
因为延迟绑定的特性即直到函数调用时函数内部的执行内容才被确定而此时i值在产生序列时最终被赋值为4了因此每一个函数调用中的上下文的i都是4而不是预期的递增变化的。
多装饰器代码打印顺序
from collections import abcdef decorator(func):print(a)def wrapper(*args, **kwargs):print(b)return func(*args, **kwargs)print(c)return wrapperdecorator
def worker(*args, **kwargs):print(d)if __name__ __main__:print(开始)worker()
# a
# 开始
# b
# d
# c没打印因为提前return了
