python学习（二）

一、过程型程序设计快速入门

python学习最好方法：一边学习理论，一边进行编程实践，获取实际经验，加深学习的内容。

首先在本地机器上安装python3.2

学习内容：

1）如何创建并执行python程序（python编辑器很多，这里选择IDLE）

2）学习python的8大关键要素。（学习完后足以编写有用的程序）

3）根据所学的内容，编程练习。（学以致用）

学习过程：

1、怎么创建python程序

要编写python代码，可以使用任意能加载与保存文本的普通文本编辑器。默认情况下，python使用UTF-8的编码方式，可以表达每种语言中的所有字符。

2、python保存文件的扩展名？

通常、程序的扩建名.py       .pyw作为python GUI程序的扩展名。.py作为python控制台和python模块的扩展名。

3、经典程序（helloworld.py）

print("hello","world")(文本编辑器编写后保存为helloworld.py)

4、怎么执行python？

说明：python配置环境变量，进入.py文件所在的文件位置，执行python程序，一开始推荐用IDLE编辑器。

5、python的8大关键要素？

要素#1 数据类型

1、任何语言必须完成基本任务？

     表示数据项

2、python内置的数据类型包括哪些？

这里只介绍以下几种：

int：整数 大小受限于机器本身的内存

str：字符串（Unicode编码）使用对称的单引号或双引号

使用[]来访问字符串序列中的某一项，下标从0开始

内置数据类型的数值都是固定的。就是说明，取字符串序列时，只可读，不可写。

一种数据类型转换另一个种数据类型使用datatype(item)的形式，来相互转化。转化是有意义的！

要素#2 对象引用

定义数据类型之后，接下来就是要定义存储某种类型数据的变量。

Python中一切都是对象，变量中存放的是对象的引用。这是一个普遍的法则。我们举个例子来说，Python是如何来处理的。

1. x = 'blue'  
2. y = 'green'  
3. z = x  

当python执行上面第一句的时候，会在heap中首先创建一个str对象，其文本内容为blue，同时还创建一个名为x的对象引用，x引用的就是这个str对象。第二句也是类似；第三条创建了一个名为z的新对象引用，并将其设置为对象引用x所指向的相同对象。如下图的变化。

所以看出在Python中赋值操作符号“=”的作用是，将对象引用和内存中的某个对象进行绑定。如果对象已经存在，就进行简单的重新绑定，以便引用“=”右边的对象；如果对象引用尚未存在，就首先创建对象，然后将对象引用和对象进行绑定。这很类似与c中的指针的概念。

Python使用“动态类型”机制，也就是说，在Python程序中，任何时候可以根据需要，某个对象引用都可以重新绑定到另一个不同的对象上（不要求是相同的类型），这和其他强化型语言如（C++,Java)不太一样，只允许重新绑定相同类型的对象上。在Python中，因为有“动态类型”机制，所以一个对象引用可以执行不同类型的对象适用的方法。当一个对象不存在任何对象引用的时候，就进入了垃圾收集的过程。

1. >>> a = 100  
2. >>> a /10  
3. 10.0  
4. >>> a[0]   
5. Traceback (most recent call last):   
6.   File "<pyshell#166>", line 1, in <module>   
7.     a[0]   
8. TypeError: 'int' object is not subscriptable   
9. >>> a = 'hello'  
10. >>> a[0]   
11. 'h'  
12. >>> a /10  
13. Traceback (most recent call last):   
14.   File "<pyshell#169>", line 1, in <module>   
15.     a /10  
16. TypeError: unsupported operand type(s) for /: 'str' and 'int' 

第一句 a = 100 
Python会在heap创建一个int对象，其内容为100，同时创建a变量，其值指向heap中的int对象

第二句 a/10
Python适用“动态类型”机制，判断a指向的对象是int型，可以适用/(除法)操作。于是便进行运算产生结果。（它会在heap中在创建一个10.0的对象么?）

第三句 a[0]
Python适用“动态类型”机制，判断a指向的对象是int型，并不适用[](分片)操作。于是就进行报错。

第四句 a = 'hello'
Python会在heap创建一个str对象，其内容为hello，同时改变a变量，使得其值指向heap中的str对象。同时原来的int对象，由于不在存在对象引用，所以就进入了垃圾收集过程。


第五句 a[0]
Python适用“动态类型”机制，判断a指向的对象是str型，可以适用[](分片)操作。于是便进行运算产生结果。

