Python学习笔记七其它核心类型

#ipython3

In [1]: X = set('spam')

In [2]: Y = {'h','a','m'}

In [3]: X,Y
Out[3]: ({'a', 'm', 'p', 's'}, {'a', 'h', 'm'})

In [4]: X & Y
Out[4]: {'a', 'm'}

In [5]: X | Y
Out[5]: {'a', 'h', 'm', 'p', 's'}

In [6]: X - Y
Out[6]: {'p', 's'}

In [7]: {x ** 2 for x in [1,2,3,4]}
Out[7]: {1, 4, 9, 16}

In [1]: 1 / 3
Out[1]: 0.3333333333333333

In [2]: (2/3) + (1/2)
Out[2]: 1.1666666666666665

In [3]: import decimal

In [4]: d = decimal.Decimal('3.141')

In [5]: d + 1
Out[5]: Decimal('4.141')

In [6]: decimal.getcontext().prec = 2

In [7]: decimal.Decimal('1.00') / decimal.Decimal('3.00')
Out[7]: Decimal('0.33')

In [8]: from fractions import Fraction  

In [9]: f = Fraction(2,3)

In [10]: f + 1
Out[10]: Fraction(5, 3)

In [11]: f + Fraction(1,2)
Out[11]: Fraction(7, 6)

In [1]: 1 > 2 , 1 < 2
Out[1]: (False, True)

In [2]: bool('spam')
Out[2]: True

In [3]: X = None

In [4]: print(X)
None

In [5]: L = [None] * 5

In [6]: L
Out[6]: [None, None, None, None, None]

In [7]: type(L)
Out[7]: list

In [8]: type(type(L))
Out[8]: type

除了允许交互地探究对象，这个函数的实际应用是，允许编写代码来检查它所处理的对象的类型。实际上，在Python脚本中至少有三种方法可以做到这点。

In [11]: if type(L) == type([]):  
   ....:     print('yes')
   ....:     
yes

In [13]: if type(L) == list:
   ....:     print('yes')
   ....:     
yes

In [15]: if isinstance(L,list):
   ....:     print('yes')
   ....:     
yes

尽管我们提供了所有的类型的检验方法，但其实，在Python程序中这样做基本都是错误的！在代码中检验了特定的类型，实际上破坏了它的灵活性，即 限制它只能使用一种类型工作，而没有这样的检测，代码也许能够使用整个范围的类型工作。这与前面我们讲到的多态的思想有些关联，它是由Python没有类 型声明而发展出来的。在Python中，我们编写对象接口（所支持的操作）而不是类型。不关注与特定的类型意味着代码会自动适应它们中的很多类型：任何具 有兼容接口的对象均能够工作，而不管它是什么对象类型。

class Worker:
    def __init__(self,name,pay):
        self.name = name
        self.pay = pay
    def lastName(self):
        return self.name.split()[-1]               //split()默认分割为空格
    def giveRaise(self,percent):
        self.pay *= (1.0 + percent)

bob = Worker('Bob Smith',5000)
sue = Worker('Sue Jones',6000)
print(bob.lastName())
print(sue.lastName())
print(sue.pay)

Smith
Jones
6600.000000000001

隐含的‘self’对象是我们把这叫做面向对象型的原因，即一个类中的函数总是有一个隐含的对象。一般来说，基于类的类型是建立在并使用了核心类型的。