python笔记

  1. python是动态语言,变量本身的类型不固定

    如:

    a=1;  
    a="abc"; 
    

    这是正确的

  2. python中有两种除法 / //

    / 得到的总是浮点数 ,// 叫做地除法 它总是只取整数部分

    如:

    10/3 
    

    3.3333

    10//3

    3

  3. 字符和编码转换
    ord() chr()

  4. 由于Python的字符串类型是str,在内存中以Unicode表示,一个字符对应若干个字节。如果要在网络上传输,或者保存到磁盘上,就需要把str变为以字节为单位的bytes。

    x=b'xyx'
    
  5. 以Unicode表示的str通过encode()方法可以编码为指定的bytes
    'abc'.encode('utf-8')
    
  6. 如果我们从网络或磁盘上读取了字节流,那么读到的数据就是bytes。要把bytes变为str,就需要用decode()方法
     b'\xe4\xb8\xad\xe6\x96\x87'.decode('utf8')
    
  7. 字符串str长度函数len(),此函数同样适用于字节
  8. 由于Python源代码也是一个文本文件,所以,当你的源代码中包含中文的时候,在保存源代码时,就需要务必指定保存为UTF-8编码。当Python解释器读取源代码时,为了让它按UTF-8编码读取,我们通常在文件开头写上这两行:
    #!/usr/bin/env python3
    # -*- coding: utf-8 -*-
    

9.list api

    list=['1','2','3']
    len(list)
    list[-1] //返回最后一个元素
    list[-2] //返回倒数第二个 依次类推
    list.append('4')  //追加元素
    list.insert(1,'5')
    list.pop() //删除最后一个
    list.pop(1) //删除索引为1的元素

