Python基础（二）

使用list和tuple：
Python内置的一种数据类型是列表：list。list是一种有序的集合，可以随时添加和删除其中的元素。

         classmates = ['Michael', 'Bob', 'Tracy']
         classmates
         ['Michael', 'Bob', 'Tracy']

变量classmates就是一个list。用len()函数可以获得list元素的个数：

 len(classmates)
        3

用索引来访问list中的每一个位置的元素，与JAVA类似，索引是从0开始的：

         classmates[0]
        'Michael'
         classmates[1]
        'Bob'
         classmates[2]
        'Tracy'

当索引超出范围，Python会报IndexError错误，所以要确保不要越界，记得最后一位元素的索引是len(classmates)-1。

如果要取得最后一个元素，可以用-1做索引，直接获取最后一个元素：

          classmates[-1]
         'Tracy'

list是一个可变的有序的表，所以，可以往list中追加元素到末尾：

        classmates('Adam')
         classmates
        ['Michael', 'Bob', 'Tracy', 'Adam']

也可以把元素插入到指定的位置，比如索引号为1的位置：

         classmates.insert(1, 'Jack')
         classmates
        ['Michael', 'Jack', 'Bob', 'Tracy', 'Adam']

要删除list末尾的元素，用pop()方法：

         classmates.pop()
        'Adam'
         classmates
        ['Michael', 'Jack', 'Bob', 'Tracy']

要删除指定位置的元素，用pop(i)方法，其中i是索引位置：

         classmates.pop(1)
        'Jack'
         classmates
        ['Michael', 'Bob', 'Tracy']

要把某个元素替换成别的元素，可以直接赋值给对应的索引位置：

         classmates[1] = 'Sarah'
         classmates
        ['Michael', 'Sarah', 'Tracy']

list元素的数据类型可以不同，比如：

 L = ['Apple', 123, True]

list元素也可以是另一个list，比如：

        s=['python','java',['asp','php'],'acheme']
        len(s)
        4

要注意s只有4个元素，s[2]又是一个list。

        p=['asp','php']
        s=['python','java',p,'scheme']

要拿到’php’可以写成p[1]或者s[2][1],因此s可以看成JAVA中的二维数组，还有三位、四维、五维…..，不过很少用到
如果一个list中一个元素也没有，就是一个空的list，它的长度为0：

        L=[]
        len(L)
        0

另外有一种有序列表叫元组：tuple。
tuple和list非常类型，但是tuple一旦初始化就不能修改，比如同样是列出同学的名字：

classmates=('Micheal','Bob','Tracy')

现在classmates这个tuple不能改变了，也没有append()、insert()方法。其他获取元素的方法和list一致，可以用classmates[0],classmates[-1],但不能赋值成另外的元素了。
不可变的tuple有什么意义呢？因为tuple不可变，所以代码更安全。如果可能，能用tuple代替list就尽量用tuple。
陷阱：当你定义一个tuple时候，在定义的时候，tuple的元素就必须被确定下来：

                    t=(1,2)
                    t
                    (1,2)

如果要定义一个空的tuple，可以写成():

                    t=()
                    t
                    ()

但是，要定义一个只有1个元素的tuple，如果你这么定义：

                    t=(1)
                    t
                    1

定义的不是tuple，是1这个数，因为()既可以表示tuple，又可以表示数学公式中的小括号。而且，python规定，这种情况下按照小括号计算，结果自然是1。
所以，只有1个元素的tuple定义时必须加上一个逗号，来消除歧义

                    t=(1,)
                    t
                    (1,)

最后来看一个可变的tuple

                    t=('a','b',['A','B'])
                    t[2][0]='X'
                    t[2][1]='y'
                    t
                    ('a','b',['X','y'])

表面上看，tuple的元素确实变了，但变的其实是list的元素。tuple一开始指向的list并没有变成别的list
可以看出，tuple所谓的不变一说，是指tuple的每个元素，指向永远不变。
即指向’a’,就不能改成指向’b’,指向一个list就不能改成指向其他的list，但是指向的这个list是可变的。

---

条件判断：
计算机之所以能进行很多自动化的任务，是因为它可以自己做条件判断。
比如，用户输入年龄，根据年龄打印不同的内容，在Python中，用if语句实现：

    age=20
    if   age>=18;
        print('your age is ',age)
        print('adult')

根据Python的缩进规则，如果if语句判断是true，就把所进的两行print语句执行了，否则什么也不做。
也可以给if添加一个else语句，意思是，如果if判断是false，不要执行if的内容，去把else执行了。

        age = 3
        if age >= 18:
            print('your age is', age)
            print('adult')
        else:
            print('your age is', age)
            print('teenager')

注意不要少写了冒号：。
当然上面的判断是很粗略的，完全可以用elif做更精细的判断：

        age=3
        if age>=18:
            print('adult')
        elif age>=6;
            print('teenager')
        else:
            print('kid')

elif是else if的缩写，完全可以有多个elif，所以语句的完整形式是：

        if<条件判断1>：
            <执行1>
        elif<条件判断2>：
            <执行2>
        elif<条件判断3>：
            <执行3>
        elif：
            <执行4>

if判断可以简写：

        if  x:
            print('True')

只要x是非零数值、非空字符串、非空list等，就判断为True，否则False。

---

循环：

Python中的循环有两种，一种是for….in循环，一次把list或者tuple中的每个元素迭代出来:

    names=['Micheal','Bob','Tracy']
    for  name  in  names:
        print(name)
    Micheal
    Bob
    Tracy

