python基础学习

# -*- coding: utf-8 -*-
print('*'*20, '列表环节', '*'*20)
# append()函数向列表末尾添加一个元素.
# extend()函数向列表末尾添加多个元素.
# insert(n,xxx)函数向列表中第n个元素前插入一个元素.
L = []
for i in range(0, 5):
    L.append(i)
print(L)
L.insert(1, 5)
L.insert(2, '5')
L.extend([8, '10'])
print(L)
# remove()函数表示从列表中删除某个元素.
# del()函数也表示从列表中删除某个元素.
# pop()函数从列表中取出最后一个元素.
if i in L:
    if i == 1:
        L.remove(1)
    if i == 8:
        index = L.index(8)
        del L[index]
    if i == 4:
        L.pop(-3)
        L.insert(3, 1)
        print(L)
        L.pop(3)
        L.append(1)
        L.extend(['111', 1])
print(L)
# 列表分片.
print(L[0:5])
# 列表进行拷贝.
mix = L[0:5]
print(mix)
# 比较操作符.
print(L > mix)  # L 包含了 mix
# 成员关系操作符.
print('111' in L)
# dir(list)可查看所有列表的操作函数(方法).
# print(dir(L))
print(L.count(1))  # 列表中出现3次1.
print(L.index(1))  # index()函数可索引列表元素.
K = L[3:7]
# print(dir(K))
# print(dir(K.reverse()))
K.reverse()
print(K)
# sort()将列表中元素从小到大排序.
K.sort()
print(K)
print('*'*20)
# 关于分片'拷贝'概念的补充.
K.reverse()
list11 = K
list22 = list11
list33 = list11[:]
print(list11)
print(list22)
print(list33)
print('*'*20, '分片“拷贝”概念的补充.')  # 注：list22=list11相当于多了个指向列表的标签，list12 = list[:]是实实在在的拷贝
list11.sort()
list11.append('222')
list11.insert(0, '0')  # 查看id可知.list22=list11相当于多指向，id相同.
print(list11, id(list11))
print(list22, id(list22))
print(list33, id(list33))
print('*'*20, '列表环节', '*'*20)
print('*'*20, '元组环节', '*'*20)
# 元组和列表是近亲关系，所以在实际使用上是非常类似的.
T = (5, 4, 3, 2, 1)
print(T)
# 元组的分片.
print(T[:2])
# 更新和删除一个元组.  # 注：其并未对原元组进行修改，而是生成了一个新的元组，并贴上temp名字标签而已。原元组由于标签没有了，则会被自动回收。
T = T[:2] + (10, ) + T[2:]
print(T)
del T
# 注：元组不允许修改和删除。
# 格式化.
print('%5.2f' % 27.625)
# 序列!!!
T = (4, 3, 2, 1)
print(T)
# max() 返回序列或者参数集合中的最大值.  # min() 返回序列或者参数集合中的最小值.
print(max(T), min(T))
# sum(iterable[,start=0]) 返回序列iterable和可选参数start的总和.
print(sum(T), sum(T, 5))
# sorted()将元素从小到大重新排列.(注：元组是不可以修改和删除的，所以不可以直接对元组使用sorted与reversed命令)
print(sorted(T))  # 以列表的形式返回，并进行了排序.
# reversed()将元素倒序排列.
# print(dir(reversed))
print(reversed(sorted(T)))  # 返回一个列表倒序对象.
# for i in reversed(sorted(T)):
#     print(i)
print(list(reversed(sorted(T))))
print(reversed(T))
print(tuple(reversed(T)))
# for i in reversed(T):  # 返回一个元组倒序对象.
#     print(i)
# enumerate()将每个元素插入枚举.
num = sorted(T)
# print(dir(enumerate(num)))  # 具备'__iter__'、'__next__'，则是一个迭代器，可以进行遍历输出.
print(enumerate(num))  # 返回一个对象.也可以用遍历的方式把内容遍历出来.
print(list(enumerate(num)), '对象', tuple(enumerate(num)))
for i in enumerate(T):
    print(i[0], num[i[0]])
# zip()返回由各个参数的序列组成的元组.
nam = sorted(T)[:]  # 进行'分片'拷贝，实实在在的拷贝，不是让列表指向多个标签.
# print(num, nam)
# print(list(reversed(num)))
print(zip(list(reversed(num)), nam))  # 返回一个zip()对象.
print(list(zip(list(reversed(num)), nam)), '对象', tuple(zip(list(reversed(num)), nam)))
print('*'*20, '元组环节', '*'*20)
# 关于函数收集参数.


def test(*params):
    print('参数的长度是:', len(params))
    print('第二个参数是', params[1])


test(1, 2, 3, 4, 5, 6)


def back():
    print('255')
    return [7, 8, 9]


# back()
# print(back())
B = back()  # B = back()实例化对象。返回:函数内容.
print(B, '返回值', B[2])  # 返回:函数的返回值.
# 内嵌函数和闭包.
# 内嵌函数.


def fun1():
    print('fun1()被调用')

    def fun2():
        print('fun2()被调用')

    def fun3():
        print('fun3()被调用')
    fun2()
    return fun3


# print(fun1().__dir__())
# fun1()
print(fun1())
# f = fun1()
# print(f)  # 返回函数fun3方法对象.
# 闭包.


def ind(x):
    def fun11(y):
        return x * y
    return fun11


print(ind(5)(8))
# ind = ind(5)
# print(ind(8))
# nonlocal语句将x强制为不是局部变量.