10. tuple 数组 tuple一旦初始化就不能修改
如果tuple中只有一个元素要跟一个逗号如

    t=(1,)
  1. 条件判断
    if age>18:
        print("18")
    elif age>10:
        print('10')
    else :
        print('baby')
    
  2. 循环
    for cell in cells
        print(cell)
    
    while n>10
        sum = sum+n
        print(sum)
    
  3. dict 同java中的map
    dict={'name':'123'}
    print(dict['name'])
    //判断dict中是否含有某个key
    'age' in dict
    //dict的get方法
    print(dict.get('name')) //输出 123 
    print(dict.get('age')) //None
    print(dict.get('age',-1)) // -1
    dict.pop('name')
    dict['age']=10 //新增元素
    

    和list比较,dict有以下几个特点:

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

    查找和插入的时间随着元素的增加而增加;
    占用空间小,浪费内存很少。

  4. set

    s = set('apage')
    print(s)
    s1 = set([1,2,3])
    s1.add(5)
    s1.remove(5)
    
  5. 内置函数

    数据类型检查可以用内置函数isinstance()

    isinstance(123,(int,float)) //第二个参数可以是一个数组
    
  6. 函数可以返回多个值
    def move(x,y){
        //处理
        return x,y
    }
    
    x,y  = move(1,2);
    print(x);
    print(y);
    
    
    r = move(1,2);
    print(r);//r=(xx,xx);返回值是tuple
    
  7. 函数参数

    1) 定义函数时可以使用默认值,例如

    def power(x,n=2):
        s = 1;
        while n >= 1 :
            s = x * s;
            n = n-1;
        return s
    

    带默认值要放到参数后面;
    参数默认值问题,默认参数必须指向不变对象!
    可以使用None来避免:如

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

    2) 可变参数

        def calc(*numbers):
            sum = 0
            for n in numbers:
                 sum = sum + n * n
            return sum
    将list或tuple作为可变参数传入
    
        num = [1,2,3]
        calc(*num)
    

    3) 关键字参数

        def person(**kw)
            print(kw)
    

    4) 命名关键字参数

        def person(a,b,*,city,job)
    命名关键字需要用*号分开,*后面的参数被视为命名关键字参数
    命名关键字参数可以使用默认值:
    
        def person(a,b,*,city='beijing',job)
    

    5) 小结:

    默认参数一定要用不可变对象,如果是可变对象,程序运行时会有逻辑错误!

    要注意定义可变参数和关键字参数的语法:
    *args是可变参数,args接收的是一个tuple;
    **kw是关键字参数,kw接收的是一个dict。
    命名的关键字参数是为了限制调用者可以传入的参数名,同时可以提供默认值。定义命名的关键字参数在没有可变参数的情况下不要忘了写分隔符*,否则定义的将是位置参数
    
  8. 尾递归是指,在函数返回的时候,调用自身本身,并且,return语句不能包含表达式。这样,编译器或者解释器就可以把尾递归做优化,使递归本身无论调用多少次,都只占用一个栈帧,不会出现栈溢出的情况。

  9. 分片操作

    即截取操作,list,tuple,字符串都可以使用分片操作,例如:

    list=[1,2,3,4,5];
    list[1:3]  //截取第二个到第三个  ,索引从0开始
    list[:3]  //截取前三个
    list[-2:]  //截取倒数两个
    list[:]   //复制
    tuple=(1,2,3,4,5)
    tuple[2:3]
    tuple[2:3:-1]  //截取出‘子串’,然后倒序输出  如果最后一位如果为正则,则正序输出;为负,则倒序输出
    
  10. 迭代
    1) 迭代dict

        dict = {'a':1,'b':2,'c':3}
        //默认迭代key
        for key in dict
            print(key)
        //迭代value
        for value in dict.values()
            print(value)
        //同时迭代
        for key,value in dict.items()
            print(key,':'value)
    

    2) 判断元素是否可以迭代:导入collections模块的Iterable类型

        from collections import Iterable
         isinstance('abc',Iterable) 
    
        //enumerate将list转换为索引-元素对 
    for i,value in enumerate(['a','b','c']):
        print(i,value)
    
  11. 列表生成式

    生成一个list列表,如

    dict={'a':1,'b':2,'c':3]
    list =[x+"="+str(y) for x,y in dict.items()]
    
  12. 列表生成器

    列表生成器和生成式的区别在于:生成器为“()” 而生成式是“[]”
    可以使用next()函数获取generator的下一个值,当获取不到值后,会产生StopIteration异常,如:

    generator = (x+"="+str(y) for x,y in dict.items())
    next(generator)
    //使用for循环
    for x in generator
        print(x)
    //使用函数产生一个生成器 
    def  fib_generator(max):
        n,a,b = 0,0,1
        while n<max:
            yield(b)
            a,b = b, a+b
            n=n+1
        return 'done'
    
    for x in fib_generator(5):
        print(x)  
    

    但是用for循环调用generator时,发现拿不到generator的return语句的返回值。如果想要拿到返回值,必须捕获StopIteration错误,返回值包含在StopIteration的value中:

     g = fib(6)
     while True:
        try:
             x = next(g)
            print('g:', x)
        except StopIteration as e:
                 print('Generator return value:', e.value)
         break  
    
  13. 凡是可作用于for循环的对象都是Iterable类型;
    凡是可作用于next()函数的对象都是Iterator类型,它们表示一个惰性计算的序列;
    集合数据类型如list、dict、str等是Iterable但不是Iterator,不过可以通过iter()函数获得一个Iterator对象。

Python的for循环本质上就是通过不断调用next()函数实现的

  1. 函数式编程

    1) 高阶函数:参数中含有其他函数的函数称为高阶函
    2) map/reduce
    map()函数接收两个参数,一个是函数,一个是Iterable,map将传入的函数依次作用到序列的每个元素,并把结果作为新的Iterator返回。
    reduce把一个函数作用在一个序列[x1, x2, x3, …]上,这个函数必须接收两个参数,reduce把结果继续和序列的下一个元素做累积计算,其效果就是:

    reduce(f, [x1, x2, x3, x4]) = f(f(f(x1, x2), x3), x4)
    

    本文根据廖雪峰老师博客记录

创作不易,转载请注明文章来源为www.full-satcker.com:邢桂帅 » python笔记

赞 (0)
分享到:更多 ()

评论 1

  • 昵称 (必填)
  • 邮箱 (必填)
  • 网址
  1. SunshineClear, infomrative, simple. Could I send you some e-hugs?回复