python的基本介绍（1）

一、python简介

1、python简介

(1)Python 是一个高层次的结合了解释性、编译性、互动性和面向对象的脚本语言。
(2)Python的设计具有很强的可读性，相比其他语言经常使用英文关键字，其他语言的一些标点符号，它具有比其他语言更有特色语法结构。
(3)Python是一种解释型语言： 这意味着开发过程中没有了编译这个环节。类似于PHP和Perl语言。
(4)Python是交互式语言： 这意味着，您可以在一个Python提示符，直接互动执行写你的程序。
(5)Python是面向对象语言: 这意味着Python支持面向对象的风格或代码封装在对象的编程技术。
(6)Python是初学者的语言：Python对初级程序员而言，是一种伟大的语言，它支持广泛的应用程序开发，从简单的文字处理到 WWW 浏览器再到游戏。--简单易学

2、python发展
    Python 是由 Guido van Rossum（龟叔） 在八十年代末和九十年代初，在荷兰国家数学和计算机科学研究所设计出来的。
    Python 本身也是由诸多其他语言发展而来的,这包括 ABC、Modula-3、C、C++、Algol-68、SmallTalk、Unix shell 和其他的脚本语言等等。像 Perl 语言一样，Python 源代码同样遵循 GPL(GNU General Public License)协议。现在 Python 是由一个核心开发团队在维护，Guido van Rossum 仍然占据着至关重要的作用，指导其进展。

3、python特点
    (1)易于学习：Python有相对较少的关键字，结构简单，和一个明确定义的语法，学习起来更加简单。
    (2)易于阅读：Python代码定义的更清晰。
    (3)易于维护：Python的成功在于它的源代码是相当容易维护的。
    (4)一个广泛的标准库：Python的最大的优势之一是丰富的库，跨平台的，在UNIX，Windows和Macintosh兼容很好。
    (5)互动模式：互动模式的支持，您可以从终端输入执行代码并获得结果的语言，互动的测试和调试代码片断。
    (6)可移植：基于其开放源代码的特性，Python已经被移植（也就是使其工作）到许多平台。
    (7)可扩展：如果你需要一段运行很快的关键代码，或者是想要编写一些不愿开放的算法，你可以使用C或C++完成那部分程序，然后从你的Python程序中调用。
    (8)数据库：Python提供所有主要的商业数据库的接口。
    (9)GUI编程：Python支持GUI可以创建和移植到许多系统调用。
    (10)可嵌入: 你可以将Python嵌入到C/C++程序，让你的程序的用户获得"脚本化"的能力。

二、基本语法

1、编码
    默认情况下，python3源文件以UTF-8编码，所有字符串都是unicode字符串。同时可以指定源文件的不同编码
    文件开头加上
    # -*- coding: UTF-8 -*-
    # coding=utf-8(等号两边不能有空格)
    允许在源文件中使用utf-8字符集中的字符编码，对应的适合语言为中文等
2、标识符
    (1)第一个字符必须是字母表中的字母或下划线_
    (2)标识符中的其他部分由字母、数字和下划线组成
    (3)标识符对大小写敏感
    在python3中，非ASCII标识符也是允许(中文)
3、注释
    单行注释：#
    多行注释：'''    '''