def non():
    x = 5

    def non1():
        nonlocal x
        x *= x
        return x
    return non1()


print(non())
# global可将局部变量声明为全局变量.
count = 5


def fun4():
    global count
    count = 10
    print(count)


fun4()
print(count)
# 匿名函数：lambda表达式.
g = lambda x: 3 * x + 2  # 相当于 def 匿名(x):    return 3 * x + 2.
print(g(3))
# 过滤函数filter()可筛选出非零元素.
# filter函数接收两个参数，第一个为函数，第二个为序列，序列的每个元素作为参数传递给函数进行判，然后返回 True 或 False，
# 最后将返回 True 的元素放到新列表中，就好比是用筛子，筛选指定的元素;
# 语句:filter(function, iterable)
T = (None, [1, 0], True, False)
print(type(T))
print(filter(None, [1, 0, True, False]))  # 返回一个filter对象.
# print(filter(lambda x: x % 2, [1, 2, 3, 4, 5]))
print(list(filter(lambda x: x % 2, [1, 2, 3, 4, 5])))
print(list(filter(None, [1, 2, 3, 0, 5])))
# print(dir(filter(None, [1, 0, True, False])))  # 查看对象属性（方法）.
# for i in filter(None, [1, 0, True, False]):  # 对对象进行遍历.
#     print(i)
# print(list(filter(None, [1, 0, True, False])), '对象', tuple(filter(None, [1, 0, True, False])))


def is_odd(n):
    return n % 2 == 1


tmp = filter(is_odd, range(10))
print(tmp)
print(list(tmp))
print('*'*20)
# iter()函数和next()用来生成迭代器.
ls = [1, 2, 3, 4, 5]
# print(dir(lis))
it = iter(ls)
print(it)  # 列表形式的迭代器对象.
print(next(it))
print(next(it))
for i in it:
    print(i, end=' ')
print('*'*20)
ls = [1, 2, 3, 4, 5]
it = iter(ls)
while True:
    try:
        x = next(it)
        print(x, end=' ')
    except StopIteration:
        # 遇到StopIteration就退出循环
        break
print('*'*20)


class MyNumbers(object):
    def __iter__(self):
        self.a = 1
        return self

    def __next__(self):
        global x
        x = self.a
        self.a += 1
        return x


myclass = MyNumbers()  # 实例对象.
myiter = iter(myclass)  # 创建迭代器对象.
print(next(myiter))
print(next(myiter))
print(next(myiter))
print('*'*20)


class MyIter(object):  # 我限制循环次数，超出则抛出错误.
    def __iter__(self):
        self.a = 1
        return self  # 返回实例对象

    def __next__(self):
        global x
        x = self.a
        self.a += 1
        if x >= 3:
            raise StopIteration('抛出一个异常')  # 异常抛出print()不会执行.
        else:
            return x


My = MyIter()  # 实例对象.
ie = iter(My)  # 创建迭代器对象.
# print(next(ie))
# print(next(ie))
# print(next(ie))  # 第三次时会出错.
for i in ie:
    print(i)
print('*'*20)


class ItIter(object):  # 类似于上面while为了防止报错.
    def __iter__(self):
        self.a = 1
        return self

    def __next__(self):
        global x
        x = self.a
        while True:
            self.a += 1
            try:
                if x >= 3:
                    raise StopIteration('抛出一个异常')
                else:
                    return x
            except StopIteration:
                break
        return


MyIe = ItIter()
Ie = iter(MyIe)
print(next(Ie))
print(next(Ie))
print(next(Ie))
print('*'*20)
# 生成器内容.


def func():
    print('内容1')
    yield 1
    print('内容2')
    yield 2
    print('内容3')


f = func()
print(f)  # 返回一个迭代器对象.然后用迭代器next()方法输出.不用进行iter()方法进行创建迭代器对象.
# print(dir(f))
print(next(f))
print(f.__next__())
# print(f.__next__())  # 也报错了,没有迭代器对象了.
# print(f.__next__())  # 再次运行则报错.
print('*'*20)
import sys


def fib(n):
    global x
    x = 0
    while True:
        if n < 0:
            print('不能为负数.')
            yield n
        if x <= n:
            print('内容%s' % x)  # 为了更加方便观察.
            yield x  # 返回一个迭代器对象.
        else:
            return  # 上半部分主要用于形成迭代器对象.
        x += 1


ib = fib(-1)
print(ib.__next__())
ib = fib(2)
print(ib.__next__())
print(ib.__next__())
print(ib.__next__())
# print(ib.__next__())  # 这次报错.
print('*'*20)
ib = fib(2)
print(ib)  # 返回一个迭代器对象.
# print(dir(ib))  # 查看对象的属性（方法）.
# for i in ib:  # for循环直接遍历出来.
#     print(i)
while True:
    try:
        print(next(ib))
    except StopIteration:
        # sys.exit()  # 直接结束python让后续的命令不能运行.
        break
print('*'*20)
# 生成器表达式.
# collections是一个包含了许多类型的module包
from collections.abc import Iterator, Iterable, Generator
g = (i**2 for i in range(1, 6) if i > 3)  # 返回一个迭代器对象.
print(g)
# print(isinstance(g, Iterable))  # 迭代器对象一定是可迭代对象，可迭代对象不一定是迭代器对象.
# print(dir(g))
# print(next(g))
for i in g:
    print(i, end=' ')
