第三周python作业——函数、面向对象

函数

基础

1. 编写一个函数，交换指定字典的key和value。

     例如:dict1={'a':1, 'b':2, 'c':3}  -->  dict1={1:'a', 2:'b', 3:'c'}  
   

   def func1(dict1):
       dict2 = {}
       for i, j in dict1.items():
           dict2[j] = i
       print(dict2)
   
   func1(dict1={'a':1, 'b':2, 'c':3})
   

   {1: 'a', 2: 'b', 3: 'c'}
   

2. 编写一个函数，提取指定字符串中所有的字母，然后拼接在一起产生一个新的字符串

      例如: 传入'12a&bc12d-+'   -->  'abcd'  
   

   def func2(str1):
       str2 = ''
       for i in str1:
           if i.isalpha():
               str2 += i
       print(str2)
   
   func2(str1 = '12a&bc12d-+')
   

   abcd
   
   

3. 写一个自己的capitalize函数，能够将指定字符串的首字母变成大写字母

     例如: 'abc' -> 'Abc'   '12asd'  --> '12asd'
   

   def func3(str1):
       if 'a' <= str1[0] <= 'z':
           str1 = str1[0].upper() + str1[1:]
           print(f'首字母大写为{str1}')
       else:
           print(str1)
   
   func3(str1 = input('请输入字符串：'))
   

   请输入字符串：>? abc
   首字母大写为Abc
   

4. 写一个自己的endswith函数，判断一个字符串是否已指定的字符串结束

      例如: 字符串1:'abc231ab' 字符串2:'ab' 函数结果为: True
           字符串1:'abc231ab' 字符串2:'ab1' 函数结果为: False
   

   def func4(str1: str, str2: str):
       if str1[-len(str2):] == str2:
           print('True')
       else:
           print('False')
   
   func4(str1 = input('请输入字符串：'), str2 = input('请输入结束字符串：'))
   

   请输入字符串：>? abc231ab
   请输入结束字符串：>? ab1
   False
   

5. 写一个自己的isdigit函数，判断一个字符串是否是纯数字字符串

      例如: '1234921'  结果: True
            '23函数'   结果: False
            'a2390'    结果: False
   

   def func5(str1):
       for i in str1:
           if not '0' <= i <= '9':
               print('False')
               break
       else:
           print('True')
   
   func5(str1 = input('请输入字符串：'))
   

   请输入字符串：>? 1245efg334
   False
   

6. 写一个自己的upper函数，将一个字符串中所有的小写字母变成大写字母

       例如: 'abH23好rp1'   结果: 'ABH23好RP1'   
   

   def func6(str1: str):
       str2 = ''
       for i in str1:
           if 'a' <= i <= 'z':
               str2 += chr(ord(i) - 32)
           else:
               str2 += i
       print(str2)
       
   func6(str1= input('请输入字符串：'))
   

   请输入字符串：>? sdfgert
   SDFGERT
   

7. 写一个自己的rjust函数，创建一个字符串的长度是指定长度，原字符串在新字符串中右对齐，剩下的部分用指定的字符填充

      例如: 原字符:'abc'  宽度: 7  字符:'^'    结果: '^^^^abc'
           原字符:'你好吗'  宽度: 5  字符:'0'    结果: '00你好吗'
   

   def func7(str1: str, width:int, char1):
       print(f'{str1:{char1}>{width}}')
   
   func7(str1 = input('请输入字符串：'),
         width=int(input('请输入长度：')),
         char1=input('请输入填充内容：'))
   

   请输入字符串：>? abc
   请输入长度：>? 7
   请输入填充内容：>? ^
   ^^^^abc
   

8. 写一个自己的index函数，统计指定列表中指定元素的所有下标，如果列表中没有指定元素返回-1

      例如: 列表: [1, 2, 45, 'abc', 1, '你好', 1, 0]  元素: 1   结果: 0,4,6  
           列表: ['赵云', '郭嘉', '诸葛亮', '曹操', '赵云', '孙权']  元素: '赵云'   结果: 0,4
           列表: ['赵云', '郭嘉', '诸葛亮', '曹操', '赵云', '孙权']  元素: '关羽'   结果: -1         
   

   def func8(list1, item):
       count = 0
       for x in range(len(list1)):
           if list1[x] == item:
               print(x, end=',')
               count += 1
       if count == 0:
           print(-1)
       print('\b')
   
   
   func8(list1=[i for i in input('列表：').split(', ')], item=input('查询元素：'))
   

   列表：>? '赵云', '郭嘉', '诸葛亮', '曹操', '赵云', '孙权'
   查询元素：>? '赵云'
   0,4
   
   列表：>? '赵云', '郭嘉', '诸葛亮', '曹操', '赵云', '孙权'
   查询元素：>? '张良'
   -1
   

