Python学习笔记No1

本篇博客是博主自己在这里：https://github.com/jackfrued/Python-100-Days 学习Python时做的一些笔记，由于我已经有了一些基础（因为学习过C语言、Java等，其中涉及到的有比如多线程、GUI、网络编程等内容），所以这里做的笔记可能对于新手来说比较有跳跃性。如果你确实有这样的体会，那建议去找其他路径来学习。买过一本关于Python爬虫的书，附了张学习Python的学习路线图，分享给大家下，仅供想要学习Python的同学参考：

本篇包括：

• 语言设计基础
• 面向对象编程
• 图形用户界面和游戏开发

一、语言设计基础

1、注释

单行注释 - 以#和空格开头的部分

多行注释 - 三个引号开头，三个引号结尾

2、运算符

示例1

a = 5
print("a = ", a)
flag1 = 3 > 2
print("flag1 = ", flag1)

示例2

#!/usr/bin/python
# -*- coding: latin-1 -*-
import os, sys

f = float(input('请输入华氏温度：'))
c = (f - 32) / 1.8
print('%.1f华氏度 = %.1f摄氏度' % (f, c))

示例3

#!/usr/bin/python
# -*- coding: latin-1 -*-
import os, sys, math

radius = float(input('Please input redius of the cicle: '))
perimeter = 2 * math.pi * radius
area = math.pi * radius * radius
print('Perimeter = %.2f' % perimeter)
print('Area = %.2f' % area)

示例4

# 输入年份 如果是闰年输出True 否则输出False

year = int(input('Please input a year: '))
# 如果代码太长写成一行不便于阅读 可以使用\或()折行
is_leap = (year % 4 == 0 and year % 100 != 0 or
           year % 400 == 0)
print(is_leap)

3、分支结构

1. 和C/C++、Java等语言不同，Python中if…else…没有用花括号来构造代码块,而是使用了缩进的方式来设置代码的层次结构。如果if条件成立的情况下需要执行多条语句，只要保持多条语句具有相同的缩进就可以了;换句话说连续的代码如果又保持了相同的缩进那么它们属于同一个代码块，相当于是一个执行的整体。

示例5-1

# 用户身份验证

username = input('Input Username: ')
password = input('Input Password: ')
# 如果希望输入Password时 终端中没有回显 可以使用getpass模块的getpass函数
# import getpass
# password = getpass.getpass('Input Password: ')
if username == 'admin' and password == '123456':
    print('Success!')
else:
    print('Fault!')

2. 如果要构造出更多的分支，则使用if…elif…else…结构。

示例5-2

"""
分段函数求值：

        3x - 5  (x > 1)
f(x) =  x + 2   (-1 <= x <= 1)
        5x + 3  (x < -1)

"""

x = float(input('x = '))
if x > 1:
    y = 3 * x - 5
elif x >= -1:
    y = x + 2
else:
    y = 5 * x + 3
print('f(%.2f) = %.2f' % (x, y))

示例6

# 掷骰子决定做什么事情

from random import randint
face = randint(1, 6)        #使用random模块的randint函数生成指定范围的随机数来模拟掷骰子
if face == 1:
    result = 'Sing'
elif face == 2:
    result = 'Dance'
elif face == 3:
    result = 'Paint'
elif face == 4:
    result = 'Socccer'
elif face == 5:
    result = 'Tennis'
else:
    result = 'Cold Joke'
print(result)

4、循环结构

• Python中构造循环结构有两种做法，一种是for-in循环，一种是while循环：如果明确的知道循环执行的次数或者要对一个容器进行迭代（后面会讲到），那么我们推荐使用for-in循环；否则，推荐使用while循环。

示例7

# 用for循环实现1~100求和

sum = 0
for x in range(101):
    sum += x
print(sum)

"""
range可以用来产生一个不变的数值序列，而且这个序列通常都是用在循环中的，例如：
range(101)可以产生一个0到100的整数序列。
range(1, 100)可以产生一个1到99的整数序列。
range(1, 100, 2)可以产生一个1到99的奇数序列，其中的2是步长，即数值序列的增量——
    此结构可以实现功能：1~100之间的偶数求和——
        只需将range(101)替换成range(2, 101, 2)即可。
"""

示例8

"""
猜数字游戏
计算机出一个1~100之间的随机数由人来猜
计算机根据人猜的数字分别给出提示大一点Larger/小一点Smaller/猜对了
"""

import random
answer = random.randint(1, 100)
counter = 0
while True:
    counter += 1
    number = int(input('Input a guess number: '))
    if number < answer:
        print('Larger')
    elif number > answer:
        print('Smaller')
    else:
        print('Guess Right!')
        break
print('You guessed %d times.' % counter)

循环结构_练习

示例9

# 输入一个正整数判断它是不是素数

from math import sqrt
num = int(input('请输入一个正整数: '))
end = int(sqrt(num))
is_prime = True
for x in range(2, end + 1):
    if num % x == 0:
        is_prime = False
        break
if is_prime and num != 1:
    print('%d是素数' % num)
else:
    print('%d不是素数' % num)

示例9

• 我的解法：

# 输入两个正整数，计算最大公约数和最小公倍数
# 注意最大公约数与最小公倍数的关系！！！

a = int(input("请输入一个正整数："))
b = int(input("请再输入一个正整数："))
if a >= b:
    min = b
else:
    min = a
