精华内容
下载资源
问答
  • head first python 中文书签版 head first python 中文书签版 head first python 中文书签版 head first python 中文书签版 head first python 中文书签版
  • head first python 中文

    2013-06-21 22:38:50
    head first python 中文 很好的书
  • Python: First Glimpse

    2019-09-22 19:13:44
    Python: First Glimpse 初学Python,做了写笔记,于是分享之。 对C++程序员来说,第一个新颖有趣的地方是什么? for循环 for有什么不一样? for…in遍历sequence的元素 sequence是什么呢? 1....

    Python: First Glimpse

    初学Python,做了写笔记,于是分享之。

    C++程序员来说,第一个新颖有趣的地方是什么?

    for循环




    for有什么不一样?

    forin遍历sequence中的元素




    sequence是什么呢?

    1.        tuple: 圆括号()

    2.        list 方括号[]

    3.        generator相对于没有中括号的list,每次产生一个iterator




    generator是什么?

    使用yield抛出iteratorfunction返回值类型为generator

    1.        在函数中使用yield 用来抛出iterator

    2.        从底层来看,相当于自动化生成了next()函数,并保存对象状态

     

    举例

    l         sum(i*i for i in range(10))

    l         set(word for line in page for word in line.split())

    l         list(data[i] for i in range(len (data)-1,-1,-1))

    l         (i *i for i in a if i >3)

    l         可以理解成:没有中括号的列表

     

    通常yield和外部的for搭配着使用

    举例:

    ¡        def reverse(data):

    ¡            for index in range(len(data)-1,-1,-1):

    ¡                yield data[index]

    ¡        for char in reverse("golf"): print char,

     

     

     

    列表推导式是什么?

    即利用for + sequence来产生列表的一种方法。

    例如:

    [3*x for x in vec if x>3]

     

     

     

    其余的部分呢?

    请查看python绝对简明教程

    http://wiki.woodpecker.org.cn/moin/PyAbsolutelyZipManual

     

     

     

    函数式编程与数据为中心


    函数式编程的最重要的概念是什么呢?

    1.        sequence:体现着数据为中心

    2.        函数

    a)       匿名函数,lambda函数

    b)       函数对象,闭包



    为什么说sequence是重要的概念?

    1.        且看map函数:map(function,sequence,[sequence...])

    2.        再看reduce函数:reducereduce(function,sequence,[init])

    3.        最后看filter函数:filter(function,sequence)

    这里所有的数据都是放在sequence中的,sequence相当于所有数据的通用容器。这也是数据为中心的体现。

    而函数就直接通过mapreducefilter作用在数据上,而弱化具体的控制流。



    与数据为中心相对应的概念是什么?

    以数据为中心关注点在数据(sequence以及操作(函数对象)

    与之对应:

    面向过程的程序设计,关注点在控制流

    面向对象的程序设计,关注微系统实体的建模

     

    以数据为中心,我们就要弱化对控制流的关注。

    控制流以及算法封装在函数对象内部。

     

    这里也插一个题外话,GNU linux的设计思想,在shell层面,也是以数据为中心。

    GNU小工具 ——》 函数对象

    pipe,字符流,文件流 ——》 sequence

    这样具体的算法和控制流,就被封装在GNU似的小工具中。

    数据通过pipe,字符流,文件流,被GNU小工具转换着。

     

     

     

    类型与对象


    万物皆对象 这不是扯么?

    这里的对象其实没有几个,请看下图

    (出处:http://wiki.woodpecker.org.cn/moin/PyTypesAndObjects

    http://www.cafepy.com/article/python_types_and_objects/images/types_map.png


    对象也就(说万物皆对象,是聪明人在忽悠人,逃避问题。)

    1.        type对象(type()函数返回<type 'type'>的对象

    a)       图中第一,二列

    2.        non-type对象(经type()函数返回types对象(例如list的对象)

    a)       图中第三列


     

    图中两种线:

    1.      —— (图中实线)

    a)       由继承关系括号指定

    b)       __bases__查看

    c)        只有类对象才有__bases__属性

    2.      ——实例(图中虚线)

    a)       __metaclass__指定

    b)       __class__查看      

     

     

     

    如果让我来定义一个新的type对象

    class mylist(object):

        __metaclass__ = type

     

     

     

    题外话

    function对象(经type()函数返回<type function'>的对象)

    实际上是一种

    1.        定义了__call__()函数

    2.        通过def简化修改__clas__()函数的过程,直接产生对象一枚

    class myfunction(object):

        def __init__(self, n):

            self.n = n

        def __call__(self, x):

            self.n += x

            return self.n

     

    例子:

    >>> def foo():

                  a=[0]

                  a[0]=datetime.datetime.now()

                  def inner():

                                print a[0]

                  return inner

     

    >>> a=foo()

    >>> b=foo()

    >>> a()

    2010-08-16 00:07:05.033000

    >>> b()

    2010-08-16 00:07:12.983000

    #可见a,b是两个不同对象

     

    >>> type(a)

    <type 'function'>

    >>> type(b)

    <type 'function'>

    #可见a,b都是function的实例

     

     

     

    Mutable vs Imutable

    数字、字符串、tuple类型是不可变类型

    字典与列表是可变类型(Mutable)

     

     

     

    装饰器decorator

    http://www.ibm.com/developerworks/cn/linux/l-cpdecor.html

     

     

    概要

    以函数作为输入,返回另外一个函数

     

    @A

    def B:pass 

    等价于

    def B:pass

    B=A(B)

     

     

    例子1

    from time import time

    #测试运行时间

    def cost_time(func):

        def result(*args,**dic):

           beign=time()

            func(*args,**dic)

            print "cost time : ",time()-beign

    return result

     

    @cost_time

    def show(n):

        for x in range(n):print x


     

    例子2

    def arg_sayer(what):

        def what_sayer(meth):

            def new(self, *args, **kws):

                print what

                return meth(self, *args, **kws)

            return new

        return what_sayer

     

    def FooMaker(word):

        class Foo(object):

            @arg_sayer(word)

            def say(self): pass

        return Foo()

     

    foo1 = FooMaker('this')

    foo2 = FooMaker('that')

    print type(foo1),; foo1.say() 

    # prints: <class '__main__.Foo'> this

    print type(foo2),; foo2.say() 

    # prints: <class '__main__.Foo'> that

     

     

    惯用法

    ¡        通常使用三层的函数来作为decorator

    ¡        这样就可以通过参数来配置装饰器了

    def arg_sayer(what):#返回用what配置的装饰器函数

        def what_sayer(meth):#meth通常是被装饰的函数

            def new(self, *args, **kws):#具体如何装饰meth

                print what

                return meth(self, *args, **kws)

            return new

        return what_sayer

     

    @arg_sayer(word)

    def say(self):pass



    decorator最典型的应用是什么呢?

    AOP

    l         函数参数类型多态

    l         跟踪

    l         日志

    l         存储、缓存

    l         线程锁定

    l         输入输出重定向

    l         认证

    l         权限检查

    l         检查参数

    l         加锁

     

     

     

    python不支持函数的重载,那有什么解决方案呢?

    1.        默认参数

    2.        指定参数

    3.        自省判断参数类型分别处理

    a)       C++重载其实也是对参数类型显式coding

    b)       C++重载把同一个函数写成不同的函数体,有不便理解之处

    c)        C++重载语义暗含在语言中,可读性,不够pythonic



     

    重载例子:优雅

    注意:这里分离了数据处理的代码与重载处理的代码

    def elementwise(fn):#fn可以处理sequenceelement两种类型

        def newfn(arg):

            if hasattr(arg,'__getitem__'):  # is a Sequence

                return type(arg)(map(fn, arg))

            else:

                return fn(arg)

        return newfn

     

    @elementwise

    def compute(x):

        return x**3 - 1

     

    print compute(5)        # prints: 124

    print compute([1,2,3])  # prints: [0, 7, 26]

    print compute((1,2,3))  # prints: (0, 7, 26)

     

     

     

     

    闭包

    secrets_of_javascript_closures.pdf

    http://en.wikipedia.org/wiki/Closure_(computer_science)

     

     

     

    闭包最核心的概念是什么呢?

    函数对象(除此之外,再无它)



    函数对象带来了什么?

    函数的状态!



    Python的函数与C++的函数有什么区别?

    C++中的函数

    1.        永远不变的,唯一实例的(像我们的上帝一样)。

    2.        调用函数就相当于跳转到唯一函数体中。

     

    Python中的函数,每申明一次函数,就会

    1.        产生一个函数对象

    2.        维系这个函数对象的变量环境


     

    函数对象的变量环境有什么用呢?

    这个闭包的精华之处:

    1.        对于同一段函数定义代码,我们产生多个不同的函数对象

    2.        存储改变函数不同对象的变量

    3.      从而让同一个函数的不同对象表现出不同的行为




    这么抽象,举个例子可以么?

    def addgen():

                  y=[0]    #2.7版本中,只支持list类型的函数状态

                  def sety0(yy):

                                y[0]=yy

                  def addy (x):

                                return x+y[0]

                  return sety0,addy




     

    通常用在什么场合呢?

    1.        回调函数

    a)       每次回调,改变其状态。

    b)       调用不同的次数,传入不同的参数,函数表现不同。

    c)        多个回调函数对象,状态互不干涉

    2.        事件响应函数

    a)       每次响应,改变其状态。

    b)       响应不同的次数,传入不同的参数,函数表现不同。

    c)        多个事件响应函数对象,状态互不干涉

     

     

     

     

    与数据为中心的编程的关系呢?

    此时,函数已经具有了对象的两个特征:

    1.        多实例

    2.        有状态

    不过函数依然是函数,依然可以作为mapreducefilter的输入,

    依然可以用作数据为中心的编程。

     

     

     

     

    总结

    以上,是我初学Python遇到的一些难点,分享之,希望各位鸟都来拍砖斧正。

    转载于:https://www.cnblogs.com/hetao/archive/2010/08/16/1800354.html

    展开全文
  • python first

    千次阅读 2018-03-11 00:14:09
    首先我们来安装python1、首先进入网站下载:点击打开链接(或自己输入网址https://www.python.org/downloads/),进入之后如下图,选择图红色圈区域进行下载。2、安装后,安装时记得选上加入环境变量path,否则...

    首先我们来安装python

    1、首先进入网站下载:点击打开链接(或自己输入网址https://www.python.org/downloads/),进入之后如下图,选择图中红色圈中区域进行下载。


    2、安装后,安装时记得选上加入环境变量path,否则需要手动,cmd命令行输入python 出现“>>>"进入python交互模式

    3、可输入简单的逻辑代码;


    展开全文
  • Head First Python 中文PDF扫描版,压缩包无解压密码。
  • Head First Python书籍的源代码。解压即可使用。 很实用,是学习python百部百科推荐的教材的代码。
  • Head First Python涉及的源码,避免了学习时手工录入代码的痛苦。
  • Pythonfirst 和follow 集

    千次阅读 2019-10-20 16:45:32
    FIRST = {} FOLLOW = {} sentences = [ 'E->TG', 'G->+TG', 'G->-TG', 'G->ε', 'T->FS', 'S->*FS', 'S->/FS', ...#初始化 first 集 和follow集合字典的键值对的 值 为空 ...
    
    FIRST = {}
    
    FOLLOW = {}
    
    sentences = [
    'E->TG',
    'G->+TG',
    'G->-TG',
    'G->ε',
    'T->FS',
    'S->*FS',
    'S->/FS',
    'S->ε',
    'F->(E)',
    'F->i',]
    
    #初始化 first 集 和follow集合字典的键值对中的 值 为空
    def initail():
        for str  in sentences :
            part_begin = str.split("->")[0]
            part_end = str.split("->")[1]
            FIRST[part_begin] = ""
            FOLLOW[part_begin] = "#"
    
    
    ###求first集 中第第一部分针对 ->  直接推出第一个字符为终结符 部分
    def getFirst():
        for str in sentences:
            part_begin = str.split("->")[0]
            part_end = str.split("->")[1]
            if not part_end[0].isupper():
                FIRST[part_begin] = FIRST.get(part_begin) + part_end[0]
    
    ##求first第二部分 针对 A -> B型  把B的first集加到A 的first集合中
    def getFirst_2():
        for str in sentences:
            part_begin = ''
            part_end = ''
            part_begin += str.split('->')[0]
            part_end += str.split('->')[1]
            ##如果型如A ->B 则把B的first集加到A 的first集中去
            if part_end[0].isupper():
                FIRST[part_begin] = FIRST.get(part_begin) + FIRST.get(part_end[0])
    
    
    def   getFisrt_3():
        while(1):
            test = FIRST
            getFirst_2()
            ##去除重复项
            for i , j  in FIRST.items():
                temp = ""
                for word in list(set(j)):
                    temp += word
                FIRST[i] = temp
            if test == FIRST:
                break
    
    
    def   getFOLLOW_3():
        while(1):
            test = FOLLOW
            getFollow()
            ##去除重复项
            for i , j  in FOLLOW.items():
                temp = ""
                for word in list(set(j)):
                    temp += word
                FOLLOW[i] = temp
            if test == FOLLOW:
                break
    
    ##计算follow集的第一部分,先计算 S -> A b 类型的
    def getFollow():
        for str in sentences:
            part_begin = str.split("->")[0]
            part_end = str.split("->")[1]
            ##如果是 S->a 直接推出终结符 则 continue
            if len(part_end) == 1:
                continue
            ##否则执行下面的操作
            else:
                #将->后面的分开再倒序
                temp = []
                for i in part_end:
                    temp.append(i)
                temp.reverse()
                #如果非终结符在句型的末端则把"#" 加入进去
                if temp[0].isupper() :
                    FOLLOW[temp[0] ]= FOLLOW.get(temp[0]) + FOLLOW.get(part_begin)
                    temp1 = temp[0]
                    for i in temp[1:]:
                        if not i.isupper():
                            temp1 = i
                        else:
                            if temp1.isupper():
                                FOLLOW[i] = FOLLOW.get(i) + FIRST.get(temp1).replace("ε","")
                            if ('ε' in FIRST.get(temp1)):
                                FOLLOW[i] = FOLLOW.get(i) + FOLLOW.get(part_begin)
                            else:
                                FOLLOW[i] = FOLLOW.get(i) + temp1
                            temp1 = i
                # 如果终结符在句型的末端
                else:
                    temp1 = temp[0]
                    for i in temp[1:]:
                        if not i.isupper():
                            temp1 = i
                        else:
                            if temp1.isupper():
                                FOLLOW[i] = FOLLOW.get(i) + FIRST.get(temp1)
                            else:
                                FOLLOW[i] = FOLLOW.get(i) + temp1
                            temp1 = i
    
    initail()
    getFirst()
    getFisrt_3()
    getFisrt_3()
    #print(  FIRST )
    getFOLLOW_3()
    getFOLLOW_3()
    #print(FOLLOW)
    
    for i ,j in FIRST.items() :
        str = j[0]
        for temp in j[1:]:
            str = str+ ',' +temp
        print("FIRST("+ i + ")" + " = {"+str+"}")
    
    for i ,j in FOLLOW.items():
        str = j[0]
        for temp in j[1:]:
            str = str + ',' + temp
        print("FOLLOW("+ i + ")" + " = {"+str+"}")
    

    在这里插入图片描述

    展开全文
  • python-first1-数据类型

    2019-10-06 03:28:40
    Python 3里,只有一种整数类型 int,表示为长整型,没有 python2 的 Long。 像大多数语言一样,数值类型的赋值和计算都是很直观的。 内置的 type() 函数可以用来查询变量所指的对象类型。 2sets集合类型 3...

    数据类型

    1number数字类型(int  float   long)     

    在Python 3里,只有一种整数类型 int,表示为长整型,没有 python2 中的 Long。

    像大多数语言一样,数值类型的赋值和计算都是很直观的。

    内置的 type() 函数可以用来查询变量所指的对象类型。

    2sets集合类型 

    3string字符串类型 

    4list列表类型

    List(列表) 是 Python 中使用最频繁的数据类型。

    列表可以完成大多数集合类的数据结构实现。它支持字符,数字,字符串甚至可以包含列表(即嵌套)。

    列表用 [ ] 标识,是 python 最通用的复合数据类型。

    列表中值的切割也可以用到变量 [头下标:尾下标] ,就可以截取相应的列表,从左到右索引默认 0 开始,从右到左索引默认 -1 开始,下标可以为空表示取到头或尾。

    5tuple元组类型

    (元组用"()"标识。内部元素用逗号隔开。但是元组不能二次赋值,相当于只读列表。)

    6dictionary字典类型: 

    字典(dictionary)是除列表以外python之中最灵活的内置数据结构类型。

    列表是有序的对象结合,字典是无序的对象集合。

      两者之间的区别在于:字典当中的元素是通过键来存取的,而不是通过偏移存取。

    字典用"{ }"标识。字典由索引(key)和它对应的值value组成。

     

    转载于:https://www.cnblogs.com/leemy11/p/7453400.html

    展开全文
  • firstProject:Python中的算法实践-FIAP毕业课程
  • 第一:您在Python中总是会错过的功能 first是一个MIT许可Python包用一个简单的函数,返回从一个可迭代第一真值,或者None如果没有,则。 如果需要更多功能,还可以提供用于判断元素真值的key函数,或者如果None不...
  • Head First Python

    2018-02-26 13:55:42
    《Head First Python(中文版)》超越枯燥的语法和甩法手册,通过一种独特的方法教你学习这种语言。你会迅速掌握Python的基础知识,然后转向持久存储、异常处理、Web开发、SQLite、数据加工和lGoogle App Engine。你还...
  • python first day

    2014-07-12 10:54:57
    在win访问python的主页下载msi文件安装。 在系统变量的path添加上安装路径即可。   1.python的交互模式 在python的交互模式shell,例如 >>> 1000+2000 3000 >>> _+4000 7000 >>>
  • File "/Library/Frameworks/Python.framework/Versions/3.7/lib/python3.7/site-packages/django/core/management/__init__.py", line 363, in execute_from_command_line utility.execute() File "/Library/...
  • 1、本地环境没有安装Python,或者远程设置也没有; 2、安装的pycharm的版本和你当前Python的版本不匹配也会出现这个问题; 然后在那个设置符号那加上下载好的python3.exe就行了 (一般情况下安装包带的是python...
  • 你想过可以通过一本书就学会Python吗?《Head First Python(中文版)》超越枯燥的语法和甩法手册,通过...·学习Python中有关数据库的API,以及如何在Python中使用各种不同的数据库系统,包括MySQL、Postgres和 SQLite。
  • 介绍了Python的动态存储数据的方法、构建基于Python的Web服务器和Web应用程序、在Android平台上编写移动的应用程序、使用PyGame和PyKyra来开发复杂的游戏、 生成基于GUI的程序与Python的代码库,以及编写Python脚本...
  • Python中 package 的标识,不能删除 定义__all__用来模糊导入 编写 Python 代码(不建议在 init 中写 python 模块,可以在包中在创建另外的模块来写,尽量保证 init.py 简单) _all_的主要作用: Python 中的包和...
  • Head_First_Python(中文影印版),很清晰。Head_First系列丛书语句通俗易懂。
  • my_first_projects:我在python中的第一个项目
  • 《Head First Python(中文版)》超越枯燥的语法和甩法手册,通过一种独特的方法教你学习这种语言。你会迅速掌握Python的基础知识,然后转向持久存储、异常处理、Web开发、SQLite、数据加工和lGoogle App Engine。你还...
  • 最近在看head first python,前面也写了一些笔记,但是基本上没有涉及到一些完整的代码,现在将书的文件相关操作的代码整理,供以后参考。 主要分为两大部分,读取文件、处理异常,处理文件、存储文件。 0,处理...
  • 作业调度最短的剩余时间作业第一个python代码 操作系统使用的最短保留时间优先代码的调度算法的Python代码。 这是在抢先式操作系统称为最短作业优先的操作系统使用的算法。 该代码是python语言。
  • Head First Pyhton中文版本, python3,“重视大脑的学习”
  • head_first_python(中文)

    2019-03-16 23:09:06
    这个系列的书就不用太多介绍了,简单易懂,中文版。提供给大家下载。
  • Head-First-Python-2:书的练习
  • Python First Week(二)

    2019-11-19 13:17:49
    Python First Week(二) 新的一天的学习时光又开始啦~ 今天大部分都在猜数字Game,噗~ getpass 可惜这个getpass不能应用于劈叉! #getpass在pycharm无法使用,只能在终端窗口运行 import getpass username=...
  • 你的算法应该满足O(n)时间和常数空间复杂度解题思路参考:http://bookshadow.com/weblog/2015/09/14/leetcode-first-missing-positive/尽可能地把数组不大于n(n为数组长度)的正整数放置到下标+1与其数值相同的...

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 2,757
精华内容 1,102
关键字:

python中first

python 订阅