【漫漫转码路】Python Day 17

一、解题

1、按顺序输出

输入[2, 5, 1, 3, 4, 7]
输出[2, 3, 5, 4, 1, 7]
2n个数字，前n个和后n个交叉着来

# 方法一
def func(nums):
    nums[::2],nums[1::2] = nums[:len(nums)//2],nums[len(nums)//2:]
    print(nums)
func(nums)
# 前n个数字放在0,2，4.....偶数位，后n个数字放在1,3,5,7...奇数位，用序列同时赋值

# 方法二
def func(nums):
    list2 = []
    list1 = list(zip(nums[:len(nums)//2],nums[len(nums)//2:]))
    for i in list1:
        list2.extend(i)
    print(list2)
func(nums)
# 将序列一分为二，用zip函数将序列各取一个，组成列表，然后遍历列表，用extend添加

# 方法三
nums = [1, 2, 3, 4, 4, 3, 2, 1]
def sut(x, y):
    list_res.extend((x, y))


list_res = []
list1 = nums[:int(len(nums)/2)]
list2 = nums[int(len(nums)/2):]

list4 = list(map(sut, list1, list2))
print(list_res)

2、输出两个数之间的奇数个数

# 方法一
num1 = int(input('请输入low(起点):'))
num2 = int(input('请输入high(终点):'))

count = 0
for i in range(num1, num2 + 1):
    if i % 2:
        count += 1
print(count)
# 计数

# 方法二
def func(num1, num2):
    if num1 % 2 == 0 and num2 % 2 == 0:
        print((num2-num1)//2)
    else:
        print((num2-num1)//2+1)

func(0, 5)
# 根据数学方法

二、类方法和静态方法的区别

# 例如
class A:
    pr1 = '这是A类'


    @classmethod  # 类方法
    def func1(cls):
        print(cls.pr1)


    @staticmethod  # 静态方法
    def func2():
        print(A.pr1) # 注意，静态方法无隐式接收，只能是写明类或实例对象


class B(A):
    pr1 = '这是B类'

A.func1() # A调用类方法
A.func2() # A调用静态方法
B.func1() # B调用类方法
B.func2() # B调用静态方法

# 终端显示
这是A类
这是A类
这是B类
这是A类  # 因为静态方法写死了class是A，所以即使B调用，也是A.pr1，

三、面向对象——继承

（1）isinstance

isinstance(object，classinfo):判断object是否是类classinfo的实例对象，考虑继承

# 例如
class A:
    pass
class B(A):
     def __init__(self):
        pass
class C(A):
    pass
b = B()
print(isinstance(b, C))
print(isinstance(b, B))
print(isinstance(b, A))
print(isinstance(b, (B, C)))

# 终端显示
False # b不是C的实例对象
True  # b是B的实例对象
True  # b是B的实例对象，B是A的子类，因此c也是A的实例对象
True  # B和C任一有一个是True，则返回True

（2）issubclass

issubclass(class, classinfo):判断class是不是classinfo的子类，考虑继承

# 例如
class A:
    pass
class B(A):
    pass
class C(A):
    pass


print(issubclass(C, B))
print(issubclass(C, A))
print(issubclass(C, (A, B)))
print(issubclass(C, C))
print(issubclass(D, A))

# 终端显示
False  # C不是B的子类
True  # C是A的子类
True  # 后面跟元组的时候，任一个成立，则全都成立
True  # C是C本身的子类
True  # 继承，D是C的子类，C是A的子类，故D也是A的子类

四、面向对象——多态性

具有不能内容的方法类使用相同的方法名，可以用一个方法名调用不同内容的方法

# 例如
class Apple():
    def change(self):
        print('苹果汁')

class Orange():
    def change(self):
        print('橘子汁')

class Melon():
    def change(self):
        print('西瓜汁')

class Juicer():
    def work(self, fruit):
        fruit.change()

A = Apple()  #  三个类有对象方法change，因此用一个对象方法就可以调用这三个不同的内容
O = Orange()
M = Melon()
J = Juicer()
J.work(A) 
J.work(O)    
J.work(M)

# 终端显示
苹果汁
橘子汁
西瓜汁

注意：
如果是类下面的实例对象共有的东西，则可以放在类属性
如果是每个实例对象特有的东西，可以放在实例属性，
对于不同类都会有的方法，可以建立父类，将共同的东西放在父类
调用的时候要把self去掉，定义的时候可以有

五、错误异常

错误异常分为语法错误和异常
语法错误：解析错误，即基本的语法错误
异常：运行时才能检测到的异常
错误异常本质上是类，父类是Exception

注意：
列表是实例对象
列表的对象方法就是实例对象的对象方法

# 例如
list1 = [1, 2, 3]  # list1是实例对象
list1.append(4)  # 对调用实例对象的对象方法append
print(isinstance(list1, list))  # 判断list1是不是list的实例对象

# 终端显示
True  # 返回True