<div class="container">
    <h1>Hello, world!</h1>
    <p>Welcome to my website!</p>
</div>

<!-- <div class="container">
    <h1>Hello, world!</h1>
    <p>Welcome to my website!</p>
</div> -->

定义：
   多态指的是一类事物有多种形态，（一个抽象类有多个子类，因而多态的概念依赖于继承）
   
例如:
	序列有多种形态:字符串，列表，元祖
	动物有多种形态:人，猪，狗
	
多态和多态性的区别:
    多态：同一种事物的多种形态，动物分为人类，猪类（在定义角度） 
    多态性：一种调用方式，不同的执行效果（多态性）
   
"""
面向对象的三大特征:封装,继承,多态

封装:又称为信息的隐藏,类的实现和使用时分开的,类提供了外部访问的方法,调用者不需要关注
类里面的具体实现,会调用即可

生活中封装:买手机会用就可以

继承:一个类继承另外一个类,被继承的类称为父类或者基类,继承的类称为子类或者派生类,
子类可以共享父类里面受保护,公有属性和方法,子类不能共享父类私有属性和方法
继承可以减少代码的书写,提高代码的可维护性

多态:同一种事物有多种形态
多态性:同一种调用方式,返回不同的结果
多态的前提:继承和重写
"""
#多态:一种事物有多种表现形式
#定义一个父类
class Animal(object):
    #定义一个普通方法
    def sayHello(self):
        pass

#定义一个子类Person,继承父类Animal
class Person(Animal):
    #重写父类同名的方法
    def sayHello(self):
        print('hello,i am Person')

#定义一个子类Pig,继承父类Animal
class Pig(Animal):
    #重写父类同名的方法
    def sayHello(self):
        print('aoao,i am Pig')

#定义一个子类Dog,继承父类Animal
class Dog(Animal):
    #重写父类同名的方法
    def sayHello(self):
        print('wangwang,i am Dog')

#实例化不同子类创建对象
Per = Person()
Pi = Pig()
Do = Dog()
# Per.sayHello()
# Pi.sayHello()
# Do.sayHello()

#多态性:同一种调用方式,返回不同的结果
def func(o):  #python是动态语言,o是多态性的体现,这里不需要指定类型,参数的类型由调用者传的值决定
    o.sayHello()

func(Per)
func(Pi)
func(Do)

#多态的好处
class Cat(Animal): #继承父类Animal重新定义子类Cat
    def sayHello(self):
        print('mimi,i am Cat')

#创建一个Cat的对象ca
ca = Cat()
func(ca)

"""
多态的好处:
1.提高代码在外部调用灵活性
2.提高代码的扩展性
"""

概述：
    在类中定义的属性（公有和私有）
	
#定义一个人类，设置姓名和年龄属性

class Person(object):
    name = 'xiaoming'  #公有类属性
    __age = 12          #私有类属性

#创建Person类的对象p
p = Person()
print(p.name)  #实例对象访问类的公有属性
print(Person.name)  #类对象访问类的公有属性

print(p.__age)   #实例对象访问类的私有属性   not ok
print(Person.__age) ##类对象访问类的私有属性 not ok 

#定义一个人类，设置姓名，年龄和地址等属性

class Person(object):
    address = '上海市' #类属性

    #定义初始化方法
    def __init__(self,name,age):
        self.name = name  #实例属性
        self.age = age

#创建Person类的对象pe
pe = Person('张三',30)
# print(pe.address)  #通过实例对象访问类属性
# print(pe.name)  #通过实例对象访问实例属性
# print(pe.age)

print(Person.address)    #类在定义的时候已经产生了,类属性直接属于类
print(Person.name)  #当实例化类创建对象,对属性赋值 实例属性才会产生内存里面 类访问不到实例属性
print(Person.age)

#定义一个人类
class Person(object):
    country = 'china' #类属性

    #定义初始化方法
    def __init__(self):
        self.country = '上海市' #实例属性

#创建Person类的对象p
p = Person()
print(p.country)  #通过实例对象访问属性 输出“上海市”
print(Person.country) #类对象访问属性 输出“china”
#通过实例属性修改类属性的值
p.country = 'chinese'  #实例属性会屏蔽类属性
print(p.country) # 输出“chinese”
print(Person.country) # 输出“china”

del p.country  #删除实例对象
print()
print(p.country) # 输出“china”，是类对象，不是实例对象
print(Person.country) # 输出“china”

#类里面定义同名的实例属性和类属性,实例对象修改类属性,实例属性会屏蔽同名类属性
#实例属性优先级高于类属性

# 定义一个人类