4、关键子和保留字

    import keyword
    print(len(keyword.kwlist))  #33
    print(keyword.kwlist)       #打印关键字

    ['False', 'None', 'True', 'and', 'as', 'assert', 'break', 'class', 'continue', 'def', 'del', 'elif', 'else', 'except', 'finally', 'for', 'from', 'global', 'if', 'import', 'in', 'is', 'lambda', 'nonlocal', 'not', 'or', 'pass', 'raise', 'return', 'try', 'while', 'with', 'yield']

    简介：
    1.and：表示逻辑‘与’
    2.del：用于list列表操作，删除一个或者连续几个元素。
    3.from：导入相应的模块，用import或者from...import
    4.not：表示逻辑‘非’
    5.while：while循环，允许重复执行一块语句，一般无限循环的情况下用它
    6.as：as单独没有意思，是这样使用：with....as用来代替传统的try...finally语法的。
        扩展：with...as...用法
            with open('./hello world') as f:
            data = f.read()
            print(data)

            class Demo(object):
                def t(self):
                    print("haha1")

            class Test(object):
                def __enter__(self):        # 1
                    print('这是enter')
                    return Demo()
                def __exit__(self,a,b,c):
                    print('这是exit')     # 3
                def t(self):
                    print("haha")

            with Test() as t:
                t.t()                       # 2

    7.elif:和if配合使用的，if语句中的一个分支用elif表示。
    8.global :定义全局变量
        例如：
        name = 10
        age = 20
        def test():
            global name
            age = 30
            name = 'aa'
            #print(name)
        test()
        print(name)     # 'aa'
        print(age)      # 20

    9.or：表示逻辑“或”
    10.with：和as一起用，使用的方法请看as，见with
    11.assert：表示断言（断言一个条件就是真的，如果断言出错则抛出异常）用于声明某个条件为真，如果该条件不是真的，则抛出异常：AssertionError

        v1 = 10
        v2 = 20
        assert(v1 > v2)

    12.else：看下面if的解释
    13.if：if语句用于选择分支，依据条件选择执行那个语句块。(if语句中最好不要嵌套if语句，建议把嵌套的if语句写在另一个函数中)
    14.pass：pass的意思就是什么都不做
    15.yield：用起来和return很像，但它返回的是一个生成器
    16.break：作用是终止循环，程序走到break的地方就是循环结束的时候。
    17.except：和try一起使用，用来捕获异常。
    18.import：用来导入模块，有时这样用from....import
    19.class：定义类
    20.in：查找列表中是否包含某个元素，或者字符串a是否包含字符串b。
    21.raise：raise可以显示地引发异常。一旦执行raise语句，后面的代码就不执行了
    22.continue：跳过continue后面循环块中的语句，继续进行下一轮循环。
    23.finally:看到finally语句，必然执行finally语句的代码块。
    24.is：Python中的对象包含三要素：id、type、value,用来判断对象是否相等
    25.return：用于跳出函数，也可以在跳出的同时返回一个值。
    26.def：用于定义方法
    27.for：for....in 一起使用：它在一序列的对象上递归，就是遍历队列中的每个项目
    28.lambda:即匿名函数
    29.try：出现在异常处理中，使用格式为：try...except，try中放想要执行的语句，except捕获异常
    30.nonlocal：nonlocal关键字用来在函数或其他作用域中使用外层(非全局)变量
        例如：
        def make_counter(): 
            count = 0 
            def counter(): 
                nonlocal count 
                count += 1 
                return count 
            return counter 
           
        def make_counter_test(): 
            mc = make_counter() 
            print(mc())
            print(mc())
            print(mc())
        make_counter_test()
5、行和缩进
    学习 Python 与其他语言最大的区别就是，Python的代码块不使用大括号{}来控制类，函数以及其他逻辑判断。python 最具特色的就是用缩进来写模块。
    缩进的空白数量是可变的，但是所有代码块语句必须包含相同的缩进空白数量，这个必须严格执行。
    例如：
    if True:
        print "True"
    else:
        print "False"
6、多行语句
    Python语句中一般以新行作为语句的结束符。但是我们可以使用斜杠（ \）将一行的语句分为多行显示，如下所示：
    total = item_one + \
            item_two + \
            item_three
    print('aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\
            aaaaaaaaaaaaaaaaaaaa')
    语句中包含 [], {} 或 () 括号就不需要使用多行连接符。如下实例：
    days = ['Monday', 'Tuesday', 'Wednesday',
            'Thursday', 'Friday']
