python入门篇-2

有注释的，应该很好懂的。。

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