所以for….in循环就是把每个元素带入变量，然后执行缩进快的语句
再如我们想计算1-10的整数之和，可以用sum变量做累加

    sum=0
    for   x   in[1,2,3,4,5,6,7,8,10]:
        sum=sum+x
    print(sum)

要是计算1-100的整数之和,从1写到100有点困难，python有一个range()函数，可以生成一个整数序列，再通过list()函数可以转换为list，比如range(5)生成的序列是从0开始小于5的整数

    list(range(5))
    [0,1,2,3,4]
    range[101]就可以生成0-100的整数序列，计算：
    sum=0
    for  x   in  range(101)
        sum=sum+x
    print(sum)

还有一种循环是while循环，只要条件满足，就不断循环，条件不满足时退出循环。
比如我们要计算100内的所有奇数之和，可以用while循环实现：

    sum=0
    n=99
    while  n>0:
        sum=sum+n
        n=n-2
    print(sum)

在循环变量n不断自减，只到变为-1时不再满足while条件，循环退出。

break：

在循环中，break语句可以提前退出循环。
例如：本来要循环打印1-100之间的数字：

    n=1
    while  n<100
        print(n)
        n=n+1
    print('END')

如果要提前结束循环，可以用break语句：

    n=1
    while n<=100
        if  n>10:
            break
        print(n)
        n=n+1
    print('END')

执行上面的代码可以看到，打印1-10后，紧接着打印END，程序结束。可见break是提前结束循环的作用。

continue

在循环过程中，也可以通过continue语句跳过当前这次循环，直接开始下一次循环，打印1-10：

    n=0
    while  n<  10:
        n=n+1
        print(n)

但是我们执行打印奇数，可以用continue跳过某些循环

    n=0
    while n<10
        n  =n+1
        if  n%2=0
            continue
        print(n)

这下打印的是1,3,5,7,9
如果代码写的有问题陷入死循环，可以Ctrl+C退出程序，或者强制结束Python进程
循环这块与JAVA有着类似的语法和用法，运用的同时也要注意区分语法格式。

---

使用dict和set

Python内置了字典：dict的支持，dict全称为dictionary，在JAVA语言中也称为map，使用键-值(key-value)存储，具有极快的查找速度。
举个例子：假设要根据同学名字查找对应的成绩，如果用list实现，需要两个list

        names=['Michal','Bob','Tracy']
        scores=[98,70,67]

给定一个名字，要查找对应的成绩，就先要在names中找到相应的位置，再从scores取出对应的成绩，list越长，耗时越长
如果用dict实现，只需要一个名字-成绩的对照表，直接根据名字查找成绩，无论这个表有多大，查找速度都不会变慢。
例如：

        d=['Micheal':95,'Bob':75,'Tracy':85]
        d['Micheal']
        95

为什么dict查找速度快？
因为dict的实现原理和查字典是一样的。
假设字典包含了1万个汉字，我们要查某一个字。
一个办法是把字典从第一页往后翻，直到找到我们想要的字为止，这种方法就是在list中查找元素的方法，list越大，查找越慢。
第二种方法是先在字典的索引表里（比如部首表）查这个字对应的页码，然后直接翻到该页，找到这个字。无论找哪个字，这种查找速度都非常快，不会随着字典大小的增加而变慢。
dict就是第二种实现方式，给定一个名字，比如’Michael’，dict在内部就可以直接计算出Michael对应的存放成绩的“页码”，也就是95这个数字存放的内存地址，直接取出来，所以速度非常快。
你可以猜到，这种key-value存储方式，在放进去的时候，必须根据key算出value的存放位置，这样，取的时候才能根据key直接拿到value。
把数据放入dict的方法，除了初始化时指定外，还可以通过key放入：

    d['Admin']=67
    d['Admin']
    67

由于一个key只能对应一个value，所以，多次对一个key放入一个value，后面的值会把前面的值冲掉

    d['Jack']=90
    d['Jack']
    90
    d['jack']=88
    d['Jack']
    88

要是key不存在，dict就会报错。
要避免key不存在的错误，有两种方法，一种是通过in判断key是否存在：

        'Thoms'in d
        False

二是通过dict提供的get()方法，如果key不存在，可以返回None，或者自己指定Value：

        d.get('Thoms')
        d.get('Thoms',-1)
        -1

注意：要是返回None。Python的交互环境不显示结果。
要删除一个key，用pop(key)方法，对应的value也会从dict中删除:

        d.pop('Bob')
        75
        d
        ['Micheal':95,'Tracy':85]

请务必注意：dict内存存放的顺序和key放入的顺序是没有关系的

    和list比较，dict有以下几个特点：
        1.查找和插入的速度极快，不会随着key的增加而变慢；
        2.需要占用大量内存，内存浪费多。       
    而list相反：
        1.查找和插入的时间随着元素的增加而增加
        2.占用空间小，浪费内存小

所以，dict是用空间来换取时间的一种方法。
dict可以用在需要高速查找的很多地方，在Python代码中几乎无处不在，正确使用dict非常重要，需要牢记的第一条就是dict的key必须是不可变对象。
这是因为dict根据key来计算value的存储位置，如果每次计算相同的key得出的结果不同，那dict内部就完全混乱了。这个通过key计算位置的算法称为哈希算法（Hash）。
要保证hash的正确性，作为可以的对象就不能变。