9. 写一个自己的len函数，统计指定序列中元素的个数

       例如: 序列:[1, 3, 5, 6]    结果: 4
            序列:(1, 34, 'a', 45, 'bbb')  结果: 5  
            序列:'hello w'    结果: 7
   

   def func9(xulie):
       print(len(xulie))
   
   
   func9(xulie=[1, 3, 5, 6])
   

   4
   

10. 写一个自己的max函数，获取指定序列中元素的最大值。如果序列是字典，取字典值的最大值

       例如: 序列:[-7, -12, -1, -9]    结果: -1   
            序列:'abcdpzasdz'    结果: 'z'  
            序列:{'小明':90, '张三': 76, '路飞':30, '小花': 98}   结果: 98
    

    def func10(items1):
        if not (type(items1) == dict):
            print(max(items1))
        else:
            items2 = [i for i in items1.values()]
            print(max(items2))
    
    func10({'小明':90, '张三': 76, '路飞':30, '小花': 98})
    

    98
    

11. 写一个函数实现自己in操作，判断指定序列中，指定的元素是否存在

        例如: 序列: (12, 90, 'abc')   元素: '90'     结果: False
             序列: [12, 90, 'abc']   元素: 90     结果: True     
    

    def func11(items1, index):
        print(index in items1)
    
    func11((12, 90, 'abc'), '90')
    

    False
    

12. 写一个自己的replace函数，将指定字符串中指定的旧字符串转换成指定的新字符串

        例如: 原字符串: 'how are you? and you?'   旧字符串: 'you'  新字符串:'me'  结果: 'how are me? and me?'
    

    def func12(str1, str2, str3):
        str4, i = '', 0
        while i < len(str1):
            if str2 == str1[i: i + len(str2)]:
                str4 += str3
                i += len(str2)
            else:
                str4 += str1[i]
                i += 1
        print(str4)
    
    
    func12('how are you? and you?', 'you', 'me')
    

    how are me? and me?
    

进阶

1. 写一个匿名函数，判断指定的年是否是闰年

   is_leap_year = lambda year: True if year % 4 == 0 and year % 100 or year % 400 == 0 else False
   print(is_leap_year(2000))  # True
   

