对于Python的一些基本知识

一.python变量和数据类型
1）.对于python中字符串是以''或“”括起来的文本。
2）.对于空值来说，python是以“None”表示的，但是None不能理解为0；因为0是有意义的，而None是一个空值。
3）.python的print语句
    python的print语句是可以用来向屏幕上输出指定的文字，在python中如果想要输出字符串，列如：>>>print 'hello','python' 则逗号将会作为
    空格输出，如果是>>>print 'hello,python'则逗号还是逗号输出。
4）.python的注释
    对于python的注释是以“#”开头。
5）.python中的变量
    变量必须是大小写英文字母，数字和下划线的组合，且不能用数字开头。
6）.python中定义字符串
     如果想要输出的字符串中包含‘ 怎么办，比如想要输出I'am OK这时候可以用 "" 括起来表示，相反，如果字符串包含 ",我们可以用 '' 括起来表示。
     如果字符串既包含 "" 又包含 ',这时候我们需要使用转义字符 \ .比如输出  Bob said "I'am OK" 这一串字符串，我们就可以使用>>>print
      'Bob said \"I\'am OK\".'
7). python中raw字符串与多行字符串
    如果一个字符需要很多转义的字符，这时候对每一个字符都要进行转义的话很太麻烦 ，这时候可以在字符串的前面加上 r 此时就不需要进行转义，而
     且r不能包含 ' 和 " 的字符串，但是r  不能表示多行字符串，这时候需要使用 ''' '''来进行表示。 列如：>>>print '''Line 1
                                                                                                               Line 2
                                                                                                               Line 3 ''' 上面的字符
     串的表示方法和下面的表示是完全一样 >>>print 'Line 1\nLine 2\nLine 3\n' 。其中还可以在多行字符串面前添加 r .

8).Python中Unicode字符串
   如果想要输出中文，需要在输出的字符串前加上一个字母u。列如>>>print u'王梦多'，如果不加，则中文就无法显示。如果中文字符串在Python环境下
    遇到 UnicodeDecodeError，这是因为.py文件保存的格式有问题。可以在第一行添加注释 #_*_ coding: utf-8 _*_ 此目的是为了告诉Python解释器用
     UTF-8编码读取源码。
9）.Python中的布尔类型    
     在Python的布尔类型中，0，空字符串 ''和None会被看成fale，其他数值和非空数值都被看成True。（在Python中是没有&&和||符号的只有and和or符号）

二. List和Tuple类型

1).Python创建list
   list是Python内置的一种数据类型，列表。直接用 [] 把list的所有元素都括起来，就是一个list对象，list的表示通常这样用：L=[1,3,'wang'],由于
    Python是一种动态语言，所以List中包含的元素并不要求都必须是同一种数据类型。一个元素也没有的list，就是空list >>L_empty=[];
2).Python按照索引访问list
   list中的索引是从0开始的，也就是说n的元素的最后一个元素的索引是n-1;
3).Python之倒序访问list.
   对于Python中访问list中元素的方法通常是正序访问，如 L=['wang','meng','duo']，如果我们想要输出 duo这个字符串，输出L[2]就可以了，但使用倒
   序的方法同样可以找到此元素此元素是L[-1],然后依次是L[-2],l[-3],倒序使用时要注意list的边界，注意不要越界。
4).Python之添加新元素
   如果在一个已经存在的list中添加一个新元素，列如：存在一个list，L=['wang','meng','duo']；此时要添加一个元素 li,这时候我们如果要添加此元素
   到list的尾部，可以使用append()方法，当使用 L.append('li')函数后，此时的list变为L=['wang','meng','duo','li']；如果我们想要添加到list的
   任意位置，这时候我们需要使用insert()函数，其中此函数一共有两个参数，第一个参数是索引号，第二个参数是要待添加的新元素。列如，想要 li这个元
   素添加到首位，此时我们可以使用 L.insert(0,'li')来添加，结果为L=['li','wang','meng','duo'];
5).Python从list中删除元素
    此时我们需要使用pop（）函数来实现对list中的元素进行删除。列如：存在一个list，L=['wang','meng','duo']；如果想要删除第一个元素，此时使用
     L.pop(0)进行删除，此时L=['meng','duo'];
6).Python中替换元素
   如果想要替换list中的元素，只需要list中的某一个索引赋值，就可以替换，同样，也可以用-1开始做索引
7).Python之创建tuple
   tuple指一种有序的列表，tuple和list非常类似，但是，tuple一旦创建完毕，就不能做更改，tuple的表现形式是>>>t=('wang','meng','duo'),tuple和
   list的表现形式不同是用（）代替了[],同时tuple没有append()和insert()函数，同时tuple可以使用t[-1]做索引，却不能赋值；
8).Python值创建单元素tuple
   包含0个元素的tuple，也就是空tuple，直接用（）表示。如果创建一个元素，列如：>>>t=(1)
                                                                            >>>print t 此时结果为 1 ，而不是(1),由于此时(1)被Python解释器
   计算成结果整数1，造成歧义，这时候为了区分，规定如果tuple是单元素是需要加“，”列如：>>>t=(1,)
                                                                                    >>>print t  此时的结果则就会是(1,)
9).Python之“可变”的tuple
   正如我们所知tuple一旦创建就不能修改，但是如下 >>>t=('a','b',['c','d'])此时t一共有三个元素，'a','b'和list:['c','d'],但此时list却是可以发
   生改变的，tuple所指的不变是指向不变，使用len()函数计算长度。

三.条件判断和循环

1）.Python之if语句
    在Python中具有相同缩进的代码被视为一个代码块。其中在if语句后接表达式，然后用 ： 表示代码块开始
2）.Python之if-else
    注意else后边同样需要 ：表示代码块开始。
3）.Python之if-elif-else
4）.Python之for循环
    对于如果想要访问list或tuple中的每一个元素，这时候会用到循环,而for循环可以依次把list和tuple的每个元素迭代出来列如 L=['wang','meng','duo']
    for name in L:
        print name      其中如果in后跟L,那name的值是从1开始的，如果in后跟的值是有一定范围range(n),那name是从0开始的，到n-1结束。name这个变量
    是在for循环中定义的，意思是，依次取出list中的每一个元素，并把元素赋给name，然后执行for循环（就是缩进的代码块）。
5）.Python之while循环
    while循环不会迭代lsit和tuple的元素，而是根据表达式判断循环是否结束。while表达式如下：  while 判断语句 ：
    其中Python中不支持自加(++)，自减(--),但是支持（+=，-=）
6). Python之多重循环   列如：   for x in ['a','b','c']：                      结果为  a1 a2 a3 b1 b2 b3 c1 c2 c3
                                      for y in ['1','2','3']：           
                                             print x+y
三. Dict和Set类型

1). Python之什么是dict
    对于list和tuple可以用来表示顺序集合，例如班里的同学名字，但是同时如果想要根据名字查找对应的成绩，这是就用到了dict,列如用名字代表dict“名
    字”，成绩的查找如下 d={'wang':95,'li':85,'liu',59},此时我们把名字惩恶为key,对应的成绩称为value，其中len()函数可以计算任何集合的大小。
2),Python之访问dict
    通过使用简单的d[key]的形式来查找对应的value，但是如果key访问的dict不存在，会报错：KeyError,如果想要避免访问不存在情况法发生可以使用：一
    先判断key值是否存在，用in操作符 if 'wang' in d     print d['wang']   二。使用dict本身提供的一个get方法，在Key不存在的时候，返回Mone，列如：
    >>>print d.get('wang')
       95
    >>>print d.get('sun')
       None
3).Python中dict的特点
   dict的第一个特点就是查找速度快，与元素的个数多少无关，而list的查找速度会随元素个数增多而下降。但是dict的缺点是占用内存大，还会良妃很多内容，
   list则相反。dict存储无序，而且dict作为key的元素必须不可变。
4）.Python更新dict
    如果想要在dict中增加dict，这时候只需要赋值语句就可以，如果dict中存在已有的key值，则会替换掉原来的value.例如： >>>d['zhang']=40 这样就能
    添加到已有的dict中
5）.Python之遍历dict
    直接使用for循环可以遍历dict的key,
6). Python中什么是set
    对于dict中的key是不能重复的，同样set也一样。创建set的方式是调用set()并传入一个list，list的元素将作为set的元素。列如： >>>s=set([''A,'B',
     'C'])可以查看set的内容 >>>print s  结果为set(['A','C','B']) .请注意上述打印的形似list但不是list，其中打印的顺序和原始list的顺序有可能
     是不同的，因为set内部存储的元素是无序的。如果set中包含重复的元素，set会自动去掉重复的元素，、
7）.Python之访问set
    因为set存储的是无序集合，所以我们不能通过索引来访问，这时可以通过in操作符来进行判断。其中大小写不一样
8）.Python之set特点
    set内部结构和dict很像，但是却不存在value,因此判断一个元素是否在set中速度很快，而且set存储的元素必须是不变元素。
9）.Python之遍历set
    对于遍历set和list类似，都可以通过for来实现。
10).Python之更新set         
    添加新元素时，可以使用set的add()方法，但是如果添加的元素存在，add()不会报错，而且不会添加进去。删除元素时，可以以使用remove()方法。但是如
    果要删除的元素不存在，remove()会报错。所以用add()可以直接添加，而remove()前需要判断

四。函数
 
1）.Python之调用函数
    定义函数需要使用 def语句，一次写出函数名，括号，括号中的参数和冒号然后在缩进块中编写函数体，函数的返回值和return语句返回。列如：
    def 函数名（参数）：
2）.Python之返回多值
    当需要返回多值时，可以使用return 返回值1，返回值2。。。  但是接收的时候只需要一个未知数来接受，因为其实Python函数返回值是单一组，但是当
    返回多值时其实就是返回一个tuple. 
3）.Pyhton默认参数
    对于Python的参数问题，有时候有默认参数，列如：Python自带的int()函数，其实有两个参数，>>>int('123',8) 结果为83 ，默认参数时是将字符型转
    换为十进制数，而如果加入第二个参数是将转化为八进制数。
    但是如果我们需要使用默认参数时必须定义在必须参数的后边，列如： def fn1(a,b=1,c=1) #OK   def fn2(a=1,b) #ERROR
4).Python之定义可变参数
   定义可变参数的目的是为了让一个函数能够接受任意个参数 格式为：  def fn(*args): 可变参数前需要有个*号，Python会把传入的一组参数组装成一个
   tuple传递给可变参数，因此，可以把函数内部的args看成是一个tuple。   列如： def average(*args):
                                                                              sum = 0.0
                                                                              if len(args) == 0:
                                                                                  return sum
                                                                              for x in args:
                                                                                 sum = sum + x
                                                                              return sum / len(args)
                                                               print average()
                                                               print average(1, 2)
                                                               print average(1, 2, 2, 3, 4)
五.切片

1）.对list进行切片。
   取一个list的部分元素时非常常见的操作，经常或许我们会使用for循还截取，列如： L=['wang','meng','duo','shi']
                                                                               r=[]
                                                                               for i in range(3)
                                                                                     r.append(L[i])
                                                                               print r                    结果为 ['wang','meng','duo']
   但是使用for循环对于取指定索引范围的操作太麻烦，所以Python提供了切片（Slice）操作符 L[0:3],它表示从索引0开始，直到索引3为止，但不包括索引
   3，即索引0，1，2，刚好三个元素，如果第一个元素是0，还可以省略如： L[:3]。如果只用一个：即L[:]，则表示从头到尾，实际是复制了一个list
2）.Python之倒序切片
   倒叙切片同样和正序一样，只不过是序列从最小开始，列如：  [-5] [-4] [-3] [-2] [-1]
                                                         [0]   [1]  [2]  [3]  [4] 对于L=[1,2,3,4,5]如果想要最后一个元素，L[-5:]，则第二个
   元素需要省略，因为L[:]中的数据切片只能切到第二个元素的n-1个数。
3）.对字符串切片
    字符串 'xxx'和 Unicode字符串 u'xxx'也可以看成是一种list，每个元素就是一个字符。因此，字符串也可以用切片操作，只是操作结果仍是字符串：
    字符串变大函数 'abc'.upper()  结果为'ABC'

五。迭代
 
1）.关于迭代
    有序集合：list,tuple,str,和unicode. 无序集合：set 。 无序并且具有key-value对：dict
2）.索引迭代
     zip()函数可以将两个list合并成一个list,列如：>>> zip([10, 20, 30], ['A', 'B', 'C']) ，合并之后[(10, 'A'), (20, 'B'), (30, 'C')]
     如果想再for循环中输出索引，这时我们可以使用enumerate()函数，
     enumerate函数说明：
     函数原型：enumerate(sequence)，其中此函数还可以有第二个参数，代表下标开始的位置
     功能：将可循环序列sequence以start开始分别列出序列数据和数据下标
     即对一个可遍历的数据对象(如列表、元组或字符串)，enumerate会将该数据对象组合为一个索引序列，同时列出数据和数据下标
      >>> L = ['Adam', 'Lisa', 'Bart', 'Paul']
      >>> for index, name in enumerate(L):
    举例说明：
       存在一个sequence，对其使用enumerate将会得到如下结果：
        start        sequence[0]
        start+1　 sequence[1]
        start+2    sequence[2]......
  实际上，enumerate()函数像是把['Adam', 'Lisa', 'Bart', 'Paul']变成了[(0, 'Adam'), (1, 'Lisa'), (2, 'Bart'), (3, 'Paul')]，因此迭代的每
  一个元素实际上是一个tuple
   for t in enumerate(L):
      index = t[0]
      name = t[1]
      print index, '-', name
3）.迭代dict的value
     对于dict对象本身就是可迭代对象，用for循环进行迭代，每次拿到dict的一个key。如果我们想要迭代dict的value，这时dict对象提供了一个values()
     方法，此方法能够把dict对象转换成一个包含所有value的list,此时我们迭代的就是dict的每一个value。
      列如：  d = { 'Adam': 95, 'Lisa': 85, 'Bart': 59 }·
                 print d.values()
                 #结果为 [85, 95, 59]
                for v in d.values():    .....
      对于itervalues（）有和values()同样的作用。但是itervalues()方法不会转换成包含value的lsit，它会在迭代的过程中依次从dict中取出value。
      所以itervalues（）方法比values（）方法节省了生成list所需的内存。
4).迭代dict的key和value
   使用dict对象的items()方法，d={'wang':95,'meng':85,'duo':59}  print d.items()结果为 [('meng',85),('wang',95),('duo',59)],此时，items()
    方法把dict对象转换成了包含tuple的list. 然后如果使用for循环其实就是迭代list，列如：for key,value in d.items(): 和items()方法同样有一个
    iteritems()方法,同样iteritems()函数不把dict转换成list。

六。列表生成式

1）.生成列表
    对于list[1,2,3,4,5,6,7,8,9],如果想要生成[1*1,2*2,3*3,4*4.....]，一种方法是使用for循环的方法，列如：
    L=[]
    for x in range(1,10):
       L.append(x*x)             此时的结果就是想要生成的结果。但是使用这样的for循环太麻烦，于是列表生成式则可以使用一行代码就生成想要的
    list,列如： [x*x for x in range(1,10) ],这种写法就是python中的列表生成式
2）.复杂表达式
    对于python中的%,其中字符串可以通过%进行格式化，使用指定的参数代替%s,字符串的join方法可以把一个list拼成一个字符串
3）.条件过滤
     对于列表生成的for循环还可以加上if判断，列如：[x*x for x in range(1,11)if x%2==0]
      列如：  编写一个函数，他接受一个函数，然后把list中的所有字符串变成大写后返回。非字符串元素将会忽略。
        def toUppers(L):
             return [x.upper() for x in L if isinstance(x,str)==True]
        print toUppers(['Hello', 'world', 101])    字符串的upper()方法可以返回大写的字母。 isinstance(x,str)可以判断变量x是否是字符串。
4）.多层表达式
     for循环可以嵌套，因此在列表生成式中，同样可以使用多层for循环 [m + n for m in 'ABC' for n in '123']  结果：['A1', 'A2', 'A3',
      'B1', 'B2', 'B3', 'C1', 'C2', 'C3']同样也可以使用如下方式：  L = []
                                                                    for m in 'ABC':
                                                                        for n in '123':
                                                                            L.append(m + n)