python 基础一

 Python代码的缩进规则，4个空格，不要使用Tab，更不要混合Tab和空格

数据类型

整数        正负整数

浮点数     浮点数也就是小数，之所以称为浮点数，是因为按照科学记数法表示时，一个浮点数的小数点位置是可变的

字符串     以''或""括起来的任意文本

布尔值     true和false

空值         空值是一个特殊的值，用None表示。None不等于0，因为0是有意义的，而None是一个特殊的空值。

列表list     一种有序的集合，可以随时添加和删除其中的元素。

元组tuple   另一种有序的列表，中文为“ 元组 ”。tuple 和 list 非常类似，不同在于tuple长度和指向永远无法改变。

字典dict      类似json  {key:value,key:value,key:value}

集合set      set 持有一系列元素，这一点和 list 很像，但是set的元素没有重复，而且是无序的，这点和 dict 的 key很像

整数和浮点数

1、整数与整数运算结果仍然是整数，浮点数与浮点数运算结果仍然是浮点数

2、整数和浮点数混合运算的结果是浮点数

3、%号的用法

格式	解释	用法
%s	字符串输出 (采用 str()的显示)	print('用法%s用法' %('用法'))
%(±n)s	在字符串的左右输出至少n个字符, 不够用空格补齐  %±10s: ,+: 右, -: 左	print('用法%10s用法' %('空格') ) print('用法%-10s用法' %('空格') )
%d	整数输出	print('用法%d用法' %(123))
%(±n)d	与%(num)s相似，输出的是整数	print('用法%10d用法' %('空格') ) print('用法%-10d用法' %('空格') )
%f	浮点数输出	print('用法%f用法' %(123.12))
%.(±n)f	保留 n 位小数	print('用法%.2f用法' %(123.123))
%(±n).f	在数字的左右输出至少n个字符, 不够用空格补齐,  %±10s: ,+: 右, -: 左 ,然后四舍五入	print('用法%10.f用法' %(123.1) ) print('用法%-10.f用法' %(123.5) )
%r	字符串 (采用 repr()的显示)
%c	单个字符
%b	二进制整数
%i	十进制整数
%o	八进制整数
%x	十六进制整数
%e	指数 (基底写为e)
%E	指数 (基底写为E)
%F	浮点数，与上相同
%g	指数(e)或浮点数 (根据显示长度)
%G	指数(E)或浮点数 (根据显示长度)
%%	字符”%”

字符串-----raw字符串与多行字符串

1、raw字符串  r''或r"" ,如果一个字符串包含很多需要转义的字符，里面的字符就不需要转义了
    r'\(~_~)/ \(~_~)/'
2、多行字符串   '''...''' ,不需用\n换行，直接回车到下一行
    '''Line 1
    Line 2
    Line 3'''
3、raw多行字符串  r'''...''',  单双引号无需转义，换行直接回车
    r'''Python is created by "Guido".
    It is free and easy to learn.
    Let's start learn Python in imooc!'''
4、unicode字符串  u''或u""       存在中文的时间需要用u
    u'中文\n日文\n韩文'
