Python基本语法(基于3.x)

1. Python的两种运行模式：
   • 命令行模式，运行python,然后在命令行中输入python命令
   • 程序脚本, 在命令行中输入 ./hello.py运行
2. Python是解释形语言，但可以通过工具打包成二进制可执行文件
3. 指定Python文件的编码方式:#coding:utf-8
4. 注释符为#,多行注释以'''开始，以'''结束
5. 变量不需要声明类型，可以自动推导，type()函数可以获得变量类型
6. 序列（sequence）是一组由顺序的元素的集合，各元素类型可以不同，序列分三种
   • tuple(元组):tuple中的元素不可以变更，用()定义，也可以省略(),字符串是一种特殊元组
   • list:各个元素可以再变更,用[]定义
   • range:表示由数字组成的不可变序列，通常用于循环
     
     
7. 一个序列可以作另一个序列的元素，用[]可以访问序列元素，也可以使用范围引用，表达式为[下限:上限:步长],获取的数据索引到上限前一个元素
8. 列表推导(list comprehension):快速生成表(list)的方法，示例:
   L=[x**2 for x in range(10)],这与生成器表达式类似，只不过用的是中括号
9. 词典类型的定义dic={key1:value1,key2:value2},key可以使字符串，数字，bool型等，不可变对象都可以做键，创建字典的方法有:
   

   dict([('sape', 4139), ('guido', 4127), ('jack', 4098)])
   #{'sape': 4139, 'jack': 4098, 'guido': 4127}
   
   {x: x**2 for x in (2, 4, 6)}
   #{2: 4, 4: 16, 6: 36}
   
   dict(sape=4139, guido=4127, jack=4098)
   #{'sape': 4139, 'jack': 4098, 'guido': 4127}

   字典的循环如下，注意循环的key值
   for key in dic:
       print(dic[key])
10. 字典的常用函数: keys(),values(),items(),clear()，还有一个常用用法是del dic['Tom'],删除key为Tom的元素，del是Python中的关键字，不是函数，用于删除对象
11. set:不重复元素的集合，可以用大括号或者set()函数创建set,set支持，支持交集,并集，差集等运算,并且也支持列表推导
    

    basket = {'apple', 'orange', 'apple', 'pear', 'orange', 'banana'}
    print(basket)#返回{'orange', 'banana', 'pear', 'apple'}
    
    #定义空集
    a=set()#注意{}定义的是空词典b={}
    
    a = set('abracadabra')
    b = set('alacazam')
    print(a)#{'a', 'r', 'b', 'c', 'd'}
    print(a-b)#{'r', 'd', 'b'}
    
    #列表推导,注释是大括号
    a = {x for x in 'abracadabra' if x not in 'abc'}
    print(a)#{'r', 'd'}

12. 函数定义的关键字：def, return可以返回多个值，如return a,b,c，相当于return(a,b,c)
    • 函数参数的传递，可以使用关键字传递参数，这样不用遵守位置的对应关系。定义函数时参数可以指定默认值
    • 包裹参数传递：定义函数时在相应的元组或者字典前加*或者**,如
      • func(*arr):arr是一个tuple,调用时，func(1,2,3,4)
      • func(**dic):dic是一个字典，调用时,func(a=1,b=2,c=3)
    • 解包裹:函数定义时未使用包裹参数，调用时传入包裹参数，函数会自动进行拆解，注意调用时，参数值前要加*或者**,对应tuple和字典,如:

      def func(a,b,c): 
            print(a,b,c)
      args = (1,3,4)
      func(*args) 
      

    • 函数也是对象,也可以作为参数传给其他函数
13. python中一切都是对象,class是对象，实例也是对象，python中所有对象都允许动态添加属性和方法,当类添加新属性后，类的实例同样能访问该属性。当访问一个对象的属性如obj.age时，查找该属性的顺序为:
    • 对象自身的属性(obj.__dict__中)
    • 对象的类属性(obj.__class__.__dict__中)
    • 对象的类的基类，以及基类的基类(obj.__class__.__bases__中的每一个类的__dict__)，一直下去
    • 最后未找到属性，会抛出AttributeError异常
