有注释的,应该很好懂的。。
class bird(object):#定义类bird,括号中的object,当括号中为object时,说明这个类没有父类(到头了)
have_feather=True#下面是两个属性
way_of_reproduction='egg'
summ=bird()#summ是类bird的一个对象
print (summ.way_of_reproduction)
#通过第一句创建对象,并说明summer是类别鸟中的一个对象,summer就有了鸟的类属性,对属性的引用是通过
# 对象.属性(object.attribute) 的形式实现的。
#日常认知中,我们在通过属性识别类别的时候,有时根据这个东西能做什么事情来区分类别。
# 比如说,鸟会移动。这样,鸟就和房屋的类别区分开了。这些动作会带来一定的结果,比如移动导致位置的变化。
#这样的一些“行为”属性为方法(method)。Python中通过在类的内部定义函数,来说明方法。
class bird(object):
have_feather=True
way_of_reproduction='egg'
def move(self,dx,dy):#也是一个属性
position=[1,0]
position[0]=position[0]+dx
position[1]=position[1]+dy
return position
summ =bird()
print ('after move:',summ.move(5,8))#它的参数中有一个self,它是为了方便我们引用对象自身。方法的第一个参数必须是self,无论是否用到。
#类别本身还可以进一步细分成子类,比如说,鸟类可以进一步分成鸡,大雁,黄鹂。在OOP中,我们通过继承(inheritance)来表达上述概念
class chicken(bird):#新定义的鸡类增加了两个属性
way_of_move='walk'#移动方式是walk;
possible_in_KFC=True
#在类定义时,括号里为了Bird。这说明,Chicken是属于鸟类(Bird)的一个子类,即Chicken继承自Bird。自然而然,
# Bird就是Chicken的父类。Chicken将享有Bird的所有属性。尽管我只声明了summer是鸡类,它通过继承享有了父类的属性
# (无论是变量属性have_feather还是方法属性move)
summer=chicken()
print (summer.way_of_reproduction,summer.way_of_move,summer.move(3,4))
#在定义方法时,必须有self这一参数。这个参数表示某个对象。对象拥有类的所有性质,那么我们可以通过self,调用类属性。
class human(object):
laugh='haha'
def show_laugh(self):
print (self.laugh)
def laugh_more(self):
for hehe in list(range(5)):
self.show_laugh()
sgx=human()
sgx.show_laugh()
print ('分割线')
sgx.laugh_more()
#这里有一个类属性laugh。在方法show_laugh()中,通过self.laugh,调用了该属性的值。
#通过对象可以修改类属性值。但这是危险的。类属性被所有同一类及其子类的对象共享。类属性值的改变会影响所有的对象。
#_init__()是一个特殊方法(special method)。Python有一些特殊方法。Python会特殊的对待它们。特殊方法的特点是名字前后有两个下划线。
#如果你在类中定义了__init__()这个方法,创建对象时,Python会自动调用这个方法。这个过程也叫初始化。和C++构造函数差不多。
class angrybird(bird):#bird的子类
def __init__(self,more_words):
print ('we are angry birds!',more_words)
sun=angrybird('angry')
#我们看到,尽管我们只是创建了summer对象,但__init__()方法被自动调用了。最后一行的语句(summer = happyBird...)先创建了对象,然后执行:
sun.__init__('fuck you')
#'angry' 被传递给了__init__()的参数more_words
#我们讲到了许多属性,但这些属性是类的属性。所有属于该类的对象会共享这些属性。比如说,鸟都有羽毛,鸡都不会飞。
#在一些情况下,我们定义对象的性质,用于记录该对象的特别信息。比如说,人这个类。性别是某个人的一个性质,
# 不是所有的人类都是男,或者都是女。这个性质的值随着对象的不同而不同。李雷是人类的一个对象,性别是男;韩美美也是人类的一个对象,性别是女。
#当定义类的方法时,必须要传递一个self的参数。这个参数指代的就是类的一个对象。我们可以通过操纵self,来修改某个对象的性质。
# 比如用类来新建一个对象,即下面例子中的li_lei, 那么li_lei就被self表示。我们通过赋值给self.attribute,
# 给li_lei这一对象增加一些性质,比如说性别的男女。self会传递给各个方法。在方法内部,可以通过引用self.attribute,查询或修改对象的性质。
#这样,在类属性的之外,又给每个对象增添了各自特色的性质,从而能描述多样的世界。
class Human(object):
def __init__(self, input_gender):
self.gender = input_gender
def printGender(self):
print (self.gender)
li_lei = Human('male') # 这里,'male'作为参数传递给__init__()方法的input_gender变量。
print (li_lei.gender)
li_lei.printGender()
#在初始化中,将参数input_gender,赋值给对象的性质,即self.gender。
#li_lei拥有了对象性质gender。gender不是一个类属性。Python在建立了li_lei这一对象之后,使用li_lei.gender这一对象性质,
# 专门储存属于对象li_lei的特有信息。
#对象的性质也可以被其它方法调用,调用方法与类属性的调用相似,正如在printGender()方法中的调用。
#两个内置函数,dir()和help()
#dir()用来查询一个类或者对象所有属性。你可以尝试一下
print (dir(list))
print (help(list))#list是python内置的一个类,所以我们新建一个表的时候相当于在建立这个list类的对象
nl = [1,2,5,3,5]#n1是list的一个对象
print (nl.count(5)) # 计数,看总共有多少个5
print (nl.index(3)) # 查询 nl 的第一个3的下标
nl.append(6) # 在 nl 的最后增添一个新元素6
nl.sort() # 对nl的元素排序
print (nl[0:6:1])
print (nl.pop()) # 从nl中去除最后一个元素,并将该元素返回。
nl.remove(2) # 从nl中去除第一个2
print (nl[0:5:1])
nl.insert(0,9) # 在下标为0的位置插入9
print (nl[0:6:1])
#总之,list是一个类。每个列表都属于该类。
#使用dir(list)的时候,能看到一个属性,是__add__()。从形式上看是特殊方法(下划线,下划线)。它特殊在哪呢?
#这个方法定义了"+"运算符对于list对象的意义,两个list的对象相加时,会进行的操作。
print ([1,2,3] + [5,6,9])
#运算符,比如+, -, >, <, 以及下标引用[start:end]等等,从根本上都是定义在类内部的方法。
#print ([1,2,3] - [3,4])
#会有错误信息,说明该运算符“-”没有定义。现在我们继承list类,添加对"-"的定义
#内置函数len()用来返回list所包含的元素的总数。内置函数__sub__()定义了“-”的操作:从第一个表中
# 去掉第二个表中出现的元素。如果__sub__()已经在父类中定义,你又在子类中定义了,
# 那么子类的对象会参考子类的定义,而不会载入父类的定义。任何其他的属性也是这样。
class superList(list):
def __sub__(self, b):
a = self[:] # 这里,self是supeList的对象。由于superList继承于list,它可以利用和list[:]相同的引用方法来表示整个对象。
b = b[:]
while len(b) > 0:
element_b = b.pop()
if element_b in a:
a.remove(element_b)
return a
print (superList([1,2,3]) - superList([3,4]))
#定义运算符对于复杂的对象非常有用。举例来说,人类有多个属性,比如姓名,年龄和身高。
# 我们可以把人类的比较(>, <, =)定义成只看年龄。这样就可以根据自己的目的,
# 将原本不存在的运算增加在对象上了。上面这个例子还是有点没太懂。。T_T
C:\Python30\python.exe E:/python笔记/Class.py
egg
after move: [6, 8]
egg walk [4, 4]
haha
分割线
haha
haha
haha
haha
haha
we are angry birds! angry
we are angry birds! fuck you
male
male
['__add__', '__class__', '__contains__', '__delattr__', '__delitem__', '__doc__',
'__eq__', '__format__', '__ge__', '__getattribute__', '__getitem__', '__gt__', '__hash__',
'__iadd__', '__imul__', '__init__', '__iter__', '__le__', '__len__', '__lt__', '__mul__',
'__ne__', '__new__', '__reduce__', '__reduce_ex__', '__repr__', '__reversed__', '__rmul__',
'__setattr__', '__setitem__', '__sizeof__', '__str__', '__subclasshook__', 'append', 'count',
'extend', 'index', 'insert', 'pop', 'remove', 'reverse', 'sort']
Help on class list in module builtins:
class list(object)
| list() -> new list
| list(sequence) -> new list initialized from sequence's items
|
| Methods defined here:
|
| __add__(...)
| x.__add__(y) <==> x+y
|
| __contains__(...)
| x.__contains__(y) <==> y in x
|
| __delitem__(...)
| x.__delitem__(y) <==> del x[y]
|
| __eq__(...)
| x.__eq__(y) <==> x==y
|
| __ge__(...)
| x.__ge__(y) <==> x>=y
|
| __getattribute__(...)
| x.__getattribute__('name') <==> x.name
|
| __getitem__(...)
| x.__getitem__(y) <==> x[y]
|
| __gt__(...)
| x.__gt__(y) <==> x>y
|
| __iadd__(...)
| x.__iadd__(y) <==> x+=y
|
| __imul__(...)
| x.__imul__(y) <==> x*=y
|
| __init__(...)
| x.__init__(...) initializes x; see x.__class__.__doc__ for signature
|
| __iter__(...)
| x.__iter__() <==> iter(x)
|
| __le__(...)
| x.__le__(y) <==> x<=y
|
| __len__(...)
| x.__len__() <==> len(x)
|
| __lt__(...)
| x.__lt__(y) <==> x<y
|
| __mul__(...)
| x.__mul__(n) <==> x*n
|
| __ne__(...)
| x.__ne__(y) <==> x!=y
|
| __repr__(...)
| x.__repr__() <==> repr(x)
|
| __reversed__(...)
| L.__reversed__() -- return a reverse iterator over the list
|
| __rmul__(...)
| x.__rmul__(n) <==> n*x
|
| __setitem__(...)
| x.__setitem__(i, y) <==> x[i]=y
|
| __sizeof__(...)
| L.__sizeof__() -- size of L in memory, in bytes
|
| append(...)
| L.append(object) -- append object to end
|
| count(...)
| L.count(value) -> integer -- return number of occurrences of value
|
| extend(...)
| L.extend(iterable) -- extend list by appending elements from the iterable
|
| index(...)
| L.index(value, [start, [stop]]) -> integer -- return first index of value.
| Raises ValueError if the value is not present.
|
| insert(...)
| L.insert(index, object) -- insert object before index
|
| pop(...)
| L.pop([index]) -> item -- remove and return item at index (default last).
| Raises IndexError if list is empty or index is out of range.
|
| remove(...)
| L.remove(value) -- remove first occurrence of value.
| Raises ValueError if the value is not present.
|
| reverse(...)
| L.reverse() -- reverse *IN PLACE*
|
| sort(...)
| L.sort(key=None, reverse=False) -- stable sort *IN PLACE*
|
| ----------------------------------------------------------------------
| Data and other attributes defined here:
|
| __hash__ = None
|
| __new__ = <built-in method __new__ of type object at 0x1E1BAD30>
| T.__new__(S, ...) -> a new object with type S, a subtype of T
None
2
3
[1, 2, 3, 5, 5, 6]
6
[1, 3, 5, 5]
[9, 1, 3, 5, 5]
[1, 2, 3, 5, 6, 9]
[1, 2]
Process finished with exit code 0