python要点

1.数据类型

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

布尔值：True, False

空值： None

类型转换

print bool('True'), bool(), bool(), bool(''), bool(None)#True True False False False
print int('')+, str()+''# 

内存模型

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'] =      #修改a指向内容的数据
print b==a,b    #b指针没变，所以内容跟a看到的一样
a = {}          #重新创建对象{}，a指向它，跟前一个不一样
a['a2'] =      #修改新对象属性
print b==a,a,b  #b还为原先的值，{'a1':},所以深拷贝可由此实现

参考：数据类型和变量

2.浅拷贝与深拷贝

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

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

# coding=utf-
#浅拷贝
a = [,,,,]
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 [, , , , , 'hello'] [, , , , , 'hello']
False [, , , , , 'hello', 'world'] [, , , , , 'hello']

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

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

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

3.函数

函数内存模型

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

函数返回多个值

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

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

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

默认参数

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

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

def m_power(x, n=):
    s =
    while(n>):
        s*=x
        n-=
    return s
print m_power()
print m_power(,)
print m_power(,n=)

#输出

可变参数

接收（），[]

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

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

#输出

关键字参数

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

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

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

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

命名关键字参数

python2不支持，略

4.函数递归

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

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

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

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

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

#输出
55

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

循环

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

demo1 for生成列表:

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

#输出结果
[, , , , , , , , , ]
[, , , , ]

demo2 遍历迭代器:

lista = [obj for obj in range(,,)]
for idx, obj in enumerate(lista):
    print idx, obj
#输出

demo3 取得元素下标:

lista = [obj for obj in range(,,)]
for idx, obj in enumerate(lista):
    if obj%==:
        break
    if obj%==:
        continue
    print idx, obj

#输出

参考：函数的参数