14. Python使用class定义类，类的实例方法第一个参数必须是self,用于引用对象本身，类似于this,类的成员以self.member形式在类中访问，python中没有public,private等关键字，类成员默认都为公开的,类的私有成员命名必须以__开始,在python内部使用name mangling技术将__membername重命名为_class__membername(classname是成员所在的类名),所以使用原有的私有成员名字会提示找不到，但使用_classname__membername仍然可以访问该私有变量，所以python的私有成员不是绝对无法访问的.注意以__开始__结尾的成员是系统保留名字，普通变量不能这样命名
15. python的类方法包括三种:
    • 实例方法，至少带一个self(其他名也可以)参数，表示实例本身,由类的实例访问，也可以由类直接访问，但第一个参数的含义就变了
      

      class A:
          def test(self,age):
              print("hello")
      
      #self='b'
      A.test('b','c')
      a=A()
      #self=a，也可以写为A.test(a,’c’)
      a.test('c')

    • 带@classmethod装饰器的方法,至少带一个参数cls,表示类本身可以通过类名访问也可以通过实例访问
    • 带@staticmethod装饰器的方法，可以不带参数，由类或者类的实例访问
16. python class中的”静态方法”和”静态成员”:在python类作用域中，不带self参数的方法和不使用self访问的成员起到静态成员的作用。对静态成员要注意:
    • 静态成员使用class.member或者instance.member都可以访问(如果没有同名的实例成员，有则访问实例成员). class是类名，instance是类的实例
    • 如果静态成员是值类型,为instance.member赋值相当于新建一个与该静态成员同名的实例成员,不会影响class.Member的值，之后对class.member的改动不会反应到instance.member。如果未对instance.member进行赋值，对class.member的改动会反应到instance.member
    • 如果静态成员是引用类型，则对instance.member的改动会反应到class.member,也会反应到其他同类型实例的member
17. 继承的语法: class SubClass(ParentClass1,ParentClass2), ParentClass是父类，SubClass是子类
    
    
18. _特殊方法(special method):通过特殊的语法实现某些操作，是python实现操作符重载的方式,常用特殊方法有:
    • object.__new__(cls,…):是一个静态方法(特殊方法，不用像声明静态函数那样声明)，用于创建一个类对象，创建出的对象会传递给__init__的self参数，函数的其余参数也传递给__init__。函数的参数由构造函数而来。如果子类中重写了__new__函数，实例化对象时会调用子类的__new__,子类的__new__方法可以显示调用基类的__new__,否则不会调用基类的__new__,子类如果没重写__new__则调用基类的__new__.
    • object._init__(self,…):相当于初始化过程。如:human = Human("male"); 参数male先传给__new__再传给__init__()方法,如果父类有__init__函数，子类重写了__init__函数，应当在子类的__init__中调用父类的__init__函数以完成初始化,否则不会自动调用父类的__init__函数，如果子类没有重写__init__函数，实例化子类时则会调用父类的__init__函数
    • object.__del__():析构器,父类中如果有__del__函数，应该在子类的__del__函数中显示调用此函数以确保资源被正常释放
    • object.__call__():定义类型时，如果实现了实例方法__call__,那么实例就是可调用的，如x(5),相当于调用了x.__call__(5).如果是metaclass定义了__call__函数，那么其创建的类就是可调用的，与类实现__call__，则其实例是可调用的是一个道理
    • object__repr__():返回对象的offical representation string, 对于许多类型，将返回值传给eval()函数可以得到一个具有相同值得对象
    • object.__str__():返回对象的informal representation string
    • object.__bytes__():返回对象的byte-string representation
    • class.__subclasses__():返回直接集成该类的子