第六句 a/10
Python适用“动态类型”机制，判断a指向的对象是str型，并不适用/(除法)操作。于是就进行报错。

总之 ：在Python中一切都是对象，变量总是存放对象引用。当一个对象没有变量指向它的时候，它便进入了垃圾收集过程。Python的“动态类型”机制，负责检查变量的对象引用适用操作。如果该对象不适用该操作，则会直接报错。一句话”变量无类型，对象有类型 “

Python 的变量是没有类型的，这与以往看到的大部分语言都不一样。但 Python 却是区分类型的，那类型在哪里呢？事实是，类型是跟着内存中的对象走的。Python 的所有变量其实都是指向内存中的对象的一个指针，所有的变量都是！此外，对象还分两类：一类是可修改的，一类是不可修改的。

Python在heap中分配的对象分成两类：可变对象和不可变对象。所谓可变对象是指，对象的内容是可变的，例如list。而不可变的对象则相反，表示其内容不可变。

• 不可变对象：int，string，float，tuple
• 可变对象   ：list，dictionary

一、不可变对象

由于Python中的变量存放的是对象引用，所以对于不可变对象而言，尽管对象本身不可变，但变量的对象引用是可变的。运用这样的机制，有时候会让人产生糊涂，似乎可变对象变化了。如下面的代码：

1. i = 73  
2. i += 2  

从上面得知，不可变的对象的特征没有变，依然是不可变对象，变的只是创建了新对象，改变了变量的对象引用。

看看下面的代码，更能体现这点的。

1. #因为258是int对象，是不可变对象的。所以下面3个id的值都是一样的，最后一句的结果也是为True   
2. #有点奇怪的是为什么在IDLE，和在脚本执行的结果不太一样。所以下面的代码请在脚本中执行。   
3.   
4. print(id(258))   
5. a = 258  
6. print(id(a))   
7. b = 258  
8. print(id(b))   
9. print(a is b)  

二、对于可变对象

其对象的内容是可以变化的。当对象的内容发生变化时，变量的对象引用是不会变化的。如下面的例子。

1. m=[5,9]   
2. m+=[6]  

二、python的id()，==，is的差别

1. id()：获取的是对象在内存中的地址

2. is ：比对2个变量的对象引用（对象在内存中的地址，即id() 获得的值）是否相同。如果相同则返回True，否则返回False。换句话说，就是比对2个变量的对象引用是否指向同一个对象。

3. ==：比对2个变量指向的对象的内容是否相同。

对象引用的名称称为标识符。对于标识符有一些限制：

1、必须以字母或下划线开头 ，其后跟0个或多个非空字符、下划线、数字。没有长度限制

2、不能与python中关键字相同

3、python标识符对大小写敏感。

要素#3 组合数据类型

整个数据项组合在一起通常会带来方面。python提供几种组合数据类型，包括关联数组及集合等类型

元组与列表：可以存储任意数量、任意类型的数据项

元组是（）创建；列表是[]创建。

列表和元组并不是真正存储数据项，而是存放对象的引用。

组合类型也是对象，了解这些对象提供的方法。

要素#4 逻辑操作符

任何程序设计语言的一个基本功能都是其逻辑运算。python提供了4组逻辑运算。

1、身份操作符

由于所有的python变量实际上对象的引用，有时比较两个或多个对象的引用是否指向相同的对象是有意义的。is操作符是一个二元操作符，用于

比较两个对象的引用是否相同。

身份操作符的作用是查看两个对象引用是否指向相同的对象，或是查看某个对象是否为None，如果比较对象的值应该使用比较操作符。

2、比较操作符

python提供二进制比较操作符的标准集合 < <= == != >= >,这些操作符对对象的值进行比较。

python比较符的一个特别好用的特性是：进行结连比较    0 <= a <=9

3、成员操作符

对于序列或集合这一类提供操作符in测试成员关系，用 not in测试非成员关系。

4、逻辑运算符

python提供了3个逻辑运算符 and or 与not  

三者都使用short-cirvuit逻辑，并返回决定结果的操作数。-而不是返回布尔值。

要素#5 控制流语句

1、.py文件中每条语句都是顺序执行的。

2、实际上，函数、方法调用、及控制结构都可以使控制流发生转变。异常也可以改变控制流

3、控制结构：if while loop 语句

布尔表达式实际上对对象进行布尔运算，并产生一个布尔值结果。在python中，预定义的False的布尔值、特殊对象None、空序列或集合、值为0的数值型数据项都是布尔结果为False