class Person(object):
    country = 'china'  # 类属性

    @classmethod
    def getCountry(cls):
        return cls.country

    @classmethod
    def setCountry(cls, country):
        cls.country = country


# 创建Person对象
p = Person()
print(p.getCountry())  # 通过实例对象访问类方法 输出“china”
print(Person.getCountry())  # 通过类对象访问类方法 输出“china”

p.setCountry('chinese')
print(p.getCountry()) # 输出"chinese"
print(Person.getCountry()) # 输出“chinese”    

# 总结:类方法可以修改类属性

概述：
   需要通过修饰器@staticmethod来进行修饰，不需要传参数  

#定义一个人类
class Person(object):
    country = 'china' #类属性

    @staticmethod
    def getCountry():
        return Person.country

#创建Person类的对象
p = Person()
print(p.getCountry())  #通过实例对象访问静态方法

动态语言：可以在运行的过程中，修改代码
静态语言：编译时已经确定的代码，运行的时候不能修改

如果我们想要限制实例属性？
    允许对Person实例中添加name和age属性，
    python允许定义class的时候，定义一个特殊的变量---->__slots__，限制class能够添加的属性
    
语法格式:__slots__ = ('属性1','属性2')
    
#定义一个人类，只允许添加姓名和年龄属性    

class Student(object):
    __slots__ = ('name','sex')  #限制当前类添加的属性

#通过Student类创建对象stu
stu = Student()
#往对象里面添加属性
stu.name = '张三'
stu.sex = '男'
print(stu.name)
print(stu.sex)
#增加一个新的属性
# stu.weight = '80kg'  #报错,类中限制添加属性没有weight
# print(stu.weight)
Student.weight = '50kg' # 添加类属性
print(stu.weight)

#定义一个子类demo,继承Student
class Demo(Student):
    pass
d = Demo()
d.height = '180'
print(d.height)

"""
注意:__slots__属性限制添加属性只对当前类的实例对象起作用,对类属性,继承的子类实例对象不起作用的
"""

#定义一个money类，设置一个私有的__money属性

class Money(object):
    #定义一个初始化方法
    def __init__(self):
        self.__money = 0

    #定义对属性设置的方法
    def setMoney(self,value):
        if isinstance(value,int) or isinstance(value,float):
            self.__money = value
        else:
            print('Error:金额只能是整形或者浮点型')

    #定义方法获取属性值
    def getMoney(self):
        return self.__money

    #添加实例属性
    money = property(getMoney,setMoney)

#通过Money类创建对象mo
mo = Money()
# print(mo.__money)  #实例对象不能访问类的私有属性
mo.setMoney(100)
print(mo.getMoney()) # 输出100

# 下面这两行代码看似是直接修改了对象的私有属性，实际上是先调用了getMoney和setMoney方法
mo.money = 500
print(mo.money) # 输出500

class Money(object):
    #定义初始化方法
    def __init__(self):
        self.__money = 0

    @property
    def money(self):  #相当于获取元素值方法
        return self.__money

    @money.setter   #money是上面取值的方法名  赋值的方法
    # @money.setter是一个装饰器，用于指定一个方法作为属性的设置方法
    def money(self,value):
        if isinstance(value,int) or isinstance(value,float):
            self.__money = value
        else:
            print('Error:不是整形也不是浮点型')
    # 上面两个方法同名，第一个用来获取元素，第二个用来设置元素的值，然后在外界看起来虽然是私有属性的money和实例属性并无区别
#通过Money创建对象m
m = Money()
print(m.money)
m.money = 16888
print(m.money)

#导入邮件库
import smtplib
#导入邮箱文本
from email.mime.text import MIMEText

#设置邮箱服务器 qq/126/163/gmail/yahoo/阿里云
SMTPServer = 'smtp.163.com'
#设置发送邮箱的地址
sender = 'ztb0016@163.com'
#设置发送邮箱的通行码，不是密码
password = 'GTTULMLHIKOZSXIZ'


#设置发送的内容
message = '你是一个好人123333...'
#转换成人能够看懂的格式
msg = MIMEText(message)
#设置发送邮件的主题
msg['subject'] = '来自一位帅哥的表白33333'
#发送者
msg['from'] = sender

#设置邮箱服务器， 25表示的是端口
emailServer = smtplib.SMTP(SMTPServer,25)
#登录邮箱
emailServer.login(sender,password)
#发送邮件的内容
emailServer.sendmail(sender,['piolet0016@gmail.com'],msg.as_string())
#关闭邮箱
emailServer.quit()