19. 特殊属性(special attributes):只读属性,常用特殊属性有:
    • object.__dict__:字典类型，存储对象的属性，不包括只读属性.要注意的是类实例的__dict__中不含其class.__dict__中的值,只包含实例本身的属性和新加的属性。
    • instance.__class__:对象的类型,准确说是创建该instance的类
    • class.__bases__:类的基类的元组,只有类类型才有该属性，实例没有
      

      #返回<class 'type'>,因为int 类是由type类创建的对象
      int.__class__
      #返回<class 'object'>,int类的基类是object
      int.__bases__
      
      x="abc"
      #返回<class 'str'>x是由str类创建的对象
      x.__class__

    • class.__name__:类名
    • class.__mro__:一个class的tuple，当解析方法时按照tuple中定义类的顺序查找基类中的方法
    • class.__module__:class所属的模块名
20. python descriptor:如果定义的类(对象)具有__get__,__set__,__delete__方法中的任意一个，这个类(对象)就叫descriptor,作用是拦截属性的访问.descriptor属性会改变普通属性访问时的查找
    

    class Descriptor(object):
        def __init__(self, label):
            self.label = label
     #本例中，instance是f,owner是Foo
        def __get__(self, instance, owner):
            print( '__get__', instance, owner)
            return instance.__dict__.get(self.label)
     
        def __set__(self, instance, value):
            print ('__set__')
    #使用__dict__生成实例属性，可以防止所有的实例都同样的值，因为descriptor是类属性
            instance.__dict__[self.label] = value
     
    class Foo(list):
    #decriptor只能应用与类属性，不能用于实例属性
        x = Descriptor('x')
        y = Descriptor('y')
    
    f = Foo()
    f.x = 5#会调用__set__
    print(f.x)#会调用__get__

    
    
21. 模块(Module):一个.py文件就是一个模块，模块名必须是小写字母和下划线，使用import关键字引入其他模块，使用模块.对象的方式来访问引入模块中的对象.每个模块中都有一个内置变量__name__,如果是模块自己运行,__name__=’__main__’,如果被其他模块import，则模块的__name__就是等于模块名(不包含扩展名),python中所有加载到内存的模块都放在sys.modules中,import一个模块时会首先查找这个列表。import的模块会被加入当前模块的名字空间，import模块时会执行模块中的代码，import package时则会执行__init__.py中的代码
22. import的一些用法：
    • import a as b :引入模块a,并重命名为b
    • from a import func1: 从模块a中引入func1对象，之后可以直接使用func1，而不用使用a.func1
    • from a import *:从模块a中引入所有对象，这样可以直接使用a中的对象，而不必用a.对象
    • module或package所在的目录再sys.path中，那么就可以import模块或package
23. Python会在以下路径搜索它想要的模块:
    • 程序所在的文件夹
    • 标准库的安装路径
    • 操作系统环境变量PYTHONPATH所包含的路径
      
      
24. package：功能相似的模块放在同一个文件夹中，就构成一个package，文件夹中必须包含一个__int__.py的文件(可以为空)以通知Python，该文件夹是一个package,通过：
    import dir.module引用dir文件夹中的module
25. 用于循环的函数：
    • range:
    • enumerate():可以在每次循环中同时得到下标和元素，for(index,value) in enumerate(arr)
    • zip():用于循环多个等长序列，每次循环从各个序列中分别取一个元素，for(a,b,c)in zip(arr1,arr2,arr3).zip的作用就是从各个序列中依次取出一个元素，合成一个tuple,返回值是一个zip类型对象，可以用list()函数转换为list类型
26. 生成器(Generator):构建一个用户自定义的循环对象，编写方法与函数类似，只是return改为yield，可以有多个yield，generator遇到yield时会暂停运行返回yield后面的值，再次调用生成器的时候，会从暂停的地方继续运行，返回下一个yield值。生成器示例:
    G=(x for x in range(4)),G就是一个生成器，用__next__()方法访问其中的值
