python基础

一、关键字(Keywords)：
 

在python2.7版本中关键字有31个，如下：
and,or,not            #逻辑与或非运算；
with...as            #简化try...except...finally这样的错误处理流程；
assert            #用于在代码中插入断言。声明某个条件为真，如果非真会引发一个错误AssertionError；
break,continue            #常用于for，while等循环语句中，表示中断和继续使用循环；
class            #声明一个类；
def            #定义一个函数；
del            #删除对象；
if...elif...else...            #条件判断语句；
try...except...else/finally...            #用于异常处理功能；
exec            #动态执行python语句或文件；
for,while            #循环语句；
from...import...as...            #用于加载其它模块或指定模块；
global            #声明全局变量；
in            #配合for的使用，也用于判断元素是否在一个序列中；
is,is not            #判断两个对象是否为同一对象；
lambda                #又叫匿名函数，不需要去给函数命名；
pass            #空操作，常用于逻辑判断中；
print            #打印对象；
raise            #产生一个异常；
return            #常用于传递函数返回值；
yield            #python特有的一个关键字，使函数可以像线程一样每次只执行一段。

二、数据类型

字符型(string)
    单引号('...')和双引号("...")括起来的都表示为字符串，三引号('''...'''或"""...""")表示多行的字符串，可以在三引号中使用单引号和双引号;
        字符串转义序列(Escape Sequences)
        \    在结尾处为续行符
        \\    \反斜杠
        \'    单引号
        \"    双引号
        \a    响铃
        \b    退格(Backspace)
        \e    转义
        \000    空
        \n    换行
        \v    纵向制表符
        \t    横向制表符
        \r    回车
        \f    换页
        \oyy    八进制数，yy代表字符，例：\o12代表换行
        \xyy    十六进制数，yy代表字符，例：\x0a代表换行
        \other    其它字符以普通格式输出
        字符串格式化
        %c    格式化字符及其ASCII码
        %s    格式化字符串
        %d,%i    格式化整数
        %u    格式化无符号整型
        %o    格式化无符号八进制数
        %x    格式化无符号十六进制数
        %X    格式化无符号十六进制数(大写)
        %f    格式化浮点数，可指定小数点后的精度。例：a = 1；print "%.3f" % a ;  1.000
        %e，%E    用科学计数法格式化浮点数
        %g    %f和%e的简写
        %G    %f和%E的简写
        %p    用十六进制数格式化变量的地址


布尔类型(bool)
    判断真和假，True(1),False(0);
数字类型(digital)
    类型转换：
    int(x [,base])        #将x转换为一个整数；
    float(x)        #将x转换为一个浮点数；
    complex(real [,imag])        #创建一个复数。complex(1,2) return (1+2j)；
    str(x)        #将对象x转换为字符串；
    repr(x)        #将对象x转换为表达式字符串
    eval(str)        #用来计算在字符串中的有效python表达式，并返回一个对象；
    tuple(s)        #将序列s转换为一个元组；
    list(s)        #将序列s转换为一个列表；
    chr(x)        #将一个整数转换为一个字符。chr(1) return '\x01';
    unichr(x)        #将一个整数转换为Unicode字符。unichr(1) return u'\x01'；
    ord(x)        #将一个字符转换为它的整数值。ord('a') return 97；
    hex(x)        #将一个整数转换为一个十六进制字符串。hex(12) return '0xc'；
    oct(x)        #将一个整数转换为一个八进制字符串。oct(12) return '014'；
    数学函数：
    abs(x)        #返回数字的绝对值，abs(-1) return 1；
    ceil(x)        #返回数字的上入整数，math.ceil(3.14) return 4.0;
    cmp(x,y)        #x < y return -1,x == y return 0,x > y return 1;
    #math函数不能直接使用，需要导入match函数使用，import math；
    exp(x)        #返回e的x次幂， math.exp(1) return  2.718281828459045;
    fabs(x)        #返回数字的绝对值，math.fabs(-1) return 1.0;
    floor(x)        #返回数字的下舍整数，math.floor(3.14) return 3.0;
    log(x)        #返回x的自然对数，math.log(8,2) return 3.0(表示2的3次幂为8);
    log10(x)        #返回以10为底的对数，math.log10(8.2) return 0.9138138523837167(表示10的0.9138138523837167幂为8.2);
    max(x1,x2,...)        #返回给定参数的最大值，参数可以为序列；
    min(x1,x2,...)        #返回给定参数的最小值，参数可以为序列；
    modf(x)        #返回x的整数部分与小数部分，两部分的数值符号与x相同，整数部分以浮点型表示。math.modf(1.1) return (0.10000000000000009, 1.0);
    pow(x,y)        #x**y，x的y次幂；
    round(x [,n])        #返回浮点数x的四舍五入值，如给出n值，则代表舍入到小数点后的位数。round(3.1415,2) return 3.14;
    sqrt(x)        #返回数字x的平方根，数字可以为负数，返回类型为实数。math.sqrt(2) return 1.4142135623730951；

