Python基础语法知识梳理

糖渍樱桃

已于 2023-09-02 09:54:39 修改

阅读量159

点赞数

分类专栏： Python 文章标签： python 开发语言面试 pycharm

于 2023-09-01 17:08:34 首次发布

本文链接：https://blog.csdn.net/never_stop_rain/article/details/132534351

版权

Python 专栏收录该内容

3 篇文章 0 订阅

订阅专栏

前言

提示：文章中的知识点梳理来自网课，部分觉得不清楚的内容添加了一些解释和扩充链接

视频回顾：B站网课《求知讲堂python+人工智能 94天完整版学完可就业》链接

提示：以下是本篇文章正文内容，下面案例可供参考

一、数据类型与运算符

知识点梳理见整理的框图

在这里插入图片描述

Python的书写方式比较自由，没有什么特别需要注明的。主意好不同语言的书写格式区别，不要混用就行。

二、函数专题（参数接口+内置+嵌套+递归+匿名）

知识点梳理见整理的框图
在这里插入图片描述

特别专题：参数引用

在 Python 中，对象可以分为可变对象和不可变对象。例如，列表、字典和集合是可变对象，而数字、字符串和元组是不可变对象。
在 Python 中，所有的数据都是对象，无论是数字、字符串还是自定义类型，而变量则是指向对象的引用。
关于参数传递的内容，具体才可以学习这篇文章：Python函数参数传递机制详解
在这里插入图片描述

对比上面两个执行结果，可以得出如下结论：
-1）对于不可变的对象，在函数体内对值进行修改实际上是对变量引用了一个新的对象，所以函数体内变量的地址改变了，但是该操作不会改变函数体外对象的值，也就不会改变它的地址。
-2）对于可变的对象，在函数体内部对其进行改造会引用对象的值，但是对象的地址不会发生变化。
总的来说，Python 的函数参数传递机制遵循“传对象引用”的方式

特别专题：Lambda的应用

主打一个简洁明了，即插即用
举个例子：
在这里插入图片描述

特别专题：深拷贝与浅拷贝（面试高频）

表面问题，可能会问Python中的值传递和引用传递（详细分析）

三、容器专题（集合+元组+字典+列表+字符串+序列操作）

知识点梳理见整理的框图
在这里插入图片描述

数据类型的比较和操作总结，写得还行，主要是有个表格

直观感受——代码举例：

sort()与sorted()

在这里插入图片描述

使用zip建一个微小型数据库的实例：

def printBookInfo():
    '''
    zip 函数的使用
    :return:
    '''
    books=[] #存储所有的图书信息
    id=input('请输入编号: 每个项以空格分隔')  #str
    bookName = input('请输入书名: 每个项以空格分隔') #str
    bookPos = input('请输入位置: 每个项以空格分隔')
    idList=id.split(' ')
    nameList = id.split(' ')
    posList = id.split(' ')

    bookInfo=zip(idList,nameList,posList) #打包处理
    for bookItem in bookInfo:
        '''
        遍历图书信息进行存储
        '''
        dictInfo={'编号':bookItem[0],'书名':bookItem[1],'位置':bookItem[2]}
        books.append(dictInfo) #将字典对象添加到list容器中
        pass
    for item in books:
        print(item)

printBookInfo()

执行结果：
在这里插入图片描述

enumerate举例：

在这里插入图片描述

Python移除元素方法的合集

四、类和对象专题(定义+实例化调用+关键字+魔法方法)

知识点梳理见整理的框图（整体太大了看不清，截图凑合看看吧）

在这里插入图片描述

基础概念

1.面向过程和面向对象(Object Oriented Programming-OOP)的区别？
1）面向过程是以过程为中心，强调流程化，线性化，步骤化的思考方式。
2）面向对象更注重整体性和差异性，它会将多个事物看成是统一体，通过构造类的概念将它们封装实现统一性，然后用派生和继承的方式实现个体差异性，实现对象的行为的多态性。这样的方式可以提高编程效率，提高代码的可复用性、可移植性和可扩展性。总体上来说就是实现了面向对象的四大特征：抽象、封装、继承和多态。

