python核心编程笔记(2)

1.元类编程

属性调用：如果user是某个类的实例，那么user.age（以及等价的getattr(user,’age’)）首先调用__getattribute__。如果类定义了__getattr__方法，那么在__getattribute__抛出 AttributeError 的时候就会调用到__getattr__，而对于描述符(get）的调用，则是发生在__getattribute__内部的。
user = User(), 那么user.age 顺序如下：
（1）如果“age”是出现在User或其基类的__dict__中， 且age是data descriptor， 那么调用其__get__方法, 否则
（2）如果“age”出现在user的__dict__中， 那么直接返回 obj.dict[‘age’]， 否则
（3）如果“age”出现在User或其基类的__dict__中
（3.1）如果age是non-data descriptor，那么调用其__get__方法， 否则
（3.2）返回 dict[‘age’]
（4）如果User有__getattr__方法，调用__getattr__方法，否则
（5）抛出AttributeError

1.1 动态属性

from datetime import date, datetime
class User:
    def __init__(self, name, birthday):
        self.name = name
        self.birthday = birthday
        self._age = 0

    # def get_age(self):
    #     return datetime.now().year - self.birthday.year

    @property
    def age(self):
        return datetime.now().year - self.birthday.year

    @age.setter
    def age(self, value):
        self._age = value

if __name__ == "__main__":
    user = User("bobby", date(year=1987, month=1, day=1))
    user.age = 30
    print (user._age)
    print(user.age)

1.2

**getattr**在当前主流的Python版本中都可用，重载__getattr__方法对类及其实例未定义的属性有效。也就属性是说，如果访问的属性存在，就不会调用__getattr__方法。这个属性的存在，包括类属性和实例属性。
**getattribute**仅在新式类中可用，重载__getattrbute__方法对类实例的每个属性访问都有效。
new 是用来控制对象的生成过程， 在对象生成之前
init是用来完善对象的
如果new方法不返回对象， 则不会调用init函数

1.3 ORM

使用过Django ORM的人都知道，有了ORM，使得我们操作数据库，变得异常简单。
属性描述符可以实现对属性值的类型，范围等一切做约束，意思就是说变量id只能是int类型，变量name只能是str类型，否则将会抛出异常。
参考：https://www.cnblogs.com/wongbingming/p/8973859.html#horm

2.迭代器和生成器

迭代器是访问集合内元素的一种方式， 一般用来遍历数据
迭代器和以下标的访问方式不一样， 迭代器是不能返回的, 迭代器提供了一种惰性方式数据的方式。

from collections.abc import Iterator

class Company(object):
    def __init__(self, employee_list):
        self.employee = employee_list

    def __iter__(self):
        return MyIterator(self.employee)

    # def __getitem__(self, item):
    #     return self.employee[item]


class MyIterator(Iterator):
    def __init__(self, employee_list):
        self.iter_list = employee_list
        self.index = 0

    def __next__(self):
        #真正返回迭代值的逻辑
        try:
            word = self.iter_list[self.index]
        except IndexError:
            raise StopIteration
        self.index += 1
        return word

if __name__ == "__main__":
    company = Company(["tom", "bob", "jane"])
    my_itor = iter(company)
    # while True:
    #     try:
    #         print (next(my_itor))
    #     except StopIteration:
    #         pass

    # next(my_itor)
    for item in company:
        print (item)
#tom
#bob
#jane

生成器函数，函数里只要有yield关键字

#生成器函数，函数里只要有yield关键字
def gen_func():
    yield 1
    yield 2
    yield 3

for data in gen_fib(10):
    print (data)
# print (gen_fib(10))
# 斐波拉契 0 1 1 2 3 5 8
#惰性求值， 延迟求值提供了可能

def func():
    return 1

if __name__ == "__main__":
    #生成器对象， python编译字节码的时候就产生了，
    gen = gen_func()
    for value in gen:
        print (value)

参考链接：https://www.cnblogs.com/yangmingxianshen/p/11252541.html

3.socket编程

服务器端：

import socket
import threading

server = socket.socket(socket.AF_INET,socket.SOCK_STREAM)
server.bind(('0.0.0.0', 8000))
server.listen()


def handle_sock(sock, addr):
    while True:
        data = sock.recv(1024)
        print(data.decode("utf8"))
        re_data = input()
        sock.send(re_data.encode("utf8"))

#获取从客户端发送的数据
#一次获取1k的数据
while True:
    sock, addr = server.accept()

    #用线程去处理新接收的连接(用户)
    client_thread = threading.Thread(target=handle_sock, args=(sock, addr))
    client_thread.start()

    data = sock.recv(1024)
    print(data.decode("utf8"))
    re_data = input()
    sock.send(re_data.encode("utf8"))
    #server.close()
    #sock.close()

客户端：

import socket
client = socket.socket(socket.AF_INET,socket.SOCK_STREAM)
client.connect(('192.168.44.1', 8000))
while True:
    re_data = input()
    client.send(re_data.encode("utf8"))
    data = client.recv(1024)
    print(data.decode("utf8"))
    # client.send("bobby".encode("utf8"))
    # data = client.recv(1024)
    # print (data.decode("utf8"))
    #client.close()

这章对应书的第二，三章（网络编程和因特网客户端编程）。