列表(list)
    序列是python中最基本的数据结构。序列中的每个元素都对应一个数字(索引)，第一个索引为0，第二个索引为1，依次类推。列表元素是可变的。
    定义列表：list = ['a',1,2,3,'b']
    列表元素截取：
    list[0] #'a' ;
    list[1:3] #[1,2] ;
    list[1:] #[1, 2, 3, 'b'] ;
    list[-1] #['b'] ;
    list[:-2] #['a', 1, 2] ;
    list[:] #['a', 1, 2, 3, 'b'] ;
    list[0] = "A" #修改列表第一个元素['A', 1, 2, 3, 'b'] ；
    del list[0] #删除列表第一个元素[1, 2, 3, 'b']；
    列表操作符：
    len(list)  #列表长度；
    [1] + [2]  #合并两个列表[1,2] ;
    [1] * 2 #复制(n-1)次列表元素[1,1]；
    1 in [1,2]    #True;  元素是否存在列表中；
    for i in [1,2,3]:print i,  #1 2 3 迭代；
    列表方法：
    list.append(obj)    #在列表末尾添加新的对象；
    list.count(obj)     #统计某个元素在列表中出现的次数；
    list.extend(seq)    #在列表末尾一次性追加另一个序列中的多个值(用新列表扩展原来的列表)；
    list.index(obj)    #从列表中找出某个值第一个匹配项的索引位置，索引从0开始；
    list.insert(index,obj)    #将对象插入对应索引列表；
    list.pop(obj=list[-1])    #移除列表中的一个索引对应的元素(默认最后一个元素)，并且返回该元素的值；
    list.remove(obj)    #移除列表中某个值的第一个匹配项；
    list.reverse()    #反向列表中元素，倒转；
    list.sort()    #对原列表进行排序；

元组(tuple)
    元组与列表类似，不同之处在于元组的元素不能修改；元组使用小括号(),列表使用方括号[];

字典(dictionary)
    字典由键(key)和对应的值(values)组成，字典使用花括号{},键与值必须用冒号(:)隔开。键必须独一无二，但值不必须；值可以取任何数据类型，但必须不可变的。字典又被称作关联数组或哈希表。
    除列表之外python中最灵活的内置数据结构类型。列表是有序的对象结合，字典是无序的对象集合。两者区别：字典当中的元素是通过键(key)来存取，而不是通过偏移存取。
    定义字典：dict = {'a':1,'b':2}  ；
    dict['a']=12    #将键为a的值改为12；
    del dict['a']   #删除键是'a'的条目；
    dict.clear()    #清空词典所有条目；
    del dict     #删除词典；
    字典内置函数：
    cmp(dict1,dict2)    #比较两个字典元素；
    len(dict)    #计算字典元素个数，即键的总数；
    str(dict)    #输出字典可打印的字符串表示；
    type(variable)    #返回输入的变量类型，如果变量是字典就返回字典类型。
    字典方法：
     dict.clear()    #删除字典内所有元素 {}；
     dict.copy()    #返回一个字典的浅复制 dict1 = dict.copy() 将dict字典的元素复制给dict1；
     dict.fromkeys()    #创建一个新字典，以序列seq中元素做字典的键，value(可选)为字典所有键对应的初始值；
            例：seq = ['a','b','c']; dict2 = dict.fromkeys(seq)；dict2 ;{'a': None, 'c': None, 'b': None};
                dict2 = dict.fromkeys(seq,10);dict2 ;{'a': 10, 'c': 10, 'b': 10};
     dict.get(key,default=None)    #返回指定键的值，如果值不在字典中返回default值；
             例：dict.get('a')   '1'
     dict.has_key(key)    #如果键在字典dict里返回True，否则返回False；
             例：dict.has_key('a')    True;
     dict.items()    #以列表返回可遍历的(键，值)元组数组；
             例：dict.items()    [('a', '1'), ('b', 2)];
     dict.keys()    #以列表返回一个字典所有的键；
             例：dict.keys()    ['a', 'b'];
     dict.setdefault(key,default=None)    #和get()类似，但如果键不存在于字典中，将会添加键并将值设为default；
             例：dict.setdefault('c',3)    {'a': '1', 'c': 3, 'b': 2};
     dict.update(dict2)    #把字典dict2的键/值对更新到dict里，如果dict与dict2有相同的键，那么dict2的键/值将覆盖所有与dict对应的键/值；
             例：dict2 = {'a': 10, 'c': 10, 'b': 10}；
                 dict.update(dict2)    {'a': 10, 'c': 10, 'b': 10, 'd': None};
     dict.values()    #以列表返回字典中的所有值；
             例：dict.values()    ['1', 2];
