Python基础

                                                                    Python基础
                                                        
python版本：2.7.5
1、输入和输出
    (1)、输入 print()
        1)、拼接字符串
            print()函数也可以接受多个字符串，用逗号“,”隔开，就可以连成一串输出
            print()会依次打印每个字符串，遇到逗号“,”会输出一个空格，因此，输出的字符串是这样拼起来的：
            例:
                print 'Hello', 'world'
                结果:Hello world
                
        2）、计算整数，打印结果
            例：
                1]、    
                    print 200 + 300
                    结果：500
                2]、    
                    print '200 + 300 =', 200 + 300
                    结果：200 + 300 = 500
    (2)、输出 input()
        例：
            代码：
                #!/usr/bin/env python
                # -*- coding: utf-8 -*-
                name = input('请输入你的名字：')
                print 'Hello,', name
            运行：
                请输入你的名字：'张三'
                Hello, 张三
            注：如果要输入字符串请带单引号或者双引号

2、数据类型和变量
    (1)、整数：Python可以处理任意大小的整数，当然包括负整数
                1000,-1000,0,1
    (2)、浮点数（小数）：Python的浮点数也没有大小限制，但是超出一定范围就直接表示为inf（无限大）。
                整数和浮点数在计算机内部存储的方式是不同的，整数运算永远是精确的（除法难道也是精确的？是的！），而浮点数运算则可能会有四舍五入的误差。
    (3)、字符串：字符串是 Python 中最常用的数据类型。我们可以使用引号('或")来创建字符串。
            'Hello world', "Hello world"
            1)、转义： \n：换行    \t：制表符  
                打印 I can't "eat"!
                代码：print "I can't \"eat\"!"  或  print 'I can\'t "eat"!'
            2)、不转义： 使用 r'' 表示 ''内部不转义
                打印 I can\'t \"eat\"!
                代码：print r'I can\'t \"eat\"!'
            3)、多行同时输出：'''...'''格式表示多行的内容
                打印：
                    第一行
                    第二行
                    第三行
                1]、在交互式命令中：
                    >>> print '''line1
                        ... line2
                        ... line3'''
                        line1
                        line2
                        line3
                    注意：输入多行内容时，提示符由>>>变为... 意为接着上一行输入，...是提示符，不是代码的一部分
                2]、在.py文件中代码：
                    #!/usr/bin/env python
                    # -*- coding: utf-8 -*-
                    print '''第一行
                    第二行
                    第三行'''
    (4)、布尔值：True False (请注意大小写)
    (5)、空值：空值是Python里一个特殊的值，用None表示。None不能理解为0，因为0是有意义的，而None是一个特殊的空值。
    (6)、变量：
        1)、单个变量赋值
            代码：
                counter = 1000 # 赋值整型变量
                miles = 10000.0 # 浮点型
                name = "Bob" # 字符串
                
                print counter
                print miles
                print name
            打印：
                1000
                10000.0
                Bob
        2)、多个变量赋值
            a = b = c = 1
            a, b, c = 1, 2, "bob"
    (7)、常量：所谓常量就是不能变的变量
        PI = 3.14159265359
        事实上PI仍然是一个变量

3、字符串和编码
    (1)、字符串：ASCLL获取与返获取
        代码：
            print ord('A')
            print chr(66)
        打印：
            65
            B
    (2)、格式化：在Python中，采用的格式化方式和C语言是一致的，用%实现
            %运算符就是用来格式化字符串的。在字符串内部，%s表示用字符串替换，%d表示用整数替换，
            有几个%?占位符，后面就跟几个变量或者值，顺序要对应好。如果只有一个%?，括号可以省略。
        1)、常见占位符
            占位符：    %d        %f        %s        %x
            替换内容:    整数    浮点数    字符串     十六进制整数
        2)、例子 格式化整数和浮点数还可以指定是否补0和整数与小数的位数
            代码：
                print '%2d-%02d' % (30000, 1)
                print '%.2f' % 3.1415926
            打印：
                30000-01
                3.14
    (3)、format()：它会用传入的参数依次替换字符串内的占位符{0}、{1}……，不过这种方式写起来比%要麻烦得多
        代码：
            #!/usr/bin/env python
            # -*- coding: utf-8 -*-
            print 'Hello, {0}, 成绩提升了 {1:.1f}%'.format('小简', 3.1415926)
        打印：
            Hello, 小简, 成绩提升了 3.1%