27. 可迭代对象(iterable):python自带的iterable包括,list,str,tuple,dict ,file,自定义了__iter__()或者__getitem__()类的实例也是,iterable.iter(iterable)就返回这个对象的迭代器
28. 迭代器(iterator):__iter__方法就返回一个迭代器，迭代器可以使用next方法调用，也就是它实现了__next__方法,将一个class实现为迭代器它必须实现__iter__()和__next__()方法.迭代器只能向前迭代，不能回退，直到抛出StopIteration,不是线程安全的。for关键字是迭代器的语法糖，封装了迭代器的循环操作。python自带的类型tuple,list,set,dict,字符串都支持迭代器
29. lambda:示例 func=lambda x,y:x+y 调用跟普通函数一样，func(3,5)
30. 异常语法如下，自己抛出式样使用raise关键字
    

     try:
        ... 
    except exception1:
        ... 
    except exception2:
        ... 
    except:
        ... 
    else:
        ... 
    finally:
        ...

    如果没有异常，则执行else语句,如果没有对应的异常类型则会向上层抛出异常
    
    
31. 上下文管理器：用于规定某个对象的使用范围，语法：with ....as...，任何定义了__enter__()和__exit__()方法的对象都可用于上下文管理器

    # with context manager 
    with open("new.txt", "w") as f:  
         print(f.closed)
         f.write("Hello World!") print(f.closed)

32. 对象的Property(attribute的一种):使用内置函数property()来返回一个property，签名如下:

    property(fget=None, fset=None, fdel=None, doc=None)

    • fget:获取property value的函数,只传递此参数，省略其他参数，将会得到只读property
    • fset:设置property value的函数
    • fdel:删除property的函数
    • doc:property的注释字符
      

      class C:
          def __init__(self):
              self._x = None
      
          def getx(self):
              return self._x
          def setx(self, value):
              self._x = value
          def delx(self):
              del self._x
          x = property(getx, setx, delx, "I'm the 'x' property.")
      
      c=C();
      //调用getx
      a=c.x
      //调用setx
      c.x=9;
      //调用delx
      del c.x

33. 可以把@property当做一个装饰器，如下代码效果同上:
    

    class C:
        def __init__(self):
            self._x = None
    
        @property
        def x(self):
            """I'm the 'x' property."""
            return self._x
    #函数名要与property name相同
        @x.setter
        def x(self, value):
            self._x = value
    
        @x.deleter
        def x(self):
            del self._x

34. 通过自定义object.__getattr__函数，在对象引用的attribute不存在时自动调用该函数，此函数中返回attribute的值或者raise AttributeError exception.注意与obj.__getattribute__函数的区别，后者在每次属性访问时都会先调用，如果属性不存在才会接着调用__getattr__
    

    class Person():
    
        def __init__(self, age):
            self.age = age
        def __getattr__(self, name):
            if name == 'adult':
                if self.age > 18: return True
                else: return False
            else: raise AttributeError(name)
    
    person = Person(20)
    #类中未定义adult attr
    print(person.adult)

35. 闭包:Python中的闭包是一个包含有环境变量取值的函数对象，环境变量取值被保存在函数对象的__closure__属性中
36. 装饰器：对一个函数，方法或者类进行加工，可以使用def定义装饰器，被装饰函数或类前要加@装饰器函数,实际上将square_sum传递给decorator，并将decorator返回的新的可调用对象赋给原来的函数名,即square_sum=decor(square_sum) ,square_sum变成了new_F函数

    def decor(F): 
        def new_F(a,b):
            print('decor')   
            return F(a,b)
        return new_F
    
    @decor
    def square_sum(a, b):    
        return a**2 + b**2
    
    print(square_sum(2,3))#调用的是new_F函数
    print(square_sum(4,3))

    
    