一块代码，称为suite，由于python中的某些语法要求存在一个suite，python提供关键字pass pass实际是一条空语句，不进行任务操作

4、if选择语句

if bool_expression1:

suite1

elif bool_expression2:

suite2

else:

else_suite

与其他编程语言不同，python使用缩排来标示块结构。建议每层缩排4个空格

5、while循环语句

while语句用于0次或多次执行某个suite，循环次数取决于while循环中布尔表达式的状态。

while bool_expression:

suite

while的结构中，还可以包括break、continue、else分支 break是跳出循环，continue是跳出当前循环，break语句和continue语句都用在if语句内部，以便条件性的改变某个循环的执行流程。

6 for ... in 语句

for variable in iterable:

suite

与while一样，for循环也支持break、continue、else分支

7、异常处理

python的很多函数与方法都会产生异常，并将其作为发生错误或重要事件的标志。

try：

try_suite

except exception as v1

exception_suite1

...

except exceptionN as vN

exception_suiteN

异常处理的逻辑工作：如果try块的suite都正常执行，exception模块将被跳过；如果try块中产生异常，则控制流会立即转向第一个异常匹配的suite-这意味着，跟谁在产生异常以后的suite将不再执行。异常也被看做一种对象。

要素#6 算数操作符

python提供完整的算术运算集，包括基本四则数学运算 + - * / 需要注意：/除法返回浮点数

还提供各式的增强的赋值操作符 += *=

python重载操作符 + +=操作符

要素#7 输入\输出

编写有用的程序，必须能够读取输入（控制台或文件中），还要产生输出（控制台或文件中）。

print("Type int ,each followed by enter,or just Enter to finish")
total = 0
count = 0
while True:
    line = input("integer:")
    if line:
        try:
            number = int(line)
        except ValueError as err:
            print(err)
            continue
        total += number
        count += 1
    else:
        break
if count:
    print("count=",count,"total =",total,"mean=",total/count)

重定向输出  >  print函数输出从控制台重定向到文件中。

重定向输入 <  终止符从空白符改为EOF字符。

异常处理模块集中放在程序尾部，以保证主要流程尽可能的清晰。

要素#8 函数的创建及调用

函数定义：def functionName(args)：

导入模块，使用import 

导入顺序：标准库-第3方-自己自定义的

6、编程练习

编程1

在命令行中输入一个数字，之后程序会使用“大”数字向控制台输入该数字。

zero = ["     ***     ",
"   *     *   ",
"  *       *  ",
"  *       *  ",
"  *       *   ",
"   *     *    ",
"     ***     "]
one = [ "    *        ",
        "   **        ",
"    *        ",
"    *        ",
"    *        ",
"    *        ",
"   ***       "
]
two = [ "    ***      ",
        "  *    *     ",
        "  *    *     ",
        "      *      ",
        "    *        ",
        "   *         ",
        "  ******     "
]
three =[]
four = []
five = ["   ******    ",
        "   *         ",
        "   *         ",
        "   ******    ",
        "        *    ",
        "        *    ",
        "   ******    "]


Digits = [zero,one,two,three,four,five]


import sys
try:
    digits = sys.argv[1]
    row = 0
    while row < 7:
        line = ""
        column = 0
        
        while column < len(digits):
            number = int(digits[column])
            digit = Digits[number]
            line += digit[row]+" "
            column += 1
        print(line)
        row += 1
except IndexError as indexerr:
    print(indexerr)
except ValueError as valerr:
    print(valerr)
    

编程2 随机生成整数组成网格程序，用户可以规定 需要多少行，多少列，以及整数所在的范围。

import random


def get_int(msg,minimun,defalut):
    while True:
        try:
            line = input(msg)
            if not line and defalut is not None:
                return defalut
            i = int(line)
            if(i< minimun):
                print("must be >=",minimun  )
            else:
                return i
        except ValueError as err:
            print(err)




rows = get_int("rows:",1,6)
columns = get_int("columns",1,6)
minimum = get_int("minimum(or enter 0)",-10000,0)


default = 1000
if default < minimum:
    default = 2 * minimum
maximum = get_int("maximum",minimum,default)


row = 0
while row < rows:
    line = ""
    column = 0
    while column < columns:
        i = random.randint(minimum,maximum)
        s = str(i)
        while(len(s) < 10):
            s = " "+s
        line += s
        column += 1
    print(line)
    row += 1