函数

Python 定义函数使用 def 关键字，一般格式如下：
定义语法：def 函数名（参数列表）:
函数体

可更改(mutable)与不可更改(immutable)对象

在 python 中，strings, tuples, 和 numbers 是不可更改的对象，而 list,dict 等则是可以修改的对象。

不可变类型：变量赋值 a=5 后再赋值 a=10，这里实际是新生成一个 int 值对象 10，再让 a 指向它，而 5 被丢弃，不是改变 a 的值，相当于新生成了 a。

可变类型：变量赋值 la=[1,2,3,4] 后再赋值 la[2]=5 则是将 list la 的第三个元素值更改，本身la没有动，只是其内部的一部分值被修改了。

python 函数的参数传递：

不可变类型：类似 C++ 的值传递，如 整数、字符串、元组。如 fun(a)，传递的只是 a 的值，没有影响 a 对象本身。如果在 fun(a)）内部修改 a 的值，则是新生成来一个 a。

可变类型：类似 C++ 的引用传递，如 列表，字典。如 fun(la)，则是将 la 真正的传过去，修改后 fun 外部的 la 也会受影响

也就是说，参数是不可变类型内部修改后外面不会改变，可变类型在内部修改后外部也会受影响。

# 可写函数说明
def changeme(a):
    "修改传入的列表"
    a.append([1, 2, 3, 4])
    print("函数内取值: ", a)
    return
# 调用changeme函数
mylist = [10, 20, 30]
changeme(mylist)
print("函数外取值: ", mylist)
##返回
函数内取值:  [10, 20, 30, [1, 2, 3, 4]]
函数外取值:  [10, 20, 30, [1, 2, 3, 4]]

参数

必需参数
关键字参数 ：使用关键字参数允许函数调用时参数的顺序与声明时不一致
默认参数：调用函数时，如果没有传递参数，则会使用默认参数。
不定长参数:加了星号 * 的参数会以元组(tuple)的形式导入，存放所有未命名的变量参数。
def printinfo( arg1, *vartuple ): #vartuple 是元组名称如果在函数调用时没有指定参数，它就是一个空元组。
加了两个星号 ** 的参数会以字典的形式导入。

# 可写函数说明
def printinfo( arg1, **vardict ):
   "打印任何传入的参数"
   print ("输出: ")
   print (arg1)
   print (vardict)
 
# 调用printinfo 函数
printinfo(1, a=2,b=3)
#输出: 
1
{'a': 2, 'b': 3}

匿名函数

python 使用 lambda 来创建匿名函数。
lambda的主体是一个表达式，而不是一个代码块。lambda 函数拥有自己的命名空间，且不能访问自己参数列表之外或全局命名空间里的参数

# 函数说明,可以看成一个sum( arg1, arg2)的函数
sum = lambda arg1, arg2: arg1 + arg2
 
# 调用sum函数
print ("相加后的值为 : ", sum( 10, 20 ))
#返回 30

return语句

return [表达式] 语句用于退出函数，选择性地向调用方返回一个表达式。不带参数值的return语句返回None。
可以利用元组直接返加多个值

def f(a,b,*e):
       return e

h,i,j=f(1,2,4,5,6,c=3)
print ('h=',h,'i=',i,'j=',j)
##返回h= 4 i= 5 j= 6

模块

模块是一个包含所有你定义的函数和变量的文件，其后缀名是.py,模块可以被别的程序引入，以使用该模块中的函数等功能。这也是使用 python 标准库的方法。模块的搜索路径是在Python编译或安装的时候确定的，安装新的库应该也会修改。搜索路径被存储在sys模块中的path变量

引入三个的方法