print('*'*20)
# print(dir(list))  # 只含有__iter__为可迭代对象.
ls = [1, 2, 3]  # 可以看到这是一个可迭代对象但并不是迭代器，我们把它搞成一个迭代器试试看.
print('迭代器对象:', isinstance(ls, Iterator), '可迭代对象', isinstance(ls, Iterable), '生成器:', isinstance(ls, Generator))


def generator_list(a):
    for e in a:
        yield 'Province:\t' + str(e)


for province in generator_list(ls):
    print(province)
gen = generator_list(ls)
print(gen)
print(isinstance(generator_list(ls), Iterator), isinstance(generator_list(ls), Iterable), isinstance(generator_list(ls), Generator))
# print(dir(generator_list(ls)))
print(next(gen))
print(next(gen))
print(next(gen))
# print(ls)  # 可迭代对象.具备__iter__属性（方法）.
lls = iter(ls)  # iter()方法的用处.第一个参数需要是具备属性可迭代对象的变量.
# print(dir(lls))  # 迭代器对象.具备'__iter__'、'__next__'属性（方法）.
print('*'*20)


class TextIter(object):
    def __init__(self):
        self.a = [1, 2, 3]
        self.b = iter(self.a)  # 迭代器对象.

    def __iter__(self):
        print('__iter__方法')
        return iter(self.a)  # 返回迭代器对象.

    def __call__(self):
        item = next(self.b)
        print('__call__方法')
        return item  # 返回迭代器函数next().


# print(dir(TextIter))
T = TextIter()  # 创建实例对象.
# print(dir(T))
print(T)  # TextIter类的实例对象具备__iter__则是可迭代对象.
print(callable(T))  # 注意这里是True
# for i in T:  # 对可迭代对象进行遍历.
#     print(i)
T1 = iter(T)  # T1是迭代器对象.
# print(dir(T1))  # 迭代器对象.  # 没有__call__方法.
print(T1)
print(callable(T1))  # 注意这里是False
# print(T1.__next__())
# print(T1.__next__())
# print(T1.__next__())
# print(T1.__next__())  # 运行到第四次则报错.
# for i in T1:  # 对迭代器对象进行遍历.
#     print(i)
T2 = iter(T, 3)  # T必须是callable,否则无法返回callable_iterator
print(T2)
for i in T2:
    print(i)
print('*'*20)


class MyIterable(object):  # 可迭代对象.
    def __init__(self, a):
        self.a = a
        self.b = [1, 2, 3]
        self.c = iter(self.b)

    def __iter__(self):
        return MyIterator(self.a)  # 返回迭代器对象.差不多返回MyIterator类的实例对象.  My = MyIterator(self.a)

    def __call__(self, *args, **kwargs):
        ite = next(self.c)
        return ite


class MyIterator(object):  # 迭代器对象.
    def __init__(self, abb):
        self.abb = abb
        self.app = 0

    def __iter__(self):  # 返回本实例对象.
        return self

    def __next__(self):
        global x
        x = self.app
        while True:
            self.app += 1
            # try:
            if self.app > self.abb:
                raise StopIteration('抛出一个错误')
            else:
                return x
            # except StopIteration:
            #     # break
            #     print('错误')


fn = MyIterable(5)  # 创建MyIterable实例对象.
# print(dir(fn))  # 可迭代对象.
print(fn)
# print(list(fn))
# print(next(fn))  # 这里是一个错误问题，展示给你们看.记住fn是可迭代对象,不是迭代器对象.
# 然后我们先尝试可迭代对象的运用.
for i in fn:  # for循环自带抛出错误后就停止
    print(i)
# print(dir(iter(fn)))  # 迭代器对象.
print(iter(fn))  # 可以先赋值给一个变量,然后运行迭代器next()方法.然后运行输出.
itt = iter(fn)
# print(dir(itt))
# print(itt.__call__())
# print(callable(itt))  # 不是一个可调用对象.
print(itt.__next__())
print(itt.__next__())
# print(itt.__next__())
# print(itt.__next__())
# print(itt.__next__())
# print(itt.__next__())
# for i in itt:
#     print(i)
Itt = iter(fn, 3)  # 返回一个callable_iterator对象.
print(Itt)
for i in Itt:
    print(i)
print('*'*20)


class MyRange(object):  # 实现和range()语句一样的效果.
    def __init__(self, *params):
        self.step = 1
        # self.start = params[0]  # 开始
        # self.stop = params[1]  # 结束
        # self.step = params[2]  # 步长
        assert type(params) == tuple
        if len(params) == 0:
            raise TypeError('range参数不能为0')
        if len(params) > 3:
            raise TypeError('range参数只有3个')
        assert len(params) >= 1 and len(params) <= 3
        # 上面是上边界.
        if len(params) == 1:  # 一个参数的时候.
            self.start = 0  # 默认起始为零
            if params[0] <= 0:
                self.stop = 0
            else:
                self.stop = params[0]
        elif len(params) == 2:  # 两个参数的时候.
            # self.start = params[0]  # 开始
            # self.stop = params[1]  # 结束
            # if params[0] >= 0:
            if params[0] < params[1]:
                self.start = params[0]
                self.stop = params[1]
            else:  # 让他返回一个空
                self.stop = 0
                self.start = 0
            # else:
            #     self.start = params[0]
            #     self.stop = params[1]
        else:  # 传入三个参数开始、结束、步长.
            assert len(params) == 3  # 确认传入的参数是3个.
            if params[2] == 0:  # range(0, 5, 1)
                raise ValueError('range() arg 3 must not be zero')
            elif (params[0] < params[1] and params[2] > 0) or (params[0] > params[1] and params[2] < 0):
                self.start = params[0]
                self.stop = params[1]
                self.step = params[2]
            else:
                self.start = 0
                self.stop = 0
        self.start -= self.step
        self.stop -= self.step

    def __iter__(self):
        return self  # 返回当前实例对象.对象里面包含一些你对其实例对象进行的一些效果.

    def __next__(self):
        assert self.step != 0  # 步长不能为0.
        if self.step > 0:
            if self.start >= self.stop:
                raise StopIteration
            self.start += self.step
            return self.start
        else:  # 步长小于0.
            if self.start <= self.stop:
                raise StopIteration
            self.start += self.step
            return self.start