4、使用list和tuple
    (1)、list 列表 是一种有序的集合，可以随时添加和删除其中的元素，可重复
        1)、常用方法
        代码：
            nameList = ['zhangSan', 'Lisi', 'wangWu']
            print nameList
            print len(nameList)    #获取list的长度
            print nameList[1]
            print nameList[-1]        #获取倒数第一个

            nameList.append('zhaoLiu')    #在末尾追加赵六
            print nameList

            a = nameList.insert(1, 'IndexIsOne')    #索引为1插入这条数据
            print a  
            print nameList

            lastVal = nameList.pop()    #删除末尾元素，返回删除的元素
            print lastVal
            print nameList

            chooseVal = nameList.pop(1)    #删除指定位置的元素，返回删除的元素
            print chooseVal
            print nameList

            nameList[1] = 'Bob'    #要把某个元素替换成别的元素，可以直接赋值给对应的索引位置
            print nameList
        打印：
            ['zhangSan', 'liSi', 'wangWu']
            3
            liSi
            wangWu
            ['zhangSan', 'liSi', 'wangWu', 'zhaoLiu']
            None
            ['zhangSan', 'IndexIsOne', 'liSi', 'wangWu', 'zhaoLiu']
            zhaoLiu
            ['zhangSan', 'IndexIsOne', 'liSi', 'wangWu']
            IndexIsOne
            ['zhangSan', 'liSi', 'wangWu']
            ['zhangSan', 'Bob', 'wangWu']
        2)、注意：list也可以是多维的
            nameList = ['zhangSan', 'liSi', ['py', 'java'], 'wangWu']
            如果想要获取java只需
            print nameList[2][1]
        3)、如果一个list中一个元素也没有，就是一个空的list，它的长度为0：
            代码：
                nameList = []
                print len(nameList)
            打印：
                0
    (2)、tuple 元组 tuple和list非常类似，但是tuple一旦初始化就不能修改，可重复
        1)、常用方法
                代码：
                    #!/usr/bin/env python
                    # -*- coding: utf-8 -*-
                    
                    nameTuple = ('zhangSan', 'liSi', 'wangWu')
                    print nameTuple
                    print nameTuple[1]
                    print nameTuple[-1]

                    nameTuple1 = (1)
                    print nameTuple1

                    nameTuple2 = (1,)
                    print nameTuple2

                    nameTuple3 = ('a', 'b', ['A', 'B'])
                    nameTuple3[2][0] = 'M'
                    nameTuple3[2][1] = 'N'
                    print nameTuple3
                打印：
                    ('zhangSan', 'liSi', 'wangWu')
                    liSi
                    wangWu
                    1
                    (1,)
                    ('a', 'b', ['M', 'N'])
                分析：
                    1]、现在，nameTuple这个tuple不能变了，它也没有append()，insert()这样的方法。其他获取元素的方法和list是一样的，
                        你可以正常地使用nameTuple[0]，nameTuple[-1]，但不能赋值成另外的元素。
                    2]、如果元组只有1个元素时，定义的不是一个tuple，而是一个变量，因为()既可以表示tuple，又可以表示数学公式中的小括号，这就产生了歧义，
                        所以当tuple只有一个元素时，在元素后面，括号里面加一个逗号, 打印出来结果也会有一个逗号,用以消除歧义
                    3]、nameTuple3[2][0] = 'M' 这里的修改不是修改元组，是修改了元组里面的列表，列表是能修改的。

5、条件判断
    (1)、if条件判断语句：if语句执行有个特点，它是从上往下判断，如果在某个判断上是True，把该判断对应的语句执行后，就忽略掉剩下的elif和else
        if <条件判断1>:
            <执行1>
        elif <条件判断2>:
            <执行2>
        elif <条件判断3>:
            <执行3>
        else:
            <执行4>
    (2)、if案例
            代码：
            #!/usr/bin/env python
            # -*- coding: utf-8 -*-

            anyInt = input('请任意输入一个整数: ')
            if anyInt < 2000:
                print'小于2000'
            elif anyInt == 2000 :
                print'等于2000'
            else:
                print '大于2000'
            输入： 2000
            打印：
                等于2000
                
