廖雪峰python教程笔记1

d.get(‘Thomas’, -1) 检查字典中是否有’Thomas’的key,没有返回-1，没有指定返回值默认返回None；
d.pop(‘Bob’) 删key
字典key不能为列表
s = set([1, 2, 3]) set需要以list作为输入集合，不能重复且无顺序。
s.add() s.remove() s1&s2 s1|s2
a = ‘abc’,b = a.replace(‘a’, ‘A’) a是变量，’abc’是字符串对象。当我们调用a.replace(‘a’, ‘A’)时，实际上调用方法replace是作用在字符串对象’abc’上的，而这个方法虽然名字叫replace，但却没有改变字符串’abc’的内容。相反，replace方法创建了一个新字符串’Abc’并返回，如果我们用变量b指向该新字符串，就容易理解了，变量a仍指向原有的字符串’abc’，但变量b却指向新字符串’Abc’了
默认参数可以不按顺序写，但当不按顺序提供部分默认参数时需要写参数名
默认参数必须指向不变对象
可变参数

def calc(*numbers): #参数numbers接收到的是一个tuple
    sum = 0
    for n in numbers:
        sum = sum + n * n
    return sum
calc(1, 2) #不需要传入列表

nums = [1, 2, 3]
calc(*nums) #*nums表示把nums这个list的所有元素作为可变参数传进去

可变参数允许你传入0个或任意个参数，这些可变参数在函数调用时自动组装为一个tuple。而关键字参数允许你传入0个或任意个含参数名的参数，这些关键字参数在函数内部自动组装为一个dict。
10. 关键字参数

def person(name, age, **kw):
    print('name:', name, 'age:', age, 'other:', kw)
person('Adam', 45, gender='M', job='Engineer')
#name: Adam age: 45 other: {'gender': 'M', 'job': 'Engineer'}

extra = {'city': 'Beijing', 'job': 'Engineer'}
person('Jack', 24, **extra) #注意kw获得的dict是extra的一份拷贝，对kw的改动不会影响到函数外的extra。
#name: Jack age: 24 other: {'city': 'Beijing', 'job': 'Engineer'}

命名关键字参数（限制传入的关键字参数名字，必须传入指定关键字参数）

def person(name, age, *, city, job):
    print(name, age, city, job)
person('Jack', 24, city='Beijing', job='Engineer')
def person(name, age, *args, city, job):
    print(name, age, args, city, job)#如果函数定义中已经有了一个可变参数，后面跟着的命名关键字参数就不再需要一个特殊分隔符*了：

命名关键字参数必须传入参数名，这和位置参数不同。这5种参数都可以组合使用，按照必选参数、默认参数、可变参数、命名关键字参数和关键字参数的顺序。

通过一个tuple和dict，你也可以调用上述函数。

def f1(a, b, c=0, *args, **kw):
    print('a =', a, 'b =', b, 'c =', c, 'args =', args, 'kw =', kw)
def f2(a, b, c=0, *, d, **kw):
    print('a =', a, 'b =', b, 'c =', c, 'd =', d, 'kw =', kw)
>>> args = (1, 2, 3, 4)
>>> kw = {'d': 99, 'x': '#'}
>>> f1(*args, **kw)
a = 1 b = 2 c = 3 args = (4,) kw = {'d': 99, 'x': '#'}
>>> args = (1, 2, 3)
>>> kw = {'d': 88, 'x': '#'}
>>> f2(*args, **kw)
a = 1 b = 2 c = 3 d = 88 kw = {'x': '#'}

递归函数
解决递归调用栈溢出的方法是通过尾递归优化，事实上尾递归和循环的效果是一样的，所以，把循环看成是一种特殊的尾递归函数也是可以的。尾递归是指，在函数返回的时候，调用自身本身，并且，return语句不能包含表达式。这样，编译器或者解释器就可以把尾递归做优化，使递归本身无论调用多少次，都只占用一个栈帧，不会出现栈溢出的情况。

def fact(n):
    if n==1:
        return 1
    return n * fact(n - 1) #可能溢出

廖雪峰python教程笔记1

猜你喜欢