print(list(range(5)))
print(list(MyRange(5)))
print('*'*20)
print(list(range(0, 5)))
print(list(MyRange(0, 5)))
print('*'*20)
print(list(range(-5, 5, 2)))
print(list(MyRange(-5, 5, 2)))
print('*'*20)
print(list(range(5, -5, -2)))
print(list(MyRange(5, -5, -2)))
# 生成器.
Str = '456'
Float = 1.0
Int = 1  # 可知可迭代对象.
print(isinstance(Str, Iterable), isinstance(Float, Iterable), isinstance(Int, Iterable))
List = []
Dict = {}
print(isinstance(List, Iterable), isinstance(Dict, Iterable))  # 列表和字典都是可迭代对象.
# 和下面是一样的，只是为了了解清楚怎么运行的.
# yield_list = [1, [4, 5], [[8]], [7, 8, 9], 10]
#
#
# def flatten(n):
#     try:
#         for i1 in n:
#             # print(i1)
#             for ii in flatten(i1):  # [4, 5]
#                 # print(ii)
#                 yield ii
#     except TypeError:
#         yield n
#
#
# f = flatten(yield_list)
# print(list(f))
# # for i in f:
# #     print(i)
# 用于展平列表元素.


def yield_i(n):
    # print(n)
    try:
        for i1 in n:  # 或者MyRange().[3, 4]
            # yield 'PP ' + str(i)
            # print(i1)  # 3或4
            # print(yield_i(i1))
            for ii in yield_i(i1):
                # print(ii)
                yield ii
    except TypeError:
        yield n


y = yield_i([1, 2, [3, 4], [[5]]])
print(list(y))
# for i in y:
#     print(i)
# 上面内容只能应用于整型或者浮点型等不可迭代对象.如果在列表元素当中夹杂了字符串（可迭代对象），则会报错.
# 上面内容有整型的报错而终止循环，但是字符串（可迭代对象）则不会终止循环.
# 为了解决字符串等可迭代问题.我们可以加一个判断语句.


def yield_ii(n):
    try:
        for i1 in n:
            if isinstance(i1, Iterable) and not isinstance(i1, list):  # 判断i1是否是可迭代对象.
                yield '<可迭代对象> 类型:' + str(type(i1))
            else:
                for ii in yield_ii(i1):
                    yield ii
    except TypeError:
        yield n  # 解决列表的展平问题,如果到不可迭代对象后，则会抛出错误，在用生成器返回，进行遍历，遍历后，再次进行生成器.返回生成器对象.


y2 = yield_ii([1, 2, [3, 4], [[5]], 'String', [6], 'Str'])
for i in y2:
    print(i)
# 下面还有一些例子:
from itertools import count, cycle, islice
counter = count(start=13)
print(next(counter))
print(counter.__next__())
print('*'*20)
colors = cycle(['red', 'white', 'blue'])
print(next(colors))
print(next(colors))
print(colors.__next__())
print(colors.__next__())
print('*'*20)
limited = islice(colors, 0, 4)
# print(dir(limited))
print(list(limited))
print('*'*20, '字典环节', '*'*20)
brand = ['开始', '结束', '步长']
slogan = ['0', '5', '2']
print('联系:', brand[slogan.index('5')])
ZiDian = {'开始': '0', '结束': '5', '步长': '2'}
print(ZiDian.keys())  # 键名.
print(ZiDian.values())  # 值.
print(ZiDian.items())  # 键值.
# get()方法提供了更宽松的方式去访问字典项，当键不存在的时候，get()方法并不会报错，只是默默第返回一个None，表示啥都没找到.
print(ZiDian.get('开始'))
print(ZiDian.get('无', '木有'))
# copy()方法是复制字典（全拷贝）
brand1 = brand.copy()  # 对于列表的复制copy.
print(brand, id(brand))
print(brand1, id(brand1))
ZiDian1 = ZiDian.copy()  # 对于字典的复制copy.
print(ZiDian, id(ZiDian))
print(ZiDian1, id(ZiDian1))
ZiDian1['开始'] = '2'
print(ZiDian, ZiDian1)
# pop()是给定键弹出对应的值，popitem()是随机弹出一个项.
print(ZiDian1.pop('步长'))
print(ZiDian1)
print(ZiDian1.popitem())
print(ZiDian1)
# setdefault()方法与get()方法相似，但setdefault()在字典中找不到相应的键值时会自动添加.
print(ZiDian1.setdefault('步长', '2'))
print(ZiDian1)
# update()方法可以更新字典.
print(ZiDian1.update({'range': 'MyRange'}))
print(ZiDian1)
print(ZiDian1.update({'range': 'Range'}))
print(ZiDian1)
# clear()可清空一个字典.
print(ZiDian1.clear())
print(ZiDian1)
print('*'*20, '字典环节', '*'*20)
print('*'*20, '集合环节', '*'*20)
# 集合中的元素都是唯一的（集合会自动帮我们把重复的数据清理掉，集合是无序的，所以不能试图去索引集合中的某一个元素）.
num = {'1': '0'}
print(type(num))
num1 = {'1', 1, '2', 2}
print(type(num1))
# print(dir(num1))
print(num1)
# 使用add()方法可以为集合添加元素，使用remove()方法可以删除集合中已知的元素.
# 不可变集合（把元素给froze冰冻起来）(像元组一样不能随意地增加或删除集合中的元素).
print('*'*20, '集合环节', '*'*20)
import pickle  # 可以非常容易地将列表、字典这类复杂的数据类型存储为文件.（转化成二进制）.
my_list = ['1', 5, '8', 9]
print(pickle.dumps(my_list))
print(pickle.loads(b'\x80\x03]q\x00(X\x01\x00\x00\x001q\x01K\x05X\x01\x00\x00\x008q\x02K\te.'))  # 注意：是字节类型.
import easygui  # EasyGui
# print(easygui.msgbox('嗨,python'))
# from easygui import *
# print(msgbox('嗨, python'))
# import easygui as f
# print(f.msgbox('嗨,python'))
# # 显示图片（注：图片需要为GIF格式，且存放在python.exe通目录）.
print('*'*20, '下面简单说下类', '*'*20)
# 组合（将需要的类一起进行实例化并放入新的类中）这部分会在下面运行当中呈现出来效果.


