函数
可以有效简化代码的重复程度。
定义函数
在Python中，可以使用def关键字来定义函数.在函数名后面的圆括号里面可以放给函数的参数，程序中函数的参数相当于数学上说的函数的自变量，而函数执行完成后我们可以通过return关键字来返回一个值，这就是相当于函数的因变量。
def factorial(num):
""" 求阶乘 ：param num: 非负整数 :return：num的阶乘 """
result = 1
for n in range(1,num + 1):
result *=n
return result
m = int(input('m = '))
n = int(input('n = '))
# 当需要计算阶乘的时候不用在写循环求阶乘，而是直接调用自己定义好的函数
print(factorial(m) //factorial(n) //factorial(m - n))函数的参数
函数是绝大多数编程语言中都支持的一个代码的“构建块”。在Python中，函数的参数可以有默认值，也可以支持可变参数，所以Python并不需要其他语言一样支持函数的重载
from random import randint
def roll_dice(n=2):
""" 摇骰子 :param n:骰子的个数 :return:n颗骰子点数之和 """
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))用模块管理函数
由于Python没有函数重载的概念，在同一个模块中，后定义的函数会覆盖之前定义，也就是两个同名函数实际上只存在一个。
def foo():
print('hello,world!')
def foo():
print('goodbye,world!')
foo() #这里输出的是goodbye,world!这里就需要两个模块管理函数
module1.py
def foo():
print(‘hello,world!’)
module2.py
def foo():
print(‘goodbye,world!’)
test.py
from module1 import foo
foo() # 输出hello,world!
from module2 import foo
foo() # 输出goodbye,world!
另一种写法
test.py
import module1 as m1
import module2 as m2
m1.foo()
m2.foo()
- 井字棋游戏
import os
def print_board(board):
print(board['TL'] + '|' + board['TM'] + '|' + board['TR'])
print('-+-+-')
print(board['ML'] + '|' + board['MM'] + '|' + board['MR'])
print('-+-+-')
print(board['BL'] + '|' + board['BM'] + '|' + board['BR'])
def main():
init_board = {
'TL': ' ', 'TM': ' ', 'TR': ' ',
'ML': ' ', 'MM': ' ', 'MR': ' ',
'BL': ' ', 'BM': ' ', 'BR': ' '
}
begin = True
while begin:
curr_board = init_board.copy()
begin = False
turn = 'x'
counter = 0
os.system('clear')
print_board(curr_board)
while counter < 9:
move = input('轮到%s走棋，请输入位置：' % turn)
if curr_board[move] == ' ':
counter += 1
curr_board[move] = turn
if turn == 'x':
turn = 'o'
else:
turn = 'x'
os.system('clear')
print_board(curr_board)
choice = input('再玩一局?(yes|no)')
begin = choice == 'yes'
if __name__ == '__main__':
main()
面向对象编程基础
把一组数据结构和处理他们的方法组成对象（object），把相同行为的对象归纳为类（class），通过类的封装（encapsulation）隐藏内部细节，通过继承（inheritance）实现类的特化（specialization）和泛化（generalization）,通过多态（polymorphism）实现基于对象类型的动态分派。
类和对象
简单的说，类是对象的蓝图和模板，而对象是累的实例。
定义类
class Student(object):
# __init__是一个特殊方法用于在创建对象时进行初始化操作
# 通过这个方法可以为学生对象绑定name和age两个属性
def __init__(self, name, age):
self.name = name
self.age = age
def study(self, course_name):
print('%s正在学习%s.' % (self.name, course_name))
# PEP 8要求标识符的名字用全小写多个单词用下划线连接
# ֕但是很多程序员更倾向于使用驼峰命名法（驼峰标志）
def watch_tv(self):
if self.age < 18:
print('%s只能观看《熊出没》。' % self.name)
else:
print('%s正在观看血腥暴力片。' % self.name)写在类中的函数，我们通常称之为（对象的）方法，这些方法就是对象可以接收到的消息。
···Python
def main():
# 创建学生对象并指定姓名和年龄
stu1 = Student（‘刘跃’, 31）
# 给对象发study消息
stu1.study(‘Python程序设计’)
# 给对象发watch_tv消息
stu1.watch_tv()
stu2 = Student(‘王大锤’, 15)
stu2.study(‘思想品德’)
stu2.watch_tv()
if name == ‘main’:
main()
···
- 练习
数字时钟
from time import sleep
class Clock(object):
""" 数字时钟 """
def __init__(self, hour=0, minute=0, second=0):
""" 构造器 :param hour: 时 :param minute: 分 :param 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 __str__(self):
"""显示时间"""
return '%02d:%02d:%02d' % \
(self._hour, self._minute, self._second)
def main():
clock = Clock(23, 59, 58)
while True:
print(clock)
sleep(1)
clock.run()
if __name__ == '__main__':
main()