字段:
静态字段
普通字段
PS:静态字段代码加载时候，已经创建
方法
所有的方法属于类
1、普通方法：至少一个self，对象执行
2、静态方法：任意参数， 类执行（对象执行）
3、类方法 ：至少一个cls， 类执行（对象执行）
属性
不论不类的东西
具有方法的写作形式，具有字段访问形式
def func(arg):
print(arg)
func(1)
func("alex")
func([11,22,33])
C#/Java
def func(int arg):#指定类型
print(arg)
func(123)
func("alex") #报错
如何实现?
class A:
pass
class B(A):
pass
class C(A):
pass
#arg参数,必须是A类型或A的子类型
def func(A arg):
print(arg)
obj = B()
obj = C()
obj = A()
func(obj)
字段
class Foo:
CC = 123 #静态字段
def __init__(self):
self.name = 'alex' #普通字段
def show(self):
print(self.name)
字段:
一般情况下,自己访问自己的字段
规则:
普通字段只能用对象访问
静态字段用类访问(万不得已的时候才可以使用对象访问)
方法:
普通方法 至少一个self, 对象执行
静态方法 任意参数, 类执行 (对象执行)
类方法 至少一个cls 类执行 (对象执行)
@staticmethod
def f1(a1,a2):
print(a1,a2)
def f2(cls):
print(cls) #cls类名,()创建对象
obj = Province('beijing')
obj.show
属性
class Pager:
def __init__(self, all_count):
self.all_count = all_count
@property #属性的获取
def all_pager(self):
a1, a2 = divmod(self.all_count, 10)
if a2 == 0:
return a1
else:
return a1 +1
@all_pager.setter
def all_pager(self, value):
print(value)
@all_pager.deleter:
print('del all_pager')
p = Pager(101)
#p.all_count#字段
print(p.all_count)
p.all_count = 102
del p.all_count
ret = p.all_pager
print(ret)
p.all_pager = 111
del p.all_pager
属性2
class Pager:
def __init__(self, all_count):
self.all_count = all_count
def f1(self):
pass
def f2(self):
pass
def f3(self):
pass
foo = property(fget=f1,fset=f2,fdel=f3)
p = Pager(101)
result = p.foo
print(result)
p.foo = 'alex'
del p.foo
成员修饰符
私有:
只能类自己本身成员内部访问
公有
pass
class Foo:
#构造方法
def __init__(self, name, age)
self.name = name
self.age = age
#析构方法
def __del__(self):
pass
def __call__(self):
print('call')
def __str__(self):
return "%s - %s" %(self.name, self.age)
obj = Foo()
obj()#对象() 执行call方法
#Foo()()
obj1 = Foo('alex',77)
ret = str(obj1) #str 方法
print(ret)
#__dict__获取对象中封装的数据
ret = obj1.__dict__
print(ret)
def __getitem__(self, item):
#item.start,item.stop,item.step
return 123
def __setitem__(self, key, value):
print('setitem')
def __delitem__(self, key):
print('del item')
dic = {"k1":123} #dic = dict(k1=123)
dic['k1'] #dic()
dic['k1'] = 123
del dic['k1']
#!/usr/bin/env python
# -*- coding:utf-8 -*-
# Author:Alex Li
class Foo:
# 构造方法
def __init__(self, name,age):
self.name = name
self.age = age
# 析构方法
def __del__(self):
pass
def __call__(self):
print('call')
def __str__(self):
return "%s - %d" %(self.name, self.age)
def __add__(self, other):
temp = "%s - %d" %(self.name,other.age)
return temp
def __getitem__(self, item):
# print(type(item),item)
# item.start item.stop item.step
print(type(item))
return 123
def __setitem__(self, key, value):
# key.start key.stop key.step
print(type(key),type(value))
def __delitem__(self, key):
# key.start key.stop key.step
print(type(key))
obj = Foo('alex', 73)
# obj() # call
# 语法对应关系
# ret1 = obj['ad']
ret2 = obj[1:4:2]
obj[1:4] = [11,22,33,44,66]
del obj[1:4]
# print(ret)
# obj['k1'] = 111
# del obj['k1']
# dic = {'k1': 123} # dic = dict(k1=123)
# dic['k1'] # dic()
# dic['k1'] = 123
# del dic['k1']
obj = Foo()
obj() # 对象() 执行call
# Foo()()
obj1 = Foo('alex', 73)
obj2 = Foo('eric', 84)
# 获取对象中封装的数据
ret = obj1.__dict__
print(ret)
# print(Foo.__dict__)
# print(obj1)
# print(obj2)
# ret = str(obj1)
# print(ret)
# ret = obj1 + obj2
# print(ret)
# __dict__
class C1:
def f1(self):
print('c1,f1')
return 123
class C2(C1):
def f1(self):
# 主动执行父类f1方法
ret = super(C2, self).f1()
print('c2.f1')
return ret
# C1.f1(self)
obj = C2()
obj.f1()
#有序字典
class MyDict(dict):
def __init__(self):
self.li = []
super(MyDict, self).__init__()
def __setattr__(self, key, value):
self.li.append(key)
super(MyDict, self).__setattr__()
def __str__(self):
temp_list = []
for key in self.li:
value = self.get(key)
temp_list.append("'%s':%s'" %(key,value,))
temp_str = "{" + ",".join(temp_list) + "}"
return temp_str
obj = MyDict()
obj['k1'] = 123
obj['k2'] = 456
print(obj)
"""
class Foo:
instance = None
def __init__(self,name):
self.name = name
@classmethod
def get_instance(cls):
#cls类名
if cls.instance:
return cls.instance
else:
obj = cls('alex')
cls.instance = obj
return obj
obj1 = Foo.get_instance()
print(obj1)
obj2 = Foo.get_instance()
print(obj2)