2. 写一个函数将一个指定的列表中的元素逆序( 如[1, 2, 3] -> [3, 2, 1])(注意:不要使用列表自带的逆序函数)

   def my_reverse(list:list):
       len1=len(list)
       for i in range(len1//2):
           print(list[i])
           list[i],list[len1-i-1]=list[len1-i-1],list[i]
       return list
   print(my_reverse([1, 2, 3]))
   # 解法2
   my_reverse1=lambda list:list.reverse()
   list=[1,2,3]
   my_reverse1(list)
   print(list)
   

3. 编写一个函数，计算一个整数的各位数的平方和

   例如: sum1(12) -> 5（1的平方加上2的平方）    sum1(123) -> 14
   

   my_sum=lambda num:sum([int(i)**2 for i in str(num) ])
   print(my_sum(12))
   print(my_sum(123))
   

4. 求列表 nums 中绝对值最小的元素

   例如：nums = [-23, 100, 89, -56, -234, 123], 最大值是：-23
   

   nums = [-23, 100, 89, -56, -234, 123]
   print(min(nums, key=lambda i: abs(i)))  # -23
   

5. 已经两个列表A和B，用map函数创建一个字典，A中的元素是key，B中的元素是value

   A = ['name', 'age', 'sex']
   B = ['张三', 18, '女']
   新字典: {'name': '张三', 'age': 18, 'sex': '女'}
   

   A = ['name', 'age', 'sex']
   B = ['张三', 18, '女']
   result=list(map(lambda i,j: {i:j}, A, B))
   print(result)  # [{'name': '张三'}, {'age': 18}, {'sex': '女'}]
   

6. 已经三个列表分别表示5个学生的姓名、学科和班号，使用map将这个三个列表拼成一个表示每个学生班级信息的的字典

   names = ['小明', '小花', '小红', '老王']
   nums = ['1906', '1807', '2001', '2004']
   subjects = ['python', 'h5', 'java', 'python']
   结果：{'小明': 'python1906', '小花': 'h51807', '小红': 'java2001', '老王': 'python2004'}
   

   names = ['小明', '小花', '小红', '老王']
   nums = ['1906', '1807', '2001', '2004']
   subjects = ['python', 'h5', 'java', 'python']
   result=dict(map(lambda i,j,k:(i,j+k),names,nums,subjects))
   print(result)
   

7. 已经一个列表message, 使用reduce计算列表中所有数字的和

   message = ['你好', 20, '30', 5, 6.89, 'hello']
   结果：31.89
   

   from functools import reduce
   message = ['你好', 20, '30', 5, 6.89, 'hello']
   sum2=reduce(lambda item,i:item+(i if type(i) in (int,float) else 0),message,0)
   print(sum2)  # 31.89
   

8. 已经列表points中保存的是每个点的坐标(坐标是用元组表示的，第一个值是x坐标，第二个值是y坐标）

   points = [
     (10, 20), (0, 100), (20, 30), (-10, 20), (30, -100)
   ]
   

   1）获取列表中y坐标最大的点

   2）获取列表中x坐标最小的点

   3）获取列表中距离原点最远的点

   4）将点按照点到x轴的距离大小从大到小排序

   points = [
     (10, 20), (0, 100), (20, 30), (-10, 20), (30, -100)
   ]
   print(points[0][1])
   y_max=max(points,key=lambda i:i[1])
   print(y_max)  # (0, 100)
   x_min=min(points,key=lambda i:i[0])
   print(x_min) # (-10, 20)
   o_max=max(points,key=lambda i:i[0]**2+i[1]**2)
   print(o_max) # (30, -100)
   xx_max=sorted(points,key=lambda i:abs(i[0]))
   print(xx_max) # [(0, 100), (10, 20), (-10, 20), (20, 30), (30, -100)]
   

面向对象

1. 定义一个狗类和一个人类：

   狗拥有属性：姓名、性别和品种 拥有方法：叫唤

   人类拥有属性：姓名、年龄、狗 拥有方法：遛狗

   class Dog:
       def __init__(self, name, gender='公', breed='土狗'):
           self.name = name
           self.gender = gender
           self.breed = breed
   
       def bark(self, voice='汪！汪！汪!'):
           print(f'{self.name}: {voice}')
   
   
   class Person:
       def __init__(self, name, age=18, dog=None):
           self.name = name
           self.age = age
           self.dog = dog
   
       def walk_the_dog(self):
           # self = p1
           if self.dog:
               print(f'{self.name}牵着{self.dog.name}散步！')
           else:
               print('你还没有狗！')
   
   
   p1 = Person('小明')
   p1.walk_the_dog()
   
   dog1 = Dog('财财', '母')
   p1.dog = dog1
   p1.walk_the_dog()
   	
   	
   	p = Person('南星', '23')
   	p.stroll(d)
   

2. 定义一个矩形类，拥有属性：长、宽 拥有方法：求周长、求面积

   class Rectangle:
       def __init__(self, length, width):
           self.length = length
           self.width = width
       def Perimeter(self):
           return self.width * 2 + self.length * 2
       def Area(self):
           return self.width * self.length
   r = Rectangle(10, 5)
   print(f'周长：{r.Perimeter()}, 面积：{r.Area()}')
   

3. 定义一个二维点类，拥有属性：x坐标、y坐标 拥有方法：求当前点到另外一个点的距离

   class Point:
       def __init__(self, x=0, y=0):
           self.x = x
           self.y = y
   
       def distance(self, other):
           return ((self.x - other.x)**2 + (self.y - other.y) ** 2) ** 0.5
   
   
   p1 = Point()
   p2 = Point(3, 4)
   print(p1.distance(p2))
   

4. 定义一个圆类，拥有属性：半径、圆心 拥有方法：求圆的周长和面积、判断当前圆和另一个圆是否外切

   class Circle:
       pi = 3.14
   
       def __init__(self, r, center=Point()):
           self.r = r
           self.center = center
   	
   	def perimeter（self):
   		return Circle.pi * self.r * 2
   
       def area(self):
           return Circle.pi * self.r ** 2
   
       def is_exterior_contact(self, other):
           return self.r + other.r == self.center.distance(other.center)
   

5. 定义一个线段类，拥有属性：起点和终点， 拥有方法：获取线段的长度

   class Line:
       def __init__(self, start=Point(), end=Point()):
           self.start = start
           self.end = end
   
       def length(self):
           return self.start.distance(self.end)
   

6. 写一个斗地主游戏类（根据生活经验添加类的内容）
   方法一

   '''
       斗地主
       1.牌堆，54张牌，四种花色，2,3,4,5,6,7,8,9,10,J,Q,K,A，大小王
       2.洗牌
       3.发牌
   '''
   import random
   class Poke():
       flowr=["黑桃","方片","梅花","红桃"]
       num=["2","3","4","5","6","7","8","9","10","J","Q","K","A"]
       kings={'big':'大王','small':'小王'}
       poker=[]
       player1=[]
       player2=[]
       player3=[]
       dipai=[]
   	
       # 总的牌数
       def __init__(self):
           for f in self.flowr:
               for n in self.num:
                   self.poker.append(f+n+' ')
           self.poker.append(self.kings['big']+' ')
           self.poker.append(self.kings['small']+' ')
   
       #洗牌
       def wash(self):
           # 54次，两两随机交换
           for i in range(54):
               index=random.randint(0,53)
               self.poker[index],self.poker[i]=self.poker[i],self.poker[index]
   
       #发牌
       def fa(self):
   		# 每个空列表（每个玩家）依次添加总列表中的第一个元素，添加17个。最后剩下的元素做底牌
           for i in range(17):
               self.player1.append(self.poker.pop(0))
               self.player2.append(self.poker.pop(0))
               self.player3.append(self.poker.pop(0))
           self.dipai=tuple(self.poker)
   
       #展示
       def show(self):
           for i in self.player1:
               print(i,end='')
           print()
           print('玩家1↑↑↑')
           for i in self.player2:
               print(i,end='')
           print()
           print('玩家2↑↑↑')
           for i in self.player3:
               print(i,end='')
           print()
           print('玩家3↑↑↑')
           for i in self.dipai:
               print(i,end='')
           print()
           print('底牌↑↑↑')
   
   p=Poke()
   p.wash()
   p.fa()
   p.show()
   
   运行结果为：
   
   红桃K 梅花9 小王 方片4 方片J 红桃5 黑桃5 方片7 黑桃8 红桃10 红桃7 黑桃6 红桃3 方片3 红桃Q 红桃8 黑桃3 
   
   玩家1 ↑↑↑ 
   
   
   
   梅花10 梅花K 黑桃7 方片9 黑桃2 黑桃Q 黑桃K 黑桃10 红桃J 红桃A 梅花5 黑桃9 梅花8 黑桃4 方片A 方片K 大王
   
   玩家2 ↑↑↑ 
   
   
   
   梅花A 黑桃A 方片2 红桃6 方片10 梅花Q 黑桃J 梅花6 梅花7 红桃2 方片5 梅花4 红桃9 方片6 梅花2 方片8 方片Q 
   
   玩家3 ↑↑↑ 
   
   
   
   梅花J 红桃4 梅花3 
   
   底牌 ↑↑↑ 
   

   方法二

   from random import shuffle
   class Poker:
       all_colors = ['♥', '♠', '♣', '♦']
       nums = [str(x) for x in range(2, 11)] + ['J', 'Q', 'K', 'A', 'joker', 'JOKER']
       table = {str(x): x for x in range(3, 11)}
       table.update({'J': 11, 'Q': 12, 'K': 13, 'A': 14, '2': 15, 'joker': 16, 'JOKER': 17})
       def __init__(self, color, num):
           self.color = color
           self.num = num
       @classmethod
       def create_cards(cls):
           """创建一副新牌"""
           cards = []
           for n in cls.nums[:-2]:
               for c in cls.all_colors:
                   cards.append(Poker(c, n))
           cards.append(Poker('', cls.nums[-2]))
           cards.append(Poker('', cls.nums[-1]))
           return cards
       def __repr__(self):
           return f'{self.color}{self.num}'
   class LandlordsGame:
       def __init__(self):
           # 有一副牌
           self.cards = Poker.create_cards()
       def deal_cards(self):
           # 洗牌
           shuffle(self.cards)
           # 发牌
           player1 = []
           player2 = []
           player3 = []
           cards = iter(self.cards)
           for _ in range(17):
               player1.append(next(cards))
               player2.append(next(cards))
               player3.append(next(cards))
           player1.sort(key=lambda item: Poker.table[item.num], reverse=True)
           player2.sort(key=lambda item: Poker.table[item.num], reverse=True)
           player3.sort(key=lambda item: Poker.table[item.num], reverse=True)
           return player1, player2, player3, list(cards)
   if __name__ == '__main__':
       game = LandlordsGame()
       p1, p2, p3, di = game.deal_cards()
       print(p1)
       print(p2)
       print(p3)
       print(di)
   
   # 运行结果为：
   [♣2, ♦A, ♥K, ♣K, ♥Q, ♣Q, ♠J, ♥J, ♠10, ♥8, ♦8, ♣8, ♣7, ♥6, ♦4, ♠3, ♣3]
   [JOKER, joker, ♠2, ♦2, ♠A, ♦K, ♠Q, ♦Q, ♦J, ♦9, ♥7, ♦7, ♠5, ♣4, ♠4, ♥3, ♦3]
   [♣A, ♥A, ♣J, ♦10, ♥10, ♣10, ♣9, ♠9, ♥9, ♠8, ♠7, ♣6, ♠6, ♦6, ♥5, ♦5, ♥4]
   [♣5, ♥2, ♠K]