python基础的查漏补缺（重难点）笔记

最新推荐文章于 2024-09-28 12:21:43 发布

程序员托马斯

最新推荐文章于 2024-09-28 12:21:43 发布

阅读量2.1k

点赞数 7

分类专栏： python学习笔记文章标签： python

本文链接：https://blog.csdn.net/zhouxuan612/article/details/119268501

版权

本文详细探讨了Python的基础知识，包括if name == 'main'的作用、动态语言与静态语言的区别、format函数的使用、列表生成式、字典操作、参数处理、高阶函数、装饰器、迭代器和生成器的原理与应用。还涵盖了面向对象部分，如类与方法的区别、对象属性的添加和删除、元类、描述器等。进一步讲解了Python的内存管理、面向对象特性、错误和异常处理、线程进程协程的总结以及GIL锁的概念。文章适合Python初学者巩固基础知识和深入理解Python机制。

摘要由CSDN通过智能技术生成

辞职在家，根据自己的学习和理解，回顾整理了一些python基础知识，我想对于任何学python编程的人和以后的自己，读来都是大有裨益。希望自己不忘初心，脚踏实地。

python基础

编译型语言与解释型语言的区别

Python中if name == ‘main’：的作用和原理

与Java、C、C++等几种语言不同的是，Python是一种解释型脚本语言，在执行之前不需要将所有代码先编译成中间代码，Python程序运行时是从模块顶行开始，逐行进行翻译执行，所以，最顶层（没有被缩进）的代码都会被执行，所以Python中并不需要一个统一的main()作为程序的入口则if name = 'main’就是函数入口。
python模块被引入时会自动执行原模块的代码。
作用：防止模块被引入时执行不该执行的代码。
if __name=='main’的文章

动态语言和静态语言的区别

动态语言在运行期进行类型检查，声明变量时可以不指定数据类型
静态语言在编译期进行类型检查，声明变量时需提前指定数据类型
各类型语言的区别

format函数的用法字符串拼接

可通过列表下标，字典key值，key值，类属性，魔法参数来填充字符串，填充数据不限定为字符串。
format学习笔记

列表生成式

for 语句前面的内容就是传统语句中append函数内的内容

生成一个列表，列表元素分别为 [1x1,2x2,3x3……n*n]，假设n = 10,且不存在偶数项。

list1 = [i*i for i in range(1,11) if i %2!=0]

原始方法：
list1 =[]
for i in range(1,11):
	if i %2 == 0
	list1.append(i*i)

列表的删除

#删除某个下标的列表值
del(list[0])
#删除最右侧的值且返回删除的值
a=list.pop()
#删处值为n下标的值并返回删除的值
a=list.pop(n)

字典的增删改查

增

d={
   }
d["key"]=180

删

d = {
   "name":"zhangsan","age":12}
# 删除指定键值对
del d["age"]
# 删除指定键值对 并把删除的值 赋给变量
age=d.pop("age")
print(age)
# 结果：12
print(d)
# 结果 d ={"name":"zhansan"}

popitem()方法的使用
删除最右边的键值对，并以元组的形式返回该键值对
字典如为空则报错

d = {
   "name": "zhangsan", "number": 12, "age": 12, "bbb": "bbb"}
c = d.popitem()
print(c)
print(d)

在这里插入图片描述

改

因为key为不可改变类型
则只能修改key对应的value

单一修改

d={
   "name":"zhansgan","age":12}
d["name"]="lisi"
print(d)
d={
   "name":"lisi","age":12}

批量修改
oldDict.update(newDict)
根据新的字典批量更新旧字典中的键值对
如果旧字典中没有对应的key，则新增键值对

d={
   "name":"zhansgan","age":12}
d.update({
   "age":666,"address":"上海"})
print(d)
# {"name":"zhansgan","age":666,"address","上海"}

查

d={
   "name":"zhansgan","age":12}
