这本书其实内容挺多的吧,完全覆盖了我看的视频课smile。为了结合它们,就随便加上序号了。
1.python中的魔法函数
什么是魔法函数?
1)在python中以双下滑线开头并且以双下滑线结尾的函数
2)魔法函数可以随意定义某个类的特性,这些方法在进行特定的操作时会自动被调用
参考:https://www.cnblogs.com/small-office/p/9337297.html
2.类和对象
2.1 鸭子类型
调用不同的子类将会产生不同的行为,而无须明确知道这个子类实际上是什么,这是多态的重要应用场景。而在python中,因为鸭子类型(duck typing)使得其多态不是那么酷。
鸭子类型是动态类型的一种风格。在这种风格中,一个对象有效的语义,不是由继承自特定的类或实现特定的接口,而是由"当前方法和属性的集合"决定。这个概念的名字来源于由James Whitcomb Riley提出的鸭子测试,“鸭子测试”可以这样表述:“当看到一只鸟走起来像鸭子、游泳起来像鸭子、叫起来也像鸭子,那么这只鸟就可以被称为鸭子。”
在鸭子类型中,关注的不是对象的类型本身,而是它是如何使用的。例如,在不使用鸭子类型的语言中,我们可以编写一个函数,它接受一个类型为"鸭子"的对象,并调用它的"走"和"叫"方法。在使用鸭子类型的语言中,这样的一个函数可以接受一个任意类型的对象,并调用它的"走"和"叫"方法。如果这些需要被调用的方法不存在,那么将引发一个运行时错误。任何拥有这样的正确的"走"和"叫"方法的对象都可被函数接受的这种行为引出了以上表述,这种决定类型的方式因此得名。
鸭子类型通常得益于不测试方法和函数中参数的类型,而是依赖文档、清晰的代码和测试来确保正确使用。
2.2 类方法,静态方法和实例方法
class Date:
#构造函数
def __init__(self, year, month, day):
self.year = year
self.month = month
self.day = day
def tomorrow(self):
self.day += 1
@staticmethod
def parse_from_string(date_str):
year, month, day = tuple(date_str.split("-"))
return Date(int(year), int(month), int(day))
@staticmethod
def valid_str(date_str):
year, month, day = tuple(date_str.split("-"))
if int(year)>0 and (int(month) >0 and int(month)<=12) and (int(day) >0 and int(day)<=31):
return True
else:
return False
@classmethod
def from_string(cls, date_str):
year, month, day = tuple(date_str.split("-"))
return cls(int(year), int(month), int(day))
def __str__(self):
return "{year}/{month}/{day}".format(year=self.year, month=self.month, day=self.day)
if __name__ == "__main__":
new_day = Date(2018, 12, 31)
new_day.tomorrow()
print(new_day)
#2018-12-31
date_str = "2018-12-31"
year, month, day = tuple(date_str.split("-"))
new_day = Date(int(year), int(month), int(day))
print (new_day)
#用staticmethod完成初始化
new_day = Date.parse_from_string(date_str)
print (new_day)
#用classmethod完成初始化
new_day = Date.from_string(date_str)
print(new_day)
print(Date.valid_str("2018-12-32"))
2.3数据封装和私有属性
from chapter04.class_method import Date
class User:
def __init__(self, birthday):
self.__birthday = birthday
def get_age(self):
#返回年龄
return 2018 - self.__birthday.year
if __name__ == "__main__":
user = User(Date(1990,2,1))
print(user._User__birthday)
print(user.get_age())
#1990/2/1
#28
2.4自省机制
通过一定的机制查询到对象的内部结构
class Person:
"""
人
"""
name = "user"
class Student(Person):
def __init__(self, scool_name):
self.scool_name = scool_name
if __name__ == "__main__":
user = Student("慕课网")
#通过__dict__查询属性
print(user.__dict__)
user.__dict__["school_addr"] = "北京市"
print(user.school_addr)
print(Person.__dict__)
print(user.name)
a = [1,2]
#{'scool_name': '慕课网'}
#北京市
#{'__module__': '__main__', '__doc__': '\n 人\n ', 'name': 'user', '__dict__': <attribute '__dict__' of 'Person' objects>, '__weakref__': <attribute '__weakref__' of 'Person' objects>}
#user
2.5 super
super() 函数是用于调用父类(超类)的一个方法。
如果子类(Puple)继承父类(Person)不做初始化,那么会自动继承父类(Person)属性name。
如果子类(Puple_Init)继承父类(Person)做了初始化,且不调用super初始化父类构造函数,那么子类(Puple_Init)不会自动继承父类的属性(name)。
如果子类(Puple_super)继承父类(Person)做了初始化,且调用了super初始化了父类的构造函数,那么子类(Puple_Super)也会继承父类的(name)属性。
super 是用来解决多重继承问题的,直接用类名调用父类方法在使用单继承的时候没问题,但是如果使用多继承,会涉及到查找顺序(MRO)、重复调用(钻石继承)等种种问题。
minin模式:解决多重继承
特点: 1. Mixin类功能单一
2. 不和基类关联,可以和任意基类组合, 基类可以不和mixin关联就能初始化成功
3. 在mixin中不要使用super这种用法
2.6 with语句和上下文管理器
class Sample:
def __enter__(self):
print ("enter")
#获取资源
return self
def __exit__(self, exc_type, exc_val, exc_tb):
#释放资源
print ("exit")
def do_something(self):
print ("doing something")
with Sample() as sample:
sample.do_something()
#enter
#doing something
#exit
import contextlib
@contextlib.contextmanager
def file_open(file_name):
print ("file open")
yield {}
print ("file end")
with file_open("bobby.txt") as f_opened:
print ("file processing")
3.自定义序列类
容器序列:list、tuple、collections.deque等,能存放不同类型的数据
扁平序列:str、bytes、bytearray、memoryview(内存视图)、array.array等,存放的是相同类型的数据
容器序列存放的实际上是对象的引用,因此可以存放不同类型的数据;扁平序列存放的是对象的值,是一段连续的内存空间,因此要求对象必须是相同类型的数据才行,如字符、数字、字节。
可变序列:list、bytearray、array.array、collections.deque、memoryview。
不可变序列:tuple、str、bytes
定义就是字面意思
切片原理:
aList = [3, 4, 5, 6, 7, 9, 11, 13, 15, 17]
print (aList[::]) # 返回包含原列表中所有元素的新列表
#[3, 4, 5, 6, 7, 9, 11, 13, 15, 17]
print (aList[::-1]) # 返回包含原列表中所有元素的逆序列表
#[17, 15, 13, 11, 9, 7, 6, 5, 4, 3]
print (aList[::2]) # 隔一个取一个,获取偶数位置的元素
#[3, 5, 7, 11, 15]
print (aList[1::2]) # 隔一个取一个,获取奇数位置的元素
#[4, 6, 9, 13, 17]
print (aList[3:6]) # 指定切片的开始和结束位置
#[6, 7, 9]
aList[0:100] # 切片结束位置大于列表长度时,从列表尾部截断
aList[100:] # 切片开始位置大于列表长度时,返回空列表
aList[len(aList):] = [9] # 在列表尾部增加元素
print(aList)
#[3, 4, 5, 6, 7, 9, 11, 13, 15, 17, 9]
aList[:0] = [1, 2] # 在列表头部插入元素
print(aList)
#[1, 2, 3, 4, 5, 6, 7, 9, 11, 13, 15, 17, 9]
aList[3:3] = [4] # 在列表中间位置插入元素
print(aList)
#[1, 2, 3, 4, 4, 5, 6, 7, 9, 11, 13, 15, 17, 9]
aList[:3] = [1, 2] # 替换列表元素,等号两边的列表长度相等
print(aList)
#[1, 2, 4, 4, 5, 6, 7, 9, 11, 13, 15, 17, 9]
aList[3:] = [4, 5, 6] # 等号两边的列表长度也可以不相等
print (aList)
#[1, 2, 4, 4, 5, 6]
aList[::2] = [0] * 3 # 隔一个修改一个
print (aList)
#[0, 2, 0, 4, 0, 6]
aList[::2] = ['a', 'b', 'c'] # 隔一个修改一个
print(aList)
#['a', 2, 'b', 4, 'c', 6]
#aList[::2] = [1,2] # 左侧切片不连续,等号两边列表长度必须相等
aList[:3] = [] # 删除列表中前3个元素
print(aList)
#[4, 'c', 6]
del aList[:3] # 切片元素连续
print(aList)
#[]
del aList[::2] # 切片元素不连续,隔一个删一个
print(aList)
#[]
3.2 set和dict
dict查找的性能远远大于list
在list中随着list数据的增大 查找时间会增大
在dict中查找元素不会随着dict的增大而增大
1.dict的key或者set的值 都必须是可以hash的
不可变对象都是可hash的(str, fronzenset, tuple)
2. dict的内存花销大,但是查询速度快, 自定义的对象 或者python内部的对象都是用dict包装的
3. dict的存储顺序和元素添加顺序有关
4. 添加数据有可能改变已有数据的顺序
s = {'a','b', 'c'}
#向set添加数据
another_set = set("cef")
re_set = s.difference(another_set)
print(re_set)
re_set = s - another_set
print(re_set)
re_set = s & another_set
print(re_set)
re_set = s | another_set
print(re_set)
#{'a', 'b'}
#{'a', 'b'}
#{'c'}
#{'c', 'e', 'f', 'a', 'b'}
#set性能很高
4.垃圾回收机制
#cpython中垃圾回收的算法是采用 引用计数
a = object()
b = a
del a
print(b)
#print(a)
class A:
def __del__(self):
pass
#<object object at 0x0000024968E0E120>
附录:python/linux面试的若干个没答上来的问题
1.python取数组倒数第四到倒数第六个数怎么写?
a=[1,2,3,4,5,6,7,8,9]
b=a[-4:-7:-1];
print(b)
这样打出来就是[6,5,4]。为什么第二个位置是-7,规定就是这样,同理如果你想结果是9,就应该取[:,-2,-1]。-1代表倒序,[:,:,-1]默认会把整个数组从后向前打一遍。
2.linux中把某文本第二个字符到第四个字符打出来?
3.如果要编一个线程池怎么写?