class Person(object):
    name = 'Person'  # 类方法.
    __name = '私有Person'  # 私有方法.

    def __init__(self, a, b):
        self.a = a
        self.b = b
        self.num = 5
        self.flag = True
        print('Person __init__方法.')

    def pen(self):
        return self.__name  # 从内部进行把私有名给输出来.

    def time(self):
        if self.flag:
            print('前 %s 小时' % self.a)
            self.flag = False
        else:
            print('后 %s 小时' % self.b)
            self.flag = True


p = Person(12, 12)  # 创建实例对象.
print(id(p))  # p 和 p1 id不一样，一个类可以创建多个对象,这就是多态.
p1 = Person(6, 6)
print(id(p1))
print(p1.name)
# print(p.__name)  # 会报错,这是私有类方法，不能被输出.
print(p1.pen())  # 可以通过访问类里面的方法进行内部的反馈.
# print(p1._Person__name)  # 在python中，只是把私有类方法改了下名字而已.


class Person1(Person):  # 应用于继承.
    pass


print('*'*20, 'Person1环节')
p2 = Person1(12, 12)
p2.time()  # 类的继承，子类可以应用父类方法.
p2.time()
print(p2.pen())


class Person2(Person):
    def __init__(self, c):  # # 注意，如果子类有和父类一样的实例方法或类方法，会进行覆盖.
        self.c = c
        self.g = Person(12, 12)  # 类似 f = Person(d)实例化得到对象.
        Person.__init__(self, 12, 12)  # 第一种方法解决覆盖问题. # 第一种方法比如我修改了父类，后面也需要修改，造成不必要的麻烦.# 注意：此处
        # self参数依旧是指向子类Person2的指针.通俗点，就是我把Person类的__init__方法指向了Person2,其实self是Person2的实例化对象.
        # 意思就是我把父类方法指向了Person2的实例化对象.
        # super(Person2, self).__init__(12, 12)  # 第二种方法解决覆盖问题.

    def eat(self):
        if self.c == 12:
            print('当前时间 %s ' % self.c)
            self.c = 24
        else:
            print('当前时间 %s ' % self.c)
            self.c = 12


print('*'*20, 'Person2环节')
p3 = Person2(12)  # 创建实例化对象.
p3.eat()
p3.eat()
p3.time()  # 注意，如果子类有和父类一样的实例方法或类方法，会进行覆盖.  # 为了解决错误问题.需要导入父类的__init__方法.
p3.time()
# 也可以多继承，一个子类继承多个父类，就是你可以有多个爹，对吧？大致意思是class Person1(Person, Person2)  # 多继承在应用方法上,有顺序之分
# 顺序的话基本不用你去算了，你只需要认定,第一个输入的参数就是第一个顺序.
print('*'*20, '组合')
per = Person2(12)  # 进行实例化对象
print(per.g.num)
# 以下例子可见，对实例对象c的count属性赋值后，就相当于覆盖了类对象C的count属性。如果没有赋值覆盖，那么引用的是类对象的count属性
p4 = Person(12, 12)  # 创建实例化对象.
p5 = Person(12, 12)
p6 = Person(12, 12)
print(id(p4), id(p5), id(p6))
print(p4.name, p5.name, p6.name)
p6.name = 'Hello Person'
print(p4.name, p5.name, p6.name)
Person.name = '<Person>'
print(p4.name, p5.name, p6.name)
# 另外，如果属性的名字跟方法名相同，属性会覆盖方法.


class C(object):
    def method(self):
        print('C:xxx')


c = C()  # 实例化对象.
c.method()
c.method = 1
print(c.method)
# c.method()  # 会报错，可见，方法x()已经被属性method给覆盖了.
# 结论：不要试图在一个类里边定义出所有能想到的特性和方法，应该利用继承和组合机制来进行扩展；
# 用不同的词性命名，如属性名用名词、方法名用动词，并使用骆驼命名法等。
print('*'*20, '下面是绑定的概念.')
# （python严格要求需要有实例才能被调用，即绑定概念）


