python教程26-函数习题讲解1、函数习题讲解2、面向对象练习、面向对象回顾

python教程_小白入门2021/3/14

学习目标

P 155 函数习题讲解1

# 函数语法
# range(start, stop[, step])
# 参数说明：
# start: 计数从start开始.默认是从0开始.例如range(5)等价于range(0,5);
# stop: 计数到stop结束，但不包括stop。例如：range(0,5)是[0, 1,2,3,4]没有5
# step：步长,默认为1,例如：range(0,5)等价于range(0,5,1)
# --------------------------------------------
# 编写函数，求1+2+3+···+N 的和
def Nxianghe(t):
    sum = 0
    for i in range(1,t):
        sum += i
    return sum

a = Nxianghe(5)
print(a)


# --------------------------------------------
# 编写一个函数，求多个数中的最大值
from random import random
import random

def get_max(*args):
    x = args[0]
    for arg in args:
        if arg > x:
            x = arg
    return x

bbb = get_max(15, 23, 5, 15, 65, 98, 99)
print("其中最大的数为{}".format(bbb))
# 其中最大的数为99
# ------------------------------------------------
# 编写一个函数，实现摇骰子功能，打印N个骰子的点数和

def get_dianshuhe(n):
    m = 0
    for i in range(n):
        x = random.randint(1,6)
        print("第{}次摇到的点数为{}".format(i+1,x))
        m = m + x
    return m

number = 3
dianshuhe = get_dianshuhe(number)
print("{}次摇骰子得到的点数和为{}".format(number,dianshuhe))
#
# 第1次摇到的点数为5
# 第2次摇到的点数为4
# 第3次摇到的点数为2
# 3次摇骰子得到的点数和为11
# ---------------------------------------------
# 编写一个函数，提取指定字符串中所有的字母，然后拼接一起产生一个新的字符串
def get_alphas(word):
    new_str = ''
    for w in word:
        if w.isalpha():
            new_str = new_str + w
    return new_str

a = get_alphas("a55fss54af78adf44")
print("拼接后的字符串为：{}".format(a))
# 拼接后的字符串为：afssafadf
# ---------------------------------------------------
# 写一个函数，默认求10的阶乘，也可以求其他数字的阶乘
def get_factorial(n=10):
    x= 1
    for i in range(1,n+1):
        x *= i
    return x

mm = get_factorial()
gg = get_factorial(3)
print(mm)       # 3628800
print(gg)       # 6
# ---------------------------------------------
# 写一个函数  求多个数的平均值
def get_average(*args):
    x= 0
    for arg in args:
        x += arg
    return x / len(args)
oo = get_average(1,2,3,5,55,6,8,9,8,8)
print(oo)               # 10.5
# ----------------------------------------------------------
#  写一个自己的capitalize函数，能够将指定字符的首字母变成大写字母
def my_catitaloze(word):
    c  = word[0]
    if 'z'>=c >= 'a':
        new_str = word[1:]
        return  c.upper() + new_str
    return word

pp = my_catitaloze('hello world')
print(pp)               # Hello world
# -----------------------------------------------------
#  写一个自己的endwith函数，判断一个字符串是否以指定的字符串结束
def is_myendwith(old_str,str1):
    return old_str[-len(str1):]== str1
print(is_myendwith('hello', 'llo'))     # True
# --------------------------------------------------
#  写一个自己的isdigit 函数，判断一个字符串是否是纯数字字符串
def my_digist(old_str):
    for s in old_str:
        if not '0'<= s <= '9':
            return False
    return True
print(my_digist('1244fsdf45'))          # False
# -------------------------------------------------------
#  写一个自己的upper函数，将一个字符串中所有的小写字母变成大写字母
def my_upper(word):
    new_str = ''
    for i in word:
        if 'a'<= i <= 'z':
            upper_s = chr(ord(i) - 32)  # ord ():获取某个字符的ASSIC 码值  chr（）再转换为字符
            new_str += upper_s
        else:
            new_str += i
    return new_str
print(my_upper('45DDsSA5afds15asdf'))
#  45DDSSA5AFDS15ASDF
# ------------------------------------------------------
#  写一个函数实现自己的in操作，判断指定序列中，指定的元素是否存在
def my_in(it,ele):
    for i in it:
        if i ==ele:
            return True
    else:
        return False
print(my_in(['zhangsan','lisi','wangwu'],'lisi'))
# True

P 156函数习题讲解2

#  写一个自己的replace函数，将指定字符串中指定的旧的字符串替换为指定的新字符串
def my_replace(all_str,old_str,new_str):
    return new_str.join(all_str.split(old_str))
    # a.join(b)---用a把b的各个部分连接起来

print(my_replace('helloworldnihao', 'l', '233'))
#    he233233owor233dnihao
#-------------------------------------------------------------
# 写一个自己的max函数，获取指定序列中元素的最大值，如果序列是字典，取字典值的最大值
def get_mymax(item):
    if type(item) == dict:
        item =  list(item.values())
    x = item[0]
    for i in item:
        if i >= x:
            x = i
    return x