6、循环
    (1)、for循环出list或tuple
        代码：
            #!/usr/bin/env python
            # -*- coding: utf-8 -*-

            nameList = ['zhangSan', 'liSi', ['py', 'java'], 'wangWu']
            for x in nameList:
                print x
                
            print '--------分割线---------'

            nameTuple = ('zhangSan', 'liSi', 'wangWu')
            for y in nameTuple:
                print y
        打印：
            zhangSan
            liSi
            ['py', 'java']
            wangWu
            --------分割线---------
            zhangSan
            liSi
            wangWu
    (2)、求和
        1)、求和1-10
            代码：
                #!/usr/bin/env python
                # -*- coding: utf-8 -*-
            
                sum = 0
                for x in [1,2,3,4,5,6,7,8,9,10]:
                    sum = sum + x
                print(sum)
            打印：
                55
        2)、range()函数：生成一个整数序列，再通过list()函数可以转换为list。比如range(5)生成的序列是从0开始小于5的整数
            代码：
                #!/usr/bin/env python
                # -*- coding: utf-8 -*-
                
                print list(range(5))
            打印：
                [0, 1, 2, 3, 4]
        3)、计算 1-100 的和
            代码：
                #!/usr/bin/env python
                # -*- coding: utf-8 -*-
                
                sum = 0
                for x in list(range(101)):        # for x in range(101): 与 for x in list(range(101)): 结果一样
                    sum = sum + x
                print(sum)
            打印：
                5050
        (3)、break 提前退出循环：当n>10时结束
            代码：
                #!/usr/bin/env python
                # -*- coding: utf-8 -*-

                n = 1
                while n <= 20:
                    if n > 10: # 当n = 11时，条件满足，执行break语句
                        break # break语句会结束当前循环
                    print(n)
                    n = n + 1
                print 'END'
            打印：
                1
                2
                3
                4
                5
                6
                7
                8
                9
                10
                END
        (4)、continue 跳过当前循环，执行下一次循环
            需求：打印出 1-10之间的偶数
            代码：
                #!/usr/bin/env python
                # -*- coding: utf-8 -*-
                
                n = 0
                while n < 10:
                    n = n + 1
                    if n % 2 != 0: # 如果n是偶数，执行continue语句
                        continue # continue语句会直接继续下一轮循环，后续的print()语句不会执行
                    print(n)
            打印：
                2
                4
                6
                8
                10
                
7、使用dict和set
    (1)、dict：字典 dict全称dictionary，在其他语言中也称为map，使用键-值（key-value）存储，具有极快的查找速度。不能重复
        1)、常用方法
            代码：
                #!/usr/bin/env python
                # -*- coding: utf-8 -*-
                    
                userDict = {'zhangSan':18,'liSi':19,'wangWu':20}
                print userDict
                print userDict['liSi']

                userDict['liSi'] = 99        #给key重新赋值
                print userDict


                print 'zhaoLiu' in userDict    #通过in判断key是否存在

                print userDict.get('zhaoLiu') #通过dict的get()判断是否存在，不存在返回None
                print userDict.get('zhaoLiu', -1) #通过dict的get()判断是否存在，不存在返回None，或者可以自己定义值，比如 -1

                print userDict.get('zhangSan') #存在就打印key对应的val

                delRet = userDict.pop('zhangSan')    #删除key为'zhangSan'，值也会一起删除
                print delRet    #返回key对应的val
                print userDict
            打印：
                {'liSi': 19, 'zhangSan': 18, 'wangWu': 20}
                19
                {'liSi': 99, 'zhangSan': 18, 'wangWu': 20}
                False
                None
                -1
                18
                18
                {'liSi': 99, 'wangWu': 20}
        2)、和list比较
            1]、和list比较，dict有以下几个特点：
                查找和插入的速度极快，不会随着key的增加而变慢；
                需要占用大量的内存，内存浪费多。
            2]、而list相反：
                查找和插入的时间随着元素的增加而增加；
                占用空间小，浪费内存很少。
    (2)、set：set和dict类似[唯一区别仅在于没有存储对应的value/也是一组key的集合，但不存储value]由于key不能重复，所以，在set中，没有重复的key。不能重复
        代码：
            nameSet = set([1,2,2,3,3,4])    #要创建一个set，需要提供一个list作为输入集合
            print nameSet        #注意，传入的参数[1, 2, 3]是一个list，而显示的{1, 2, 3}只是告诉你这个set内部有1，2，3这3个元素，显示的顺序也不表示set是有序的。。


            nameSet.add(5)        #过add(key)方法可以添加元素到set中，可以重复添加，但不会有效果：
            print nameSet

            nameSet.add(4)
            print nameSet

            nameSet.remove(2)    #remove(key)删除元素
            print nameSet

            nameSet1 = set([2,3,4,5,6])  #可进行并集、交集操作
            print nameSet & nameSet1
            print nameSet | nameSet1
        打印：
            set([1, 2, 3, 4])
            set([1, 2, 3, 4, 5])
            set([1, 2, 3, 4, 5])
            set([1, 3, 4, 5])
            set([3, 4, 5])
            set([1, 2, 3, 4, 5, 6])