class B(object):
    def printB():
        print('no zuo no die')


B.printB()  # 没有绑定实例对象时.
b = B()
# b.printB()  # 出现错误原因是由于绑定机制，自动把b对象作为第一个参数传入.


class A(object):
    name = '123'

    def printA(self):  # 我方法绑定给实例对象.
        print('A')

    def printAA(self):
        self.printA()


a = A()
a.printA()
a.printAA()
# Python严格要求方法需要有实例才能被调用，这种限制其实就是Python所谓的绑定概念.
# issubclass(class, classinfo)  如果第一个参数（class）是第二个参数（classinfo）的一个子类，则返回True，否则返回False.
print(issubclass(A, object))
# isinstance(object, classinfo)  如果第一个参数（object）是第二个参数（classinfo）的实例对象，则返回True，否则返回False.
print(isinstance(a, A))
print(isinstance(a, object))
# hasattr(object, name)  用来测试一个对象里是否有指定的属性，第一个参数（object）是对象，第二个参数（name）是属性名（属性的字符串名字）.
print(hasattr(a, 'name'))
# getattr(object, name[, default])  返回对象指定的属性值，如果指定的属性不存在，则返回default(可选参数);若没有设置default参数，则抛出异常.
print(getattr(a, 'age', '20'))
# setattr(object, name, value)  可以设置对象中指定属性的值，如果指定的属性不存在，则会新建属性并赋值.
setattr(a, 'age', '20')
print(getattr(a, 'age'))
# delattr(object, name)  用于删除对象中指定的属性，如果属性不存在，抛出异常。
print(delattr(a, 'age'))
print(getattr(a, 'age', 50))
# property(fget=None, fset=None, fdel=None, doc=None)
# 用来通过属性设置属性，第一个参数是获取属性的方法名，第二个参数是设置属性的方法名，第三个参数是删除属性的方法名.
print('*'*20)


class D(object):
    def __init__(self, size=10):
        self.size = size

    def getsize(self):
        return self.size

    def setsize(self, value):
        self.size = value

    def delsize(self):
        del self.size
    x = property(getsize, setsize, delsize)


d = D()
print(d.x)
d.x = 12
print(d.x)
del d.x
# print(d.x)  # 会报错.
print('*'*20, '魔术方法')
# 注：__init__()方法的返回值一定是None .
# 其实，__new__()才是在一个对象实例化时候所调用的第一个方法，它的第一个参数是这个类（cla）,而其他的参数会直接传递给__init__()方法.


class CapStr(str):
    def __new__(cls, string):
        string = string.upper()  # 大写
        return str.__new__(cls, string)  # 使用str的__new__方法,指向当前类,并把值提交给str.


a = CapStr('hello world')
print(a)
# __del__(self)  当对象将要被销毁的时候，这个方法就会被调用。但要注意，
# 并非del x就相当于调用x.__del__()，__del__()方法是当垃圾回收机制回收这个对象的时候才调用的。


class Poo1(object):
    def __init__(self):
        print('__init__被调用')

    # def __del__(self):
    #     print('__del__被调用')


k = Poo1()
k1 = k
k2 = k1
# print(id(k))  # 多指向标签.
# print(id(k1))
# print(id(k2))
# del k
# del k1
# del k2
print('*'*20)


class NewInt(int):
    def __init__(self, value):
        self.value = value

    def __add__(self, other):  # 先说参数,第一个self参数是当前实例化参数,而other是另外一个实例化参数.
        print(id(self), id(other))  # 进行比较id实例化a、b，应该和我猜想的一样吧,相当于我把实例化的b当成参数了.
        # print('add', self, other)
        # return int.__sub__(self, other)  # 可以尝试着改成 int.__add__(self, other)
        # print(self.value, other.value)  # 为了进一步验证我的想法.
        return int(self) + int(other)  # #将self与other强制转换为整型，所以不会出现两个对象相加触发__add__()方法

    def __sub__(self, other):
        # print('sub', self, other)
        # return int.__add__(self, other)  # 和上面一样进行修改.
        return int(self) - int(other)

    # def __str__(self):
    #     return self.value


a = NewInt(3)
b = NewInt(5)
c = NewInt(1)
# print(a, b)
# print(a.value)
# print(b.value)
# print(type(a), type(b))  # 先说下相加和相减的前提是类型要一样,从这里可以看出，出自同一个类.
print(id(a), id(b))
# print(a)  # out -> 3
# print(b)  # out -> 5
print(a + b)  # 两个对象相加，触发 __add__(self,other)方法.# 顺序>>实例a -> 触发add方法(+) -> 实例b. + 返回 - 的效果.
# a + b运行模式应该是,b 进入了 a中,所以当前self是a，所以b相当于传入进去的参数,但是a和b都是同一个类.所以a能用的b也能用.
print(a - b)
print(a + b + c)


class NenInt(object):
    def __init__(self, value):
        self.value = value
        # print('__init__ %s ' % self.value)  # 体现是否创建了实例化对象.

    def __add__(self, other):
        # NenInt(f'{self.value}{other.value}') 相当于一个实例化对象.NenInt('aaaAAA').
        # print('add', self, other)
        return NenInt(f'{self.value}{other.value}')  # 运行顺序 -> 先运行Nen + Nen1，运行完之后(Nen + Nen1) + Nen2.

    def __str__(self):  # 对实例化对象进行返回self.value.
        return self.value


