python语法

python

所有 python 对格式要求非常严格。
因此，在 Python 的代码块中必须使用相同数目的行首缩进空格数。

列表[]

切割也可以用到变量 [头下标:尾下标] ，就可以截取相应的列表，从左到右索引默认 0 开始，从右到左索引默认 -1 开始，下标可以为空表示取到头或尾。

元组（）tuple

元组是另一个数据类型，类似于 List（列表）。
元组用 () 标识。内部元素用逗号隔开。但是元组不能二次赋值，相当于只读列表。

字典 dict

每个键值 key=>value 对用冒号 : 分割，每个对之间用逗号(,)分割，整个字典包括在花括号 {} 中
d = {key1 : value1, key2 : value2, key3 : value3 }

优点

1.论这个表有多大，查找速度都不会变慢
在字典的索引表里（比如部首表）查这个字对应的页码，然后直接翻到该页，找到这个字。无论找哪个字，这种查找速度都非常快，不会随着字典大小的增加而变慢。
dict内部存放的顺序和key放入的顺序是没有关系的
要删除一个key，用pop(key)方法，对应的value也会从dict中删除
dict的key必须是不可变对象。

方法

创建空字典
emptyDict = {‘key’,value}

查找key->value
a= dict[key]

判断是否存在
1.‘Thomas’ in d
2.d.get(‘Thomas’, -1)
删除：s.pop(key)

dict与list比较

和list比较，dict有以下几个特点：

查找和插入的速度极快，不会随着key的增加而变慢；
需要占用大量的内存，内存浪费多。

而list相反：

查找和插入的时间随着元素的增加而增加；
占用空间小，浪费内存很少。
可变对象，不可作为key

修改不可变对象str,新建新的

