精华内容
下载资源
问答
  • Python UDP chatroom DEMO

    2018-06-21 16:51:53
    复旦大学 计算机科学技术学院 本科生课程 计算机网络 课程Lab 使用Python写一个基于UDP聊天室 注意: 此代码此Lab_不完全实现_。你需要自己进行修改,以适应实验指导中要求。需要补充代码为服务端指令...
  • <div><p>edb-X555LI:~/Judger/demo$ sudo python demo.py Traceback (most recent call last): File "demo.py", line 26, in gid=0) ValueError: dlopen error</p><p>该提问来源于开源项目:...
  • 大部分人会问问周围朋友,看看他们最近有什么好看电影可以推荐给自己,而我们一般会倾向于从口味比较类似朋友那里得到推荐信息。这就是协同过滤核心思想。 要实现协同过滤,需要一下几个步骤: 收集用户便...

    概述

    协同过滤(collaborative filtering)是推荐算法里面最经典也是最常用的。
    该算法通过分析用户的兴趣,在用户群中找到指定用户的相似用户,综合这些相似用户对某一信息的评价,形成系统对该指定用户的喜好程度预测。
    比如,你现在想看一部电影,但是不知道具体看哪一部,你会怎么做?大部分人会问问周围的朋友,看看他们最近有什么好看的电影可以推荐给自己,而我们一般会倾向于从口味比较类似的朋友那里得到推荐信息。这就是协同过滤的核心思想。
    要实现协同过滤,需要一下几个步骤:

    1. 收集用户便好
    2. 找到相似的用户或物品
    3. 计算并推荐

    评分

    从用户的行为和便好中发现规律,并基于此进行推荐。所以,收集用户便好信息成为系统推荐效果最基础的决定因素。用户有很多种方式向系统提供自己的信息便好,比如评分、投票、转发、保存书签、购买、点击、页面停留时间等
    以上行为是通用的,在实际推荐引擎设计中自己可以多添加一些特定的用户行为,并用他们表示对物品的喜好程度。通常情况下,在一个推荐系统中,用户行为都会多于一个。那么。如何组合这些不同的行为呢?
    基本上有两种方式,如下:

    • 1.将不同的行为分组
      一般可以分为查看和购买,然后基于不同的用户行为,计算不同用户或物品的相似度。类似当当网或者亚马逊给出的“购买了该书的人还购买了”“查看了该书的人还看了”等
    • 2.对不同行为进行加权
      对不同行为产生的用户喜好程度进行加权,然后求出用户对物品的总体喜好程度。在我们收集好用户的行为数据后,还要对数据进行预处理,最核心的就是减噪和归一化。
      • 减噪:因为用户数据在使用过程中可能出现大量的噪声和误操作,所以需要过滤掉这些噪声
      • 归一化:不同的行为数据差别较大,比如,用户的查看数据肯定比购买数据大的多,所以需要通过归一化,数据才能更加准确

    相似度

    在对用户的行为进程分析得到用户的便好后,可以根据用户的便好计算相似用户或相似物品,然后可以根据相似用户和相似物品进行推荐。这就是协同过滤的两个分支,即基于用户的协同过滤和基于物品的协同过滤。
    关于相似度的计算,现在有的几种算法都是基于向量的,其实就是计算向量的距离,距离越近,说明相似度值越大,在推荐系统中,用户-物品便好的二维矩阵中,我们可以将一个用户对所有物品的便好作为一个向量来计算用户之间的相似度,或者将所有用户对某个物品的便好作为一个向量来计算物品之间的相似度
    几种常见的相似度计算方法:

    1. 同现相似度
      物品A和物品B的同现相似度定义如下:
      WA,B=N(A)N(B)N(A)W_{A,B}=\frac{|N(A)\bigcap N(B)|}{|N(A)|}
      N(A)是喜欢A的用户数,N(A)N(B)|N(A)\bigcap N(B)|是同时喜欢A和B的用户数,即上式表示喜欢A的用户中有多少比例也喜欢物品B。
      上式存在一个问题,如果B是热门物品,那么WA,BW_{A,B}就会很大,接近1.因此该公式造成任何物品与热门物品的相似度都很大。为了避免避免推荐热门物品,可以采取下面的公式。
      WA,B=N(A)N(B)N(A)N(B)W_{A,B}=\frac{|N(A)\bigcap N(B)|}{|N(A)||N(B)|}
      上式对物品B的权重进行了惩罚,减小了热门物品与很多物品相似的可能性.

    2. 欧几里得距离
      该距离最初用于计算两点的距离,假设x,yx,y是二维空间的两个点,他们之间的欧几里得距离如下:
      d(x,y)=(xiyi)nd(x,y)=\sqrt{\sum(x_i-y_i)^n}
      当n等于2时,欧几里得距离就是平面上两个点的距离
      当用欧几里得表示相似度时,一般采用下面公式进行转换
      sim(x,y)=11+d(x,y)sim(x,y)=\frac{1}{1+d(x,y)}
      距离越小,相似度越大

    3. 余弦相似度
      余弦相似度是文本相似度度量中使用比较多的一种方法,对于两个向量X和Y,其对应的形式如下
      X=(x1,x2,,xn)RnX=(x_1,x_2,……,x_n)\in R^n
      Y=(y1,y2,,yn)RnY=(y_1,y_2,……,y_n)\in R^n
      对应的余弦相似度为
      CosSim(X,Y)=ixiyi(ixi2)(iyi2)CosSim(X,Y)=\frac{\sum_ix_iy_i}{\sqrt{(\sum_ix_i^2)}\sqrt{(\sum_iy_i^2)}}

    4. 皮尔逊相关系数
      皮尔逊相关系数一般用于计算两个定居变量间联系的紧密程度,取值范围为[1,1][-1,1]
      p(x,y)=xiyinxy(n1)SxSy=nxiyixiyinxi2(xi)2nyi2(yi)2p(x,y)=\frac{\sum x_iy_i-n\overline{xy}}{(n-1)S_xS_y}=\frac{n\sum x_iy_i-\sum x_i\sum y_i}{\sqrt{n\sum x_i^2-{(\sum x_i)^2}}\sqrt{n\sum y_i^2-{(\sum y_i)^2}}}
      Sx,SyS_x,S_y是x和y的样本标准差

    5. Cosine相似度
      Cosine相似度一般用于计算文档数据的相似度
      C(x,y)=x,yx2y2=xiyixi2yi2C(x,y)=\frac{x,y}{||x||^2||y||^2}=\frac{\sum x_iy_i}{\sqrt{\sum x_i^2}\sqrt{\sum y_i^2}}

    6. Tanimoto系数
      Tanimoto系数也被称为Jaccard系数,Cosine相似度的扩展,一般用于计算文档数据的相似度
      T(x,y)=x,yx2+y2xy=xiyixi2+yi2xiyiT(x,y)=\frac{x,y}{||x||^2+||y||^2-x·y}=\frac{\sum x_iy_i}{\sqrt{\sum x_i^2}+\sqrt{\sum y_i^2}-\sum x_iy_i}
      在计算用户相似度时,是将一个用户对所有物品的便好作为一个向量,而在计算物品相似度时,是将所有用户对某个物品的便好作为一个向量。求出相似度后,接下来可以计算相邻用户和相邻物品。

    推荐计算

    1、 基于用户的协同过滤(UserCF)

    基于用户协同过滤的思想很简单,基于用户对物品的便好,找到相邻的用户,然后将相邻用户喜欢的物品推荐给当前用户。在计算时,就是将一个用户对所有物品的便好作为一个向量来计算用户之间的相似度,找到K个相邻用户后,根据相邻用户的相似度权重以及他们对物品的偏好,预测当前用户喜欢的物品,计算得到一个排序的物品列表进行推荐。

    如下表给出的例子

    物品/用户 物品A 物品B 物品C 物品D
    用户A 推荐
    用户B
    用户C

    对于用户A,根据历史偏好,这里只计算一个邻居得到–用户C,然后可以将C喜欢的物品D推荐给A

    2、基于物品的协同过滤(ItemCF)

    基于物品的协同过滤原理与基于用户的协同过滤原理类似,只是在计算邻居时采用物品本身(而不是从用户角度),基于用户对物品的偏好找到相似的物品,然后根据用户的历史偏好推荐相似的物品从计算的角度看,就是将所有用户对某个物品的偏好作为一个相量,来计算物品之间的相似度,得到某物品的相似度后,如根据用户的历史偏好预测当前用户还没有表示偏好的物品,则计算得到一个排序的物品列表推荐。如下表

    物品/用户 物品A 物品B 物品C
    用户A
    用户B
    用户C 推荐

    对于物品A,根据用户偏好–喜欢物品A的用户都喜欢C,得出物品A和物品C比较相似,而用户C喜欢物品A,纳闷可以推断用户C可能也喜欢物品C

    协同过滤算法实现

    简单演示

    • 相似度计算
      先定义一个余弦相似度计算的函数
    def cos_sim(x,y):
        '''
        余弦相似性
        input:  x(mat):以行向量的形式存储,可以是用户或者商品
                y(mat):以行向量的形式存储,可以是用户或者商品
        output: x和y之间的余弦相似度
        '''
        numerator=np.dot(x,y.T)#x和y之间的内机
        denominator = np.sqrt(np.dot(x,x.T))*np.sqrt(np.dot(y,y.T))
        return (numerator/denominator)
    

    接下来再定义一个计算相似度矩阵的函数

    def similarity(data):
        '''
        计算矩阵中任意两行之间的相似度
        input:  data(mat):任意矩阵
        output: w(mat):任意两行之间的相似度
        '''
        m = np.shape(data)[0]#用户的数量
        #初始化相似度矩阵
        w = np.mat(np.zeros((m,m)))
        for i in range(m):
            for j in range(i,m):
                if i!=j:
                    #计算任意两行之间的相似度
                    w[i,j] = cos_sim(data[i,],data[j,])
                    w[j,i] = w[i,j]
                else:
                    w[i,j]=0#约定自身的相似度为0
        return w
    
    

    简单定义一个数据

    User\Item I_1 I_2 I_3 I_4 I_5
    U_1 4 3 - 5 -
    U_2 5 - 4 4 -
    U_3 4 - 5 - 3
    U_4 2 3 - 1 -
    U_5 - 4 2 - 5

    计算用户相似度

    similarity(A)
    
    matrix([[0.        , 0.74926865, 0.32      , 0.83152184, 0.25298221],
            [0.74926865, 0.        , 0.74926865, 0.49559463, 0.1579597 ],
            [0.32      , 0.74926865, 0.        , 0.30237158, 0.52704628],
            [0.83152184, 0.49559463, 0.30237158, 0.        , 0.47809144],
            [0.25298221, 0.1579597 , 0.52704628, 0.47809144, 0.        ]])
    
    • 基于用户的协同过滤

    计算完用户之间的相似度后,利用用户之间的相似度为用户中没有打分的商品打分,具体计算方法为:
    p(u,i)=vN(i)wu,vrv,ip(u,i)=\sum_{v\in N(i)}w_{u,v}r_{v,i}
    其中,N(i)表示对商品i打过分的用户集合,比如上表中,对与User1,商品D_3没有打分,要想计算商品D_3的分数。对商品D_3打过分的用户有User2、User3、User5。wu,vw_{u,v}表示用户u和用户v 之间的相似度,rv,ir_{v,i}表示用户v对商品i的打分。
    具体计算的代码如下:

    def user_base_recommend(data,w,user):
        '''
         基于用户相似性为用户user推荐商品
         input:  data(mat):用户商品矩阵
                w(mat):用户之间的相似度
                user(int):用户的编号
         output: predict(list):推荐列表
        '''
        m,n=np.shape(data)
        interaction = data[user,]#用户user与商品信息
        #先找到用户user没有打过分的商品
        not_inter = []
        for i in range(n):#n商品数量
            if interaction[i]==0:#没有打分的商品
                not_inter.append(i)
        #print(not_inter)
        #对没有打分的商品进行预测
        predict={}
        for x in not_inter:
            item = np.copy(data[:,x])#找到所有用户对商品x的打分信息
            for i in range(m):#对所有的用户
                if item[i] != 0:#如果用户对商品x打过分
                    if x not in predict:
                        predict[x]=w[user,i]*item[i]
                        
                    else:
                        predict[x] = predict[x]+w[user,i]*item[i]
                        
            #按照预测的大小排序
        return sorted(predict.items(),key=lambda d:d[1],reverse=True)
                
    

    实际带入计算

    user_base_recommend(A,w,0)
    [(2, 5.10303902268836), (4, 2.2249110640673515)]
    

    推荐TOP-N

    def top_k(predict,k):
        '''为用户推荐前k个商品
        input:  predict(list):排好序的商品列表
                k(int):推荐的商品个数
        output: top_recom(list):top_k个商品
        '''
        top_recom=[]
        len_r = len(predict)#计算有多少待推荐商品
        if k>=len_r:#如果需要推荐的个数大于待推荐的数量,直接输出
            top_recom=predict
        else:
            for i in range(k):
                top_recom.append(predict[i])
                
        return top_recom
    

    打印下结果

    k=2
    result=top_k(user_base_recommend(A,w,0),k)
    for i in range(k):
        print("给User_0推荐的商品有:商品%d,打分为%.3f"%(result[i][0],result[i][1]))
        
    给User_0推荐的商品有:商品2,打分为5.103
    给User_0推荐的商品有:商品4,打分为2.225    
    
    • 基于商品的协同过滤

    首先要计算Item之间的相似度,还是套用上面的similarity函数,前提是先把矩阵进行转置。
    之后利用商品之间的相似度为用户没有打分的商品计算得分,计算方法:
    p(u,i)=jI(u)wi,jrj,up(u,i)=\sum_{j\in I(u)}w_{i,j}r_{j,u}
    I(u)I(u)表示用户u打过分的商品集合,比如在表中,用户User1打过分的商品有商品D_1,商品D_2,商品D_4,wi,jw_{i,j}表示商品i和商品j之间的相似度,rj,ur_{j,u}表示用户u对商品j的打分。
    原理与基于用户是相同的

    Item_base_recommend(B,similarity(B),0)
    [(2, 5.507604598998138), (4, 2.8186967825714824)]
    

    完整代码:https://github.com/Andyszl/Recommendation_algorithm/blob/master/collaborative-filtering_demo.ipynb

    展开全文
  • python demo2练习

    2020-09-22 22:24:02
    “”" @author yk-ddm 杨侃 ...以此类推, 后面每个格子里的米都前一个格子里的2 倍, 一直把64 个格子都放满。需要多少粒米呢? 要求使用列表推导式和内置函数进行计算。 “”" result = sum([2 ** i for i in ran

    “”"
    @author yk-ddm 杨侃
    @function 阿凡提与国王比赛下棋,国王说要是自己输了的话阿凡提想要什么他都可以拿得出来。
    阿凡提说那就要点米吧, 棋盘一共64 个小格子, 在第一个格子里放1 粒米,第二个格子里放2 粒米,
    第三个格子里放4 粒米, 第四个格子里放8 粒米,
    以此类推, 后面每个格子里的米都是前一个格子里的2 倍,
    一直把64 个格子都放满。需要多少粒米呢?
    要求使用列表推导式和内置函数进行计算。
    “”"
    result = sum([2 ** i for i in range(64)])
    print(result)

    展开全文
  • 我希望能用一个最平易近人例子, 把 Python 协程中 async/await 概念讲清楚, 希望能够帮助大家有一个形象化认识。 注: 所有讲解都在代码注释. from time import sleep, time def demo1(): """ 假设...

    前言

    我希望能用一个最平易近人的例子, 把 Python 协程中的 async/await 概念讲清楚, 希望能够帮助大家有一个形象化的认识。

    注: 所有的讲解都在代码的注释里.

    from time import sleep, time
    
    
    def demo1():
        """
        假设我们有三台洗衣机, 现在有三批衣服需要分别放到这三台洗衣机里面洗.
        """
        
        def washing1():
            sleep(3)  # 第一台洗衣机, 需要洗3秒才能洗完 (只是打个比方)
            print('washer1 finished')  # 洗完的时候, 洗衣机会响一下, 告诉我们洗完了
        
        def washing2():
            sleep(2)
            print('washer2 finished')
        
        def washing3():
            sleep(5)
            print('washer3 finished')
        
        washing1()
        washing2()
        washing3()
        
        """
        这个还是很容易理解的, 运行 demo1(), 那么需要10秒钟才能把全部衣服洗完.
        没错, 大部分时间都花在挨个地等洗衣机上了.
        """
    
    
    def demo2():
        """
        现在我们想要避免无谓的等待, 为了提高效率, 我们将使用 async.
        washing1/2/3() 本是 "普通函数", 现在我们用 async 把它们升级为 "异步函数".
        
        注: 一个异步的函数, 有个更标准的称呼, 我们叫它 "协程" (coroutine).
        """
        
        async def washing1():
            sleep(3)
            print('washer1 finished')
        
        async def washing2():
            sleep(2)
            print('washer2 finished')
        
        async def washing3():
            sleep(5)
            print('washer3 finished')
        
        washing1()
        washing2()
        washing3()
        
        """
        从正常人的理解来看, 我们现在有了异步函数, 但是却忘了定义应该什么时候 "离开" 一台洗衣
        机, 去看看另一个... 这就会导致, 现在的情况是我们一边看着第一台洗衣机, 一边着急地想着
        "是不是该去开第二台洗衣机了呢?" 但又不敢去 (只是打个比方), 最终还是花了10秒的时间才
        把衣服洗完.
        
        PS: 其实 demo2() 是无法运行的, Python 会直接警告你:
            RuntimeWarning: coroutine 'demo2.<locals>.washing1' was never awaited
            RuntimeWarning: coroutine 'demo2.<locals>.washing2' was never awaited
            RuntimeWarning: coroutine 'demo2.<locals>.washing3' was never awaited
        """
    
    
    def demo3():
        """
        现在我们吸取了上次的教训, 告诉自己洗衣服的过程是 "可等待的" (awaitable), 在它开始洗衣服
        的时候, 我们可以去弄别的机器.
        """
        
        async def washing1():
            await sleep(3)  # 注意这里加入了 await
            print('washer1 finished')
        
        async def washing2():
            await sleep(2)
            print('washer2 finished')
        
        async def washing3():
            await sleep(5)
            print('washer3 finished')
        
        washing1()
        washing2()
        washing3()
        
        """
        尝试运行一下, 我们会发现还是会报错 (报错内容和 demo2 一样). 这里我说一下原因, 以及在
        demo4 中会给出一个最终答案:
            1. 第一个问题是, await 后面必须跟一个 awaitable 类型或者具有 __await__ 属性的
            对象. 这个 awaitable, 并不是我们认为 sleep() 是 awaitable 就可以 await 了,
            常见的 awaitable 对象应该是:
                await asyncio.sleep(3)  # asyncio 库的 sleep() 机制与 time.sleep() 不
                # 同, 前者是 "假性睡眠", 后者是会导致线程阻塞的 "真性睡眠"
                await an_async_function()  # 一个异步的函数, 也是可等待的对象
            以下是不可等待的:
                await time.sleep(3)
                x = await 'hello'  # <class 'str'> doesn't define '__await__'
                x = await 3 + 2  # <class 'int'> dosen't define '__await__'
                x = await None  # ...
                x = await a_sync_function()  # 普通的函数, 是不可等待的
                
            2. 第二个问题是, 如果我们要执行异步函数, 不能用这样的调用方法:
                washing1()
                washing2()
                washing3()
            而应该用 asyncio 库中的事件循环机制来启动 (具体见 demo4 讲解).
        """
    
    
    def demo4():
        """
        这是最终我们想要的实现.
        """
        import asyncio  # 引入 asyncio 库
        
        async def washing1():
            await asyncio.sleep(3)  # 使用 asyncio.sleep(), 它返回的是一个可等待的对象
            print('washer1 finished')
        
        async def washing2():
            await asyncio.sleep(2)
            print('washer2 finished')
        
        async def washing3():
            await asyncio.sleep(5)
            print('washer3 finished')
        
        """
        事件循环机制分为以下几步骤:
            1. 创建一个事件循环
            2. 将异步函数加入事件队列
            3. 执行事件队列, 直到最晚的一个事件被处理完毕后结束
            4. 最后建议用 close() 方法关闭事件循环, 以彻底清理 loop 对象防止误用
        """
        # 1. 创建一个事件循环
        loop = asyncio.get_event_loop()
        
        # 2. 将异步函数加入事件队列
        tasks = [
            washing1(),
            washing2(),
            washing3(),
        ]
        
        # 3. 执行事件队列, 直到最晚的一个事件被处理完毕后结束
        loop.run_until_complete(asyncio.wait(tasks))
        """
        PS: 如果不满意想要 "多洗几遍", 可以多写几句:
            loop.run_until_complete(asyncio.wait(tasks))
            loop.run_until_complete(asyncio.wait(tasks))
            loop.run_until_complete(asyncio.wait(tasks))
            ...
        """
        
        # 4. 如果不再使用 loop, 建议养成良好关闭的习惯
        # (有点类似于文件读写结束时的 close() 操作)
        loop.close()
        
        """
        最终的打印效果:
            washer2 finished
            washer1 finished
            washer3 finished
            elapsed time = 5.126561641693115
            	(毕竟切换线程也要有点耗时的)
            
        说句题外话, 我看有的博主的加入事件队列是这样写的:
            tasks = [
                loop.create_task(washing1()),
                loop.create_task(washing2()),
                loop.create_task(washing3()),
            ]
            运行的效果是一样的, 暂不清楚为什么他们这样做.
        """
    
    
    if __name__ == '__main__':
        # 为验证是否真的缩短了时间, 我们计个时
        start = time()
        
        # demo1()  # 需花费10秒
        # demo2()  # 会报错: RuntimeWarning: coroutine ... was never awaited
        # demo3()  # 会报错: RuntimeWarning: coroutine ... was never awaited
        demo4()  # 需花费5秒多一点点
        
        end = time()
        print('elapsed time = ' + str(end - start))
    
    
    
    展开全文
  • 烦人环境终于ok了,改了改文本,换了换图片资源,还是能在手机运行。ok,关了Eclipse,去vs中看看吧。 虽然根老骨头了,但还真没怎么用C++,以前接触过点Java开发框架,估计大差不差。 在VS2012中打开用...

    烦人的环境终于ok了,改了改文本,换了换图片资源,还是能在手机里运行。ok,关了Eclipse,去vs中看看吧。

    虽然是根老骨头了,但还真没怎么用C++,以前接触过点Java的开发框架,估计大差不差。


    在VS2012中打开用python命令新建的LazyGame项目。

    --------------------

    LazyGame

    -Classes

    -AppDelegate.cpp

    -AppDelegate.h

    -HelloWorldScene.cpp

    -HelloWorldScene.h

    -win32

    -main.cpp

    -main.h

    外部依赖类

    -------------------

    main.cpp应该是入口类

    里面定义了窗口的标题eglView->setViewName("LazyGame");

    和窗口的大小eglView->setFrameSize(960, 540);

    还有AppDelegate的句柄,这个类应该是Cocos2dx主要的控制类。


    AppDelegate.cpp主要控制类

    里面有三个方法:

    applicationDidFinishLaunching();初始化方法,比如Scene的初始化

    applicationDidEnterBackground();游戏临时中断的处理

    applicationWillEnterForeground();由中断状态再次进入游戏的处理

    相关方法:

    CCDirector* pDirector = CCDirector::sharedDirector();初始化导演类

    pDirector->setDisplayStats(true);显示FPS

    pDirector->setAnimationInterval(1.0 / 60);设置刷新率

    CCScene *pScene = HelloWorld::scene();初始化舞台

    pDirector->runWithScene(pScene);显示当前舞台


    再来看下HelloWorldScene.cpp

    有scene添加方法、初始化方法、还有按钮回调事件

    我感觉HelloWorld应该是一个层,而非舞台。

    scene->addChild(layer);加入到舞台中

    初始化init()中:

    首先调用父类的init

    CCDirector::sharedDirector()->getVisibleSize();可视区域大小

    CCDirector::sharedDirector()->getVisibleOrigin();可视区域原点坐标

    创建一个图片按钮:参数(常态图,按下图,句柄,回调方法)

    CCMenuItemImage *pCloseItem = CCMenuItemImage::create(
    "CloseNormal.png",
    "CloseSelected.png",
    this,
    menu_selector(HelloWorld::menuCloseCallback));

    //然后应该是设置位置了

    pCloseItem->setPosition(ccp(origin.x + visibleSize.width - pCloseItem->getContentSize().width/2 ,
    origin.y + pCloseItem->getContentSize().height/2));

    看来cocos2dx设置控件时的坐标,是以左下角为原点,并且设置的是item中心点的位置。所以要减去item的宽高。

    然后把创建的item加到一个Menu里,

    CCMenu* pMenu = CCMenu::create(pCloseItem, NULL);

    pMenu->setPosition(CCPointZero);然后设置(0,0)点。
    this->addChild(pMenu, 1);最后添加到舞台中。

    同样的方法加入一个label,同样是创建,设位置,添加

    CCLabelTTF* pLabel = CCLabelTTF::create("LazyGame", "Arial", 24);

    同样的,再加入一个精灵CCSprie

    CCSprite* pSprite = CCSprite::create("HelloWorld.png");

    最后是创建按钮MenuItem时,加入的回调方法

    void HelloWorld::menuCloseCallback(CCObject* pSender)
    CCDirector::sharedDirector()->end();


    一个最最原始的Demo就这些东西。骨头还有很多问题没弄明白,和C++还有框架相关的,没关系,一点点来。



    常用的快捷键:

    Tab 快速完成

    Shift + Alt + Enter 全屏

    Ctrl + K,Ctrl+D 格式化代码





    展开全文
  • 烦人环境终于ok了,改了改文本,换了换图片资源,还是能在手机运行。ok,关了Eclipse,去vs中看看吧。 虽然根老骨头了,但还真没怎么用C++,以前接触过点Java开发框架,估计大差不差。 在VS2012中打开用...
  • 还有报错这么说: ``` Traceback (most recent call last): File "E:\java4412\spider_demo\book_spider\main.py", line 21, in None ip_html = n._get_html(ip_html) File "E:\java4412\spider_...
  • 最近在写接口的时候,遇到了需要使用RSA加密和PBE加密的情况,对方公司提供的DEMOJAVA的,我需要用python来实现。在网上搜了一下,python的RSA加密这块写的还是比较多的,但是PBE较少。所以我就讲讲我在RSA加密...
  • 宁德时代、广东电网电科院、机科院等等巨头都在用AI算法开发神器...下面就让我们详细看看这个在短短几个月时间,两次登上Github Daily全球趋势榜,迅速获得1.1k Star项目,它到底有什么过人之处呢? ...
  • 第一次遇到这个问题,真的一脸懵逼,把所有步骤的数据打印查看到底问题出在哪里,结果发现所有地方的数据都按照预想的流程运行的,问题出在了list.append(dict),追加了之后发现列表里的每项数据都一样了。...
  • Python 闭包

    2019-07-30 19:12:48
    内部函数对外部函数作用域里的变量的引用 函数内的属性,都有生命周期,都在函数执行期间 闭包内的闭包函数私有化了变量,完成了数据封装,类似面向对象 demo: def foo(): print('in foo()') def bar(): ....
  • 官网两个demo 桑基图绘制项目实战 在开始之前,我们先来看看通过本文制作最终效果图: 什么是桑基图? 桑基图(桑葚图),也叫桑基能量分流图或者桑基能量平衡图,里面桑基其实一个人名,全名...
  • Python—闭包

    2019-07-30 19:13:47
    内部函数对外部函数作用域里的变量的引用 函数内的属性,都有生命周期,都在函数执行期间 闭包内的闭包函数私有化了变量,完成了数据的封装,类似面向对象 demo: def foo(): print('in foo()') def bar...
  • 上传图片二进制数据到七牛云上面不难, 照着七牛云API文档基本就能行,有一点很坑,七牛云官方文档Python API 贼鸡儿坑,上面的Demo,上传本地图片的put_file()方法,我要上传远程服务器上
  • 本文所有的demo,都浏览器下展示的 同步发布在博客</a></p> <p><a href="https://github.com/shengxinjing/my_blog/tree/master/log_visual">项目地址,跪求右上角star :star: :star2: :stars: 基于...
  • 是什么? Acra示例应用程序说明了将集成到现有应用程序中过程。 保护数据对于用户而言是完全透明,并且只需要对基础结构进行最小更改。 这个集合有几个示例应用程序。 每个文件夹都包含docker-compose文件...
  • Python导模块问题

    2019-04-01 18:24:00
    我们在import一个模块时候,有没有想过如果我重复import会怎么样?导入时都做了些什么?让我们来看看 1.首先我们新建一个demo,py,...实际上它这样: 1.先从sys.modules去查看是否已经导入了,如果没就...
  • 赵雷到底在唱什么,纯粹自己兴趣引导自己学习爬虫,关注应该有好多对爬虫感兴趣小伙伴,为了巩固自己爬虫知识,从今天开始更新python爬虫这个基础教程,自己准备了挺长时间整理了自己学习笔记,希望能给...
  • Python 3基础教程47-Matplotlib显示图例

    千次阅读 2017-05-10 17:04:58
    举例,我们在地铁看到了,北京这么多条地铁线路图,那个图一般右上角或者其他地方,会显示,哪号线什么颜色,叫几号线,这种在绘图就叫图例。 1. 新建一个demo.py文件,敲以下Python代码。 # 演示如何增加图例...
  • 这里问题是猜出电脑存储数字是什么。你将要编写一个能够随机生成一个0到100之间且包括0和100数字程序。这个程序提示用户连续地输入数字直到它与那个随机生成数字相同。对于每个用户输入数字,程序会...
  • daipe-demo-databricks-源码

    2021-04-01 21:59:55
    任何具有python基本技能人都可以创建管道并改善业务逻辑, 开发标准DataLake项目几乎不需要工程师, 适用于所有环境代码(您最喜欢IDE + Databricks UI), 随着项目发展追求一致性。 每个人都将使用...
  • 这里问题是猜出电脑存储数字是什么。你将要编写-一个能够随机生成一个0到 100之间且包括0和100数字程序。这个程序提示用户连续地输入数字直到它与那个随 机生成数字相同。对于每个用户输人数字,程序...
  • 这句话是什么意思呢? 就是你不能只掌握数量很少方法、工具。 否则你认知会被自己能力框住。不只是存在盲点,而是存在“盲维”。 你会尝试用不合适方法解决问题(还自诩“一招鲜,吃遍天”),却对原本合适...
  • <div><p>python3 ./demo.py ./cfg/...cfg/里面不同配置文件区别是什么,和weight文件有对应关系吗?需要配套使用吗?</p><p>该提问来源于开源项目:Tianxiaomo/pytorch-YOLOv4</p></div>

空空如也

空空如也

1 2 3 4 5 6
收藏数 111
精华内容 44
关键字:

python里的demo是什么

python 订阅