NenInt('ooo')
Nen = NenInt('aaa')
Nen1 = NenInt('AAA')
Nen2 = NenInt('bbb')
# Nen3 = NenInt('BBB')  # 用于验证.
# print(Nen)
print(Nen + Nen1 + Nen2)  # 可以把__str__方法注释掉，看下前后效果.


class Vector(object):
    def __init__(self, box, eye):
        self.box = box
        self.eye = eye

    def __add__(self, other):
        return Vector(self.box + self.eye + other.box, self.eye + other.box + other.eye)

    def __str__(self):
        return 'Vector ( %s , %s )' % (self.box, self.eye)


v = Vector(10, 2)
v1 = Vector(20, -5)
print(v + v1)
print('*'*20)
# 这里a是加数，b是被加数，如果a对象的__add__()方法没有实现或者不支持相应的操作，那么python就会自动调用b的__radd__()方法


class NInt(int):
    def __init__(self, q):
        self.q = q

    def __radd__(self, other):
        # print(self.q)  # 用于观看self实例化对象是谁.
        return int.__sub__(self, other)  # 调用减.


a = NInt(5)
b = NInt(3)
print(a + b)  # 由于a对象默认有__add__()方法，所以b的__radd__()没有执行.
print(3 + b)  # 由于3无__add__()方法，所以执行b的反运算__radd__(self,other)方法，其中self是b对象.
print(b + 3)
print('*'*20)


# class MyClass(object):
#     def __add__(self, other):
#         return self + other
#
#     # def __str__(self):
#         # return self
#
#
# Cla = MyClass()
# Cla1 = MyClass()
# print(Cla + Cla1)
from datetime import datetime
# 定制一个计时器类.


# class MyTimer(object):
#     def __init__(self, total=0):
#         self.begin = 0  # 时间始.
#         self.end = 0  # 时间末.
#         self.total = total
#
#     def __add__(self, other):
#         # return '相加 %s 秒' % round(float(self.total) + float(other.total), 1)  # 本身就是浮点数.
#         return MyTimer(self.total + other.total)
#
#     def __str__(self):  # 用于解决实例对象的返回的问题.
#         return str(self.total)
#
#     def start(self):  # 启动计数.
#         print('启动计时器...')
#         self.begin = datetime.now()  # 标记起始时间.
#         return self.begin
#
#     def stop(self):  # 停止计时.
#         print('终止计时器!!!')
#         self.end = datetime.now()
#         self.total = round(self.end.timestamp() - self.begin.timestamp(), 1)
#         print('总共运行了 %s 秒' % self.total)
#         return self.total
#
#     def cycle(self):
#         name = input('start/stop:').strip()
#         while True:
#             if name == 'start':
#                 self.start()
#                 name = input('stop:').strip()
#                 if name == 'stop':
#                     pass
#                 elif name == '0':
#                     break
#                 else:
#                     print('*' * 20, '请按照规则:start/stop或者退出(0)', '*' * 20)
#             elif name == 'stop':
#                 self.stop()
#                 break
#             # elif self.name == '+':  # 本来也可以在这里加，但是针对性太强，反而没有灵活性的去相加.
#             #     pass
#             else:
#                 break
#
#
# time = MyTimer()
# # print(time.start())
# # print(time.stop())
# time1 = MyTimer()
# time2 = MyTimer()
# time.cycle()
# time1.cycle()
# time2.cycle()
# # time2 = MyTimer()
# print('相加', time + time1 + time2, '秒')
# # print(time + time1)


# class MyTimer(int):
#     def __init__(self, total=0):
#         self.begin = 0  # 时间始.
#         self.end = 0  # 时间末.
#         self.total = total
#
#     def __add__(self, other):
#         # print(type(self), type(other))  # <class '__main__.MyTimer'>
#         # print(self, other)
#         # print(self.total, other.total)
#         # print(type(self), type(other))
#         print(self, other, type(self), type(other), type(int(self)), type(int(other)))
#         return int(self) + int(other)
#         # return float(self) + float(other)  # 本身就是浮点数.
#         # return '相加 %s 秒' % MyTimer(self.total)
#
#     def __radd__(self, other):
#         print('__radd__')
#         return int.__add__(self, other)
#
#     # def __str__(self):  # 用于解决实例对象的返回的问题.
#     #     return str(self.total)
#
#     def start(self):  # 启动计数.
#         print('启动计时器...')
#         self.begin = datetime.now()  # 标记起始时间.
#         return self.begin
#
#     def stop(self):  # 停止计时.
#         print('终止计时器!!!')
#         self.end = datetime.now()
#         self.total = round(self.end.timestamp() - self.begin.timestamp(), 1)
#         print('总共运行了 %s 秒' % self.total)
#         # return self
#
#     def cycle(self):
#         name = input('start/stop:').strip()
#         while True:
#             if name == 'start':
#                 self.start()
#                 name = input('stop:').strip()
#                 if name == 'stop':
#                     pass
#                 elif name == '0':
#                     break
#                 else:
#                     print('*' * 20, '请按照规则:start/stop或者退出(0)', '*' * 20)
#             elif name == 'stop':
#                 self.stop()
#                 break
#             # elif self.name == '+':  # 本来也可以在这里加，但是针对性太强，反而没有灵活性的去相加.
#             #     pass
#             else:
#                 break
#
#
# time = MyTimer(5)
# # print(time.start())
# # print(time.stop())
# time1 = MyTimer(2)
# time2 = MyTimer(1)
# time3 = MyTimer(1)
# # time.cycle()
# # time1.cycle()
# # time2.cycle()
# print(time + time1 + time2 + time3)  # 从上面种种表现可知，我是先触发__add__然后再触发了__radd__.
# # print(time + time1)
# print(time2)
# print(type(time2))