集合(set)
    是一个无序不重复元素集，基本功能包括关系测试和消除重复元素。
    集合对象支持并集(union),交集(intersection),差集(difference),对称差集(sysmmetric difference)等数学运算。
    还支持x in set,len(set)和for x in set。作为一个无序集合，set不记录元素位置或者插入点。set不支持索引('set' object does not support indexing),切片(slicing),或其它类序列(sequence-like)。
     x = set('hello')
     y = set('world')
     z = set('o')
     x & y    #x.intersection(y)交集set(['l', 'o'])
     x | y    #x.union(y)并集set(['e', 'd', 'h', 'l', 'o', 'r', 'w'])
     x - y    #x.difference(y)差集set(['h', 'e'])
     y - x    #set(['r', 'd', 'w'])
     x ^ y    #x.symmetric_difference(y)对称差集set(['e', 'd', 'h', 'r', 'w'])
     len(x)   #去重后长度4
     len(y)   #5
     'h' in x #True
     'z' not in y #True
     z.issubset(x)    #True,z是x的子集
     x.issuperset(z)  #True,x是否包含z

日期(date)
    获取当前时间需要导入相应的时间模块；
    import time,datetime;
    time.localtime()    #查看本地时间；
        time.struct_time(tm_year=2016, tm_mon=7, tm_mday=26, tm_hour=18, tm_min=0, tm_sec=0, tm_wday=1, tm_yday=208, tm_isdst=0)；
     #tm_year(年)，tm_mon(月),tm_mday(日)，tm_hour(小时),tm_min(分钟) ,tm_sec(秒),tm_wday(周的第几天0-6，1是周二),tm_yday(一年中的第几天，这里是208天),tm_isdst(夏令时，-1,0,1；-1是决定是否为夏令时的旗帜，0表示正常格式，1表示为夏令时格式)；
    获取格式化的时间：
    time.strftime('%Y-%m-%d %H:%M:%S')    #字符串格式输出时间'2016-07-26 18:20:00'
    datetime.datetime.strftime(datetime.datetime.now(), '%Y-%m-%d %H:%M:%S')    #'2016-07-26 18:20:00'
    str(datetime.datetime.now())[:19]    #[:19]表示输出日期的长度；'2016-07-26 18:20:00'
    time.asctime(time.localtime(time.time()))    #'Wed Jul 27 10:37:09 2016'
    time模块下的内置函数：
        time.altzone    #返回格林威治西部的夏令时地区的偏移秒数。
        time.asctime([tupletime])    #接受时间元组并返回一个可读的形式为'Wed Jul 27 10:45:55 2016'的24个字符的字符串；
        time.clock()        #用浮点数计算的秒数返回当前的CPU时间。用来衡量不同程序的耗时，比time.time()更有用。
        time.ctime([secs])        #作用相当于asctime(localtime(secs)),未给参数相当于asctime();
        time.qmtime([secs])        #接受时间戳(1970纪元后经过的浮点秒数)并返回格林威治天文时间下的时间元组t。t.tm_isdst始终为0；
        time.localtime([secs])        #接收时间戳并返回当地时间下的时间元组t(t.tm_isdst可取0或1，取决于当地当时是不是夏令时)；
        time.mktime(tupletime)        #接收时间元组并返回吃俭戳；
        time.sleep(secs)        #推迟调用线程的运行，secs指秒数；
        time.strftime(str,fmt='%a%b%d%H:%M:%S%Y')        #根据fmt的格式把一个时间字符串解析为时间元组；
        time.time()        #返回当前时间的时间戳；
        time.tzset()        #根据环境变量TZ重新初始化时间相关设置；
        time.timezone        #属性time.timezone是当地时区(未启动夏令时)距离格林威治的偏移秒数(>0,美洲；<=0大部分欧洲，亚洲，非洲)；
        time.tzname        #属性time.tzname包含一对根据情况的不同而不同的字符串，分别是带夏令时的本地时区名称，和不带的；

    日历(calendar)模块：import calendar;
            calendar.calendar(year,w=2,l=1,c=6)        #返回一个多行字符串格式的year年历，3个月一行，间隔距离为c。每日宽度间隔为w字符。每行长度为21*w+18+2*c。l是每星期行数；
            calendar.firstweekday()        #返回当前每周起始日期的设置。默认情况下，首次载入calendar模块时返回0，即星期一；
            calendar.isleap(year)        #是闰年返回True，否则为False；
            calendar.leapdays(y1,y2)        #返回在y1，y2两年之间的闰年总数；
            calendar.month(year,month,w=2,l=1)        #返回一个多行字符串格式的year年month月日历，两行标题，一周一行。每日宽度间隔为w字符。每行长度为7*w+6.l是每星期的行数；
            calendar.monthcalendar(year,month)        #返回一个整数的单层嵌套列表。每个子列表装载代表一个星期的整数。year年month月外的日期都设为0；范围内的日子都由该月第几日表示，从1开始。
            calendar.monthrange(year,month)        #返回两个整数。第一个是该月的星期几的日期码，第二个是该月的日期码。日从0(星期一)到6(星期日)；月从1到12；
            calendar.prcal(year,w=2,l=1,c=6)        #相当于 calendar.calendar(year,w,l,c);
            calendar.prmonth(year,month,w=2,l=1)        #相当于calendar.calendar(year,w,l,c);
            calendar.setfirstweekday(weekday)        #设置每周的其实日期码。0(星期一)到6(星期日)；
            calendar.timegm(tupletime)           #和time.gmtime相反；接受一个时间元组形式，返回该时刻的时间戳；
            calendar.weekday(year,month,day)        #返回给定日期的日期码。0(星期一)到6(星期日)；月份为1到12；

