python语法基础笔记

本篇笔记基于博主自己的的学习，理解，总结所写。很多东西可能存在误解，不能保证百分之百的正确。

1. 数据表达
1.1 常量和变量
1.2 数据类型
1.2.1 基本数据元素
1.2.1.1 数字
1.2.1.2 字符串
1.2.2 标准数据类型
1.2.2.1 列表（方括号）
1.2.2.2 元祖（圆括号）
1.2.2.3 字典（花括号）
1.3 运算符
1.3.1 算术运算
1.3.2 关系运算
1.3.3 逻辑运算
1.3.4 赋值运算
1.3.5 位运算
1.3.6 成员运算
1.3.7 身份运算
1.4 表达式
1.5 返回值
2. 控制结构
2.1 条件判断结构
2.1.1 if 特殊情况判断
2.1.2 if 互斥情况判断
2.1.3 if 多种情况判断
2.1.4 if 多个条件混合判断
2.2 条件循环结构
2.2.1 for循环遍历
2.2.2 while条件循环
2.3 控制跳转
3. 模块编程
3.1 语句和语句块
3.2 函数和模块
3.2.1 函数的定义
3.2.2 函数的调用
3.2.3 函数的传参
3.2.4 函数的返回
3.2.3 高阶函数
3.3 包和类

1. 数据表达

1.1 常量和变量

• 变量

变量在解释器的命名空间中，只是一个标签，用于表示对对象的引用。可以作为数据类型的引用，也可以用函数等其他对象的引用。

1.2 数据类型

1.2.1 基本数据元素

1.2.1.1 数字

• 整形 int
• 浮点型 float
• 布尔型 bool
• 复数型 complex

1.2.1.2 字符串

1.2.2 标准数据类型

1.2.2.1 列表（方括号）

1.2.2.2 元祖（圆括号）

1.2.2.3 字典（花括号）

1.3 运算符

运算符表示数据运算的类别。python中共有七种运算类型。不同运算类型包括不同的运算符。

• 算术运算
• 关系运算
• 逻辑计算
• 赋值运算
• 位运算
• 成员运算
• 身份运算

1.3.1 算术运算

算术运算包括七种运算符：

+     加法计算
-     减法计算
*     乘法计算
/     除法计算
%    取模（余）计算
**     幂计算
//    取整除计算

1.3.2 关系运算

关系运算包括七种运算符：

==    等于
!=    不等于
<>    不等于
>    大于
<    小于
>=    大于等于
<=    小于等于

1.3.3 逻辑运算

逻辑运算包括三种运算符：

and    布尔与
or       布尔或
not     布尔非

1.3.4 赋值运算

赋值运算包括八种运算符：

=    基本赋值
+=    加后赋值
-=   减后赋值
*=    乘后赋值
/=    除法赋值
%=    取余赋值
**=    幂赋值
//=    取整赋值

1.3.5 位运算

位运算包括六种运算符：

&    按位于
|    按位或
^    按位异或
~    按位取反
<<    左移
>>    右移

1.3.6 成员运算

成员运算两种运算符：

in
not in

1.3.7 身份运算

is
not is

1.4 表达式

表达式由数据类型和运算符组成。表达式有返回值。

返回值有：

• 基本数据元素
• 标准数据类型

表达式有多种类型，比如：

• 运算表达式
• 条件表达式
• 赋值表达式
• 判断表达式

1.5 返回值

返回值一般为：

• 基本数据元素
• 标准数据类型
• 空值
• 无返回值

2. 控制结构

2.1 条件判断结构

条件判断结构，由if...elseif...else...else引导构成。

if后面为条件表达式，条件表达式通常由关系运算，身份运算，成员运算等能够构成条件运算，且一般返回布尔类型值True或者False构成判断条件。

esle为条件成立后的结果。一般为输入，输出，计算，或者无操作。

条件判断不单一，一般存在一个或者多个添加。

一般会按照“判断条件-结果分支“的形式，存在多种判断结构。即：

• 单条件，单分支
• 单条件，双分支
• 单条件，多分支
• 多条件，单分支
• 多条件，双分支
• 多条件，多分支

2.1.1 if 特殊情况判断

单分支。常用于特殊情况排除

    # 简单示例
    if True:
        print 'ok'
    if 1:
        print 'ok'
    if 2 > 1:
        print 'ok'
    # 示例代码
    for i in range(10):
        if i % 2 != 0:
            print i

2.1.2 if 互斥情况判断

双分支。常用于对立的两个方面

    #简单示例
    if False
        print 'ok'
    else:
        print 'not ok'
    # 示例代码
    for i in range(10):
        if i % 2 == 0:
            print "偶数:",i
        else:
            print "奇数:",i

2.1.3 if 多种情况判断

多分支。常用于多个情况的选择或者条件嵌套

    # 简单示例
    # 示例代码
    if 0 < a < 100:
        print "a+100=:",a+100
    elif 100 <= a < 200:
        print "a+200=:",a+200
    elif 200 < a:
        print "a > 200"
    else:
        print "a < 0"

2.1.4 if 多个条件混合判断

    #示例代码
    a = input("a的值:")
    b = input("b的值:")
    if a > 100 and b < 100:
        print "a > 100 and b < 100"
    else:
        print "不满足a>100，并且b<100"
    if a >= 100 or b >= 100:
        print "a >= 100 or b >= 100"
    else:
        print "a和b都不大于100"

