python basic knowledge

python basic knowledge

list

get the data from list

• index
• count

add or modify or delete the data from list

• append
• insert
• extend
• pop
• remove

action in list

• sort
• reverse

str

get the index from str

• find

action in str

• split

• join

• strip

• lower/upper

• replace

• translate

  • just like the function replace but it can only focus on single byte

dict

• clear

• copy and deep copy

  • copy
    • 对可变对象的修改保持同步
    • 对不可变对象的修改保持独立
  • deep copy
    • 则是复制完全副本

• get

  • 当我们试图访问字典中不存在的项目的时候会出现报错。但使用get就可以避免这个问题。get(‘name’,‘ethan’)

• setdefault

  • 用于对字典设定键值

• update

  • update 方法将一个字典添加一个字典中，如果有同名字典则替换

• items/iteritems

  • items将所有项用字典返回，iteritems怎么是一个迭代器

• keys/iterkeys

• values/itervalues

• pop

• popitem

  • 用于随机移除字典中的某个键值对

• 对元素为字典的进行排序

  • sorted(students, keys=lambda stu:(stu[‘score’],-stu[‘age’]))

set

• add
• remove
• 交集/并集/差集
  • s1 & s2
  • s1 | s2
  • s1 - s2
  • s3.issubset(s1) #s3是否是s1的子集
  • s3.issuperset(s2) #s3是否是s2的超集

函数

• 必选参数
• 默认参数
• 可变参数 *number
• 关键字参数 **kwargs
• 组合参数 def func(x,y,z=0,*args,**kwargs)

函数式编程

• 高阶函数
  • 可接收其他函数作为参数的函数成为高阶函数

def func(g,arr):
 return [g(x) for x in arr]

map/filter/reduce

• python 较为常见的内建函数
• map(function,sequence)
• reduce(function,sequence[,initial])
  • reduce(lambda x,y:xy,[1,2,3,4],5) #(51)23*4
• filter(function,sequence)
• python2返回的是基本数据类型，python3返回的是迭代器

匿名函数

• lambda 参数:表达式
• (lambda x:2*x)(8)

使用场景

• arr=func(add_one,[1,2,3])
• arr=func(lambda x:x+1,[1,2,3])

闭包

• 在python中，函数也是一个对象，在函数中再定义一个函数

from math import pow

def make_pow(n)
    def inner_func(x):
    return pow(x,n)
return inner_func


pow2=make_pow(2)
pow2(6)
36

闭包的作用

• 闭包的最大特点就是引用了自由变量，即使生成闭包的环境已经释放，闭包依然存在.
• 闭包在运行时可以有多个实例。

我觉得最大的特点就是,内置的函数是给别人用的，最顶层的函数封装是给自己用的。

常见的误区

返回闭包时牢记的一点就是：返回函数不要引用任何循环变量，或者后续会发生变化的变量。

装饰器

def wrap_in_tag(tag):
    def decorator(func):
        def wrapper(*args,**kwargs):
            ret=func(*args,**kwargs)
            return '<'+tag+'>'+ret+'</'+tag+'>'
        return wrapper
    return decorator      

基于类的装饰器

class Bold(object):
    def __init__(self,func):
        self.func=func

    def __call__(self,*args,**kwargs):
        return '<b>'+self.func(*args,**kwargs)+'</b>'


@Bold
def hello(name):
    return 'hello%s'% name        

class Tag(object):
    def __init__(tag):
        self.tag=tag
    def __call__(self,func):
        def wrapped(*args,**kwargs):
            return "<{tag}>{res}</{tag}>".format(res=func(*args,**kwargs),tag=self.tag)
        return wrapped

@Tag('b')
def hello(name) 
    return 'Hello%s'%name       

from functools import wraps

def makeitalic(func):
    @wraps(func)
    def wrapped(*args,**kwargs):
        return func(*args,**kwargs)
    return wrapped

@makeitalic
def hello():
    return "hello word"    

partial 函数

from functools import partial
double=partial(multiply,y=2)

类

这一块需要加强，python是一门面向对象的.

• type
• isinstance
• hasattr
• getattr
• setattr
• dir

继承和多态

• 继承可以拿到父类的所有数据和方法，子类可以重写父类的方法，也可以新增自己特有的方法
• 有了继承，才有了多态，不同类的对象对同一个消息会作出不同的响应

类方法和静态方法

类方法

class A(object):
    bar =1
    @classmethod
    def class_foo(cls):
        print 'Hello,',cls
        print cls.bar