print(d["name"]

在这里插入图片描述

d={
   "name":"zhansgan","age":12}
v= d.get("age")
print(v)
# 结果
12

在这里插入图片描述
如果没有对应键值则原字典增加键值对

查所有键值键值对

d = {
   "name": "zhangsan", "number": 12, "age": 12, "bbb": "bbb"}

print(d.keys())
print(type(d.keys()))
print(d.values())
print(d.items())

结果：
在这里插入图片描述
python3.6版本
修改字典键值对后相应的取值发生改变

d = {
   "name": "zhangsan", "number": 12, "age": 12, "bbb": "bbb"}

print(d.keys())
print(type(d.keys()))
print(d.values())
print(d.items())
d["name"] = "lisi"
print(d.keys())
print(type(d.keys()))
print(d.values())
print(d.items())

结果：
在这里插入图片描述
可以使用list 把键值转为列表类型

遍历查询

d = {
   "name": "zhangsan", "number": 12, "age": 14, "bbb": "bbb"}

for key in d:
    print(key)

for value in d.values():
    print(value)

for k, v in d.items():
    print(k,v)

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

判定

判断字典中的key是否存在x

d = {
   "name": "zhangsan", "number": 12, "age": 14, "bbb": "bbb"}
print("name" in d)

在这里插入图片描述
元组字符串列表都是有序的，因为可以通过索引值获取里面的元素
例如

a = ("zhangsan", 1, 4, 5)
print(a[2])

结果 4
字典，集合是无序的
且集合是不可随机获取的因为没有键值对 集合不可重复

参数的装包与拆包

：
在这里插入图片描述

装包

操作：

def test_put(*args):
    print(args)
    print(type(args))

test_put(1,23,45,6)

结果
在这里插入图片描述


def sum(a, b, c, d):
    print(a + b + c + d)


def test_put(*args):
    print(args)
    print(type(args))

    # 拆包
    print(*args)
    print(sum(*args))
    # 等同于
    print(sum(args[0], args[1], args[2], args[3]))


test_put(1, 23, 45, 6)

结果
在这里插入图片描述

字典拆包

def test(**kwargs):
    print(kwargs)
    print(type(kwargs))
    mysum(**kwargs)
    mysum(a=1,b=2)

def mysum(a,b):
    print(a)
    print(b)

test(a=1,b=2,)

# def sum(a, b, c, d):
#     print(a + b + c + d)
#
#
# def test_put(*args):
#     print(args)
#     print(type(args))
#
#     # 拆包
#     print(*args)
#     print(sum(*args))
#     # 等同于
#     print(sum(args[0], args[1], args[2], args[3]))
#
#
# test_put(1, 23, 45, 6)

结果：
相当于拆包成a=1,b=2
在这里插入图片描述

偏函数

概念了解
自己理解偏爱某个给定值的参数的函数
在这里插入图片描述

高阶函数

函数中参数是别的函数
在这里插入图片描述
函数也可以赋值给一个变量
此时这个变量就拥有的函数的功能

此处sorted就是高阶函数

返回函数

函数内部返回另一个函数
在这里插入图片描述

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

**

匿名函数

无需定义函数名
返回值是表达式的结果
作用是简单逻辑处理，简洁语法
在这里插入图片描述
例子：

函数的闭包

在这里插入图片描述

闭包注意事项
在这里插入图片描述

def test():
    num = 10
    print("testnum", id(num))

    def test2():
        num = 12
        print("test2num", id(num))
        print(num)

    print(num)
    return test2


result = test()

result()

结果：
子函数是定义了一个新变量
在这里插入图片描述
如果内部函数想修改外部函数的值需要加nonlocal声明

装饰器

本质闭包
给函数增加功能函数名字内部代码不能改变
下面两个写法完全相同
本来写法

def checklogin(function):
    def inner():
        print("登陆身份验证")
        function()

    return inner


def picture():
    print("查看图片")

# 在这一步已经执行了
a = checklogin(picture)
a()

注意装饰器立即执行 语法糖@checklogin既然等于a = checklogin（picture）则也是安装上语法糖装饰器立即执行

语法糖写法

def checklogin(function):
    def inner():
        print("登陆身份验证")
        function()

    return inner


@checklogin
def picture():
    print("查看图片")


picture()

结果相同
在这里插入图片描述
装饰器的叠加

装饰器装饰带参数的函数
装饰器内部函数形参数量要和要装饰函数一致
不一致可以使用*args **kwargs

def checklogin(function):
    def inner(*args, **kwargs):
        print("登陆身份验证")
        # args的元素自动生成元组，kwargs的自动生成字典格式
        print(args, kwargs)
        function(*args, **kwargs)

    return inner


@checklogin
def dic(num1, num2, num3):
    print(num1, num2, num3)


dic(1, 2, num3="zhangsan")

在这里插入图片描述
通过不同的参数得到不同的装饰器
装饰器套一个得到装饰器的函数(作用就是给装饰器传参) 再返回装饰器

# 建立一个获取装饰器的函数
# 先得到一个装饰器,在拿装饰器装饰函数
def getzsq(x):
    def zsq(function):
        def inner(a, b, c):
            print(x * 30)
            function(a, b, c)
        return inner

    return zsq


@getzsq("&")
def test(a, b, c):
    print(a + b + c)
    return a + b + c


test(1, 23, 4)

装饰器装饰带有返回值的函数
保持装饰器内部函数inner格式和要装饰的函数格式一致

def star(function):
    def inner(*args):
        print("-" * 30)
        fun = function(*args)
        return fun

    return inner


@star
def test(a, b, c):
    return a + b + c


res=test(1,2,3)
print(res)