7、python的引号
    Python 可以使用引号( ' )、双引号( " )、三引号( ''' 或 """ )表示字符串，引号的开始与结束必须的相同类型的。
    其中三引号可以由多行组成，编写多行文本的快捷语法，常用于文档字符串，在文件的特定地点，被当做注释。

    word = 'word'
    sentence = "这是一个句子。"
    paragraph = """这是一个段落。
    包含了多个语句"""

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

9、等待用户输入
    执行下面的程序在按回车键后就会等待用户输入：

    input("\n\n按下 enter 键后退出。")

10、同一行显示多条语句
    Python可以在同一行中使用多条语句，语句之间使用分号(;)分割，以下是一个简单的实例：

    x = 'runoob';print(x + '\n')

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

    if expression : 
       suite
    elif expression : 
       suite 
    else : 
       suite
12、Print 输出
    print 默认输出是换行的，如果要实现不换行需要在变量末尾加上 end=""：

    x="a"
    y="b"
    # 换行输出
    print( x )
    print( y )
     
    print('---------')
    # 不换行输出
    print( x, end=" " )
    print( y, end=" " )
    print()

13、import 与 from...import
    在 python 用 import 或者 from...import 来导入相应的模块。
    a、将整个模块(somemodule)导入，格式为： import somemodule
    b、从某个模块中导入某个函数,格式为： from somemodule import somefunction
    c、从某个模块中导入多个函数,格式为： from somemodule import firstfunc, secondfunc, thirdfunc
    d、将某个模块中的全部函数导入，格式为： from somemodule import *

    (1)导入 sys 模块
        import sys
        print('================Python import mode==========================');
        print ('命令行参数为:')
        for i in sys.argv:
            print (i)
        print ('\n python 路径为',sys.path)
    
    (2)导入 sys 模块的 argv,path 成员
        from sys import argv,path  #  导入特定的成员
         
        print('================python from import===================================')
        print('path:',path) # 因为已经导入path成员，所以此处引用时不需要加sys.path

14、命令行参数
    很多程序可以执行一些操作来查看一些基本信息，Python可以使用-h参数查看各参数帮助信息：

    $ python -h
    usage: python [option] ... [-c cmd | -m mod | file | -] [arg] ...
    Options and arguments (and corresponding environment variables):
    -c cmd : program passed in as string (terminates option list)
    -d     : debug output from parser (also PYTHONDEBUG=x)
    -E     : ignore environment variables (such as PYTHONPATH)
    -h     : print this help message and exit

三、基本数据类型

1、变量赋值
    counter = 100       # 整型变量
    miles = 1000.0      # 浮点型变量
    name = "runoob"     # 字符串

    print (counter)
    print (miles)
    print (name)

2、多变量赋值
    Python允许你同时为多个变量赋值。例如：
    a = b = c = 1
    以上实例，创建一个整型对象，值为 1，从后向前赋值，三个变量被赋予相同的数值。

    可以为多个对象指定多个变量。例如：

    a, b, c = 1, 2, "runoob"
    a,b = b,a           # 变量的交换
    以上实例，两个整型对象 1 和 2 的分配给变量 a 和 b，字符串对象 "runoob" 分配给变量 c。

    注意：
    a = 10
    b = 20
    a,b = b,a+5
    print(a,b)

    结果：a = 20,b=15

3、标准数据类型

    Number（数字）、String（字符串）、List（列表）、Tuple（元组）、Set（集合）、Dictionary（字典）

    a、不可变数据（3 个）：Number（数字）、String（字符串）、Tuple（元组）
    b、可变数据（3 个）：List（列表）、Dictionary（字典）、Set（集合）

4、Number
    int、float、bool、complex(复数)
    例如：
        a,b,c,d = 20,5.5,True,5+4j
        print(type(a),type(b),type(c),type(d))
    函数：
        type(a)             # 判断数据类型
        isinstance(a,int)   # 判断数据是否属于某类型
        del var1,var2       # 删除数据的引用
        区别:
            (1)type()不会认为子类是一种父类类型
            (2)isinstance()会认为子类是一种父类类型
            例如：
                class A:
                    pass
                class B(A):
                    pass
                print(type(A()) == A)
                print(type(B()) == A)
                print(isinstance(B(),A))
                print(isinstance(B(),A))
    进制：
        二进制：使用0b开头  例如：0b1010
        八进制：使用0o开头  例如：0o555
        十六进制：0x开头       例如：0x52A74（大小写都OK）
        注意：python中没有数字的大小限制，可以使用任意大的数字
             python可以保证整数运算的精确，但是浮点数运算时可能会得到一个不精确的结果(计算机中无法用二进制小数的)
        扩展：小数的二进制的计算方法
             a、分母为奇数，分子*2，大于分母取1，小于取0
             b、分母为偶数，分母/2，直到分母为偶数时再按照奇数的方式计算
             C、当分子和分母相同时，取整
             d、二进制小数转十进制，先转换成分数，再计算
    注意：
    (1)在Python2中是没有布尔型的，它用数字0表示False，用1表示True。到Python3中，把True和False定义成关键字了，但它们的值还是 1 和 0，它们可以和数字相加。
    print(True+1)       # 2
    (2)复数的实部喝虚部都是浮点型的
    (3)数值的除法包含两个运算符：/ 返回一个浮点数，// 返回一个整数。
    (4)在混合计算时，Python会把整型转换成为浮点数。
    (5)比较长的数据显示方法，例如 money = 999999999    money = 999_999_999

    扩展：
    import math
    (1) 数学函数
        函数                  返回值 ( 描述 )
        abs(x)              返回数字的绝对值，如abs(-10) 返回 10
        ceil(x)             返回数字的上入整数，如math.ceil(4.1) 返回 5
        (x>y)-(x<y)         如果 x < y 返回 -1, 如果 x == y 返回 0, 如果 x > y 返回 1
        exp(x)              返回e的x次幂(ex),如math.exp(1) 返回2.718281828459045
        fabs(x)             返回数字的绝对值，如math.fabs(-10) 返回10.0
        floor(x)            返回数字的下舍整数，如math.floor(4.9)返回 4
        log(x)              如math.log(math.e)返回1.0,math.log(100,10)返回2.0
        log10(x)            返回以10为基数的x的对数，如math.log10(100)返回 2.0
        max(x1, x2,...)     返回给定参数的最大值，参数可以为序列。
        min(x1, x2,...)     返回给定参数的最小值，参数可以为序列。
        modf(x)             返回x的整数部分与小数部分，两部分的数值符号与x相同，整数部分以浮点型表示。
        pow(x, y)           x**y 运算后的值。
        round(x [,n])       返回浮点数x的四舍五入值，如给出n值，则代表舍入到小数点后的位数。
        sqrt(x)             返回数字x的平方根。
    (2) 随机数函数
        随机数可以用于数学，游戏，安全等领域中，还经常被嵌入到算法中，用以提高算法效率，并提高程序的安全性。
        函数                  描述
        choice(seq)         从序列的元素中随机挑选一个元素，比如random.choice(range(10))，从0到9中随机挑选一个整数。
        randrange ([start,] stop [,step])   从指定范围内，按指定基数递增的集合中获取一个随机数，基数缺省值为1
        random()            随机生成下一个实数，它在[0,1)范围内。
        seed([x])           改变随机数生成器的种子seed。如果你不了解其原理，你不必特别去设定seed，Python会帮你选择seed。
        shuffle(lst)        将序列的所有元素随机排序
        uniform(x, y)       随机生成下一个实数，它在[x,y]范围内。

    (3) 三角函数
        函数                  描述
        acos(x)             返回x的反余弦弧度值。
        asin(x)             返回x的反正弦弧度值。
        atan(x)             返回x的反正切弧度值。
        atan2(y, x)         返回给定的 X 及 Y 坐标值的反正切值。
        cos(x)              返回x的弧度的余弦值。
        hypot(x, y)         返回欧几里德范数 sqrt(x*x + y*y)。
        sin(x)              返回的x弧度的正弦值。
        tan(x)              返回x弧度的正切值。
        degrees(x)          将弧度转换为角度,如degrees(math.pi/2) ， 返回90.0
        radians(x)          将角度转换为弧度

    (4) 数学常量
        常量                  描述
        pi                  数学常量 pi（圆周率，一般以π来表示）
        e                   数学常量 e，e即自然常数（自然常数）。

5、String
    Python中的字符串用单引号 ' 或双引号 " 括起来，同时使用反斜杠 \ 转义特殊字符。下标从0开始
    加号 + 是字符串的连接符， 星号 * 表示复制当前字符串，紧跟的数字为复制的次数。
    (1)字符串截取
        变量[头下标:尾下标:正倒序)

         -6  -5  -4  -3  -2  -1
          0   1   2   3   4   5
        +---+---+---+---+---+---+
        | a | b | c | d | e | f |
        +---+---+---+---+---+---+

        例如：
            str = 'hello world'
            l = str[0:1:1]
            print(l)

    (2)字符串打印
        Python 使用反斜杠(\)转义特殊字符，如果你不想让反斜杠发生转义，可以在字符串前面添加一个 r，表示原始字符串：

        print('Ru\noob')
        Ru
        oob
        print(r'Ru\noob')
        Ru\noob
    (3)字符串获取
        print(str[0])
    注意：
        1、反斜杠可以用来转义，使用r可以让反斜杠不发生转义。
        2、字符串可以用+运算符连接在一起，用*运算符重复。
        3、Python中的字符串有两种索引方式，从左往右以0开始，从右往左以-1开始。
        4、Python中的字符串不能改变。
            str = 'abcdef'
            str[0] = 's'    # 报错
        5、Python 没有单独的字符类型，一个字符就是长度为1的字符串。
6、List
    List（列表）是Python 中使用最频繁的数据类型。列表可以完成大多数集合类的数据结构实现。列表中元素的类型可以不相同，它支持数字，字符串甚至可以包含列表(所谓嵌套)。列表是写在方括号[]之间、用逗号分隔开的元素列表。和字符串一样，列表同样可以被索引和截取，列表被截取后返回一个包含所需元素的新列表。
    定义：
        list = [0,1,2,3,'c']
        list[0]         # 0
        len(list)       # 长度5
        list[0:3]       # [0,1,2]

    注意：
        1、List写在方括号之间，元素用逗号隔开。
        2、和字符串一样，list可以被索引和切片。
        3、List可以使用+操作符进行拼接。
        4、List中的元素是可以改变的。
        5、不支持与或非运算

7、Tuple
    元组（tuple）与列表类似，不同之处在于元组的元素不能修改。元组写在小括号 () 里，元素之间用逗号隔开。
    定义：
        t = (0,1,2,3,'c')
        t[0]            # 0
        len(list)       # 长度5
        t[0:3]          # (0,1,2)
        t[0] = 2        # 报错

    注意：
        1、与字符串一样，元组的元素不能修改。虽然tuple的元素不可改变，但它可以包含可变的对象，比如list列表。
            list = [0,2,1,3]
            t = (0,1,2,3,list)
            t[0] = 1            # 报错
            t[4][0] = 1
            print(t[4])         # ok
        2、元组也可以被索引和切片，方法一样。
        3、注意构造包含0或1个元素的元组的特殊语法规则。
            tup1 = ()           # 空元组
            tup2 = (20,)        # 一个元素，需要在元素后添加逗号
        4、元组也可以使用 + 或 * 操作符进行拼接。

8、Set
    集合（set）是由一个。合的事物或对象称作元素或是成员。基本功能是进行成员关系测试和删除重复元素。
    可以使用大括号 { } 或者 set() 函数创建集合，注意：创建一个空集合必须用 set() 而不是 { }，因为 { } 是用来创建一个空字典。

    创建格式：
        parame = {value01,value02,...} 或者 set(value)

    s = {'Tom', 'Jim', 'Mary', 'Tom', 'Jack', 'Rose'}
    print(s)                    # {'Mary', 'Jack', 'Rose', 'Tom', 'Jim'}

    s = set('1b1b2b3b2b')       # {'2', '3', '1', 'b'}

    set操作：
        # set可以进行集合运算
        a = set('abracadabra')
        b = set('alacazam')
         
        print(a)
        >>> {'b', 'a', 'c', 'r', 'd'}
        print(a - b)     # a和b的差集
        >>> {'b', 'd', 'r'}
        print(a | b)     # a和b的并集
        >>> {'l', 'r', 'a', 'c', 'z', 'm', 'b', 'd'}
        print(a & b)     # a和b的交集
        >>> {'a', 'c'}
        print(a ^ b)     # a和b中不同时存在的元素
        >>> {'l', 'r', 'z', 'm', 'b', 'd'}

9、Dictionary（字典）
    字典（dictionary）是Python中另一个非常有用的内置数据类型。
    列表是有序的对象集合，字典是无序的对象集合。两者之间的区别在于：字典当中的元素是通过键来存取的，而不是通过偏移存取。
    字典是一种映射类型，字典用"{ }"标识，它是一个无序的键(key) : 值(value)对集合。
    键(key)必须使用不可变类型。
    在同一个字典中，键(key)必须是唯一的。
    字典创建：
        (1) d = {"a":1,"b":2,"c":3}
        (2) d = dict([('Runoob', 1), ('Google', 2), ('Taobao', 3)])
        (3) d = {x:x**2 for x in (2, 4, 6)}
        (4) d = dict(Runoob=1, Google=2, Taobao=3)
    字典操作：
        tinydict = {'name': 'guigu','code':1, 'site': 'www.atguigu.com'}

        print (dict['name'])            # 输出键为 'name' 的值
        print (dict['code'])            # 输出键为 'code' 的值
        print (tinydict)                # 输出完整的字典
        print (tinydict.keys())         # 输出所有键 dict_keys(['name', 'code', 'site'])
        print (tinydict.values())       # 输出所有值 dict_values(['guigu', 1, 'www.atguigu.com'])

10、python类型转换

    函数                          描述
    int(x [,base])              将x转换为一个整数
    float(x)                    将x转换到一个浮点数
    complex(real [,imag])       创建一个复数
    str(x)                      将对象 x 转换为字符串
    repr(x)                     将对象 x 转换为表达式字符串
    eval(str)                   用来计算在字符串中的有效Python表达式,并返回一个对象
    tuple(s)                    将序列 s 转换为一个元组
    list(s)                     将序列 s 转换为一个列表
    set(s)                      转换为可变集合
    dict(d)                     创建一个字典。d 必须是一个序列 (key,value)元组。
    frozenset(s)                转换为不可变集合
    chr(x)                      将一个整数转换为一个字符
    ord(x)                      将一个字符转换为它的整数值
    hex(x)                      将一个整数转换为一个十六进制字符串
    oct(x)                      将一个整数转换为一个八进制字符串

四、python解释器Linux/Unix的系统上，一般默认的 python 版本为 2.x，我们可以将 python3.x 安装在 /usr/local/python3 目录中。
安装完成后，我们可以将路径 /usr/local/python3/bin 添加到您的 Linux/Unix 操作系统的环境变量中，这样您就可以通过 shell 终端输入下面的命令来启动 Python3 。

$ PATH=$PATH:/usr/local/python3/bin/python3    # 设置环境变量
$ python3 --version
Python 3.4.0

1、在Window系统下你可以通过以下命令来设置Python的环境变量，假设你的Python安装在 C:\Python34 下:
    set path=%path%;C:\python34
2、交互式编程
    我们可以在命令提示符中输入"Python"命令来启动Python解释器：

    $ python3

    (1)执行以上命令后，出现如下窗口信息：

        $ python3
        Python 3.4.0 (default, Apr 11 2014, 13:05:11) 
        [GCC 4.8.2] on linux
        Type "help", "copyright", "credits" or "license" for more information.
        >>> 
    
    (2)在 python 提示符中输入以下语句，然后按回车键查看运行效果：

        print ("Hello, Python!");

    (3)以上命令执行结果如下：

        Hello, Python!

    (4)当键入一个多行结构时，续行是必须的。我们可以看下如下 if 语句：

        >>> flag = True
        >>> if flag :
        ...     print("flag 条件为 True!")
        ... 
        flag 条件为 True!
3、脚本式编程
    (1)将如下代码拷贝至 hello.py文件中：

        print ("Hello, Python!");

    (2)通过以下命令执行该脚本：

        python3 hello.py
    
    (3)输出结果为：

        Hello, Python!

    (4)在Linux/Unix系统中，你可以在脚本顶部添加以下命令让Python脚本可以像SHELL脚本一样可直接执行：

        #! /usr/bin/env python3

    (5)然后修改脚本权限，使其有执行权限，命令如下：

        $ chmod +x hello.py

    (6)执行以下命令：

        ./hello.py

    (7)输出结果为：

        Hello, Python!

五、运算符
1、算术运算符
a = 10 b = 21
运算符 描述 实例
+ 加 两个对象相加 a + b 输出结果 31
- 减 得到负数或是一个数减去另一个数 a - b 输出结果 -11
* 乘 两个数相乘或是返回一个被重复若干次的字符串 a * b 输出结果 210
/ 除 x 除以 y b / a 输出结果 2.1
% 取模 返回除法的余数 b % a 输出结果 1
** 幂 返回x的y次幂 a**b 为10的21次方
// 取整除 向下取接近除数的整数 9//2 # 4
-9//2 #-5

2、比较运算符
    a = 10  b = 20
    运算符         描述              实例
    ==              等于              比较对象是否相等            (a == b) 返回 False
    !=              不等于         比较两个对象是否不相等 (a != b) 返回 True
    >               大于              返回x是否大于y            (a > b) 返回 False
    <               小于              返回x是否小于y            (a < b) 返回 True
    >=              大于等于            返回x是否大于等于y      (a >= b) 返回 False
    <=              小于等于            返回x是否小于等于y      (a <= b) 返回 True
    注意：所有比较运算符返回1表示真，返回0表示假。这分别与特殊的变量True和False等价。注意，这些变量名的大写。

3、赋值运算符
    运算符         描述              实例
    =               简单的赋值运算符    c = a + b 将     a + b 的运算结果赋值为 c
    +=              加法赋值运算符 c += a 等效于  c = c + a
    -=              减法赋值运算符 c -= a 等效于  c = c - a
    *=              乘法赋值运算符 c *= a 等效于  c = c * a
    /=              除法赋值运算符 c /= a 等效于  c = c / a
    %=              取模赋值运算符 c %= a 等效于  c = c % a
    **=             幂赋值运算符      c **= a 等效于     c = c ** a
    //=             取整除赋值运算符    c //= a 等效于     c = c // a

4、位运算符
    运算符         描述              实例
    &               按位与运算符：参与运算的两个值,如果两个相应位都为1,则该位的结果为1,否则为0    
                                    (a & b) 输出结果 12 ，二进制解释： 0000 1100
    |               按位或运算符：只要对应的二个二进位有一个为1时，结果位就为1。
                                    (a | b) 输出结果 61 ，二进制解释： 0011 1101
    ^               按位异或运算符：当两对应的二进位相异时，结果为1
                                    (a ^ b) 输出结果 49 ，二进制解释： 0011 0001
    ~               按位取反运算符：对数据的每个二进制位取反,即把1变为0,把0变为1。~x 类似于 -x-1
                                    (~a ) 输出结果 -61 ，二进制解释： 1100 0011， 在一个有符号二进制数的补码形式。
    <<              左移动运算符：运算数的各二进位全部左移若干位，由"<<"右边的数指定移动的位数，高位丢弃，低位补0。
                                    a << 2 输出结果 240 ，二进制解释： 1111 0000
    >>              右移动运算符：把">>"左边的运算数的各二进位全部右移若干位，">>"右边的数指定移动的位数  
                                    a >> 2 输出结果 15 ，二进制解释：0000 1111
5、逻辑运算符(bool)
    a = 10, b = 20
    运算符         逻辑表达式   描述                                                      实例
    and x and y     布尔"与"       如果x为 False，x and y 返回False，否则它返回y的计算值       (a and b) 返回 20
    or  x or y      布尔"或"       如果x是 True，它返回x的值，否则它返回y的计算值             (a or b) 返回 10
    not not x       布尔"非"       如果x为 True，返回False 。如果x为False，它返回True            not(a and b) 返回 False

6、成员运算符
    除了以上的一些运算符之外，Python还支持成员运算符，测试实例中包含了一系列的成员，包括字符串，列表或元组。

    运算符         描述                                                      实例
    in              如果在指定的序列中找到值返回 True，否则返回 False。         x在y序列中,如果x在y序列中返回True
    not in          如果在指定的序列中没有找到值返回 True，否则返回 False。       x不在y序列中,如果x不在y序列中返回True

7、身份运算符
    身份运算符用于比较两个对象的存储单元

    运算符         描述          实例
    is              is是判断两个标识符是不是引用自一个对象    
                                x is y, 类似 id(x) == id(y) , 如果引用的是同一个对象则返回 True，否则返回 False
    is not          is not是判断两个标识符是不是引用自不同对象
                                x is not y ， 类似id(a)!=id(b)。如果引用的不是同一个对象则返回结果True，否则返回False。

8、Python运算符优先级
    以下表格列出了从最高到最低优先级的所有运算符：

    运算符                     描述
    **                          指数 (最高优先级)
    ~ + -                       按位翻转, 一元加号和减号 (最后两个的方法名为 +@ 和 -@)
    * / % //                    乘，除，取模和取整除
    + -                         加法减法
    >> <<                       右移，左移运算符
    &                           位 'AND'
    ^ |                         位运算符
    <= < > >=                   比较运算符
    <> == !=                    等于运算符
    = %= /= //= -= += *= **=    赋值运算符
    is is not                   身份运算符
    in not in                   成员运算符
    and or not                  逻辑运算符