Python学习第三天

递归函数

• 递归：函数直接或者间接调用自己

# 例：阶乘
def fun_a(n = 0):
    if n == 1:
        return 1
    return n * fun_a(n-1)

print(fun_a(int(input("输入一个数字"))))

# 例：斐波那契数列

def f_b(n = 0):
    if n == 1 or n == 2:
        return 1
    return f_b(n-1) + f_b(n-2)

print(f_b(int(input("输入一个数字"))))

# 例：汉诺塔

def hano(a , b , c , n):
    if n == 1:
        print("{}-->{}".format(a,c))
        return None
    if n == 2:
        print("{}-->{}".format(a,b))
        print("{}-->{}".format(a,c))
        print("{}-->{}".format(b,c))
        return None
    hano(a , c , b , n-1)
    print("{}-->{}".format(a,c))
    hano(b , a , c , n-1)
    return None

hano("A","B","C",3)
    

OOP

• 思想

  • 以模块化思想解决工程问题
  • 面向过程 VS 面向对象
  • 由面向过程转向面向对象

• 常用名词

  • oo:面向对象
  • ooa：面向对象分析
  • ood：面向对象设计
  • oop：面向对象编程
  • ool：面向对象实现
  • ooa --> ood --> ooi

• 类 VS 对象

  • 类：抽象，描述的是一个集合，侧重于共性
  • 对象：具象，描述的是个体

• 类的内容

  • 动作，函数
  • 属性，变量

• is-a

• 定义类：class关键字

• 类命名：

  • 遵循大驼峰
  • 第一个字母大写`

• self

  • self 可以用别的名称代替
  • self 不是关键字
  • 作用是指代本身

# 定义学生类
class Student():
    name = "l"
    age = 12
    def sayHai(self):
        print("Hai!")
        return None

# 定义对象
# 实例化
ll = Student()
print(ll.name)
ll.sayHai()

类变量作用域的问题

• 类的变量：属于类自己的变量
• 实例变量：属于实例的变量，可以借助类变量

访问类的属性

• 在类里面如果强制访问类的属性，则需要使用__class__
• 类方法：
  • 定义类的方法的时候，没有self参数
  • 类的方法中只允许使用类的内容
  • 两种使用方法
    • ClassName
    • class

构造函数

• 类在实例化的时候，执行一些基础性的初始化工作
• 使用特殊的名称和写法
  • init(self)
• 实例化的时候自动执行，是执行的“第一个”函数

面向对象的三大特征

• 继承
  • 子类可以使用父类定义的内容或者行为
  • 继承的实现
    • 父类，基类，超类：被继承的类，BaseClass，SupperClass
    • 所有类都必须有一个父类
    • 如果没有，则默认为object的子类
  • issubclass检测是否是子类
    • 可以用来检测两个类的父子关系
    • issubclass(类1，类2)
  • 构造函数的继承
    • 构造函数默认继承
    • 子类没有，则自动调用父类的构造函数
    • 子类定义了，则不再自动调用父类的构造函数
• 封装
• 多态

匿名函数

• 别名 新的函数名 = 函数名
• lambda a,b: a + b 匿名函数

  • 一般用于表达简单函数，且只调用一次

  • 调用方式

    • 函数名 = lamdba a , b : a + b
    • 把函数当做参数传递给另一个函数

  • 使用匿名函数的内置函数

    • sorted（列表） 排序，生成新的有序列表
    • sort
    • filter 类 对可迭代对象进行过滤，得到的是一个filter对象
    • map
    • reduce`

# 函数回调

def add(a, b):
    return a + b
def minus(a, b):
    return a - b
def celc(a, b, fn):
    return fn(a,b)

x = celc(1, 2, add)

# lamdba使用

y = celc(3, 5, lambda a, b: a + b)

print(x, y)

# sort例 ：给学生信息按成绩排序

student = [{'name' : '李华', 'age' : 17, 'score' : 76},
          {'name' : '小明', 'age' : 17, 'score' : 86},
          {'name' : '小强', 'age' : 17, 'score' : 55}]

def fun(ele):
    return ele['score']
#    print(ele)
student.sort(key=fun)
print(student)

student.sort(key= lambda ele: ele['score'])
print(student)

# fliter例：
ages = [12,23,30,17,16,22,19]
x = filter(lambda ele: ele > 18,ages)
l = list(x)
print(l)

# map 例：
x = map(lambda ele: ele +2,ages)
print(list(x))

# reduce 例：
from functools import reduce
student = [{'name' : '李华', 'age' : 17, 'score' : 76},
          {'name' : '小明', 'age' : 17, 'score' : 86},
          {'name' : '小强', 'age' : 17, 'score' : 55}]

def bar(x, y):
    return x + y['age']
print(reduce(bar, student,0))
# reduce (((0 + y['age']) + y['age']) +y['age'])

内置函数总结

• 数学相关的
  • abs 取绝对值
  • divmod 求两个数相除的商和余数
  • max 求最大值
  • min 求最小值
  • pow 幂运算
  • round 四舍五入保留到指定小数位
  • sum 用来求和
• 可迭代相关的
  • all 如果所有元素转换为布尔值都是True，结果是True否则是false
  • any 如果有任意一个或者多个元素转换为布尔值都是True，结果是True否则是false
  • len 获取长度
  • iter 获取到可迭代对象的迭代器
  • next: for … in 循环本质就是调用迭代器的next方法
  • sorted 用来排序
• 互相转换
  • bin 将数字转换为二进制
  • oct 将数字转换为8进制
  • hex 将数字转换为16进制
  • chr 将字符编码转换为对应的字符
  • ord 将字符转换为对应的编码
  • eval 执行字符串里的Python代码
• 变量相关
  • globals 用来查看所有全局变量
  • locals 用来查看所有局部变量
• 判断对象相关的方法
  • isinstence 判断对象是否为一个类创建出来的
  • issubclass 判断一个类是否是另一个类的子类
• dir:列出对象所有的属性和方法
• help 查看帮助文档
• id 获取一个对象的内存地址
• exit 以指定的退出码结束程序

高阶函数

• 一个函数作为另一个函数的返回值
• 一个函数作为另一个函数的参数
• 函数内部再定义一个函数

# 例 计算程序运行时间
import time
def cal_time(fn):
    start = time.time()
    fn()
    end = time.time()
    print("代码运行了{}秒".format(end - start))
    return None

def demo():
    x = 0
    for i in range(1, 100000000):
        x += i
    print(x)
    return None

cal_time(demo)

# 优化  装饰性语法    语法糖
import time
def cal_time(fn):
    
    def inner(k, *args, **kwargs):
        
        start = time.time()
        s = fn(k)
        end = time.time()
        # print("代码运行了{}秒".format(end - start))
        return s, end - start
    
    return inner

@cal_time    # 调用cal_time函数，并把被修饰的函数传递给fn
def demo(n):
    x = 0
    for i in range(1, n):
        
        x += i
#    print(x)
    return x

@cal_time
def foo(n):
    print("hello")
    time.sleep(3)
    print("end")
#
demo(6)
print("*" * 20)
# foo(6)

# 装饰器使用
 
def can_play(fn):
    
    def inner(x, y, *args, **kwargs):
        clock = kwargs.get('clock', 23)
        if clock <= 21:
            fn(x,y)
        else:
            print("太晚了，不能玩了")
    
    return inner

@can_play
def play_game(name,game):
    print("{}正在玩{}".format(name, game))
    return None

play_game("张三", "王者荣耀", 21)