2.2 条件循环结构

2.2.1 for循环遍历

• for 循环输入

for 遍历一个列表（或者返回列表的表达式），来处理输入操作

    a = [ ]
    for i in range(10):
        a.append(i)
        print a[i]

• for 循环输出

for遍历一个列表（或者返回列表的表达式），来处理输出操作。示例如下：

    for i in 1,2,3,4:
        print i
    for i in range(10):
        print i

• for 循环计算

2.2.2 while条件循环

2.3 控制跳转

3. 模块编程

3.1 语句和语句块

python语句由换行符和缩进组成。语句块是稍微复杂一点的带有逻辑性的语句，如控制结构种的语句模块。

语句和语句块是模块化编程的基础，也就是语法基础。由语句和语句块，构成了编程文件。

语句和表达式的区别在于，表达式一般都有返回值，而语句只是一条包含了表达式的指令合集。

    ## 赋值语句
    a = 100
    a = input("输入a:")
    ## 控制结构
    if a > 0:
        print a
    else
        print "hello"

上述示例种，控制结构语句块，包含了条件表达式等

3.2 函数和模块

如果说语句和语句块，是编程语句的最基本组成。

那么可以由语句或者语句组成功能性更强，重复性更低的代码段。可以称之为函数。

函数的定义，在数学上为：对输入的不同的值，都进行同样的操作，这也服务编程中函数的使用规范。

python函数，表示组织好的，可重复使用的，用来实现单一，或者相关功能的代码段。

python解释器，提供了很多内置函数，也支持用户自定义函数

函数的使用，包括定义，调用，传参，返回，变量作用域等概念。

函数在python中的引用极其重要，是python功能的体现。

3.2.1 函数的定义

语法层面上，函数以def关键字定义，后接函数名称和圆括号括起来的参数列表

任何传入参量和自变量，需要放入参数列表中

函数第一行语句，可以选择性的使用函数说明文档。

函数同样遵循python的语法，冒号+缩进

return 表达式，表示函数的结束，表示给调用者的返回。不带表达式的函数返回None

定义函数时，需要确定函数的名称和参数个数；如果有必要，可以先对参数的数据类型做检查。

    #语法结构
    def    functionname( parameters ):
        "函数_文档字符串"
        function_suite
        return    [experssion]
    #示例代码。打印字符串函数
    def helloworld(str):
        print "I am :%s" % str
    helloworld("liwanliang")

3.2.2 函数的调用

函数的定义完成之后，基本上能够知道函数的功能。函数功能的实现，通过在代码中调用函数实现。

有多个默认参数时，调用的时候，既可以按照顺序提供的默认参数，也可以不按顺序提供部分默认参数。当不按顺序提供部分默认参数时，需要把参数名写上。

    #示例代码：
    def helloworld(str):
        print "I am :%s" % str
    myname = raw_input("input your name:")
    hellowrld(myname)  

3.2.3 函数的传参

python中，一切都是对象。对象才具有类型，而变量是对象的引用，无类型。

对象有可变对象，也有不可变对象。

可变对象包括：

• list
• dict

不可变对象包括：

• string
• tuple
• number

python函数中，以变量来进行参数传递，分为不可变类型和可变类型。

不可变类型传递的是值的拷贝，而可变类型传递得是值。

严格意义上讲，我们不能说是值传递，还是引用传递。我们应该说是传可变对象和传不可变对象。

    #不可变对象示例代码
    def liwanliang(a):
        a = 100
        print a
    b = 200
    liwanliang(b)
    print b
    #可变对象示例代码
    def helloworld(str1,str2):
        print "Hello,I am:" + str1 +"."+ "I am "+ str2
    myname = raw_input("input your name:")
    myage = raw_input("input your age:")
    helloworld(myname,myage)

python可以使用的正式参数类型：

• 必备参数。即函数定义了参数，调用时也一定要传入。
• 关键字参数。即函数调用时，在参数列表中赋值传入。
• 默认参数。即函数调用时，未指定参数值时，则会默认为函数定义时的值。
• 不定长参数。即函数参数不定长时，通过*号表示不定长的参数列表。

可变参数允许传入0个或者任意个参数，这些可变参数在函数调用时自动组装为tuple。

关键字参数允许传入0个或者任意个含参数名的参数，这些关键字参数在函数内部自动组装成dict。

3.2.4 函数的返回

return 表达式。该语句表示退出函数，选择性地向调用方返回一个表达式。不带参数值的return语句返回None。

所有函数均有返回值，通过显示指定，或者隐式返回None。

一个函数可以有多个return语句，但是只有一个被执行。如果没有一条return被执行，则隐式返回None。

如果执行了return语句，函数会立刻返回，结束调用。被执行的return之后的语句，不再被执行。

return和print的区别为：print仅仅是函数代码段中，打印标准输出部分的语句；而return是结束调用时，返回给调用者的对象。

无论定时的返回什么类型，return只能返回单个标准数据类型，单个数据类型可以包括多种基本数据元素。

函数可以同时返回多个值，但其实就是一个tuple。

• 返回基本数据元素
  
  如整型，浮点型，布尔型，复数型
• 返回标准数据类型
  
  如字符串，列表，元祖，字典，集合
• 返回函数，闭包，匿名函数

3.2.3 高阶函数

python高阶函数中，函数可以作为参数，也可以作为返回值，并且参与函数运算。

3.3 包和类