python基础语法难点突破（持续更新）

python基础语法难点突破

1.面向对象类的基本使用

知识点：

• 属性：类属性、实例对象属性
• 方法：实例方法、类方法、静态方法
• 类可以调用哪些内容：类属性、类方法、静态方法

代码示例：

class A(object):
    # 类属性
    class_a = 20

    def __init__(self):
        # 实例对象属性
        self.a = 10

    # 实例方法
    def a_print(self):
        print("a_print")

    # 类方法
    @classmethod
    def class_print(cls):
        print('class_print')

    # 静态方法
    @staticmethod
    def static_print():
        print("static_print")


# 类调用类属性，不能调用实例对象属性
print(A.class_a)
# 使用实例化对象调用实例对象属性
print(A().a)

# 使用类调用类方法
A.class_print()
# 使用类调用静态方法
A.static_print()
# 调用实例方法的两种方式
A.a_print(A())
A().a_print()

2.面向对象类的调用和属性

知识点：

• 在一个类中想要调用另一个类的方法和属性的方法：继承、属性赋值的形式

代码示例：

class A(object):
    class_a = 20

    def __init__(self):
        self.a = 10

    def a_print(self):
        print("a_print")

    @classmethod
    def class_print(cls):
        print('class_print')

    @staticmethod
    def static_print():
        print("static_print")


# 继承
class B(A):
    def b_print(self):
        print("b_print")


B().b_print()
B().a_print()


# 属性赋值的形式
class C(object):
    obj_a = A()

    def c_print(self):
        print('c_print')


# 调用A中的方法
C.obj_a.a_print()

3.面向对象super和@property的使用

知识点：

• super作用：super() 函数是用于调用父类(超类)的一个方法。
• super使用场景：重写父类方法，在父类方法的基础上，新增一些业务逻辑
• 使用@property装饰器可以直接通过方法名来访问方法，不需要再在后面使用"()"

代码示例：

class A(object):

    def a_print(self):
        print("a_print")


class B(A):
    def a_print(self):
        # 调用父类方法
        super().a_print()
        print("add_data")

    @property
    def data(self):
        print("data")


B().a_print()
# 直接以调用属性的形式调用方法
B().data

4.装饰器

代码示例：

def func1(fun):
    def func2():
        print("增加的业务功能")
        return fun()
    return func2


@func1
def a_print():
    print("a")
    return "data"


data = a_print()
print(data)

# 1、将a_print函数引用传递给func1中的fun
# 2、将func2的函数引用传递给a_print

打印结果：
增加的业务功能
a
data

5.lambda匿名函数

def func_lambda(x):
    return x + 1


func = lambda x: x + 1


# 缺省参数
def func_lambda1(a, b=1):
    return a + b


func1 = lambda a, b=1: a + b


# 条件判断
def func_lambda2(a):
    if a > 0:
        return a + 1
    else:
        return abs(a) + 1


func2 = lambda a: a + 1 if a > 0 else abs(a) + 1

# 无参数
import time


def get_timestamp():
    return int(time.time())


func3 = lambda: int(time.time())

6.常用的python函数

map
将列表的每个元素平方

a_list = [2, 3, 5, 7, 11]
result = list(map(lambda x: x**2, a_list))
print(result)

zip
将x里的元素作为key，y里的元素作为value，组成一个字典

x = [1, 2, 3, 4, 5]
y = ['1', '2', '3', '4', '5']
print(dict(list(zip(x, y))))

filter
过滤掉大于5的数

d_list = [1, 2, 3, 4, 5, 6, 7, 8, 9, 10]
print(list(filter(lambda x: x < 5, d_list)))

isinstance：判断一个对象是否是一个已知的类型

e_list = [1, 2]
print(isinstance(e_list, list))  # True

将items = [1, 2, [3, 4, [5, 6], 7], 8, 9, (10, 11), 12, [13], [14, 15]]转化为[1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15]

from collections import Iterable
def func(items):
    for x in items:
        if isinstance(x, Iterable):
            # 递归
            yield from func(x)
        else:
            yield x

result = [x for x in func(items)]
# print(result)

any：用于判断给定的可迭代参数是否全部为False,是则返回False,如果有一个为True,则返回True
根据关键字过滤标题

title_keys = ['欧冠', '游戏', '文化', '养生', '数码']
title_list = [
    '明晚直播欧冠决赛',
    'xxx游戏将迎来重大更新',
    '多读书做一个有文化的人',
    '养生要从年轻人开始',
    '数码产品要买新不买旧',
    '冬奥会结束',
    '残奥会各项准备工作基本就绪',
]
for title in title_list:
    if any(key in title for key in title_keys):
        ...

7.for循环删除的坑

g_list = [1, 3, 3, 3, 5]
for g in g_list:
    if g == 3:
        g_list.remove(g)
# print(g_list)


def del_item(list, data):
    """
    删除列表的值.
    :param list: 要从里面删除元素的列表.
    :param data: 是我们想要删除的元素.
    :return: 删除过后的列表.
    """
    d = dict(zip(range(len(list)), list))
    # 这个字典的key 是列表的index. value是列表的对应的值.
    print(d)
    return [v for k, v in d.items() if v != data]

print(del_item([1,3,3,3,5], 3))

8.可迭代对象

python中的可迭代对象, 类里定义了 __iter__方法, 返回自己

斐波那契数列.1、1、2、3、5、8、13、21、34
(有一只青蛙, 它一次可以跳1格, 也可以跳2格. 它跳上N阶台阶有多少种跳法.)

fib = lambda n: 1 if n <= 2 else fib(n-1) + fib(n-2)
print([fib(i) for i in range(1, 10)])

用可迭代对象的知识, 实现斐波那契数列

# 可迭代对象.
from collections import Iterable

class TestIter:

    """可迭代对象测试"""
    # python中的可迭代对象, 类里定义了 __iter__方法, 返回自己.
    def __init__(self, num):
        self.num = num
        self.a = 0
        self.b = 1
        self.current = 0

    def __iter__(self):
        return self

    def __next__(self):
        self.current += 1
        if self.current < self.num:
            self.a, self.b = self.b, self.a + self.b
            return self.a
        else:
            raise MyStopIteration


test_iter = TestIter(10)
# print(isinstance(test_iter, Iterable))
# for循环底层是调用对象的__next__方法.
# 遍历出来的值 是__next__的返回值.
print([i for i in test_iter])

9 上下文管理器

# with语句，上下文管理器


class MyRequest:
    """
    上下文管理器:当一个类里定义了enter方法和exit方法，那么这个类就叫做上下文管理器
    """
    def __enter__(self):
        return self  # 返回这个类的实例对象

    def __exit__(self, exc_type, exc_val, exc_tb):
        print(111111)
        return True  # exit方法是有返回值的，为true的时候，不会把异常向上抛


with MyRequest() as mr:
    print(mr)