• ·概要: 我也忘记最开始为什么学习Python了。后来就是学习了基础语法,而库就没有学--主要是还没找到要需要Python的地方。 在Python中的核心概念是:一切都是对象,对象都有名字(很OO啊)。 同时Python的一大特色...

     

    ·概要:

        我也忘记最开始为什么学习Python了。后来就是学习了基础语法,而库就没有学--主要是还没找到要需要Python的地方。

        在Python中的核心概念是:一切都是对象,对象都有名字(很OO啊)。

        同时Python的一大特色就是用空格控制程序块;

     

    ·要点:

    基础类型:

        Python是动态语言,不需要像C++/Java等要先声明类型。

    --整型:

        所看到的1,3等数字就是整型--内部表示为整数对象所以有相关方法。

    --浮点型:

        Python对浮点型的支持还存在跟Java(我学的时候的Java)一样的精度问题。

        比较来说,Python给我的感觉不适合处理数字。

    --None类型:

        这是一种概念常量,多用于函数返回类型和判断式。

    --逻辑表达式:

        首先需要说明的是Python中没有boolean类型;

        对于逻辑假的集合为:None,0,0.0(浮点数),""(空串),()(空元组),[],{}

        替代三元运算符(?:)的是:<cond> and <expr_true> or <expr_false>

     

    数据结构:

        需要提醒的是这些数据结构都是对象,也拥有各种方法来处理不同情况。

    --字符串(string,不可变):

        定义形式有单引号('str')、双引号("str")和三引号('''str'''或"""str""")形式。

        对于单引号和双引号还可以通过符号(\)进行多行定义;

        三引号具有原文呈现的特性,可以作为多行注释使用;

        支持转移字符和格式化输出。

        支持字符串连接操作符("david"+'yang')

        类型转换:float(str),int(str),int(str,base),long(str),long(str,base);

    --元组(tuple,常量list不支持pop/remove/insert等方法):

        定义方式为:a=(1,2,3,4)形式--括号可省略,单元素元组为(1,)形式;

        可通过下标操作符返回元素或子元组(切片操作)。

        可用于多变量的赋值操作;

        性能比list好--不提供动态内存管理的功能;

        使用的地方:可变参数、格式化输出和继承结构;

    --列表(list):

        类似于C++中的Vector和C中的数组--顺序存储结构;

        用操作符[]定义,支持扩展的下标操作符--索引从0开始且支持负索引;

        支持切片操作--采用[start[:end[:step]]];

        支持列表推导式:[<expr1> for k in L if<expr2>];

        函数range([start,]stop[,step])可生成一个list;

    --序列(sequence):

        一种概念结构,包括string,list和tuple。

        支持的操作:in判断,len函数,下标操作,切片操作,+连接,*重复和列表推导式;

    --字典(dictionary):

        用{}定义,是一种无需存储结构,每个元素都是一个pair--两个元素的tuple;

        其中key类型:integer或stirng或任何含有__hash__和__cmp__方法的对象;

        要求是没重复的key,而value的类型随意;

        支持下标操作符;

        可通过函数dict(list)构造字典—list是一个元素为tuple的list。

     

    程序流程:

        整体结构跟C++中流程控制很像,不过没有switch,而且曾加了可选的else;

    --分支结构if:

        if<expr1>:

            <statement-block>

        elif<expr2>:

            <statement-block>

        else:

            <statement-block>

    --循环while:

        while<expr1>:

            <statement-block>

        else:

            <statement-block>

    --循环for:

        for x in <range>:

            <statement-block>

        else:

            <statement-block>

    --流程控制continue/break:

        continue跳过一次循环;break则跳出当前循环;

     

    函数:

        函数是一段可重复使用的代码。

        函数也是对象,可以把函数赋值给另一个变量;

        定义方式:def <function_name>(<parameters_list>):

                           <code_block>

        返回指使用return语句;

    --默认参数/可变参数:

        跟C++一样,可使用默认参数并遵守默认参数都放在最右侧;

        在调用多默认参数函数时可通过赋值参数方法来改变参数顺序和个数;

        可变参数有两种方式:

          *args方式:传递的是tuple,通过访问tuple的方式来访问;

          **args方法:传递的是dict,调用函数时采用赋值方式来指定key;

    --Doc String:

        Doc String是函数对象的__doc__属性;

        定义方式是函数体中的第一个string(一般采用三引号),否则为None;

        作用是对函数的注释,在使用Python内置的帮助得到的函数的用法就是这个;

    --lambda函数:

        这是fucntional programming的概念,简单理解的话就是匿名函数;

        定义方式:f=lambda a,b:a+b等价于def f(a,b):return a+b形式;

        因为函数也是对象,所以一个函数也可以返回一个lambda函数;

    --函数作用域:

        遵循LGB原则:local namespace>global namespace

                         >building namespace;

        通过使用global语句可以改变变量的命名空间(与C++不同概念);

    --嵌套函数:

        嵌套函数即允许在函数中嵌套定义函数;

        嵌套的函数不可以访问外层函数的变量;

    --参数传递:

        因为Python中"一切都是对象",所以参数传递的也是对对象的引用;

     

    模块和包:

        一个module是包含函数和类的文件;

        而package是一组module的集合--即文件夹;

        module也含有Doc String--出注释外的第一条string;

    --引人module:

        引入module有两种方式:

          import module方式:在global namespace中创建名字,使用方式是

                                    module_name.attr形式;

          from module import attr形式:不会在global namespace中创建名字,

                                   直接使用attr,同时module_name.attr形式会报错;

        如果源文件修改了,可通过reload(module)函数重新加载;

    --查找module顺序:

        首先会在当前目录中查找=》然后在环境变量PYTHONPATH中查找

             =》最后在安装目录中查找;

        所以尽量不要起跟库相同名字的module--即文件;

    --创建package步骤:

        在当前目录中创建一个目录—package名字命名;

        在目录中创建一个命名为__init__.py的空文件;

        可以创建包中的modules了;

        使用时采用package.module.attr形式;

     

    命名空间:

        这是一种概念:我的理解是命名空间就是{对象、名称}绑定关系的集合;

                 是对象(object)和名字的映射关系,是动态数据结构dictionary;

        常用命名空间有:

               build-in namespace,global namespace和local namespace;

        在一进入python的解释器就会建立一个module和唯一的blobal namespace,

           其中一个重要属性是__name__来标志module,globale namespace的

           __name__属性为"__main__"(测试可用)。

        函数locals()和globals()分别返回local namespace和global namespace;

        函数del可以接触对象和名字之间的绑定关系,而系统会自动垃圾回收内存;

     

    面向对象编程:

        面向对象(OO)是一种编程思想;

             目的是代码重用;机制是封装、继承和多态;核心是抽象;

    --类和对象:

        类定义格式:class <class_name>(super_class1,super_class3,…):

                               <class_attr>

                               def <method_name>(self,<args>):

                                         <self.attr和method_body>

                  其中类方法的第一个参数是self--表示类实例对象;

        在Python中对象(object)泛指一切;

           通过object.__dict__可得到对象的命名空间--即对象与名字的映射关系;

           通过object.__dict__.keys()和object.__dict__[name]得到key和值;

        vars(obj)得到obj的namespace,dir(obj)得到obj所有attribute;

        attribute(property和method)中name搜索算法:

          1.首先搜索对象的namespace;

          2.如果对象是类实例会搜索对象所属类的namespace;

              2.1如果对象所属类有父类则会从子类到父类顺序搜索类的namespace;

          3.如果对象有__getattr__函数,调用这个函数返回结果;

          PS:可以看出在第2步就实现了继承的概念;

    --类方法和数据成员:

        类方法分为对象绑定方法和对象未绑定方法:

          对象绑定方法:第一个参数是self,通过对象调用如obj_name.method();

          对象未绑定方法:第一个参数不必是self,通过class_name.method()调用;

                               class_name.method()的典型应用是调用父类方法;

        抽象虚拟函数的定义方式是在函数内直接抛出异常来阻止调用;

        在<class_attr>处定义的是类的属性,可通过类和对象调用;

           通过self.attr定义的是对象的属性,只能通过对象调用;

        使用attribute的定义方法是加前缀"__",这种方法并不是像C++中的private

             一样控制,而是系统会在有"__"的属性前加"_classname"前缀预防;

    --继承:

        python中可以多继承,方式是父类作为元素的tuple放在类名和冒号之间;

        每个类实例都有一个"__bases__"的属性记录直接父类的tuple;

        重载是通过attribute的所有算法实现的:先搜索子类后搜索父类;

        在多继承中父类的顺序决定了搜索算法的查找顺序;

    --特殊函数:

        如同C++中的构造/析构函数和复制函数等一样,pyhon中也存在特殊函数:

            __init__:不同与C++中的构造函数,是在构造完成后的初始化函数;

            __del__(self):删除对象时调用;

            __repr__(self):使用repr(obj)函数时调用;

            __str__(self):返回对象的字符串描述,在需要字符串的地方调用;

            __cmp__(self,other):用于比较操作,返回值有(-1,0,1)三个;

            __hash__(self):返回一个32位的hash value;

            __nozero__(self):定义对象是否为逻辑假(0假1真);

            __len__(self):调用内置函数len()时调用;

            __getitem__(self,key):模拟obj[key];

            __setitem__(self,key,value):模拟obj[key]=value;

            __delitem__(self,key):模拟del obj[key];

            __contains__(self,other):用于in语句的判断;

            __call__(self,arg1,arg2,…):让对象具有函数的行为--类似函数对象;

            __getattr__:控制函数的调用;

        重载运算操作符:__add__(self,other),__sub__(self,other),

            __mul__(self,other),__div__(self,other),__mod__(self,other),

            __divmod__(self,other),__pow__(self,other),

            __pow__(self,other,modulo),__lshift__(self,other)(左移),

            __rshift__(self,other)等;

        这里列出的是常用的,但并不是全部;

    --new style class:

        如果一个class的祖先有"object"类那么这个类就是new style class了;

            即:可直接或间接地继承object,但要求祖先中只有一个object;

        增加的两种函数:

            static methord:定义方法是在函数定义后,在增加一条语句:

                                        func_name=staticmethod(fucn_name)

                                 特点是类和实例都可以调用,而行为与普通函数类似;

            class methord:定义方法是在函数定义后,增加语句:

                                       fucn_name=classmethod(fucn_name)

                               要求函数的第一个参数是类,而不是self表示的对象;

           以上两种方法的定义都在函数定义完成后增加一条声明语句;

        增加的特殊函数:

            __new__:真正的构造函数,默认为class method;

            __getattribute__:与__getattr__不同,位于搜索算法的第一步;

        在传统类中调用父类是通过父类名来调用,

                    而new style class通过super(clsobj,obj)返回父类;

     

    异常处理:

        抛出异常是使用raise语句--可以抛出任何对象作为异常;

    --捕获异常:

        格式:try:

                   <body>

                except ExceptionType:

                   <body>

                except (ExcptionType1,ExcpetionType2):

                   <body>

                except:  #捕获任意类型异常

                    <body>

                else:    #只有在没发生异常是才会执行

                    <body>

        finally结构:

               try:

                   <body>

               except:

                   <body>

               finally:    #无论是否发生异常都执行

                   <body>

     

    模块:

        模块就是python的类库,提供了丰富的功能;

        学习的上面的语法才算是刚起步;

    --常用模块:

        提供内置函数:help(),callable(),repr(),eval(),dir(),hasattr()setattr()

                       delattr(),get(),vars(),locals(),globals(),type(),

                       isinstance(),issubclass();

        类型转换函数:chr(),ord(),oct(),hex(),str(),list(),tuple(),dict(),

                        int(),long(),complex(),max(),min();

        执行代码函数:exec语句,compile(),eval();

        file对象:对文件支持的内置对象;

               相关方法:open();f.write(),f.read(),f.open(),f.readline(),

                            f.tell(),f.seek(),f.close();

        sys模块:包含和系统相关的信息;

        os模块:和操作系统相关的调用和操作;

        re模块:正则表达式功能模块;

        struct模块:二进制序列化相关模块:pacak(),unpack()和cacsize();

        cmd模块:编写命令行接口,用于大型程序的测试;

        getop模块:命令行参数处理模块;

        time模块:时间处理模块;

        socket模块:网络模块;

    --图形编程:

        标准模块是Tkinter模块;

        第三方模块是wxWidgets提供的python接口图形库;

    --其他模块:

        标准库中还有很多有用的模块如thread/urllib2等模块需要学习;

        同时丰富的第三方模块也是编程更加简单和容易;

       

     

    ·小结:

        最近一段时间工作轻松些,把以前搜集记录的学习资料都整理下。

    转载于:https://www.cnblogs.com/davidyang2415/archive/2012/04/19/2456852.html

    展开全文
  • 王纯业Python学习笔记
  • Python学习笔记

    2018-09-10 10:34:50
    #贼害怕,搞起来.23082018. 1.Pycharm导入aip: ... 2.Py当中自定义函数返回多个数值时,其实返回的是一个tuple。...但是从语法上来讲,返回一个tuple可以省略括号,而且多个变量可以同时接收一个...所以,python的函...

    #贼害怕,搞起来.23082018.

    1.Pycharm导入aip:

    File-setting-Project untitled-Project Interpreter-点击右侧+;

    2.Py当中自定义函数返回多个数值时,其实返回的是一个tuple。

    但是从语法上来讲,返回一个tuple可以省略括号,而且多个变量可以同时接收一个tuple,按位置赋给对应的值。

    所以,python的函数返回多值其实就是一个tuple,但是写起来特别方便。

    详细的可以参考:廖雪峰老师的py教学(其实很老了。。但是很好。)

    3.Py的默认参数值。

    def powermore(x,n=2):
        s=1;
        while (n>0):
            n=n-1;
            s=s*x;
        return s
    
    print(powermore(5,3))
    print(powermore(5))
    

    默认参数简化函数使用。但是:设置默认参数时候,有几点需要注意:默认参数放在可变参数的后面,。

     

    默认参数必须指向不变对象。

    尤其是在传参是list的时候。

    def calc(*numbers):
        sum=0
        for n in numbers:
            sum=sum+n*n
        return sum
    
    
    print(calc(4))
    print(calc(4,5))
    num=[1,2,3]
    print(*num)
    print(calc(*num))

    在传参的时候,如果对象是list,可以用*变量名  一次传一个list或者tuple进去,这种方法给力常用。

    *nums表示把nums这个list的所有元素作为可变参数传进去。这种写法相当有用,而且很常见。”-廖雪峰py教学。

    参数定义的顺序必须是:必选参数、默认参数、可变参数、命名关键字参数和关键字参数。

    #########基础部分完结#########

    #Python的高级特性

    1行代码能实现的功能,决不写5行代码。请始终牢记,代码越少,开发效率越高。

    1:切片特性和MATLAB一模一样。。。。

    2:迭代

       通过collections模块的Iterable类型来判断是否可以迭代。

    enumerate函数可以把一个list变成索引-元素对

     

    python实现输出时间。

    import time as t
    print(t.localtime())
    
    now = int(t.time())
    timeArray =t.localtime(now)
    otherStyleTime=t.strftime("%Y--%m--%d %H:%M:%S", timeArray)
    print(otherStyleTime)

    这样的输出结果是年月日。

    展开全文
  • (以下基本摘自《王纯业python学习笔记》,所有命令均测试通过) 模块(module)是Python中非常重要的一个概念,模块其实就一些函数和类的集合文件,它能实现一些相应的功能,当我们需要使用这些功能的时候,...

    (以下基本摘自《王纯业的python学习笔记》,所有命令均测试通过)

      

        模块(module)是Python中非常重要的一个概念,模块其实就一些函数和类的集合文件,它能实现一些相应的功能,当我们需要使用这些功能的时候,直接把相应的模块导入到我们的程序中,我们就可以使用了。这类似于C语言中的include头文件,Python中我们用import导入我们需要的模块。

        类似于头文件,模块也是需要系统的搜索路径的,下面的命令即是系统默认的搜索路径,当你导入一个模块时,系统就会在下面的路径列表中搜索相应的文件。

    >>> sys.path

    ['C:/Python26/code', 'C:\\Python26\\Lib\\idlelib', 'C:\\WINDOWS\\system32\\python26.zip', 'C:\\Python26\\DLLs', 'C:\\Python26\\lib', 'C:\\Python26\\lib\\plat-win', 'C:\\Python26\\lib\\lib-tk', 'C:\\Python26', 'C:\\Python26\\lib\\site-packages', 'C:\\Python26\\lib\\site-packages\\win32', 'C:\\Python26\\lib\\site-packages\\win32\\lib', 'C:\\Python26\\lib\\site-packages\\Pythonwin', 'C:\\Python26\\lib\\site-packages\\wx-2.8-msw-unicode']

        假如没有搜到相应内容就会报错。

    >>> import xxx

     

    Traceback (most recent call last):

      File "<pyshell#104>", line 1, in <module>

        import xxx

    ImportError: No module named xxx

        当然我们也可以添加我们的搜索路径。调用列表的append方法即可。

    sys.path.append(‘相对路径或者绝对路径’)

        然后我们就可以加载我们自己的模块了。那么如何创建我们自己的模块呢,简单看一下。首先我们在当前目录创建一个名为testmodule.py的文件,内容如下:

    """

    this only is a very simple test module

    """

    age=0 # a simple attribute

    def sayHello(): # a simple function in a module

        print 'Hello'

    if __name__=="__main__":

        sayHello()

        然后我们导入这个模块就可以使用它的变量和函数了。

    >>> import test_module

    >>> test_module.age

    0

    >>> test_module.sayHello()

    Hello

    >>>

       当然我们也可以这样:

    >>> from test_module import age,sayHello

    >>> age

    0

    >>> sayHello

    <function sayHello at 0x012DF430>

    >>> sayHello()

    Hello

    >>> test_module

     

    Traceback (most recent call last):

      File "<pyshell#138>", line 1, in <module>

        test_module

    NameError: name 'test_module' is not defined

    >>> 

        注意两种方法的不同。 From 并没有把test_module 引进来,所以当前namespace没有test_module这个name。所以报错。

     

        命名空间(name space)是从名称(name)到对象(object)的映射(map)。当一个name映射到一个object上时,这个name和这个object就绑定(bind)了。

        Python中一切都是对象(object),包括function,module,class,package本身。这些对象都在内存中真正的存在,就 像活在世上的每一个人。但是我们怎么找到这些object呢?用name给每个object起名。每个名字只对应一个对象,一个对象可以由多个名字。但是 name不是object本身。

    Python中有很多name space,常用的有:build—in name space(内建命名空间)global name space(全局命名空间),local name space(局部命名空间)。在不同的name space中的name是没有关系的。

    每个object都有自己的name space,可以通过object.name的方式访问object的name space中的name,每个object的name都是独立。即使在别的name space中有与之相同的name,它们也是没有任何关联的。

    每一个object,都有自己的name space,name space都是动态创建的,每一个name space的生存时间也不一样。

        一个模块的name space是这个module被import的时候创建的。每个module都有一个_name_的attribute,用来表示当前module的名字。所以每个module都有这样的代码:

    If _name_= = “_main_”:

       sayHello()  #测试代码

       下面是测试代码

    >>> import sys

    >>> sys.path.append('C:\Python26\code')

    >>> sys.path

    ['C:\\Python26\\Lib\\idlelib', 'C:\\WINDOWS\\system32\\python26.zip', 'C:\\Python26\\DLLs', 'C:\\Python26\\lib', 'C:\\Python26\\lib\\plat-win', 'C:\\Python26\\lib\\lib-tk', 'C:\\Python26', 'C:\\Python26\\lib\\site-packages', 'C:\\Python26\\lib\\site-packages\\win32', 'C:\\Python26\\lib\\site-packages\\win32\\lib', 'C:\\Python26\\lib\\site-packages\\Pythonwin', 'C:\\Python26\\lib\\site-packages\\wx-2.8-msw-unicode', 'C:\\Python26\\code']

    >>> import test_module

    >>> dir(test_module)

    ['__builtins__', '__doc__', '__file__', '__name__', '__package__', 'age', 'sayHello']

    >>> test_module.__name__

    'test_module'

    >>> 

        我们看到这个module有一个__name__属性。因为这个module在被import的时候,它的name space中创建了一个内置的name ,__name__,用来表示module的文件名称。所以import的时候,测试代码sayHello()并没有运行,因为if条件不满足。但是如果我们直接运行该模块的话,那么module的name space就是global name space,这时Python自动把global name space中的__name__ 设为__main__,测试代码就会运行,打印出Hello。

     

        当调用一个function的时候,function的local name space被创建了,当function返回的时候或者异常中断的时候,local name space被删除了。

     

        作用域(scope),是python中的代码从字面意义上可以直接访问的name集合。

    LGB的规则用scope的概念来解释就是:和任何代码执行的时候,都至少有三个scope:local name space,global name space ,buildin name space (LGB)。看下面的例子:

    >>> def sayHello():

           print 'Hello'

     

    >>> saidHello=sayHello

    >>> saidHello

    <function sayHello at 0x012DFE30>

    >>> sayHello

    <function sayHello at 0x012DFE30>

    >>> sayHello()

    Hello

    >>> saidHello()

    Hello

    >>> 

        可以看到sayHello和saidHello不过是两个名字,他们都是指的同样的object,就像一个人有两个名字一样。

    用del可以从一个name space删除一个name,如:

    >>> a=1

    >>> b=a

    >>> a

    1

    >>> b

    1

    >>> id(a)

    11364056

    >>> id(b)

    11364056

    >>> del a

    >>> a

     

    Traceback (most recent call last):

      File "<pyshell#27>", line 1, in <module>

        a

    NameError: name 'a' is not defined

    >>> b

    1

       可以看到a和b指向同一个object,然后我们del a,只是从name space清除了一个name和object的绑定关系,如果没有其他name和这个对象bind,那么才是真正的清除object。实际上python中使用了智能指针技术,每个name都和指向object的指针相关联,每一个object都有一个reference counter记住有多少个name和这个object相关联。每次bind,reference counter都加1,每次删除bind,都减1,只有当reference counter为0时,object才真正被删除。

    转载于:https://blog.51cto.com/752112048/761995

    展开全文
  • python学习笔记

    2018-10-12 17:09:06
    操作数组:数组可以随便放不同的类别的元素 member = ['嘿嘿','哈哈','啦啦'] 插入元素 member.insert(插入位置,插入元素) member.append(对象) member.extend(对象) ...这两个方法的区别是,extend会遍历对象,...

    操作数组:数组可以随便放不同的类别的元素

    member = ['嘿嘿','哈哈','啦啦']

    插入元素

    member.insert(插入位置,插入元素)

    member.append(对象)

    member.extend(对象)

    这两个方法的区别是,extend会遍历对象,进行插入,append是把这个对象原封不动插入到member中,比如这个对象是一个数组,插入到另一个数组中,那么append得到的就是['aa','bb',['cc','dd']]这种,而extend则是['aa','bb','cc','dd']

    删除元素

    member.remove(内容)删除数组中指定的内容相同的地方

    del member 这就是删除整个数组

    del member[i]删除数组中某个元素

    member.pop() 这是把数组最后一个元素展示出来,并且从数组中移除

     

    分片,就是获得member中的某一段

    member[i:j]这里的i,j代表索引位置,获取的是从i开始的元素到j结束的元素不包含j

    如果是member[:]这样不指定i和j那就是复制一份member

    元组

    元组与列表(数组)不同的地方在于元组中的元素定义好了就不能修改,元组是用()表示的

    但是有一点要注意,元组中只有一个元素时,(1)不能这么表示,这样会被认为1是个数组,需要(1,)这样定义才能创建的是元素类型,另外,

                                            temp = 1,   

    这种形式定义的话,带了个括号也会被认为是元组

    字符串format用法

     {0},{1},{2}代表三个位置参数,后边按顺序依次把参数放入拼接成新的字符串。

    "{0} love {1}-{2}".format("I","China","beijing")

    或者用abc来表示位置,后边用等式规定值

    也可以交叉使用"{0} love {b}-{c}".format("I",b="China",c="beijing")但是要注意{0}这种数字表示的一定要放在{a}{b}等这种变量参数位置的前边,不然会报错。

    展开全文
  • 王纯业Python学习笔记(2.2).pdf 简明Python教程.chm 笨办法学 Python (第三版).pdf Python源码剖析.pdf Python学习手册(第4版).pdf Python数据结构与算法.chm Python入门经典.pdf Python基础教程(第2版).pdf ...
  • 书籍一 王纯业Python学习笔记书籍二 Python学习笔记--皮大庆书籍 三 深入Python中文版 Python是一种新兴的计算机程序语言,是自由软件运动的丰硕成果。Python是一种免费的、解释型的、可移植的、开放源代码的脚本...
    书籍一 王纯业的Python学习笔记
    书籍二   Python学习笔记--皮大庆
    书籍 三  深入Python中文版
          Python是一种新兴的计算机程序语言,是自由软件运动的丰硕成果。Python是一种免费的、解释型的、可移植的、开放源代码的脚本编程语言。它提供了大量的模块,不仅加快了程序开发速度和代码的清晰程度,而且使程序员专注于要解决的问题,不会陷入繁琐的技术细节。它可以用来开发各种应用程序,从简单的脚本任务到复杂的、面向对象的应用程序。
           Python是一种脚本语言,它的语法表达优美易读。它具有很多优秀的脚本语言的特点:
    2 解释的;
    2 面向对象的;
    2 内建的高级数据结构;
    2 支持模块和包;
    2 支持多种平台;
    2 可扩展。
            它非常适合于教学。在学习Python的过程中,它可以使学生专注计算机程序语言的基本概念,着中理解现代程序语言的精髓,而不必理会那些细枝末节、令人头痛技术细节,这些细节问题不但难于讲解,也很难理解,而且还会使学生产生厌烦情绪,无助于计算机程序语言的学习。
    分享至
    更多1
    一键收藏,随时查看,分享好友!
    icon01.pngaha45、wgkgood、liangqin1573
    14人
    了这篇文章

    http://saturn.blog.51cto.com/184463/32625

    转载于:https://blog.51cto.com/584250550/1242840

    展开全文
  • python备忘录

    2019-07-13 16:33:11
    Python学习笔记_王纯业http://pan.baidu.com/s/1eQrDEYA 部分有详细的博文链接 1.字符串: 切片 s[a:b] :返回的是 [a,b)的子串 长度: len(s) 字符串的替换方法有两种: last_date = “1/2/3” 目标为...
  • 你是如何自学 Python 的?  去找一个实际项目练手。我当时是因为要做一个网站,不得已要学python。这种条件下的效果比你平时学一门新语言要好很多。所以最好是要有真实的项目做。可以找几个同学一起做个网站之...
  • 网上搜集的,点击即可下载...  O'Reilly.Python.And.XML.pdf 2.02 MB  OReilly - Programming Python 2nd.pdf 6.98 MB ... Orielly.Learning.Python.pdf ... Dive into Python-中文版(python研究,很好的书).ch...
  • 很全的Python资源收集

    2010-03-11 22:36:00
    Programming Python, 2nd Edition (OReilly)http://www.osbbs.com/dl/Programming Python, 2nd Edition (OReilly).chm很全很经典了python学习入门资料OReilly - Learning Python:...
  • Python入门中文资料

    2007-03-19 13:55:00
    最近开始学习Python,收集了一些中文的入门材料与大家分享。 首先是《简明Python教程》,打包自Swaroop C. H.的《A Byte of Python》(简体中文版,沈浩元译)——这是偶第一次觉得能看的懂的编程资料,所以很适合...
  • Programming Python, 2nd Edition (O'Reilly) http://www.osbbs.com/dl/Programming Python, 2nd Edition (O'Reilly).chm 很全很经典了python学习入门资料 OReilly - Learning Python: ...
  • python书籍

    2008-01-20 22:52:00
    api32.hml.chm Manning.Python与Tkinter编程.pdf OReilly - Programming Python, 3rd Edition (2006).ch plone开发旅程.pdf Python Standard Library.chm Python 教學文件.chm Python 研究(Dive Into Python).chm ...
  • python入门书籍

    2019-06-17 19:16:36
    最近开始学习Python,收集了一些中文的入门材料与大家分享。 首先是《简明Python教程》,打包自Swaroop C. H.的《A Byte of Python》(简体中文版,沈浩元译)——这是偶第一次觉得能看的懂的编程资料,所以很...
  • Python语言

    2018-12-30 03:54:11
    关于 Python 是一种解释性的,面向对象的,具有动态语义的程序设计语言 适合快速开发 代码具有优秀的可读性 具有模块和包的概念 支持各种主流平台,并具有很好的跨平台性 可以很容易地包装C/C++的代码...
  • 这两年Python的发展突飞猛进,语法和现在的版本都不一样,现在学习Vitesse开发的人,可能Python 2.3的资源都不好找了。我手里有几本当年下载的书,比较适合那个时代的Python开发者使用。压缩包里面包括: Python开发...
1
收藏数 20
精华内容 8
热门标签