while(min != 1):
    if(a % min == 0 and b % min == 0):
        print('%d和%d的最大公约数是：%d' % (a, b, min))
        print('%d和%d的最小公倍数是：%d' % (a, b, a * b // min))
        break
    else:
        min -= 1

• 老师解法：

# 输入两个正整数，计算最大公约数和最小公倍数

x = int(input('x = '))
y = int(input('y = '))
if x > y:
    x, y = y, x 					# 啥意思？？？
for factor in range(x, 0, -1):
    if x % factor == 0 and y % factor == 0:
        print('%d和%d的最大公约数是%d' % (x, y, factor))
        print('%d和%d的最小公倍数是%d' % (x, y, x * y // factor))
        break

示例10

"""
Craps赌博游戏:
玩家摇两颗色子，如果第一次摇出的两筛子之和为7点或11点——玩家胜；
如果摇出2点 3点 12点——庄家胜；
其他情况时，则需要玩家再次摇这两颗色子：如果和为7点——庄家胜；
如果和与第一次相同——玩家胜。
玩家进入游戏时有1000元的资本，玩家每次选择赌注，直至全部输光，游戏结束。
"""
from random import randint

money = 1000        # 玩家的总资产...不需要在意庄家的，始终是玩家的总资产在改变着
while money > 0:
    print('你的总资产为：%d' % money)
    needs_go_on = False
    while True:
        debt = int(input('请下注：'))
        if debt > 0 and debt <= money:
            break
    first = randint(1, 6) + randint(1, 6)
    print('玩家摇出了%d点' % first)
    if first == 7 or first == 11:
        print('Player Success')
        money += debt
    elif first == 2 or first == 3 or first == 12:
        print('Zhuangjia Success')
        money -= debt
    else:                   # 摇出的两筛子之和不是7/11/22/3/12的情况
        needs_go_on = True

    while needs_go_on:
        current = randint(1, 6) + randint(1, 6)
        print('玩家摇出了%d点' % current)
        if current == 7:
            print('Zhuangjia Success')
            money -= debt
            needs_go_on = False
        elif current == first:
            print('Player Success')
            money += debt
            needs_go_on = False

print('你破产了...Game Over! ')

示例11

# 输出斐波那契数列的前20个数

a = 0
b = 1
for _ in range(20):
    a, b = b, a + b
    print(a)

• 讲解：Python中的赋值语法——从右往左进行计算，然后再依次(从左往右)赋值
  1、a, b = b, a + b 等价于：a = b, b = a + b。过程：
  temp = b # 先保存b的原值
  b = a + b # 赋b新值
  a = temp # 将b的原值赋予a
  2、a, b = 1, 3 等价于 a = 1, b = 3

示例12

# 判断输入的正整数是不是回文数

num = int(input('请输入一个正整数: '))
temp = num
num2 = 0
while temp > 0:
    num2 *= 10          # 每次扩大十倍，为下面加上“个位”做准备
    num2 += temp % 10   # 每次得到temp的最低位
    temp //= 10         # 每次得到舍去temp最低位后的那个数
if num == num2:
    print('%d是回文数' % num)
else:
    print('%d不是回文数' % num)

示例13

"""
找出1~9999之间的所有完美数
完美数是除自身外其他所有因子的和正好等于这个数本身的数
例如: 6 = 1 + 2 + 3, 28 = 1 + 2 + 4 + 7 + 14
"""

for i in (1, 10000):
    sum = 0
    for factor in range(1, int(math.sqrt(num)) + 1):
        if num % factor == 0:
            sum += fator;
            # 如28可以被2整除，那么其结果14也必定是28的因子。这里就是这样找出它的“另一半”的
            if factor > 1 and num / factor != factor:
                sum += num / factor
    if sum == num:
        print(num)

5、函数

函数的定义

Python中的函数与其他语言中的函数有很多不太相同的地方，其中一个显著的区别就是Python对函数参数的处理。在Python中，函数的参数可以有默认值，也支持使用可变参数，所以Python并不需要像其他语言一样支持函数的重载，因为我们在定义一个函数的时候可以让它有多种不同的使用方式，下面是两个小例子。

• 为参数设定默认值

from random import randint

"""
摇色子

:param n: 色子的个数
:return: n颗色子点数之和
"""
def roll_dice(n=2):
    total = 0
    for _ in range(n):
        total += randint(1, 6)
    return total

def add(a=0, b=0, c=0):
    return a + b + c

# 如果没有指定参数那么使用默认值摇两颗色子
print(roll_dice())
# 摇三颗色子
print(roll_dice(3))
print(add())
print(add(1))
print(add(1, 2))
print(add(1, 2, 3))
# 传递参数时可以不按照设定的顺序进行传递
print(add(c=50, a=100, b=200))

• 设置可变参数

# 在参数名前面的*表示args是一个可变参数
# 即在调用add函数时可以传入0个或多个参数
def add(*args):
    total = 0
    for val in args:
        total += val
    return total

print(add())
print(add(1))
print(add(1, 2))
print(add(1, 2, 3))
print(add(1, 3, 5, 7, 9))

函数的管理——用模块管理函数

• 由于Python没有函数重载的概念，那么后面的函数定义会覆盖之前的函数定义，也就意味着两个函数同名函数实际上只有一个是存在的。那么如何使得两个同名函数都能够互不干扰的存在呢？答案其实很简单，Python中每个文件就代表了一个模块（module），在不同的模块中可以有同名的函数，在使用函数的时候我们通过import关键字导入指定的模块就可以区分到底要使用的是哪个模块中的foo函数，代码如下所示。

module1.py

def foo():
    print('hello, world!')

module2.py

def foo():
    print('goodbye, world!')

方式1
test.py

from module1 import foo
foo()				# 输出hello, world!

from module2 import foo
foo()				# 输出goodbye, world!

方式2
test.py

import module1 as m1
import module2 as m2

m1.foo()
m2.foo()

错误示范：后导入的foo覆盖了之前导入的foo

from module1 import foo
from module2 import foo

# 输出goodbye, world!
foo()

• 需要说明的是，如果我们导入的模块除了定义函数之外还中有可以执行代码，那么Python解释器在导入这个模块时就会执行这些代码，事实上我们可能并不希望如此，因此如果我们在模块中编写了可执行代码，最好是将这些执行代码放入如下所示的条件中，这样的话除非直接运行该模块，否则if条件下的这些代码（函数中的可执行代码）是不会执行的，因为只有直接执行的模块（或者说是“当前正在执行的模块”）的名字才是“main”。

module3.py

def foo():
    pass

def bar():
    pass

# __name__是Python中一个隐含的变量，它代表模块的名字
# 只有被Python解释器直接执行的模块的名字才是__main__
if __name__ == '__main__':
    print('call foo()')
    foo()
    print('call bar()')
    bar()

test.py

import module3

# 导入module3时，不会执行模块中if条件成立时的代码，因为if中模块的名字_name_是module3而不是__main__，所以不符合if执行的条件。所以我们导入的module3模块中的可执行代码不会执行。

• Python中有关变量作用域的问题的讨论具体请参考这里。

def foo():
    b = 'hello'

    def bar(): 			 # Python中可以在函数内部再定义函数
        c = True
        print(a)
        print(b)
        print(c)

    bar()
    # print(c)  # NameError: name 'c' is not defined

if __name__ == '__main__':
    a = 100
    # print(b)  # NameError: name 'b' is not defined
    foo()

说明：输出为100 hello True。原因请点击上面的链接进行查看（之所以没有解释，是因为自己会，只是为了以防万一又不会，所以还是简单的放在这里以下）。

• 从现在开始我们可以将Python代码按照下面的格式进行书写，这一点点的改进其实就是在我们理解了函数和作用域的基础上跨出的巨大的一步。

def main():
    # Todo: Add your code here
    pass 		# pass写在任何缩进的语句块部分，只是占位，什么事情都不做。为了满足python的语法要求。

if __name__ == '__main__':
    main()

6、常用数据结构-练习题

Click Here.

二、面向对象编程

1、基础

类是对象的蓝图和模板，而对象是类的实例。可以看出，类是抽象的概念，而对象是具体的东西。在面向对象编程的世界中，一切皆为对象，对象都有属性和行为，每个对象都是独一无二的，而且对象一定属于某个类（型）。当我们把一大堆拥有共同特征的对象的静态特征（属性——通过类中的变量描述）和动态特征（行为——通过类中的方法描述【 写在类中的函数，我们通常称之为（对象的）方法】）都抽取出来后，就可以定义出一个叫做“类”的东西。

类的定义、创建、使用

务必仔细阅读下面的程序及注释，描述了相关的语法规则。更详细的Python中类的定义的解释，请看这里。

class Student(object):

    # __init__是一个特殊方法用于在创建对象时进行初始化操作
    # 通过这个方法我们可以为学生对象绑定name和age两个属性
	def __init__(self, name, age):		# self参数是类中的每个方法的参数都必须有的，用于指示本对象，相当于Java中的this
		self.name = name
		self.age = age

	def study(self, course_name):
		print('%s正在学习%s.' % (self.name, course_name))

    # PEP 8要求标识符的名字用全小写多个单词用下划线连接
    # 但是部分程序员和公司更倾向于使用驼峰命名法(驼峰标识)
	def watch_movie(self):
		if self.age < 18:
			print('%s只能看《熊出没》.' % self.name)
		else:
			print('%s正在看喜欢的电影.' % self.name)


def main():
	stu1 = Student('zjy', 18)	        # 自动调用__init__方法，使‘Student’赋值给self，‘zjy’赋值给name，'18'赋值给age
	stu1.study('Python程序设计')
	stu1.watch_movie()


if __name__ == '__main__':
	main()

类中属性/方法的访问权限

在Python中，属性和方法的访问权限只有两种，也就是公开的和私有的，如果希望属性是私有的，在给属性命名时可以用两个下划线作为开头，下面的代码可以验证这一点。

class Test:

    def __init__(self, foo):
        self.__foo = foo 			# 左侧的__foo是类中的属性，foo只是参数罢了

    def __bar(self):
        print(self.__foo)
        print('__bar')


def main():
    test = Test('hello')    # 自动调用__init__方法，使‘Test’赋值给self，‘hello’赋值给foo

    # (私有方法)AttributeError: 'Test' object has no attribute '__bar'
    test.__bar()
    
    # (私有属性)AttributeError: 'Test' object has no attribute '__foo'
    print(test.__foo)


if __name__ == "__main__":
    main()

但是，Python并没有从语法上严格保证私有属性或方法的私密性，它只是给私有的属性和方法换了一个名字来“妨碍”对它们的访问，事实上如果你知道更换名字的规则，那么你仍然可以访问到那些所谓的私有属性。下面的代码就可以验证这一点，并且你可以从中知道“更换名字的规则”。之所以这样设定，可以用这样一句名言加以解释，就是“We are all consenting adults here”。因为绝大多数程序员都认为开放比封闭要好，而且程序员要自己为自己的行为负责。

class Test:

    def __init__(self, foo):
        self.__foo = foo

    def __bar(self):
        print(self.__foo)
        print('__bar')


def main():
    test = Test('hello')	
    test._Test__bar() 		# 使私有的__bar()方法变成“公有”
    print(test._Test__foo)  # 使私有的__foo属性变成“公有”


if __name__ == "__main__":
    main()

在实际开发中，我们并不建议将属性设置为私有的，因为这会导致子类无法访问（后面会讲到）。所以大多数Python程序员会遵循一种命名惯例就是让属性名以单下划线开头来表示属性是受保护的，本类之外的代码在访问这样的属性时应该要保持慎重。这种做法并不是语法上的规则，因为单下划线开头的属性和方法外界仍然是可以访问的，所以更多的时候它是一种暗示或隐喻：“虽然我可以被访问，但是，请把我视为私有变量，不要随意访问”。

• 练习1：定义一个类描述数字时钟

from time import sleep

class Clock(object):

	def __init__(self, hour=0, minute=0, second=0):
		# 成员变量hour、minute、second是“受保护”的——名称以单个下划线开始
		self._hour = hour   
		self._minute = minute
		self._second = second


	def run(self):
		self._second += 1
		if self._second == 60:
			self._second = 0;

			self._minute += 1
			if self._minute == 60:
				self._minute = 0

				self._hour += 1
				if self._hour == 24:
					self._hour = 0


	def show(self):
		return '%02d:%02d:%02d' % (self._hour, self._minute, self._second)


def main():
	clock = Clock(23, 59, 58)
	while True:
		print(clock.show())
		sleep(1)
		clock.run()

（除非手动停止，否则不停显示。）

• 练习2：定义一个类描述平面上的点并提供移动点和计算到另一个点距离的方法

from math import sqrt

class Point(object):

	def __init__(self, x=0, y=0):
		self.x = x
		self.y = y


	def show(self):
		print('点在平面上的位置：x = %d, y = %d' % (self.x, self.y))


	def distance(self, other):
		dx = self.x - other.x
		dy = self.y - other.y
		return sqrt(dx ** 2 + dy ** 2)


	def move_to(self, x, y): 
		"""移动到指定位置

		:param x: 新的横坐标
		"param y: 新的纵坐标
		"""
		self.x = x
		self.y = y


	def move_by(self, dx, dy):
		"""移动指定的增量

		:param dx: 横坐标的增量
		"param dy: 纵坐标的增量
		"""
		self.x += dx
		self.y += dy


def main():
	p1 = Point(3, 5)
	p2 = Point()

	p1.show()
	p2.show()

	p2.move_by(-1, 2)
	p2.show()

	print(p1.distance(p2))


if __name__ == '__main__':
	main()

面向对象的三大支柱 之 封装

• “隐藏一切可以隐藏的实现细节，只向外界暴露（提供）简单的编程接口”。我们在类中定义的方法其实就是把数据和对数据的操作封装起来了，在我们创建了对象之后，只需要给对象发送一个消息（调用方法）就可以执行方法中的代码，也就是说我们只需要知道方法的名字和传入的参数（方法的外部视图），而不需要知道方法内部的实现细节（方法的内部视图）。

2、进阶

@property装饰器

以上，我们知道了：不建议将属性设置为私有的，但是如果直接将属性暴露给外界也是有问题的，比如我们没有办法检查赋给属性的值是否有效。我们之前的建议是将属性命名以单下划线开头，通过这种方式来暗示属性是受保护的，不建议外界直接访问，那么如果想访问属性可以通过属性的getter（访问器） 和 setter（修改器） 方法进行对应的操作。如果要做到这点，就可以考虑使用 @property包装器 来包装getter和setter方法，使得对属性的访问既安全又方便，代码如下所示。

class Person(object):

	def __init__(self, name, age):
		self._name = name
		self._age = age

# 必须要先getter方法，然后再setter方法，否则会有编译错误

	@property       # 访问器：getter方法
	def age(self):  
		return self._age
	

	@property       # 访问器：getter方法
	def name(self):
		return self._name


	@age.setter     # 修改器：setter方法
	def age(self, age):
		self._age = age


	def play(self):
		if self._age <= 16:
			print('%s正在玩飞行棋...' % self._name)
		else:
			print('%s正在玩斗地主...' % self._name)


def main():
	person = Person('zjy', 12)
	person.play()

	"""
	为了重新为person._age赋值，系统根据此语句将自动调用相应的set方法，重新为_age赋值。
	这里使用的是_age，实际上，使用person.age也ok，
	但其他age的变形就不行了，也就是说，可以是_age或age，
	看下一知识点就可以知道如何进行名称使用的限制了
	"""
	person._age = 22     

	"""
	你以为下面也是为变量重新赋值的语句，但其实：TypeError: 'int' object is not callable.
	所以，这是一种错误的重新为成员变量赋值的方法，与Java不太相同的地方。
	Java要写出调用的set方法为变量赋值，
	而这里的重新赋值应该写成上面那样，系统明白(@age.setter)你是想重新为变量赋值。
	"""
#	person.age(22)       

	person.play()

	"""
	下面的语句：AttributeError: can't set attribute. 
	因为没有提供name的set方法(@name.setter)，所以不能修改此属性。
	"""
#	person.name = 'zyy'  


	"""
	如何通过所谓的get方法调用属性值？这里有必要说一下：
	你以为：print('姓名：%c' % person.name())
	但实际：print('姓名：%c' % person.name)
	又与Java不同，这里不把他们当做方法来使用，而是直接当作成员变量！
	然后会自动调用相应的get方法~
	"""
	print('姓名：%s' % person.name)
	

if __name__ == '__main__':
	main()

__slots__魔法

至此，你应该知道Python是一门动态语言。通常，动态语言允许我们在程序运行时给对象绑定新的属性或方法，当然也可以对已经绑定的属性和方法进行解绑定。但是如果我们需要限定自定义类型的对象只能绑定指定的某些属性，可以通过在类中定义__slots__变量来进行限定。需要注意的是 __slots__的限定只对当前类的对象生效，对子类并不起任何作用。

class Person(object):

	# 限定Person对象只能绑定_name，_age和_gender属性
	__slots__ = ('_name', '_age', '_gender')

	def __init__(self, name, age):
		self._name = name
		self._age = age


	@property
	def name(self):
		return self._name


	@property
	def age(self):
		return self._age


	@age.setter
	def age(self, age):
		self._age = age


	def play(self):
		if self._age <= 16:
			print('%s正在玩飞行棋.' % self._name)
		else:
			print('%s正在玩斗地主.' % self._name)
	
def main():
	person = Person('zjy', 22)
	person.play()
	person._gender = '男' # 这回就不可以用person.gender了！因为属性名已经被限制了！ 


if __name__ == '__main__':
	main()

@staticmethod 与 @classmethod

在此之前，我们在类中定义的方法都称为对象方法，也就是说这些方法都是发送给对象的消息。下面，我们来学习两种非写给对象的方法，而是属于类的方法。

@staticmethod

使用@staticmethod定义出来的方法叫做静态方法。例如我们定义一个“三角形”类，通过传入三条边长来构造三角形，并提供计算周长和面积的方法，但是传入的三条边长未必能构造出三角形对象，因此我们可以先写一个方法来验证三条边长是否可以构成三角形，这个方法很显然就不是对象方法，因为在调用这个方法时三角形对象尚未创建出来（因为都不知道三条边能不能构成三角形），所以这个方法是属于三角形类而并不属于三角形对象的。

from math import sqrt

class Triangle(object):

	def __init__(self, a, b, c):
		self._a = a
		self._b = b
		self._c = c

	@staticmethod
	def is_valid(a, b, c):
		return a + b > c and b + c > a and a + c > b

	# 求三角形周长
	def perimeter(self):
		return self._a + self._b + self._c

	# 求三角形面积
	def area(self):
		half = self.perimeter() / 2
		return sqrt(half * (half - self._a) * (half - self._b) * (half - self._c))


def main():
	a, b, c = 3, 4, 5
	# 静态方法(以及下面要讲的类方法)都是通过给类发消息来调用的
	if Triangle.is_valid(a, b, c):    # 关键语句！！！
		t = Triangle(a, b, c)

		# 调用对象方法的第一种方式
		print(t.perimeter())
#		调用对象方法的第二种方式：通过给类发消息，此时需要传入接收消息的类对象作为参数
#		print(Triangle.perimeter(t))

		print(t.area())   # 等价于：print(Triangle.area(t))
	else:
		print('无法构成三角形...')


if __name__ == '__main__':
	main()

@classmethod

和静态方法比较类似，Python还可以在类中定义类方法，类方法的第一个参数约定名为cls，它代表的是与当前类相关的信息的对象（类本身也是一个对象，有的地方也称之为类的元数据对象），通过这个参数我们可以获取和类相关的信息并且通过此创建出类的对象，代码如下所示。

from time import time, localtime, sleep

class Clock(object):
    """数字时钟"""

    def __init__(self, hour=0, minute=0, second=0):
        self._hour = hour
        self._minute = minute
        self._second = second

    @classmethod
    def now(cls):
        ctime = localtime(time())	# 调用Python内置函数localtime()、time()
        return cls(ctime.tm_hour, ctime.tm_min, ctime.tm_sec)

    def run(self):
        """走字"""
        self._second += 1
        if self._second == 60:
            self._second = 0
            self._minute += 1
            if self._minute == 60:
                self._minute = 0
                self._hour += 1
                if self._hour == 24:
                    self._hour = 0

    def show(self):
        """显示时间"""
        return '%02d:%02d:%02d' % \
               (self._hour, self._minute, self._second)


def main():  
    clock = Clock.now()		# 关键语句——通过类方法创建对象并获取系统时间
    while True:
        print(clock.show())
        sleep(1)
        clock.run()


if __name__ == '__main__':
    main()

类之间的关系

简单的说，类和类之间的关系有三种：is-a、has-a和use-a关系：

• is-a关系也叫继承或泛化，比如学生和人的关系、手机和电子产品的关系都属于继承关系。
• has-a关系通常称之为关联，比如部门和员工的关系，汽车和引擎的关系都属于关联关系；关联关系如果是整体和部分的关联，那么我们称之为聚合关系；如果整体进一步负责了部分的生命周期（整体和部分是不可分割的，同时同在也同时消亡），那么这种就是最强的关联关系，我们称之为合成关系。
• use-a关系通常称之为依赖，比如司机有一个驾驶的行为（方法），其中（的参数）使用到了汽车，那么司机和汽车的关系就是依赖关系。

我们可以使用一种叫做UML（统一建模语言）的东西来进行面向对象建模，其中一项重要的工作就是把类和类之间的关系用标准化的图形符号描述出来。关于UML我们在这里不做详细的介绍，有兴趣的读者可以自行阅读《UML面向对象设计基础》一书。

利用类之间的这些关系，我们可以在已有类的基础上来完成某些操作，也可以在已有类的基础上创建新的类，这些都是实现代码复用的重要手段。复用现有的代码不仅可以减少开发的工作量，也有利于代码的管理和维护，这是我们在日常工作中都会使用到的技术手段。

面向对象的三大支柱 之 继承

上面已提到：可以在已有类的基础上创建新类。这其中的一种做法就是让一个类从另一个类那里将属性和方法直接继承下来，从而减少重复代码的编写。提供继承信息的我们称之为父类，也叫超类或基类；得到继承信息的我们称之为子类，也叫派生类或衍生类。子类除了继承父类提供的属性和方法，还可以定义自己特有的属性和方法，所以子类比父类拥有的更多的能力，在实际开发中，我们经常会用子类对象去替换掉一个父类对象，这是面向对象编程中一个常见的行为，对应的原则称之为里氏替换原则。下面我们先看一个继承的例子。

class Person(object):

	def __init__(self, name, age):
		self._name = name
		self._age = age

	@property
	def name(self):
		return self._name
	
	@property
	def age(self):
		return self._age
	
	@age.setter
	def age(self, age):
		self._age = age

	def play(self):
		print('%s正在愉快的玩耍.' % self._name)

	def watch_tv(self):
		if self._age >= 18:
			print('%s正在观看泡沫剧.' % self._name)
		else:
			print('%s只能观看《熊出没》.' % self._name)


class Student(Person):

	def __init__(self, name, age, grade):

		super(Student, self).__init__(name, age)
#		下面是Python3中的用法
#		super().__init__(name, age)
		self._grade = grade

	@property
	def grade(self):
		return self._grade

	@grade.setter
	def grade(self, grade):
		self._grade = grade

	def study(self, course):
		print('%s的%s正在学习%s.' % (self._grade, self._name, course))


class Teacher(Person):

	def __init__(self, name, age, title):  # title表示老师的职位
		super(Teacher, self).__init__(name, age)
#		下面是Python3中的用法
#		super().__init__(name, age)
		self._title = title

	@property
	def title(self):
		return self._title
	
	def teach(self, course):
		print('%s%s正在讲%s' % (self._name, self._title, course))


def main():
	stu = Student('zjy', 15, '初三')
	stu.study('数学')
	stu.watch_tv()

	t = Teacher('zyy', 38, '教授')
	t.teach('Python程序设计.')
	t.watch_tv


if __name__ == '__main__':
	main()

面向对象的三大支柱 之 多态

子类在继承了父类的方法后，可以对父类已有的方法给出新的实现版本，这个动作称之为方法重写（override）。通过方法重写我们可以让父类的同一个行为在子类中拥有不同的实现版本，当我们调用这个经过子类重写的方法时，不同的子类对象会表现出不同的行为，这一现象就被称作多态（poly-morphism）。

from abc import ABCMeta, abstractmethod

class Pet(object, metaclass=ABCMeta):  # metaclass=ABCMeta必须要在3.5版本以上的Python环境下才可以啊

	def __init__(self, nickname):
		self._nickname = nickname

	@abstractmethod	# 在父类中定义抽象方法，当有子类继承时，就要写此抽象方法
	def make_voice(self)
		pass


class Dog(Pet):

	def make_voice(self):
		print('%s: 汪汪汪' % self._nickname)


class Cat(Pet):

	def make_voice(self):
		print('%s 喵喵喵' % self._nickname)


def main():
	pets = [Dog('旺财'), Cat('凯蒂'), Dog('大黄')]   # 一个宠物列表
	for pet in pets:
		pet.make_voice()


if __name__ == '__main__':
	main()

在上面的代码中，我们将Pet类处理成了一个抽象类，所谓抽象类就是不能够创建对象的类，这种类的存在就是专门为了让其他类去继承它。Python从语法层面并没有像Java或C#那样提供对抽象类的支持，但是我们可以通过abc模块的ABCMeta元类和abstractmethod包装器来达到抽象类的效果，如果一个类中存在抽象方法那么这个类就不能够实例化（创建对象）。上面的代码中，Dog和Cat两个子类分别对Pet类中的make_voice抽象方法进行了重写并给出了不同的实现版本，当我们在main函数中调用该方法时，这个方法就表现出了多态行为（同样的方法做了不同的事情）。

• 练习1：奥特曼打小怪兽

简要描述：

1. 奥特曼和小怪兽是敌对的两方，两者要进行战斗。其父类称之为“战斗者”，有属性战斗者名称、战斗者生命值、alive（该属性是判断生命值是否大于0得出的：alive为True表示生命值大于0，表示还存活在游戏中），此外，有一个待继承的表示攻击形式的抽象方法attack()。
2. 奥特曼类：除了有名字、生命值属性外，又添加了魔法值属性。具有继承来的表示普通攻击形式的attack()方法以及魔法攻击形式的magic_attack()方法以及终级必杀技攻击形式的huge_attack()方法，由于魔法值会因为使用了普通攻击而增加，所以还具有增加魔法值的resume()方法。
3. 小怪兽类：具有从父类继承来的名字、声明值属性，以及普通攻击形势的attack()方法。
4. 三个全局函数：
   1）is_any_alive()：判断一群小怪兽里还有没有是活着的
   2）select_alive_one()：选中一只活着的小怪兽（用来与奥特曼战斗）
   3）display_info()：显示奥特曼和小怪兽的相关战斗信息

from abc import ABCMeta, abstractmethod
from random import randint, randrange


class Fighter(object, metaclass=ABCMeta):
	"""战斗者（父类），将由奥特曼（子类）、小怪兽（子类）继承"""

	# 通过__slots__魔法限定对象可以绑定的成员变量
	__slots__ = ('_name', '_hp')

	def __init__(self, name, hp):
		"""
		初始化方法

		:param name: 名字
		:param hp: 生命值
		"""
		self._name = name
		self._hp = hp

	@property
	def name(self):
		return self._name

	@property
	def hp(self):
		return self._hp

	@hp.setter
	def hp(self, hp):
		self._hp = hp if hp >= 0 else 0

	@property
	def alive(self):
		return self._hp > 0
	
	@abstractmethod
	def attack(self, other):
		"""
		攻击

		:param other: 被攻击的对象
		"""
		pass
	
			
class Ultraman(Fighter):
	"""奥特曼"""

	__slots__ = ('_name', '_hp', '_mp')

	def __init__(self, name, hp, mp):
		"""
		初始化方法

		:param name: 名字
		:param hp: 生命值
		:param mp: 魔法值
		"""
		super().__init__(name, hp)
		self._mp = mp

	def attack(self, other): 
		other.hp -= randint(15, 25) 

	def huge_attack(self, other):
		"""
		终级必杀技(打掉对方至少50点或四分之三的血)

		:param other: 被攻击的某个对象
		:return: 使用成功返回True否则返回False
		"""
		if self._mp >= 50:
			self._mp -= 50
			injury = other.hp * 3 // 4
			injury = injury if injury >= 50 else 50
			other.hp -= injury
			return True
		else:		# 使用终级必杀技需要消耗50魔法值，此为魔法值不足的情况，无法使用终级必杀技，改为使用普通攻击
			self.attack(other)
			return False

	def magic_attack(self, others):
		"""
		魔法攻击

		:param others: 被攻击的群体（使用魔法攻击可以一次性攻击多个小怪兽）
		:return: 使用魔法成功返回True否则返回False
		"""
		if self._mp >= 20:
			self._mp -= 20
			for temp in others:
				if temp.alive:
					temp.hp -= randint(10, 15)
			return True
		else:				# 魔法值不足20时无法使用魔法攻击
			return False

	def resume(self):
		"""
		恢复随机点数的魔法值

		:return: 返回新增的点数
		"""
		incr_point = randint(1, 10)
		self._mp += incr_point
		return incr_point

	def __str__(self):
		return '~~~%s奥特曼~~~\n' % self._name + \
				'生命值：%d\n' % self._hp + \
				'魔法值：%d\n' % self._mp


class Monster(Fighter):
	"""小怪兽"""

	__slots__ = ('_name', '_hp')

	def attack(self, other):
		other.hp -= randint(10, 20)

	def __str__(self):
		return '~~~%s小怪兽~~~\n' % self._name + \
				'生命值：%d\n' % self._hp


def is_any_alive(monsters):
	"""判断有没有小怪兽是活着的"""
	for monster in monsters:
		if monster.alive > 0:
			return True
	return False


def select_alive_one(monsters):
	"""选中一只活着的小怪兽"""
	monsters_num = len(monsters)
	while True:
		index = randrange(monsters_num)
		monster = monsters[index]
		if monster.alive > 0:
			return monster


def display_info(ultraman, monsters):
	"""显示奥特曼和小怪兽的相关战斗信息"""
	print(ultraman) 			# 自动调用__str__方法
	for monster in monsters:	
		print(monster, end='')  # 自动调用__str__方法


def main():
	u = Ultraman('zjy', 1000, 120)
	m1 = Monster('aaa', 250)
	m2 = Monster('bbb', 500)
	m3 = Monster('ccc', 750)
	ms = [m1, m2, m3]
	fight_round = 1 		 # 大战回合数
	while u.alive and is_any_alive(ms): # alive()是父级中的用来得到alive变量的get方法，该方法用来判断_hp 是否大于0 只有大于0才说明战斗者活着，只有活着才能进行下面的动作。活着的话就返回True，True == 1
		print('=========第%02d回合========' % fight_round)
		m = select_alive_one(ms) 	# 选中一只小怪兽参与战斗
		skill = randint(1, 10)		# 通过随机数选择使用哪种技能
		if skill <= 6:		# skill为1 ~ 6时，奥特曼使用普通攻击
			print('%s使用普通攻击打了%s.' % (u.name, m.name))
			u.attack(m)
			print('%s的魔法值恢复了%d点.' % (u.name, u.resume()))      # 每使用一次普通攻击，魔法值都会有一定补给
		elif skill <= 9: 	# skill为6 ~ 9时，奥特曼使用魔法攻击
			if u.magic_attack(ms):
				print('%s成功使用魔法攻击了小怪兽群体.' % u.name)
			else:
				print('%s魔法值不足，魔法攻击失败.' % u.name)
		else: # skill为10时，奥特曼使用终级必杀技
			if u.huge_attack(m):
				print('%s使用终级必杀技虐了%s.' % (u.name, m.name))
			else:
				print('%s使用普通攻击打了%s.' % (u.name, m.name))
				print('%s的魔法值恢复了%d点.' % (u.name, u.resume())) # 每使用一次普通攻击，魔法值都会有一定补给
		if m.alive > 0: # 如果与奥特曼战斗的小怪兽没有死，就回击奥特曼
		# 不能替换成if m.alive() == True！因为alive其实是个get到的成员变量...
			print('%s回击了%s.' % (m.name, u.name))
			m.attack(u)
		display_info(u, ms)  # 每个回合结束后显示奥特曼和小怪兽的信息
		fight_round += 1
	print('\n========战斗结束!========\n')
	if u.alive > 0:
		print('%s奥特曼胜利!' % u.name)
	else:
		print('小怪兽胜利!')


if __name__ == '__main__':
	main()

运行结果部分截图：

• 练习2：扑克游戏

简要说明

1. “一张牌”类
   属性：花色、点数
   方法：用来以统一的格式输出每张牌的__str__方法
2. “一副牌”类
   属性：保存了一整副牌的cards属性、用来判断是否发了牌的current属性
   方法：洗牌、发牌、判断牌是否已全部发完
3. “玩家”类
   属性：玩家姓名name、 玩家手中的所有牌cards_on_hand
   方法：摸牌、整理手中的牌
4. 全局函数get_key(card)用来定义排序规则-先根据花色再根据点数排序。

import random

class Card(object):
    """一张牌"""

    def __init__(self, suite, face):
        """
        :suite: 花色
        :face: 点数
        """
        self._suite = suite
        self._face = face

    @property
    def face(self):
        return self._face

    @property
    def suite(self):
        return self._suite

    def __str__(self):
        if self._face == 1:
            face_str = 'A'
        elif self._face == 11:
            face_str = 'J'
        elif self._face == 12:
            face_str = 'Q'
        elif self._face == 13:
            face_str = 'K'
        else:
            face_str = str(self._face)
        return '%s%s' % (self._suite, face_str)
    
    def __repr__(self): 		# 类的一个专有方法，用来打印、转换
        return self.__str__()


class Poker(object):
    """一副牌"""

    def __init__(self):
        """
        :cards: 保存了一整副牌
        :current: 用来判断是否发了牌：current为0表示还没有发牌；每发一张拍current就会加1；同时也作为cards的索引，从而可以取到每一张牌
        """
        self._cards = [Card(suite, face)   # ？？？这个初始化看不懂？？？？？？？？？？？？？？？？？？？？？？？？？？？？
                       for suite in '♠♥♣♦'
                       for face in range(1, 14)] # 没有大王小王...
        self._current = 0       # _cards _current都是成员变量吗？参数里面没有啊？所以意思是只要出现在__init__函数中的就代表是成员变量？？

    @property
    def cards(self):
        return self._cards 

    def shuffle(self):
        """洗牌(随机乱序)"""
        self._current = 0
        random.shuffle(self._cards) # 这不是有吊用自己了吗？这怎么行。。。？？？？？？？？？？？？？？？？？？？？？？？？？？？？？

    @property
    def next(self):
        """
        发牌

		:return: 返回发的那张牌
        """
        card = self._cards[self._current] # current作为索引，取到将要发的牌self._cards[self._current]
        self._current += 1				  # 每发一张牌，surrent就变化
        return card 					  

    @property
    def has_next(self):
        """还有没有牌"""
        return self._current < len(self._cards)	# 判断是否发了牌，如果发完了牌，那么current的值应该是52(没有大王小王)


class Player(object):
    """玩家"""

    def __init__(self, name):
        """
        :name: 玩家姓名
        :cards_on_hand: 玩家手中的牌
        """
        self._name = name
        self._cards_on_hand = []

    @property
    def name(self):
        return self._name

    @property
    def cards_on_hand(self):
        return self._cards_on_hand

    def get(self, card):
        """摸牌"""
        self._cards_on_hand.append(card)

    def arrange(self, card_key):
        """玩家整理手上的牌"""
        self._cards_on_hand.sort(key=card_key) # ???????????????????????????????????？？？？？？？？？？


# 排序规则-先根据花色再根据点数排序
def get_key(card):
    return (card.suite, card.face)


def main():
	# 创建一副牌
    p = Poker()
    # 洗牌
    p.shuffle()
    # 建立玩家
    players = [Player('东邪'), Player('西毒'), Player('南帝'), Player('北丐')]
    
    for _ in range(13):			# 牌的点数在1 ~ 13之间，所以这里进行限制
        for player in players:	# 玩家依次摸牌
            player.get(p.next)  # 玩家使用get()方法摸牌，摸到的牌是由next()发的
    for player in players:
        print(player.name + ':', end=' ')
        player.arrange(get_key)	# 玩家整理手中的牌？？？？？？？？？为什么参数是get_key,get_key是函数啊，不应该get_key()?
        print(player.cards_on_hand) # cards_on_hand是个列表，保存了某个玩家的所有手中的牌


if __name__ == '__main__':
    main()

• 练习3：工资结算系统

"""
某公司有三种类型的员工 分别是部门经理、程序员和销售员
需要设计一个工资结算系统 根据提供的员工信息来计算月薪
部门经理的月薪是每月固定15000元
程序员的月薪按本月工作时间计算 每小时150元
销售员的月薪是1200元的底薪加上销售额5%的提成
"""
from abc import ABCMeta, abstractmethod

class Employee(object, mataclass=ABCMeta):
	"""员工"""

	def __init__(self, name):
		self._name = name

	@property
	def name(self):
		return self._name

	@abstractmethod
	def get_salary(self):
		"""
		获得月薪

		:return: 月薪
		"""
		pass
	
class Manager(Employee):
	"""部门经理"""

	def get_salary(self):
		return 15000.0


class Programmer(Employee):
	"""程序员"""

	def __init__(self, name, working_hour=0):
		super.__init__(name)
		self._working_hour = working_hour

	@property
	def working_hour(self):
		return self._working_hour

	@working_hour.setter
	def working_hour(self, working_hour):
		self._working_hour = working_hour if working_hour > 0 else 0

	def get_salary(self):
		return 150.0 * self._working_hour

class Salesman(Employee):
	"""销售员"""

	def __init__(self, name, sale_num=0):
		super.__init__(name)
		self._sale_num = sale_num

	@property
	def sale_num(self):
		return self._sale_num

	@sale_num.setter
	def sale_num(self, sale_num):
		self._sale_num = sale_num if sale_num > 0 else 0

	def get_salary(self):
		return 1200.0 + self._sales * 0.05


def main():
	emps = [
		Manager('刘备'), Programmer('诸葛亮'),
		Manager('曹操'), Salesman('荀彧'),
		Salesman('吕布'), Programmer('张辽'),
		Programmer('赵云')
	]
	for emp in emps:
		if isinstance(emp, Programmer):
			emp.working_hour = int(input('请输入%s本月工作时间: ' % emp.name))
		elif isinstance(emp, Salesman):
			emp.sales = float(input('请输入%s本月销售额: ' % emp.name))
		# 同样是接收get_salary这个消息但是不同的员工表现出了不同的行为(多态)
		print('%s本月工资为: ￥%s元' %
	  (emp.name, emp.get_salary()))
	
	
if __name__ == '__main__':
	main()

（有编译错误未解决：）