类成员：(1)字段:a.[普通字段 属于对象 执行只能通过对象访问]b.[静态字段 属于类 执行 既可以通过对象访问，也可以通过类访问]
(2)方法:a.[普通方法 保存在类中，由对象来调用 参数self 代指=>>调用对象]b.[静态方法 保存在类中，由类直接调用，不需要self参数] c.[类方法 保存在类中，由类直接调用，参数cls 代指=>> 当前类]
类成员：
#字段 （也称为：属性） 静态字段 属于类 执行 既可以通过对象访问，也可以通过类访问普通字段 属于对象 执行只能通过对象访问 （即：定义在 __init__方法中的字段）
class Foo:
def __init__(self,name):
# 字段
self.name = name
# 方法
def show(self):
print(self.name)
obj = Foo('alex')
print(obj.name) # 调用字段，后边不需要加括号
obj.show() # 调用方法，后边需要加括号
字段实例：
class Province:
# 静态字段 （类比全局变量）
country = '中国'
def __init__(self,name):
# 普通字段
self.name = name
henan = Province('河南')
hebei = Province('河北')
print(henan.name) # 输出结果：河南 #通过对象访问
print(Province.country) # 输出结果：中国 #通过类访问
print(henan.country) # 输出结果：中国 #通过对象访问
#方法
普通方法 保存在类中，需创建对象，由对象来调用 参数self 代指=>>调用对象
静态方法 保存在类中，不需创建对象，由类直接调用，加@staticmethod装饰器，不需要传self参数
类方法 保存在类中，由类直接调用，加@classmethod装饰器，需传递参数，约定俗成的self参数写法cls 代指=>> 当前类的类名对于静态方法中不需要传递self参数的情况，对比记忆必须传递self参数的，子类继承父类方法时的除了super方式外的第二种方式：fathor.func(self)
# 静态方法
class Foo:
def bar(self):
print('bar')
@staticmethod
def sta():
print('123')
@staticmethod
def stat(a1,a2):
print(a1,a2)
Foo.sta()
Foo.stat(1,2)
# 输出结果：
# 123
# 1 2
# 类方法
class Foo:
def bar(self):
print('bar')
@classmethod
def class_f(cls):
print('我自己的类名')
Foo.class_f() # 通过类直接调用访问
# 输出结果：我自己的类名
# 普通方法，静态方法，类方法的应用场景：
如果对象中需要保存一些值，在执行某功能时，
需要使用对象中的这些值的情况下，使用===》普通方法
不需要使用对象中的任何值的情况下，使用==》静态方法
在方法里边如果需要用到当前类的话，使用==》类方法
# 这里注意下，类方法，其实作用不是很大，可以通过自己构造静态方法，传递参数(类名)来实现。
# 特殊的方法类型 -- 属性 (俗称)
加上@property装饰器，既有字段的特性，又有方法的影子！
# 即：它采用方法的定义格式，字段的调用方式（也就是，调用的时候，不需要加括号。）
class Foo:
@property
def pro(self):
return 1
obj = Foo()r = obj.proprint(r)
# 输出结果：1
# 如何利用@property修改设置pro方法的默认值
class Foo:
# 用于获取值 @property
def pro(self):
return 1 # 用于修改原先方法pro的默认值 下方@pro是方法名 除了支持@pro.setter写法外，还有@pro.delete @pro.setter
def pro(self,val):
print(val)obj = Foo()r = obj.proprint(r)
# 输出结果：1# 重新设置pro的值 obj.pro = 123# 注意：对于@pro.setter 和@pro.delete 其实这里并没有真正重新设置或者删除值，而是改变了对象调用的对应关系，相当于调用了新的方法！
# 那么，属性有什么用呢？
和它的特性一样，采用方法的定义格式，采用字段的调用方式；它没有什么特殊的用处，只是为了书写的时候，简略明了，省去括号。
# 实例： 输入页码 显示分页 练习目的：通过利用属性 减少代码最后调用时，加括号。
# -*- coding: utf-8 -*-
class pagenation:
def __init__(self,current_page):
try:
# 捕捉用户输入的错误格式 （非数字类型）
p = int(current_page)
except Exception as e:
# 出现异常后 返回第1页
p = 1
self.page = p
@property
def start(self):
val = (self.page-1)*10
return val
@property
def end(self):
val = self.page * 10
return val
# 假如说相关数据有1000页
li = []
for i in range(1000):
li.append(i)
while True:
p = input('请输入要查看的页码:') #每页显示10条
# 1页 1，10
# 2页 10，20
# 3页 20，30
obj = pagenation(p)
# 因为类中采用了@property 所以下方调用start和end方法的时候，不需要加括号
print(li[obj.start:obj.end])
# 属性 property 的第二种写法 （即：不调用装饰器）
# -*- coding: utf-8 -*-
class Foo:
def f1(self):
return123
def f2(self,v):
print(v)
def f3(self):
print('del info myself define!')
# 属性 除了@property装饰器写法的另一种写法
per = property(fget=f1,fset=f2,fdel=f3,doc='相关描述')
# 注意：上方property() 括号中，算上doc,最多传递4个参数
# 参数 fget，fset，fdel 分别对应下方的三种调用方式
obj = Foo()
# 1 获取
# ret = obj.per
# print(ret)
# 2 设置
# obj.per = 123456
# 3 删除
del obj.per
# 注意：Python WEB框架 Django 的视图中 request.POST 就是使用的静态字段的方式创建的属性
class WSGIRequest(http.HttpRequest):
def __init__(self, environ):
script_name = get_script_name(environ)
path_info = get_path_info(environ)
if not path_info:
# Sometimes PATH_INFO exists, but is empty (e.g. accessing
# the SCRIPT_NAME URL without a trailing slash). We really need to
# operate as if they'd requested '/'. Not amazingly nice to force
# the path like this, but should be harmless.
path_info = '/'
self.environ = environ
self.path_info = path_info
self.path = '%s/%s' % (script_name.rstrip('/'), path_info.lstrip('/'))
self.META = environ
self.META['PATH_INFO'] = path_info
self.META['SCRIPT_NAME'] = script_name
self.method = environ['REQUEST_METHOD'].upper()
_, content_params = cgi.parse_header(environ.get('CONTENT_TYPE', ''))
if 'charset' in content_params:
try:
codecs.lookup(content_params['charset'])
except LookupError:
pass
else:
self.encoding = content_params['charset']
self._post_parse_error = False
try:
content_length = int(environ.get('CONTENT_LENGTH'))
except (ValueError, TypeError):
content_length = 0
self._stream = LimitedStream(self.environ['wsgi.input'], content_length)
self._read_started = False
self.resolver_match = None
def _get_scheme(self):
return self.environ.get('wsgi.url_scheme')
def _get_request(self):
warnings.warn('`request.REQUEST` is deprecated, use `request.GET` or '
'`request.POST` instead.', RemovedInDjango19Warning, 2)
if not hasattr(self, '_request'):
self._request = datastructures.MergeDict(self.POST, self.GET)
return self._request
@cached_property
def GET(self):
# The WSGI spec says 'QUERY_STRING' may be absent.
raw_query_string = get_bytes_from_wsgi(self.environ, 'QUERY_STRING', '')
return http.QueryDict(raw_query_string, encoding=self._encoding)
# ############### 看这里看这里 ###############
def _get_post(self):
if not hasattr(self, '_post'):
self._load_post_and_files()
return self._post
# ############### 看这里看这里 ###############
def _set_post(self, post):
self._post = post
@cached_property
def COOKIES(self):
raw_cookie = get_str_from_wsgi(self.environ, 'HTTP_COOKIE', '')
return http.parse_cookie(raw_cookie)
def _get_files(self):
if not hasattr(self, '_files'):
self._load_post_and_files()
return self._files
# ############### 看这里看这里 ###############
POST = property(_get_post, _set_post)
FILES = property(_get_files)
REQUEST = property(_get_request)
所以，定义属性共有两种方式，分别是【装饰器】和【静态字段】，而【装饰器】方式针对经典类和新式类又有所不同。
# python 成员修饰符
公有成员
私有成员
__字段名 __方法名
无法直接访问，可以通过在类内部自定义方法，间接访问。
普通字段的私有属性
静态字段的私有属性
普通方法私有性
同理，静态方法同样有私有属性
对于子类继承父类的情况，子类无法直接访问父类中的私有方法和字段，因为私有属性的私有性是相对于字段所属的类来讲的，也就是说，私有方法和私有字段只能通过所在的类内部访问调用。
# 特殊成员
类后边加（）自动调用执行__init__ 方法
对象后边加（）自动调用执行__call__方法
加减乘除
析构方法
只要对象在内存中，被垃圾回收机制找到销毁的时候，Python内部就会自动触发，执行析构方法。
__dict__ 通过字典的形式，将对象或者类的成员显示出来。
__getitem__ 实现通过索引取值
__setitem__ 实现类似列表通过索引赋值的方法
__delitem__ 实现类似列表通过索引删除相关值的方法
上述方法 没有加逻辑之前，仅仅和下方对应的相关调用语句是一一对应关系，并没有真正的修改和删除。
单例模式
