python函数的基本概念

关于函数的一些基本概念

2015年8月9日

17:49

函数属性：可以给函数添加任意属性

Def foo()

  foo.secure=1

 foo.private=1

 

函数的作用域：在函数内部如何访问全局变量？只想读取变量的值（也就是不想重绑变量）

print（参数+external）引用全局变量

 

问题：若局部变量或者参数的名字和想要访问的全局变量名相同的话，就不能直接访问了，全局变量会被局部变量所屏蔽。

若需要，可使用globals函数获得全局变量值。

Print (参数,globals['参数']).

如何重绑全局变量。若在函数内部将值赋予一个变量，它会自动成为局部变量。除非告知Python将其声明为全局变量。

 

在函数与编程中，在函数中对变量进行赋值时，这些变量始终绑定到该函数的局部命名空间中，

在函数中，如果想给全局变量赋值，则需要用关键字global声明，例如：

 

 x = 50

def func():

global x

print('x的值是', x)

x = 2

print('全局变量x改为', x)

func()

print('x的值是', x)

 

 

嵌套作用域

 

嵌套：可以将一个函数放在另一个里面，外层函数返回里层函数，被返回的函数本身并没有被调用。返回的函数还可以访问它带着的环境和相关的局部变量。

Def fa(n):

   if n==1:

      return 0

    else:

Return n*f(n-1).

 

 

 

更加抽象：

创建自己的对象类型：（尤其是类型或者是被称为类的对象，是python的核心概念）

多态：意味着可以对不同类的对象使用同样的操作。

封装：对外部世界隐藏对象的工作细节。

继承：以普通类为基础建立专门的类对象。

 

isinstance函数：查看对象是否为元组。

很多函数和运算符都是多态的，唯一能够毁掉多态的就是使用函数显示地检查类型。

 

 

如何定义类：__metaclass__=type #确定能够使用新式类

Class 类名：

    def 1（self,参数）其中self是对对象自身的引用，在调用函数1时，foo自动将自己作为第一个参数传入函数中。对于self参数而言，方法将它们的第一个参数绑定到所属的实例上，故self参数可以不必提供。

 

Foo=类名（）

Foo.1（‘参数”）

 

python并不直接支持私有方式，而是要靠程序员在外把握。

为了让方法或特性变为私有（从外部无法访问，只要在它的名字前面加上双下划线即可。

 

Class 类名：

   def __inaccessible(self):

 

  def accessible（self):

    self.__inaccessible() 最关键的一步 ，私有函数是无法从外界访问的，而在类内部的共有函数还可以继续访问。

 

 

在类的内部定义中，所有以双下划线开始的名字都被翻译成前面加上单下划线和类名的形式： _类名__私有函数的形式。

 

 

类的命名空间 ：所有位于class语句中的代码都在特殊的命名空间————类命名空间。这个命名空间可由类内所有成员访问。

        有些语句支持多种层次的成员变量（私有性），尽管单双下划线在某种程度上给出了两个级别的私有性，但python并没有真正支持私有化。

 

 

 

 

   如何扩展超类： 子类可以扩展超类的定义。将其他类名写在class语句后的圆括号内可指定超类：

 class filter():

   def __init__(self):

      self.blocked=[ ]

 

class新类名(filter):

 

此时新类名为filter的子类，而filter为新类名的超级类。

 

Def init(self):#重写filter超类中的init的方法。

 

如何调查继承：如果想要看一个类是否是一个类的子类，可使用内建的issubclass函数

     issubclass（子类，超类）

 

如果想要知道已知类的基类（们 ），[一般来说是针对子类来说的],，可直接使用它的特殊特性 __bases__：

例子：spamfilter.__bases__

 

同样道理，还能使用isinstance方法检查一个对象是否是一个类的实例:

 isinstance(函数 ，类）

 

 

如果只想知道对象属于哪一个类，可用__class__特性。

s.__class__:查看对象S属于哪一个类。

 

如何检查所需方法是否已经存在？ Hasattr(对象，'方法')

如何检查一个特性是否调用？  Hasattr(x,'call')

 

如何设置对象的特性：  setattr（tc, ,'name','xxoo')

 

g关于面向对象设计的思考：

1、将属于一类的对象放在一起

 

设计类的方法：１、写下问题的描述（程序要做什么？）

　　　　　　　２、对于所有名词，用作可能的类

　　　　　　　３、对所有动词，用作可能方向。

 

 

多个超类： 例子class A：

                                   def a:

                               class B:

                                  def  b:

                              class(A,B):

                                  pass。

 子类C：自己不做任何事情，它从自己的超类继承所有的行为。

这种行为成为多重继承，是个非常有用的工具。当使用多重继承时，若一个方法从多个超类继承（两个具有相同名字的不同方法），必须要注意超类的顺序：

                    先继承类中的方法会重写后继承的类中的方法。 在查找给定方法或特性时，访问超类的顺序被称为MRO（方法判定顺序）。

 

type函数：

def dump(value):

    print (type(value),value)

  

接口和内省：

    接口：和多态有关。在处理多态对象时，只要关心它的接口——也就是公开的方法和特性。

               不用显式地指定对象必须包含哪些方法才能作为参数来接收。一般来讲，只需要让对象符合当前的接口。

 

内置函数：__builtins__模块包含了这些函数。

Enumrate[iter.[initial,value)给定可迭代对象，返回新迭代器，

i = 0
seq = ['one', 'two', 'three']
for element in seq:
    print i, seq[i]
    i += 1
#0 one
#1 two
#2 three

 

 

for i,j in enumerate('abc'):

print(i,j)

 

 

seq = ['one', 'two', 'three']
for i, element in enumerate(seq):
    print i, seq[i]

 

Setattr(object,name,value) 其中name是字符串，与object.name=value的意思相同。

数学运算：

Demical:定义了两种基本数据类型：

1、表示十进制数的Demical类型。

2、一种表示与精度和四舍五入错误等计算有关的各种参数的context类型。

 

如何改变精度并执行计算：

Decimal.getcontext().prec=3 改变计算的精确度

 

只改变某个语句块的精度

With decimal.localhost(decimal.context(prec=10))