python笔记

python笔记

循环区别：
while 循环结束后，继续使用控制条件的那个变量，用while循环
for 知道循环次数

1.函数
1.函数的参数
1.1可变参数：其实可以用list和tuple代替，但是它们在输入时有要求，而加上 * 变成可变参数，就没有了这个后顾之忧
1.2关键字参数：键值对的字典，在必要参数，默认参数，可变参数下，可以随意传入多个键值对，也就是随意增加一些想要的键值对参数。
命名关键字参数：限制关键字参数的名字
2.递归函数

def Hanio(n,a,b,c):
    if n==1:
        print(a,'-->',c)  #只有一个盘子时，直接把一个盘子从A挪到C
    else:
        Hanio(n-1,a,c,b)  #挪n个盘子时，只有先把n-1个盘子挪到b上，才能将a中最大的盘子挪到c，此时n-1个盘子怎么挪呢，首先得将n-2个盘子挪到c（用到递归），
                         #再把其中a上最大的那个挪到c上，此时打印a-->c
        print(a,'-->',c)
        Hanio(n-1,b,a,c)       #此时考虑将b上的n-1个从b上挪到c上，借助a柱，又用到递归思想，先把n-2个挪到a上，挪时先将n-3挪到c上，将b其中最大的那个挪到a上
                         #这样递归下去，柱上每个圆盘都会在某一步中成为最大的圆盘，打印出来，记录为步骤

** 2高级特性**
1.切片
1.1
[-1:] [::2]
2迭代
2.1
2.2 整数不可迭代
isinstance(123, Iterable)
False
for i in 10 这是个错误的写法
2.3列表生成式
for 前边的if ……else 是表达式 后边加if 是过滤条件，而且不能后边加else

[x+y for x in 'paul' for y in 'love']
[x*x for x in range(1,10) if (x*x)%2 == 0]

2.4生成器
generator（）
列表生成器太浪费内存，想一个边循环，边计算的算法，就是迭代器
[ ]–>() 例子，斐波那契fib（）
yield 每次循环一次，暂停一次
迭代器不可以直接输出，必须for循环一个一个读出数据；从当前位置暂停，并从当前位置返回；输出当下数。
2.5迭代器
list tupel str 这些都是Iterable不是Iterator，但是可以使用Iter(list)可转化为Iterator,for循环其实是不断调用next()函数实现的
Iterator是一个数据流，Iterator对象是被next（）函数调用，并不返回下一个数据，直至没有数据集报出StopIteration错误。

函数式编程
1.高阶函数
1.1map reduce
map(函数，迭代对象)
reduce(函数，map()) reduce进行两两累积操作reduce(f, [x1, x2, x3, x4]) = f(f(f(x1, x2), x3), x4)
为啥引入map? 将一个迭代对象按照规则变成一个对应的列表，进行抽象，也是对应形式转化。如str --> int
1.2为什么编程都是从下标0开始的嘛？
（1）a[0]的偏移量是0，即为首地址。a[i]的偏移量是i，寻址公式就是a[i]_address = base_address + i*data_type_size
如果下标从1开始，那对应的寻址公式a[i]_address = base_address + （i-1）*data_type_size
对CPU来说，每次随机访问，就多了一次运算，多发一条指令，增加运算成本。
（2）从数学而言，a,c表示不了0，要表示只能用到-1
a. 0<i<11
b. 1<=i<11
c. 0<i<=10
d. 1<=i<=10
C语言当初这样设计的，其他语言仿效该语言同时也节少了学习成本
1.3
sorted(列表，排序的规则函数，其他参数)
sorted(L,key = lambda x:x[1], reverse = True)
1.4返回函数
（1）不需要立刻求和，而是在需要时再求和，引入返回函数，它可以不返回求和的结果，而是返回求和的函数。
（2）函数中又定义一个函数，并且外部函数返回内部函数，内部函数可以使用外部函数的参数和局部变量作为参数，外部函数的参数保存在内部函数中，这种被成为闭包

（3）n=0初始化只用了一次，也可以看作运行一步，输出一步相当于yield

def createCounter():
    n=0               #这里n可以看作只调用了一次
    def counter():
        nonlocal n   #这里注意是局部变量
        n=n+1
        return n
    return counter

1.5lambda匿名函数：顾名思义不起名的函数
lambda 参数:表达式
只能有一个表达式，且返回值就是表达式的值
1.6装饰器
不改变原函数的功能，增加原函数的功能，引入装饰器

import functools

def log(text):
    def decorator(func):
        @functools.wraps(func)
        def wrapper(*args, **kw):
            print('%s %s():' % (text, func.__name__))
            return func(*args, **kw)
        return wrapper
    return decorator

@functools.wraps(func) 设置装饰函数名字
1.7偏函数
重新设置函数的部分默认参数
int2 = functools.partial(int ,base=2)

模块
1模块里公开greeting()函数，而把内部逻辑用private函数隐藏起来

面向对象和编程
1类和实例
class Student(继承的类) 如果没有继承的类，则继承object
def init(self,参数1，参数2……),用__init__这个特殊的方法，必须设定的属性强制绑定进去，而且第一个参数是self，表示创建的实例本身
类中实现的方法，实例可以直接调用，这样方法就被封装了起来，面向对象的一个重要数据特点 ，就是数据封装
2访问限制
（1）self.__name=name __代表私有属性，不让外界随意访问，增加了安全性
（2）_name 单下划线虽然也可以访问，但是被看作私有属性，不要随意访问
3继承和多态
继承是继承父类的方法
子类可以自己重新定义父类的方法，就是多态
4.获取对象信息
type（） IsInstance() dir()
5.实例属性和类属性
（1）实例属性互不干扰，类属性却共享一个
（2）实例属性可以覆盖类属性，所以不要使用相同的名字

面向对象高级编程
1.slots 给该类中所有实例绑定方法，只有在该类中，在实例中绑定的的属性和方法
2.@property 实例属性可以不暴露，同时检测参数的正确性
3.多重继承
MixIn,多重继承就是一个类，如果不多重继承，则有很复杂的层次继承关系，所以我们用多重继承组合多个MixIn这个功能

Class MyTcpServer(TCPServer,ThreadingServer):
Classs Dog(Mammal,RunableMixIn,FlyableMixIn)

4.定制类
__init __str __next
直接调用，把函数当作对象，对象当作函数
5.枚举
from enum import Enum,unique
@unique装饰器帮我们检查有没有重复得值
6.元类
metaclass允许你创建类或者修改类。换句话说，你可以把类看成是metaclass创建出来的“实例”

错误测试调试
1.错误处理
tyr:
except:
finally
2.调试logging
3.单元测试
4.文档测试

IO编程
1.文件读写
with open(’/Users/49232/abc.txt’,‘r’,encoding=‘UTF-8’) as f:
f.write(‘Hello World!!!’)
这样会自动关闭f.close()字节流
2.StringIO和BytesIO
将数据暂时保存在内存中，而不是文件硬盘中
StringIO(‘内容’)
3.操作文件和目录
一部分是放在os目录下，已不是是在os.path下
os.rename() os.remove()
4序列化
不同编程语言之间传递对象，就必须将对象序列化为标准格式。JSON序列化出来就是一个字符串，可以方便保存在磁盘中存储与传输。
把变量从内存中变成可存储可运输的过程叫序列化
JSON 中dump序列化 load反序列化
if name == ‘main’ ：
每个文件有内置函数，如果相同则执行，之后的内容，不同则不执行。