python-类加载顺序-命名空间-组合

类的加载顺序

看一下下面的的代码，结果是什么？

class A:
    country = "China"
    print(country)
    def __init__(self, name):
        print("执行我吗？？")

执行的结果是：

China
执行我吗？？

类内部一个缩进的所有代码都是在py文件从上到下解释的时候就已经被执行了

class A:
    country = "China"
    print(country)
    def __init__(self):
        print("执行我吗？？")


    def func(self):
        print("func11111....")

    def func(self):
        print('func22222....')


a = A()
a.func()
'''
China
执行我吗？？
func22222....
'''

class A:
    def __init__(self):
        print('执行我了')

    def func(self):
        print('1111111')

    def func(self):
        print('2222222',A.country)

    country = 'China'
    country = 'English'

a = A()
a.func()
A().func()

'''
执行我了
2222222 English
执行我了
2222222 English

'''

类中的代码永远是从上到下依次执行的

总结：

类的加载顺序

• 1.类内部一个缩进的所有代码都是在py文件从上到下解释的时候就已经被执行了
• 2.类中的代码永远是从上到下依次执行的

类和对象的命名空间

class Student:
    def __init__(self,name,age,sex):
        self.name = name
        self.age = age
        self.sex = sex
    a = 1
    b = 2
    def func(self):
        pass

yang = Student('yang',20,'male')

# 类 和 对象 存储在两块命名空间里的
class Student:
    country = 'China'
    def __init__(self,name,country):
        self.name = name
        self.country = country

zhang = Student('zhang','日本人')
zou = Student('zou','法国人')
print(Student.country)
print(zou.country)
print(zhang.country)
# 对象去找类空间中的名字的前提 ： 在自己的空间中没有这个名字

class Student:
    country = 'China'
    def __init__(self,name):
        self.name = name

zhang = Student('zhang')
zou = Student('zou')
print(zhang.country)
Student.country = '法国人'
print(zhang.country)
zhang.country = '日本人'   # 给一个对象添加了一个属性
print(zou.country)
print(zhang.country)
# 在操作静态变量的时候应该尽量的使用类名来操作而不是使用对象名



class Person:
    money = 0
    def __init__(self,name):
        self.name = name

    def salary_deliery(self):
        Person.money += 1000



写一个类，能够自动的统计这个类有多少个对象

class A:
    Count = 0
    def __init__(self,name):
        self.name = name
        A.Count += 1

a = A('Yang')   # 创建了一个新对象
a2 = A('Yang1')
print(A.Count)

class A:
    Count = 0
    def __init__(self,name):
        self.name = name
        A.Count += 1

a = A('Yang')   # 创建了一个新对象
a2 = A('Yang1')
print(A.Count)


class B:
    l = [0]
    def __init__(self,name):
        self.name = name

b1 = B('C')
b2 = B('D')
print(B.l)
print(b1.l)
print(b2.l)
b1.l[0] += 1
print(b2.l[0])
b1.l = [123]
print(b2.l)

# 只要是对一个对象.名字直接赋值，那么就是在这个对象的空间内创建了新的属性
# 只要是对一个可变的数据类型内部的变化，那么仍然是所有的对象和类共享这个改变的成果

# 所有的静态变量都是用类名来操作，这样修改就能被所有的对象感知到
# 如果是对于可变数据类型的静态变量 操作的是这个数据内部的内容，也可以使用对象来调用

组合

# 圆形类
from math import pi
class Circle:
    def __init__(self,r):
        self.r = r

    def area(self):
        return 3.14*self.r**2

    def perimeter(self):
        return 2*3.14*self.r

# 圆环类
class Ring:
    def __init__(self,r1,r2):
        if r1>=r2:
            self.outer = r1
            self.inner = r2
        else:
            self.inner = r1
            self.outer = r2

    def area(self):
        return 3.14 * self.outer ** 2 - 3.14 * self.inner ** 2

    def perimeter(self):
        return 2 * 3.14 * self.outer + 2 * 3.14 * self.inner

# 圆柱类
class C3d:
    def __init__(self,r,h):
        self.r = r
        self.h = h

    def area(self):
        c_area = 3.14 * self.r**2
        rec_area = 2 * 3.14 *self.r * self.h
        return c_area*2 + rec_area

    def vic(self):
        c_area = 3.14 * self.r ** 2
        return c_area*self.h


# 耦合
# 紧耦合
    # 圆形面积的公式和类中方法

from math import pi
class Circle:
    def __init__(self,r):
        self.r = r

    def area(self):
        return pi*self.r**2

    def perimeter(self):
        return 2*pi*self.r

# 圆环类
class Ring:
    def __init__(self,r1,r2):
        c1 = Circle(r1)
        c2 = Circle(r2)
        if r1>=r2:
            self.outer = c1       # 组合
            # self.outer.area()   # c1.area()
            self.inner = c2       # 组合
        else:
            self.inner = c1       # 组合
            self.outer = c2       # 组合

    def area(self):
        return self.outer.area() -self.inner.area()

    def perimeter(self):
        return self.outer.perimeter() + self.inner.perimeter()

# 圆柱类
class C3d:
    def __init__(self,r,h):
        self.c = Circle(r)     # 组合
        self.h = h

    def area(self):
        c_area = self.c.area()
        rec_area = self.c.perimeter() * self.h
        return c_area*2 + rec_area

    def vic(self):
        c_area = self.c.area()
        return c_area*self.h

# 组合
    # 一个类的对象是另一个类对象的属性
    # 圆形类的对象 是圆环类对象的outer属性的值
# 计算圆形相关数据的公式只和Circle类在一起
# 其余的用到公式的地方都是通过circle类来使用的
# 公式与其他类之间的关系是一个“松耦合”关系




一个日期可不可以是一个类
class Date:
    def __init__(self,year,month,day):
        self.year = year
        self.month = month
        self.day = day

    def date(self):
        return '%s-%s-%s'%(self.year,self.month,self.day)

class Student:
    def __init__(self,name,num,birth,in_shcool,start_day):
        self.name = name
        self.num = num
        self.birth = birth     # 组合
        self.in_school = in_shcool # 组合
        self.start_day = start_day # 组合

d1 = Date(1999,10,27)
d2 = Date(2019,1,9)
d3 = Date(2019,2,9)
feng = Student('feng',10086,d1,d2,d3)
print(feng.birth.year)
print(feng.birth.month)
print(feng.birth.day)
print(feng.birth.date())

feng.start_day.month +=1
print(feng.start_day.date())


class Student:
    def __init__(self,name,num,course):
        self.name = name
        self.num = num
        self.course = course

class Course:
    def __init__(self,name,price,period):
        self.name = name
        self.price = price
        self.period = period
python = Course('python',25000,'6 months')
s1 = Student('A',10085,python)
s2 = Student('B',10084,python)
s3 = Student('C',10083,python)
# print(s1.__dict__)
python.price = 30000
python.period = '7 months'

转载于:https://www.cnblogs.com/yangchangjie150330/p/10603984.html