python核心编程笔记(1)

这本书其实内容挺多的吧，完全覆盖了我看的视频课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.如果要编一个线程池怎么写?