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 包和类