python学习整理

1、  “\”  换行 -

例: if （1 < 2）and \

        （2 < 3）: 

                print "11111111111111"

2、同一行写多个语句

    import sys; x = "foo"; sys.stdout.write(x+'\n')

3、 “\n” 输出换行

    print  “abc” + “\n” +“def”

    >>abc

        def

4、缩进相同的一组语句构成代码块，即代码组。像if、while、def、class这样的复合语句，首行以关键字开始，以冒号（：）结束，该行之后的一行或多行代码构成代码组， 我们将首行及后面的代码组称为一个子句（clause）。通过缩进来分隔代码组

5、多元赋值：

    >>>x, y, z = 1, 2, "aaaa"

6、两个变量交换

    >>>x, y = 1, 2

    >>>x, y = y, x

7、内建（built_in）

    built_in是__builtins__模块的成员，在程序开始或在交互解释器中给出>>>提示之前，有解释器自动导入的，可以把他们看成适用在任何一级python代码的全局变量

8、>>>s = {}.fromkeys(("a", "b", "c", "d"), 42)

    >>>print s

            {"a":42, "b":42, "c":42, "d":42}   

9、

#也可以使用'{0}','{1}'形式的占位符   print('{0},I\'m {1},my E-mail is {2}'.format('Hello','Hongten','[email protected]'))   #可以改变占位符的位置 print('{1},I\'m {0},my E-mail is {2}'.format('Hongten','Hello','[email protected]'))

#使用'{name}'形式的占位符  print('Hi,{name},{message}'.format(name = 'Tom',message = 'How old are you?'))

#5开平方，小数点保留位数依据{1}的数值
print('is,{0:.{1}f}'.format(math.sqrt(5), 4)
'is 2.2361' 

10、静态方法（staticmethod()）和类方法（classmethod()）   

classmethod：类方法
staticmethod：静态方法

在python中，静态方法和类方法都是可以通过类对象和类对象实例访问。但是区别是：

• @classmethod 是一个函数修饰符，它表示接下来的是一个类方法，而对于平常我们见到的则叫做实例方法。 类方法的第一个参数cls，而实例方法的第一个参数是self，表示该类的一个实例。
  
• 普通对象方法至少需要一个self参数，代表类对象实例
• 类方法有类变量cls传入，从而可以用cls做一些相关的处理。并且有子类继承时，调用该类方法时，传入的类变量cls是子类，而非父类。 对于类方法，可以通过类来调用，就像C.f()，有点类似C＋＋中的静态方法, 也可以通过类的一个实例来调用，就像C().f()，这里C()，写成这样之后它就是类的一个实例了。
  
• 静态方法则没有，它基本上跟一个全局函数相同，一般来说用的很少

Example 1:

> > > class a ( ) :

@staticmethod
def staticm():
print 'static'
def normalm(self):
print 'nomarl',self
@classmethod
def classm(cls):
print 'class',cls


>>> a1=a()
>>> a1.normalm()
nomarl <__main__.a instance at 0x84dddec>
>>> a1.staticm()
static
>>> a1.classm()
class __main__.a
>>> type(a)
<type 'classobj'>
>>> type(a1)
<type 'instance'>

Example 2:

class A(object):
@classmethod
def cm(cls):
print '类方法cm(cls)调用者：', cls.__name__
@staticmethod
def sm():
print '静态方法sm()被调用'

class B(A):
pass

A.cm()
B.cm()

A.sm()
B.sm()

输出：

类方法cm(cls)调用者： A
类方法cm(cls)调用者： B
静态方法sm()被调用
静态方法sm()被调用

9、所有的函数都有一个内置的属性__doc__，它会返回在函数源代码中定义的文档字符串

    引入模块，使用模块的内置属性__doc__就可以获取到模块的解释说明字符串

    >>>import sys

    >>>print sys.__doc__

    定义的函数可以通过model.function()访问到，当模块被导入时def语句会被执行，函数也就定义好，函数的文档变量是function.__doc__

10、exec和eval默认的，eval 和 exec 所运行的代码都位于当前的名称空间中，它们也可以接受一个或两个可选字典参数作为代码执行的全局名称空间和局部名称空间

    （1）exec是一个语句不是函数

            exec语句是用来执行储存在字符串或文件中的python语句

            例：>>>exec  “ if  1 < 2： print   ‘this  is  good！’ ”

                  回车结果为：this  is good！

        exec执行字符串语句存在安全风险，因为exec可能会干扰命名空间，即改变不应该变的变量。

        例如：>>>from math import sqrt

                >>>exec  "sqrt=1"

                >>>sqrt(4)

                会报错

                从上面的例子可以看出，exec干扰了命名空间，改变了sqrt的值，使其不是一个函数而变成1了。由此可见，如果对exec不加限制就会存在安全风险。下面是改进措施。

               措施：通过增加 in <scope>来实现，其中的<scope>是一个字典，该字典起到放置代码字符串命名空间的作用。这样exec执行的代码只会在<scope>代表的命名空间中起作用。如

               

        例如：>>>scope={}   #字典

                >>>from math import sqrt

                >>>exec  "sqrt=1"  in scope

                >>>sqrt(4)

                结果2.0

                >>>scope["sqrt"]

                结果1

    （2）eval

        eval 会计算字符串形式的Python表达式，并返回结果的值。

               exec语句不会返回任何对象。而eval会返回表达式的值。下面的代码可以创建一个Python计算器：

1	#Python计算器

2	print  eval(raw_input("Please input an arithmetic expression:"))

11、str和repr

    （1）str()的输出针对用户比较多，致力生成一个对象的可读性好的字符串表示

    （2）repr()的输出针对python比较友好，可通过eval()重新获得该对象

        例：>>>a = “aaa”

              >>>eval(repr(a))

            结果:"aaa"

            obj = eval(repr(obj))是成立的

>>> import types >>> type(1)==types.IntType
True >>> type("1")==types.StringType
True

12、globals返回全局变量的字典，locals返回局部变量的值

 例如：有一个名为parameter的全局变量，那么在combine（parameter）函数内部访问全局变量时，因为与参数重名，必须使用globals()['parameter']获取。代码如下：

1	defcombine(parameter):

2	printparameter+globals()['parameter']

3

4

#函数调用

5	parameter="hello"

6	combine("berry"）