2.类是模板，类有自己的名称，它包含了属性和行为；对象是根据模板创建的实例，通过实例执行类中的函数。
类和对象基础概念

3.析构函数专题讲解
需要注意的是手动del删除对象和使用析构函数删除对象还是有区别的，析构函数更彻底。我们称析构函数的这种处理方式为垃圾回收机制（又叫做GC）。所以当问到python中的垃圾回收问题时，不要懵了。
构造与析构过程中的垃圾回收
希望以上内容能回答下列问题：
在这里插入图片描述

定义类的举例：

class Animal(object):    # 创建一个初始化方法
    def __init__(self):
        self.name = '旺财'
        self.colour = '黄色'
dog = Animal()  # 实例化对象
print(dog.name)  # 访问属性
print(dog.colour) # 访问colour属性

魔法方法的使用（init+del+str+new+call）

new和init的区别

class Person:
    def __init__(self,pro,name,food):
        '''

        :param pro: 专业
        :param name: 姓名
        :param food: 食物
        '''
        self.pro=pro  #实例属性的定义
        self.name=name
        self.food=food
        print('----init-----函数执行')
        pass
    '''
   定义类
    '''
    def eat(self,name,food):
        '''
        实例方法
        :return:
        '''
        # print('self=%s',id(self))
        print('%s 喜欢吃 %s 修的专业是:%s'%(self.name,self.food,self.pro))
        pass
    def __str__(self):
        '''
        打印对象 自定义对象 是内容格式的
        :return:
        '''
        return '%s 喜欢吃 %s 修的专业是:%s'%(self.name,self.food,self.pro)
        pass
    def __new__(cls, *args, **kwargs):
        '''
        创建对象实例的方法  每调用一次 就会生成一个新的对象 cls 就是class的缩写

        场景：可以控制创建对象的一些属性限定 经常用来做单例模式的时候来使用
        :param args:
        :param kwargs:
        '''
        print('----new-----函数的执行')
        return object.__new__(cls) #在这里是真正创建对象实例的
        #如果没有这句话，实例化的对象是无法打印出有意义的结果的
        pass
    pass
    #观察输出打印结果可以发现，__new__会先执行，这样对象才真正实例化了，然后才会执行__init__

# xw是一个新的实例化对象
xw=Person('心理学','小王','榴莲')
# print('xw=%s',id(xw))
# xw.eat('小王','榴莲')
print(xw)  #直接输出对象

执行结果：
在这里插入图片描述

关于call的举例
python 中的 repr() 方法
 推荐一个讲解python八股文的网站，但是一些知识点要会员，可以只跟着他的目录分析重难点自己梳理框架，搜集学习整理

单继承举例

Python之Object关键字及其内置函数
 内置函数，也是写得还行的

class Animal:#这里其实为class Animal(Object):是父类的关键字，可写可不写，不写的时候会默认存在
    def  eat(self):
        print('吃饭了')
        pass
    def drink(self):
        print('喝水了')
        pass

class Dog(Animal): #继承了Animal 父类 此时dog就是子类
    def wwj(self):
        print('小狗汪汪叫')
    pass
class Cat(Animal):
    def mmj(self):
        print('小猫喵喵叫')
    pass

d1=Dog()
d1.eat() #具备了吃的行为  是继承了父类的行为
d1.wwj()
print('**************cat 的行为**********************')
c1=Cat()
c1.eat()
c1.mmj()

执行结果：
在这里插入图片描述

继承与重写

关键字cls和self的使用和区别
 同上嗷
在这里插入图片描述

class Dog:
    def __init__(self,name,color):
        self.name=name
        self.color=color

    def bark(self):
        print('汪汪叫....')
        pass
    pass
