Python学习记录——Python函数及对象

记载内容目录：

1.函数操纵
    a.函数定义
    b.参数的定义 定参与不定参以及函数重载
    c.参数默认值
    d.传递引用和引用外部变量
    e.修改全局变量
    f.lambda写法 和 函数传递
    g.函数内定义函数
2.对象操纵
    1）对象定义
        a.构造函数和析构函数
        b.定义成员变量和成员方法
        c.定义私有成员和公有成员
        d.类的静态方法
    2）继承于多态
        a.继承方法
        b.访问规则
        c.覆写父类方法

1.函数操纵

a.函数定义

def 函数名（参数列表）:
    函数体

#函数定义
def FirstFunc():
    print("\n\nHello,MyFirstFunc!")
#函数调用
FirstFunc()

b.参数的定义 定参与不定参以及函数重载

#1. 定参
def SecondFunc(arg1,arg2):
    #do something

#2. 不定参  函数重载
def SecondFunc(arg1,arg2,*arg3):
    print("\n\nSecondFunc(arg1,arg2,*arg3):")
    print(arg1)
    print(arg2)
    print(arg3)

SecondFunc(None,"Python","test","func")

# 输出
# SecondFunc(arg1,arg2,*arg3):
# None
# Python
# ('test', {'sdfs': 23, 'ss': 'llllll'})

c.参数默认值

#3.默认值
def ThreeFunc(arg1,arg2 = "default"):
    #do something

d.传递引用和引用外部变量

#4.传递引用和直接访问全局变量
val = "python"
def FourFunc(arg_list,arg_dirc):
    print("\n\nFourFunc(arg_list,arg_dirc):")
    print(arg_list) # list是个引用
    print(arg_dirc) # dirc是个引用
    print(val)      #直接访问全局变量 //只读不写 写请往下看
    key = "change_key"
    if key in arg_dirc:
        arg_dirc[key] = "FourFunc(arg_list,arg_dirc):"
    return "test"

e.修改全局变量

#5 修改全局变量
def FiveFunc():
    print("\n\ndef FiveFunc():")
    global val  #如果需要修改全局变量则需要添加global标示字，如果只是访问全局变量直接直接引用
    print(val)
    val = "fefefe"
    print(val)

#除了global标识符，还有nonlocl

f.lambda写法 和 函数传递

#6 lambda 和 函数传递
#lambda 写法：lambda [arg1 [,arg2,.....argn]]:expression
def SixFunc(callBack):
    print("\n\ndef SixFunc(callBack):")
    callBack("@def SixFunc(callBack):")


#lambda写法  这里的 or 是用来连接多行lambda表达式的
func1 = lambda arg:print("lambda arg:") or print(arg)

SixFunc(func1)
#输出
#def SixFunc(callBack):
#lambda arg:
#@def SixFunc(callBack):


# 函数写法
def ArgFunc(arg):
    print("def ArgFunc(arg):")
    print(arg)
func2 = ArgFunc

SixFunc(func2)
#输出
#def SixFunc(callBack):
#def ArgFunc(arg):
#@def SixFunc(callBack):

g.函数内定义函数

def GetFunc():
    print("Execute GetFunc()")

    # 在方法体内定义一个函数，并且返回
    def TestFunc():
        print("Execute TestFunc()")
        # do something

    return TestFunc

back_func = GetFunc()
back_func()
#输出
#Execute GetFunc()
#Execute TestFunc()

2.对象操纵

1）对象定义

a.构造函数和析构函数
b.定义成员变量和成员方法
c.定义私有成员和公有成员
d.类的静态方法

# 所有带双下划线的函数，变量都是私有的
# 所有的对象方法第一个变量必定是自己，也必须是自己,但可以自己命名，例如 self，this...
class HelloClass:
    val = ""  #public 成员变量
    __val2 = ""  #private 成员变量

    # 构造函数
    def __init__(self,val):
        self.val = "Hello,Class" + str(val)

    # 析构函数
    def __del__(self):
        print(self.val,"__del__")

    # 自定义函数
    # public
    def Print(self,arg):
        print("\n")
        print(self.val)
        print(arg)
        self.__Print()

    # private 所有加双下划线的都是private类型
    def __Print(self):
        print("Private Function")

    # public static
    @staticmethod
    def PrintHelloClass():
        print("PrintHelloClass  HelloClass")


HelloClass.PrintHelloClass()
# 输出
# PrintHelloClass  HelloClass

x1 = HelloClass(None)
x1.Print("__X1.Hello")
del x1 #删除对象

# 输出
# Hello,ClassNone
# __X1.Hello
# Private Function
# Hello,ClassNone __del__

x2 = HelloClass("X2")
x2.Print("__X2.Hello")
del x2

# 输出
# Hello,ClassX2
# __X2.Hello
# Private Function
# Hello,ClassX2 __del__

2）继承于多态

a.继承方法
b.访问规则
c.覆写父类方法

class BassClass:
    val = ""
    def __init__(self,val):
        self.val = "BassClass" + str(val)

    def Print():
        print("\nBassClass")

# 继承方法 ChildClass(BassClass1,BassClass2,...)
# 支持多继承 继承访问规则是从左往右找 即 先从当前对象里面找，找不到就去第一个父类里面找，以此类推
class ChildClass(BassClass):
    def __init__(self,val):
        BassClass.__init__(self,val) #按照继承顺序初始化父类
        self.val = "ChildClass" + str(val)

    # Override
    def Print(self):    
        print("\nChildClass" + "    " + str(self.val))


obj = ChildClass("obj")
obj.Print() 
#输出
#ChildClass    ChildClassobj