5、unicode多行字符串   u'''...'''    存在中文的时间需要用u，常用的ru'''...'''与r'''...'''区别在于ru可以有中文
    ur'''Python的Unicode字符串支持"中文",
    "日文",
    "韩文"等多种语言''
6、字符串拼接：直接拼接，‘+’加号拼接，‘,’逗号拼接，逗号拼接会转换成空格
    'abc' 'efg' = 'abcdef'
    'abc'+'efg' = 'abcdef'
    'abc','efg' = 'abc def'
 

布尔值

与运算：只有两个布尔值都为 True 时，计算结果才为 True

True and True   # ==> True
True and False   # ==> False
False and True   # ==> False
False and False   # ==> False

或运算：只要有一个布尔值为 True，计算结果就是 True

True or True   # ==> True
True or False   # ==> True
False or True   # ==> True
False or False   # ==> False

非运算：把True变为False，或者把False变为True

not True   # ==> False
not False   # ==> True

真假值：Python把0、空字符串''和None看成 False，其他数值和非空字符串都看成 True

短路计算：

1. 在计算 a and b 时，如果 a 是 False，则根据与运算法则，整个结果必定为 False，因此返回 a；如果 a 是 True，则整个计算结果必定取决与 b，因此返回 b。

2. 在计算 a or b 时，如果 a 是 True，则根据或运算法则，整个计算结果必定为 True，因此返回 a；如果 a 是 False，则整个计算结果必定取决于 b，因此返回 b。

所以做布尔运算时，只要能提前确定计算结果，它就不会往后算了，直接返回结果。

list列表

    L = ['Adam', 'Lisa', 'Bart']
#正序访问list内元素，通过下标访问，从0开始
    L[0]
#倒序访问list内元素，能过下标访问，从-1开始
    L[-1]
#添加元素有两种，末尾添加append(值);  任意位置添加insert(下标，值);
    L.append('Tom')
#删除元素，pop(下标)，不填下标默认删除最后一个，下标从0开始
    L.pop(2)
#修改元素，直接按下标用=修改
    L[2] = 'Rose'

tuple元组 与list类似  

tuple的每个元素，指向内存永远不变，当元素为list时，list里的值是可变的

    T = ('Adam', 'Lisa', 'Bart')
1、单元素tuple ('Adma',),单元素时需要添加,否则python会把()认为是优先级运算
    T = ('Adam',)
2、可‘变’tuple，当tuple内的元素是list类型时，list类型的元素是可变的
    T = (['a','b','c'],'a','b')
    T[0][0] = 'd'

set集合   

    s = ([’cat‘，'dog'，'pig']) 
#与list相似，但是元素不能重复，且元素是无序的，且元素类型必须不可变   

#'pig' in s 返回True 判断一个元素是否在set中速度很快
    print 'pig' in s
#s.add('panda')可以直接添加，而remove('pig')前需要判断，因为删除的元素不存在会报错。
    if 'pig' in s:
        remove('pig')

dict字典 类似js对象 

dict的特点：查找速度快,占用内存大,key不能重复,key-value序对是没有顺序的， key 的元素类型必须不可变

    {key:value,key:value,key:value}

#d[key] 获取 value

#d.get('key') 获取 value

#if 'key' in d 判断 key是否存在，用于防止错误

变量

变量是用一个变量名表示，变量名必须是大小写英文、数字和下划线（_）的组合，且不能用数字开头

变量分动态语言和静态语言，默认是动态，静态语言就是固定类型的变量，在变量前加int，str等关键字

if条件判断   if...else   if...elif...else

循环 

1、for循环  for x in L:  

2、 while循环  while 条件:   条件成立继续执行循环，不成立则退出循环 

3、break退出循环

4、continue跳过后续循环代码，继续下一次循环

定义函数 

def 函数名(参数):
    def test1(a,b):
        return a+b
可以返回多个值 return x,y,z    
    def test2(a,b,c):
        return a,b,c
def 函数名(*参数名)  可传入多个参数，参数个数自定义
    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)

切片  [参数:参数:参数]

有三个参数 分别表示，起始下标，结束下标，每N个取一个

#对list切片  取出3的倍数  
    list = [1,2,3,4,5,6,7,8,9,10]
    print list[2,10,3]
    [3,6,9]
#对字符串切片   可以把字符串看成是list    
    str = 'hello world'    
    print str[0:5]     
    'hello'

迭代 ----迭代永远是取出元素本身，而非元素的索引

1、python的迭代 是一个动词，实际就是for循环这个动作，下面是可以迭代的集合

有序集合：list，tuple，str和unicode；
无序集合：set
无序集合并且具有 key-value 对：dict

2、索引迭代  利用enumerate转换为tuple

L = ['Adam', 'Lisa', 'Bart', 'Paul']
#enumerate()函数把集合转换为tuple
#enumerate(L) = [(0, 'Adam'), (1, 'Lisa'), (2, 'Bart'), (3, 'Paul')]
for index, name in enumerate(L):
    print index, '-', name

3、迭代dict的value   values()跟itervalues()效果一样，itervalues()更省内存

d = { 'Adam': 95, 'Lisa': 85, 'Bart': 59 }
print d.values()
# [85, 95, 59]
for v in d.values():
    print v
print d.itervalues()
# [85, 95, 59]
for v in d.itervalues():
    print v

4、迭代dict的key和value    items()把dict转换为包含tuple的list   iteritems()不转换为list在迭代过程中不断给出 tuple 更省内存

d = { 'Adam': 95, 'Lisa': 85, 'Bart': 59 }
print d.items()   #[('Lisa', 85), ('Adam', 95), ('Bart', 59)]
for key, value in d.items():
    print key, ':', value
for key, value in d.iteritems():
    print key, ':', value

生成列表

把要生成的元素 x * x 放到前面，后面跟 for 循环，就可以把list创建出来

[x * x for x in range(1, 11)]
[1, 4, 9, 16, 25, 36, 49, 64, 81, 100]

条件过滤，列表生成式的 for 循环后面还可以加上 if 判断

[x * x for x in range(1, 11) if x % 2 == 0]
[4, 16, 36, 64, 100]

for循环可以嵌套，因此，在列表生成式中，也可以用多层 for 循环来生成列表。

[m + n for m in 'ABC' for n in '123']
['A1', 'A2', 'A3', 'B1', 'B2', 'B3', 'C1', 'C2', 'C3']

函数式编程：

不是纯函数式编程：允许有变量

支持高阶函数：函数也可以作为变量传入

支持闭包：有了闭包就能返回函数

有限度的支持匿名函数

map(f,list)

接收一个函数 f 和一个 list，并通过把函数 f 依次作用在 list 的每个元素上，得到一个新的 list 并返回。

注意：map()函数不改变原有的 list，而是返回一个新的 list。

#把list按首字母大写其他小写，按首字母排序
def format_name(s):
    return s[0].upper() + s[1:].lower()
print map(format_name, ['adam', 'LISA', 'barT'])  ###['Adam', 'Lisa', 'Bart']

reduce(f,list,num) 

接收一个函数 f，一个list，但行为和 map()不同，reduce()传入的函数 f 必须接收两个参数，reduce()对list的每个元素反复调用函数f，并返回最终结果值

def f(x, y):
    return x + y
print reduce(f, [1, 3, 5, 7, 9])      ###25
#当只有2个参数的时候
#先计算头两个元素：f(1, 3)，结果为4；
#再把结果和第3个元素计算：f(4, 5)，结果为9；
#再把结果和第4个元素计算：f(9, 7)，结果为16；
#再把结果和第5个元素计算：f(16, 9)，结果为25；
#由于没有更多的元素了，计算结束，返回结果25。

当有3个参数的时候，
print reduce(f, [1, 3, 5, 7, 9], 100)      ###125
#先计算头两个元素：f(100，1)，最终结果为125

filter(f,list) 过滤函数

接收一个函数 f 和一个list，这个函数 f 的作用是对每个元素进行判断，返回 True或 False，filter()根据判断结果自动过滤掉不符合条件的元素，返回由符合条件元素组成的新list。

#过滤出1~100中平方根是整数的数
import math
def is_sqr(x):
    print math.sqrt(x) % 1             ###传入的数开根后余1，无小数则符合条件
    return math.sqrt(x) % 1 == 0       ###判断余数为0 则是
print filter(is_sqr, range(1, 101))

sorted() 自定义排序函数

接收一个比较函数来实现自定义排序，比较函数的定义是，传入两个待比较的元素 x, y，如果 x 应该排在 y 的前面，返回 -1，如果 x 应该排在 y 的后面，返回 1。如果 x 和 y 相等，返回 0。

#忽略大小写排序，先将要排序的字符串转小写再排序
def cmp_ignore_case(s1, s2):
    u1 = s1.upper()
    u2 = s2.upper()
    if u1 < u2:
        return -1
    if u1 > u2:
        return 1
    return 0
print sorted(['bob', 'about', 'Zoo', 'Credit'], cmp_ignore_case)

返回函数

返回函数可以把一些计算延迟执行

由于可以返回函数，在后续代码里就可以决定到底要不要调用该函数。

def calc_prod(lst):
    def xx():                      ###定义需要返回的函数
        def prod(x, y):            ###定义计算函数
            return x*y             ###返回计算函数的值
        return reduce(prod,lst)    ###返回循环计算list的函数
    return xx                      ###返回待调用函数
f = calc_prod([1, 2, 3, 4])        ###把返回函数存入变量
#想调用的时候再调用
print f()

闭包

函数内部定义的函数和外部定义的函数是一样的，外部访问调用内部定义的函数

闭包的特点是返回的函数还引用了外层函数的局部变量，所以，要正确使用闭包，就要确保引用的局部变量在函数返回后不能变

#内层函数引用了外层函数的变量（参数也算变量），然后返回内层函数的情况，称为闭包（Closure）。
def calc_sum(lst):
    def lazy_sum():
        return sum(lst)
    return lazy_sum

#要正确使用闭包，就要确保引用的局部变量在函数返回后不能变
def count():
    fs = []
    for i in range(1, 4):
        def f():
             return i*i
        fs.append(f)
    return fs                  ###返回fs的时候i已经变成了3
f1, f2, f3 = count()           ###结果是9,9,9

#以下为正确使用方法
def count():
    fs = []                    
    def f(j):              
        def g():
            return j*j
        return g
    for i in range(1, 4):
        r = f(i)
        fs.append(r)
    return fs
f1, f2, f3 = count()
print f1(), f2(), f3()        ###1，4，9

匿名函数

关键字lambda 表示匿名函数，冒号前面的 x 表示函数参数。

匿名函数有个限制，就是只能有一个表达式，不写return，返回值就是该表达式的结果。

def is_not_empty(s):
    return s and len(s.strip()) > 0
#is_not_empty()改成下面的lambda s:s and len(s.strip()) > 0
print filter(lambda s:s and len(s.strip()) > 0, ['test', None, '', 'str', '  ', 'END'])