# class MyTimer(object):
#     def __init__(self, total=0):
#         self.begin = 0  # 时间始.
#         self.end = 0  # 时间末.
#         self.total = total
#
#     def __add__(self, other):
#         # print(self, other, type(self), type(other))
#         # print('__add__')
#         try:
#             return str(self.total + other.total)
#         except AttributeError:
#             return self.total + other
#
#     def __radd__(self, other):
#         # print('__radd__')
#         return MyTimer.__add__(self, float(other))
#
#     # def __str__(self):  # 用于解决实例对象的返回的问题.
#     #     return str(self.total)
#
#     def start(self):  # 启动计数.
#         print('启动计时器...')
#         self.begin = datetime.now()  # 标记起始时间.
#         return self.begin
#
#     def stop(self):  # 停止计时.
#         print('终止计时器!!!')
#         self.end = datetime.now()
#         self.total = round(self.end.timestamp() - self.begin.timestamp(), 1)
#         print('总共运行了 %s 秒' % self.total)
#         # return self
#
#     def cycle(self):
#         name = input('start/stop:').strip()
#         while True:
#             if name == 'start':
#                 self.start()
#                 name = input('stop:').strip()
#                 if name == 'stop':
#                     pass
#                 elif name == '0':
#                     break
#                 else:
#                     print('*' * 20, '请按照规则:start/stop或者退出(0)', '*' * 20)
#             elif name == 'stop':
#                 self.stop()
#                 break
#             else:
#                 break
#
#
# time = MyTimer()
# # print(time.start())
# # print(time.stop())
# time1 = MyTimer()
# time2 = MyTimer()
# # time3 = MyTimer()
# time.cycle()
# time1.cycle()
# time2.cycle()
# # time3.cycle()
# print('总共', time + time1 + time2, '秒')  # 从上面种种表现可知，我是先触发__add__然后再触发了__radd__.
# # print(time + time1)
# # print(time2)
# # print(type(time2))


# class MyTimer(object):  # 之后再尝试了.
#     def __init__(self):
#         self.date = ['年', '月', '日', '小时', '分钟', '秒']
#         self.begin = 0
#         self.end = 0
#
#     def __add__(self, other):
#         return None
#
#     def start(self):
#         if not self.stop:
#

print('*'*20)


class IndexAtt(object):
    # x = 1

    def __getattribute__(self, item):  # –定义当该类的属性被访问时的行为.
        print('__getattribute__')
        return super(IndexAtt, self).__getattribute__(item)  # 根类__getattribute__应该返回给根类的__getattr__.
        # return IndexAtt.__getattr__(self, item)

    def __getattr__(self, item):  # –定义当用户试图获取一个不存在的属性时的行为.
        print('__getattr__')
        return ' %s 类方法不存在.' % item

    def __delattr__(self, item):  # –定义当一个属性被删除时的行为.
        print('__delattr__')
        super(IndexAtt, self).__delattr__(item)

    def __setattr__(self, key, value):  # –定义当一个属性被设置时的行为.
        print('__setattr__')
        super(IndexAtt, self).__setattr__(key, value)

    def __str__(self):
        return 'I'


I = IndexAtt()
print(I.x)
print('*'*20)
I.x = 2
print('*'*20)
print(I.x)
print('*'*20)
del I.x
print('*'*20)
print(I.x)
print('*'*20)


class Rectangle(object):
    def __init__(self, width, height):
        self.width = width  # 宽.
        self.height = height  # 高.

    def __setattr__(self, key, value):
        if key == 'square':
            self.width = value
            self.height = value
        else:
            self.__dict__[key] = value

    def getarea(self):
        return self.width * self.height


r = Rectangle(5, 4)
print(r.getarea())
r.square = 5
print(r.getarea())
r.p = 4
print(r.__dict__)
print('*'*20)
# 描述符.


class MyDescriptor(object):
    def __init__(self):
        self.a1 = 'aa1'
        print('MyDescriptor')

    def __get__(self, instance, owner):
        print('get', self, instance, owner)
        return self

    def __set__(self, instance, value):
        print('set', self, instance, value)

    def __delete__(self, instance):
        print('del', self, instance)

    def __getattribute__(self, item):
        # print(self, item)
        # return '触发1 %s ' % item
        return super(MyDescriptor, self).__getattribute__(item)


class Test(object):
    x = MyDescriptor()  # 取MyDescriptor类的实例指派给Test类的属性x.  # 相当于创建实例对象.

    def __init__(self):
        self.a2 = 'a2'
        self.x = '实例化对象'  # 类似Test实例化对象对x类方法进行设置.
        print('Test')

    # def __getattribute__(self, item):  # 刻属性可以让描述器失效.
    #     return '触发2 %s ' % item
        # return super(Test, self).__getattribute__(item)


test = Test()
test.x
Test.x
print(Test.x.a1)
# print(test.x.a1)
# print(test.x)  # 有顺序之分.__getattribute__ -> 数据描述符 -> 实例对象的字典 -> 类的字典 -> 非数据描述符 -> 父类的字典 -> getattr().
# 所以呐，就先注释掉__set__、__get__、__delete__其中两个使之变成非数据描述符.
# test.x = '可口'
# del test.x