Python每日学习笔记

list：a=[1,2,3]   list值可变

tuple：b=（1,2,3） tuple值不可变

dict：c={'a':1,'b':2,'c'：3}  dict（key-value）key不可变
读取c：c['a']

set：d=set([1,2,3])   set(key)无value key为传入一个list


range(5)生成的序列是从0开始小于5的整数：
>>> list(range(5))
[0, 1, 2, 3, 4]

在Python中，定义一个函数要使用def语句
只允许整数和浮点数类型的参数。数据类型检查可以用内置函数isinstance()实现：
def my_abs(x):
    if not isinstance(x, (int, float)):
        raise TypeError('bad operand type')
    if x >= 0:
        return x
    else:
        return -x
默认参数：
def power(x, n=2):
    s = 1
    while n > 0:
        n = n - 1
        s = s * x
    return s
调用power（）时就可以只有一个参数了，n默认2

坑：
def add_end(L=[]):
    L.append('END')
    return L
>>> add_end()
['END']
但是，再次调用add_end()时，结果就不对了：
>>> add_end()
['END', 'END']
>>> add_end()
['END', 'END', 'END']
原因解释如下：
Python函数在定义的时候，默认参数L的值就被计算出来了，即[]，因为默认参数L也是一个变量，它指向对象[]，每次调用该函数，如果改变了L的内容，则下次调用时，默认参数的内容就变了，不再是函数定义时的[]了。
！！！定义默认参数要牢记一点：默认参数必须指向不变对象！
修改：def add_end(L=None):
    if L is None:
        L = []
    L.append('END')
    return L

可变参数：def calc(*numbers):
    sum = 0
    for n in numbers:
        sum = sum + n * n
    return sum
在number前加了个* ，没有*的话可以传入list或者tuple
加了*就是接受tuple
当有一个nums = [1, 2, 3]
可以 calc(nums[0], nums[1], nums[2])
这样繁琐：可这样：calc(*nums)
*nums表示把nums这个list或者tuple的所有元素作为可变参数传进去

关键字参数：
def person(name, age, **kw):
    print('name:', name, 'age:', age, 'other:', kw)
关键字kw扩展函数的功能，和可变参数类似，也可以先组装出一个dict，然后，把该dict转换为关键字参数传进：
>>> extra = {'city': 'Beijing', 'job': 'Engineer'}
>>> person('Jack', 24, city=extra['city'], job=extra['job'])
name: Jack age: 24 other: {'city': 'Beijing', 'job': 'Engineer'}
简化写法：
>>> extra = {'city': 'Beijing', 'job': 'Engineer'}
>>> person('Jack', 24, **extra)
name: Jack age: 24 other: {'city': 'Beijing', 'job': 'Engineer'}在dict前面加两个**，**extra表示把extra这个dict的所有key-value用关键字参数传入到函数的**kw参数，kw将获得一个dict，注意kw获得的dict是extra的一份拷贝，对kw的改动不会影响到函数外的extra。

命名关键字参数：
检查传入的关键字
def person(name, age, **kw):
    if 'city' in kw:
        # 有city参数
        pass
    if 'job' in kw:
        # 有job参数
        pass
    print('name:', name, 'age:', age, 'other:', kw)但是调用者仍可以传入不受限制的关键字参数
要想限制关键字，要命名关键字参数，只接收city和job作为关键字参数：
def person(name, age, *, city, job):
    print(name, age, city, job)
和关键字参数**kw不同，命名关键字参数需要一个特殊分隔符*，*后面的参数被视为命名关键字参数。
如果函数定义中已经有了一个可变参数，后面跟着的命名关键字参数就不再需要一个特殊分隔符*了：
def person(name, age, *args, city, job):
    print(name, age, args, city, job)



参数组合：
定义函数时可以用必选参数、默认参数、可变参数、关键字参数和命名关键字参数，这5种参数都可以组合使用。




切片：
>>> L = ['Michael', 'Sarah', 'Tracy', 'Bob', 'Jack']
>>> r = []
>>> n = 3
>>> for i in range(n):
...     r.append(L[i])
...
>>> r
['Michael', 'Sarah', 'Tracy']
 range(n)生成0到n-1的整数
切片（Slice）操作符：
>>> L[0:3]
['Michael', 'Sarah', 'Tracy']
从0开始到3（不包括3索引）即0,1,2   如果第一个索引是0，还可以省略：L[:3]
L[-1]取倒数第一个元素
列：  L = list(range(100))
前10个数：
>>> L[:10]
[0, 1, 2, 3, 4, 5, 6, 7, 8, 9]

后10个数：
>>> L[-10:]
[90, 91, 92, 93, 94, 95, 96, 97, 98, 99]

前11-20个数：
>>> L[10:20]
[10, 11, 12, 13, 14, 15, 16, 17, 18, 19]

前10个数，每两个取一个：
>>> L[:10:2]
[0, 2, 4, 6, 8]

所有数，每5个取一个：
>>> L[::5]
[0, 5, 10, 15, 20, 25, 30, 35, 40, 45, 50, 55, 60, 65, 70, 75, 80, 85, 90, 95]

甚至什么都不写，只写[:]就可以原样复制一个list：
>>> L[:]
[0, 1, 2, 3, ..., 99]
     
tuple也是一种list，唯一区别是tuple不可变。因此，tuple也可以用切片操作，只是操作的结果仍是tuple：
>>> (0, 1, 2, 3, 4, 5)[:3]
(0, 1, 2)

字符串'xxx'也可以看成是一种list，每个元素就是一个字符。因此，字符串也可以用切片操作，只是操作结果仍是字符串：
>>> 'ABCDEFG'[:3]
'ABC'
>>> 'ABCDEFG'[::2]
'ACEG'