python要点

1.数据类型

字符串： ''或""表示单行，写三对符合表示多行， r'这种写法转义符不生效'

布尔值：True, False

空值： None

类型转换

print bool('True'), bool(1), bool(0), bool(''), bool(None)#True True False False False
print int('1')+1, str(1)+'1'#2 11

内存模型

a = 'abc'       #内存创建变量a, 字符串'abc'
b = a           #创建变量b， b指向a地址，也就是'abc'
a = 'xyz'       #创建字符串'xyz'，a指向‘xyz’
print b         #b指针没变，所以还是‘abc’

a = {}          #创建变量a,创建对象{}，a指向{}
b  = a          #创建变量b， b指向a地址，也就是{}
a['a1'] = 1     #修改a指向内容的数据
print b==a,b    #b指针没变，所以内容跟a看到的一样
a = {}          #重新创建对象{}，a指向它，跟前一个不一样
a['a2'] = 2     #修改新对象属性
print b==a,a,b  #b还为原先的值，{'a1':1},所以深拷贝可由此实现

参考：数据类型和变量

2.浅拷贝与深拷贝

可变对象：有多个属性的对象，如{}，[],()

不可变对象：只有一个数据的对象，如‘abc’，1，True，None

# coding=utf-8
#浅拷贝
a = [1,2,3,4,5]
b = a
a.append('hello')
print a == b, a, b

#深拷贝
from copy import copy
c = copy(a)
a.append('world')
print a == c, a, c

#输出结果
True [1, 2, 3, 4, 5, 'hello'] [1, 2, 3, 4, 5, 'hello']
False [1, 2, 3, 4, 5, 'hello', 'world'] [1, 2, 3, 4, 5, 'hello']

=为浅拷贝，a跟b指向同一对象

copy.copy()为深拷贝，a跟b指向不同对象

参考：python的复制，深拷贝和浅拷贝的区别

3.函数

函数内存模型

# coding=utf-8
a = abs         #变量abs指向绝对值函数，a指向abs指向的地址
print a(-1)
abs = 3         #变量abs指向整数对象3 
print a(-1)
print abs(-1)   #再调就会报错，因为他已经不是绝对值函数了

函数返回多个值

实际上返回的是元组，python可以x,y=(1,2)这样赋值而已

def test1():
    return 1,2
def test2():
    return (1,2)
def test3():
    return [1,2]
a, b = test1()
print a, b, type(test1())
a, b = test2()
print a, b, type(test2())
a, b = test3()
print a, b, type(test3())

#输出
1 2 <type 'tuple'>
1 2 <type 'tuple'>
1 2 <type 'list'>

默认参数

函数执行时，会先赋值必要参数，找不到就会抛异常结束，所以，默认参数必须写必要参数后面

默认参数为=号赋值，所以，会出现浅拷贝现象

def m_power(x, n=2):
    s = 1
    while(n>0):
        s*=x
        n-=1
    return s
print m_power(10)
print m_power(10,3)
print m_power(10,n=3)

#输出
100
1000
1000

可变参数

接收（），[]

#可变参数函数手动实现
def test(nums):
    sum = 0
    for n in nums:
        sum += n
    return sum
print test([1,2,3,4,5])

#可变参数
def test(*nums):#为什么此处重名没报错？？？
    sum = 0
    for n in nums:
        sum += n
    return sum
print test(1,2,3,4,5)
nums = [1,2,3,4,5]
print test(*nums)

#输出
15
15
15

关键字参数

可传入任意参数，接收{}

#关键字参数手动实现
from copy import copy
def test2(props):
    temp = copy(props)
    temp['test_2'] = 2
    return temp
kw = {'a':1,'b':2}
print test2(kw)

#关键字参数
def test3(**props):
    props['test_3'] = 2
    return props
print test3(**kw)
print test3(a=1,b=2)

#输出
{'a': 1, 'b': 2, 'test_2': 2}
{'a': 1, 'b': 2, 'test_3': 2}
{'a': 1, 'b': 2, 'test_3': 2}

命名关键字参数

python2不支持，略

4.函数递归

递归每种条件都有返回，并且在一定条件下能结束递归。

递归本身是堆栈调用，无法跳出递归或者堆栈过深会导致超过最大栈长度报错

尾递归调用：return a+add(a-1)为非尾递归，尾递归调用就会返回，只占用一个堆栈

尾递归详细见递归函数，有点没看懂

def add(a):
    if a>0:
        return a+add(a-1)
    return 0
print add(10)

#输出
55

参数定义的顺序必须是：必选参数、默认参数、可变参数、命名关键字参数和关键字参数

循环

python：永远别写for循环？？？

demo1 for生成列表:

lista = [i for i in range(10)]
print lista
lista = [i for i in range(1,10,2)]
print lista

#输出结果
[0, 1, 2, 3, 4, 5, 6, 7, 8, 9]
[1, 3, 5, 7, 9]

demo2 遍历迭代器:

lista = [obj for obj in range(1,10,2)]
for idx, obj in enumerate(lista):
    print idx, obj
#输出
0 1
1 3
2 5
3 7
4 9

demo3 取得元素下标:

lista = [obj for obj in range(1,10,2)]
for idx, obj in enumerate(lista):
    if obj%9==0:
        break
    if obj%3==0:
        continue
    print idx, obj

#输出
0 1
2 5
3 7

参考：函数的参数