print(get_mymax({'x':1,'y':55,'z':44,'m':99,'n':12}))
# 99

P 157 函数对象练习

# 面向对象练习--老师讲的很清楚，一定要求去听视频  对象就是内存里的一部分空间

# 房子House 有户型，总面积，剩余面积和家具名称列表 属性
# 新房子没有任何家具
# 将 家具名称 追加到 家具名称列表中，
# 判断 家具的面积 是否超过 剩余面积，如果超过，提示不能添加这件家具

class House(object):
    def __init__(self, house_type, total_area, fru_list=None):
        if fru_list is None:
            fru_list = []
        #  缺省参数---为fru_list设置为缺省参数，可写可不写
        self.house_type = house_type
        self.total_area = total_area
        self.free_area = total_area * 0.6
        self.fru_list = fru_list
        print("房屋总面积为：{}平方米".format(self.total_area))

    def add_fru(self, x):  # x = bed
        if self.free_area < x.area:
            print("没有地方可以放{}了".format(x.name))
        else:
            self.fru_list.append(x.name)
            self.free_area = self.free_area - x.area
            print('成功将家具：{}添加到房子里'.format(x.name))
        print("此时的房屋剩余面积为{}平方米".format(self.free_area))

    def __str__(self):
        return "户型为：{}，总面积为：{}平方米，剩余面积为：{}平方米,所放的家具有：{}".format(self.house_type,self.total_area,self.free_area,self.fru_list)

class Furniture(object):
    def __init__(self, name, area):
        self.name = name
        self.area = area


bed1 = Furniture('席梦思', 4)
chest1 = Furniture('衣柜', 2)
desk1 = Furniture('餐桌', 3)
chest2 = Furniture('鞋柜', 2)
desk2 = Furniture('书桌', 5)


# 创建房间对象的时候，必须要传入户型和总面积
house1 = House('两室一厅', 30, )
house1.add_fru(bed1)
house1.add_fru(bed1)
house1.add_fru(desk2)
house1.add_fru(desk1)
house1.add_fru(desk2)

# 家具Furniture  有名字，占地面积属性，其中
# 席梦思 占地4平米
# 衣柜  占地2平米
# 餐桌 占地1.5平米
# 将以上三件家具 添加到 房子中
# 打印房子时，要求 输出： 户型，总面积.剩余面积等于总面积的60%，家具名称列表
# print("\n房子户型为：{}，总面积为：{}平方米，剩余面积为：{}平方米".format(house1.house_type,house1.total_area,house1.free_area))



#　在使用print方法时，默认的是调用方法中的＿str_ 方法
#print(house1)   等同于 print(house1.__str__())
print(house1)


# 成功将家具：席梦思添加到房子里
# 此时的房屋剩余面积为14.0平方米
# 成功将家具：席梦思添加到房子里
# 此时的房屋剩余面积为10.0平方米
# 成功将家具：书桌添加到房子里
# 此时的房屋剩余面积为5.0平方米
# 成功将家具：餐桌添加到房子里
# 此时的房屋剩余面积为2.0平方米
# 没有地方可以放书桌了
# 此时的房屋剩余面积为2.0平方米
# 户型为：两室一厅，总面积为：30平方米，剩余面积为：2.0平方米,所放的家具有：['席梦思', '席梦思', '书桌', '餐桌']

P 158 面向对象回顾

# 魔法方法，也叫魔术方法，是类里的特殊的一些方法
# 特点:   __(???)__
# 1. 不需要手动调用，会在合适的时机自动调用(可以强制手动调用)
# 2. 这些方法，都是使用__开始__结束
# 3. 方法名都是使用系统规定好的，会在合适的时机自己调用

class Person(object):
    # 在创建对象时，会自动调用这个方法
    def __init__(self, name, age):
        print("init方法被调用了")
        self.name = name
        self.age = age

    def __del__(self):
        # 当一个对象被销毁的时候（程序执行完了之后），会自动调用这个方法
        print("__del__这个方法被调用了")

    def __str__(self):
        return self.name

    def __call__(self, *args, **kwargs):
        # print("call方法被调用了")
        print('args = {},kwargs ={}'.format(args, kwargs))
        gongshi = kwargs['fn']
        return gongshi(args[0],args[1],args[2])


p = Person("张三", 55)  # init方法被调用了
# print(p.age)        # 55
# # __del__这个方法被调用了

# 如果不做任何的修改，直接打印一个对象，打印的是对象的类型以及内存地址
# print(p)    # <__main__.Person object at 0x000001F759966460>

# 当打印一个对象的时候，会调用这个对象的__str__或者__repr__方法
# 如果这两个算法都写了 ，那么只走 str
#　print(p)  # 张三

# 如果不重写call方法，直接调用对象名，会报错
#p()     # 'Person' object is not callable,对象不能直接调用

# p()         # __del__这个方法被调用了
# 重写了 call方法，调用对象名就不会报错了

n = p(1, 2, 3,fn=lambda x, y, z: x + y + z)
print(n)        # 6