三、python操作符
    

算数运算符：
    +    加法
    -    减法
    *    乘法
    /    除法
    %    取模，求余数
    **    指数，求幂
    //    地板除(整除)

比较操作符：
    ==    相等
    !+和<>    不等
    >    大于
    <    小于
    >=    大于等于
    <=    小于等于

赋值运算符：
    =    赋值
    +=    加赋值
    -=    减赋值
    *=    乘赋值
    /=    除赋值
    %=    模赋值
    **    幂赋值
    //=    整除赋值

位运算符：
    &    按位与运算符，参与运算的两个值，如果两个相应位都为1，则该位结果为1，否则为0；例：12(1100) & 5(0101) = 4(0100);
    |    按位或运算符，只要对应的两个二进位有一个为1时，结果就为1。例：12(1100) | 5(0101) = 13(1101);
    ^    按位异或运算符，当两个对应的二进位相异时，结果为1。12(1100) ^ 5(0101) = 9(1001);
    ~    按位取反运算符，对数据的每个二进制位取反，即把1变为0,0变为1。在一个有符号二进制数的补码形式。例：~12 = -13；~x = -(x+1)。
    <<    左移动运算符，运算数的各二进位全部左移若干位，由"<<"右边的数指定移动的位数，高位丢弃，低位补0。例：12(0000 1100) << 2 =  48(0011 0000)；
    >>    右移动运算符，把">>"左边的运算数的各二进位全部右移若干位，">>"右边的数指定移动的位数。例：12(0000 1100) >> 2 = 3(0000 0011)；


逻辑运算符：
    and    布尔"与"，如果x为False，x and y返回False，否则它返回y的计算值。 例：12 and 5 返回5；0 and 5 返回0；
    or     布尔"或"，如果x是非0，它返回x的值，否则它返回y的计算值。例：12 or 5 返回12；0 or 5 返回5；
    not    布尔"非"，如果x为True，返回False。如果x为False，返回True。例：not 1 返回False；not0 返回True；not None 返回True；

成员运算符：
    in    如果在指定的序列中找到值返回True，否则返回False。
    not in    如果在指定的序列中没有找到值返回True，否则返回False。
标识运算符：
    is    判断两个标识符是不是引用自一个对象。x is y，如果id(x)等于id(y)，is返回结果1；
    is not    判断两个标识符是不是应用自不同对象。x is not y，如果id(x)不等于id(y)，is not返回结果为1；