Python核心基础：之二：基础语法

4: 基础语法

http://www.pythondoc.com/pythontutorial3/

http://www.runoob.com/python/python-variable-types.html

• 基础语法

    在 Python 里，标识符有字母、数字、下划线组成。在 Python 中，所有标识符可以包括英文、数字以及下划线(_)，但不能以数字开头。Python 中的标识符是区分大小写的。

    以下划线开头的标识符是有特殊意义的。以单下划线开头 _foo 的代表不能直接访问的类属性，需通过类提供的接口进行访问，不能用 from xxx import * 而导入；

    以双下划线开头的 __foo 代表类的私有成员；以双下划线开头和结尾的 __foo__ 代表 Python 里特殊方法专用的标识，如 __init__() 代表类的构造函数。

    Python 可以同一行显示多条语句，方法是用分号 ; 分开（不推荐）

    

    Python 的关键字只包含小写字母。

    Python 的代码块不使用大括号 {} 来控制类，函数以及其他逻辑判断。python 最具特色的就是用缩进来写模块。缩进的空白数量是可变的，但是所有代码块语句必须包含相同的缩进空白数量，这个必须严格执行。建议你在每个缩进层次使用 单个制表符 或 两个空格 或 四个空格 , 切记不能混用。否则可能出 IndentationError: unexpected indent 或者  IndentationError: unindent does not match any outer indentation level。

    Python语句中一般以新行作为为语句的结束符。但是我们可以使用斜杠（ \）将一行的语句分为多行显示。语句中包含 [], {} 或 () 括号就不需要使用多行连接符。

    Python 可以使用引号( ' )、双引号( " )、三引号( ''' 或 """ ) 来表示字符串，引号的开始与结束必须的相同类型的。

其中三引号可以由多行组成，编写多行文本的快捷语法，常用于文档字符串，在文件的特定地点，被当做注释。

    python中单行注释采用 # 开头。注释可以在语句或表达式行末。python 中多行注释使用三个单引号(''')或三个双引号(""" )。

    函数之间或类的方法之间用空行分隔，表示一段新的代码的开始。类和函数入口之间也用一行空行分隔，以突出函数入口的开始。空行并不是Python语法的一部分，书写时不插入空行，Python解释器运行也不会出错。但是空行的作用在于分隔两段不同功能或含义的代码，便于日后代码的维护或重构。

    等待用户输入： raw_input("\n\nPress the enter key to exit.”) 

    print 默认输出是换行的，如果要实现不换行需要在变量末尾加上逗号. >>> print '000000', ; print ‘99999’ 会输出在一行。

    像if、while、def和class这样的复合语句，首行以关键字开始，以冒号( : )结束，该行之后的一行或多行代码构成代码组。我们将首行及后面的代码组称为一个子句(clause)。

    Python pass是空语句，是为了保持程序结构的完整性。pass 不做任何事情，一般用做占位语句。

    可更改(mutable)与不可更改(immutable)对象

    在 python 中，strings, tuples, 和 numbers 是不可更改的对象，而 list,dict 等则是可以修改的对象。

    不可变类型：变量赋值 a=5 后再赋值 a=10，这里实际是新生成一个 int 值对象 10，再让 a 指向它，而 5 被丢弃，不是改变a的值，相当于新生成了a。

    可变类型：变量赋值 la=[1,2,3,4] 后再赋值 la[2]=5 则是将 list la 的第三个元素值更改，本身la没有动，只是其内部的一部分值被修改了。

• 数据类型

    所有数据和函数都是对象，变量只是指向对象的引用。    

    Python 中的变量赋值不需要类型声明。每个变量在使用前都必须赋值，变量赋值以后该变量才会被创建。等号（=）用来给变量赋值。等号（=）运算符左边是一个变量名,等号（=）运算符右边是存储在变量中的值。

    

    python允许你同时为多个变量赋值

a = b = c = 1

创建一个整型对象，值为1，三个变量被分配到相同的内存空间上。

a, b, c = 1, 2, “john"

为多个对象指定多个变量

    Python有五个标准的数据类型：

Numbers（数字）

int, long, float, complex（复数）

长整型也可以使用小写"L"，但是还是建议您使用大写"L"，避免与数字"1"混淆。Python使用"L"来显示长整型。

数由实数部分和虚数部分构成，可以用a + bj,或者complex(a,b)表示， 复数的实部a和虚部b都是浮点型。

String（字符串）：

是由数字、字母、下划线组成的一串字符

如果你要实现从字符串中获取一段子字符串的话，可以使用变量 [头下标:尾下标]，就可以截取相应的字符串，其中下标是从 0 开始算起，可以是正数或负数，下标可以为空表示取到头或尾。

从左到右索引默认0开始的，最大范围是字符串长度少1

从右到左索引默认-1开始的，最大范围是字符串开头

加号（+）是字符串连接运算符，星号（*）是重复操作。

str = 'Hello World!'

print str           # 输出完整字符串

print str[0]        # 输出字符串中的第一个字符

print str[2:5]      # 输出字符串中第三个至第五个之间的字符串

print str[2:]       # 输出从第三个字符开始的字符串

print str * 2       # 输出字符串两次

print str + "TEST"  # 输出连接的字符串

  List（列表）

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

列表是有序的对象结合。

它支持字符，数字，字符串甚至可以包含列表（即嵌套）。

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

加号 + 是列表连接运算符，星号 * 是重复操作。

list = [ 'runoob', 786 , 2.23, 'john', 70.2 ]

tinylist = [123, 'john']

print list               # 输出完整列表

print list[0]            # 输出列表的第一个元素

print list[1:3]          # 输出第二个至第三个的元素

print list[2:]           # 输出从第三个开始至列表末尾的所有元素

print tinylist * 2       # 输出列表两次

print list + tinylist    # 打印组合的列表

Tuple（元组）

元组用"()"标识。内部元素用逗号隔开。

但是元组不能二次赋值，相当于只读列表。

tuple = ( 'runoob', 786 , 2.23, 'john', 70.2 )

tinytuple = (123, 'john')

print tuple               # 输出完整元组

print tuple[0]            # 输出元组的第一个元素

print tuple[1:3]          # 输出第二个至第三个的元素

print tuple[2:]           # 输出从第三个开始至列表末尾的所有元素

print tinytuple * 2       # 输出元组两次

print tuple + tinytuple   # 打印组合的元组

tinytuple[2] = 1000    # 非法，元组中不可变的

set （集合）

集合是一个无序不重复元素的集。基本功能包括关系测试和消除重复元素。

集合对象还支持 union（联合），intersection（交），difference（差）和 sysmmetric difference（对称差集）等数学运算。

大括号或 set() 函数可以用来创建集合。

注意：想要创建空集合，你必须使用 set() 而不是 {}。后者用于创建空字典

>>> basket = {'apple', 'orange', 'apple', 'pear', 'orange', 'banana'}

>>> print(basket)      # show that duplicates have been removed

{'orange', 'banana', 'pear', 'apple'}

>>> 'orange' in basket                 # fast membership testing

True

>>> # Demonstrate set operations on unique letters from two words

>>> a = set('abracadabra')

>>> b = set('alacazam')

>>> a                                  # unique letters in a

{'a', 'r', 'b', 'c', 'd'}

>>> a - b                              # letters in a but not in b

{'r', 'd', 'b'}

>>> a | b                              # letters in either a or b

{'a', 'c', 'r', 'd', 'b', 'm', 'z', 'l'}

>>> a & b                              # letters in both a and b

{'a', 'c'}

>>> a ^ b                              # letters in a or b but not both

{'r', 'd', 'b', 'm', 'z', 'l'}

Dictionary（字典）

字典是无序的对象集合。

字典当中的元素是通过键来存取的，字典用"{ }”标识。

字典由索引(key)和它对应的值value组成。类似于Map

dict = {}

dict['one'] = "This is one"

dict[2] = "This is two"

tinydict = {'name': 'john','code':6734, 'dept': 'sales'}

print dict['one']          # 输出键为'one' 的值

print dict[2]              # 输出键为 2 的值

print tinydict             # 输出完整的字典

print tinydict.keys()      # 输出所有键

print tinydict.values()    # 输出所有值

        

• 基本数据类型转换

    Python的数据转换都是类似于调用函数，只不过函数名跟数据类型名一致。常见的如下，不常见的用到再查。

int(x [,base])                            将x转换为一个整数

long(x [,base] )                        将x转换为一个长整数

float(x)                                     将x转换到一个浮点数

str(x)                                       将对象 x 转换为字符串

eval(str)                                   用来计算在字符串中的有效Python表达式,并返回一个对象

tuple(s)                                    将序列 s 转换为一个元组

list(s)                                       将序列 s 转换为一个列表

set(s)                                       转换为可变集合

dict(d)                                      创建一个字典。d 必须是一个序列 (key,value)元组。

frozenset(s)                             转换为不可变集合

unichr(x)                                  将一个整数转换为Unicode字符

• 基础运算符

+   正常的+，字符串拼接

-    正常的-，Set求差

*    正常的乘，字符串重复若干次

/    正常的除

%    正常的取模

**    幂，相当于Java的^

//    取整除 - 返回商的整数部分    9//2 输出结果 4 , 9.0//2.0 输出结果 4.0

==   等于 - 比较对象是否相等

!=    不等于 - 比较两个对象是否不相等

<>   不等于 - 比较两个对象是否不相等

>    大于 - 返回x是否大于y

<    小于 - 返回x是否小于y

>=    大于等于    - 返回x是否大于等于y

<=    小于等于 -    返回x是否小于等于y

所有比较运算符返回1表示真，返回0表示假。这分别与特殊的变量True和False等价。注意，这些变量名的大写。 

=    简单的赋值运算符 

+=    加法赋值运算符 

-=    减法赋值运算符

*=    乘法赋值运算符

/=    除法赋值运算符

%=    取模赋值运算符

**=    幂赋值运算符

//=    取整除赋值运算符

位运算符

&    按位与运算符

|    按位或运算符

^    按位异或运算符：当两对应的二进位相异时，结果为1

~    按位取反运算符

<<    左移动运算符：运算数的各二进位全部左移若干位，由"<<"右边的数指定移动的位数，高位丢弃，低位补0

>>    右移动运算符：把">>"左边的运算数的各二进位全部右移若干位，">>"右边的数指定移动的位数

逻辑运算符

and    x and y    布尔"与"

or    x or y    布尔"或"

not    not x    布尔"非"

成员运算符

in    如果在指定的序列中找到值返回 True，否则返回 False。

not in    如果在指定的序列中没有找到值返回 True，否则返回 False。

身份运算符

is   是判断两个标识符是不是引用自一个对象    x is y, 类似 id(x) == id(y) , 如果引用的是同一个对象则返回 True，否则返回 False

is not    是判断两个标识符是不是引用自不同对象

• 判断循环

if 判断条件1:

    执行语句1……

elif 判断条件2:

    执行语句2……

elif 判断条件3:

    执行语句3……

else:

    执行语句4……

在 python 中，for … else 表示这样的意思，for 中的语句和普通的没有区别，else 中的语句会在循环正常执行完（即 for 不是通过 break 跳出而中断的）的情况下执行，while … else 也是一样。

count = 0

while count < 5:

   print count, " is  less than 5"

   count = count + 1

else:

   print count, " is not less than 5"

for letter in 'Python':     # 第一个实例

   print '当前字母 :', letter

fruits = ['banana', 'apple',  'mango']

for fruit in fruits:        # 第二个实例

   print '当前水果 :', fruit

fruits = ['banana', 'apple',  'mango']

for index in range(len(fruits)):

   print '当前水果 :', fruits[index]

for num in range(10,20):  # 迭代 10 到 20 之间的数字

   for i in range(2,num): # 根据因子迭代

      if num%i == 0:      # 确定第一个因子

         j=num/i          # 计算第二个因子

         print '%d 等于 %d * %d' % (num,i,j)

         break            # 跳出当前循环

   else:                  # 循环的 else 部分

      print num, '是一个质数'

'''在python中，for循环后的in跟随一个序列的话，循环每次使用的序列元素，而不是序列

的下标’''

s = 'qazxswedcvfr'

for i in range(0,len(s),2):

    print s[i]

'''enumerate() :

    在每次循环中，可以同时得到下标和元素

    际上，enumerate(),在每次循环中返回的是包含每个元素的定值表，两个元素分别赋值

index，char'''

for (index,char) in enumerate(s):

    print "index=%s ,char=%s" % (index,char)

Python break语句，就像在C语言中，打破了最小封闭for或while循环。

break语句用来终止循环语句，即循环条件没有False条件或者序列还没被完全递归完，也会停止执行循环语句。

break语句用在while和for循环中。

如果您使用嵌套循环，break语句将停止执行最深层的循环，并开始执行下一行代码。

continue 语句用来告诉Python跳过当前循环的剩余语句，然后继续进行下一轮循环。

continue语句用在while和for循环中。

• 异常处理（否则无法讲异常继承参考后面类继承部分）：

try:

<语句>        #运行别的代码

except <名字>：

<语句>        #如果在try部份引发了'name'异常

except ExceptionType, Argument:

    你可以在这输出 Argument 的值...

else:

<语句>        #如果没有异常发生

finally:

<语句>    #退出try时总会执行

你可以不带任何异常类型使用except

try:

    正常的操作

   ......................

except:

    发生异常，执行这块代码

   ......................

else:

    如果没有异常执行这块代码

使用except而带多种异常类型

try:

    正常的操作

   ......................

except(Exception1[, Exception2[,...ExceptionN]]]):

   发生以上多个异常中的一个，执行这块代码

   ......................

else:

    如果没有异常执行这块代码

像这样触发异常: raise MyException("Error message") 或者 raise MyException

模块或包应该定义自己的特定域的异常基类, 这个基类应该从内建的Exception类继承. 模块的异常基类应该叫做”Error”.

class Error(Exception):

    pass

try:

    raise Error

except Error as error:

    pass

使用finally子句来执行那些无论try块中有没有异常都应该被执行的代码. 这对于清理资源常常很有用, 例如关闭文件