class kejiquan(Dog):
    def __init__(self,name,color):#属于重写父类的方法
        # 针对这种需求  我们就需要去调用父类的函数了
        Dog.__init__(self,name,color) #手动调用  调用父类的方法了 执行完毕就可以具备name,color这两个实例属性了\
        super().__init__(name,color) 
        super(kejiquan, self).__init__(name,color)
        #以上为三种继承和重写方法
        #super是自动找到父类 进而调用方法, 假设继承了多个父类，那么会按照顺序逐个去找 然后调用
        # 拓展其他的属性
        self.height=90
        self.weight=20
        pass
    def __str__(self):
        return '{}的颜色会{} 它的身高是{}cm 体重是:{}'.format(self.name,self.color,self.height,self.weight
                                                  )
    def bark(self): #属于重写类的方法
        super().bark() #调用父类的方法
        print('叫的跟神一样')
        print(self.name)
    pass

kj=kejiquan('柯基犬','红色')
kj.bark()
print(kj

执行结果
在这里插入图片描述

多态

Python中的多态详解
代码举例

class Animal:
    '''
    父类【基类】
    '''
    def say_who(self):
        print('我是一个动物....')
        pass
    pass
class Duck(Animal):
    '''
      鸭子类 【子类】 派生类
    '''
    def say_who(self):
        '''
        在这里重写父类的方法
        :return:
        '''
        print('我是一只漂亮的鸭子')
        pass
    pass
class Dog(Animal):
    '''
     小狗类 【子类】 派生类
    '''
    def say_who(self):
        print('我是一只哈巴狗')
        pass
    pass
def commonInvoke(obj):
    '''
    统一调用的方法
    :param obj: 对象的实例
    :return:
    '''
    obj.say_who()

# duck1=Duck()
# duck1.say_who()
# dog1=Dog()
# dog1.say_who()
# cat1=Cat()
# cat1.say_who()

listObj=[Duck(), Dog()]
for item in listObj:
    '''
     循环去调用函数
    '''
    commonInvoke(item)

执行结果:
在这里插入图片描述

截图来自求知讲堂网课-B站

类属性和实例属性

代码举例：
在这里插入图片描述

截图来自求知讲堂网课-B站

类方法和静态方法

类方法、实例方法和静态方法辨析
理解就好，看多了会昏头┗|｀O′|┛ 嗷~~

代码举例

class  People:
    country='china'
    #类方法 用 classmethod 来进行修饰
    @classmethod
    def get_country(cls):
        return cls.country #访问类属性
        pass
    @classmethod
    def change_country(cls,data):
        cls.country=data #修改类属性的值  在类方法中
        pass
    @staticmethod
    def getData():
        return People.country  #通过类对象去引用
        pass
    @staticmethod
    def add(x,y):
        return x+y
        pass


print(People.add(10,56)) #带有参数的静态方法

# print(People.getData())

# print(People.get_country()) #通过类对象去引用
p=People()
print(p.getData()) #注意 一般情况下 我们没有必要通过实例对象去访问静态方法
# print('实例对象访问 %s'%p.get_country())
# print('-----------------修改之后---------------------------')
# People.change_country('英国')
# print(People.get_country()) #通过类对象去引用

在这里插入图片描述
截图来自求知讲堂网课-B站

私有化方法和属性

在这里插入图片描述
用子类继承该父类，也仍然无法使用私有属性，即私有属性无法继承。变为私有化方法的方式与私有化属性的变化方式相同，此处不再做赘述。（截图来自求知讲堂网课-B站）

五、其他

在这里插入图片描述

装饰器（decorator）

这个东西的产生其实可能是从工业场景协同使用的角度出发，产生的一种做法。个人单线作战时候可能没什么感觉，但是团队修改的时候需要具备统一的语言规范，不能个人风格太重。
装饰器的一点解释

property属性
详解

class Person(object):
    def __init__(self):
        self.__age = 18 # 定义一个私有化属性，属性名字前加连个 __ 下滑线

    @property # 使用装饰器对age进行装饰，提供一个getter方法
    def age(self): # 访问私有实例属性 
        return self.__age

    @age.setter # 使用装饰器进行装饰，提供一个setter方法
    def age(self, age): # 修改私有实例属性
        if age < 0:
            print('年龄不能小于0')
        else:
            self.__age = age

xiaoming = Person()
xiaoming.age = 15
print(xiaoming.age)

在Python中，property 是一种特殊的装饰器（decorator），用于定义类的属性访问方式。

通过使用 property 装饰器，可以将类的方法转换为属性，从而使属性的访问和赋值操作更加灵活。
使用 property 装饰器可以定义三个方法，它们分别是 getter、setter 和 deleter。这些方法对应于属性的获取、设置和删除操作。

class MyClass:
    def __init__(self):
        self._value = None

    @property
    def value(self):
        # Getter方法，用于获取属性值
        return self._value

    @value.setter
    def value(self, new_value):
        # Setter方法，用于设置属性值
        self._value = new_value

    @value.deleter
    def value(self):
        # Deleter方法，用于删除属性
        del self._value

在上述示例中，value 是一个属性，通过 @property 装饰器将 value 方法转化为属性。value 方法即为 getter 方法，用于获取属性值。@value.setter 装饰器定义了 value 的 setter 方法，用于设置属性值。@value.deleter 装饰器定义了 value 的 deleter 方法，用于删除属性。

通过使用 property 装饰器，我们可以像访问普通属性一样访问和赋值 value 属性：

obj = MyClass()
obj.value = 10  # 设置属性值
print(obj.value)  # 获取属性值，输出: 10
del obj.value  # 删除属性

new对象的使用

python的__new__和__init__方法以及单例模式为什么要关联在一起问？
python的__new__和__init__方法以及单例模式的使用讲得很清楚的一篇博文，布局也很工整
关键点：
1）python的__new__执行在__init__方法之前，为什么？
2）两者的区别是什么？
3）python中如果没有__new__来创建返回对象，类本身会默认存在吗？

在Python中，每个类都有一个__new__方法，它是类的一个特殊方法，用于创建并返回一个新的对象。如果没有显式地定义__new__方法，Python会使用默认的__new__实现，它会调用类的__init__方法来初始化新创建的对象。
然而，即使没有显式地定义__new__方法，类本身仍然存在。类是Python语言的一种抽象元数据，定义了对象的属性和方法。类本身并不依赖于__new__方法来存在，它是一个独立的实体。
总结起来，即使没有显式地定义__new__方法，类本身仍然存在，并且可以使用默认的__new__实现来创建并返回对象。

单例模式

# 单例模式  是一种常用的软件设计模式 目的：确保某一个类只有一个实例存在
# 如果希望在真个系统中 某个类只能出现一个实例的时候，那么这个单例对象就满足要求

# 创建一个单例对象 基于__new__去实现的【推荐的一种】

class DataBaseClass(object):
    def __new__(cls, *args, **kwargs):
        # cls._instance=cls.__new__(cls)  不能使用自身的new方法
            # 容易造成一个深度递归，应该调用父类的new方法
        if not hasattr(cls,'_instance'):  #如果不存在就开始创建
            cls._instance=super().__new__(cls,*args, **kwargs)
        return cls._instance
    pass

class DBoptSingle(DataBaseClass):
    pass

db1=DBoptSingle()
print(id(db1))
db2=DBoptSingle()
print(id(db2))
db3=DBoptSingle()
print(id(db3))

在这里插入图片描述

异常检测

常用异常检测关键字类型
在这里插入图片描述
但是我感觉这部分课程教给人的意思是你已经知道会产生什么错误或者添加可能的错误类型，进行验证检测。不知道实际的工作中有什么用处，pycharm自带的报错不香嘛。

try:
    print('--------test----------')
except Exception as e: # Exception 可以捕获任何类型的异常
    print(e)
else:
    print('haha --- 没有捕获到异常') # 没有捕获到异常，将执行else里面代码，否则不执行

finally:
    print('不管有没有捕获到异常，finally都是执行的')


try: 
    print('--------test----------') # try里面有异常
    1/0
except Exception as e: # Exception 可以捕获任何类型的异常
    print(e)
else:
    print('haha --- 没有捕获到异常') # 捕获到异常，执行else 的代码

finally:
    print('不管有没有捕获到异常，finally都是执行的')