语法： import module1[, module2[,… moduleN]
实例：import Wmodle #引入文件名为Wmodle.py的模块
Wmodle.inputText(handle,Text) #调用Wmodle内的inputText 方法
如果你打算经常使用一个函数，你可以把它赋给一个本地的名称：
imputText= Wmodle.inputText
inputText(handle,Text)

语法 from modname import funname1[, funname2[, … funnameN]]
实例：import Wmodle import imputText #这个声明不会把整个Wmodle模块导入到当前的命名空间中，它只会将Wmodle里的imputText函数引入进来
inputText(handle,Text) #引用时也不用再加模块名称

语法 from modname import *
把一个模块的所有内容全都导入到当前的命名空间，但是那些由单一下划线（_）开头的名字不在此例。 , Python程序员不使用这种方法，因为引入的其它来源的命名，很可能覆盖了已有的定义。

__name__属性

模块除了方法定义，还可以包括可执行的代码。这些代码一般用来初始化这个模块。这些代码只有在第一次被导入时才会被执行。如果我们想在模块被引入时，模块中的某一程序块不执行，我们可以用__name__属性来使该程序块仅在该模块自身运行时执行。当__name__属性值是’main’时，表明该模块自身在运行，否则是被引入。

# Filename: using_name.py
if __name__ == '__main__':
   print('程序自身在运行')
else:
   print('我来自另一模块')

dir() 函数

内置的函数 dir(modname ) 可以找到模块内定义的所有名称。以一个字符串列表的形式返回:
如果没有给定参数，那么 dir() 函数会罗列出当前定义的所有名称:

类

类对象支持两种操作：属性引用和实例化。
属性引用使用和 Python 中所有的属性引用一样的标准语法：obj.name。
类对象创建后，类命名空间中所有的命名都是有效属性名。所以都是可以在实例化后被访问

类的构造方法话__init__() ，该方法在类实例化时会自动调用

类的方法

在类的内部，使用 def 关键字来定义一个方法，与一般函数定义不同，类方法必须包含参数 self, 且为第一个参数，self 代表的是类的实例
self代表类的实例，而非类,self 不是 python 关键字，我们把他换成 runoob 或是使用 this都是可以的，但是最好还是按照约定是用 self。

类的私有属性

__private_attrs：两个下划线开头，声明该属性为私有，不能在类的外部被使用或直接访问。在类内部的方法中使用时 self.__private_attrs。

类的私有方法

__private_method：两个下划线开头，声明该方法为私有方法，只能在类的内部调用 ，不能在类的外部调用。self.__private_methods。

#类定义
class people:
    #定义基本属性
    name = ''
    age = 0
    #定义私有属性,私有属性在类外部无法直接进行访问
    __weight = 0
    #定义构造方法
    def __init__(self,n,a,w):
        self.name = n
        self.age = a
        self.__weight = w
    def speak(self):
        print("%s 说: 我 %d 岁。" %(self.name,self.age))
 
# 实例化类
p = people('runoob',10,30)
p.speak()

继承

语法：class DerivedClassName(BaseClassName1，[BaseClassName2…]):
#需在构造函数调用父类的构函
如果你的父类方法的功能不能满足你的需求，你可以在子类重写你父类的方法，重写后可以通过super() 函数是用于调用父类(超类)的一个方法。

类的专有方法：

init : 构造函数，在生成对象时调用
del : 析构函数，释放对象时使用
repr : 打印，转换
setitem : 按照索引赋值
getitem: 按照索引获取值
len: 获得长度
cmp: 比较运算
call: 函数调用
add: 加运算
sub: 减运算
mul: 乘运算
truediv: 除运算
mod: 求余运算
pow: 乘方

运算符重载

Python同样支持运算符重载，我们可以对类的专有方法进行重载
实例：

class Vector:
   def __init__(self, a, b):
      self.a = a
      self.b = b
 
   def __str__(self):
      return 'Vector (%d, %d)' % (self.a, self.b)
   
   def __add__(self,other):
      return Vector(self.a + other.a, self.b + other.b)
 
v1 = Vector(2,10)
v2 = Vector(5,-2)
print (v1 + v2)

常见的格式化符号

格式符号 转换
%s 通过str()字符串转换来格式化
%u 无符号的十进制整数
%d 有符号的十进制整数
%o 八进制整数
%x 十六进制整数，小写字母
%X 十六进制整数，大写字母
%e 浮点数字(科学计数法)
%E 浮点数字(科学计数法，用E代替e)
%f 浮点实数
%g 浮点数字(根据值的大小采用%e或%f)
%G 浮点数字(类似于%g)

参考：https://www.runoob.com/python3/python3-function.html

Python @函数装饰器及用法
那么，函数装饰器的工作原理是怎样的呢？假设用 funA() 函数装饰器去装饰 funB() 函数，如下所示：
#funA 作为装饰器函数
def funA(fn):
#…
fn() # 执行传入的fn参数
#…
return ‘…’
@funA
def funB():
#…

实际上，上面程序完全等价于下面的程序：
def funA(fn):
#…
fn() # 执行传入的fn参数
#…
return ‘…’
def funB():
#…
funB = funA(funB)
通过比对以上 2 段程序不难发现，使用函数装饰器 A() 去装饰另一个函数 B()，其底层执行了如下 2 步操作：
将 B 作为参数传给 A() 函数；
将 A() 函数执行完成的返回值反馈回 B。
参考http://c.biancheng.net/view/2270.html