初识Python---感受蟒蛇的强大（一）

python 简介----python始终坚持着“只用一种最好的方法，来解决问题”
      1，Python诞生--(吉多·范罗苏姆创建）Guido为了打发圣诞节的无趣，就开发一个全新的编程语言——Python
      2,Python能用来做什么：
    1>openstack业界公认的私有云平台标准是由Python编写的
    2>Web应用开发--豆瓣网和过客网
3>运维开发--DevOps（自动化运维）
4>科学与数字计算--Spark（数据挖掘）
5>3D游戏的开发
6>图形界面的开发
7>网络编程--Sochet

8>网络爬虫--

                  。。。。。。

 3,特性：
    1>简单，语法亲和，条理清晰--所见即所得
2>可以跨平台运行--只需要在Linux，windows，mac的操作系统上安装Python解释器就可以运行Python应用程序
                  原理：Python解释器中包含pvm虚拟机（pvm负责Python程序的运行）
3>敏捷开发


Python 基本概念
      1,环境变量 -->
          定义：解释器的路径
     意义：能够随时随地的启动存在于环境变量路径下的应用程序
     操作系统中应用程序的启动过程
          1. 在启动的当前目录下寻找程序的启动文件，如果在当前目录下没有找到这一个启动文件的话
          2. 读取PATH
          3. 依次在PATH环境变量所拥有的路径下寻找
      2,关键字
    1>定义：被Python语言赋予特定含义的英文单词
2>特点：字母全部为小写
3>注意事项：在一个好的编辑器中（包括vim），特殊字符高亮，直观。
 3，标示符：
     1>定义：就是给类，方法，变量等对象命名时使用的序列
 2>规则：英文大小写字母，数字字符，$和_
 3>注意事项：不能以数字开头，大小写敏感，不能是Python中的关键字
 4,运算符
      1>定义：具有特殊含义的字符
  2>分类
      1）算术运算符 + - * / %
  2）赋值运算符 =
  3）比较运算符 > < =  !=
  4）逻辑运算符 & | ！


Python的注释：注释是一个程序员必须要具有的良好编程习惯


          1,定义：用于解释说明程序的话语
 2，分类格式
       1>单行注释：# 注释文字
2>文档或多行注释：''' 注释文字'''
 3，作用：
                 1>提高程序的可读性
                 2>帮助我们排错  
 
Python的变量
          1，定义：在程序执行过程中，其值可以变化的量
                    例如：与数学中的未知数相似
          2,格式：固定格式，变量名 = 初始化值
          3，赋值操作符：赋值并不是直接将一个值赋给一个变量，Python中数据对象通过引用对象传递的，而变量就是引用对象
 
 4，变量赋值过程：自定义了一个引用对象（变量）和内存对象（存放数据），将引用变量指向内存对象。
          5,增量赋值运算符：等号可以和一个算数操作组合在一起，将结果赋值给左边的变量
            例：e.g.1. >>> x = 1                  e.g.2 >>>x = 1
                       >>> x += 1      可以写成         >>>x+1 = 1
                       >>>x                             >>>x
                       >>>2                >>>2
             好处： 增量赋值相对与普通的赋值不仅仅是写法上的改变，最有意义的变化是第一个对象仅被处理了一次。
                    有效的提高了运行效率。
e.g. 1：
>>>i += 1
1. 读取左i的地址
2. i + 1
3. 将i+1的值的引用传递给左i
e.g.2：
>>>i = i + 1
1. 读取右i的引用地址 ? 1
2. i + 1  == 1 + 1
3. 读取左i的引用地址 ?  指向一个存储地址(数据对象)
4. 将新对象的值赋值给左i
  6,常用的变量运算符：+/-
  
python 基本数据类型
          1，数值型
                整型Integarl---是一种不可变类型，就是一个整数-->int类型对象在内存中并不会发生改变，但可以改变int型对象所对应变量的值。其调用过程为：变量num只存储了索                                           引地址，再通过索引找到在内存中存储的int型对象，并最终引用出来。
                浮点型：Float---小数---->float类型的数据有存储限制。

                布尔型Bool---布尔类型可以直接赋值，注意首字母要大写，布尔型只有两个值 （0|1 false | True）

 2，组合数据类型
     序列：
    定义：Python最基本的组合数据结构。序列：由非负整数索引的对象的有序集合。
分类：
        1.字符串String--可以通过索引引用，以字符为单位，属于不可变类型
           1>定义一个str对象时，str对象会在内存中以ASCII码的格式从 索引对象指定的入口地址依次以字符为单位存放起来，其中每一个Char都占                                                                                1Byte(8bit)的存储空间。
                                                          注：在Python中的字符串可以使用 ‘Str’ 或者 “Str” 括起来，而且两者没有任何的区别
        2>字符串的切片：可以使用切片操作符来实现字符串切片的显示
          (1)stringName[x:y]–>显示字符串中从第x个索引的字符–第y-1个字符,索引从0开始计算，其中的空 格也算一个字符。
例：>>> student = 'my name is shark'
                                                                                                       >>> student
                                                                                                               'my name is shark'
                                                                                                      >>> student [1]
                                                                                                                'y'
                                                                                                      >>> student [0]
                                                                                                                 'm'
                                                                                                        >>> student [0:7]
                                                                                                               'my name'
                                       
 (2)当x或y为空时，默认为显示往前、往后的所有
 (3)string[x:y:步进]，在上述的基础上加入步进显示

            步进的作用即将切片后的字符串，从第一次字符开始，往后均已以步进指定的间隔取出字符。

                                                                                  例： >>> student

                                                                                           'my name is shark'
                                                                                         >>> student [0:7]
                                                                                             'my name'
                                                                                         >>> student [0:7:2]
                                                                                                 'm ae'
                                                                                          >>> student [0:7:3]
                                                                                                   'mne'
                                                 小结：当执行一条赋值语句时，生成了两个对象。分别如下： 
                                                          1). 数据对象：Python会将所有的数据对象存放到分配的存储中(一般存放在内存中特定的地址块)。 
                                                          2). 引用对象：既是变量，其在内存中存放指定的数据对象的索引地址,既数据对象和变量是分别存放的。程序运行时，通过引用对象(变量)来调                                                                                 用出数据对象的值。而且引用对象(变量)是动态类型，可以任意改变引用对象的索引值。 
                                                       值得注意的是，Python自身带有垃圾回收的机制，各种对象在不被引用的时候，便自动由垃圾回收器回收。
                                         
       2. 元组Tuple--不可变对象 anTuple = ('value1','value2','value3')
           
        可以使用内置函数help(Object)来获取一个对象详细的帮助文档
   
       3. 列表---可变对象--是任意对象的有序集合，通过索引访问其中的元素，可以任意的嵌套、伸长、异构

                4. 字典：Dict---字典是Python特有的一种数据结构，其不是以下标的索引来查询数据，而是使用Key：Value的键值对来实现变量和数 据的映射，所以字典也                                                                被称之为映射数据类型。字典使用dictName = {key1:vlalue1,key2:value2,…}创建。字典数据类型，使得Python程序具有了更好的灵活性，因                                                             为其键值对的 设计，很好的兼用了JOSN、NoSQL等主流数据处理技术。
          例子：>>> dictName = {'y':'yu','z':'zhi','l':'lei'}
                                                              >>> dictName
                                                                     {'y': 'yu', 'z': 'zhi', 'l': 'lei'}
                                                            >>> dictName ['y']
                                                                   'yu'
                                                          >>> dictName ['z']
                                                                 'zhi'
                                                         >>> dictName.keys()
                                                                     ['y', 'z', 'l']
                                                        >>> dictName.values()
                                                                   ['yu', 'zhi', 'lei']
结论：
1. 不可变对象：int、float、string、tuple        对一个不可变类型的变量赋以新的值，会改变变量引用对象的索引值，使引用对象新的索引指向新的内存对象。原有的内存对象不                           会发生改变，但若不再被引用对象引用时，会自动的被垃圾回收机制回收。 

2. 可变对象：list、distionary   对一个可变类型的变量赋以新的值，会直接在变量引用对象指向的内存空间中存放新的value，而不会重新开辟新的空间存放新的值。

3，id(变量)：查询变量存储的索引地址 ,

       type(变量)：查看变量的数据类型