set(无序和无重复元素

创建：s = set([1, 2, 3])
添加：s.add(key)
删除 s.remove(4)

函数

进制转化

相互装换：括号内：原进制，外：要转的进制

空函数pass 占位

注意：函数无法判断参数类型问题

进行参数检查

def my_abs(x):
    if not isinstance(x, (int, float)):
        raise TypeError('bad operand type')

同时获得多个返回值

x, y = move(100, 100, 60, math.pi / 6)
def move(x, y, step, angle=0):
    nx = x + step * math.cos(angle)
    ny = y - step * math.sin(angle)
    return nx, ny

函数的参数

1.把power(x)修改为power(x, n)，形成多个参数
但原参数不可用
修改：默认参数

默认参数

power(x,n=1)
只有与默认参数不符的学生才需要提供额外的信息：

如何设置
一是必选参数在前，默认参数在后，否则Python的解释器会报错（思考一下为什么默认参数不能放在必选参数前面）；

二是如何设置默认参数。

当函数有多个参数时，把变化大的参数放前面，变化小的参数放后面。变化小的参数就可以作为默认参数。

注意
定义默认参数要牢记一点：默认参数必须指向不变对象！

def add_end(L=None):
    if L is None:
        L = []
    L.append('END')
    return L

可变参数def calc(*numbers):0个或任意个参数

接收到的是一个tuple，所有元素作为可变参数传进去

def calc(*numbers):
    sum = 0
    for n in numbers:
        sum = sum + n * n
    return sum

如果是key-value :dict
extra这个dict的所有key-value用关键字参数传入到函数的kw参数，kw将获得一个dict，注意kw获得的dict是extra的一份拷贝，对kw的改动不会影响到函数外的extra。

关键字参数：0个或任意个含参数名的参数，这些关键字参数在函数内部自动组装为一个dict。可以传入不受限的关键字参数

定义

def person(name, age, **kw):
    print('name:', name, 'age:', age, 'other:', kw)
>>> person('Bob', 35, city='Beijing')
name: Bob age: 35 other: {'city': 'Beijing'}
>>> person('Adam', 45, gender='M', job='Engineer')
name: Adam age: 45 other: {'gender': 'M', 'job': 'Engineer'}

命名关键字参数:限制关键字参数的名字

注意：一定要写命名关键字或用*占位，如果 缺 少 ，Python解释器将无法识别位置参数和命名关键字参数

递归函数

注意：函数调用通过栈实现,每当进入一个函数调用，栈就会加一层栈帧，每当函数返回，栈就会减一层栈帧。由于栈的大小不是无限的，所以，递归调用的次数过多，会导致栈溢出。

解决栈溢出：尾递归–>类循环（return语句中修改参数，在递归函数执行前就修改参数

高级特性

切片slice:取一个list或tuple的部分元素

List[]
前10：L[:10]
后10：L[-10:]
前10个数，每两个取一个：L[:10:2]
所有数，每5个取一个：L[::5]
只写[:]就可以原样复制一个list：

tuple也可以用切片操作，只是操作的结果仍是tuple：

迭代 for … in：只要是可迭代对象，无论有无下标，都可以迭代，比如dict就可以迭代

list或tuple
dict迭代的是key。
如果要迭代value，可以用for value in d.values()，
如果要同时迭代key和value，可以用for k, v in d.items()。

判断是否可迭代： isinstance(‘abc’, Iterable)

列表生成器[ x for x in a ]

[x*x for x in range(1,11)]

[m+n for m in'ABC' for n in 'xyz'

for k,v in d.items()
同时迭代key value

加入if :for 后
加入if else :前

生成器：generator。不断推算出后续的元素(x for x in a)

g = (x * x for x in range(10))

generator保存的是算法,也是可迭代对象：for

enerator函数，在执行过程中，遇到yield就中断，下次又继续执行

迭代器

一类是集合数据类型，如list、tuple、dict、set、str等；

一类是generator，包括生成器和带yield的generator function。

函数式编程

高阶函数：个函数就可以接收另一个函数作为参数

map(方法名，[参数列]):通过list()函数让它把整个序列都计算出来并返回一个list

L = []
for n in [1, 2, 3, 4, 5, 6, 7, 8, 9]:
    L.append(f(n))
print(L)

reduce(参数名，[参数])的用法:作用两个函数

reduce把一个函数作用在一个**序列[x1, x2, x3, …]**上，这个函数必须接收两个参数，reduce把结果继续和序列的下一个元素做累积计算，

补充：lambda函数写法(匿名函数

lambda [arg1 [,arg2,…argn]]:expression

[arg…] 是参数列表，它的结构与 Python 中函数(function)的参数列表是一样的。
expression 是一个参数表达式，表达式中出现的参数需要在[arg…]中有定义，并且表达式只能是单行的，只能有一个表达式。

常见用法

1。将lambda函数赋值给一个变量，通过这个变量间接调用该lambda函数。

add = lambda x, y: x+y
aad(1,2)
3

2.将lambda函数赋值给其他函数，从而将其他函数用该lambda函数替换。

3.将lambda函数作为参数传递给其他函数。

sorted() 函数对所有可迭代的对象进行排序操作

sort 是 list 的一个方法，而 sorted 可以对所有可迭代的对象进行排序操作。
list 的 sort 方法返回的是对已经存在的列表进行操作，无返回值，而内建函数 sorted 方法返回的是一个新的 list，而不是在原来的基础上进行的操作。

sorted(iterable[, cmp[, key[, reverse]]])
加入函数，实现自定义排序

 sorted([36, 5, -12, 9, -21], key=abs)
[5, 9, -12, -21, 36]

字符串排序

是按照ASCII的大小比较的，由于’Z’ < ‘a’，结果，大写字母Z会排在小写字母a的前面。

filter(函数，可迭代对象)过滤序列，过滤掉不符合条件的元素，返回由符合条件元素组成的新列表。

返回函数和函数的闭包

返回闭包时牢记一点：返回函数不要引用任何循环变量，或者后续会发生变化的变量。因为外层函数结果为看成内层函数中的全局变量，全部变化
如果一定要引用循环变量怎么办？方法是再创建一个函数，用该函数的参数绑定循环变量当前的值，无论该循环变量后续如何更改，已绑定到函数参数的值不变：

def count():
    def f(j):
        def g():
            return j*j
        return g
    fs = []
    for i in range(1, 4):
        fs.append(f(i)) # f(i)立刻被执行，因此i的当前值被传入f()
    return fs

加入nonlocal x声明

def inc():
    x = 0
    def fn():
        # nonlocal x
        x = x + 1
        return x
    return fn

f = inc()
print(f()) # 1
print(f()) # 2

补充：函数的闭包与装饰器

**闭包：**函数的属性，值存在与函数执行的期间
返回函数：使得外部变量可被内部函数使用
闭包内的闭包函数私有化了变量，完成的数据的封装

装饰器：基于闭包
不用更改原函数的代码前提下给函数增加新的功能。
被装饰的函数带参数

python 的变量作用域

1. (常见）局部作用域：local
2. 闭包函数外的函数中：Enclosing
3. (常见)全局作用域：Global
4. 内建作用域：build-in