静态方法

class A(object)
    bar =1
    @staticmethod
    def static_foo():
        print 'Hello,',A.bar

• 类方法使用@classmethod 装饰器，可以使用类来调用方法
• 静态方法使用@staticmethod装饰器，它是跟类有关系但在运行时又不需要实例和类参与的方法。

定制类

new 和 init

当我们创建一个类的实例时，类会先调用__new__来创建实例，然后__init__方法再对该实例进行初始化。

class A(object):
    _dict=dict()
    def __new__(cls):
        if 'key' in A._dict:
            print 'EXISTS'
            return A._dict['key']
        else:
            print 'NEW'
            return object.__new__(cls)

    def __int__(self):
        print 'INIT'
        A._dict['key']=self

str__和__repr

“class Foo(object):
    def __init__(self, name):
        self.name = name
    def __str__(self):
        return 'Foo object (name: %s)' % self.name

>>> print Foo('ethan')      # 使用 print
Foo object (name: ethan)
>>>
>>> str(Foo('ethan'))       # 使用 str
'Foo object (name: ethan)'
>>>
>>> Foo('ethan')             # 直接显示
<__main__.Foo at 0x10c37a490>”

“class Foo(object):
    def __init__(self, name):
        self.name = name
    def __str__(self):
        return 'Foo object (name: %s)' % self.name
    def __repr__(self):
        return 'Foo object (name: %s)' % self.name

>>> Foo('ethan')
'Foo object (name: ethan)”

iter

这时我们要在类里面定义__iter__ 和 next

class Fib(object):
    def __int__(self):
        self.a,self.b=0,1
    
    def __iter__(self):
        return self

    def __next__(self):
        self.a,self.b=self.b,self.a+self.b
        return self.a 

getitem

我们希望可以使用obj[n]这种方式对实例对象进行取值。

call

我们一般使用obj.method()来调用对象的方法。那能不能直接在实例本身上调用呢？

p=Point(3,4)
callable(p)
p(6)

使用@property

class Exam(object):
     def __init__(self.score):
        self._score=score
     def get_score(self):
        return self._score
    def set_score(self,val):
        if val< 0:
            self._score=0
        elif val > 100:
            self._score=100
        else :
            self._score=val  

python为我们提供了简单的封装

class Exam(object):
    def __init__(self,score):
        self._score=score
    @property
    def score():
        return self._score

    @property.setter
    def score(self,val):
        if val< 0:
            self._score=0
        elif val >100:
            self._score=100
        else:
            self._score=val

super

“class Base(object):
    def __init__(self, a, b):
        self.a = a
        self.b = b

class A(Base):
    def __init__(self, a, b, c):
        super(A, self).__init__(a, b)  # Python3 可使用 super().__init__(a, b)
        self.c = c”

上下文管理

其实我们可以简单地把它理解为环境。

• 上下文管理器协议，是指要实现对象的__enter__()和__exit__()方法

一般用在with的语句模块中的

contextlib 模块

from contextlib import contextmanager
@contextmanager
def point(x,y):
    print 'before yield'
    yield x*x+y*y
    print 'after yield'

with point(3,4) as value:
    print 'value is:%s' % value

# output
before yield
value is: 25
after yield    

文件和目录

字母	模式
‘r’	读模式
‘w’	写模式
‘a’	追加模式
‘b’	二进制模式
‘+’	读写模式

• readlines()
• read()

with open('aa.txt','r') as f:
    for line in f:
        print line

os 模块

方法	说明
os.mkdir	创建目录
os.rmdir	删除目录
os.rename	重命名
os.getcwd	获得当前工作路径
os.walk	遍历路径
os.path.join	连接目录与文件名
os.path.split	分割文件名与目录
os.path.abspath	获得绝对路径
os.path.dirname	获取路径
os.path.basename	获取文件名
os.path.splittext	分离文件名与扩展名
os.path.isfile	判断给出的路径是否是一个文件
os.path.isdir	判断给出的路径是否是一个目录

异常

• try…except…
• try…except…else…
• try…except…else…finally
• try…except…except…else…finally
• try…finally…

“try:
    x = input('Enter x: ')
    y = input('Enter y: ')
    print x / y
except ZeroDivisionError as e:
    print 'ZeroDivisionError:',e
except TypeError as e:
    print 'TypeError:',e
except BaseException as e:
    print 'BaseException:',e
else:
    print 'no error!'

print 'hello world”