37. 装饰器即装饰器类示例

    

    def decorator(func): # 装饰器函数
        print('in decorator')
        def wrapper(*args):
            print('in decorator wrapper')
            wrapper._calls += 1
            print("calls = %d" % (wrapper._calls))
            func(*args)
        wrapper._calls = 0
        return wrapper
    
    @decorator
    def foo(x, y):
        print("x = %d, y = %d" % (x, y))
    
    foo(1, 2) # foo对象就被赋成了wrapper对象
    """
    in decorator #定义foo时就会输出
    in decorator wrapper
    calls = 1
    x = 1, y = 2
    """
    
    foo(2, 3)
    """
    in decorator wrapper
    calls = 2
    x = 2, y = 3
    """
    #################下面是一个装饰类################################################
    class decorator: #装饰器类
        def __init__(self, func):
            print('in decorator __init__')
            self.func = func
            self.calls = 0
        def __call__(self, *args):
            print('in decorator __call__')
            self.calls += 1
            print("calls = %d" % (self.calls))
            self.func(*args)
    
    @decorator
    def foo(x, y):
        print("x = %d, y = %d" % (x, y))
    
    foo(1, 2) # foo对象被赋值成了decorator对象
    #执行过程先以foo为参数初始化decorator对象，调用foo(1,2)时则会调用decorator的__call__
    """
    in decorator __init__ #定义foo时输出
    in decorator __call__
    calls = 1
    x = 1, y = 2
    """
    
    foo(2, 3) # 实际是调用decorator对象
    """
    in decorator __call__
    calls = 2
    x = 2, y = 3
    """

38. 格式化字符串:Python使用一个字符串作模板，模板中有格式符，如print("I am %s,i am %d years old" %('Tom',10)),模板与tuple之间有一个%号分隔，它代表了格式化操作，可以用如下方式对格式进一步的控制:
    %[(name)][flags][width].[precision]typecode
    

    print("I'm %(name)s. I'm %(age)d year old" % {'name':'Vamei', 'age':99})(使用字典传递真实值)

39. 常用内置函数:

    • dir()用于查询一个类或者对象所有属性,其结果包含类或者对象的__dict__中包含的结果
    • help()用于查询说明文档
    • isinstance(objec,classinfo):返回对象是否是类的实例
    • issubclass(class,classinfo):class类是否是classinfo类的子类
    • repr():调用对象的__repr__,返回offical representation string，与反引号操作符作用相同，输出对python友好，可以作为解释器的输入
    • str():调用对象的__str__，类似于c#的toString()功能，对人友好
    • bytes():调用对象的__bytes_
    • getattr():返回对象的属性值，如果该属性不存在会抛出AttributeError
    • hasattr():判断类或对象是否包含某属性
    • setattr():设置对象的属性值,如果不存在会为对象添加新属性，但不影响类的属性.setattr(x,’name’,’tom’)相当于x.name=’tom’
    • delattr():删除属性,delattr(x,’foobar’) 相当于del x.foobar,不影响类属性
    • iter():返回一个迭代器
    • vars():返回module,class,instance,或者是其他对象(包含__dict__属性)的__dict__属性
    • zip():以多个支持迭代器的对象为参数，返回一个tuples的迭代器，然后可以使用__next__()方法访问每个tuple
    • super():访问基类函数

      class C(B):
          def method(self, arg):
       # This does the same thing as:
       # super(C, self).method(arg),相当于B.method(self,arg),但在多继承情况下super函数能避免相同基类被多次调用
              super().method(arg)

    • map(函数对象，list...):功能是将函数对象依次作用于list的每一个元素,每次作用的结果存储在返回的循环对象中，如果函数对象有多个参数，则后面可以有多个list，map函数每次从所有的list中取出一个值，作为函数的参数

    • filter(函数对象，list...):功能是将函数对象作用于多个元素，如果函数对象返回的是True,则返回该次的元素存储在循环对象中

    • reduce(函数对象，list):函数对象只能接受两个参数，可以累进的从list中取值，每一次调用函数对象的返回值与list中后面一个元素作为下次函数对象调用的参数。3.x中需要引入functools包 

40. 内置函数列表：

		Built-in Functions
abs()	dict()	help()	min()	setattr()
all()	dir()	hex()	next()	slice()
any()	divmod()	id()	object()	sorted()
ascii()	enumerate()	input()	oct()	staticmethod()
bin()	eval()	int()	open()	str()
bool()	exec()	isinstance()	ord()	sum()
bytearray()	filter()	issubclass()	pow()	super()
bytes()	float()	iter()	print()	tuple()
callable()	format()	len()	property()	type()
chr()	frozenset()	list()	range()	vars()
classmethod()	getattr()	locals()	repr()	zip()
compile()	globals()	map()	reversed()	__import__()
complex()	hasattr()	max()	round()
delattr()	hash()	memoryview()	set()