编程语法之 类，对象，属性，使用方法

一、嵌套函数在函数内部定义的函数

def f1():
    print("1")
    def f2():
        print("2")
    f2()

#f1()


def ChineseName(name,famliyName):
    print("{0} {1}".format(famliyName,name))

def EnglishName(name,famliyName):
    print("{0} {1}".format(name,famliyName))


def printName(isChinese,name,familyName):
    def inner_print(a,b):
        print("{0} {1}".format(a,b))

    if isChinese:
        inner_print(familyName,name)

    else:
        inner_print(name,familyName)


printName(False,"xuan","li")

二、nonlocol关键字

1、概念

nonlocal用来声明外层的局部变量

global 用来声明全局变量

2、测试

def outer():
    b=10
    a=1000

    def inner():
        nonlocal b
        print("inner:",b)
        b=20


        global a
        a=1000

    inner()
    print("outer:",b)

outer()
print("a:",a)

三、LEGB规则

1、概念：在查重名称时，按照local enclosed global built in 顺序查找

local：方法内部

enclosed：嵌套函数

global：全局变量

built in：特殊名称

其实就是由里到外查找

str="global"

def outer():
    #str="outer"


    def inner():
        #str="inner"
        print(str)

    inner()


outer()

四、面向对象编程

1、面向对象和面向过程的区别

1）面向过程更加关注的是程序逻辑流程

2）面向对象关注的是软件中对象之间的关系，适合大规模的程序

2、面向对象思考方式：

遇到复杂问题，先从问题中找名词，确立类，根据需求确定类的属性和方法，确定类之间的关系。

五、对象的进化

1、说明：随着编程面临的问题越来越复杂，语言也在进化。从主要处理简单数据开始，随着数据变多进化“数组”，数据类型变复杂，进化出了结构体，处理数据的方式和逻辑变复杂，进化出了对象。

数据：1，2，3

数组：（1，2，3）

结构体：包含了类别

对象

六、类的定义

1、类的结构：属性+方法

属性：数据对应的状态

方法：函数行为对应了行为

2、定义类示例

class Student:
    def __init__(self,name,age):
    #构造方法
        self.name=name
        self.age=age


    def score(self):
        print("{0}的分数是：{1}".format(self.name,self.age))


s=Student("lixuan",24)
s.score()

七、构造函数

1、对象的组成：id，type，value

2、构造函数用于执行实例对象的初始化工作，即对象创建后，初始化当前对象的属性。

八、实例属性

1、概念：实例属性是属于实例对象的属性，也成为实例变量。

2、实例方法

class Student:
    def __init__(self,name,age):
    #构造方法
        self.name=name
        self.age=age


    def score(self):
        print("{0}的分数是：{1}".format(self.name,self.age))


s=Student("lixuan",24)
s.score()


s.age=32
s.salary=3000
print(s.salary)
s1=Student("JAMES",36)
print(s1.name,s1.age)

九、实例方法

1、要定义一个实例方法，第一个参数必须为self，self指当前实例对象

2、调用实例方法时，不需要也不能给self传参，self由解释器自动传参

3、函数和方法的区别：

1）都是用用来完成一个功能的语句块，本质一样

2）方法调用时，通过对象来调用，函数没有这个特点。

3）方法需要传递self，函数不需要

4、dir（object）可以获得对象的所有属性，方法

5、obj.__dict__对象的属性字典。

6、pass语句

class Student:
    def __init__(self,name,age):
    #构造方法
        self.name=name
        self.age=age


    def score(self):
        print("{0}的分数是：{1}".format(self.name,self.age))


s=Student("lixuan",24)
s.score()


s.age=32
s.salary=3000
print(s.salary)
s1=Student("JAMES",36)
print(s1.name,s1.age)
print(dir(s1))
print(s1.__dict__)

十、类对象

1、class 类名：会创造一个类对象

class student:
    pass
print(id(student))
print(type(student))

十一、类属性

1、概念：从属于类对象的属性，也成为类变量。可以被所有实例对象共享。实例在__init__构造函数中，类属性在class下直接添加，无需定义在函数下。

2、示例：

class student:
    company="tencent"
    #类属性
    def __init__(self,name,age):
        self.name=name
        self.age=age
        #实例属性

十二、类方法

1、格式：

@classmethod

def 类方法名（cls）:

        函数体

2、要点：

1）classmethod必须位于方法上面一行

2）第一个cls必须有，指的是类对象本身

3）调用方法通过类名.类方法名调用

3、测试：

class student:
    company="tencent"
    #类属性
    def __init__(self,name,age):
        self.name=name
        self.age=age
        #实例属性

    @classmethod
    def printCompany(cls):
        print(cls.company)

student.printCompany()

类方法和静态方法中不能调用实例变量

十三、静态方法

1、允许定义与类对象无关的方法，成为静态方法。

2、与普通函数没有区别

3、格式

@staticmethod

def 静态方法名（形参列表）

       函数体

十四、__del__析构函数

1、作用：销毁对象

2、也可以通过del语句删除对象。

3、python会自动提供__del__方法，不需要自定义析构方法。

4、示例：

class Person:
    def __del__(self):
        print("销毁对象：{0}".format(self))

p1=Person()
p2=Person()
del p2
print("程序结束")

15、call()方法

1、功能：定义了方法的对象，成为可调用对象，可以像调用函数一样被调用

2、测试

#测试可调用方法__call__()

class SalaryAccount:
    '''计算工资'''
    def __call__(self, salary):
        print("算工资了")
        yearSalary=salary*12
        daySalary=salary//22.5
        hourSalary=daySalary//8
        return dict(yearSalary=yearSalary,monthsalary=salary,daySalary=daySalary,hourSalary=hourSalary)




s=SalaryAccount()
print(s(30000))

本文地址：https://blog.csdn.net/weixin_51182518/article/details/109641474