"""
栈--->有名堆栈
原理:先进后出

装子弹
"""
#使用列表模拟堆栈
#入栈
# stack = []
# stack.append('A')
# stack.append('B')
# stack.append('C')
# print(stack)
#
# #出栈
# stack.pop()
# print(stack)
import os
def getAllFileDir(path):
    stack = []
    #入栈
    stack.append(path)
    #处理栈,当栈为空的时候结束操作
    while len(stack) != 0:
        #出栈
        outDir = stack.pop()
        #获取当前目录所有文件
        filelist = os.listdir(outDir)
        #判断哪些是目录,继续入栈,如果是文件直接打印
        for fileName in filelist:
            #判断文件是否是路径(用绝对路径)
            fileAbsPath = os.path.join(outDir,fileName)
            if os.path.isdir(fileAbsPath):
                print('目录:',fileName)
                #入栈
                stack.append(fileAbsPath)
            else:
                print('文本文件:',fileName)
#调用函数
getAllFileDir('C:\python课程大纲\python课程大纲')

import collections
queue = collections.deque()

queue.append(path)

outDir = queus.popLeft()

"""
队列原理:先进先出
#银行办理业务排队

collections
deque()  创建一个队列
append() 队列添加元素
popLeft() 从队列里面删除元素
len() 获取长度

listdir()获取当前目录下所有的文件
isdir()判断是否是目录
"""
import collections
import os
def getAllFileDir(path):
    #创建一个队列
    queue = collections.deque()
    #入队
    queue.append(path)
    #处理队列,如果队列为空结束操作
    while len(queue) != 0:
        #出队
        outDir = queue.popleft()
        #获取当前目录下所有的文件
        filelist = os.listdir(outDir)
        #判断哪些是目录,入队,如果是文件直接打印
        for fileName in filelist:
            #判断是否是路径(用绝对路径)
            fileAbsPath = os.path.join(outDir,fileName)
            if os.path.isdir(fileAbsPath):
                print('目录:',fileName)
                #入队
                queue.append(fileAbsPath)
            else:
                print('文本文件:',fileName)
#调用函数
getAllFileDir('C:\python课程大纲\python课程大纲')

li = [1,2,3,4]
#案例1:计算列表各个元素的平方
#定义一个求平方的函数
def square(n):
    return n ** 2

res = map(square,li)  #将li列表里面每个元素先作为square函数参数,获取每个元素平方,再执行map函数
print(res)  #输出<map object at 0x000002C8C4875CC0>
print(tuple(res))   #输出(1, 4, 9, 16)
print(list(res))  #输出[]
#案例2：将单个字符转换为对应的字面量整数
li2 = ['1','2','3','4']
#定义一个函数
def chrToInt(str):
    return {'0':0,'1':1,'2':2,'3':3,'4':4,'5':5}[str]
res2 = map(chrToInt,li2)
# print(list(res2))

#案例3：将整数元素的序列，转换为字符串类型
#[1,2,3,4]--->['1','2','3','4']
res3 = map(str,[1,2,3,4])
print(tuple(res3))

from functools import reduce
#案例1:两个数的求和
def add(a,b):
    return a + b
res = reduce(add,range(1,101))
print(res)

#案例2:获取每一个词出现的次数（空格）
str = 'hello python hello php python aa ss aa'
list = str.split(' ')
print(list)

#定义一个函数
def func(x,y):
    if y in x:
        x[y] += 1
    else:
        x[y] = 1
    return x
res3 = reduce(func,list,{})
# reduce 函数的工作流程是：
# 将初始值 {} 和列表中的第一个元素传递给函数 func 进行处理，得到一个新的结果。
# 将上一步的结果和列表中的下一个元素传递给函数 func 进行处理，得到另一个新的结果。
# 不断重复上述过程，直到列表中的所有元素都被处理完毕。
# 返回最终的结果，即字典，其中存储了每个单词的出现次数。
print(res3)

#案例1:筛选指定的元素
list01 = [1,2,3,4,5,6,7,8,9,10]
#案例1:将偶数筛选出来,奇数删除
#定义一个函数
def even(num):
    if num % 2 == 0:
        return True
    return False
res = filter(even,list01)
print(list(res))

#案例2:将没有爱好的信息过滤掉
list02 = [['姓名','年龄','爱好'],['xiaoming',25,'无'],['laowang',30,'写代码'],['xiaogang',29,'无']]
#定义一个函数
def test(v):
    if v == '无':
        return False
    return True
for line in list02:
    res2 = filter(test,line)
print(list(res2))
#使用匿名函数
res4 = filter(lambda x:x.isdigit(),L)
print(list(res4))

lst = [2,0,99,20,100,111]
lst.sort()
print(lst)
res = sorted(lst)
print(res)

#key接受一个内置函数进行排序
lst2 = [-3,10,8,2,111,-200]
lst2.sort()
print(lst2)
res2 = sorted(lst2,key=abs)
print(res2)

class MyClass:
    class_attr = "I am a class attribute"  # 类属性

# 通过类名修改类属性的值
MyClass.class_attr = "Modified class attribute"

# 输出修改后的类属性值
print(MyClass.class_attr)  # 输出："Modified class attribute"

# 创建实例对象
obj = MyClass()

# 通过实例对象修改类属性的值
obj.class_attr = "New class attribute value"

# 输出实例对象的属性值
print(obj.class_attr)  # 输出："New class attribute value"

# 输出类属性的值
print(MyClass.class_attr)  # 输出："Modified class attribute"

'''
2.定义学生类student,在该类中使用构造函数实现对学生信息(姓名、年龄、性别)
的初始化，然后针对类的各个属性建立相应的方法来获取属性的值
'''
class student():
    name = ''
    age = 0
    sex = ''
    def __init__(self, name, age, sex):
        self.name = name
        self.age = age
        self.sex = sex
    def get_name(self):
        return self.name
    def get_age(self):
        return self.age
    def get_sex(self):
        return self.sex

studentA = student("xiaoming", 19, "男")

print(studentA.get_name())
print(studentA.get_age())
print(studentA.get_sex())

"""
3.定义一个学生类。有下面的类属性:
1 姓名
2 年龄
3 成绩（语文,数学,英语)[每课成绩的类型为整数]
类方法：
1 获取学生的姓名：get_name() 返回类型:str
2 获取学生的年龄：get_age() 返回类型:int
3 返回3门科目中最高的分数。get_course() 返回类型:int
写好类以后,可以创建对象测试下：
stu = Student('zhangming',20,[69,88,100])
返回结果：
zhangming
20
100
"""
class Student:
    def __init__(self, name, age, scores):
        self.name = name
        self.age = age
        self.scores = scores

    def get_name(self):
        return self.name

    def get_age(self):
        return self.age

    def get_course(self):
        return max(self.scores)

# 创建学生对象并测试
stu = Student('zhangming', 20, [69, 88, 100])
print(stu.get_name())
print(stu.get_age())
print(stu.get_course())

"""
4.练习：
    有一个学校,人数为0,入职的老师和学生,人数增加1,老师要显示姓名和工号,
	学生要显示姓名和成绩,老师和学生入职后都需要做自我介绍
"""
class people():
    def __init__(self, name, id):
        self.name = name
        self.id = id
    def introduction(self):
        print(f"大家好，我是{self.name}")

class teacher(people):
    def __init__(self, name, id):
        super(teacher, self).__init__(name, id)
    def __str__(self):
        msg = f"姓名：{self.name}  工号：{self.id}"
        return msg
class student(people):
    def __init__(self, name, id, scores):
        self.scores = scores
        super(student, self).__init__(name, id)
    def __str__(self):
        msg = f"姓名：{self.name}  学号：{self.id}  成绩：{self.scores}"
        return msg

class school():
    def __init__(self):
        self.total_num = 0
        self.teachers = []
        self.students = []
    def add_teachers(self, teacher):
        self.teachers.append(teacher)
        self.total_num += 1
        print(teacher)
        teacher.introduction()
    def add_student(self, student):
        self.students.append(student)
        self.total_num += 1
        print(student)
        student.introduction()

jinan_university = school()
teacherA = teacher("xiazhihua", "0001")
studentA = student("ztb", "123", [89, 89, 89])
jinan_university.add_teachers(teacherA)
jinan_university.add_student(studentA)

import torch
import torch.nn as nn


m = nn.MultiheadAttention(embed_dim=2, num_heads=1)
# embed_dim=2：指定了输入的嵌入维度（embedding dimension），即每个输入样本的特征维度为2，说白了就是图像的列数
# num_heads=1：指定了注意力头的数量，即将输入特征分成几份进行注意力计算。在这个例子中，只使用了1个注意力头。
t1 = [[[1., 2.],   # q1, k1, v1
       [2., 3.],   # q2, k2, v2
       [3., 4.]]]  # q3, k3, v3

t2 = [[[1., 2.],   # q1, k1, v1
       [3., 4.],   # q3, k3, v3
       [2., 3.]]]  # q2, k2, v2

q, k, v = torch.as_tensor(t1), torch.as_tensor(t1), torch.as_tensor(t1)
print("result1: \n", m(q, k, v))

q, k, v = torch.as_tensor(t2), torch.as_tensor(t2), torch.as_tensor(t2)
print("result2: \n", m(q, k, v))